summaryrefslogtreecommitdiffstats
path: root/src/amd/addrlib
diff options
context:
space:
mode:
Diffstat (limited to 'src/amd/addrlib')
-rw-r--r--src/amd/addrlib/addrinterface.cpp66
-rw-r--r--src/amd/addrlib/core/addrcommon.h197
-rw-r--r--src/amd/addrlib/core/addrelemlib.cpp167
-rw-r--r--src/amd/addrlib/core/addrelemlib.h67
-rw-r--r--src/amd/addrlib/core/addrlib.cpp71
-rw-r--r--src/amd/addrlib/core/addrlib.h69
-rw-r--r--src/amd/addrlib/core/addrlib1.cpp284
-rw-r--r--src/amd/addrlib/core/addrlib1.h29
-rw-r--r--src/amd/addrlib/core/addrobject.cpp78
-rw-r--r--src/amd/addrlib/core/addrobject.h38
-rw-r--r--src/amd/addrlib/r800/ciaddrlib.cpp205
-rw-r--r--src/amd/addrlib/r800/ciaddrlib.h28
-rw-r--r--src/amd/addrlib/r800/egbaddrlib.cpp261
-rw-r--r--src/amd/addrlib/r800/egbaddrlib.h16
-rw-r--r--src/amd/addrlib/r800/siaddrlib.cpp245
-rw-r--r--src/amd/addrlib/r800/siaddrlib.h40
16 files changed, 969 insertions, 892 deletions
diff --git a/src/amd/addrlib/addrinterface.cpp b/src/amd/addrlib/addrinterface.cpp
index c3eb598e34a..efb6ff50841 100644
--- a/src/amd/addrlib/addrinterface.cpp
+++ b/src/amd/addrlib/addrinterface.cpp
@@ -35,6 +35,8 @@
#include "addrcommon.h"
+using namespace Addr;
+
///////////////////////////////////////////////////////////////////////////////////////////////////
// Create/Destroy/Config functions
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -56,7 +58,7 @@ ADDR_E_RETURNCODE ADDR_API AddrCreate(
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
- returnCode = AddrLib::Create(pAddrCreateIn, pAddrCreateOut);
+ returnCode = Lib::Create(pAddrCreateIn, pAddrCreateOut);
return returnCode;
}
@@ -81,7 +83,7 @@ ADDR_E_RETURNCODE ADDR_API AddrDestroy(
if (hLib)
{
- AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+ Lib* pLib = Lib::GetLib(hLib);
pLib->Destroy();
}
else
@@ -114,7 +116,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] surface information
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) ///< [out] surface parameters and alignments
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -148,7 +150,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] surface info and coordinates
ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] surface address
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -180,7 +182,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] surface info and address
ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) ///< [out] coordinates
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -218,7 +220,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
const ADDR_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] Htile information
ADDR_COMPUTE_HTILE_INFO_OUTPUT* pOut) ///< [out] Htile pitch, height and size in bytes
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -250,7 +252,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] Htile info and coordinates
ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Htile address
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -283,7 +285,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] Htile info and address
ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) ///< [out] Htile coordinates
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -322,7 +324,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
const ADDR_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] Cmask pitch and height
ADDR_COMPUTE_CMASK_INFO_OUTPUT* pOut) ///< [out] Cmask pitch, height and size in bytes
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -354,7 +356,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Cmask info and coordinates
ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Cmask address
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -387,7 +389,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Cmask info and address
ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Cmask coordinates
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -425,7 +427,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] Fmask information
ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut) ///< [out] Fmask pitch and height
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -457,7 +459,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Fmask info and coordinates
ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Fmask address
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -489,7 +491,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Fmask info and address
ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Fmask coordinates
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -527,7 +529,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
{
ADDR_E_RETURNCODE returnCode;
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
if (pLib != NULL)
{
@@ -560,7 +562,7 @@ UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib)
{
UINT_32 version = 0;
- AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+ Addr::Lib* pLib = Lib::GetLib(hLib);
ADDR_ASSERT(pLib != NULL);
@@ -584,7 +586,7 @@ BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib)
{
BOOL_32 useTileIndex = FALSE;
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_ASSERT(pLib != NULL);
@@ -608,7 +610,7 @@ BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib)
{
BOOL_32 useCombinedSwizzle = FALSE;
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_ASSERT(pLib != NULL);
@@ -637,7 +639,7 @@ ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
if (pLib != NULL)
{
@@ -668,7 +670,7 @@ ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
if (pLib != NULL)
{
@@ -699,7 +701,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
if (pLib != NULL)
{
@@ -730,7 +732,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
if (pLib != NULL)
{
@@ -763,7 +765,7 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
- AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+ Lib* pLib = Lib::GetLib(hLib);
if (pLib != NULL)
{
@@ -796,7 +798,7 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
- AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+ Lib* pLib = Lib::GetLib(hLib);
if (pLib != NULL)
{
@@ -826,7 +828,7 @@ BOOL_32 ADDR_API ElemGetExportNorm(
ADDR_HANDLE hLib, ///< addrlib handle
const ELEM_GETEXPORTNORM_INPUT* pIn) ///< [in] input structure
{
- AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+ Addr::Lib* pLib = Lib::GetLib(hLib);
BOOL_32 enabled = FALSE;
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -861,7 +863,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] tile info with real value
ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut) ///< [out] tile info with HW register value
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -893,7 +895,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
const ADDR_CONVERT_TILEINDEX_INPUT* pIn, ///< [in] input - tile index
ADDR_CONVERT_TILEINDEX_OUTPUT* pOut) ///< [out] tile mode/type/info
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -925,7 +927,7 @@ ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
const ADDR_GET_MACROMODEINDEX_INPUT* pIn, ///< [in] input
ADDR_GET_MACROMODEINDEX_OUTPUT* pOut) ///< [out] macro mode index
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode;
@@ -957,7 +959,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
const ADDR_CONVERT_TILEINDEX1_INPUT* pIn, ///< [in] input - tile index
ADDR_CONVERT_TILEINDEX_OUTPUT* pOut) ///< [out] tile mode/type/info
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -992,7 +994,7 @@ ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
const ADDR_GET_TILEINDEX_INPUT* pIn,
ADDR_GET_TILEINDEX_OUTPUT* pOut)
{
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -1024,7 +1026,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
- AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+ V1::Lib* pLib = V1::Lib::GetLib(hLib);
if (pLib != NULL)
{
@@ -1053,7 +1055,7 @@ ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
ADDR_HANDLE hLib, ///< address lib handle
ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut) ///< [out] output structure
{
- AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+ Addr::Lib* pLib = Lib::GetLib(hLib);
ADDR_E_RETURNCODE returnCode = ADDR_OK;
diff --git a/src/amd/addrlib/core/addrcommon.h b/src/amd/addrlib/core/addrcommon.h
index 5c17f80caf7..9b0cc6dafa9 100644
--- a/src/amd/addrlib/core/addrcommon.h
+++ b/src/amd/addrlib/core/addrcommon.h
@@ -47,99 +47,6 @@
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////
-// Common constants
-///////////////////////////////////////////////////////////////////////////////////////////////////
-static const UINT_32 MicroTileWidth = 8; ///< Micro tile width, for 1D and 2D tiling
-static const UINT_32 MicroTileHeight = 8; ///< Micro tile height, for 1D and 2D tiling
-static const UINT_32 ThickTileThickness = 4; ///< Micro tile thickness, for THICK modes
-static const UINT_32 XThickTileThickness = 8; ///< Extra thick tiling thickness
-static const UINT_32 PowerSaveTileBytes = 64; ///< Nuber of bytes per tile for power save 64
-static const UINT_32 CmaskCacheBits = 1024; ///< Number of bits for CMASK cache
-static const UINT_32 CmaskElemBits = 4; ///< Number of bits for CMASK element
-static const UINT_32 HtileCacheBits = 16384; ///< Number of bits for HTILE cache 512*32
-
-static const UINT_32 MicroTilePixels = MicroTileWidth * MicroTileHeight;
-
-static const INT_32 TileIndexInvalid = TILEINDEX_INVALID;
-static const INT_32 TileIndexLinearGeneral = TILEINDEX_LINEAR_GENERAL;
-static const INT_32 TileIndexNoMacroIndex = -3;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Common macros
-///////////////////////////////////////////////////////////////////////////////////////////////////
-#define BITS_PER_BYTE 8
-#define BITS_TO_BYTES(x) ( ((x) + (BITS_PER_BYTE-1)) / BITS_PER_BYTE )
-#define BYTES_TO_BITS(x) ( (x) * BITS_PER_BYTE )
-
-/// Helper macros to select a single bit from an int (undefined later in section)
-#define _BIT(v,b) (((v) >> (b) ) & 1)
-
-/**
-****************************************************************************************************
-* @brief Enums to identify AddrLib type
-****************************************************************************************************
-*/
-enum AddrLibClass
-{
- BASE_ADDRLIB = 0x0,
- R600_ADDRLIB = 0x6,
- R800_ADDRLIB = 0x8,
- SI_ADDRLIB = 0xa,
- CI_ADDRLIB = 0xb,
-};
-
-/**
-****************************************************************************************************
-* AddrChipFamily
-*
-* @brief
-* Neutral enums that specifies chip family.
-*
-****************************************************************************************************
-*/
-enum AddrChipFamily
-{
- ADDR_CHIP_FAMILY_IVLD, ///< Invalid family
- ADDR_CHIP_FAMILY_R6XX,
- ADDR_CHIP_FAMILY_R7XX,
- ADDR_CHIP_FAMILY_R8XX,
- ADDR_CHIP_FAMILY_NI,
- ADDR_CHIP_FAMILY_SI,
- ADDR_CHIP_FAMILY_CI,
- ADDR_CHIP_FAMILY_VI,
-};
-
-/**
-****************************************************************************************************
-* AddrConfigFlags
-*
-* @brief
-* This structure is used to set configuration flags.
-****************************************************************************************************
-*/
-union AddrConfigFlags
-{
- struct
- {
- /// These flags are set up internally thru AddrLib::Create() based on ADDR_CREATE_FLAGS
- UINT_32 optimalBankSwap : 1; ///< New bank tiling for RV770 only
- UINT_32 noCubeMipSlicesPad : 1; ///< Disables faces padding for cubemap mipmaps
- UINT_32 fillSizeFields : 1; ///< If clients fill size fields in all input and
- /// output structure
- UINT_32 ignoreTileInfo : 1; ///< Don't use tile info structure
- UINT_32 useTileIndex : 1; ///< Make tileIndex field in input valid
- UINT_32 useCombinedSwizzle : 1; ///< Use combined swizzle
- UINT_32 checkLast2DLevel : 1; ///< Check the last 2D mip sub level
- UINT_32 useHtileSliceAlign : 1; ///< Do htile single slice alignment
- UINT_32 allowLargeThickTile : 1; ///< Allow 64*thickness*bytesPerPixel > rowSize
- UINT_32 disableLinearOpt : 1; ///< Disallow tile modes to be optimized to linear
- UINT_32 reserved : 22; ///< Reserved bits for future use
- };
-
- UINT_32 value;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
// Platform specific debug break defines
///////////////////////////////////////////////////////////////////////////////////////////////////
#if DEBUG
@@ -186,7 +93,7 @@ union AddrConfigFlags
///////////////////////////////////////////////////////////////////////////////////////////////////
#if DEBUG
-#define ADDR_PRNT(a) AddrObject::DebugPrint a
+#define ADDR_PRNT(a) Object::DebugPrint a
/// @brief Macro for reporting informational messages
/// @ingroup util
@@ -256,6 +163,106 @@ union AddrConfigFlags
#endif // DEBUG
///////////////////////////////////////////////////////////////////////////////////////////////////
+namespace Addr
+{
+
+namespace V1
+{
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Common constants
+///////////////////////////////////////////////////////////////////////////////////////////////////
+static const UINT_32 MicroTileWidth = 8; ///< Micro tile width, for 1D and 2D tiling
+static const UINT_32 MicroTileHeight = 8; ///< Micro tile height, for 1D and 2D tiling
+static const UINT_32 ThickTileThickness = 4; ///< Micro tile thickness, for THICK modes
+static const UINT_32 XThickTileThickness = 8; ///< Extra thick tiling thickness
+static const UINT_32 PowerSaveTileBytes = 64; ///< Nuber of bytes per tile for power save 64
+static const UINT_32 CmaskCacheBits = 1024; ///< Number of bits for CMASK cache
+static const UINT_32 CmaskElemBits = 4; ///< Number of bits for CMASK element
+static const UINT_32 HtileCacheBits = 16384; ///< Number of bits for HTILE cache 512*32
+
+static const UINT_32 MicroTilePixels = MicroTileWidth * MicroTileHeight;
+
+static const INT_32 TileIndexInvalid = TILEINDEX_INVALID;
+static const INT_32 TileIndexLinearGeneral = TILEINDEX_LINEAR_GENERAL;
+static const INT_32 TileIndexNoMacroIndex = -3;
+
+} // V1
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Common macros
+///////////////////////////////////////////////////////////////////////////////////////////////////
+#define BITS_PER_BYTE 8
+#define BITS_TO_BYTES(x) ( ((x) + (BITS_PER_BYTE-1)) / BITS_PER_BYTE )
+#define BYTES_TO_BITS(x) ( (x) * BITS_PER_BYTE )
+
+/// Helper macros to select a single bit from an int (undefined later in section)
+#define _BIT(v,b) (((v) >> (b) ) & 1)
+
+/**
+****************************************************************************************************
+* @brief Enums to identify AddrLib type
+****************************************************************************************************
+*/
+enum LibClass
+{
+ BASE_ADDRLIB = 0x0,
+ R600_ADDRLIB = 0x6,
+ R800_ADDRLIB = 0x8,
+ SI_ADDRLIB = 0xa,
+ CI_ADDRLIB = 0xb,
+};
+
+/**
+****************************************************************************************************
+* ChipFamily
+*
+* @brief
+* Neutral enums that specifies chip family.
+*
+****************************************************************************************************
+*/
+enum ChipFamily
+{
+ ADDR_CHIP_FAMILY_IVLD, ///< Invalid family
+ ADDR_CHIP_FAMILY_R6XX,
+ ADDR_CHIP_FAMILY_R7XX,
+ ADDR_CHIP_FAMILY_R8XX,
+ ADDR_CHIP_FAMILY_NI,
+ ADDR_CHIP_FAMILY_SI,
+ ADDR_CHIP_FAMILY_CI,
+ ADDR_CHIP_FAMILY_VI,
+};
+
+/**
+****************************************************************************************************
+* ConfigFlags
+*
+* @brief
+* This structure is used to set configuration flags.
+****************************************************************************************************
+*/
+union ConfigFlags
+{
+ struct
+ {
+ /// These flags are set up internally thru AddrLib::Create() based on ADDR_CREATE_FLAGS
+ UINT_32 optimalBankSwap : 1; ///< New bank tiling for RV770 only
+ UINT_32 noCubeMipSlicesPad : 1; ///< Disables faces padding for cubemap mipmaps
+ UINT_32 fillSizeFields : 1; ///< If clients fill size fields in all input and
+ /// output structure
+ UINT_32 ignoreTileInfo : 1; ///< Don't use tile info structure
+ UINT_32 useTileIndex : 1; ///< Make tileIndex field in input valid
+ UINT_32 useCombinedSwizzle : 1; ///< Use combined swizzle
+ UINT_32 checkLast2DLevel : 1; ///< Check the last 2D mip sub level
+ UINT_32 useHtileSliceAlign : 1; ///< Do htile single slice alignment
+ UINT_32 allowLargeThickTile : 1; ///< Allow 64*thickness*bytesPerPixel > rowSize
+ UINT_32 disableLinearOpt : 1; ///< Disallow tile modes to be optimized to linear
+ UINT_32 reserved : 22; ///< Reserved bits for future use
+ };
+
+ UINT_32 value;
+};
+
///////////////////////////////////////////////////////////////////////////////////////////////////
// Misc helper functions
////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -596,5 +603,7 @@ static inline ADDR_CHANNEL_SETTING InitChannel(
return t;
}
+} // Addr
+
#endif // __ADDR_COMMON_H__
diff --git a/src/amd/addrlib/core/addrelemlib.cpp b/src/amd/addrlib/core/addrelemlib.cpp
index 2ec518f6687..b894f49cca6 100644
--- a/src/amd/addrlib/core/addrelemlib.cpp
+++ b/src/amd/addrlib/core/addrelemlib.cpp
@@ -34,10 +34,12 @@
#include "addrelemlib.h"
#include "addrlib.h"
+namespace Addr
+{
/**
****************************************************************************************************
-* AddrElemLib::AddrElemLib
+* ElemLib::ElemLib
*
* @brief
* constructor
@@ -46,12 +48,13 @@
* N/A
****************************************************************************************************
*/
-AddrElemLib::AddrElemLib(
- AddrLib* const pAddrLib) : ///< [in] Parent addrlib instance pointer
- AddrObject(pAddrLib->GetClient()),
+ElemLib::ElemLib(
+ Lib* pAddrLib) ///< [in] Parent addrlib instance pointer
+ :
+ Object(pAddrLib->GetClient()),
m_pAddrLib(pAddrLib)
{
- switch (m_pAddrLib->GetAddrChipFamily())
+ switch (m_pAddrLib->GetChipFamily())
{
case ADDR_CHIP_FAMILY_R6XX:
m_depthPlanarType = ADDR_DEPTH_PLANAR_R600;
@@ -76,7 +79,7 @@ AddrElemLib::AddrElemLib(
/**
****************************************************************************************************
-* AddrElemLib::~AddrElemLib
+* ElemLib::~ElemLib
*
* @brief
* destructor
@@ -85,13 +88,13 @@ AddrElemLib::AddrElemLib(
* N/A
****************************************************************************************************
*/
-AddrElemLib::~AddrElemLib()
+ElemLib::~ElemLib()
{
}
/**
****************************************************************************************************
-* AddrElemLib::Create
+* ElemLib::Create
*
* @brief
* Creates and initializes AddrLib object.
@@ -100,21 +103,21 @@ AddrElemLib::~AddrElemLib()
* Returns point to ADDR_CREATEINFO if successful.
****************************************************************************************************
*/
-AddrElemLib* AddrElemLib::Create(
- const AddrLib* const pAddrLib) ///< [in] Pointer of parent AddrLib instance
+ElemLib* ElemLib::Create(
+ const Lib* pAddrLib) ///< [in] Pointer of parent AddrLib instance
{
- AddrElemLib* pElemLib = NULL;
+ ElemLib* pElemLib = NULL;
if (pAddrLib)
{
- pElemLib = new(pAddrLib->GetClient()) AddrElemLib(const_cast<AddrLib* const>(pAddrLib));
+ pElemLib = new(pAddrLib->GetClient()) ElemLib(const_cast<Lib* const>(pAddrLib));
}
return pElemLib;
}
/**************************************************************************************************
-* AddrElemLib::Flt32sToInt32s
+* ElemLib::Flt32sToInt32s
*
* @brief
* Convert a ADDR_FLT_32 value to Int32 value
@@ -123,10 +126,10 @@ AddrElemLib* AddrElemLib::Create(
* N/A
****************************************************************************************************
*/
-VOID AddrElemLib::Flt32sToInt32s(
+VOID ElemLib::Flt32sToInt32s(
ADDR_FLT_32 value, ///< [in] ADDR_FLT_32 value
UINT_32 bits, ///< [in] nubmer of bits in value
- AddrNumberType numberType, ///< [in] the type of number
+ NumberType numberType, ///< [in] the type of number
UINT_32* pResult) ///< [out] Int32 value
{
UINT_8 round = 128; //ADDR_ROUND_BY_HALF
@@ -304,7 +307,7 @@ VOID AddrElemLib::Flt32sToInt32s(
/**
****************************************************************************************************
-* AddrElemLib::Int32sToPixel
+* ElemLib::Int32sToPixel
*
* @brief
* Pack 32-bit integer values into an uncompressed pixel,
@@ -320,12 +323,12 @@ VOID AddrElemLib::Flt32sToInt32s(
* if called on compressed pixel.
****************************************************************************************************
*/
-VOID AddrElemLib::Int32sToPixel(
+VOID ElemLib::Int32sToPixel(
UINT_32 numComps, ///< [in] number of components
UINT_32* pComps, ///< [in] compnents
UINT_32* pCompBits, ///< [in] total bits in each component
UINT_32* pCompStart, ///< [in] the first bit position of each component
- ADDR_COMPONENT_FLAGS properties, ///< [in] properties about byteAligned, exportNorm
+ ComponentFlags properties, ///< [in] properties about byteAligned, exportNorm
UINT_32 resultBits, ///< [in] result bits: total bpp after decompression
UINT_8* pPixel) ///< [out] a depth/stencil pixel value
{
@@ -386,7 +389,7 @@ VOID AddrElemLib::Int32sToPixel(
* N/A
****************************************************************************************************
*/
-VOID AddrElemLib::Flt32ToDepthPixel(
+VOID ElemLib::Flt32ToDepthPixel(
AddrDepthFormat format, ///< [in] Depth format
const ADDR_FLT_32 comps[2], ///< [in] two components of depth
UINT_8* pPixel ///< [out] depth pixel value
@@ -394,10 +397,10 @@ VOID AddrElemLib::Flt32ToDepthPixel(
{
UINT_32 i;
UINT_32 values[2];
- ADDR_COMPONENT_FLAGS properties; // byteAligned, exportNorm
- UINT_32 resultBits = 0; // result bits: total bits per pixel after decompression
+ ComponentFlags properties; // byteAligned, exportNorm
+ UINT_32 resultBits = 0; // result bits: total bits per pixel after decompression
- ADDR_PIXEL_FORMATINFO fmt;
+ PixelFormatInfo fmt;
// get type for each component
PixGetDepthCompInfo(format, &fmt);
@@ -455,7 +458,7 @@ VOID AddrElemLib::Flt32ToDepthPixel(
* N/A
****************************************************************************************************
*/
-VOID AddrElemLib::Flt32ToColorPixel(
+VOID ElemLib::Flt32ToColorPixel(
AddrColorFormat format, ///< [in] Color format
AddrSurfaceNumber surfNum, ///< [in] Surface number
AddrSurfaceSwap surfSwap, ///< [in] Surface swap
@@ -463,14 +466,14 @@ VOID AddrElemLib::Flt32ToColorPixel(
UINT_8* pPixel ///< [out] a red/green/blue/alpha pixel value
) const
{
- ADDR_PIXEL_FORMATINFO pixelInfo;
+ PixelFormatInfo pixelInfo;
UINT_32 i;
UINT_32 values[4];
- ADDR_COMPONENT_FLAGS properties; // byteAligned, exportNorm
- UINT_32 resultBits = 0; // result bits: total bits per pixel after decompression
+ ComponentFlags properties; // byteAligned, exportNorm
+ UINT_32 resultBits = 0; // result bits: total bits per pixel after decompression
- memset(&pixelInfo, 0, sizeof(ADDR_PIXEL_FORMATINFO));
+ memset(&pixelInfo, 0, sizeof(PixelFormatInfo));
PixGetColorCompInfo(format, surfNum, surfSwap, &pixelInfo);
@@ -532,7 +535,7 @@ VOID AddrElemLib::Flt32ToColorPixel(
/**
****************************************************************************************************
-* AddrElemLib::GetCompType
+* ElemLib::GetCompType
*
* @brief
* Fill per component info
@@ -542,10 +545,10 @@ VOID AddrElemLib::Flt32ToColorPixel(
*
****************************************************************************************************
*/
-VOID AddrElemLib::GetCompType(
- AddrColorFormat format, ///< [in] surface format
- AddrSurfaceNumber numType, ///< [in] number type
- ADDR_PIXEL_FORMATINFO* pInfo) ///< [in][out] per component info out
+VOID ElemLib::GetCompType(
+ AddrColorFormat format, ///< [in] surface format
+ AddrSurfaceNumber numType, ///< [in] number type
+ PixelFormatInfo* pInfo) ///< [in][out] per component info out
{
BOOL_32 handled = FALSE;
@@ -705,7 +708,7 @@ VOID AddrElemLib::GetCompType(
/**
****************************************************************************************************
-* AddrElemLib::GetCompSwap
+* ElemLib::GetCompSwap
*
* @brief
* Get components swapped for color surface
@@ -715,9 +718,9 @@ VOID AddrElemLib::GetCompType(
*
****************************************************************************************************
*/
-VOID AddrElemLib::GetCompSwap(
- AddrSurfaceSwap swap, ///< [in] swap mode
- ADDR_PIXEL_FORMATINFO* pInfo) ///< [in/out] output per component info
+VOID ElemLib::GetCompSwap(
+ AddrSurfaceSwap swap, ///< [in] swap mode
+ PixelFormatInfo* pInfo) ///< [in/out] output per component info
{
switch (pInfo->comps)
{
@@ -795,7 +798,7 @@ VOID AddrElemLib::GetCompSwap(
/**
****************************************************************************************************
-* AddrElemLib::GetCompSwap
+* ElemLib::GetCompSwap
*
* @brief
* Get components swapped for color surface
@@ -805,10 +808,10 @@ VOID AddrElemLib::GetCompSwap(
*
****************************************************************************************************
*/
-VOID AddrElemLib::SwapComps(
- UINT_32 c0, ///< [in] component index 0
- UINT_32 c1, ///< [in] component index 1
- ADDR_PIXEL_FORMATINFO* pInfo) ///< [in/out] output per component info
+VOID ElemLib::SwapComps(
+ UINT_32 c0, ///< [in] component index 0
+ UINT_32 c1, ///< [in] component index 1
+ PixelFormatInfo* pInfo) ///< [in/out] output per component info
{
UINT_32 start;
UINT_32 bits;
@@ -824,7 +827,7 @@ VOID AddrElemLib::SwapComps(
/**
****************************************************************************************************
-* AddrElemLib::PixGetColorCompInfo
+* ElemLib::PixGetColorCompInfo
*
* @brief
* Get per component info for color surface
@@ -834,11 +837,11 @@ VOID AddrElemLib::SwapComps(
*
****************************************************************************************************
*/
-VOID AddrElemLib::PixGetColorCompInfo(
- AddrColorFormat format, ///< [in] surface format, read from register
- AddrSurfaceNumber number, ///< [in] pixel number type
- AddrSurfaceSwap swap, ///< [in] component swap mode
- ADDR_PIXEL_FORMATINFO* pInfo ///< [out] output per component info
+VOID ElemLib::PixGetColorCompInfo(
+ AddrColorFormat format, ///< [in] surface format, read from register
+ AddrSurfaceNumber number, ///< [in] pixel number type
+ AddrSurfaceSwap swap, ///< [in] component swap mode
+ PixelFormatInfo* pInfo ///< [out] output per component info
) const
{
// 1. Get componet bits
@@ -961,7 +964,7 @@ VOID AddrElemLib::PixGetColorCompInfo(
/**
****************************************************************************************************
-* AddrElemLib::PixGetDepthCompInfo
+* ElemLib::PixGetDepthCompInfo
*
* @brief
* Get per component info for depth surface
@@ -971,9 +974,9 @@ VOID AddrElemLib::PixGetColorCompInfo(
*
****************************************************************************************************
*/
-VOID AddrElemLib::PixGetDepthCompInfo(
- AddrDepthFormat format, ///< [in] surface format, read from register
- ADDR_PIXEL_FORMATINFO* pInfo ///< [out] output per component bits and type
+VOID ElemLib::PixGetDepthCompInfo(
+ AddrDepthFormat format, ///< [in] surface format, read from register
+ PixelFormatInfo* pInfo ///< [out] output per component bits and type
) const
{
if (m_depthPlanarType == ADDR_DEPTH_PLANAR_R800)
@@ -1059,7 +1062,7 @@ VOID AddrElemLib::PixGetDepthCompInfo(
/**
****************************************************************************************************
-* AddrElemLib::PixGetExportNorm
+* ElemLib::PixGetExportNorm
*
* @brief
* Check if fp16 export norm can be enabled.
@@ -1069,7 +1072,7 @@ VOID AddrElemLib::PixGetDepthCompInfo(
*
****************************************************************************************************
*/
-BOOL_32 AddrElemLib::PixGetExportNorm(
+BOOL_32 ElemLib::PixGetExportNorm(
AddrColorFormat colorFmt, ///< [in] surface format, read from register
AddrSurfaceNumber numberFmt, ///< [in] pixel number type
AddrSurfaceSwap swap ///< [in] components swap type
@@ -1077,7 +1080,7 @@ BOOL_32 AddrElemLib::PixGetExportNorm(
{
BOOL_32 enabled = TRUE;
- ADDR_PIXEL_FORMATINFO formatInfo;
+ PixelFormatInfo formatInfo;
PixGetColorCompInfo(colorFmt, numberFmt, swap, &formatInfo);
@@ -1111,7 +1114,7 @@ BOOL_32 AddrElemLib::PixGetExportNorm(
/**
****************************************************************************************************
-* AddrElemLib::AdjustSurfaceInfo
+* ElemLib::AdjustSurfaceInfo
*
* @brief
* Adjust bpp/base pitch/width/height according to elemMode and expandX/Y
@@ -1120,8 +1123,8 @@ BOOL_32 AddrElemLib::PixGetExportNorm(
* N/A
****************************************************************************************************
*/
-VOID AddrElemLib::AdjustSurfaceInfo(
- AddrElemMode elemMode, ///< [in] element mode
+VOID ElemLib::AdjustSurfaceInfo(
+ ElemMode elemMode, ///< [in] element mode
UINT_32 expandX, ///< [in] decompression expansion factor in X
UINT_32 expandY, ///< [in] decompression expansion factor in Y
UINT_32* pBpp, ///< [in/out] bpp
@@ -1199,7 +1202,7 @@ VOID AddrElemLib::AdjustSurfaceInfo(
else
{
// Evergreen family workaround
- if (bBCnFormat && (m_pAddrLib->GetAddrChipFamily() == ADDR_CHIP_FAMILY_R8XX))
+ if (bBCnFormat && (m_pAddrLib->GetChipFamily() == ADDR_CHIP_FAMILY_R8XX))
{
// For BCn we now pad it to POW2 at the beginning so it is safe to
// divide by 4 directly
@@ -1236,7 +1239,7 @@ VOID AddrElemLib::AdjustSurfaceInfo(
/**
****************************************************************************************************
-* AddrElemLib::RestoreSurfaceInfo
+* ElemLib::RestoreSurfaceInfo
*
* @brief
* Reverse operation of AdjustSurfaceInfo
@@ -1245,8 +1248,8 @@ VOID AddrElemLib::AdjustSurfaceInfo(
* N/A
****************************************************************************************************
*/
-VOID AddrElemLib::RestoreSurfaceInfo(
- AddrElemMode elemMode, ///< [in] element mode
+VOID ElemLib::RestoreSurfaceInfo(
+ ElemMode elemMode, ///< [in] element mode
UINT_32 expandX, ///< [in] decompression expansion factor in X
UINT_32 expandY, ///< [out] decompression expansion factor in Y
UINT_32* pBpp, ///< [in/out] bpp
@@ -1328,7 +1331,7 @@ VOID AddrElemLib::RestoreSurfaceInfo(
/**
****************************************************************************************************
-* AddrElemLib::GetBitsPerPixel
+* ElemLib::GetBitsPerPixel
*
* @brief
* Compute the total bits per element according to a format
@@ -1339,9 +1342,9 @@ VOID AddrElemLib::RestoreSurfaceInfo(
* Bits per pixel
****************************************************************************************************
*/
-UINT_32 AddrElemLib::GetBitsPerPixel(
+UINT_32 ElemLib::GetBitsPerPixel(
AddrFormat format, ///< [in] surface format code
- AddrElemMode* pElemMode, ///< [out] element mode
+ ElemMode* pElemMode, ///< [out] element mode
UINT_32* pExpandX, ///< [out] decompression expansion factor in X
UINT_32* pExpandY, ///< [out] decompression expansion factor in Y
UINT_32* pUnusedBits) ///< [out] bits unused
@@ -1350,7 +1353,7 @@ UINT_32 AddrElemLib::GetBitsPerPixel(
UINT_32 expandX = 1;
UINT_32 expandY = 1;
UINT_32 bitUnused = 0;
- AddrElemMode elemMode = ADDR_UNCOMPRESSED; // default value
+ ElemMode elemMode = ADDR_UNCOMPRESSED; // default value
switch (format)
{
@@ -1497,7 +1500,7 @@ UINT_32 AddrElemLib::GetBitsPerPixel(
/**
****************************************************************************************************
-* AddrElemLib::GetCompBits
+* ElemLib::GetCompBits
*
* @brief
* Set each component's bit size and bit start. And set element mode and number type
@@ -1506,13 +1509,13 @@ UINT_32 AddrElemLib::GetBitsPerPixel(
* N/A
****************************************************************************************************
*/
-VOID AddrElemLib::GetCompBits(
- UINT_32 c0, ///< [in] bits of component 0
- UINT_32 c1, ///< [in] bits of component 1
- UINT_32 c2, ///< [in] bits of component 2
- UINT_32 c3, ///< [in] bits of component 3
- ADDR_PIXEL_FORMATINFO* pInfo, ///< [out] per component info out
- AddrElemMode elemMode) ///< [in] element mode
+VOID ElemLib::GetCompBits(
+ UINT_32 c0, ///< [in] bits of component 0
+ UINT_32 c1, ///< [in] bits of component 1
+ UINT_32 c2, ///< [in] bits of component 2
+ UINT_32 c3, ///< [in] bits of component 3
+ PixelFormatInfo* pInfo, ///< [out] per component info out
+ ElemMode elemMode) ///< [in] element mode
{
pInfo->comps = 0;
@@ -1544,7 +1547,7 @@ VOID AddrElemLib::GetCompBits(
/**
****************************************************************************************************
-* AddrElemLib::GetCompBits
+* ElemLib::GetCompBits
*
* @brief
* Set the clear color (or clear depth/stencil) for a surface
@@ -1557,7 +1560,7 @@ VOID AddrElemLib::GetCompBits(
* N/A
****************************************************************************************************
*/
-VOID AddrElemLib::SetClearComps(
+VOID ElemLib::SetClearComps(
ADDR_FLT_32 comps[4], ///< [in/out] components
BOOL_32 clearColor, ///< [in] TRUE if clear color is set (CLEAR_COLOR)
BOOL_32 float32) ///< [in] TRUE if float32 component (BLEND_FLOAT32)
@@ -1600,7 +1603,7 @@ VOID AddrElemLib::SetClearComps(
/**
****************************************************************************************************
-* AddrElemLib::IsBlockCompressed
+* ElemLib::IsBlockCompressed
*
* @brief
* TRUE if this is block compressed format
@@ -1611,7 +1614,7 @@ VOID AddrElemLib::SetClearComps(
* BOOL_32
****************************************************************************************************
*/
-BOOL_32 AddrElemLib::IsBlockCompressed(
+BOOL_32 ElemLib::IsBlockCompressed(
AddrFormat format) ///< [in] Format
{
return format >= ADDR_FMT_BC1 && format <= ADDR_FMT_BC7;
@@ -1620,7 +1623,7 @@ BOOL_32 AddrElemLib::IsBlockCompressed(
/**
****************************************************************************************************
-* AddrElemLib::IsCompressed
+* ElemLib::IsCompressed
*
* @brief
* TRUE if this is block compressed format or 1 bit format
@@ -1631,7 +1634,7 @@ BOOL_32 AddrElemLib::IsBlockCompressed(
* BOOL_32
****************************************************************************************************
*/
-BOOL_32 AddrElemLib::IsCompressed(
+BOOL_32 ElemLib::IsCompressed(
AddrFormat format) ///< [in] Format
{
return IsBlockCompressed(format) || format == ADDR_FMT_BC1 || format == ADDR_FMT_BC7;
@@ -1639,7 +1642,7 @@ BOOL_32 AddrElemLib::IsCompressed(
/**
****************************************************************************************************
-* AddrElemLib::IsExpand3x
+* ElemLib::IsExpand3x
*
* @brief
* TRUE if this is 3x expand format
@@ -1650,7 +1653,7 @@ BOOL_32 AddrElemLib::IsCompressed(
* BOOL_32
****************************************************************************************************
*/
-BOOL_32 AddrElemLib::IsExpand3x(
+BOOL_32 ElemLib::IsExpand3x(
AddrFormat format) ///< [in] Format
{
BOOL_32 is3x = FALSE;
@@ -1671,4 +1674,4 @@ BOOL_32 AddrElemLib::IsExpand3x(
return is3x;
}
-
+}
diff --git a/src/amd/addrlib/core/addrelemlib.h b/src/amd/addrlib/core/addrelemlib.h
index b47a413a9b4..2875026e32e 100644
--- a/src/amd/addrlib/core/addrelemlib.h
+++ b/src/amd/addrlib/core/addrelemlib.h
@@ -38,10 +38,13 @@
#include "addrobject.h"
#include "addrcommon.h"
-class AddrLib;
+namespace Addr
+{
+
+class Lib;
// The masks for property bits within the Properties INT_32
-union ADDR_COMPONENT_FLAGS
+union ComponentFlags
{
struct
{
@@ -53,8 +56,8 @@ union ADDR_COMPONENT_FLAGS
UINT_32 value;
};
-// Copy from legacy lib's AddrNumberType
-enum AddrNumberType
+// Copy from legacy lib's NumberType
+enum NumberType
{
// The following number types have the range [-1..1]
ADDR_NO_NUMBER, // This component doesn't exist and has no default value
@@ -109,7 +112,7 @@ enum AddrNumberType
};
// Copy from legacy lib's AddrElement
-enum AddrElemMode
+enum ElemMode
{
// These formats allow both packing an unpacking
ADDR_ROUND_BY_HALF, // add 1/2 and truncate when packing this element
@@ -137,7 +140,7 @@ enum AddrElemMode
ADDR_END_ELEMENT // Used for range comparisons
};
-enum AddrDepthPlanarType
+enum DepthPlanarType
{
ADDR_DEPTH_PLANAR_NONE = 0, // No plane z/stencl
ADDR_DEPTH_PLANAR_R600 = 1, // R600 z and stencil planes are store within a tile
@@ -146,19 +149,19 @@ enum AddrDepthPlanarType
/**
****************************************************************************************************
-* ADDR_PIXEL_FORMATINFO
+* PixelFormatInfo
*
* @brief
* Per component info
*
****************************************************************************************************
*/
-struct ADDR_PIXEL_FORMATINFO
+struct PixelFormatInfo
{
UINT_32 compBit[4];
- AddrNumberType numType[4];
+ NumberType numType[4];
UINT_32 compStart[4];
- AddrElemMode elemMode;
+ ElemMode elemMode;
UINT_32 comps; ///< Number of components
};
@@ -167,18 +170,18 @@ struct ADDR_PIXEL_FORMATINFO
* @brief This class contains asic indepentent element related attributes and operations
****************************************************************************************************
*/
-class AddrElemLib : public AddrObject
+class ElemLib : public Object
{
protected:
- AddrElemLib(AddrLib* const pAddrLib);
+ ElemLib(Lib* pAddrLib);
public:
/// Makes this class virtual
- virtual ~AddrElemLib();
+ virtual ~ElemLib();
- static AddrElemLib *Create(
- const AddrLib* const pAddrLib);
+ static ElemLib* Create(
+ const Lib* pAddrLib);
/// The implementation is only for R6xx/R7xx, so make it virtual in case we need for R8xx
BOOL_32 PixGetExportNorm(
@@ -196,32 +199,32 @@ public:
const ADDR_FLT_32 comps[4], UINT_8 *pPixel) const;
static VOID Flt32sToInt32s(
- ADDR_FLT_32 value, UINT_32 bits, AddrNumberType numberType, UINT_32* pResult);
+ ADDR_FLT_32 value, UINT_32 bits, NumberType numberType, UINT_32* pResult);
static VOID Int32sToPixel(
UINT_32 numComps, UINT_32* pComps, UINT_32* pCompBits, UINT_32* pCompStart,
- ADDR_COMPONENT_FLAGS properties, UINT_32 resultBits, UINT_8* pPixel);
+ ComponentFlags properties, UINT_32 resultBits, UINT_8* pPixel);
VOID PixGetColorCompInfo(
AddrColorFormat format, AddrSurfaceNumber number, AddrSurfaceSwap swap,
- ADDR_PIXEL_FORMATINFO* pInfo) const;
+ PixelFormatInfo* pInfo) const;
VOID PixGetDepthCompInfo(
- AddrDepthFormat format, ADDR_PIXEL_FORMATINFO* pInfo) const;
+ AddrDepthFormat format, PixelFormatInfo* pInfo) const;
UINT_32 GetBitsPerPixel(
- AddrFormat format, AddrElemMode* pElemMode,
+ AddrFormat format, ElemMode* pElemMode,
UINT_32* pExpandX = NULL, UINT_32* pExpandY = NULL, UINT_32* pBitsUnused = NULL);
static VOID SetClearComps(
ADDR_FLT_32 comps[4], BOOL_32 clearColor, BOOL_32 float32);
VOID AdjustSurfaceInfo(
- AddrElemMode elemMode, UINT_32 expandX, UINT_32 expandY,
+ ElemMode elemMode, UINT_32 expandX, UINT_32 expandY,
UINT_32* pBpp, UINT_32* pBasePitch, UINT_32* pWidth, UINT_32* pHeight);
VOID RestoreSurfaceInfo(
- AddrElemMode elemMode, UINT_32 expandX, UINT_32 expandY,
+ ElemMode elemMode, UINT_32 expandX, UINT_32 expandY,
UINT_32* pBpp, UINT_32* pWidth, UINT_32* pHeight);
/// Checks if depth and stencil are planar inside a tile
@@ -231,7 +234,7 @@ public:
}
/// Sets m_configFlags, copied from AddrLib
- VOID SetConfigFlags(AddrConfigFlags flags)
+ VOID SetConfigFlags(ConfigFlags flags)
{
m_configFlags = flags;
}
@@ -244,27 +247,29 @@ protected:
static VOID GetCompBits(
UINT_32 c0, UINT_32 c1, UINT_32 c2, UINT_32 c3,
- ADDR_PIXEL_FORMATINFO* pInfo,
- AddrElemMode elemMode = ADDR_ROUND_BY_HALF);
+ PixelFormatInfo* pInfo,
+ ElemMode elemMode = ADDR_ROUND_BY_HALF);
static VOID GetCompType(
AddrColorFormat format, AddrSurfaceNumber numType,
- ADDR_PIXEL_FORMATINFO* pInfo);
+ PixelFormatInfo* pInfo);
static VOID GetCompSwap(
- AddrSurfaceSwap swap, ADDR_PIXEL_FORMATINFO* pInfo);
+ AddrSurfaceSwap swap, PixelFormatInfo* pInfo);
static VOID SwapComps(
- UINT_32 c0, UINT_32 c1, ADDR_PIXEL_FORMATINFO* pInfo);
+ UINT_32 c0, UINT_32 c1, PixelFormatInfo* pInfo);
private:
UINT_32 m_fp16ExportNorm; ///< If allow FP16 to be reported as EXPORT_NORM
- AddrDepthPlanarType m_depthPlanarType;
+ DepthPlanarType m_depthPlanarType;
- AddrConfigFlags m_configFlags; ///< Copy of AddrLib's configFlags
- AddrLib* const m_pAddrLib; ///< Pointer to parent addrlib instance
+ ConfigFlags m_configFlags; ///< Copy of AddrLib's configFlags
+ Addr::Lib* const m_pAddrLib; ///< Pointer to parent addrlib instance
};
+} //Addr
+
#endif
diff --git a/src/amd/addrlib/core/addrlib.cpp b/src/amd/addrlib/core/addrlib.cpp
index f98a459f372..8553ca6569f 100644
--- a/src/amd/addrlib/core/addrlib.cpp
+++ b/src/amd/addrlib/core/addrlib.cpp
@@ -81,6 +81,8 @@ UINT_32 __umoddi3(UINT_64 n, UINT_32 base)
#endif // __APPLE__
+namespace Addr
+{
///////////////////////////////////////////////////////////////////////////////////////////////////
// Constructor/Destructor
@@ -88,14 +90,14 @@ UINT_32 __umoddi3(UINT_64 n, UINT_32 base)
/**
****************************************************************************************************
-* AddrLib::AddrLib
+* Lib::Lib
*
* @brief
* Constructor for the AddrLib class
*
****************************************************************************************************
*/
-AddrLib::AddrLib() :
+Lib::Lib() :
m_class(BASE_ADDRLIB),
m_chipFamily(ADDR_CHIP_FAMILY_IVLD),
m_chipRevision(0),
@@ -113,15 +115,15 @@ AddrLib::AddrLib() :
/**
****************************************************************************************************
-* AddrLib::AddrLib
+* Lib::Lib
*
* @brief
* Constructor for the AddrLib class with hClient as parameter
*
****************************************************************************************************
*/
-AddrLib::AddrLib(const AddrClient* pClient) :
- AddrObject(pClient),
+Lib::Lib(const Client* pClient) :
+ Object(pClient),
m_class(BASE_ADDRLIB),
m_chipFamily(ADDR_CHIP_FAMILY_IVLD),
m_chipRevision(0),
@@ -139,14 +141,14 @@ AddrLib::AddrLib(const AddrClient* pClient) :
/**
****************************************************************************************************
-* AddrLib::~AddrLib
+* Lib::~AddrLib
*
* @brief
* Destructor for the AddrLib class
*
****************************************************************************************************
*/
-AddrLib::~AddrLib()
+Lib::~Lib()
{
if (m_pElemLib)
{
@@ -162,7 +164,7 @@ AddrLib::~AddrLib()
/**
****************************************************************************************************
-* AddrLib::Create
+* Lib::Create
*
* @brief
* Creates and initializes AddrLib object.
@@ -171,11 +173,11 @@ AddrLib::~AddrLib()
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib::Create(
+ADDR_E_RETURNCODE Lib::Create(
const ADDR_CREATE_INPUT* pCreateIn, ///< [in] pointer to ADDR_CREATE_INPUT
ADDR_CREATE_OUTPUT* pCreateOut) ///< [out] pointer to ADDR_CREATE_OUTPUT
{
- AddrLib* pLib = NULL;
+ Lib* pLib = NULL;
ADDR_E_RETURNCODE returnCode = ADDR_OK;
if (pCreateIn->createFlags.fillSizeFields == TRUE)
@@ -191,7 +193,7 @@ ADDR_E_RETURNCODE AddrLib::Create(
(pCreateIn->callbacks.allocSysMem != NULL) &&
(pCreateIn->callbacks.freeSysMem != NULL))
{
- AddrClient client = {
+ Client client = {
pCreateIn->hClient,
pCreateIn->callbacks
};
@@ -202,13 +204,13 @@ ADDR_E_RETURNCODE AddrLib::Create(
switch (pCreateIn->chipFamily)
{
case FAMILY_SI:
- pLib = AddrSIHwlInit(&client);
+ pLib = SiHwlInit(&client);
break;
case FAMILY_VI:
case FAMILY_CZ: // VI based fusion(carrizo)
case FAMILY_CI:
case FAMILY_KV: // CI based fusion
- pLib = AddrCIHwlInit(&client);
+ pLib = CiHwlInit(&client);
break;
default:
ADDR_ASSERT_ALWAYS();
@@ -235,7 +237,7 @@ ADDR_E_RETURNCODE AddrLib::Create(
pLib->m_configFlags.allowLargeThickTile = pCreateIn->createFlags.allowLargeThickTile;
pLib->m_configFlags.disableLinearOpt = FALSE;
- pLib->SetAddrChipFamily(pCreateIn->chipFamily, pCreateIn->chipRevision);
+ pLib->SetChipFamily(pCreateIn->chipFamily, pCreateIn->chipRevision);
pLib->SetMinPitchAlignPixels(pCreateIn->minPitchAlignPixels);
@@ -244,7 +246,7 @@ ADDR_E_RETURNCODE AddrLib::Create(
if (initValid)
{
- pLib->m_pElemLib = AddrElemLib::Create(pLib);
+ pLib->m_pElemLib = ElemLib::Create(pLib);
}
else
{
@@ -285,19 +287,19 @@ ADDR_E_RETURNCODE AddrLib::Create(
/**
****************************************************************************************************
-* AddrLib::SetAddrChipFamily
+* Lib::SetChipFamily
*
* @brief
-* Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
+* Convert familyID defined in atiid.h to ChipFamily and set m_chipFamily/m_chipRevision
* @return
* N/A
****************************************************************************************************
*/
-VOID AddrLib::SetAddrChipFamily(
+VOID Lib::SetChipFamily(
UINT_32 uChipFamily, ///< [in] chip family defined in atiih.h
UINT_32 uChipRevision) ///< [in] chip revision defined in "asic_family"_id.h
{
- AddrChipFamily family = HwlConvertChipFamily(uChipFamily, uChipRevision);
+ ChipFamily family = HwlConvertChipFamily(uChipFamily, uChipRevision);
ADDR_ASSERT(family != ADDR_CHIP_FAMILY_IVLD);
@@ -307,7 +309,7 @@ VOID AddrLib::SetAddrChipFamily(
/**
****************************************************************************************************
-* AddrLib::SetMinPitchAlignPixels
+* Lib::SetMinPitchAlignPixels
*
* @brief
* Set m_minPitchAlignPixels with input param
@@ -316,7 +318,7 @@ VOID AddrLib::SetAddrChipFamily(
* N/A
****************************************************************************************************
*/
-VOID AddrLib::SetMinPitchAlignPixels(
+VOID Lib::SetMinPitchAlignPixels(
UINT_32 minPitchAlignPixels) ///< [in] minmum pitch alignment in pixels
{
m_minPitchAlignPixels = (minPitchAlignPixels == 0) ? 1 : minPitchAlignPixels;
@@ -324,7 +326,7 @@ VOID AddrLib::SetMinPitchAlignPixels(
/**
****************************************************************************************************
-* AddrLib::GetAddrLib
+* Lib::GetLib
*
* @brief
* Get AddrLib pointer
@@ -333,15 +335,15 @@ VOID AddrLib::SetMinPitchAlignPixels(
* An AddrLib class pointer
****************************************************************************************************
*/
-AddrLib * AddrLib::GetAddrLib(
+Lib* Lib::GetLib(
ADDR_HANDLE hLib) ///< [in] handle of ADDR_HANDLE
{
- return static_cast<AddrLib *>(hLib);
+ return static_cast<Addr::Lib*>(hLib);
}
/**
****************************************************************************************************
-* AddrLib::GetMaxAlignments
+* Lib::GetMaxAlignments
*
* @brief
* Gets maximum alignments
@@ -350,7 +352,7 @@ AddrLib * AddrLib::GetAddrLib(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib::GetMaxAlignments(
+ADDR_E_RETURNCODE Lib::GetMaxAlignments(
ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut ///< [out] output structure
) const
{
@@ -374,7 +376,7 @@ ADDR_E_RETURNCODE AddrLib::GetMaxAlignments(
/**
****************************************************************************************************
-* AddrLib::Bits2Number
+* Lib::Bits2Number
*
* @brief
* Cat a array of binary bit to a number
@@ -383,7 +385,7 @@ ADDR_E_RETURNCODE AddrLib::GetMaxAlignments(
* The number combined with the array of bits
****************************************************************************************************
*/
-UINT_32 AddrLib::Bits2Number(
+UINT_32 Lib::Bits2Number(
UINT_32 bitNum, ///< [in] how many bits
...) ///< [in] varaible bits value starting from MSB
{
@@ -414,7 +416,7 @@ UINT_32 AddrLib::Bits2Number(
/**
****************************************************************************************************
-* AddrLib::Flt32ToColorPixel
+* Lib::Flt32ToColorPixel
*
* @brief
* Convert a FLT_32 value to a depth/stencil pixel value
@@ -422,7 +424,7 @@ UINT_32 AddrLib::Bits2Number(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib::Flt32ToDepthPixel(
+ADDR_E_RETURNCODE Lib::Flt32ToDepthPixel(
const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,
ELEM_FLT32TODEPTHPIXEL_OUTPUT* pOut) const
{
@@ -492,7 +494,7 @@ ADDR_E_RETURNCODE AddrLib::Flt32ToDepthPixel(
/**
****************************************************************************************************
-* AddrLib::Flt32ToColorPixel
+* Lib::Flt32ToColorPixel
*
* @brief
* Convert a FLT_32 value to a red/green/blue/alpha pixel value
@@ -500,7 +502,7 @@ ADDR_E_RETURNCODE AddrLib::Flt32ToDepthPixel(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib::Flt32ToColorPixel(
+ADDR_E_RETURNCODE Lib::Flt32ToColorPixel(
const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,
ELEM_FLT32TOCOLORPIXEL_OUTPUT* pOut) const
{
@@ -530,7 +532,7 @@ ADDR_E_RETURNCODE AddrLib::Flt32ToColorPixel(
/**
****************************************************************************************************
-* AddrLib::GetExportNorm
+* Lib::GetExportNorm
*
* @brief
* Check one format can be EXPORT_NUM
@@ -538,7 +540,7 @@ ADDR_E_RETURNCODE AddrLib::Flt32ToColorPixel(
* TRUE if EXPORT_NORM can be used
****************************************************************************************************
*/
-BOOL_32 AddrLib::GetExportNorm(
+BOOL_32 Lib::GetExportNorm(
const ELEM_GETEXPORTNORM_INPUT* pIn) const
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -561,3 +563,4 @@ BOOL_32 AddrLib::GetExportNorm(
return enabled;
}
+} // Addr
diff --git a/src/amd/addrlib/core/addrlib.h b/src/amd/addrlib/core/addrlib.h
index 581ef377f74..10d029f34fe 100644
--- a/src/amd/addrlib/core/addrlib.h
+++ b/src/amd/addrlib/core/addrlib.h
@@ -34,7 +34,6 @@
#ifndef __ADDR_LIB_H__
#define __ADDR_LIB_H__
-
#include "addrinterface.h"
#include "addrobject.h"
#include "addrelemlib.h"
@@ -60,12 +59,16 @@
#ifndef CIASICIDGFXENGINE_SEAISLAND
#define CIASICIDGFXENGINE_SEAISLAND 0x0000000B
#endif
+
+namespace Addr
+{
+
/**
****************************************************************************************************
* @brief Neutral enums that define pipeinterleave
****************************************************************************************************
*/
-enum AddrPipeInterleave
+enum PipeInterleave
{
ADDR_PIPEINTERLEAVE_256B = 256,
ADDR_PIPEINTERLEAVE_512B = 512,
@@ -76,7 +79,7 @@ enum AddrPipeInterleave
* @brief Neutral enums that define DRAM row size
****************************************************************************************************
*/
-enum AddrRowSize
+enum RowSize
{
ADDR_ROWSIZE_1KB = 1024,
ADDR_ROWSIZE_2KB = 2048,
@@ -89,7 +92,7 @@ enum AddrRowSize
* @brief Neutral enums that define bank interleave
****************************************************************************************************
*/
-enum AddrBankInterleave
+enum BankInterleave
{
ADDR_BANKINTERLEAVE_1 = 1,
ADDR_BANKINTERLEAVE_2 = 2,
@@ -99,23 +102,10 @@ enum AddrBankInterleave
/**
****************************************************************************************************
-* @brief Neutral enums that define MGPU chip tile size
-****************************************************************************************************
-*/
-enum AddrChipTileSize
-{
- ADDR_CHIPTILESIZE_16 = 16,
- ADDR_CHIPTILESIZE_32 = 32,
- ADDR_CHIPTILESIZE_64 = 64,
- ADDR_CHIPTILESIZE_128 = 128,
-};
-
-/**
-****************************************************************************************************
* @brief Neutral enums that define shader engine tile size
****************************************************************************************************
*/
-enum AddrEngTileSize
+enum ShaderEngineTileSize
{
ADDR_SE_TILESIZE_16 = 16,
ADDR_SE_TILESIZE_32 = 32,
@@ -126,7 +116,7 @@ enum AddrEngTileSize
* @brief Neutral enums that define bank swap size
****************************************************************************************************
*/
-enum AddrBankSwapSize
+enum BankSwapSize
{
ADDR_BANKSWAP_128B = 128,
ADDR_BANKSWAP_256B = 256,
@@ -134,16 +124,15 @@ enum AddrBankSwapSize
ADDR_BANKSWAP_1KB = 1024,
};
-
/**
****************************************************************************************************
* @brief This class contains asic independent address lib functionalities
****************************************************************************************************
*/
-class AddrLib : public AddrObject
+class Lib : public Object
{
public:
- virtual ~AddrLib();
+ virtual ~Lib();
static ADDR_E_RETURNCODE Create(
const ADDR_CREATE_INPUT* pCreateInfo, ADDR_CREATE_OUTPUT* pCreateOut);
@@ -154,7 +143,7 @@ public:
delete this;
}
- static AddrLib* GetAddrLib(ADDR_HANDLE hLib);
+ static Lib* GetLib(ADDR_HANDLE hLib);
/// Returns AddrLib version (from compiled binary instead include file)
UINT_32 GetVersion()
@@ -163,7 +152,7 @@ public:
}
/// Returns asic chip family name defined by AddrLib
- AddrChipFamily GetAddrChipFamily()
+ ChipFamily GetChipFamily()
{
return m_chipFamily;
}
@@ -181,8 +170,8 @@ public:
ADDR_E_RETURNCODE GetMaxAlignments(ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut) const;
protected:
- AddrLib(); // Constructor is protected
- AddrLib(const AddrClient* pClient);
+ Lib(); // Constructor is protected
+ Lib(const Client* pClient);
/// Pure virtual function to get max alignments
virtual ADDR_E_RETURNCODE HwlGetMaxAlignments(ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut) const = 0;
@@ -194,7 +183,7 @@ protected:
virtual BOOL_32 HwlInitGlobalParams(const ADDR_CREATE_INPUT* pCreateIn) = 0;
/// Pure Virtual function for Hwl converting chip family
- virtual AddrChipFamily HwlConvertChipFamily(UINT_32 uChipFamily, UINT_32 uChipRevision) = 0;
+ virtual ChipFamily HwlConvertChipFamily(UINT_32 uChipFamily, UINT_32 uChipRevision) = 0;
/// Get equation table pointer and number of equations
virtual UINT_32 HwlGetEquationTableInfo(const ADDR_EQUATION** ppEquationTable) const
@@ -207,15 +196,15 @@ protected:
//
// Misc helper
//
- static UINT_32 Bits2Number(UINT_32 bitNum,...);
+ static UINT_32 Bits2Number(UINT_32 bitNum, ...);
static UINT_32 GetNumFragments(UINT_32 numSamples, UINT_32 numFrags)
{
return (numFrags != 0) ? numFrags : Max(1u, numSamples);
}
- /// Returns pointer of AddrElemLib
- AddrElemLib* GetElemLib() const
+ /// Returns pointer of ElemLib
+ ElemLib* GetElemLib() const
{
return m_pElemLib;
}
@@ -228,19 +217,19 @@ protected:
private:
// Disallow the copy constructor
- AddrLib(const AddrLib& a);
+ Lib(const Lib& a);
// Disallow the assignment operator
- AddrLib& operator=(const AddrLib& a);
+ Lib& operator=(const Lib& a);
- VOID SetAddrChipFamily(UINT_32 uChipFamily, UINT_32 uChipRevision);
+ VOID SetChipFamily(UINT_32 uChipFamily, UINT_32 uChipRevision);
VOID SetMinPitchAlignPixels(UINT_32 minPitchAlignPixels);
protected:
- AddrLibClass m_class; ///< Store class type (HWL type)
+ LibClass m_class; ///< Store class type (HWL type)
- AddrChipFamily m_chipFamily; ///< Chip family translated from the one in atiid.h
+ ChipFamily m_chipFamily; ///< Chip family translated from the one in atiid.h
UINT_32 m_chipRevision; ///< Revision id from xxx_id.h
@@ -249,7 +238,7 @@ protected:
//
// Global parameters
//
- AddrConfigFlags m_configFlags; ///< Global configuration flags. Note this is setup by
+ ConfigFlags m_configFlags; ///< Global configuration flags. Note this is setup by
/// AddrLib instead of Client except forceLinearAligned
UINT_32 m_pipes; ///< Number of pipes
@@ -267,11 +256,13 @@ protected:
UINT_32 m_minPitchAlignPixels; ///< Minimum pitch alignment in pixels
UINT_32 m_maxSamples; ///< Max numSamples
private:
- AddrElemLib* m_pElemLib; ///< Element Lib pointer
+ ElemLib* m_pElemLib; ///< Element Lib pointer
};
-AddrLib* AddrSIHwlInit (const AddrClient* pClient);
-AddrLib* AddrCIHwlInit (const AddrClient* pClient);
+Lib* SiHwlInit (const Client* pClient);
+Lib* CiHwlInit (const Client* pClient);
+
+} // Addr
#endif
diff --git a/src/amd/addrlib/core/addrlib1.cpp b/src/amd/addrlib/core/addrlib1.cpp
index 4a2b4563eb0..e7ac3859a81 100644
--- a/src/amd/addrlib/core/addrlib1.cpp
+++ b/src/amd/addrlib/core/addrlib1.cpp
@@ -35,12 +35,16 @@
#include "addrlib1.h"
#include "addrcommon.h"
+namespace Addr
+{
+namespace V1
+{
///////////////////////////////////////////////////////////////////////////////////////////////////
// Static Const Member
///////////////////////////////////////////////////////////////////////////////////////////////////
-const AddrTileModeFlags AddrLib1::ModeFlags[ADDR_TM_COUNT] =
+const TileModeFlags Lib::ModeFlags[ADDR_TM_COUNT] =
{// T L 1 2 3 P Pr B
{1, 1, 0, 0, 0, 0, 0, 0}, // ADDR_TM_LINEAR_GENERAL
{1, 1, 0, 0, 0, 0, 0, 0}, // ADDR_TM_LINEAR_ALIGNED
@@ -76,69 +80,71 @@ const AddrTileModeFlags AddrLib1::ModeFlags[ADDR_TM_COUNT] =
/**
****************************************************************************************************
-* AddrLib1::AddrLib1
+* Lib::AddrLib1
*
* @brief
* Constructor for the AddrLib1 class
*
****************************************************************************************************
*/
-AddrLib1::AddrLib1() :
- AddrLib()
+Lib::Lib()
+ :
+ Addr::Lib()
{
}
/**
****************************************************************************************************
-* AddrLib1::AddrLib1
+* Lib::Lib
*
* @brief
-* Constructor for the AddrLib1 class with hClient as parameter
+* Constructor for the Addr::V1::Lib class with hClient as parameter
*
****************************************************************************************************
*/
-AddrLib1::AddrLib1(const AddrClient* pClient) :
- AddrLib(pClient)
+Lib::Lib(const Client* pClient)
+ :
+ Addr::Lib(pClient)
{
}
/**
****************************************************************************************************
-* AddrLib1::~AddrLib1
+* Lib::~AddrLib1
*
* @brief
* Destructor for the AddrLib1 class
*
****************************************************************************************************
*/
-AddrLib1::~AddrLib1()
+Lib::~Lib()
{
}
/**
****************************************************************************************************
-* AddrLib1::GetAddrLib1
+* Lib::GetLib
*
* @brief
* Get AddrLib1 pointer
*
* @return
-* An AddrLib1 class pointer
+* An Addr::V1::Lib class pointer
****************************************************************************************************
*/
-AddrLib1* AddrLib1::GetAddrLib1(
+Lib* Lib::GetLib(
ADDR_HANDLE hLib) ///< [in] handle of ADDR_HANDLE
{
- AddrLib* pAddrLib = AddrLib::GetAddrLib(hLib);
+ Addr::Lib* pAddrLib = Addr::Lib::GetLib(hLib);
if ((pAddrLib != NULL) &&
- ((pAddrLib->GetAddrChipFamily() == ADDR_CHIP_FAMILY_IVLD) ||
- (pAddrLib->GetAddrChipFamily() > ADDR_CHIP_FAMILY_VI)))
+ ((pAddrLib->GetChipFamily() == ADDR_CHIP_FAMILY_IVLD) ||
+ (pAddrLib->GetChipFamily() > ADDR_CHIP_FAMILY_VI)))
{
// only valid and pre-VI AISC can use AddrLib1 function.
ADDR_ASSERT_ALWAYS();
hLib = NULL;
}
- return static_cast<AddrLib1 *>(hLib);
+ return static_cast<Lib*>(hLib);
}
@@ -149,7 +155,7 @@ AddrLib1* AddrLib1::GetAddrLib1(
/**
****************************************************************************************************
-* AddrLib1::ComputeSurfaceInfo
+* Lib::ComputeSurfaceInfo
*
* @brief
* Interface function stub of AddrComputeSurfaceInfo.
@@ -158,7 +164,7 @@ AddrLib1* AddrLib1::GetAddrLib1(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
+ADDR_E_RETURNCODE Lib::ComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
) const
@@ -222,7 +228,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
UINT_32 expandX = 1;
UINT_32 expandY = 1;
- AddrElemMode elemMode;
+ ElemMode elemMode;
// Save outputs that may not go through HWL
pOut->pixelBits = localIn.bpp;
@@ -435,7 +441,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
/**
****************************************************************************************************
-* AddrLib1::ComputeSurfaceInfo
+* Lib::ComputeSurfaceInfo
*
* @brief
* Interface function stub of AddrComputeSurfaceInfo.
@@ -444,7 +450,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceAddrFromCoord(
+ADDR_E_RETURNCODE Lib::ComputeSurfaceAddrFromCoord(
const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
@@ -515,7 +521,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceAddrFromCoord(
/**
****************************************************************************************************
-* AddrLib1::ComputeSurfaceCoordFromAddr
+* Lib::ComputeSurfaceCoordFromAddr
*
* @brief
* Interface function stub of ComputeSurfaceCoordFromAddr.
@@ -524,7 +530,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceAddrFromCoord(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceCoordFromAddr(
+ADDR_E_RETURNCODE Lib::ComputeSurfaceCoordFromAddr(
const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
) const
@@ -590,7 +596,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceCoordFromAddr(
/**
****************************************************************************************************
-* AddrLib1::ComputeSliceTileSwizzle
+* Lib::ComputeSliceTileSwizzle
*
* @brief
* Interface function stub of ComputeSliceTileSwizzle.
@@ -599,7 +605,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceCoordFromAddr(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeSliceTileSwizzle(
+ADDR_E_RETURNCODE Lib::ComputeSliceTileSwizzle(
const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_SLICESWIZZLE_OUTPUT* pOut ///< [out] output structure
) const
@@ -643,7 +649,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSliceTileSwizzle(
/**
****************************************************************************************************
-* AddrLib1::ExtractBankPipeSwizzle
+* Lib::ExtractBankPipeSwizzle
*
* @brief
* Interface function stub of AddrExtractBankPipeSwizzle.
@@ -652,7 +658,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSliceTileSwizzle(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ExtractBankPipeSwizzle(
+ADDR_E_RETURNCODE Lib::ExtractBankPipeSwizzle(
const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn, ///< [in] input structure
ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT* pOut ///< [out] output structure
) const
@@ -695,7 +701,7 @@ ADDR_E_RETURNCODE AddrLib1::ExtractBankPipeSwizzle(
/**
****************************************************************************************************
-* AddrLib1::CombineBankPipeSwizzle
+* Lib::CombineBankPipeSwizzle
*
* @brief
* Interface function stub of AddrCombineBankPipeSwizzle.
@@ -704,7 +710,7 @@ ADDR_E_RETURNCODE AddrLib1::ExtractBankPipeSwizzle(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::CombineBankPipeSwizzle(
+ADDR_E_RETURNCODE Lib::CombineBankPipeSwizzle(
const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT* pIn, ///< [in] input structure
ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT* pOut ///< [out] output structure
) const
@@ -751,7 +757,7 @@ ADDR_E_RETURNCODE AddrLib1::CombineBankPipeSwizzle(
/**
****************************************************************************************************
-* AddrLib1::ComputeBaseSwizzle
+* Lib::ComputeBaseSwizzle
*
* @brief
* Interface function stub of AddrCompueBaseSwizzle.
@@ -759,7 +765,7 @@ ADDR_E_RETURNCODE AddrLib1::CombineBankPipeSwizzle(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeBaseSwizzle(
+ADDR_E_RETURNCODE Lib::ComputeBaseSwizzle(
const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn,
ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT* pOut) const
{
@@ -808,7 +814,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeBaseSwizzle(
/**
****************************************************************************************************
-* AddrLib1::ComputeFmaskInfo
+* Lib::ComputeFmaskInfo
*
* @brief
* Interface function stub of ComputeFmaskInfo.
@@ -817,7 +823,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeBaseSwizzle(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeFmaskInfo(
+ADDR_E_RETURNCODE Lib::ComputeFmaskInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut ///< [out] output structure
)
@@ -902,7 +908,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskInfo(
/**
****************************************************************************************************
-* AddrLib1::ComputeFmaskAddrFromCoord
+* Lib::ComputeFmaskAddrFromCoord
*
* @brief
* Interface function stub of ComputeFmaskAddrFromCoord.
@@ -911,7 +917,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskInfo(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeFmaskAddrFromCoord(
+ADDR_E_RETURNCODE Lib::ComputeFmaskAddrFromCoord(
const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
@@ -946,7 +952,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskAddrFromCoord(
/**
****************************************************************************************************
-* AddrLib1::ComputeFmaskCoordFromAddr
+* Lib::ComputeFmaskCoordFromAddr
*
* @brief
* Interface function stub of ComputeFmaskAddrFromCoord.
@@ -955,7 +961,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskAddrFromCoord(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeFmaskCoordFromAddr(
+ADDR_E_RETURNCODE Lib::ComputeFmaskCoordFromAddr(
const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
) const
@@ -990,7 +996,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskCoordFromAddr(
/**
****************************************************************************************************
-* AddrLib1::ConvertTileInfoToHW
+* Lib::ConvertTileInfoToHW
*
* @brief
* Convert tile info from real value to HW register value in HW layer
@@ -999,7 +1005,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskCoordFromAddr(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ConvertTileInfoToHW(
+ADDR_E_RETURNCODE Lib::ConvertTileInfoToHW(
const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut ///< [out] output structure
) const
@@ -1042,7 +1048,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileInfoToHW(
/**
****************************************************************************************************
-* AddrLib1::ConvertTileIndex
+* Lib::ConvertTileIndex
*
* @brief
* Convert tile index to tile mode/type/info
@@ -1051,7 +1057,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileInfoToHW(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex(
+ADDR_E_RETURNCODE Lib::ConvertTileIndex(
const ADDR_CONVERT_TILEINDEX_INPUT* pIn, ///< [in] input structure
ADDR_CONVERT_TILEINDEX_OUTPUT* pOut ///< [out] output structure
) const
@@ -1091,7 +1097,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex(
/**
****************************************************************************************************
-* AddrLib1::GetMacroModeIndex
+* Lib::GetMacroModeIndex
*
* @brief
* Get macro mode index based on input info
@@ -1100,7 +1106,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::GetMacroModeIndex(
+ADDR_E_RETURNCODE Lib::GetMacroModeIndex(
const ADDR_GET_MACROMODEINDEX_INPUT* pIn, ///< [in] input structure
ADDR_GET_MACROMODEINDEX_OUTPUT* pOut ///< [out] output structure
) const
@@ -1128,7 +1134,7 @@ ADDR_E_RETURNCODE AddrLib1::GetMacroModeIndex(
/**
****************************************************************************************************
-* AddrLib1::ConvertTileIndex1
+* Lib::ConvertTileIndex1
*
* @brief
* Convert tile index to tile mode/type/info
@@ -1137,7 +1143,7 @@ ADDR_E_RETURNCODE AddrLib1::GetMacroModeIndex(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex1(
+ADDR_E_RETURNCODE Lib::ConvertTileIndex1(
const ADDR_CONVERT_TILEINDEX1_INPUT* pIn, ///< [in] input structure
ADDR_CONVERT_TILEINDEX_OUTPUT* pOut ///< [out] output structure
) const
@@ -1178,7 +1184,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex1(
/**
****************************************************************************************************
-* AddrLib1::GetTileIndex
+* Lib::GetTileIndex
*
* @brief
* Get tile index from tile mode/type/info
@@ -1187,7 +1193,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex1(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::GetTileIndex(
+ADDR_E_RETURNCODE Lib::GetTileIndex(
const ADDR_GET_TILEINDEX_INPUT* pIn, ///< [in] input structure
ADDR_GET_TILEINDEX_OUTPUT* pOut ///< [out] output structure
) const
@@ -1213,7 +1219,7 @@ ADDR_E_RETURNCODE AddrLib1::GetTileIndex(
/**
****************************************************************************************************
-* AddrLib1::Thickness
+* Lib::Thickness
*
* @brief
* Get tile mode thickness
@@ -1222,7 +1228,7 @@ ADDR_E_RETURNCODE AddrLib1::GetTileIndex(
* Tile mode thickness
****************************************************************************************************
*/
-UINT_32 AddrLib1::Thickness(
+UINT_32 Lib::Thickness(
AddrTileMode tileMode) ///< [in] tile mode
{
return ModeFlags[tileMode].thickness;
@@ -1236,7 +1242,7 @@ UINT_32 AddrLib1::Thickness(
/**
****************************************************************************************************
-* AddrLib1::ComputeHtileInfo
+* Lib::ComputeHtileInfo
*
* @brief
* Interface function stub of AddrComputeHtilenfo
@@ -1245,7 +1251,7 @@ UINT_32 AddrLib1::Thickness(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeHtileInfo(
+ADDR_E_RETURNCODE Lib::ComputeHtileInfo(
const ADDR_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_HTILE_INFO_OUTPUT* pOut ///< [out] output structure
) const
@@ -1306,7 +1312,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileInfo(
/**
****************************************************************************************************
-* AddrLib1::ComputeCmaskInfo
+* Lib::ComputeCmaskInfo
*
* @brief
* Interface function stub of AddrComputeCmaskInfo
@@ -1315,7 +1321,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileInfo(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
+ADDR_E_RETURNCODE Lib::ComputeCmaskInfo(
const ADDR_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_CMASK_INFO_OUTPUT* pOut ///< [out] output structure
) const
@@ -1372,7 +1378,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
/**
****************************************************************************************************
-* AddrLib1::ComputeDccInfo
+* Lib::ComputeDccInfo
*
* @brief
* Interface function to compute DCC key info
@@ -1381,7 +1387,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
* return code of HwlComputeDccInfo
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeDccInfo(
+ADDR_E_RETURNCODE Lib::ComputeDccInfo(
const ADDR_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_DCCINFO_OUTPUT* pOut ///< [out] output structure
) const
@@ -1422,7 +1428,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeDccInfo(
/**
****************************************************************************************************
-* AddrLib1::ComputeHtileAddrFromCoord
+* Lib::ComputeHtileAddrFromCoord
*
* @brief
* Interface function stub of AddrComputeHtileAddrFromCoord
@@ -1431,7 +1437,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeDccInfo(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeHtileAddrFromCoord(
+ADDR_E_RETURNCODE Lib::ComputeHtileAddrFromCoord(
const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
@@ -1497,7 +1503,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileAddrFromCoord(
/**
****************************************************************************************************
-* AddrLib1::ComputeHtileCoordFromAddr
+* Lib::ComputeHtileCoordFromAddr
*
* @brief
* Interface function stub of AddrComputeHtileCoordFromAddr
@@ -1506,7 +1512,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileAddrFromCoord(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeHtileCoordFromAddr(
+ADDR_E_RETURNCODE Lib::ComputeHtileCoordFromAddr(
const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
) const
@@ -1565,7 +1571,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileCoordFromAddr(
/**
****************************************************************************************************
-* AddrLib1::ComputeCmaskAddrFromCoord
+* Lib::ComputeCmaskAddrFromCoord
*
* @brief
* Interface function stub of AddrComputeCmaskAddrFromCoord
@@ -1574,7 +1580,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileCoordFromAddr(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeCmaskAddrFromCoord(
+ADDR_E_RETURNCODE Lib::ComputeCmaskAddrFromCoord(
const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
@@ -1637,7 +1643,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskAddrFromCoord(
/**
****************************************************************************************************
-* AddrLib1::ComputeCmaskCoordFromAddr
+* Lib::ComputeCmaskCoordFromAddr
*
* @brief
* Interface function stub of AddrComputeCmaskCoordFromAddr
@@ -1646,7 +1652,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskAddrFromCoord(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeCmaskCoordFromAddr(
+ADDR_E_RETURNCODE Lib::ComputeCmaskCoordFromAddr(
const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
) const
@@ -1703,7 +1709,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskCoordFromAddr(
/**
****************************************************************************************************
-* AddrLib1::ComputeTileDataWidthAndHeight
+* Lib::ComputeTileDataWidthAndHeight
*
* @brief
* Compute the squared cache shape for per-tile data (CMASK and HTILE)
@@ -1715,7 +1721,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskCoordFromAddr(
* MacroWidth and macroHeight are measured in pixels
****************************************************************************************************
*/
-VOID AddrLib1::ComputeTileDataWidthAndHeight(
+VOID Lib::ComputeTileDataWidthAndHeight(
UINT_32 bpp, ///< [in] bits per pixel
UINT_32 cacheBits, ///< [in] bits of cache
ADDR_TILEINFO* pTileInfo, ///< [in] Tile info
@@ -1747,7 +1753,7 @@ VOID AddrLib1::ComputeTileDataWidthAndHeight(
/**
****************************************************************************************************
-* AddrLib1::HwlComputeTileDataWidthAndHeightLinear
+* Lib::HwlComputeTileDataWidthAndHeightLinear
*
* @brief
* Compute the squared cache shape for per-tile data (CMASK and HTILE) for linear layout
@@ -1759,7 +1765,7 @@ VOID AddrLib1::ComputeTileDataWidthAndHeight(
* MacroWidth and macroHeight are measured in pixels
****************************************************************************************************
*/
-VOID AddrLib1::HwlComputeTileDataWidthAndHeightLinear(
+VOID Lib::HwlComputeTileDataWidthAndHeightLinear(
UINT_32* pMacroWidth, ///< [out] macro tile width
UINT_32* pMacroHeight, ///< [out] macro tile height
UINT_32 bpp, ///< [in] bits per pixel
@@ -1773,7 +1779,7 @@ VOID AddrLib1::HwlComputeTileDataWidthAndHeightLinear(
/**
****************************************************************************************************
-* AddrLib1::ComputeHtileInfo
+* Lib::ComputeHtileInfo
*
* @brief
* Compute htile pitch,width, bytes per 2D slice
@@ -1784,7 +1790,7 @@ VOID AddrLib1::HwlComputeTileDataWidthAndHeightLinear(
* *Htile pitch, height, total size in bytes, macro-tile dimensions and slice size*
****************************************************************************************************
*/
-UINT_32 AddrLib1::ComputeHtileInfo(
+UINT_32 Lib::ComputeHtileInfo(
ADDR_HTILE_FLAGS flags, ///< [in] htile flags
UINT_32 pitchIn, ///< [in] pitch input
UINT_32 heightIn, ///< [in] height input
@@ -1861,7 +1867,7 @@ UINT_32 AddrLib1::ComputeHtileInfo(
/**
****************************************************************************************************
-* AddrLib1::ComputeCmaskBaseAlign
+* Lib::ComputeCmaskBaseAlign
*
* @brief
* Compute cmask base alignment
@@ -1870,7 +1876,7 @@ UINT_32 AddrLib1::ComputeHtileInfo(
* Cmask base alignment
****************************************************************************************************
*/
-UINT_32 AddrLib1::ComputeCmaskBaseAlign(
+UINT_32 Lib::ComputeCmaskBaseAlign(
ADDR_CMASK_FLAGS flags, ///< [in] Cmask flags
ADDR_TILEINFO* pTileInfo ///< [in] Tile info
) const
@@ -1891,7 +1897,7 @@ UINT_32 AddrLib1::ComputeCmaskBaseAlign(
/**
****************************************************************************************************
-* AddrLib1::ComputeCmaskBytes
+* Lib::ComputeCmaskBytes
*
* @brief
* Compute cmask size in bytes
@@ -1900,7 +1906,7 @@ UINT_32 AddrLib1::ComputeCmaskBaseAlign(
* Cmask size in bytes
****************************************************************************************************
*/
-UINT_64 AddrLib1::ComputeCmaskBytes(
+UINT_64 Lib::ComputeCmaskBytes(
UINT_32 pitch, ///< [in] pitch
UINT_32 height, ///< [in] height
UINT_32 numSlices ///< [in] number of slices
@@ -1912,7 +1918,7 @@ UINT_64 AddrLib1::ComputeCmaskBytes(
/**
****************************************************************************************************
-* AddrLib1::ComputeCmaskInfo
+* Lib::ComputeCmaskInfo
*
* @brief
* Compute cmask pitch,width, bytes per 2D slice
@@ -1922,7 +1928,7 @@ UINT_64 AddrLib1::ComputeCmaskBytes(
* macro-tile dimensions
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
+ADDR_E_RETURNCODE Lib::ComputeCmaskInfo(
ADDR_CMASK_FLAGS flags, ///< [in] cmask flags
UINT_32 pitchIn, ///< [in] pitch input
UINT_32 heightIn, ///< [in] height input
@@ -2027,7 +2033,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
/**
****************************************************************************************************
-* AddrLib1::ComputeXmaskCoordYFromPipe
+* Lib::ComputeXmaskCoordYFromPipe
*
* @brief
* Compute the Y coord from pipe number for cmask/htile
@@ -2037,7 +2043,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
*
****************************************************************************************************
*/
-UINT_32 AddrLib1::ComputeXmaskCoordYFromPipe(
+UINT_32 Lib::ComputeXmaskCoordYFromPipe(
UINT_32 pipe, ///< [in] pipe number
UINT_32 x ///< [in] x coordinate
) const
@@ -2119,7 +2125,7 @@ UINT_32 AddrLib1::ComputeXmaskCoordYFromPipe(
/**
****************************************************************************************************
-* AddrLib1::HwlComputeXmaskCoordFromAddr
+* Lib::HwlComputeXmaskCoordFromAddr
*
* @brief
* Compute the coord from an address of a cmask/htile
@@ -2131,7 +2137,7 @@ UINT_32 AddrLib1::ComputeXmaskCoordYFromPipe(
* This method is reused by htile, so rename to Xmask
****************************************************************************************************
*/
-VOID AddrLib1::HwlComputeXmaskCoordFromAddr(
+VOID Lib::HwlComputeXmaskCoordFromAddr(
UINT_64 addr, ///< [in] address
UINT_32 bitPosition, ///< [in] bitPosition in a byte
UINT_32 pitch, ///< [in] pitch
@@ -2301,7 +2307,7 @@ VOID AddrLib1::HwlComputeXmaskCoordFromAddr(
/**
****************************************************************************************************
-* AddrLib1::HwlComputeXmaskAddrFromCoord
+* Lib::HwlComputeXmaskAddrFromCoord
*
* @brief
* Compute the address from an address of cmask (prior to si)
@@ -2311,7 +2317,7 @@ VOID AddrLib1::HwlComputeXmaskCoordFromAddr(
*
****************************************************************************************************
*/
-UINT_64 AddrLib1::HwlComputeXmaskAddrFromCoord(
+UINT_64 Lib::HwlComputeXmaskAddrFromCoord(
UINT_32 pitch, ///< [in] pitch
UINT_32 height, ///< [in] height
UINT_32 x, ///< [in] x coord
@@ -2513,7 +2519,7 @@ UINT_64 AddrLib1::HwlComputeXmaskAddrFromCoord(
/**
****************************************************************************************************
-* AddrLib1::ComputeSurfaceAddrFromCoordLinear
+* Lib::ComputeSurfaceAddrFromCoordLinear
*
* @brief
* Compute address from coord for linear surface
@@ -2523,7 +2529,7 @@ UINT_64 AddrLib1::HwlComputeXmaskAddrFromCoord(
*
****************************************************************************************************
*/
-UINT_64 AddrLib1::ComputeSurfaceAddrFromCoordLinear(
+UINT_64 Lib::ComputeSurfaceAddrFromCoordLinear(
UINT_32 x, ///< [in] x coord
UINT_32 y, ///< [in] y coord
UINT_32 slice, ///< [in] slice/depth index
@@ -2551,7 +2557,7 @@ UINT_64 AddrLib1::ComputeSurfaceAddrFromCoordLinear(
/**
****************************************************************************************************
-* AddrLib1::ComputeSurfaceCoordFromAddrLinear
+* Lib::ComputeSurfaceCoordFromAddrLinear
*
* @brief
* Compute the coord from an address of a linear surface
@@ -2560,7 +2566,7 @@ UINT_64 AddrLib1::ComputeSurfaceAddrFromCoordLinear(
* N/A
****************************************************************************************************
*/
-VOID AddrLib1::ComputeSurfaceCoordFromAddrLinear(
+VOID Lib::ComputeSurfaceCoordFromAddrLinear(
UINT_64 addr, ///< [in] address
UINT_32 bitPosition, ///< [in] bitPosition in a byte
UINT_32 bpp, ///< [in] bits per pixel
@@ -2584,7 +2590,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrLinear(
/**
****************************************************************************************************
-* AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled
+* Lib::ComputeSurfaceCoordFromAddrMicroTiled
*
* @brief
* Compute the coord from an address of a micro tiled surface
@@ -2593,7 +2599,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrLinear(
* N/A
****************************************************************************************************
*/
-VOID AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled(
+VOID Lib::ComputeSurfaceCoordFromAddrMicroTiled(
UINT_64 addr, ///< [in] address
UINT_32 bitPosition, ///< [in] bitPosition in a byte
UINT_32 bpp, ///< [in] bits per pixel
@@ -2706,7 +2712,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled(
/**
****************************************************************************************************
-* AddrLib1::ComputePipeFromAddr
+* Lib::ComputePipeFromAddr
*
* @brief
* Compute the pipe number from an address
@@ -2716,7 +2722,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled(
*
****************************************************************************************************
*/
-UINT_32 AddrLib1::ComputePipeFromAddr(
+UINT_32 Lib::ComputePipeFromAddr(
UINT_64 addr, ///< [in] address
UINT_32 numPipes ///< [in] number of banks
) const
@@ -2746,7 +2752,7 @@ UINT_32 AddrLib1::ComputePipeFromAddr(
/**
****************************************************************************************************
-* AddrLib1::ComputeMicroTileEquation
+* Lib::ComputeMicroTileEquation
*
* @brief
* Compute micro tile equation
@@ -2756,7 +2762,7 @@ UINT_32 AddrLib1::ComputePipeFromAddr(
*
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputeMicroTileEquation(
+ADDR_E_RETURNCODE Lib::ComputeMicroTileEquation(
UINT_32 log2BytesPP, ///< [in] log2 of bytes per pixel
AddrTileMode tileMode, ///< [in] tile mode
AddrTileType microTileType, ///< [in] pixel order in display/non-display mode
@@ -2959,7 +2965,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeMicroTileEquation(
/**
****************************************************************************************************
-* AddrLib1::ComputePixelIndexWithinMicroTile
+* Lib::ComputePixelIndexWithinMicroTile
*
* @brief
* Compute the pixel index inside a micro tile of surface
@@ -2969,7 +2975,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeMicroTileEquation(
*
****************************************************************************************************
*/
-UINT_32 AddrLib1::ComputePixelIndexWithinMicroTile(
+UINT_32 Lib::ComputePixelIndexWithinMicroTile(
UINT_32 x, ///< [in] x coord
UINT_32 y, ///< [in] y coord
UINT_32 z, ///< [in] slice/depth index
@@ -3174,7 +3180,7 @@ UINT_32 AddrLib1::ComputePixelIndexWithinMicroTile(
/**
****************************************************************************************************
-* AddrLib1::AdjustPitchAlignment
+* Lib::AdjustPitchAlignment
*
* @brief
* Adjusts pitch alignment for flipping surface
@@ -3184,7 +3190,7 @@ UINT_32 AddrLib1::ComputePixelIndexWithinMicroTile(
*
****************************************************************************************************
*/
-VOID AddrLib1::AdjustPitchAlignment(
+VOID Lib::AdjustPitchAlignment(
ADDR_SURFACE_FLAGS flags, ///< [in] Surface flags
UINT_32* pPitchAlign ///< [out] Pointer to pitch alignment
) const
@@ -3204,7 +3210,7 @@ VOID AddrLib1::AdjustPitchAlignment(
/**
****************************************************************************************************
-* AddrLib1::PadDimensions
+* Lib::PadDimensions
*
* @brief
* Helper function to pad dimensions
@@ -3214,7 +3220,7 @@ VOID AddrLib1::AdjustPitchAlignment(
*
****************************************************************************************************
*/
-VOID AddrLib1::PadDimensions(
+VOID Lib::PadDimensions(
AddrTileMode tileMode, ///< [in] tile mode
UINT_32 bpp, ///< [in] bits per pixel
ADDR_SURFACE_FLAGS flags, ///< [in] surface flags
@@ -3310,7 +3316,7 @@ VOID AddrLib1::PadDimensions(
/**
****************************************************************************************************
-* AddrLib1::HwlPreHandleBaseLvl3xPitch
+* Lib::HwlPreHandleBaseLvl3xPitch
*
* @brief
* Pre-handler of 3x pitch (96 bit) adjustment
@@ -3319,7 +3325,7 @@ VOID AddrLib1::PadDimensions(
* Expected pitch
****************************************************************************************************
*/
-UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
+UINT_32 Lib::HwlPreHandleBaseLvl3xPitch(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input
UINT_32 expPitch ///< [in] pitch
) const
@@ -3328,7 +3334,7 @@ UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
//
// If pitch is pre-multiplied by 3, we retrieve original one here to get correct miplevel size
//
- if (AddrElemLib::IsExpand3x(pIn->format) &&
+ if (ElemLib::IsExpand3x(pIn->format) &&
pIn->mipLevel == 0 &&
pIn->tileMode == ADDR_TM_LINEAR_ALIGNED)
{
@@ -3341,7 +3347,7 @@ UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
/**
****************************************************************************************************
-* AddrLib1::HwlPostHandleBaseLvl3xPitch
+* Lib::HwlPostHandleBaseLvl3xPitch
*
* @brief
* Post-handler of 3x pitch adjustment
@@ -3350,7 +3356,7 @@ UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
* Expected pitch
****************************************************************************************************
*/
-UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
+UINT_32 Lib::HwlPostHandleBaseLvl3xPitch(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input
UINT_32 expPitch ///< [in] pitch
) const
@@ -3359,7 +3365,7 @@ UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
// 96 bits surface of sub levels require element pitch of 32 bits instead
// So we just return pitch in 32 bit pixels without timing 3
//
- if (AddrElemLib::IsExpand3x(pIn->format) &&
+ if (ElemLib::IsExpand3x(pIn->format) &&
pIn->mipLevel == 0 &&
pIn->tileMode == ADDR_TM_LINEAR_ALIGNED)
{
@@ -3372,7 +3378,7 @@ UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
/**
****************************************************************************************************
-* AddrLib1::IsMacroTiled
+* Lib::IsMacroTiled
*
* @brief
* Check if the tile mode is macro tiled
@@ -3381,7 +3387,7 @@ UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
* TRUE if it is macro tiled (2D/2B/3D/3B)
****************************************************************************************************
*/
-BOOL_32 AddrLib1::IsMacroTiled(
+BOOL_32 Lib::IsMacroTiled(
AddrTileMode tileMode) ///< [in] tile mode
{
return ModeFlags[tileMode].isMacro;
@@ -3389,7 +3395,7 @@ BOOL_32 AddrLib1::IsMacroTiled(
/**
****************************************************************************************************
-* AddrLib1::IsMacro3dTiled
+* Lib::IsMacro3dTiled
*
* @brief
* Check if the tile mode is 3D macro tiled
@@ -3398,7 +3404,7 @@ BOOL_32 AddrLib1::IsMacroTiled(
* TRUE if it is 3D macro tiled
****************************************************************************************************
*/
-BOOL_32 AddrLib1::IsMacro3dTiled(
+BOOL_32 Lib::IsMacro3dTiled(
AddrTileMode tileMode) ///< [in] tile mode
{
return ModeFlags[tileMode].isMacro3d;
@@ -3406,7 +3412,7 @@ BOOL_32 AddrLib1::IsMacro3dTiled(
/**
****************************************************************************************************
-* AddrLib1::IsMicroTiled
+* Lib::IsMicroTiled
*
* @brief
* Check if the tile mode is micro tiled
@@ -3415,7 +3421,7 @@ BOOL_32 AddrLib1::IsMacro3dTiled(
* TRUE if micro tiled
****************************************************************************************************
*/
-BOOL_32 AddrLib1::IsMicroTiled(
+BOOL_32 Lib::IsMicroTiled(
AddrTileMode tileMode) ///< [in] tile mode
{
return ModeFlags[tileMode].isMicro;
@@ -3423,7 +3429,7 @@ BOOL_32 AddrLib1::IsMicroTiled(
/**
****************************************************************************************************
-* AddrLib1::IsLinear
+* Lib::IsLinear
*
* @brief
* Check if the tile mode is linear
@@ -3432,7 +3438,7 @@ BOOL_32 AddrLib1::IsMicroTiled(
* TRUE if linear
****************************************************************************************************
*/
-BOOL_32 AddrLib1::IsLinear(
+BOOL_32 Lib::IsLinear(
AddrTileMode tileMode) ///< [in] tile mode
{
return ModeFlags[tileMode].isLinear;
@@ -3440,7 +3446,7 @@ BOOL_32 AddrLib1::IsLinear(
/**
****************************************************************************************************
-* AddrLib1::IsPrtNoRotationTileMode
+* Lib::IsPrtNoRotationTileMode
*
* @brief
* Return TRUE if it is prt tile without rotation
@@ -3448,7 +3454,7 @@ BOOL_32 AddrLib1::IsLinear(
* This function just used by CI
****************************************************************************************************
*/
-BOOL_32 AddrLib1::IsPrtNoRotationTileMode(
+BOOL_32 Lib::IsPrtNoRotationTileMode(
AddrTileMode tileMode)
{
return ModeFlags[tileMode].isPrtNoRotation;
@@ -3456,7 +3462,7 @@ BOOL_32 AddrLib1::IsPrtNoRotationTileMode(
/**
****************************************************************************************************
-* AddrLib1::IsPrtTileMode
+* Lib::IsPrtTileMode
*
* @brief
* Return TRUE if it is prt tile
@@ -3464,7 +3470,7 @@ BOOL_32 AddrLib1::IsPrtNoRotationTileMode(
* This function just used by CI
****************************************************************************************************
*/
-BOOL_32 AddrLib1::IsPrtTileMode(
+BOOL_32 Lib::IsPrtTileMode(
AddrTileMode tileMode)
{
return ModeFlags[tileMode].isPrt;
@@ -3472,7 +3478,7 @@ BOOL_32 AddrLib1::IsPrtTileMode(
/**
****************************************************************************************************
-* AddrLib1::ComputeMipLevel
+* Lib::ComputeMipLevel
*
* @brief
* Compute mipmap level width/height/slices
@@ -3480,11 +3486,11 @@ BOOL_32 AddrLib1::IsPrtTileMode(
* N/A
****************************************************************************************************
*/
-VOID AddrLib1::ComputeMipLevel(
+VOID Lib::ComputeMipLevel(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn ///< [in/out] Input structure
) const
{
- if (AddrElemLib::IsBlockCompressed(pIn->format))
+ if (ElemLib::IsBlockCompressed(pIn->format))
{
if (pIn->mipLevel == 0)
{
@@ -3502,7 +3508,7 @@ VOID AddrLib1::ComputeMipLevel(
/**
****************************************************************************************************
-* AddrLib1::OptimizeTileMode
+* Lib::OptimizeTileMode
*
* @brief
* Check if base level's tile mode can be optimized (degraded)
@@ -3510,7 +3516,7 @@ VOID AddrLib1::ComputeMipLevel(
* TRUE if degraded, also returns degraded tile mode (unchanged if not degraded)
****************************************************************************************************
*/
-BOOL_32 AddrLib1::OptimizeTileMode(
+BOOL_32 Lib::OptimizeTileMode(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure for surface info
AddrTileMode* pTileMode ///< [out] Degraded tile mode
) const
@@ -3529,7 +3535,7 @@ BOOL_32 AddrLib1::OptimizeTileMode(
// Check if linear mode is optimal
if ((pIn->height == 1) &&
(IsLinear(tileMode) == FALSE) &&
- (AddrElemLib::IsBlockCompressed(pIn->format) == FALSE) &&
+ (ElemLib::IsBlockCompressed(pIn->format) == FALSE) &&
(pIn->flags.depth == FALSE) &&
(pIn->flags.stencil == FALSE) &&
(m_configFlags.disableLinearOpt == FALSE) &&
@@ -3572,7 +3578,7 @@ BOOL_32 AddrLib1::OptimizeTileMode(
/**
****************************************************************************************************
-* AddrLib1::DegradeLargeThickTile
+* Lib::DegradeLargeThickTile
*
* @brief
* Check if the thickness needs to be reduced if a tile is too large
@@ -3580,7 +3586,7 @@ BOOL_32 AddrLib1::OptimizeTileMode(
* The degraded tile mode (unchanged if not degraded)
****************************************************************************************************
*/
-AddrTileMode AddrLib1::DegradeLargeThickTile(
+AddrTileMode Lib::DegradeLargeThickTile(
AddrTileMode tileMode,
UINT_32 bpp) const
{
@@ -3642,14 +3648,14 @@ AddrTileMode AddrLib1::DegradeLargeThickTile(
/**
****************************************************************************************************
-* AddrLib1::PostComputeMipLevel
+* Lib::PostComputeMipLevel
* @brief
* Compute MipLevel info (including level 0) after surface adjustment
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::PostComputeMipLevel(
+ADDR_E_RETURNCODE Lib::PostComputeMipLevel(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in/out] Input structure
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] Output structure
) const
@@ -3682,7 +3688,7 @@ ADDR_E_RETURNCODE AddrLib1::PostComputeMipLevel(
/**
****************************************************************************************************
-* AddrLib1::HwlSetupTileCfg
+* Lib::HwlSetupTileCfg
*
* @brief
* Map tile index to tile setting.
@@ -3690,7 +3696,7 @@ ADDR_E_RETURNCODE AddrLib1::PostComputeMipLevel(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::HwlSetupTileCfg(
+ADDR_E_RETURNCODE Lib::HwlSetupTileCfg(
UINT_32 bpp, ///< Bits per pixel
INT_32 index, ///< [in] Tile index
INT_32 macroModeIndex, ///< [in] Index in macro tile mode table(CI)
@@ -3704,7 +3710,7 @@ ADDR_E_RETURNCODE AddrLib1::HwlSetupTileCfg(
/**
****************************************************************************************************
-* AddrLib1::HwlGetPipes
+* Lib::HwlGetPipes
*
* @brief
* Get number pipes
@@ -3712,7 +3718,7 @@ ADDR_E_RETURNCODE AddrLib1::HwlSetupTileCfg(
* num pipes
****************************************************************************************************
*/
-UINT_32 AddrLib1::HwlGetPipes(
+UINT_32 Lib::HwlGetPipes(
const ADDR_TILEINFO* pTileInfo ///< [in] Tile info
) const
{
@@ -3722,7 +3728,7 @@ UINT_32 AddrLib1::HwlGetPipes(
/**
****************************************************************************************************
-* AddrLib1::ComputeQbStereoInfo
+* Lib::ComputeQbStereoInfo
*
* @brief
* Get quad buffer stereo information
@@ -3730,7 +3736,7 @@ UINT_32 AddrLib1::HwlGetPipes(
* TRUE if no error
****************************************************************************************************
*/
-BOOL_32 AddrLib1::ComputeQbStereoInfo(
+BOOL_32 Lib::ComputeQbStereoInfo(
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [in/out] updated pOut+pStereoInfo
) const
{
@@ -3767,7 +3773,7 @@ BOOL_32 AddrLib1::ComputeQbStereoInfo(
/**
****************************************************************************************************
-* AddrLib1::ComputePrtInfo
+* Lib::ComputePrtInfo
*
* @brief
* Compute prt surface related info
@@ -3776,7 +3782,7 @@ BOOL_32 AddrLib1::ComputeQbStereoInfo(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE AddrLib1::ComputePrtInfo(
+ADDR_E_RETURNCODE Lib::ComputePrtInfo(
const ADDR_PRT_INFO_INPUT* pIn,
ADDR_PRT_INFO_OUTPUT* pOut) const
{
@@ -3786,12 +3792,12 @@ ADDR_E_RETURNCODE AddrLib1::ComputePrtInfo(
UINT_32 expandX = 1;
UINT_32 expandY = 1;
- AddrElemMode elemMode;
+ ElemMode elemMode;
UINT_32 bpp = GetElemLib()->GetBitsPerPixel(pIn->format,
- &elemMode,
- &expandX,
- &expandY);
+ &elemMode,
+ &expandX,
+ &expandY);
if (bpp <8 || bpp == 24 || bpp == 48 || bpp == 96)
{
@@ -3895,3 +3901,5 @@ ADDR_E_RETURNCODE AddrLib1::ComputePrtInfo(
return returnCode;
}
+} // V1
+} // Addr
diff --git a/src/amd/addrlib/core/addrlib1.h b/src/amd/addrlib/core/addrlib1.h
index 9751d1d4f17..7c19d102c16 100644
--- a/src/amd/addrlib/core/addrlib1.h
+++ b/src/amd/addrlib/core/addrlib1.h
@@ -27,7 +27,7 @@
/**
****************************************************************************************************
* @file addrlib1.h
-* @brief Contains the AddrLib1 base class definition.
+* @brief Contains the Lib base class definition.
****************************************************************************************************
*/
@@ -36,13 +36,17 @@
#include "addrlib.h"
+namespace Addr
+{
+namespace V1
+{
/**
****************************************************************************************************
* @brief Neutral enums that define bank swap size
****************************************************************************************************
*/
-enum AddrSampleSplitSize
+enum SampleSplitSize
{
ADDR_SAMPLESPLIT_1KB = 1024,
ADDR_SAMPLESPLIT_2KB = 2048,
@@ -55,7 +59,7 @@ enum AddrSampleSplitSize
* @brief Flags for AddrTileMode
****************************************************************************************************
*/
-struct AddrTileModeFlags
+struct TileModeFlags
{
UINT_32 thickness : 4;
UINT_32 isLinear : 1;
@@ -72,12 +76,12 @@ struct AddrTileModeFlags
* @brief This class contains asic independent address lib functionalities
****************************************************************************************************
*/
-class AddrLib1 : public AddrLib
+class Lib : public Addr::Lib
{
public:
- virtual ~AddrLib1();
+ virtual ~Lib();
- static AddrLib1* GetAddrLib1(
+ static Lib* GetLib(
ADDR_HANDLE hLib);
/// Returns tileIndex support
@@ -187,8 +191,8 @@ public:
const ADDR_PRT_INFO_INPUT* pIn,
ADDR_PRT_INFO_OUTPUT* pOut) const;
protected:
- AddrLib1(); // Constructor is protected
- AddrLib1(const AddrClient* pClient);
+ Lib(); // Constructor is protected
+ Lib(const Client* pClient);
/// Pure Virtual function for Hwl computing surface info
virtual ADDR_E_RETURNCODE HwlComputeSurfaceInfo(
@@ -434,7 +438,7 @@ protected:
//
// Misc helper
//
- static const AddrTileModeFlags ModeFlags[ADDR_TM_COUNT];
+ static const TileModeFlags ModeFlags[ADDR_TM_COUNT];
static UINT_32 Thickness(
AddrTileMode tileMode);
@@ -495,10 +499,10 @@ protected:
private:
// Disallow the copy constructor
- AddrLib1(const AddrLib1& a);
+ Lib(const Lib& a);
// Disallow the assignment operator
- AddrLib1& operator=(const AddrLib1& a);
+ Lib& operator=(const Lib& a);
UINT_32 ComputeCmaskBaseAlign(
ADDR_CMASK_FLAGS flags, ADDR_TILEINFO* pTileInfo) const;
@@ -517,5 +521,8 @@ private:
UINT_32 pipe, UINT_32 x) const;
};
+} // V1
+} // Addr
+
#endif
diff --git a/src/amd/addrlib/core/addrobject.cpp b/src/amd/addrlib/core/addrobject.cpp
index 2d86e033f13..0c5f81a5185 100644
--- a/src/amd/addrlib/core/addrobject.cpp
+++ b/src/amd/addrlib/core/addrobject.cpp
@@ -26,23 +26,26 @@
/**
****************************************************************************************************
-* @file addrobject.cpp
-* @brief Contains the AddrObject base class implementation.
+* @file Object.cpp
+* @brief Contains the Object base class implementation.
****************************************************************************************************
*/
#include "addrinterface.h"
#include "addrobject.h"
+namespace Addr
+{
+
/**
****************************************************************************************************
-* AddrObject::AddrObject
+* Object::Object
*
* @brief
-* Constructor for the AddrObject class.
+* Constructor for the Object class.
****************************************************************************************************
*/
-AddrObject::AddrObject()
+Object::Object()
{
m_client.handle = NULL;
m_client.callbacks.allocSysMem = NULL;
@@ -52,40 +55,40 @@ AddrObject::AddrObject()
/**
****************************************************************************************************
-* AddrObject::AddrObject
+* Object::Object
*
* @brief
-* Constructor for the AddrObject class.
+* Constructor for the Object class.
****************************************************************************************************
*/
-AddrObject::AddrObject(const AddrClient* pClient)
+Object::Object(const Client* pClient)
{
m_client = *pClient;
}
/**
****************************************************************************************************
-* AddrObject::~AddrObject
+* Object::~Object
*
* @brief
-* Destructor for the AddrObject class.
+* Destructor for the Object class.
****************************************************************************************************
*/
-AddrObject::~AddrObject()
+Object::~Object()
{
}
/**
****************************************************************************************************
-* AddrObject::ClientAlloc
+* Object::ClientAlloc
*
* @brief
-* Calls instanced allocSysMem inside AddrClient
+* Calls instanced allocSysMem inside Client
****************************************************************************************************
*/
-VOID* AddrObject::ClientAlloc(
+VOID* Object::ClientAlloc(
size_t objSize, ///< [in] Size to allocate
- const AddrClient* pClient) ///< [in] Client pointer
+ const Client* pClient) ///< [in] Client pointer
{
VOID* pObjMem = NULL;
@@ -106,13 +109,13 @@ VOID* AddrObject::ClientAlloc(
/**
****************************************************************************************************
-* AddrObject::AddrMalloc
+* Object::Alloc
*
* @brief
* A wrapper of ClientAlloc
****************************************************************************************************
*/
-VOID* AddrObject::AddrMalloc(
+VOID* Object::Alloc(
size_t objSize) const ///< [in] Size to allocate
{
return ClientAlloc(objSize, &m_client);
@@ -120,15 +123,15 @@ VOID* AddrObject::AddrMalloc(
/**
****************************************************************************************************
-* AddrObject::ClientFree
+* Object::ClientFree
*
* @brief
-* Calls freeSysMem inside AddrClient
+* Calls freeSysMem inside Client
****************************************************************************************************
*/
-VOID AddrObject::ClientFree(
+VOID Object::ClientFree(
VOID* pObjMem, ///< [in] User virtual address to free.
- const AddrClient* pClient) ///< [in] Client pointer
+ const Client* pClient) ///< [in] Client pointer
{
if (pClient->callbacks.freeSysMem != NULL)
{
@@ -147,13 +150,13 @@ VOID AddrObject::ClientFree(
/**
****************************************************************************************************
-* AddrObject::AddrFree
+* Object::Free
*
* @brief
* A wrapper of ClientFree
****************************************************************************************************
*/
-VOID AddrObject::AddrFree(
+VOID Object::Free(
VOID* pObjMem) const ///< [in] User virtual address to free.
{
ClientFree(pObjMem, &m_client);
@@ -161,18 +164,18 @@ VOID AddrObject::AddrFree(
/**
****************************************************************************************************
-* AddrObject::operator new
+* Object::operator new
*
* @brief
-* Allocates memory needed for AddrObject object. (with ADDR_CLIENT_HANDLE)
+* Allocates memory needed for Object object. (with ADDR_CLIENT_HANDLE)
*
* @return
* Returns NULL if unsuccessful.
****************************************************************************************************
*/
-VOID* AddrObject::operator new(
+VOID* Object::operator new(
size_t objSize, ///< [in] Size to allocate
- const AddrClient* pClient) ///< [in] Client pointer
+ const Client* pClient) ///< [in] Client pointer
{
return ClientAlloc(objSize, pClient);
}
@@ -180,37 +183,37 @@ VOID* AddrObject::operator new(
/**
****************************************************************************************************
-* AddrObject::operator delete
+* Object::operator delete
*
* @brief
-* Frees AddrObject object memory.
+* Frees Object object memory.
****************************************************************************************************
*/
-VOID AddrObject::operator delete(
+VOID Object::operator delete(
VOID* pObjMem, ///< [in] User virtual address to free.
- const AddrClient* pClient) ///< [in] Client handle
+ const Client* pClient) ///< [in] Client handle
{
ClientFree(pObjMem, pClient);
}
/**
****************************************************************************************************
-* AddrObject::operator delete
+* Object::operator delete
*
* @brief
-* Frees AddrObject object memory.
+* Frees Object object memory.
****************************************************************************************************
*/
-VOID AddrObject::operator delete(
+VOID Object::operator delete(
VOID* pObjMem) ///< [in] User virtual address to free.
{
- AddrObject* pObj = static_cast<AddrObject*>(pObjMem);
+ Object* pObj = static_cast<Object*>(pObjMem);
ClientFree(pObjMem, &pObj->m_client);
}
/**
****************************************************************************************************
-* AddrObject::DebugPrint
+* Object::DebugPrint
*
* @brief
* Print debug message
@@ -219,7 +222,7 @@ VOID AddrObject::operator delete(
* N/A
****************************************************************************************************
*/
-VOID AddrObject::DebugPrint(
+VOID Object::DebugPrint(
const CHAR* pDebugString, ///< [in] Debug string
...) const
{
@@ -244,3 +247,4 @@ VOID AddrObject::DebugPrint(
#endif
}
+} // Addr
diff --git a/src/amd/addrlib/core/addrobject.h b/src/amd/addrlib/core/addrobject.h
index e3cf0afbc8f..c6483862b56 100644
--- a/src/amd/addrlib/core/addrobject.h
+++ b/src/amd/addrlib/core/addrobject.h
@@ -26,8 +26,8 @@
/**
****************************************************************************************************
-* @file addrobject.h
-* @brief Contains the AddrObject base class definition.
+* @file Object.h
+* @brief Contains the Object base class definition.
****************************************************************************************************
*/
@@ -37,12 +37,15 @@
#include "addrtypes.h"
#include "addrcommon.h"
+namespace Addr
+{
+
/**
****************************************************************************************************
* @brief This structure contains client specific data
****************************************************************************************************
*/
-struct AddrClient
+struct Client
{
ADDR_CLIENT_HANDLE handle;
ADDR_CALLBACKS callbacks;
@@ -52,38 +55,39 @@ struct AddrClient
* @brief This class is the base class for all ADDR class objects.
****************************************************************************************************
*/
-class AddrObject
+class Object
{
public:
- AddrObject();
- AddrObject(const AddrClient* pClient);
- virtual ~AddrObject();
+ Object();
+ Object(const Client* pClient);
+ virtual ~Object();
- VOID* operator new(size_t size, const AddrClient* pClient);
- VOID operator delete(VOID* pObj, const AddrClient* pClient);
+ VOID* operator new(size_t size, const Client* pClient);
+ VOID operator delete(VOID* pObj, const Client* pClient);
VOID operator delete(VOID* pObj);
- VOID* AddrMalloc(size_t size) const;
- VOID AddrFree(VOID* pObj) const;
+ VOID* Alloc(size_t size) const;
+ VOID Free(VOID* pObj) const;
VOID DebugPrint(
const CHAR* pDebugString,
...) const;
- const AddrClient* GetClient() const {return &m_client;}
+ const Client* GetClient() const {return &m_client;}
protected:
- AddrClient m_client;
+ Client m_client;
private:
- static VOID* ClientAlloc(size_t size, const AddrClient* pClient);
- static VOID ClientFree(VOID* pObj, const AddrClient* pClient);
+ static VOID* ClientAlloc(size_t size, const Client* pClient);
+ static VOID ClientFree(VOID* pObj, const Client* pClient);
// disallow the copy constructor
- AddrObject(const AddrObject& a);
+ Object(const Object& a);
// disallow the assignment operator
- AddrObject& operator=(const AddrObject& a);
+ Object& operator=(const Object& a);
};
+} // Addr
#endif
diff --git a/src/amd/addrlib/r800/ciaddrlib.cpp b/src/amd/addrlib/r800/ciaddrlib.cpp
index ebaf3e5623b..839a26833a6 100644
--- a/src/amd/addrlib/r800/ciaddrlib.cpp
+++ b/src/amd/addrlib/r800/ciaddrlib.cpp
@@ -27,7 +27,7 @@
/**
****************************************************************************************************
* @file ciaddrlib.cpp
-* @brief Contains the implementation for the CiAddrLib class.
+* @brief Contains the implementation for the CiLib class.
****************************************************************************************************
*/
@@ -48,9 +48,31 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
+namespace Addr
+{
+
+/**
+****************************************************************************************************
+* CiHwlInit
+*
+* @brief
+* Creates an CiLib object.
+*
+* @return
+* Returns an CiLib object pointer.
+****************************************************************************************************
+*/
+Lib* CiHwlInit(const Client* pClient)
+{
+ return V1::CiLib::CreateObj(pClient);
+}
+
+namespace V1
+{
+
/**
****************************************************************************************************
-* AddrMask
+* Mask
*
* @brief
* Gets a mask of "width"
@@ -58,7 +80,7 @@
* Bit mask
****************************************************************************************************
*/
-static UINT_64 AddrMask(
+static UINT_64 Mask(
UINT_32 width) ///< Width of bits
{
UINT_64 ret;
@@ -76,7 +98,7 @@ static UINT_64 AddrMask(
/**
****************************************************************************************************
-* AddrGetBits
+* GetBits
*
* @brief
* Gets bits within a range of [msb, lsb]
@@ -84,7 +106,7 @@ static UINT_64 AddrMask(
* Bits of this range
****************************************************************************************************
*/
-static UINT_64 AddrGetBits(
+static UINT_64 GetBits(
UINT_64 bits, ///< Source bits
UINT_32 msb, ///< Most signicant bit
UINT_32 lsb) ///< Least signicant bit
@@ -93,14 +115,14 @@ static UINT_64 AddrGetBits(
if (msb >= lsb)
{
- ret = (bits >> lsb) & (AddrMask(1 + msb - lsb));
+ ret = (bits >> lsb) & (Mask(1 + msb - lsb));
}
return ret;
}
/**
****************************************************************************************************
-* AddrRemoveBits
+* RemoveBits
*
* @brief
* Removes bits within the range of [msb, lsb]
@@ -108,7 +130,7 @@ static UINT_64 AddrGetBits(
* Modified bits
****************************************************************************************************
*/
-static UINT_64 AddrRemoveBits(
+static UINT_64 RemoveBits(
UINT_64 bits, ///< Source bits
UINT_32 msb, ///< Most signicant bit
UINT_32 lsb) ///< Least signicant bit
@@ -117,15 +139,15 @@ static UINT_64 AddrRemoveBits(
if (msb >= lsb)
{
- ret = AddrGetBits(bits, lsb - 1, 0) // low bits
- | (AddrGetBits(bits, 8 * sizeof(bits) - 1, msb + 1) << lsb); //high bits
+ ret = GetBits(bits, lsb - 1, 0) // low bits
+ | (GetBits(bits, 8 * sizeof(bits) - 1, msb + 1) << lsb); //high bits
}
return ret;
}
/**
****************************************************************************************************
-* AddrInsertBits
+* InsertBits
*
* @brief
* Inserts new bits into the range of [msb, lsb]
@@ -133,7 +155,7 @@ static UINT_64 AddrRemoveBits(
* Modified bits
****************************************************************************************************
*/
-static UINT_64 AddrInsertBits(
+static UINT_64 InsertBits(
UINT_64 bits, ///< Source bits
UINT_64 newBits, ///< New bits to be inserted
UINT_32 msb, ///< Most signicant bit
@@ -143,41 +165,25 @@ static UINT_64 AddrInsertBits(
if (msb >= lsb)
{
- ret = AddrGetBits(bits, lsb - 1, 0) // old low bitss
- | (AddrGetBits(newBits, msb - lsb, 0) << lsb) //new bits
- | (AddrGetBits(bits, 8 * sizeof(bits) - 1, lsb) << (msb + 1)); //old high bits
+ ret = GetBits(bits, lsb - 1, 0) // old low bitss
+ | (GetBits(newBits, msb - lsb, 0) << lsb) //new bits
+ | (GetBits(bits, 8 * sizeof(bits) - 1, lsb) << (msb + 1)); //old high bits
}
return ret;
}
-
-/**
-****************************************************************************************************
-* AddrCiHwlInit
-*
-* @brief
-* Creates an CiAddrLib object.
-*
-* @return
-* Returns an CiAddrLib object pointer.
-****************************************************************************************************
-*/
-AddrLib* AddrCIHwlInit(const AddrClient* pClient)
-{
- return CiAddrLib::CreateObj(pClient);
-}
-
/**
****************************************************************************************************
-* CiAddrLib::CiAddrLib
+* CiLib::CiLib
*
* @brief
* Constructor
*
****************************************************************************************************
*/
-CiAddrLib::CiAddrLib(const AddrClient* pClient) :
- SiAddrLib(pClient),
+CiLib::CiLib(const Client* pClient)
+ :
+ SiLib(pClient),
m_noOfMacroEntries(0),
m_allowNonDispThickModes(FALSE)
{
@@ -187,19 +193,19 @@ CiAddrLib::CiAddrLib(const AddrClient* pClient) :
/**
****************************************************************************************************
-* CiAddrLib::~CiAddrLib
+* CiLib::~CiLib
*
* @brief
* Destructor
****************************************************************************************************
*/
-CiAddrLib::~CiAddrLib()
+CiLib::~CiLib()
{
}
/**
****************************************************************************************************
-* CiAddrLib::HwlComputeDccInfo
+* CiLib::HwlComputeDccInfo
*
* @brief
* Compute DCC key size, base alignment
@@ -207,7 +213,7 @@ CiAddrLib::~CiAddrLib()
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE CiAddrLib::HwlComputeDccInfo(
+ADDR_E_RETURNCODE CiLib::HwlComputeDccInfo(
const ADDR_COMPUTE_DCCINFO_INPUT* pIn,
ADDR_COMPUTE_DCCINFO_OUTPUT* pOut) const
{
@@ -281,7 +287,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeDccInfo(
/**
****************************************************************************************************
-* CiAddrLib::HwlComputeCmaskAddrFromCoord
+* CiLib::HwlComputeCmaskAddrFromCoord
*
* @brief
* Compute tc compatible Cmask address from fmask ram address
@@ -290,7 +296,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeDccInfo(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE CiAddrLib::HwlComputeCmaskAddrFromCoord(
+ADDR_E_RETURNCODE CiLib::HwlComputeCmaskAddrFromCoord(
const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] fmask addr/bpp/tile input
ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut ///< [out] cmask address
) const
@@ -325,7 +331,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeCmaskAddrFromCoord(
/**
****************************************************************************************************
-* CiAddrLib::HwlComputeHtileAddrFromCoord
+* CiLib::HwlComputeHtileAddrFromCoord
*
* @brief
* Compute tc compatible Htile address from depth/stencil address
@@ -334,7 +340,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeCmaskAddrFromCoord(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE CiAddrLib::HwlComputeHtileAddrFromCoord(
+ADDR_E_RETURNCODE CiLib::HwlComputeHtileAddrFromCoord(
const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] depth/stencil addr/bpp/tile input
ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] htile address
) const
@@ -369,19 +375,19 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeHtileAddrFromCoord(
/**
****************************************************************************************************
-* CiAddrLib::HwlConvertChipFamily
+* CiLib::HwlConvertChipFamily
*
* @brief
-* Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
+* Convert familyID defined in atiid.h to ChipFamily and set m_chipFamily/m_chipRevision
* @return
-* AddrChipFamily
+* ChipFamily
****************************************************************************************************
*/
-AddrChipFamily CiAddrLib::HwlConvertChipFamily(
+ChipFamily CiLib::HwlConvertChipFamily(
UINT_32 uChipFamily, ///< [in] chip family defined in atiih.h
UINT_32 uChipRevision) ///< [in] chip revision defined in "asic_family"_id.h
{
- AddrChipFamily family = ADDR_CHIP_FAMILY_CI;
+ ChipFamily family = ADDR_CHIP_FAMILY_CI;
switch (uChipFamily)
{
@@ -419,7 +425,7 @@ AddrChipFamily CiAddrLib::HwlConvertChipFamily(
/**
****************************************************************************************************
-* CiAddrLib::HwlInitGlobalParams
+* CiLib::HwlInitGlobalParams
*
* @brief
* Initializes global parameters
@@ -429,7 +435,7 @@ AddrChipFamily CiAddrLib::HwlConvertChipFamily(
*
****************************************************************************************************
*/
-BOOL_32 CiAddrLib::HwlInitGlobalParams(
+BOOL_32 CiLib::HwlInitGlobalParams(
const ADDR_CREATE_INPUT* pCreateIn) ///< [in] create input
{
BOOL_32 valid = TRUE;
@@ -492,7 +498,7 @@ BOOL_32 CiAddrLib::HwlInitGlobalParams(
/**
****************************************************************************************************
-* CiAddrLib::HwlPostCheckTileIndex
+* CiLib::HwlPostCheckTileIndex
*
* @brief
* Map a tile setting to index if curIndex is invalid, otherwise check if curIndex matches
@@ -501,7 +507,7 @@ BOOL_32 CiAddrLib::HwlInitGlobalParams(
* Tile index.
****************************************************************************************************
*/
-INT_32 CiAddrLib::HwlPostCheckTileIndex(
+INT_32 CiLib::HwlPostCheckTileIndex(
const ADDR_TILEINFO* pInfo, ///< [in] Tile Info
AddrTileMode mode, ///< [in] Tile mode
AddrTileType type, ///< [in] Tile type
@@ -583,7 +589,7 @@ INT_32 CiAddrLib::HwlPostCheckTileIndex(
/**
****************************************************************************************************
-* CiAddrLib::HwlSetupTileCfg
+* CiLib::HwlSetupTileCfg
*
* @brief
* Map tile index to tile setting.
@@ -591,7 +597,7 @@ INT_32 CiAddrLib::HwlPostCheckTileIndex(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE CiAddrLib::HwlSetupTileCfg(
+ADDR_E_RETURNCODE CiLib::HwlSetupTileCfg(
UINT_32 bpp, ///< [in] Bits per pixel
INT_32 index, ///< [in] Tile index
INT_32 macroModeIndex, ///< [in] Index in macro tile mode table(CI)
@@ -620,7 +626,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlSetupTileCfg(
}
else
{
- const AddrTileConfig* pCfgTable = GetTileSetting(index);
+ const TileConfig* pCfgTable = GetTileSetting(index);
if (pInfo != NULL)
{
@@ -682,15 +688,15 @@ ADDR_E_RETURNCODE CiAddrLib::HwlSetupTileCfg(
/**
****************************************************************************************************
-* CiAddrLib::HwlComputeSurfaceInfo
+* CiLib::HwlComputeSurfaceInfo
*
* @brief
-* Entry of ci's ComputeSurfaceInfo
+* Entry of CI's ComputeSurfaceInfo
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE CiAddrLib::HwlComputeSurfaceInfo(
+ADDR_E_RETURNCODE CiLib::HwlComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
) const
@@ -704,7 +710,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeSurfaceInfo(
// Pass tcCompatible flag from input to output; and turn off it if tile split occurs
pOut->tcCompatible = pIn->flags.tcCompatible;
- ADDR_E_RETURNCODE retCode = SiAddrLib::HwlComputeSurfaceInfo(pIn,pOut);
+ ADDR_E_RETURNCODE retCode = SiLib::HwlComputeSurfaceInfo(pIn,pOut);
if (pOut->macroModeIndex == TileIndexNoMacroIndex)
{
@@ -716,14 +722,14 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeSurfaceInfo(
/**
****************************************************************************************************
-* CiAddrLib::HwlFmaskSurfaceInfo
+* CiLib::HwlFmaskSurfaceInfo
* @brief
* Entry of r800's ComputeFmaskInfo
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE CiAddrLib::HwlComputeFmaskInfo(
+ADDR_E_RETURNCODE CiLib::HwlComputeFmaskInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut ///< [out] output structure
)
@@ -803,7 +809,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeFmaskInfo(
/**
****************************************************************************************************
-* CiAddrLib::HwlFmaskPreThunkSurfInfo
+* CiLib::HwlFmaskPreThunkSurfInfo
*
* @brief
* Some preparation before thunking a ComputeSurfaceInfo call for Fmask
@@ -811,7 +817,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeFmaskInfo(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-VOID CiAddrLib::HwlFmaskPreThunkSurfInfo(
+VOID CiLib::HwlFmaskPreThunkSurfInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pFmaskIn, ///< [in] Input of fmask info
const ADDR_COMPUTE_FMASK_INFO_OUTPUT* pFmaskOut, ///< [in] Output of fmask info
ADDR_COMPUTE_SURFACE_INFO_INPUT* pSurfIn, ///< [out] Input of thunked surface info
@@ -824,7 +830,7 @@ VOID CiAddrLib::HwlFmaskPreThunkSurfInfo(
/**
****************************************************************************************************
-* CiAddrLib::HwlFmaskPostThunkSurfInfo
+* CiLib::HwlFmaskPostThunkSurfInfo
*
* @brief
* Copy hwl extra field after calling thunked ComputeSurfaceInfo
@@ -832,7 +838,7 @@ VOID CiAddrLib::HwlFmaskPreThunkSurfInfo(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-VOID CiAddrLib::HwlFmaskPostThunkSurfInfo(
+VOID CiLib::HwlFmaskPostThunkSurfInfo(
const ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pSurfOut, ///< [in] Output of surface info
ADDR_COMPUTE_FMASK_INFO_OUTPUT* pFmaskOut ///< [out] Output of fmask info
) const
@@ -843,7 +849,7 @@ VOID CiAddrLib::HwlFmaskPostThunkSurfInfo(
/**
****************************************************************************************************
-* CiAddrLib::HwlDegradeThickTileMode
+* CiLib::HwlDegradeThickTileMode
*
* @brief
* Degrades valid tile mode for thick modes if needed
@@ -852,7 +858,7 @@ VOID CiAddrLib::HwlFmaskPostThunkSurfInfo(
* Suitable tile mode
****************************************************************************************************
*/
-AddrTileMode CiAddrLib::HwlDegradeThickTileMode(
+AddrTileMode CiLib::HwlDegradeThickTileMode(
AddrTileMode baseTileMode, ///< [in] base tile mode
UINT_32 numSlices, ///< [in] current number of slices
UINT_32* pBytesPerTile ///< [in/out] pointer to bytes per slice
@@ -863,7 +869,7 @@ AddrTileMode CiAddrLib::HwlDegradeThickTileMode(
/**
****************************************************************************************************
-* CiAddrLib::HwlOverrideTileMode
+* CiLib::HwlOverrideTileMode
*
* @brief
* Override THICK to THIN, for specific formats on CI
@@ -873,7 +879,7 @@ AddrTileMode CiAddrLib::HwlDegradeThickTileMode(
*
****************************************************************************************************
*/
-VOID CiAddrLib::HwlOverrideTileMode(
+VOID CiLib::HwlOverrideTileMode(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut ///< [in/out] input output structure
) const
{
@@ -1024,7 +1030,7 @@ VOID CiAddrLib::HwlOverrideTileMode(
/**
****************************************************************************************************
-* CiAddrLib::HwlSelectTileMode
+* CiLib::HwlSelectTileMode
*
* @brief
* Select tile modes.
@@ -1034,7 +1040,7 @@ VOID CiAddrLib::HwlOverrideTileMode(
*
****************************************************************************************************
*/
-VOID CiAddrLib::HwlSelectTileMode(
+VOID CiLib::HwlSelectTileMode(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut ///< [in/out] input output structure
) const
{
@@ -1120,13 +1126,13 @@ VOID CiAddrLib::HwlSelectTileMode(
/**
****************************************************************************************************
-* CiAddrLib::HwlSetupTileInfo
+* CiLib::HwlSetupTileInfo
*
* @brief
* Setup default value of tile info for SI
****************************************************************************************************
*/
-VOID CiAddrLib::HwlSetupTileInfo(
+VOID CiLib::HwlSetupTileInfo(
AddrTileMode tileMode, ///< [in] Tile mode
ADDR_SURFACE_FLAGS flags, ///< [in] Surface type flags
UINT_32 bpp, ///< [in] Bits per pixel
@@ -1453,7 +1459,7 @@ VOID CiAddrLib::HwlSetupTileInfo(
/**
****************************************************************************************************
-* CiAddrLib::ReadGbTileMode
+* CiLib::ReadGbTileMode
*
* @brief
* Convert GB_TILE_MODE HW value to ADDR_TILE_CONFIG.
@@ -1461,9 +1467,9 @@ VOID CiAddrLib::HwlSetupTileInfo(
* NA.
****************************************************************************************************
*/
-VOID CiAddrLib::ReadGbTileMode(
- UINT_32 regValue, ///< [in] GB_TILE_MODE register
- AddrTileConfig* pCfg ///< [out] output structure
+VOID CiLib::ReadGbTileMode(
+ UINT_32 regValue, ///< [in] GB_TILE_MODE register
+ TileConfig* pCfg ///< [out] output structure
) const
{
GB_TILE_MODE gbTileMode;
@@ -1529,7 +1535,7 @@ VOID CiAddrLib::ReadGbTileMode(
/**
****************************************************************************************************
-* CiAddrLib::InitTileSettingTable
+* CiLib::InitTileSettingTable
*
* @brief
* Initialize the ADDR_TILE_CONFIG table.
@@ -1537,7 +1543,7 @@ VOID CiAddrLib::ReadGbTileMode(
* TRUE if tile table is correctly initialized
****************************************************************************************************
*/
-BOOL_32 CiAddrLib::InitTileSettingTable(
+BOOL_32 CiLib::InitTileSettingTable(
const UINT_32* pCfg, ///< [in] Pointer to table of tile configs
UINT_32 noOfEntries ///< [in] Numbe of entries in the table above
)
@@ -1598,7 +1604,7 @@ BOOL_32 CiAddrLib::InitTileSettingTable(
/**
****************************************************************************************************
-* CiAddrLib::ReadGbMacroTileCfg
+* CiLib::ReadGbMacroTileCfg
*
* @brief
* Convert GB_MACRO_TILE_CFG HW value to ADDR_TILE_CONFIG.
@@ -1606,7 +1612,7 @@ BOOL_32 CiAddrLib::InitTileSettingTable(
* NA.
****************************************************************************************************
*/
-VOID CiAddrLib::ReadGbMacroTileCfg(
+VOID CiLib::ReadGbMacroTileCfg(
UINT_32 regValue, ///< [in] GB_MACRO_TILE_MODE register
ADDR_TILEINFO* pCfg ///< [out] output structure
) const
@@ -1622,7 +1628,7 @@ VOID CiAddrLib::ReadGbMacroTileCfg(
/**
****************************************************************************************************
-* CiAddrLib::InitMacroTileCfgTable
+* CiLib::InitMacroTileCfgTable
*
* @brief
* Initialize the ADDR_MACRO_TILE_CONFIG table.
@@ -1630,7 +1636,7 @@ VOID CiAddrLib::ReadGbMacroTileCfg(
* TRUE if macro tile table is correctly initialized
****************************************************************************************************
*/
-BOOL_32 CiAddrLib::InitMacroTileCfgTable(
+BOOL_32 CiLib::InitMacroTileCfgTable(
const UINT_32* pCfg, ///< [in] Pointer to table of tile configs
UINT_32 noOfMacroEntries ///< [in] Numbe of entries in the table above
)
@@ -1669,7 +1675,7 @@ BOOL_32 CiAddrLib::InitMacroTileCfgTable(
/**
****************************************************************************************************
-* CiAddrLib::HwlComputeMacroModeIndex
+* CiLib::HwlComputeMacroModeIndex
*
* @brief
* Computes macro tile mode index
@@ -1677,7 +1683,7 @@ BOOL_32 CiAddrLib::InitMacroTileCfgTable(
* TRUE if macro tile table is correctly initialized
****************************************************************************************************
*/
-INT_32 CiAddrLib::HwlComputeMacroModeIndex(
+INT_32 CiLib::HwlComputeMacroModeIndex(
INT_32 tileIndex, ///< [in] Tile mode index
ADDR_SURFACE_FLAGS flags, ///< [in] Surface flags
UINT_32 bpp, ///< [in] Bit per pixel
@@ -1769,7 +1775,7 @@ INT_32 CiAddrLib::HwlComputeMacroModeIndex(
/**
****************************************************************************************************
-* CiAddrLib::HwlComputeTileDataWidthAndHeightLinear
+* CiLib::HwlComputeTileDataWidthAndHeightLinear
*
* @brief
* Compute the squared cache shape for per-tile data (CMASK and HTILE) for linear layout
@@ -1781,7 +1787,7 @@ INT_32 CiAddrLib::HwlComputeMacroModeIndex(
* MacroWidth and macroHeight are measured in pixels
****************************************************************************************************
*/
-VOID CiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
+VOID CiLib::HwlComputeTileDataWidthAndHeightLinear(
UINT_32* pMacroWidth, ///< [out] macro tile width
UINT_32* pMacroHeight, ///< [out] macro tile height
UINT_32 bpp, ///< [in] bits per pixel
@@ -1814,7 +1820,7 @@ VOID CiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
/**
****************************************************************************************************
-* CiAddrLib::HwlComputeMetadataNibbleAddress
+* CiLib::HwlComputeMetadataNibbleAddress
*
* @brief
* calculate meta data address based on input information
@@ -1835,7 +1841,7 @@ VOID CiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
*
****************************************************************************************************
*/
-UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
+UINT_64 CiLib::HwlComputeMetadataNibbleAddress(
UINT_64 uncompressedDataByteAddress,
UINT_64 dataBaseByteAddress,
UINT_64 metadataBaseByteAddress,
@@ -1883,7 +1889,7 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
UINT_32 lsb = pipeBits + pipeInterleaveBits;
UINT_32 msb = bankBits - 1 + lsb;
- UINT_64 bankDataBits = AddrGetBits(offset, msb, lsb);
+ UINT_64 bankDataBits = GetBits(offset, msb, lsb);
///--------------------------------------------------------------------------------------------
/// Save pipe data bits
@@ -1891,7 +1897,7 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
lsb = pipeInterleaveBits;
msb = pipeBits - 1 + lsb;
- UINT_64 pipeDataBits = AddrGetBits(offset, msb, lsb);
+ UINT_64 pipeDataBits = GetBits(offset, msb, lsb);
///--------------------------------------------------------------------------------------------
/// Remove pipe and bank bits
@@ -1899,7 +1905,7 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
lsb = pipeInterleaveBits;
msb = dataMacrotileBits - 1;
- UINT_64 offsetWithoutPipeBankBits = AddrRemoveBits(offset, msb, lsb);
+ UINT_64 offsetWithoutPipeBankBits = RemoveBits(offset, msb, lsb);
ADDR_ASSERT((0 != blockByteSize));
UINT_64 blockInBankpipe = offsetWithoutPipeBankBits / blockByteSize;
@@ -1917,7 +1923,7 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
}
msb = bankBits - 1 + lsb;
- UINT_64 blockInBankpipeWithBankBits = AddrInsertBits(blockInBankpipe, bankDataBits, msb, lsb);
+ UINT_64 blockInBankpipeWithBankBits = InsertBits(blockInBankpipe, bankDataBits, msb, lsb);
/// NOTE *2 because we are converting to Nibble address in this step
UINT_64 metaAddressInPipe = blockInBankpipeWithBankBits * 2 * metadataBitSize / 8;
@@ -1928,14 +1934,14 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
///--------------------------------------------------------------------------------------------
lsb = pipeInterleaveBits + 1; ///<+1 due to Nibble address now gives interleave bits extra lsb.
msb = pipeBits - 1 + lsb;
- UINT_64 metadataAddress = AddrInsertBits(metaAddressInPipe, pipeDataBits, msb, lsb);
+ UINT_64 metadataAddress = InsertBits(metaAddressInPipe, pipeDataBits, msb, lsb);
return metadataAddress;
}
/**
****************************************************************************************************
-* CiAddrLib::HwlPadDimensions
+* CiLib::HwlPadDimensions
*
* @brief
* Helper function to pad dimensions
@@ -1945,7 +1951,7 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
*
****************************************************************************************************
*/
-VOID CiAddrLib::HwlPadDimensions(
+VOID CiLib::HwlPadDimensions(
AddrTileMode tileMode, ///< [in] tile mode
UINT_32 bpp, ///< [in] bits per pixel
ADDR_SURFACE_FLAGS flags, ///< [in] surface flags
@@ -2021,7 +2027,7 @@ VOID CiAddrLib::HwlPadDimensions(
/**
****************************************************************************************************
-* CiAddrLib::HwlGetMaxAlignments
+* CiLib::HwlGetMaxAlignments
*
* @brief
* Gets maximum alignments
@@ -2029,7 +2035,7 @@ VOID CiAddrLib::HwlPadDimensions(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE CiAddrLib::HwlGetMaxAlignments(
+ADDR_E_RETURNCODE CiLib::HwlGetMaxAlignments(
ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut ///< [out] output structure
) const
{
@@ -2060,4 +2066,5 @@ ADDR_E_RETURNCODE CiAddrLib::HwlGetMaxAlignments(
return ADDR_OK;
}
-
+} // V1
+} // Addr
diff --git a/src/amd/addrlib/r800/ciaddrlib.h b/src/amd/addrlib/r800/ciaddrlib.h
index 69ede03f51c..438790a5895 100644
--- a/src/amd/addrlib/r800/ciaddrlib.h
+++ b/src/amd/addrlib/r800/ciaddrlib.h
@@ -27,7 +27,7 @@
/**
****************************************************************************************************
* @file ciaddrlib.h
-* @brief Contains the CiAddrLib class definition.
+* @brief Contains the CiLib class definition.
****************************************************************************************************
*/
@@ -37,6 +37,11 @@
#include "addrlib1.h"
#include "siaddrlib.h"
+namespace Addr
+{
+namespace V1
+{
+
/**
****************************************************************************************************
* @brief CI specific settings structure.
@@ -74,18 +79,18 @@ struct CIChipSettings
* function set.
****************************************************************************************************
*/
-class CiAddrLib : public SiAddrLib
+class CiLib : public SiLib
{
public:
- /// Creates CiAddrLib object
- static AddrLib* CreateObj(const AddrClient* pClient)
+ /// Creates CiLib object
+ static Addr::Lib* CreateObj(const Client* pClient)
{
- return new(pClient) CiAddrLib(pClient);
+ return new(pClient) CiLib(pClient);
}
private:
- CiAddrLib(const AddrClient* pClient);
- virtual ~CiAddrLib();
+ CiLib(const Client* pClient);
+ virtual ~CiLib();
protected:
@@ -98,7 +103,7 @@ protected:
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn,
ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut);
- virtual AddrChipFamily HwlConvertChipFamily(
+ virtual ChipFamily HwlConvertChipFamily(
UINT_32 uChipFamily, UINT_32 uChipRevision);
virtual BOOL_32 HwlInitGlobalParams(
@@ -117,7 +122,7 @@ protected:
ADDR_TILEINFO* pTileInfo, AddrTileMode* pTileMode = NULL, AddrTileType* pTileType = NULL
) const;
- // Sub-hwl interface - defined in EgBasedAddrLib
+ // Sub-hwl interface - defined in EgBasedLib
virtual VOID HwlSetupTileInfo(
AddrTileMode tileMode, ADDR_SURFACE_FLAGS flags,
UINT_32 bpp, UINT_32 pitch, UINT_32 height, UINT_32 numSamples,
@@ -167,7 +172,7 @@ protected:
private:
VOID ReadGbTileMode(
- UINT_32 regValue, AddrTileConfig* pCfg) const;
+ UINT_32 regValue, TileConfig* pCfg) const;
VOID ReadGbMacroTileCfg(
UINT_32 regValue, ADDR_TILEINFO* pCfg) const;
@@ -198,6 +203,9 @@ private:
CIChipSettings m_settings;
};
+} // V1
+} // Addr
+
#endif
diff --git a/src/amd/addrlib/r800/egbaddrlib.cpp b/src/amd/addrlib/r800/egbaddrlib.cpp
index 393557741bc..5de3f996f08 100644
--- a/src/amd/addrlib/r800/egbaddrlib.cpp
+++ b/src/amd/addrlib/r800/egbaddrlib.cpp
@@ -27,15 +27,20 @@
/**
****************************************************************************************************
* @file egbaddrlib.cpp
-* @brief Contains the EgBasedAddrLib class implementation
+* @brief Contains the EgBasedLib class implementation
****************************************************************************************************
*/
#include "egbaddrlib.h"
+namespace Addr
+{
+namespace V1
+{
+
/**
****************************************************************************************************
-* EgBasedAddrLib::EgBasedAddrLib
+* EgBasedLib::EgBasedLib
*
* @brief
* Constructor
@@ -44,8 +49,8 @@
*
****************************************************************************************************
*/
-EgBasedAddrLib::EgBasedAddrLib(const AddrClient* pClient) :
- AddrLib1(pClient),
+EgBasedLib::EgBasedLib(const Client* pClient) :
+ Lib(pClient),
m_ranks(0),
m_logicalBanks(0),
m_bankInterleave(1)
@@ -54,19 +59,19 @@ EgBasedAddrLib::EgBasedAddrLib(const AddrClient* pClient) :
/**
****************************************************************************************************
-* EgBasedAddrLib::~EgBasedAddrLib
+* EgBasedLib::~EgBasedLib
*
* @brief
* Destructor
****************************************************************************************************
*/
-EgBasedAddrLib::~EgBasedAddrLib()
+EgBasedLib::~EgBasedLib()
{
}
/**
****************************************************************************************************
-* EgBasedAddrLib::DispatchComputeSurfaceInfo
+* EgBasedLib::DispatchComputeSurfaceInfo
*
* @brief
* Compute surface sizes include padded pitch,height,slices,total size in bytes,
@@ -77,7 +82,7 @@ EgBasedAddrLib::~EgBasedAddrLib()
* TRUE if no error occurs
****************************************************************************************************
*/
-BOOL_32 EgBasedAddrLib::DispatchComputeSurfaceInfo(
+BOOL_32 EgBasedLib::DispatchComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
) const
@@ -198,7 +203,7 @@ BOOL_32 EgBasedAddrLib::DispatchComputeSurfaceInfo(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeSurfaceInfoLinear
+* EgBasedLib::ComputeSurfaceInfoLinear
*
* @brief
* Compute linear surface sizes include padded pitch, height, slices, total size in
@@ -209,7 +214,7 @@ BOOL_32 EgBasedAddrLib::DispatchComputeSurfaceInfo(
* TRUE if no error occurs
****************************************************************************************************
*/
-BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoLinear(
+BOOL_32 EgBasedLib::ComputeSurfaceInfoLinear(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut, ///< [out] Output structure
UINT_32 padDims ///< [in] Dimensions to padd
@@ -293,7 +298,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoLinear(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeSurfaceInfoMicroTiled
+* EgBasedLib::ComputeSurfaceInfoMicroTiled
*
* @brief
* Compute 1D/Micro Tiled surface sizes include padded pitch, height, slices, total
@@ -304,7 +309,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoLinear(
* TRUE if no error occurs
****************************************************************************************************
*/
-BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMicroTiled(
+BOOL_32 EgBasedLib::ComputeSurfaceInfoMicroTiled(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut, ///< [out] Output structure
UINT_32 padDims, ///< [in] Dimensions to padd
@@ -403,7 +408,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMicroTiled(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeSurfaceInfoMacroTiled
+* EgBasedLib::ComputeSurfaceInfoMacroTiled
*
* @brief
* Compute 2D/macro tiled surface sizes include padded pitch, height, slices, total
@@ -414,7 +419,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMicroTiled(
* TRUE if no error occurs
****************************************************************************************************
*/
-BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMacroTiled(
+BOOL_32 EgBasedLib::ComputeSurfaceInfoMacroTiled(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut, ///< [out] Output structure
UINT_32 padDims, ///< [in] Dimensions to padd
@@ -615,7 +620,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMacroTiled(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeSurfaceAlignmentsLinear
+* EgBasedLib::ComputeSurfaceAlignmentsLinear
*
* @brief
* Compute linear surface alignment, calculation results are returned through
@@ -625,7 +630,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMacroTiled(
* TRUE if no error occurs
****************************************************************************************************
*/
-BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsLinear(
+BOOL_32 EgBasedLib::ComputeSurfaceAlignmentsLinear(
AddrTileMode tileMode, ///< [in] tile mode
UINT_32 bpp, ///< [in] bits per pixel
ADDR_SURFACE_FLAGS flags, ///< [in] surface flags
@@ -671,7 +676,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsLinear(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled
+* EgBasedLib::ComputeSurfaceAlignmentsMicroTiled
*
* @brief
* Compute 1D tiled surface alignment, calculation results are returned through
@@ -681,7 +686,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsLinear(
* TRUE if no error occurs
****************************************************************************************************
*/
-BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled(
+BOOL_32 EgBasedLib::ComputeSurfaceAlignmentsMicroTiled(
AddrTileMode tileMode, ///< [in] tile mode
UINT_32 bpp, ///< [in] bits per pixel
ADDR_SURFACE_FLAGS flags, ///< [in] surface flags
@@ -721,7 +726,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlReduceBankWidthHeight
+* EgBasedLib::HwlReduceBankWidthHeight
*
* @brief
* Additional checks, reduce bankHeight/bankWidth if needed and possible
@@ -731,7 +736,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled(
* TRUE if no error occurs
****************************************************************************************************
*/
-BOOL_32 EgBasedAddrLib::HwlReduceBankWidthHeight(
+BOOL_32 EgBasedLib::HwlReduceBankWidthHeight(
UINT_32 tileSize, ///< [in] tile size
UINT_32 bpp, ///< [in] bits per pixel
ADDR_SURFACE_FLAGS flags, ///< [in] surface flags
@@ -825,7 +830,7 @@ BOOL_32 EgBasedAddrLib::HwlReduceBankWidthHeight(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled
+* EgBasedLib::ComputeSurfaceAlignmentsMacroTiled
*
* @brief
* Compute 2D tiled surface alignment, calculation results are returned through
@@ -835,7 +840,7 @@ BOOL_32 EgBasedAddrLib::HwlReduceBankWidthHeight(
* TRUE if no error occurs
****************************************************************************************************
*/
-BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled(
+BOOL_32 EgBasedLib::ComputeSurfaceAlignmentsMacroTiled(
AddrTileMode tileMode, ///< [in] tile mode
UINT_32 bpp, ///< [in] bits per pixel
ADDR_SURFACE_FLAGS flags, ///< [in] surface flags
@@ -949,7 +954,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled(
/**
****************************************************************************************************
-* EgBasedAddrLib::SanityCheckMacroTiled
+* EgBasedLib::SanityCheckMacroTiled
*
* @brief
* Check if macro-tiled parameters are valid
@@ -957,7 +962,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled(
* TRUE if valid
****************************************************************************************************
*/
-BOOL_32 EgBasedAddrLib::SanityCheckMacroTiled(
+BOOL_32 EgBasedLib::SanityCheckMacroTiled(
ADDR_TILEINFO* pTileInfo ///< [in] macro-tiled parameters
) const
{
@@ -1054,7 +1059,7 @@ BOOL_32 EgBasedAddrLib::SanityCheckMacroTiled(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeSurfaceMipLevelTileMode
+* EgBasedLib::ComputeSurfaceMipLevelTileMode
*
* @brief
* Compute valid tile mode for surface mipmap sub-levels
@@ -1063,7 +1068,7 @@ BOOL_32 EgBasedAddrLib::SanityCheckMacroTiled(
* Suitable tile mode
****************************************************************************************************
*/
-AddrTileMode EgBasedAddrLib::ComputeSurfaceMipLevelTileMode(
+AddrTileMode EgBasedLib::ComputeSurfaceMipLevelTileMode(
AddrTileMode baseTileMode, ///< [in] base tile mode
UINT_32 bpp, ///< [in] bits per pixels
UINT_32 pitch, ///< [in] current level pitch
@@ -1146,14 +1151,14 @@ AddrTileMode EgBasedAddrLib::ComputeSurfaceMipLevelTileMode(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlDegradeBaseLevel
+* EgBasedLib::HwlDegradeBaseLevel
* @brief
* Check if degrade is needed for base level
* @return
* TRUE if degrade is suggested
****************************************************************************************************
*/
-BOOL_32 EgBasedAddrLib::HwlDegradeBaseLevel(
+BOOL_32 EgBasedLib::HwlDegradeBaseLevel(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn) const
{
BOOL_32 degrade = FALSE;
@@ -1230,7 +1235,7 @@ BOOL_32 EgBasedAddrLib::HwlDegradeBaseLevel(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlDegradeThickTileMode
+* EgBasedLib::HwlDegradeThickTileMode
*
* @brief
* Degrades valid tile mode for thick modes if needed
@@ -1239,7 +1244,7 @@ BOOL_32 EgBasedAddrLib::HwlDegradeBaseLevel(
* Suitable tile mode
****************************************************************************************************
*/
-AddrTileMode EgBasedAddrLib::HwlDegradeThickTileMode(
+AddrTileMode EgBasedLib::HwlDegradeThickTileMode(
AddrTileMode baseTileMode, ///< [in] base tile mode
UINT_32 numSlices, ///< [in] current number of slices
UINT_32* pBytesPerTile ///< [in/out] pointer to bytes per slice
@@ -1303,7 +1308,7 @@ AddrTileMode EgBasedAddrLib::HwlDegradeThickTileMode(
/**
****************************************************************************************************
-* EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord
+* EgBasedLib::DispatchComputeSurfaceAddrFromCoord
*
* @brief
* Compute surface address from given coord (x, y, slice,sample)
@@ -1312,7 +1317,7 @@ AddrTileMode EgBasedAddrLib::HwlDegradeThickTileMode(
* Address in bytes
****************************************************************************************************
*/
-UINT_64 EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord(
+UINT_64 EgBasedLib::DispatchComputeSurfaceAddrFromCoord(
const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
@@ -1468,7 +1473,7 @@ UINT_64 EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeMacroTileEquation
+* EgBasedLib::ComputeMacroTileEquation
*
* @brief
* Computes the address equation in macro tile
@@ -1476,7 +1481,7 @@ UINT_64 EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord(
* If equation can be computed
****************************************************************************************************
*/
-ADDR_E_RETURNCODE EgBasedAddrLib::ComputeMacroTileEquation(
+ADDR_E_RETURNCODE EgBasedLib::ComputeMacroTileEquation(
UINT_32 log2BytesPP, ///< [in] log2 of bytes per pixel
AddrTileMode tileMode, ///< [in] tile mode
AddrTileType microTileType, ///< [in] micro tiling type
@@ -1599,7 +1604,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::ComputeMacroTileEquation(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled
+* EgBasedLib::ComputeSurfaceAddrFromCoordMicroTiled
*
* @brief
* Computes the surface address and bit position from a
@@ -1608,7 +1613,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::ComputeMacroTileEquation(
* The byte address
****************************************************************************************************
*/
-UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMacroTiled(
+UINT_64 EgBasedLib::ComputeSurfaceAddrFromCoordMacroTiled(
UINT_32 x, ///< [in] x coordinate
UINT_32 y, ///< [in] y coordinate
UINT_32 slice, ///< [in] slice index
@@ -1874,7 +1879,7 @@ UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMacroTiled(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled
+* EgBasedLib::ComputeSurfaceAddrFromCoordMicroTiled
*
* @brief
* Computes the surface address and bit position from a coordinate for 1D tilied
@@ -1883,7 +1888,7 @@ UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMacroTiled(
* The byte address
****************************************************************************************************
*/
-UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled(
+UINT_64 EgBasedLib::ComputeSurfaceAddrFromCoordMicroTiled(
UINT_32 x, ///< [in] x coordinate
UINT_32 y, ///< [in] y coordinate
UINT_32 slice, ///< [in] slice index
@@ -1999,7 +2004,7 @@ UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlComputePixelCoordFromOffset
+* EgBasedLib::HwlComputePixelCoordFromOffset
*
* @brief
* Compute pixel coordinate from offset inside a micro tile
@@ -2007,7 +2012,7 @@ UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled(
* N/A
****************************************************************************************************
*/
-VOID EgBasedAddrLib::HwlComputePixelCoordFromOffset(
+VOID EgBasedLib::HwlComputePixelCoordFromOffset(
UINT_32 offset, ///< [in] offset inside micro tile in bits
UINT_32 bpp, ///< [in] bits per pixel
UINT_32 numSamples, ///< [in] number of samples
@@ -2188,7 +2193,7 @@ VOID EgBasedAddrLib::HwlComputePixelCoordFromOffset(
/**
****************************************************************************************************
-* EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddrDispatch
+* EgBasedLib::DispatchComputeSurfaceCoordFromAddrDispatch
*
* @brief
* Compute (x,y,slice,sample) coordinates from surface address
@@ -2196,7 +2201,7 @@ VOID EgBasedAddrLib::HwlComputePixelCoordFromOffset(
* N/A
****************************************************************************************************
*/
-VOID EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddr(
+VOID EgBasedLib::DispatchComputeSurfaceCoordFromAddr(
const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
) const
@@ -2333,7 +2338,7 @@ VOID EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddr(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled
+* EgBasedLib::ComputeSurfaceCoordFromAddrMacroTiled
*
* @brief
* Compute surface coordinates from address for macro tiled surface
@@ -2341,7 +2346,7 @@ VOID EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddr(
* N/A
****************************************************************************************************
*/
-VOID EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled(
+VOID EgBasedLib::ComputeSurfaceCoordFromAddrMacroTiled(
UINT_64 addr, ///< [in] byte address
UINT_32 bitPosition, ///< [in] bit position
UINT_32 bpp, ///< [in] bits per pixel
@@ -2491,7 +2496,7 @@ VOID EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeSurfaceCoord2DFromBankPipe
+* EgBasedLib::ComputeSurfaceCoord2DFromBankPipe
*
* @brief
* Compute surface x,y coordinates from bank/pipe info
@@ -2499,7 +2504,7 @@ VOID EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled(
* N/A
****************************************************************************************************
*/
-VOID EgBasedAddrLib::ComputeSurfaceCoord2DFromBankPipe(
+VOID EgBasedLib::ComputeSurfaceCoord2DFromBankPipe(
AddrTileMode tileMode, ///< [in] tile mode
UINT_32 x, ///< [in] x coordinate
UINT_32 y, ///< [in] y coordinate
@@ -2677,14 +2682,14 @@ VOID EgBasedAddrLib::ComputeSurfaceCoord2DFromBankPipe(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlExtractBankPipeSwizzle
+* EgBasedLib::HwlExtractBankPipeSwizzle
* @brief
-* Entry of EgBasedAddrLib ExtractBankPipeSwizzle
+* Entry of EgBasedLib ExtractBankPipeSwizzle
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlExtractBankPipeSwizzle(
+ADDR_E_RETURNCODE EgBasedLib::HwlExtractBankPipeSwizzle(
const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn, ///< [in] input structure
ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT* pOut ///< [out] output structure
) const
@@ -2700,14 +2705,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlExtractBankPipeSwizzle(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlCombineBankPipeSwizzle
+* EgBasedLib::HwlCombineBankPipeSwizzle
* @brief
* Combine bank/pipe swizzle
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlCombineBankPipeSwizzle(
+ADDR_E_RETURNCODE EgBasedLib::HwlCombineBankPipeSwizzle(
UINT_32 bankSwizzle, ///< [in] bank swizzle
UINT_32 pipeSwizzle, ///< [in] pipe swizzle
ADDR_TILEINFO* pTileInfo, ///< [in] tile info
@@ -2731,14 +2736,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlCombineBankPipeSwizzle(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlComputeBaseSwizzle
+* EgBasedLib::HwlComputeBaseSwizzle
* @brief
* Compute base swizzle
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeBaseSwizzle(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeBaseSwizzle(
const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn,
ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT* pOut
) const
@@ -2806,14 +2811,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeBaseSwizzle(
/**
****************************************************************************************************
-* EgBasedAddrLib::ExtractBankPipeSwizzle
+* EgBasedLib::ExtractBankPipeSwizzle
* @brief
* Extract bank/pipe swizzle from base256b
* @return
* N/A
****************************************************************************************************
*/
-VOID EgBasedAddrLib::ExtractBankPipeSwizzle(
+VOID EgBasedLib::ExtractBankPipeSwizzle(
UINT_32 base256b, ///< [in] input base256b register value
ADDR_TILEINFO* pTileInfo, ///< [in] 2D tile parameters. Client must provide all data
UINT_32* pBankSwizzle, ///< [out] bank swizzle
@@ -2844,14 +2849,14 @@ VOID EgBasedAddrLib::ExtractBankPipeSwizzle(
/**
****************************************************************************************************
-* EgBasedAddrLib::GetBankPipeSwizzle
+* EgBasedLib::GetBankPipeSwizzle
* @brief
* Combine bank/pipe swizzle
* @return
* Base256b bits (only filled bank/pipe bits)
****************************************************************************************************
*/
-UINT_32 EgBasedAddrLib::GetBankPipeSwizzle(
+UINT_32 EgBasedLib::GetBankPipeSwizzle(
UINT_32 bankSwizzle, ///< [in] bank swizzle
UINT_32 pipeSwizzle, ///< [in] pipe swizzle
UINT_64 baseAddr, ///< [in] base address
@@ -2870,14 +2875,14 @@ UINT_32 EgBasedAddrLib::GetBankPipeSwizzle(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeSliceTileSwizzle
+* EgBasedLib::ComputeSliceTileSwizzle
* @brief
* Compute cubemap/3d texture faces/slices tile swizzle
* @return
* Tile swizzle
****************************************************************************************************
*/
-UINT_32 EgBasedAddrLib::ComputeSliceTileSwizzle(
+UINT_32 EgBasedLib::ComputeSliceTileSwizzle(
AddrTileMode tileMode, ///< [in] Tile mode
UINT_32 baseSwizzle, ///< [in] Base swizzle
UINT_32 slice, ///< [in] Slice index, Cubemap face index, 0 means +X
@@ -2935,7 +2940,7 @@ UINT_32 EgBasedAddrLib::ComputeSliceTileSwizzle(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlComputeQbStereoRightSwizzle
+* EgBasedLib::HwlComputeQbStereoRightSwizzle
*
* @brief
* Compute right eye swizzle
@@ -2943,7 +2948,7 @@ UINT_32 EgBasedAddrLib::ComputeSliceTileSwizzle(
* swizzle
****************************************************************************************************
*/
-UINT_32 EgBasedAddrLib::HwlComputeQbStereoRightSwizzle(
+UINT_32 EgBasedLib::HwlComputeQbStereoRightSwizzle(
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pInfo ///< [in] Surface info, must be valid
) const
{
@@ -2967,7 +2972,7 @@ UINT_32 EgBasedAddrLib::HwlComputeQbStereoRightSwizzle(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeBankFromCoord
+* EgBasedLib::ComputeBankFromCoord
*
* @brief
* Compute bank number from coordinates
@@ -2975,7 +2980,7 @@ UINT_32 EgBasedAddrLib::HwlComputeQbStereoRightSwizzle(
* Bank number
****************************************************************************************************
*/
-UINT_32 EgBasedAddrLib::ComputeBankFromCoord(
+UINT_32 EgBasedLib::ComputeBankFromCoord(
UINT_32 x, ///< [in] x coordinate
UINT_32 y, ///< [in] y coordinate
UINT_32 slice, ///< [in] slice index
@@ -3099,7 +3104,7 @@ UINT_32 EgBasedAddrLib::ComputeBankFromCoord(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeBankFromAddr
+* EgBasedLib::ComputeBankFromAddr
*
* @brief
* Compute the bank number from an address
@@ -3107,7 +3112,7 @@ UINT_32 EgBasedAddrLib::ComputeBankFromCoord(
* Bank number
****************************************************************************************************
*/
-UINT_32 EgBasedAddrLib::ComputeBankFromAddr(
+UINT_32 EgBasedLib::ComputeBankFromAddr(
UINT_64 addr, ///< [in] address
UINT_32 numBanks, ///< [in] number of banks
UINT_32 numPipes ///< [in] number of pipes
@@ -3132,7 +3137,7 @@ UINT_32 EgBasedAddrLib::ComputeBankFromAddr(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputePipeRotation
+* EgBasedLib::ComputePipeRotation
*
* @brief
* Compute pipe rotation value
@@ -3140,7 +3145,7 @@ UINT_32 EgBasedAddrLib::ComputeBankFromAddr(
* Pipe rotation
****************************************************************************************************
*/
-UINT_32 EgBasedAddrLib::ComputePipeRotation(
+UINT_32 EgBasedLib::ComputePipeRotation(
AddrTileMode tileMode, ///< [in] tile mode
UINT_32 numPipes ///< [in] number of pipes
) const
@@ -3167,7 +3172,7 @@ UINT_32 EgBasedAddrLib::ComputePipeRotation(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeBankRotation
+* EgBasedLib::ComputeBankRotation
*
* @brief
* Compute bank rotation value
@@ -3175,7 +3180,7 @@ UINT_32 EgBasedAddrLib::ComputePipeRotation(
* Bank rotation
****************************************************************************************************
*/
-UINT_32 EgBasedAddrLib::ComputeBankRotation(
+UINT_32 EgBasedLib::ComputeBankRotation(
AddrTileMode tileMode, ///< [in] tile mode
UINT_32 numBanks, ///< [in] number of banks
UINT_32 numPipes ///< [in] number of pipes
@@ -3210,7 +3215,7 @@ UINT_32 EgBasedAddrLib::ComputeBankRotation(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeHtileBytes
+* EgBasedLib::ComputeHtileBytes
*
* @brief
* Compute htile size in bytes
@@ -3219,7 +3224,7 @@ UINT_32 EgBasedAddrLib::ComputeBankRotation(
* Htile size in bytes
****************************************************************************************************
*/
-UINT_64 EgBasedAddrLib::ComputeHtileBytes(
+UINT_64 EgBasedLib::ComputeHtileBytes(
UINT_32 pitch, ///< [in] pitch
UINT_32 height, ///< [in] height
UINT_32 bpp, ///< [in] bits per pixel
@@ -3253,7 +3258,7 @@ UINT_64 EgBasedAddrLib::ComputeHtileBytes(
/**
****************************************************************************************************
-* EgBasedAddrLib::DispatchComputeFmaskInfo
+* EgBasedLib::DispatchComputeFmaskInfo
*
* @brief
* Compute fmask sizes include padded pitch, height, slices, total size in bytes,
@@ -3264,7 +3269,7 @@ UINT_64 EgBasedAddrLib::ComputeHtileBytes(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE EgBasedAddrLib::DispatchComputeFmaskInfo(
+ADDR_E_RETURNCODE EgBasedLib::DispatchComputeFmaskInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut) ///< [out] output structure
{
@@ -3330,14 +3335,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::DispatchComputeFmaskInfo(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlFmaskSurfaceInfo
+* EgBasedLib::HwlFmaskSurfaceInfo
* @brief
-* Entry of EgBasedAddrLib ComputeFmaskInfo
+* Entry of EgBasedLib ComputeFmaskInfo
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskInfo(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeFmaskInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut ///< [out] output structure
)
@@ -3372,14 +3377,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskInfo(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlComputeFmaskAddrFromCoord
+* EgBasedLib::HwlComputeFmaskAddrFromCoord
* @brief
-* Entry of EgBasedAddrLib ComputeFmaskAddrFromCoord
+* Entry of EgBasedLib ComputeFmaskAddrFromCoord
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskAddrFromCoord(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeFmaskAddrFromCoord(
const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
@@ -3405,14 +3410,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskAddrFromCoord(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlComputeFmaskCoordFromAddr
+* EgBasedLib::HwlComputeFmaskCoordFromAddr
* @brief
-* Entry of EgBasedAddrLib ComputeFmaskCoordFromAddr
+* Entry of EgBasedLib ComputeFmaskCoordFromAddr
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskCoordFromAddr(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeFmaskCoordFromAddr(
const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
) const
@@ -3437,7 +3442,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskCoordFromAddr(
#if ADDR_AM_BUILD
/**
****************************************************************************************************
-* EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord
+* EgBasedLib::DispatchComputeFmaskAddrFromCoord
*
* @brief
* Computes the FMASK address and bit position from a coordinate.
@@ -3445,7 +3450,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskCoordFromAddr(
* The byte address
****************************************************************************************************
*/
-UINT_64 EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord(
+UINT_64 EgBasedLib::DispatchComputeFmaskAddrFromCoord(
const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
@@ -3526,7 +3531,7 @@ UINT_64 EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled
+* EgBasedLib::ComputeFmaskAddrFromCoordMicroTiled
*
* @brief
* Computes the FMASK address and bit position from a coordinate for 1D tilied (micro
@@ -3535,7 +3540,7 @@ UINT_64 EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord(
* The byte address
****************************************************************************************************
*/
-UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled(
+UINT_64 EgBasedLib::ComputeFmaskAddrFromCoordMicroTiled(
UINT_32 x, ///< [in] x coordinate
UINT_32 y, ///< [in] y coordinate
UINT_32 slice, ///< [in] slice index
@@ -3634,7 +3639,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled
+* EgBasedLib::ComputeFmaskAddrFromCoordMacroTiled
*
* @brief
* Computes the FMASK address and bit position from a coordinate for 2D tilied (macro
@@ -3643,7 +3648,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled(
* The byte address
****************************************************************************************************
*/
-UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled(
+UINT_64 EgBasedLib::ComputeFmaskAddrFromCoordMacroTiled(
UINT_32 x, ///< [in] x coordinate
UINT_32 y, ///< [in] y coordinate
UINT_32 slice, ///< [in] slice index
@@ -3756,7 +3761,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled
+* EgBasedLib::ComputeFmaskCoordFromAddrMicroTiled
*
* @brief
* Compute (x,y,slice,sample,plane) coordinates from fmask address
@@ -3765,7 +3770,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled(
*
****************************************************************************************************
*/
-VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled(
+VOID EgBasedLib::ComputeFmaskCoordFromAddrMicroTiled(
UINT_64 addr, ///< [in] byte address
UINT_32 bitPosition,///< [in] bit position
UINT_32 pitch, ///< [in] pitch in pixels
@@ -3843,7 +3848,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled
+* EgBasedLib::ComputeFmaskCoordFromAddrMacroTiled
*
* @brief
* Compute (x,y,slice,sample,plane) coordinates from
@@ -3853,7 +3858,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled(
*
****************************************************************************************************
*/
-VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled(
+VOID EgBasedLib::ComputeFmaskCoordFromAddrMacroTiled(
UINT_64 addr, ///< [in] byte address
UINT_32 bitPosition,///< [in] bit position
UINT_32 pitch, ///< [in] pitch in pixels
@@ -3943,7 +3948,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled(
/**
****************************************************************************************************
-* EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr
+* EgBasedLib::DispatchComputeFmaskCoordFromAddr
*
* @brief
* Compute (x,y,slice,sample,plane) coordinates from
@@ -3953,7 +3958,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled(
*
****************************************************************************************************
*/
-VOID EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr(
+VOID EgBasedLib::DispatchComputeFmaskCoordFromAddr(
const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
) const
@@ -4033,7 +4038,7 @@ VOID EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples
+* EgBasedLib::ComputeFmaskNumPlanesFromNumSamples
*
* @brief
* Compute fmask number of planes from number of samples
@@ -4042,7 +4047,7 @@ VOID EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr(
* Number of planes
****************************************************************************************************
*/
-UINT_32 EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples(
+UINT_32 EgBasedLib::ComputeFmaskNumPlanesFromNumSamples(
UINT_32 numSamples) ///< [in] number of samples
{
UINT_32 numPlanes;
@@ -4078,7 +4083,7 @@ UINT_32 EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples(
/**
****************************************************************************************************
-* EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples
+* EgBasedLib::ComputeFmaskResolvedBppFromNumSamples
*
* @brief
* Compute resolved fmask effective bpp based on number of samples
@@ -4087,7 +4092,7 @@ UINT_32 EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples(
* bpp
****************************************************************************************************
*/
-UINT_32 EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples(
+UINT_32 EgBasedLib::ComputeFmaskResolvedBppFromNumSamples(
UINT_32 numSamples) ///< number of samples
{
UINT_32 bpp;
@@ -4123,7 +4128,7 @@ UINT_32 EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples(
/**
****************************************************************************************************
-* EgBasedAddrLib::IsTileInfoAllZero
+* EgBasedLib::IsTileInfoAllZero
*
* @brief
* Return TRUE if all field are zero
@@ -4131,7 +4136,7 @@ UINT_32 EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples(
* Since NULL input is consider to be all zero
****************************************************************************************************
*/
-BOOL_32 EgBasedAddrLib::IsTileInfoAllZero(
+BOOL_32 EgBasedLib::IsTileInfoAllZero(
ADDR_TILEINFO* pTileInfo)
{
BOOL_32 allZero = TRUE;
@@ -4155,7 +4160,7 @@ BOOL_32 EgBasedAddrLib::IsTileInfoAllZero(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlTileInfoEqual
+* EgBasedLib::HwlTileInfoEqual
*
* @brief
* Return TRUE if all field are equal
@@ -4163,7 +4168,7 @@ BOOL_32 EgBasedAddrLib::IsTileInfoAllZero(
* Only takes care of current HWL's data
****************************************************************************************************
*/
-BOOL_32 EgBasedAddrLib::HwlTileInfoEqual(
+BOOL_32 EgBasedLib::HwlTileInfoEqual(
const ADDR_TILEINFO* pLeft, ///<[in] Left compare operand
const ADDR_TILEINFO* pRight ///<[in] Right compare operand
) const
@@ -4184,14 +4189,14 @@ BOOL_32 EgBasedAddrLib::HwlTileInfoEqual(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlConvertTileInfoToHW
+* EgBasedLib::HwlConvertTileInfoToHW
* @brief
-* Entry of EgBasedAddrLib ConvertTileInfoToHW
+* Entry of EgBasedLib ConvertTileInfoToHW
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlConvertTileInfoToHW(
+ADDR_E_RETURNCODE EgBasedLib::HwlConvertTileInfoToHW(
const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut ///< [out] output structure
) const
@@ -4452,14 +4457,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlConvertTileInfoToHW(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlComputeSurfaceInfo
+* EgBasedLib::HwlComputeSurfaceInfo
* @brief
-* Entry of EgBasedAddrLib ComputeSurfaceInfo
+* Entry of EgBasedLib ComputeSurfaceInfo
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceInfo(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
) const
@@ -4539,14 +4544,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceInfo(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlComputeSurfaceAddrFromCoord
+* EgBasedLib::HwlComputeSurfaceAddrFromCoord
* @brief
-* Entry of EgBasedAddrLib ComputeSurfaceAddrFromCoord
+* Entry of EgBasedLib ComputeSurfaceAddrFromCoord
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceAddrFromCoord(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeSurfaceAddrFromCoord(
const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
@@ -4572,14 +4577,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceAddrFromCoord(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlComputeSurfaceCoordFromAddr
+* EgBasedLib::HwlComputeSurfaceCoordFromAddr
* @brief
-* Entry of EgBasedAddrLib ComputeSurfaceCoordFromAddr
+* Entry of EgBasedLib ComputeSurfaceCoordFromAddr
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceCoordFromAddr(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeSurfaceCoordFromAddr(
const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
) const
@@ -4600,14 +4605,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceCoordFromAddr(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlComputeSliceTileSwizzle
+* EgBasedLib::HwlComputeSliceTileSwizzle
* @brief
-* Entry of EgBasedAddrLib ComputeSurfaceCoordFromAddr
+* Entry of EgBasedLib ComputeSurfaceCoordFromAddr
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSliceTileSwizzle(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeSliceTileSwizzle(
const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_SLICESWIZZLE_OUTPUT* pOut ///< [out] output structure
) const
@@ -4633,7 +4638,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSliceTileSwizzle(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlComputeHtileBpp
+* EgBasedLib::HwlComputeHtileBpp
*
* @brief
* Compute htile bpp
@@ -4642,7 +4647,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSliceTileSwizzle(
* Htile bpp
****************************************************************************************************
*/
-UINT_32 EgBasedAddrLib::HwlComputeHtileBpp(
+UINT_32 EgBasedLib::HwlComputeHtileBpp(
BOOL_32 isWidth8, ///< [in] TRUE if block width is 8
BOOL_32 isHeight8 ///< [in] TRUE if block height is 8
) const
@@ -4654,7 +4659,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBpp(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlComputeHtileBaseAlign
+* EgBasedLib::HwlComputeHtileBaseAlign
*
* @brief
* Compute htile base alignment
@@ -4663,7 +4668,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBpp(
* Htile base alignment
****************************************************************************************************
*/
-UINT_32 EgBasedAddrLib::HwlComputeHtileBaseAlign(
+UINT_32 EgBasedLib::HwlComputeHtileBaseAlign(
BOOL_32 isTcCompatible, ///< [in] if TC compatible
BOOL_32 isLinear, ///< [in] if it is linear mode
ADDR_TILEINFO* pTileInfo ///< [in] Tile info
@@ -4685,7 +4690,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBaseAlign(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled
+* EgBasedLib::HwlGetPitchAlignmentMicroTiled
*
* @brief
* Compute 1D tiled surface pitch alignment, calculation results are returned through
@@ -4695,7 +4700,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBaseAlign(
* pitch alignment
****************************************************************************************************
*/
-UINT_32 EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(
+UINT_32 EgBasedLib::HwlGetPitchAlignmentMicroTiled(
AddrTileMode tileMode, ///< [in] tile mode
UINT_32 bpp, ///< [in] bits per pixel
ADDR_SURFACE_FLAGS flags, ///< [in] surface flags
@@ -4734,7 +4739,7 @@ UINT_32 EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled
+* EgBasedLib::HwlGetSizeAdjustmentMicroTiled
*
* @brief
* Adjust 1D tiled surface pitch and slice size
@@ -4743,7 +4748,7 @@ UINT_32 EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(
* Logical slice size in bytes
****************************************************************************************************
*/
-UINT_64 EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled(
+UINT_64 EgBasedLib::HwlGetSizeAdjustmentMicroTiled(
UINT_32 thickness, ///< [in] thickness
UINT_32 bpp, ///< [in] bits per pixel
ADDR_SURFACE_FLAGS flags, ///< [in] surface flags
@@ -4776,7 +4781,7 @@ UINT_64 EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled(
/**
****************************************************************************************************
-* EgBasedAddrLib::HwlStereoCheckRightOffsetPadding
+* EgBasedLib::HwlStereoCheckRightOffsetPadding
*
* @brief
* check if the height needs extra padding for stereo right eye offset, to avoid swizzling
@@ -4786,7 +4791,7 @@ UINT_64 EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled(
*
****************************************************************************************************
*/
-UINT_32 EgBasedAddrLib::HwlStereoCheckRightOffsetPadding(
+UINT_32 EgBasedLib::HwlStereoCheckRightOffsetPadding(
ADDR_TILEINFO* pTileInfo ///< Tiling info
) const
{
@@ -4809,3 +4814,5 @@ UINT_32 EgBasedAddrLib::HwlStereoCheckRightOffsetPadding(
return stereoHeightAlign;
}
+} // V1
+} // Addr
diff --git a/src/amd/addrlib/r800/egbaddrlib.h b/src/amd/addrlib/r800/egbaddrlib.h
index 6bc6c53e874..c397cfc4f81 100644
--- a/src/amd/addrlib/r800/egbaddrlib.h
+++ b/src/amd/addrlib/r800/egbaddrlib.h
@@ -27,7 +27,7 @@
/**
****************************************************************************************************
* @file egbaddrlib.h
-* @brief Contains the EgBasedAddrLib class definition.
+* @brief Contains the EgBasedLib class definition.
****************************************************************************************************
*/
@@ -36,7 +36,10 @@
#include "addrlib1.h"
-
+namespace Addr
+{
+namespace V1
+{
/// Structures for functions
struct CoordFromBankPipe
{
@@ -58,11 +61,11 @@ struct CoordFromBankPipe
* @note Abstract class
****************************************************************************************************
*/
-class EgBasedAddrLib : public AddrLib1
+class EgBasedLib : public Lib
{
protected:
- EgBasedAddrLib(const AddrClient* pClient);
- virtual ~EgBasedAddrLib();
+ EgBasedLib(const Client* pClient);
+ virtual ~EgBasedLib();
public:
@@ -415,5 +418,8 @@ protected:
UINT_32 m_bankInterleave; ///< Bank interleave, as a multiple of pipe interleave size
};
+} // V1
+} // Addr
+
#endif
diff --git a/src/amd/addrlib/r800/siaddrlib.cpp b/src/amd/addrlib/r800/siaddrlib.cpp
index 964f2fd28cc..9d3f5aa9367 100644
--- a/src/amd/addrlib/r800/siaddrlib.cpp
+++ b/src/amd/addrlib/r800/siaddrlib.cpp
@@ -27,7 +27,7 @@
/**
****************************************************************************************************
* @file siaddrlib.cpp
-* @brief Contains the implementation for the SiAddrLib class.
+* @brief Contains the implementation for the SiLib class.
****************************************************************************************************
*/
@@ -45,34 +45,40 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
+namespace Addr
+{
/**
****************************************************************************************************
-* AddrSiHwlInit
+* SiHwlInit
*
* @brief
-* Creates an SiAddrLib object.
+* Creates an SiLib object.
*
* @return
-* Returns an SiAddrLib object pointer.
+* Returns an SiLib object pointer.
****************************************************************************************************
*/
-AddrLib* AddrSIHwlInit(const AddrClient* pClient)
+Lib* SiHwlInit(const Client* pClient)
{
- return SiAddrLib::CreateObj(pClient);
+ return V1::SiLib::CreateObj(pClient);
}
+namespace V1
+{
+
/**
****************************************************************************************************
-* SiAddrLib::SiAddrLib
+* SiLib::SiLib
*
* @brief
* Constructor
*
****************************************************************************************************
*/
-SiAddrLib::SiAddrLib(const AddrClient* pClient) :
- EgBasedAddrLib(pClient),
+SiLib::SiLib(const Client* pClient)
+ :
+ EgBasedLib(pClient),
m_noOfEntries(0),
m_numEquations(0)
{
@@ -82,19 +88,19 @@ SiAddrLib::SiAddrLib(const AddrClient* pClient) :
/**
****************************************************************************************************
-* SiAddrLib::~SiAddrLib
+* SiLib::~SiLib
*
* @brief
* Destructor
****************************************************************************************************
*/
-SiAddrLib::~SiAddrLib()
+SiLib::~SiLib()
{
}
/**
****************************************************************************************************
-* SiAddrLib::HwlGetPipes
+* SiLib::HwlGetPipes
*
* @brief
* Get number pipes
@@ -102,7 +108,7 @@ SiAddrLib::~SiAddrLib()
* num pipes
****************************************************************************************************
*/
-UINT_32 SiAddrLib::HwlGetPipes(
+UINT_32 SiLib::HwlGetPipes(
const ADDR_TILEINFO* pTileInfo ///< [in] Tile info
) const
{
@@ -123,14 +129,14 @@ UINT_32 SiAddrLib::HwlGetPipes(
/**
****************************************************************************************************
-* SiAddrLib::GetPipePerSurf
+* SiLib::GetPipePerSurf
* @brief
* get pipe num base on inputing tileinfo->pipeconfig
* @return
* pipe number
****************************************************************************************************
*/
-UINT_32 SiAddrLib::GetPipePerSurf(
+UINT_32 SiLib::GetPipePerSurf(
AddrPipeCfg pipeConfig ///< [in] pipe config
) const
{
@@ -169,7 +175,7 @@ UINT_32 SiAddrLib::GetPipePerSurf(
/**
****************************************************************************************************
-* SiAddrLib::ComputeBankEquation
+* SiLib::ComputeBankEquation
*
* @brief
* Compute bank equation
@@ -178,7 +184,7 @@ UINT_32 SiAddrLib::GetPipePerSurf(
* If equation can be computed
****************************************************************************************************
*/
-ADDR_E_RETURNCODE SiAddrLib::ComputeBankEquation(
+ADDR_E_RETURNCODE SiLib::ComputeBankEquation(
UINT_32 log2BytesPP, ///< [in] log2 of bytes per pixel
UINT_32 threshX, ///< [in] threshold for x channel
UINT_32 threshY, ///< [in] threshold for y channel
@@ -303,7 +309,7 @@ ADDR_E_RETURNCODE SiAddrLib::ComputeBankEquation(
/**
****************************************************************************************************
-* SiAddrLib::ComputePipeEquation
+* SiLib::ComputePipeEquation
*
* @brief
* Compute pipe equation
@@ -312,7 +318,7 @@ ADDR_E_RETURNCODE SiAddrLib::ComputeBankEquation(
* If equation can be computed
****************************************************************************************************
*/
-ADDR_E_RETURNCODE SiAddrLib::ComputePipeEquation(
+ADDR_E_RETURNCODE SiLib::ComputePipeEquation(
UINT_32 log2BytesPP, ///< [in] Log2 of bytes per pixel
UINT_32 threshX, ///< [in] Threshold for X channel
UINT_32 threshY, ///< [in] Threshold for Y channel
@@ -501,7 +507,7 @@ ADDR_E_RETURNCODE SiAddrLib::ComputePipeEquation(
/**
****************************************************************************************************
-* SiAddrLib::ComputePipeFromCoord
+* SiLib::ComputePipeFromCoord
*
* @brief
* Compute pipe number from coordinates
@@ -509,7 +515,7 @@ ADDR_E_RETURNCODE SiAddrLib::ComputePipeEquation(
* Pipe number
****************************************************************************************************
*/
-UINT_32 SiAddrLib::ComputePipeFromCoord(
+UINT_32 SiLib::ComputePipeFromCoord(
UINT_32 x, ///< [in] x coordinate
UINT_32 y, ///< [in] y coordinate
UINT_32 slice, ///< [in] slice index
@@ -652,7 +658,7 @@ UINT_32 SiAddrLib::ComputePipeFromCoord(
/**
****************************************************************************************************
-* SiAddrLib::ComputeTileCoordFromPipeAndElemIdx
+* SiLib::ComputeTileCoordFromPipeAndElemIdx
*
* @brief
* Compute (x,y) of a tile within a macro tile from address
@@ -660,7 +666,7 @@ UINT_32 SiAddrLib::ComputePipeFromCoord(
* Pipe number
****************************************************************************************************
*/
-VOID SiAddrLib::ComputeTileCoordFromPipeAndElemIdx(
+VOID SiLib::ComputeTileCoordFromPipeAndElemIdx(
UINT_32 elemIdx, ///< [in] per pipe element index within a macro tile
UINT_32 pipe, ///< [in] pipe index
AddrPipeCfg pipeCfg, ///< [in] pipe config
@@ -909,7 +915,7 @@ VOID SiAddrLib::ComputeTileCoordFromPipeAndElemIdx(
/**
****************************************************************************************************
-* SiAddrLib::TileCoordToMaskElementIndex
+* SiLib::TileCoordToMaskElementIndex
*
* @brief
* Compute element index from coordinates in tiles
@@ -917,7 +923,7 @@ VOID SiAddrLib::ComputeTileCoordFromPipeAndElemIdx(
* Element index
****************************************************************************************************
*/
-UINT_32 SiAddrLib::TileCoordToMaskElementIndex(
+UINT_32 SiLib::TileCoordToMaskElementIndex(
UINT_32 tx, ///< [in] x coord, in Tiles
UINT_32 ty, ///< [in] y coord, in Tiles
AddrPipeCfg pipeConfig, ///< [in] pipe config
@@ -1045,7 +1051,7 @@ UINT_32 SiAddrLib::TileCoordToMaskElementIndex(
/**
****************************************************************************************************
-* SiAddrLib::HwlComputeTileDataWidthAndHeightLinear
+* SiLib::HwlComputeTileDataWidthAndHeightLinear
*
* @brief
* Compute the squared cache shape for per-tile data (CMASK and HTILE) for linear layout
@@ -1057,7 +1063,7 @@ UINT_32 SiAddrLib::TileCoordToMaskElementIndex(
* MacroWidth and macroHeight are measured in pixels
****************************************************************************************************
*/
-VOID SiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
+VOID SiLib::HwlComputeTileDataWidthAndHeightLinear(
UINT_32* pMacroWidth, ///< [out] macro tile width
UINT_32* pMacroHeight, ///< [out] macro tile height
UINT_32 bpp, ///< [in] bits per pixel
@@ -1091,7 +1097,7 @@ VOID SiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
/**
****************************************************************************************************
-* SiAddrLib::HwlComputeHtileBytes
+* SiLib::HwlComputeHtileBytes
*
* @brief
* Compute htile size in bytes
@@ -1100,7 +1106,7 @@ VOID SiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
* Htile size in bytes
****************************************************************************************************
*/
-UINT_64 SiAddrLib::HwlComputeHtileBytes(
+UINT_64 SiLib::HwlComputeHtileBytes(
UINT_32 pitch, ///< [in] pitch
UINT_32 height, ///< [in] height
UINT_32 bpp, ///< [in] bits per pixel
@@ -1115,7 +1121,7 @@ UINT_64 SiAddrLib::HwlComputeHtileBytes(
/**
****************************************************************************************************
-* SiAddrLib::HwlComputeXmaskAddrFromCoord
+* SiLib::HwlComputeXmaskAddrFromCoord
*
* @brief
* Compute address from coordinates for htile/cmask
@@ -1123,7 +1129,7 @@ UINT_64 SiAddrLib::HwlComputeHtileBytes(
* Byte address
****************************************************************************************************
*/
-UINT_64 SiAddrLib::HwlComputeXmaskAddrFromCoord(
+UINT_64 SiLib::HwlComputeXmaskAddrFromCoord(
UINT_32 pitch, ///< [in] pitch
UINT_32 height, ///< [in] height
UINT_32 x, ///< [in] x coord
@@ -1270,7 +1276,7 @@ UINT_64 SiAddrLib::HwlComputeXmaskAddrFromCoord(
/**
****************************************************************************************************
-* SiAddrLib::HwlComputeXmaskCoordFromAddr
+* SiLib::HwlComputeXmaskCoordFromAddr
*
* @brief
* Compute the coord from an address of a cmask/htile
@@ -1282,7 +1288,7 @@ UINT_64 SiAddrLib::HwlComputeXmaskAddrFromCoord(
* This method is reused by htile, so rename to Xmask
****************************************************************************************************
*/
-VOID SiAddrLib::HwlComputeXmaskCoordFromAddr(
+VOID SiLib::HwlComputeXmaskCoordFromAddr(
UINT_64 addr, ///< [in] address
UINT_32 bitPosition, ///< [in] bitPosition in a byte
UINT_32 pitch, ///< [in] pitch
@@ -1476,14 +1482,14 @@ VOID SiAddrLib::HwlComputeXmaskCoordFromAddr(
/**
****************************************************************************************************
-* SiAddrLib::HwlGetPitchAlignmentLinear
+* SiLib::HwlGetPitchAlignmentLinear
* @brief
* Get pitch alignment
* @return
* pitch alignment
****************************************************************************************************
*/
-UINT_32 SiAddrLib::HwlGetPitchAlignmentLinear(
+UINT_32 SiLib::HwlGetPitchAlignmentLinear(
UINT_32 bpp, ///< [in] bits per pixel
ADDR_SURFACE_FLAGS flags ///< [in] surface flags
) const
@@ -1506,7 +1512,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentLinear(
/**
****************************************************************************************************
-* SiAddrLib::HwlGetSizeAdjustmentLinear
+* SiLib::HwlGetSizeAdjustmentLinear
*
* @brief
* Adjust linear surface pitch and slice size
@@ -1515,7 +1521,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentLinear(
* Logical slice size in bytes
****************************************************************************************************
*/
-UINT_64 SiAddrLib::HwlGetSizeAdjustmentLinear(
+UINT_64 SiLib::HwlGetSizeAdjustmentLinear(
AddrTileMode tileMode, ///< [in] tile mode
UINT_32 bpp, ///< [in] bits per pixel
UINT_32 numSamples, ///< [in] number of samples
@@ -1567,7 +1573,7 @@ UINT_64 SiAddrLib::HwlGetSizeAdjustmentLinear(
/**
****************************************************************************************************
-* SiAddrLib::HwlPreHandleBaseLvl3xPitch
+* SiLib::HwlPreHandleBaseLvl3xPitch
*
* @brief
* Pre-handler of 3x pitch (96 bit) adjustment
@@ -1576,7 +1582,7 @@ UINT_64 SiAddrLib::HwlGetSizeAdjustmentLinear(
* Expected pitch
****************************************************************************************************
*/
-UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
+UINT_32 SiLib::HwlPreHandleBaseLvl3xPitch(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input
UINT_32 expPitch ///< [in] pitch
) const
@@ -1587,7 +1593,7 @@ UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
// do here
if (pIn->flags.pow2Pad == FALSE)
{
- AddrLib1::HwlPreHandleBaseLvl3xPitch(pIn, expPitch);
+ Addr::V1::Lib::HwlPreHandleBaseLvl3xPitch(pIn, expPitch);
}
else
{
@@ -1599,7 +1605,7 @@ UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
/**
****************************************************************************************************
-* SiAddrLib::HwlPostHandleBaseLvl3xPitch
+* SiLib::HwlPostHandleBaseLvl3xPitch
*
* @brief
* Post-handler of 3x pitch adjustment
@@ -1608,7 +1614,7 @@ UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
* Expected pitch
****************************************************************************************************
*/
-UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
+UINT_32 SiLib::HwlPostHandleBaseLvl3xPitch(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input
UINT_32 expPitch ///< [in] pitch
) const
@@ -1620,7 +1626,7 @@ UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
// From SI, the pitch is expanded 3x first, then padded to pow2, so no special handler here
if (pIn->flags.pow2Pad == FALSE)
{
- AddrLib1::HwlPostHandleBaseLvl3xPitch(pIn, expPitch);
+ Addr::V1::Lib::HwlPostHandleBaseLvl3xPitch(pIn, expPitch);
}
return expPitch;
@@ -1628,7 +1634,7 @@ UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
/**
****************************************************************************************************
-* SiAddrLib::HwlGetPitchAlignmentMicroTiled
+* SiLib::HwlGetPitchAlignmentMicroTiled
*
* @brief
* Compute 1D tiled surface pitch alignment
@@ -1637,7 +1643,7 @@ UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
* pitch alignment
****************************************************************************************************
*/
-UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
+UINT_32 SiLib::HwlGetPitchAlignmentMicroTiled(
AddrTileMode tileMode, ///< [in] tile mode
UINT_32 bpp, ///< [in] bits per pixel
ADDR_SURFACE_FLAGS flags, ///< [in] surface flags
@@ -1648,7 +1654,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
if (flags.qbStereo)
{
- pitchAlign = EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(tileMode,bpp,flags,numSamples);
+ pitchAlign = EgBasedLib::HwlGetPitchAlignmentMicroTiled(tileMode,bpp,flags,numSamples);
}
else
{
@@ -1660,7 +1666,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
/**
****************************************************************************************************
-* SiAddrLib::HwlGetSizeAdjustmentMicroTiled
+* SiLib::HwlGetSizeAdjustmentMicroTiled
*
* @brief
* Adjust 1D tiled surface pitch and slice size
@@ -1669,7 +1675,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
* Logical slice size in bytes
****************************************************************************************************
*/
-UINT_64 SiAddrLib::HwlGetSizeAdjustmentMicroTiled(
+UINT_64 SiLib::HwlGetSizeAdjustmentMicroTiled(
UINT_32 thickness, ///< [in] thickness
UINT_32 bpp, ///< [in] bits per pixel
ADDR_SURFACE_FLAGS flags, ///< [in] surface flags
@@ -1740,19 +1746,19 @@ UINT_64 SiAddrLib::HwlGetSizeAdjustmentMicroTiled(
/**
****************************************************************************************************
-* SiAddrLib::HwlConvertChipFamily
+* SiLib::HwlConvertChipFamily
*
* @brief
-* Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
+* Convert familyID defined in atiid.h to ChipFamily and set m_chipFamily/m_chipRevision
* @return
-* AddrChipFamily
+* ChipFamily
****************************************************************************************************
*/
-AddrChipFamily SiAddrLib::HwlConvertChipFamily(
+ChipFamily SiLib::HwlConvertChipFamily(
UINT_32 uChipFamily, ///< [in] chip family defined in atiih.h
UINT_32 uChipRevision) ///< [in] chip revision defined in "asic_family"_id.h
{
- AddrChipFamily family = ADDR_CHIP_FAMILY_SI;
+ ChipFamily family = ADDR_CHIP_FAMILY_SI;
switch (uChipFamily)
{
@@ -1774,13 +1780,13 @@ AddrChipFamily SiAddrLib::HwlConvertChipFamily(
/**
****************************************************************************************************
-* SiAddrLib::HwlSetupTileInfo
+* SiLib::HwlSetupTileInfo
*
* @brief
* Setup default value of tile info for SI
****************************************************************************************************
*/
-VOID SiAddrLib::HwlSetupTileInfo(
+VOID SiLib::HwlSetupTileInfo(
AddrTileMode tileMode, ///< [in] Tile mode
ADDR_SURFACE_FLAGS flags, ///< [in] Surface type flags
UINT_32 bpp, ///< [in] Bits per pixel
@@ -2097,7 +2103,7 @@ VOID SiAddrLib::HwlSetupTileInfo(
/**
****************************************************************************************************
-* SiAddrLib::DecodeGbRegs
+* SiLib::DecodeGbRegs
*
* @brief
* Decodes GB_ADDR_CONFIG and noOfBanks/noOfRanks
@@ -2107,7 +2113,7 @@ VOID SiAddrLib::HwlSetupTileInfo(
*
****************************************************************************************************
*/
-BOOL_32 SiAddrLib::DecodeGbRegs(
+BOOL_32 SiLib::DecodeGbRegs(
const ADDR_REGISTER_VALUE* pRegValue) ///< [in] create input
{
GB_ADDR_CONFIG reg;
@@ -2186,7 +2192,7 @@ BOOL_32 SiAddrLib::DecodeGbRegs(
/**
****************************************************************************************************
-* SiAddrLib::HwlInitGlobalParams
+* SiLib::HwlInitGlobalParams
*
* @brief
* Initializes global parameters
@@ -2196,7 +2202,7 @@ BOOL_32 SiAddrLib::DecodeGbRegs(
*
****************************************************************************************************
*/
-BOOL_32 SiAddrLib::HwlInitGlobalParams(
+BOOL_32 SiLib::HwlInitGlobalParams(
const ADDR_CREATE_INPUT* pCreateIn) ///< [in] create input
{
BOOL_32 valid = TRUE;
@@ -2235,21 +2241,21 @@ BOOL_32 SiAddrLib::HwlInitGlobalParams(
/**
****************************************************************************************************
-* SiAddrLib::HwlConvertTileInfoToHW
+* SiLib::HwlConvertTileInfoToHW
* @brief
* Entry of si's ConvertTileInfoToHW
* @return
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE SiAddrLib::HwlConvertTileInfoToHW(
+ADDR_E_RETURNCODE SiLib::HwlConvertTileInfoToHW(
const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut ///< [out] output structure
) const
{
ADDR_E_RETURNCODE retCode = ADDR_OK;
- retCode = EgBasedAddrLib::HwlConvertTileInfoToHW(pIn, pOut);
+ retCode = EgBasedLib::HwlConvertTileInfoToHW(pIn, pOut);
if (retCode == ADDR_OK)
{
@@ -2277,7 +2283,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlConvertTileInfoToHW(
/**
****************************************************************************************************
-* SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe
+* SiLib::HwlComputeXmaskCoordYFrom8Pipe
*
* @brief
* Compute the Y coord which will be added to Xmask Y
@@ -2286,7 +2292,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlConvertTileInfoToHW(
* Y coord
****************************************************************************************************
*/
-UINT_32 SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe(
+UINT_32 SiLib::HwlComputeXmaskCoordYFrom8Pipe(
UINT_32 pipe, ///< [in] pipe id
UINT_32 x ///< [in] tile coord x, which is original x coord / 8
) const
@@ -2300,7 +2306,7 @@ UINT_32 SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe(
/**
****************************************************************************************************
-* SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe
+* SiLib::HwlComputeSurfaceCoord2DFromBankPipe
*
* @brief
* Compute surface x,y coordinates from bank/pipe info
@@ -2308,7 +2314,7 @@ UINT_32 SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe(
* N/A
****************************************************************************************************
*/
-VOID SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe(
+VOID SiLib::HwlComputeSurfaceCoord2DFromBankPipe(
AddrTileMode tileMode, ///< [in] tile mode
UINT_32* pX, ///< [in/out] x coordinate
UINT_32* pY, ///< [in/out] y coordinate
@@ -2465,7 +2471,7 @@ VOID SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe(
/**
****************************************************************************************************
-* SiAddrLib::HwlPreAdjustBank
+* SiLib::HwlPreAdjustBank
*
* @brief
* Adjust bank before calculating address acoording to bank/pipe
@@ -2473,7 +2479,7 @@ VOID SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe(
* Adjusted bank
****************************************************************************************************
*/
-UINT_32 SiAddrLib::HwlPreAdjustBank(
+UINT_32 SiLib::HwlPreAdjustBank(
UINT_32 tileX, ///< [in] x coordinate in unit of tile
UINT_32 bank, ///< [in] bank
ADDR_TILEINFO* pTileInfo ///< [in] tile info
@@ -2497,7 +2503,7 @@ UINT_32 SiAddrLib::HwlPreAdjustBank(
/**
****************************************************************************************************
-* SiAddrLib::HwlComputeSurfaceInfo
+* SiLib::HwlComputeSurfaceInfo
*
* @brief
* Entry of si's ComputeSurfaceInfo
@@ -2505,14 +2511,14 @@ UINT_32 SiAddrLib::HwlPreAdjustBank(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE SiAddrLib::HwlComputeSurfaceInfo(
+ADDR_E_RETURNCODE SiLib::HwlComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
) const
{
pOut->tileIndex = pIn->tileIndex;
- ADDR_E_RETURNCODE retCode = EgBasedAddrLib::HwlComputeSurfaceInfo(pIn, pOut);
+ ADDR_E_RETURNCODE retCode = EgBasedLib::HwlComputeSurfaceInfo(pIn, pOut);
UINT_32 tileIndex = static_cast<UINT_32>(pOut->tileIndex);
@@ -2541,14 +2547,14 @@ ADDR_E_RETURNCODE SiAddrLib::HwlComputeSurfaceInfo(
/**
****************************************************************************************************
-* SiAddrLib::HwlComputeMipLevel
+* SiLib::HwlComputeMipLevel
* @brief
* Compute MipLevel info (including level 0)
* @return
* TRUE if HWL's handled
****************************************************************************************************
*/
-BOOL_32 SiAddrLib::HwlComputeMipLevel(
+BOOL_32 SiLib::HwlComputeMipLevel(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn ///< [in/out] Input structure
) const
{
@@ -2558,7 +2564,7 @@ BOOL_32 SiAddrLib::HwlComputeMipLevel(
// Note: Don't check expand 3x formats(96 bit) as the basePitch is not pow2 even if
// we explicity set pow2Pad flag. The 3x base pitch is padded to pow2 but after being
// divided by expandX factor (3) - to program texture pitch, the basePitch is never pow2.
- if (AddrElemLib::IsExpand3x(pIn->format) == FALSE)
+ if (ElemLib::IsExpand3x(pIn->format) == FALSE)
{
// Sublevel pitches are generated from base level pitch instead of width on SI
// If pow2Pad is 0, we don't assert - as this is not really used for a mip chain
@@ -2579,7 +2585,7 @@ BOOL_32 SiAddrLib::HwlComputeMipLevel(
/**
****************************************************************************************************
-* SiAddrLib::HwlCheckLastMacroTiledLvl
+* SiLib::HwlCheckLastMacroTiledLvl
*
* @brief
* Sets pOut->last2DLevel to TRUE if it is
@@ -2587,7 +2593,7 @@ BOOL_32 SiAddrLib::HwlComputeMipLevel(
*
****************************************************************************************************
*/
-VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
+VOID SiLib::HwlCheckLastMacroTiledLvl(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [in/out] Output structure (used as input, too)
) const
@@ -2622,7 +2628,7 @@ VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
nextHeight = pOut->height >> 1;
// Special format such as FMT_1 and FMT_32_32_32 can be linear only so we consider block
// compressed foramts
- if (AddrElemLib::IsBlockCompressed(pIn->format))
+ if (ElemLib::IsBlockCompressed(pIn->format))
{
nextHeight = (nextHeight + 3) / 4;
}
@@ -2654,7 +2660,7 @@ VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
/**
****************************************************************************************************
-* SiAddrLib::HwlDegradeThickTileMode
+* SiLib::HwlDegradeThickTileMode
*
* @brief
* Degrades valid tile mode for thick modes if needed
@@ -2663,18 +2669,18 @@ VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
* Suitable tile mode
****************************************************************************************************
*/
-AddrTileMode SiAddrLib::HwlDegradeThickTileMode(
+AddrTileMode SiLib::HwlDegradeThickTileMode(
AddrTileMode baseTileMode, ///< [in] base tile mode
UINT_32 numSlices, ///< [in] current number of slices
UINT_32* pBytesPerTile ///< [in/out] pointer to bytes per slice
) const
{
- return EgBasedAddrLib::HwlDegradeThickTileMode(baseTileMode, numSlices, pBytesPerTile);
+ return EgBasedLib::HwlDegradeThickTileMode(baseTileMode, numSlices, pBytesPerTile);
}
/**
****************************************************************************************************
-* SiAddrLib::HwlTileInfoEqual
+* SiLib::HwlTileInfoEqual
*
* @brief
* Return TRUE if all field are equal
@@ -2682,7 +2688,7 @@ AddrTileMode SiAddrLib::HwlDegradeThickTileMode(
* Only takes care of current HWL's data
****************************************************************************************************
*/
-BOOL_32 SiAddrLib::HwlTileInfoEqual(
+BOOL_32 SiLib::HwlTileInfoEqual(
const ADDR_TILEINFO* pLeft, ///<[in] Left compare operand
const ADDR_TILEINFO* pRight ///<[in] Right compare operand
) const
@@ -2691,7 +2697,7 @@ BOOL_32 SiAddrLib::HwlTileInfoEqual(
if (pLeft->pipeConfig == pRight->pipeConfig)
{
- equal = EgBasedAddrLib::HwlTileInfoEqual(pLeft, pRight);
+ equal = EgBasedLib::HwlTileInfoEqual(pLeft, pRight);
}
return equal;
@@ -2699,7 +2705,7 @@ BOOL_32 SiAddrLib::HwlTileInfoEqual(
/**
****************************************************************************************************
-* SiAddrLib::GetTileSettings
+* SiLib::GetTileSettings
*
* @brief
* Get tile setting infos by index.
@@ -2707,7 +2713,7 @@ BOOL_32 SiAddrLib::HwlTileInfoEqual(
* Tile setting info.
****************************************************************************************************
*/
-const AddrTileConfig* SiAddrLib::GetTileSetting(
+const TileConfig* SiLib::GetTileSetting(
UINT_32 index ///< [in] Tile index
) const
{
@@ -2717,7 +2723,7 @@ const AddrTileConfig* SiAddrLib::GetTileSetting(
/**
****************************************************************************************************
-* SiAddrLib::HwlPostCheckTileIndex
+* SiLib::HwlPostCheckTileIndex
*
* @brief
* Map a tile setting to index if curIndex is invalid, otherwise check if curIndex matches
@@ -2726,7 +2732,7 @@ const AddrTileConfig* SiAddrLib::GetTileSetting(
* Tile index.
****************************************************************************************************
*/
-INT_32 SiAddrLib::HwlPostCheckTileIndex(
+INT_32 SiLib::HwlPostCheckTileIndex(
const ADDR_TILEINFO* pInfo, ///< [in] Tile Info
AddrTileMode mode, ///< [in] Tile mode
AddrTileType type, ///< [in] Tile type
@@ -2796,7 +2802,7 @@ INT_32 SiAddrLib::HwlPostCheckTileIndex(
/**
****************************************************************************************************
-* SiAddrLib::HwlSetupTileCfg
+* SiLib::HwlSetupTileCfg
*
* @brief
* Map tile index to tile setting.
@@ -2804,7 +2810,7 @@ INT_32 SiAddrLib::HwlPostCheckTileIndex(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE SiAddrLib::HwlSetupTileCfg(
+ADDR_E_RETURNCODE SiLib::HwlSetupTileCfg(
UINT_32 bpp, ///< [in] Bits per pixel
INT_32 index, ///< [in] Tile index
INT_32 macroModeIndex, ///< [in] Index in macro tile mode table(CI)
@@ -2846,7 +2852,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlSetupTileCfg(
}
else
{
- const AddrTileConfig* pCfgTable = GetTileSetting(index);
+ const TileConfig* pCfgTable = GetTileSetting(index);
if (pInfo)
{
@@ -2877,17 +2883,17 @@ ADDR_E_RETURNCODE SiAddrLib::HwlSetupTileCfg(
/**
****************************************************************************************************
-* SiAddrLib::ReadGbTileMode
+* SiLib::ReadGbTileMode
*
* @brief
-* Convert GB_TILE_MODE HW value to ADDR_TILE_CONFIG.
+* Convert GB_TILE_MODE HW value to TileConfig.
* @return
* NA.
****************************************************************************************************
*/
-VOID SiAddrLib::ReadGbTileMode(
- UINT_32 regValue, ///< [in] GB_TILE_MODE register
- AddrTileConfig* pCfg ///< [out] output structure
+VOID SiLib::ReadGbTileMode(
+ UINT_32 regValue, ///< [in] GB_TILE_MODE register
+ TileConfig* pCfg ///< [out] output structure
) const
{
GB_TILE_MODE gbTileMode;
@@ -2917,7 +2923,7 @@ VOID SiAddrLib::ReadGbTileMode(
/**
****************************************************************************************************
-* SiAddrLib::InitTileSettingTable
+* SiLib::InitTileSettingTable
*
* @brief
* Initialize the ADDR_TILE_CONFIG table.
@@ -2925,7 +2931,7 @@ VOID SiAddrLib::ReadGbTileMode(
* TRUE if tile table is correctly initialized
****************************************************************************************************
*/
-BOOL_32 SiAddrLib::InitTileSettingTable(
+BOOL_32 SiLib::InitTileSettingTable(
const UINT_32* pCfg, ///< [in] Pointer to table of tile configs
UINT_32 noOfEntries ///< [in] Numbe of entries in the table above
)
@@ -2968,7 +2974,7 @@ BOOL_32 SiAddrLib::InitTileSettingTable(
/**
****************************************************************************************************
-* SiAddrLib::HwlGetTileIndex
+* SiLib::HwlGetTileIndex
*
* @brief
* Return the virtual/real index for given mode/type/info
@@ -2976,7 +2982,7 @@ BOOL_32 SiAddrLib::InitTileSettingTable(
* ADDR_OK if successful.
****************************************************************************************************
*/
-ADDR_E_RETURNCODE SiAddrLib::HwlGetTileIndex(
+ADDR_E_RETURNCODE SiLib::HwlGetTileIndex(
const ADDR_GET_TILEINDEX_INPUT* pIn,
ADDR_GET_TILEINDEX_OUTPUT* pOut) const
{
@@ -2989,7 +2995,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlGetTileIndex(
/**
****************************************************************************************************
-* SiAddrLib::HwlFmaskPreThunkSurfInfo
+* SiLib::HwlFmaskPreThunkSurfInfo
*
* @brief
* Some preparation before thunking a ComputeSurfaceInfo call for Fmask
@@ -2997,7 +3003,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlGetTileIndex(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-VOID SiAddrLib::HwlFmaskPreThunkSurfInfo(
+VOID SiLib::HwlFmaskPreThunkSurfInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pFmaskIn, ///< [in] Input of fmask info
const ADDR_COMPUTE_FMASK_INFO_OUTPUT* pFmaskOut, ///< [in] Output of fmask info
ADDR_COMPUTE_SURFACE_INFO_INPUT* pSurfIn, ///< [out] Input of thunked surface info
@@ -3009,7 +3015,7 @@ VOID SiAddrLib::HwlFmaskPreThunkSurfInfo(
/**
****************************************************************************************************
-* SiAddrLib::HwlFmaskPostThunkSurfInfo
+* SiLib::HwlFmaskPostThunkSurfInfo
*
* @brief
* Copy hwl extra field after calling thunked ComputeSurfaceInfo
@@ -3017,7 +3023,7 @@ VOID SiAddrLib::HwlFmaskPreThunkSurfInfo(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-VOID SiAddrLib::HwlFmaskPostThunkSurfInfo(
+VOID SiLib::HwlFmaskPostThunkSurfInfo(
const ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pSurfOut, ///< [in] Output of surface info
ADDR_COMPUTE_FMASK_INFO_OUTPUT* pFmaskOut ///< [out] Output of fmask info
) const
@@ -3028,14 +3034,14 @@ VOID SiAddrLib::HwlFmaskPostThunkSurfInfo(
/**
****************************************************************************************************
-* SiAddrLib::HwlComputeFmaskBits
+* SiLib::HwlComputeFmaskBits
* @brief
* Computes fmask bits
* @return
* Fmask bits
****************************************************************************************************
*/
-UINT_32 SiAddrLib::HwlComputeFmaskBits(
+UINT_32 SiLib::HwlComputeFmaskBits(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn,
UINT_32* pNumSamples
) const
@@ -3129,7 +3135,7 @@ UINT_32 SiAddrLib::HwlComputeFmaskBits(
/**
****************************************************************************************************
-* SiAddrLib::HwlOverrideTileMode
+* SiLib::HwlOverrideTileMode
*
* @brief
* Override tile modes (for PRT only, avoid client passes in an invalid PRT mode for SI.
@@ -3139,7 +3145,7 @@ UINT_32 SiAddrLib::HwlComputeFmaskBits(
*
****************************************************************************************************
*/
-void SiAddrLib::HwlOverrideTileMode(
+VOID SiLib::HwlOverrideTileMode(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut ///< [in/out] input output structure
) const
{
@@ -3199,7 +3205,7 @@ void SiAddrLib::HwlOverrideTileMode(
/**
****************************************************************************************************
-* SiAddrLib::HwlSelectTileMode
+* SiLib::HwlSelectTileMode
*
* @brief
* Select tile modes.
@@ -3209,7 +3215,7 @@ void SiAddrLib::HwlOverrideTileMode(
*
****************************************************************************************************
*/
-VOID SiAddrLib::HwlSelectTileMode(
+VOID SiLib::HwlSelectTileMode(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut ///< [in/out] input output structure
) const
{
@@ -3275,7 +3281,7 @@ VOID SiAddrLib::HwlSelectTileMode(
/**
****************************************************************************************************
-* SiAddrLib::HwlGetMaxAlignments
+* SiLib::HwlGetMaxAlignments
*
* @brief
* Gets maximum alignments
@@ -3283,7 +3289,7 @@ VOID SiAddrLib::HwlSelectTileMode(
* ADDR_E_RETURNCODE
****************************************************************************************************
*/
-ADDR_E_RETURNCODE SiAddrLib::HwlGetMaxAlignments(
+ADDR_E_RETURNCODE SiLib::HwlGetMaxAlignments(
ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut ///< [out] output structure
) const
{
@@ -3321,7 +3327,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlGetMaxAlignments(
/**
****************************************************************************************************
-* SiAddrLib::InitEquationTable
+* SiLib::InitEquationTable
*
* @brief
* Initialize Equation table.
@@ -3330,7 +3336,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlGetMaxAlignments(
* N/A
****************************************************************************************************
*/
-VOID SiAddrLib::InitEquationTable()
+VOID SiLib::InitEquationTable()
{
ADDR_EQUATION_KEY equationKeyTable[EquationTableSize];
memset(equationKeyTable, 0, sizeof(equationKeyTable));
@@ -3354,7 +3360,7 @@ VOID SiAddrLib::InitEquationTable()
{
UINT_32 equationIndex = ADDR_INVALID_EQUATION_INDEX;
- AddrTileConfig tileConfig = m_tileTable[tileIndex];
+ TileConfig tileConfig = m_tileTable[tileIndex];
ADDR_SURFACE_FLAGS flags = {{0}};
@@ -3492,7 +3498,7 @@ VOID SiAddrLib::InitEquationTable()
/**
****************************************************************************************************
-* SiAddrLib::IsEquationSupported
+* SiLib::IsEquationSupported
*
* @brief
* Check if it is supported for given bpp and tile config to generate a equation.
@@ -3501,9 +3507,9 @@ VOID SiAddrLib::InitEquationTable()
* TRUE if supported
****************************************************************************************************
*/
-BOOL_32 SiAddrLib::IsEquationSupported(
+BOOL_32 SiLib::IsEquationSupported(
UINT_32 bpp, ///< Bits per pixel
- AddrTileConfig tileConfig, ///< Tile config
+ TileConfig tileConfig, ///< Tile config
INT_32 tileIndex ///< Tile index
) const
{
@@ -3540,7 +3546,7 @@ BOOL_32 SiAddrLib::IsEquationSupported(
if ((supported == TRUE) && (m_chipFamily == ADDR_CHIP_FAMILY_SI))
{
- // Please refer to SiAddrLib::HwlSetupTileInfo for PRT tile index selecting
+ // Please refer to SiLib::HwlSetupTileInfo for PRT tile index selecting
// Tile index 3, 6, 21-25 are for PRT single sample
if (tileIndex == 3)
{
@@ -3564,4 +3570,5 @@ BOOL_32 SiAddrLib::IsEquationSupported(
return supported;
}
-
+} // V1
+} // Addr
diff --git a/src/amd/addrlib/r800/siaddrlib.h b/src/amd/addrlib/r800/siaddrlib.h
index ef24dfbe560..b63d7e878dc 100644
--- a/src/amd/addrlib/r800/siaddrlib.h
+++ b/src/amd/addrlib/r800/siaddrlib.h
@@ -27,7 +27,7 @@
/**
****************************************************************************************************
* @file siaddrlib.h
-* @brief Contains the R800AddrLib class definition.
+* @brief Contains the R800Lib class definition.
****************************************************************************************************
*/
@@ -37,12 +37,17 @@
#include "addrlib1.h"
#include "egbaddrlib.h"
+namespace Addr
+{
+namespace V1
+{
+
/**
****************************************************************************************************
* @brief Describes the information in tile mode table
****************************************************************************************************
*/
-struct AddrTileConfig
+struct TileConfig
{
AddrTileMode mode;
AddrTileType type;
@@ -74,18 +79,18 @@ struct SIChipSettings
* function set.
****************************************************************************************************
*/
-class SiAddrLib : public EgBasedAddrLib
+class SiLib : public EgBasedLib
{
public:
- /// Creates SIAddrLib object
- static AddrLib* CreateObj(const AddrClient* pClient)
+ /// Creates SiLib object
+ static Addr::Lib* CreateObj(const Client* pClient)
{
- return new(pClient) SiAddrLib(pClient);
+ return new(pClient) SiLib(pClient);
}
protected:
- SiAddrLib(const AddrClient* pClient);
- virtual ~SiAddrLib();
+ SiLib(const Client* pClient);
+ virtual ~SiLib();
// Hwl interface - defined in AddrLib1
virtual ADDR_E_RETURNCODE HwlComputeSurfaceInfo(
@@ -113,7 +118,7 @@ protected:
virtual BOOL_32 HwlComputeMipLevel(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn) const;
- virtual AddrChipFamily HwlConvertChipFamily(
+ virtual ChipFamily HwlConvertChipFamily(
UINT_32 uChipFamily, UINT_32 uChipRevision);
virtual BOOL_32 HwlInitGlobalParams(
@@ -157,7 +162,7 @@ protected:
virtual UINT_32 HwlComputeXmaskCoordYFrom8Pipe(
UINT_32 pipe, UINT_32 x) const;
- // Sub-hwl interface - defined in EgBasedAddrLib
+ // Sub-hwl interface - defined in EgBasedLib
virtual VOID HwlSetupTileInfo(
AddrTileMode tileMode, ADDR_SURFACE_FLAGS flags,
UINT_32 bpp, UINT_32 pitch, UINT_32 height, UINT_32 numSamples,
@@ -246,7 +251,7 @@ protected:
// Check if it is supported for given bpp and tile config to generate an equation
BOOL_32 IsEquationSupported(
- UINT_32 bpp, AddrTileConfig tileConfig, INT_32 tileIndex) const;
+ UINT_32 bpp, TileConfig tileConfig, INT_32 tileIndex) const;
// Protected non-virtual functions
VOID ComputeTileCoordFromPipeAndElemIdx(
@@ -260,14 +265,14 @@ protected:
BOOL_32 DecodeGbRegs(
const ADDR_REGISTER_VALUE* pRegValue);
- const AddrTileConfig* GetTileSetting(
+ const TileConfig* GetTileSetting(
UINT_32 index) const;
// Initialize equation table
VOID InitEquationTable();
static const UINT_32 TileTableSize = 32;
- AddrTileConfig m_tileTable[TileTableSize];
+ TileConfig m_tileTable[TileTableSize];
UINT_32 m_noOfEntries;
// Max number of bpp (8bpp/16bpp/32bpp/64bpp/128bpp)
@@ -288,13 +293,14 @@ private:
UINT_32 GetPipePerSurf(AddrPipeCfg pipeConfig) const;
- VOID ReadGbTileMode(
- UINT_32 regValue, AddrTileConfig* pCfg) const;
- BOOL_32 InitTileSettingTable(
- const UINT_32 *pSetting, UINT_32 noOfEntries);
+ VOID ReadGbTileMode(UINT_32 regValue, TileConfig* pCfg) const;
+ BOOL_32 InitTileSettingTable(const UINT_32 *pSetting, UINT_32 noOfEntries);
SIChipSettings m_settings;
};
+} // V1
+} // Addr
+
#endif
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-14 22:02:28 +0000