KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

amdgpu/addrlib: Adjust 99 "*" to 100 "*" alignment 

Signed-off-by: Nicolai Hähnle <nicolai.haehnle@amd.com>
This commit is contained in:
Kevin Zhao 2015-08-18 00:17:31 -04:00 committed by Marek Olšák
parent acaeae2861
commit 8912862a40
18 changed files with 895 additions and 895 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
src/amd/addrlib/addrinterface.cpp
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file addrinterface.cpp
* @brief Contains the addrlib interface functions
***************************************************************************************************
****************************************************************************************************
*/
#include "addrinterface.h"
#include "addrlib1.h"
@ -40,7 +40,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
****************************************************************************************************
* AddrCreate
*
* @brief
@ -48,7 +48,7 @@
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrCreate(
const ADDR_CREATE_INPUT* pAddrCreateIn, ///< [in] infomation for creating address lib object
@ -64,7 +64,7 @@ ADDR_E_RETURNCODE ADDR_API AddrCreate(
/**
***************************************************************************************************
****************************************************************************************************
* AddrDestroy
*
* @brief
@ -72,7 +72,7 @@ ADDR_E_RETURNCODE ADDR_API AddrCreate(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrDestroy(
ADDR_HANDLE hLib) ///< address lib handle
@ -99,7 +99,7 @@ ADDR_E_RETURNCODE ADDR_API AddrDestroy(
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeSurfaceInfo
*
* @brief
@ -107,7 +107,7 @@ ADDR_E_RETURNCODE ADDR_API AddrDestroy(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
ADDR_HANDLE hLib, ///< address lib handle
@ -133,7 +133,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeSurfaceAddrFromCoord
*
* @brief
@ -141,7 +141,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
ADDR_HANDLE hLib, ///< address lib handle
@ -165,7 +165,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeSurfaceCoordFromAddr
*
* @brief
@ -173,7 +173,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
ADDR_HANDLE hLib, ///< address lib handle
@ -203,7 +203,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeHtileInfo
*
* @brief
@ -211,7 +211,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
ADDR_HANDLE hLib, ///< address lib handle
@ -235,7 +235,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeHtileAddrFromCoord
*
* @brief
@ -243,7 +243,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
ADDR_HANDLE hLib, ///< address lib handle
@ -267,7 +267,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeHtileCoordFromAddr
*
* @brief
@ -276,7 +276,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
ADDR_HANDLE hLib, ///< address lib handle
@ -306,7 +306,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeCmaskInfo
*
* @brief
@ -315,7 +315,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
ADDR_HANDLE hLib, ///< address lib handle
@ -339,7 +339,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeCmaskAddrFromCoord
*
* @brief
@ -347,7 +347,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
ADDR_HANDLE hLib, ///< address lib handle
@ -371,7 +371,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeCmaskCoordFromAddr
*
* @brief
@ -380,7 +380,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
ADDR_HANDLE hLib, ///< address lib handle
@ -410,7 +410,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeFmaskInfo
*
* @brief
@ -418,7 +418,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
ADDR_HANDLE hLib, ///< address lib handle
@ -442,7 +442,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeFmaskAddrFromCoord
*
* @brief
@ -450,7 +450,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
ADDR_HANDLE hLib, ///< address lib handle
@ -474,7 +474,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeFmaskCoordFromAddr
*
* @brief
@ -482,7 +482,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
ADDR_HANDLE hLib, ///< address lib handle
@ -512,13 +512,13 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeDccInfo
*
* @brief
* Compute DCC key size, base alignment based on color surface size, tile info or tile index
*
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
ADDR_HANDLE hLib, ///< handle of addrlib
@ -548,13 +548,13 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
///////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
****************************************************************************************************
* AddrGetVersion
*
* @brief
* Get AddrLib version number. Client may check this return value against ADDRLIB_VERSION
* defined in addrinterface.h to see if there is a mismatch.
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib)
{
@ -573,12 +573,12 @@ UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib)
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrUseTileIndex
*
* @brief
* Return TRUE if tileIndex is enabled in this address library
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib)
{
@ -597,12 +597,12 @@ BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib)
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrUseCombinedSwizzle
*
* @brief
* Return TRUE if combined swizzle is enabled in this address library
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib)
{
@ -621,14 +621,14 @@ BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib)
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrExtractBankPipeSwizzle
*
* @brief
* Extract Bank and Pipe swizzle from base256b
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
ADDR_HANDLE hLib, ///< addrlib handle
@ -652,14 +652,14 @@ ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrCombineBankPipeSwizzle
*
* @brief
* Combine Bank and Pipe swizzle
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
ADDR_HANDLE hLib,
@ -683,14 +683,14 @@ ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeSliceSwizzle
*
* @brief
* Compute a swizzle for slice from a base swizzle
* @return
* ADDR_OK if no error
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
ADDR_HANDLE hLib,
@ -714,14 +714,14 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputeBaseSwizzle
*
* @brief
* Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
* @return
* ADDR_OK if no error
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
ADDR_HANDLE hLib,
@ -745,7 +745,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* ElemFlt32ToDepthPixel
*
* @brief
@ -754,7 +754,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
*
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
ADDR_HANDLE hLib, ///< addrlib handle
@ -778,7 +778,7 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
}
/**
***************************************************************************************************
****************************************************************************************************
* ElemFlt32ToColorPixel
*
* @brief
@ -787,7 +787,7 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
*
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
ADDR_HANDLE hLib, ///< addrlib handle
@ -811,7 +811,7 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
}
/**
***************************************************************************************************
****************************************************************************************************
* ElemGetExportNorm
*
* @brief
@ -820,7 +820,7 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
* FP16 can be reported as EXPORT_NORM for rv770 in r600
* family
*
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 ADDR_API ElemGetExportNorm(
ADDR_HANDLE hLib, ///< addrlib handle
@ -846,7 +846,7 @@ BOOL_32 ADDR_API ElemGetExportNorm(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrConvertTileInfoToHW
*
* @brief
@ -854,7 +854,7 @@ BOOL_32 ADDR_API ElemGetExportNorm(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
ADDR_HANDLE hLib, ///< address lib handle
@ -878,7 +878,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrConvertTileIndex
*
* @brief
@ -886,7 +886,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
ADDR_HANDLE hLib, ///< address lib handle
@ -910,7 +910,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrGetMacroModeIndex
*
* @brief
@ -918,7 +918,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
ADDR_HANDLE hLib, ///< address lib handle
@ -942,7 +942,7 @@ ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrConvertTileIndex1
*
* @brief
@ -950,7 +950,7 @@ ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
ADDR_HANDLE hLib, ///< address lib handle
@ -974,7 +974,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrGetTileIndex
*
* @brief
@ -985,7 +985,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
*
* @note
* Only meaningful for SI (and above)
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
ADDR_HANDLE hLib,
@ -1009,13 +1009,13 @@ ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrComputePrtInfo
*
* @brief
* Interface function for ComputePrtInfo
*
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
ADDR_HANDLE hLib,
@ -1039,7 +1039,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrGetMaxAlignments
*
* @brief
@ -1047,7 +1047,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
ADDR_HANDLE hLib, ///< address lib handle

424
src/amd/addrlib/addrinterface.h
View File

File diff suppressed because it is too large Load Diff

52
src/amd/addrlib/addrtypes.h
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file addrtypes.h
* @brief Contains the helper function and constants
***************************************************************************************************
****************************************************************************************************
*/
#ifndef __ADDR_TYPES_H__
#define __ADDR_TYPES_H__
@ -62,9 +62,9 @@ typedef int INT;
#endif // defined (__APPLE__) && !defined(HAVE_TSERVER)
/**
***************************************************************************************************
****************************************************************************************************
* Calling conventions
***************************************************************************************************
****************************************************************************************************
*/
#ifndef ADDR_CDECL
#if defined(__GNUC__)
@ -121,9 +121,9 @@ typedef int INT;
#define ADDR_API ADDR_FASTCALL //default call convention is fast call
/**
***************************************************************************************************
****************************************************************************************************
* Global defines used by other modules
***************************************************************************************************
****************************************************************************************************
*/
#if !defined(TILEINDEX_INVALID)
#define TILEINDEX_INVALID -1
@ -138,9 +138,9 @@ typedef int INT;
#endif
/**
***************************************************************************************************
****************************************************************************************************
* Return codes
***************************************************************************************************
****************************************************************************************************
*/
typedef enum _ADDR_E_RETURNCODE
{
@ -159,14 +159,14 @@ typedef enum _ADDR_E_RETURNCODE
} ADDR_E_RETURNCODE;
/**
***************************************************************************************************
****************************************************************************************************
* @brief
* Neutral enums that define tile modes for all H/W
* @note
* R600/R800 tiling mode can be cast to hw enums directly but never cast into HW enum from
* ADDR_TM_2D_TILED_XTHICK
*
***************************************************************************************************
****************************************************************************************************
*/
typedef enum _AddrTileMode
{
@ -200,13 +200,13 @@ typedef enum _AddrTileMode
} AddrTileMode;
/**
***************************************************************************************************
****************************************************************************************************
* AddrFormat
*
* @brief
* Neutral enum for SurfaceFormat
*
***************************************************************************************************
****************************************************************************************************
*/
typedef enum _AddrFormat {
ADDR_FMT_INVALID = 0x00000000,
@ -276,13 +276,13 @@ typedef enum _AddrFormat {
} AddrFormat;
/**
***************************************************************************************************
****************************************************************************************************
* AddrDepthFormat
*
* @brief
* Neutral enum for addrFlt32ToDepthPixel
*
***************************************************************************************************
****************************************************************************************************
*/
typedef enum _AddrDepthFormat
{
@ -298,13 +298,13 @@ typedef enum _AddrDepthFormat
} AddrDepthFormat;
/**
***************************************************************************************************
****************************************************************************************************
* AddrColorFormat
*
* @brief
* Neutral enum for ColorFormat
*
***************************************************************************************************
****************************************************************************************************
*/
typedef enum _AddrColorFormat
{
@ -347,13 +347,13 @@ typedef enum _AddrColorFormat
} AddrColorFormat;
/**
***************************************************************************************************
****************************************************************************************************
* AddrSurfaceNumber
*
* @brief
* Neutral enum for SurfaceNumber
*
***************************************************************************************************
****************************************************************************************************
*/
typedef enum _AddrSurfaceNumber {
ADDR_NUMBER_UNORM = 0x00000000,
@ -367,13 +367,13 @@ typedef enum _AddrSurfaceNumber {
} AddrSurfaceNumber;
/**
***************************************************************************************************
****************************************************************************************************
* AddrSurfaceSwap
*
* @brief
* Neutral enum for SurfaceSwap
*
***************************************************************************************************
****************************************************************************************************
*/
typedef enum _AddrSurfaceSwap {
ADDR_SWAP_STD = 0x00000000,
@ -383,12 +383,12 @@ typedef enum _AddrSurfaceSwap {
} AddrSurfaceSwap;
/**
***************************************************************************************************
****************************************************************************************************
* AddrHtileBlockSize
*
* @brief
* Size of HTILE blocks, valid values are 4 or 8 for now
***************************************************************************************************
****************************************************************************************************
*/
typedef enum _AddrHtileBlockSize
{
@ -398,7 +398,7 @@ typedef enum _AddrHtileBlockSize
/**
***************************************************************************************************
****************************************************************************************************
* AddrPipeCfg
*
* @brief
@ -411,7 +411,7 @@ typedef enum _AddrHtileBlockSize
* For hw configurations w/ non-pow2 memory number of memory channels, it usually matches
* the number of ROP units(? TODO: which registers??)
* The enum value = hw enum + 1 which is to reserve 0 for requesting default.
***************************************************************************************************
****************************************************************************************************
*/
typedef enum _AddrPipeCfg
{
@ -434,12 +434,12 @@ typedef enum _AddrPipeCfg
} AddrPipeCfg;
/**
***************************************************************************************************
****************************************************************************************************
* AddrTileType
*
* @brief
* Neutral enums that specifies micro tile type (MICRO_TILE_MODE)
***************************************************************************************************
****************************************************************************************************
*/
typedef enum _AddrTileType
{

84
src/amd/addrlib/core/addrcommon.h
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file addrcommon.h
* @brief Contains the helper function and constants
***************************************************************************************************
****************************************************************************************************
*/
#ifndef __ADDR_COMMON_H__
@ -75,9 +75,9 @@ static const INT_32 TileIndexNoMacroIndex = -3;
#define _BIT(v,b) (((v) >> (b) ) & 1)
/**
***************************************************************************************************
****************************************************************************************************
* @brief Enums to identify AddrLib type
***************************************************************************************************
****************************************************************************************************
*/
enum AddrLibClass
{
@ -89,13 +89,13 @@ enum AddrLibClass
};
/**
***************************************************************************************************
****************************************************************************************************
* AddrChipFamily
*
* @brief
* Neutral enums that specifies chip family.
*
***************************************************************************************************
****************************************************************************************************
*/
enum AddrChipFamily
{
@ -110,12 +110,12 @@ enum AddrChipFamily
};
/**
***************************************************************************************************
****************************************************************************************************
* AddrConfigFlags
*
* @brief
* This structure is used to set configuration flags.
***************************************************************************************************
****************************************************************************************************
*/
union AddrConfigFlags
{
@ -261,12 +261,12 @@ union AddrConfigFlags
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
****************************************************************************************************
* AddrXorReduce
*
* @brief
* Xor the right-side numberOfBits bits of x.
***************************************************************************************************
****************************************************************************************************
*/
static inline UINT_32 XorReduce(
UINT_32 x,
@ -284,12 +284,12 @@ static inline UINT_32 XorReduce(
}
/**
***************************************************************************************************
****************************************************************************************************
* IsPow2
*
* @brief
* Check if the size (UINT_32) is pow 2
***************************************************************************************************
****************************************************************************************************
*/
static inline UINT_32 IsPow2(
UINT_32 dim) ///< [in] dimension of miplevel
@ -299,12 +299,12 @@ static inline UINT_32 IsPow2(
}
/**
***************************************************************************************************
****************************************************************************************************
* IsPow2
*
* @brief
* Check if the size (UINT_64) is pow 2
***************************************************************************************************
****************************************************************************************************
*/
static inline UINT_64 IsPow2(
UINT_64 dim) ///< [in] dimension of miplevel
@ -314,12 +314,12 @@ static inline UINT_64 IsPow2(
}
/**
***************************************************************************************************
****************************************************************************************************
* ByteAlign
*
* @brief
* Align UINT_32 "x" to "align" alignment, "align" should be power of 2
***************************************************************************************************
****************************************************************************************************
*/
static inline UINT_32 PowTwoAlign(
UINT_32 x,
@ -333,12 +333,12 @@ static inline UINT_32 PowTwoAlign(
}
/**
***************************************************************************************************
****************************************************************************************************
* ByteAlign
*
* @brief
* Align UINT_64 "x" to "align" alignment, "align" should be power of 2
***************************************************************************************************
****************************************************************************************************
*/
static inline UINT_64 PowTwoAlign(
UINT_64 x,
@ -352,12 +352,12 @@ static inline UINT_64 PowTwoAlign(
}
/**
***************************************************************************************************
****************************************************************************************************
* Min
*
* @brief
* Get the min value between two unsigned values
***************************************************************************************************
****************************************************************************************************
*/
static inline UINT_32 Min(
UINT_32 value1,
@ -367,12 +367,12 @@ static inline UINT_32 Min(
}
/**
***************************************************************************************************
****************************************************************************************************
* Min
*
* @brief
* Get the min value between two signed values
***************************************************************************************************
****************************************************************************************************
*/
static inline INT_32 Min(
INT_32 value1,
@ -382,12 +382,12 @@ static inline INT_32 Min(
}
/**
***************************************************************************************************
****************************************************************************************************
* Max
*
* @brief
* Get the max value between two unsigned values
***************************************************************************************************
****************************************************************************************************
*/
static inline UINT_32 Max(
UINT_32 value1,
@ -397,12 +397,12 @@ static inline UINT_32 Max(
}
/**
***************************************************************************************************
****************************************************************************************************
* Max
*
* @brief
* Get the max value between two signed values
***************************************************************************************************
****************************************************************************************************
*/
static inline INT_32 Max(
INT_32 value1,
@ -412,12 +412,12 @@ static inline INT_32 Max(
}
/**
***************************************************************************************************
****************************************************************************************************
* NextPow2
*
* @brief
* Compute the mipmap's next level dim size
***************************************************************************************************
****************************************************************************************************
*/
static inline UINT_32 NextPow2(
UINT_32 dim) ///< [in] dimension of miplevel
@ -443,12 +443,12 @@ static inline UINT_32 NextPow2(
}
/**
***************************************************************************************************
****************************************************************************************************
* Log2NonPow2
*
* @brief
* Compute log of base 2 no matter the target is power of 2 or not
***************************************************************************************************
****************************************************************************************************
*/
static inline UINT_32 Log2NonPow2(
UINT_32 x) ///< [in] the value should calculate log based 2
@ -466,12 +466,12 @@ static inline UINT_32 Log2NonPow2(
}
/**
***************************************************************************************************
****************************************************************************************************
* Log2
*
* @brief
* Compute log of base 2
***************************************************************************************************
****************************************************************************************************
*/
static inline UINT_32 Log2(
UINT_32 x) ///< [in] the value should calculate log based 2
@ -483,12 +483,12 @@ static inline UINT_32 Log2(
}
/**
***************************************************************************************************
****************************************************************************************************
* QLog2
*
* @brief
* Compute log of base 2 quickly (<= 16)
***************************************************************************************************
****************************************************************************************************
*/
static inline UINT_32 QLog2(
UINT_32 x) ///< [in] the value should calculate log based 2
@ -522,12 +522,12 @@ static inline UINT_32 QLog2(
}
/**
***************************************************************************************************
****************************************************************************************************
* SafeAssign
*
* @brief
* NULL pointer safe assignment
***************************************************************************************************
****************************************************************************************************
*/
static inline VOID SafeAssign(
UINT_32* pLVal, ///< [in] Pointer to left val
@ -540,12 +540,12 @@ static inline VOID SafeAssign(
}
/**
***************************************************************************************************
****************************************************************************************************
* SafeAssign
*
* @brief
* NULL pointer safe assignment for 64bit values
***************************************************************************************************
****************************************************************************************************
*/
static inline VOID SafeAssign(
UINT_64* pLVal, ///< [in] Pointer to left val
@ -558,12 +558,12 @@ static inline VOID SafeAssign(
}
/**
***************************************************************************************************
****************************************************************************************************
* SafeAssign
*
* @brief
* NULL pointer safe assignment for AddrTileMode
***************************************************************************************************
****************************************************************************************************
*/
static inline VOID SafeAssign(
AddrTileMode* pLVal, ///< [in] Pointer to left val
@ -576,12 +576,12 @@ static inline VOID SafeAssign(
}
/**
***************************************************************************************************
****************************************************************************************************
* InitChannel
*
* @brief
* Get channel initialization value
***************************************************************************************************
****************************************************************************************************
*/
static inline ADDR_CHANNEL_SETTING InitChannel(
UINT_32 valid, ///< [in] valid setting

86
src/amd/addrlib/core/addrelemlib.cpp
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file addrelemlib.cpp
* @brief Contains the class implementation for element/pixel related functions
***************************************************************************************************
****************************************************************************************************
*/
#include "addrelemlib.h"
@ -36,7 +36,7 @@
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::AddrElemLib
*
* @brief
@ -44,7 +44,7 @@
*
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
AddrElemLib::AddrElemLib(
AddrLib* const pAddrLib) : ///< [in] Parent addrlib instance pointer
@ -75,7 +75,7 @@ AddrElemLib::AddrElemLib(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::~AddrElemLib
*
* @brief
@ -83,14 +83,14 @@ AddrElemLib::AddrElemLib(
*
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
AddrElemLib::~AddrElemLib()
{
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::Create
*
* @brief
@ -98,7 +98,7 @@ AddrElemLib::~AddrElemLib()
*
* @return
* Returns point to ADDR_CREATEINFO if successful.
***************************************************************************************************
****************************************************************************************************
*/
AddrElemLib* AddrElemLib::Create(
const AddrLib* const pAddrLib) ///< [in] Pointer of parent AddrLib instance
@ -121,7 +121,7 @@ AddrElemLib* AddrElemLib::Create(
*
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrElemLib::Flt32sToInt32s(
ADDR_FLT_32 value, ///< [in] ADDR_FLT_32 value
@ -303,7 +303,7 @@ VOID AddrElemLib::Flt32sToInt32s(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::Int32sToPixel
*
* @brief
@ -318,7 +318,7 @@ VOID AddrElemLib::Flt32sToInt32s(
* an uncompressed pixel. The pixel values are specifies in
* standard order, e.g. depth/stencil. This routine asserts
* if called on compressed pixel.
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrElemLib::Int32sToPixel(
UINT_32 numComps, ///< [in] number of components
@ -376,7 +376,7 @@ VOID AddrElemLib::Int32sToPixel(
}
/**
***************************************************************************************************
****************************************************************************************************
* Flt32ToDepthPixel
*
* @brief
@ -384,7 +384,7 @@ VOID AddrElemLib::Int32sToPixel(
*
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrElemLib::Flt32ToDepthPixel(
AddrDepthFormat format, ///< [in] Depth format
@ -445,7 +445,7 @@ VOID AddrElemLib::Flt32ToDepthPixel(
}
/**
***************************************************************************************************
****************************************************************************************************
* Flt32ToColorPixel
*
* @brief
@ -453,7 +453,7 @@ VOID AddrElemLib::Flt32ToDepthPixel(
*
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrElemLib::Flt32ToColorPixel(
AddrColorFormat format, ///< [in] Color format
@ -531,7 +531,7 @@ VOID AddrElemLib::Flt32ToColorPixel(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::GetCompType
*
* @brief
@ -540,7 +540,7 @@ VOID AddrElemLib::Flt32ToColorPixel(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrElemLib::GetCompType(
AddrColorFormat format, ///< [in] surface format
@ -704,7 +704,7 @@ VOID AddrElemLib::GetCompType(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::GetCompSwap
*
* @brief
@ -713,7 +713,7 @@ VOID AddrElemLib::GetCompType(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrElemLib::GetCompSwap(
AddrSurfaceSwap swap, ///< [in] swap mode
@ -794,7 +794,7 @@ VOID AddrElemLib::GetCompSwap(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::GetCompSwap
*
* @brief
@ -803,7 +803,7 @@ VOID AddrElemLib::GetCompSwap(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrElemLib::SwapComps(
UINT_32 c0, ///< [in] component index 0
@ -823,7 +823,7 @@ VOID AddrElemLib::SwapComps(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::PixGetColorCompInfo
*
* @brief
@ -832,7 +832,7 @@ VOID AddrElemLib::SwapComps(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrElemLib::PixGetColorCompInfo(
AddrColorFormat format, ///< [in] surface format, read from register
@ -960,7 +960,7 @@ VOID AddrElemLib::PixGetColorCompInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::PixGetDepthCompInfo
*
* @brief
@ -969,7 +969,7 @@ VOID AddrElemLib::PixGetColorCompInfo(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrElemLib::PixGetDepthCompInfo(
AddrDepthFormat format, ///< [in] surface format, read from register
@ -1058,7 +1058,7 @@ VOID AddrElemLib::PixGetDepthCompInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::PixGetExportNorm
*
* @brief
@ -1067,7 +1067,7 @@ VOID AddrElemLib::PixGetDepthCompInfo(
* @return
* TRUE if this can be enabled.
*
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 AddrElemLib::PixGetExportNorm(
AddrColorFormat colorFmt, ///< [in] surface format, read from register
@ -1110,7 +1110,7 @@ BOOL_32 AddrElemLib::PixGetExportNorm(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::AdjustSurfaceInfo
*
* @brief
@ -1118,7 +1118,7 @@ BOOL_32 AddrElemLib::PixGetExportNorm(
*
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrElemLib::AdjustSurfaceInfo(
AddrElemMode elemMode, ///< [in] element mode
@ -1235,7 +1235,7 @@ VOID AddrElemLib::AdjustSurfaceInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::RestoreSurfaceInfo
*
* @brief
@ -1243,7 +1243,7 @@ VOID AddrElemLib::AdjustSurfaceInfo(
*
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrElemLib::RestoreSurfaceInfo(
AddrElemMode elemMode, ///< [in] element mode
@ -1327,7 +1327,7 @@ VOID AddrElemLib::RestoreSurfaceInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::GetBitsPerPixel
*
* @brief
@ -1337,7 +1337,7 @@ VOID AddrElemLib::RestoreSurfaceInfo(
*
* @return
* Bits per pixel
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 AddrElemLib::GetBitsPerPixel(
AddrFormat format, ///< [in] surface format code
@ -1496,7 +1496,7 @@ UINT_32 AddrElemLib::GetBitsPerPixel(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::GetCompBits
*
* @brief
@ -1504,7 +1504,7 @@ UINT_32 AddrElemLib::GetBitsPerPixel(
*
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrElemLib::GetCompBits(
UINT_32 c0, ///< [in] bits of component 0
@ -1543,7 +1543,7 @@ VOID AddrElemLib::GetCompBits(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::GetCompBits
*
* @brief
@ -1555,7 +1555,7 @@ VOID AddrElemLib::GetCompBits(
*
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrElemLib::SetClearComps(
ADDR_FLT_32 comps[4], ///< [in/out] components
@ -1599,7 +1599,7 @@ VOID AddrElemLib::SetClearComps(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::IsBlockCompressed
*
* @brief
@ -1609,7 +1609,7 @@ VOID AddrElemLib::SetClearComps(
*
* @return
* BOOL_32
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 AddrElemLib::IsBlockCompressed(
AddrFormat format) ///< [in] Format
@ -1619,7 +1619,7 @@ BOOL_32 AddrElemLib::IsBlockCompressed(
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::IsCompressed
*
* @brief
@ -1629,7 +1629,7 @@ BOOL_32 AddrElemLib::IsBlockCompressed(
*
* @return
* BOOL_32
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 AddrElemLib::IsCompressed(
AddrFormat format) ///< [in] Format
@ -1638,7 +1638,7 @@ BOOL_32 AddrElemLib::IsCompressed(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrElemLib::IsExpand3x
*
* @brief
@ -1648,7 +1648,7 @@ BOOL_32 AddrElemLib::IsCompressed(
*
* @return
* BOOL_32
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 AddrElemLib::IsExpand3x(
AddrFormat format) ///< [in] Format

12
src/amd/addrlib/core/addrelemlib.h
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file addrelemlib.h
* @brief Contains the class for element/pixel related functions
***************************************************************************************************
****************************************************************************************************
*/
#ifndef __ELEM_LIB_H__
@ -145,13 +145,13 @@ enum AddrDepthPlanarType
};
/**
***************************************************************************************************
****************************************************************************************************
* ADDR_PIXEL_FORMATINFO
*
* @brief
* Per component info
*
***************************************************************************************************
****************************************************************************************************
*/
struct ADDR_PIXEL_FORMATINFO
{
@ -163,9 +163,9 @@ struct ADDR_PIXEL_FORMATINFO
};
/**
***************************************************************************************************
****************************************************************************************************
* @brief This class contains asic indepentent element related attributes and operations
***************************************************************************************************
****************************************************************************************************
*/
class AddrElemLib : public AddrObject
{

52
src/amd/addrlib/core/addrlib.cpp
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file addrlib.cpp
* @brief Contains the implementation for the AddrLib base class..
***************************************************************************************************
****************************************************************************************************
*/
#include "addrinterface.h"
@ -87,13 +87,13 @@ UINT_32 __umoddi3(UINT_64 n, UINT_32 base)
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib::AddrLib
*
* @brief
* Constructor for the AddrLib class
*
***************************************************************************************************
****************************************************************************************************
*/
AddrLib::AddrLib() :
m_class(BASE_ADDRLIB),
@ -112,13 +112,13 @@ AddrLib::AddrLib() :
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib::AddrLib
*
* @brief
* Constructor for the AddrLib class with hClient as parameter
*
***************************************************************************************************
****************************************************************************************************
*/
AddrLib::AddrLib(const AddrClient* pClient) :
AddrObject(pClient),
@ -138,13 +138,13 @@ AddrLib::AddrLib(const AddrClient* pClient) :
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib::~AddrLib
*
* @brief
* Destructor for the AddrLib class
*
***************************************************************************************************
****************************************************************************************************
*/
AddrLib::~AddrLib()
{
@ -161,7 +161,7 @@ AddrLib::~AddrLib()
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib::Create
*
* @brief
@ -169,7 +169,7 @@ AddrLib::~AddrLib()
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib::Create(
const ADDR_CREATE_INPUT* pCreateIn, ///< [in] pointer to ADDR_CREATE_INPUT
@ -284,14 +284,14 @@ ADDR_E_RETURNCODE AddrLib::Create(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib::SetAddrChipFamily
*
* @brief
* Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrLib::SetAddrChipFamily(
UINT_32 uChipFamily, ///< [in] chip family defined in atiih.h
@ -306,7 +306,7 @@ VOID AddrLib::SetAddrChipFamily(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib::SetMinPitchAlignPixels
*
* @brief
@ -314,7 +314,7 @@ VOID AddrLib::SetAddrChipFamily(
*
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrLib::SetMinPitchAlignPixels(
UINT_32 minPitchAlignPixels) ///< [in] minmum pitch alignment in pixels
@ -323,7 +323,7 @@ VOID AddrLib::SetMinPitchAlignPixels(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib::GetAddrLib
*
* @brief
@ -331,7 +331,7 @@ VOID AddrLib::SetMinPitchAlignPixels(
*
* @return
* An AddrLib class pointer
***************************************************************************************************
****************************************************************************************************
*/
AddrLib * AddrLib::GetAddrLib(
ADDR_HANDLE hLib) ///< [in] handle of ADDR_HANDLE
@ -340,7 +340,7 @@ AddrLib * AddrLib::GetAddrLib(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib::GetMaxAlignments
*
* @brief
@ -348,7 +348,7 @@ AddrLib * AddrLib::GetAddrLib(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib::GetMaxAlignments(
ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut ///< [out] output structure
@ -373,7 +373,7 @@ ADDR_E_RETURNCODE AddrLib::GetMaxAlignments(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib::Bits2Number
*
* @brief
@ -381,7 +381,7 @@ ADDR_E_RETURNCODE AddrLib::GetMaxAlignments(
*
* @return
* The number combined with the array of bits
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 AddrLib::Bits2Number(
UINT_32 bitNum, ///< [in] how many bits
@ -413,14 +413,14 @@ UINT_32 AddrLib::Bits2Number(
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib::Flt32ToColorPixel
*
* @brief
* Convert a FLT_32 value to a depth/stencil pixel value
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib::Flt32ToDepthPixel(
const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,
@ -491,14 +491,14 @@ ADDR_E_RETURNCODE AddrLib::Flt32ToDepthPixel(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib::Flt32ToColorPixel
*
* @brief
* Convert a FLT_32 value to a red/green/blue/alpha pixel value
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib::Flt32ToColorPixel(
const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,
@ -529,14 +529,14 @@ ADDR_E_RETURNCODE AddrLib::Flt32ToColorPixel(
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib::GetExportNorm
*
* @brief
* Check one format can be EXPORT_NUM
* @return
* TRUE if EXPORT_NORM can be used
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 AddrLib::GetExportNorm(
const ELEM_GETEXPORTNORM_INPUT* pIn) const

32
src/amd/addrlib/core/addrlib.h
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file addrlib.h
* @brief Contains the AddrLib base class definition.
***************************************************************************************************
****************************************************************************************************
*/
#ifndef __ADDR_LIB_H__
@ -61,9 +61,9 @@
#define CIASICIDGFXENGINE_SEAISLAND 0x0000000B
#endif
/**
***************************************************************************************************
****************************************************************************************************
* @brief Neutral enums that define pipeinterleave
***************************************************************************************************
****************************************************************************************************
*/
enum AddrPipeInterleave
{
@ -72,9 +72,9 @@ enum AddrPipeInterleave
};
/**
***************************************************************************************************
****************************************************************************************************
* @brief Neutral enums that define DRAM row size
***************************************************************************************************
****************************************************************************************************
*/
enum AddrRowSize
{
@ -85,9 +85,9 @@ enum AddrRowSize
};
/**
***************************************************************************************************
****************************************************************************************************
* @brief Neutral enums that define bank interleave
***************************************************************************************************
****************************************************************************************************
*/
enum AddrBankInterleave
{
@ -98,9 +98,9 @@ enum AddrBankInterleave
};
/**
***************************************************************************************************
****************************************************************************************************
* @brief Neutral enums that define MGPU chip tile size
***************************************************************************************************
****************************************************************************************************
*/
enum AddrChipTileSize
{
@ -111,9 +111,9 @@ enum AddrChipTileSize
};
/**
***************************************************************************************************
****************************************************************************************************
* @brief Neutral enums that define shader engine tile size
***************************************************************************************************
****************************************************************************************************
*/
enum AddrEngTileSize
{
@ -122,9 +122,9 @@ enum AddrEngTileSize
};
/**
***************************************************************************************************
****************************************************************************************************
* @brief Neutral enums that define bank swap size
***************************************************************************************************
****************************************************************************************************
*/
enum AddrBankSwapSize
{
@ -136,9 +136,9 @@ enum AddrBankSwapSize
/**
***************************************************************************************************
****************************************************************************************************
* @brief This class contains asic independent address lib functionalities
***************************************************************************************************
****************************************************************************************************
*/
class AddrLib : public AddrObject
{

244
src/amd/addrlib/core/addrlib1.cpp
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file addr1lib.cpp
* @brief Contains the implementation for the AddrLib1 base class..
***************************************************************************************************
****************************************************************************************************
*/
#include "addrinterface.h"
@ -75,13 +75,13 @@ const AddrTileModeFlags AddrLib1::ModeFlags[ADDR_TM_COUNT] =
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::AddrLib1
*
* @brief
* Constructor for the AddrLib1 class
*
***************************************************************************************************
****************************************************************************************************
*/
AddrLib1::AddrLib1() :
AddrLib()
@ -89,13 +89,13 @@ AddrLib1::AddrLib1() :
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::AddrLib1
*
* @brief
* Constructor for the AddrLib1 class with hClient as parameter
*
***************************************************************************************************
****************************************************************************************************
*/
AddrLib1::AddrLib1(const AddrClient* pClient) :
AddrLib(pClient)
@ -103,20 +103,20 @@ AddrLib1::AddrLib1(const AddrClient* pClient) :
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::~AddrLib1
*
* @brief
* Destructor for the AddrLib1 class
*
***************************************************************************************************
****************************************************************************************************
*/
AddrLib1::~AddrLib1()
{
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::GetAddrLib1
*
* @brief
@ -124,7 +124,7 @@ AddrLib1::~AddrLib1()
*
* @return
* An AddrLib1 class pointer
***************************************************************************************************
****************************************************************************************************
*/
AddrLib1* AddrLib1::GetAddrLib1(
ADDR_HANDLE hLib) ///< [in] handle of ADDR_HANDLE
@ -148,7 +148,7 @@ AddrLib1* AddrLib1::GetAddrLib1(
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeSurfaceInfo
*
* @brief
@ -156,7 +156,7 @@ AddrLib1* AddrLib1::GetAddrLib1(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
@ -434,7 +434,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeSurfaceInfo
*
* @brief
@ -442,7 +442,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceAddrFromCoord(
const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
@ -514,7 +514,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeSurfaceCoordFromAddr
*
* @brief
@ -522,7 +522,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceAddrFromCoord(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceCoordFromAddr(
const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
@ -589,7 +589,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceCoordFromAddr(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeSliceTileSwizzle
*
* @brief
@ -597,7 +597,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceCoordFromAddr(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeSliceTileSwizzle(
const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn, ///< [in] input structure
@ -642,7 +642,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSliceTileSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ExtractBankPipeSwizzle
*
* @brief
@ -650,7 +650,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSliceTileSwizzle(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ExtractBankPipeSwizzle(
const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn, ///< [in] input structure
@ -694,7 +694,7 @@ ADDR_E_RETURNCODE AddrLib1::ExtractBankPipeSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::CombineBankPipeSwizzle
*
* @brief
@ -702,7 +702,7 @@ ADDR_E_RETURNCODE AddrLib1::ExtractBankPipeSwizzle(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::CombineBankPipeSwizzle(
const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT* pIn, ///< [in] input structure
@ -750,14 +750,14 @@ ADDR_E_RETURNCODE AddrLib1::CombineBankPipeSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeBaseSwizzle
*
* @brief
* Interface function stub of AddrCompueBaseSwizzle.
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeBaseSwizzle(
const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn,
@ -807,7 +807,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeBaseSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeFmaskInfo
*
* @brief
@ -815,7 +815,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeBaseSwizzle(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeFmaskInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
@ -901,7 +901,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeFmaskAddrFromCoord
*
* @brief
@ -909,7 +909,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskInfo(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeFmaskAddrFromCoord(
const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
@ -945,7 +945,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeFmaskCoordFromAddr
*
* @brief
@ -953,7 +953,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskAddrFromCoord(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeFmaskCoordFromAddr(
const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
@ -989,7 +989,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskCoordFromAddr(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ConvertTileInfoToHW
*
* @brief
@ -997,7 +997,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskCoordFromAddr(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ConvertTileInfoToHW(
const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
@ -1041,7 +1041,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileInfoToHW(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ConvertTileIndex
*
* @brief
@ -1049,7 +1049,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileInfoToHW(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex(
const ADDR_CONVERT_TILEINDEX_INPUT* pIn, ///< [in] input structure
@ -1090,7 +1090,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::GetMacroModeIndex
*
* @brief
@ -1098,7 +1098,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::GetMacroModeIndex(
const ADDR_GET_MACROMODEINDEX_INPUT* pIn, ///< [in] input structure
@ -1127,7 +1127,7 @@ ADDR_E_RETURNCODE AddrLib1::GetMacroModeIndex(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ConvertTileIndex1
*
* @brief
@ -1135,7 +1135,7 @@ ADDR_E_RETURNCODE AddrLib1::GetMacroModeIndex(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex1(
const ADDR_CONVERT_TILEINDEX1_INPUT* pIn, ///< [in] input structure
@ -1177,7 +1177,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex1(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::GetTileIndex
*
* @brief
@ -1185,7 +1185,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex1(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::GetTileIndex(
const ADDR_GET_TILEINDEX_INPUT* pIn, ///< [in] input structure
@ -1212,7 +1212,7 @@ ADDR_E_RETURNCODE AddrLib1::GetTileIndex(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::Thickness
*
* @brief
@ -1220,7 +1220,7 @@ ADDR_E_RETURNCODE AddrLib1::GetTileIndex(
*
* @return
* Tile mode thickness
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 AddrLib1::Thickness(
AddrTileMode tileMode) ///< [in] tile mode
@ -1235,7 +1235,7 @@ UINT_32 AddrLib1::Thickness(
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeHtileInfo
*
* @brief
@ -1243,7 +1243,7 @@ UINT_32 AddrLib1::Thickness(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeHtileInfo(
const ADDR_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] input structure
@ -1305,7 +1305,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeCmaskInfo
*
* @brief
@ -1313,7 +1313,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileInfo(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
const ADDR_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] input structure
@ -1371,7 +1371,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeDccInfo
*
* @brief
@ -1379,7 +1379,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
*
* @return
* return code of HwlComputeDccInfo
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeDccInfo(
const ADDR_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input structure
@ -1421,7 +1421,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeDccInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeHtileAddrFromCoord
*
* @brief
@ -1429,7 +1429,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeDccInfo(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeHtileAddrFromCoord(
const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
@ -1496,7 +1496,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeHtileCoordFromAddr
*
* @brief
@ -1504,7 +1504,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileAddrFromCoord(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeHtileCoordFromAddr(
const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
@ -1564,7 +1564,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileCoordFromAddr(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeCmaskAddrFromCoord
*
* @brief
@ -1572,7 +1572,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileCoordFromAddr(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeCmaskAddrFromCoord(
const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
@ -1636,7 +1636,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeCmaskCoordFromAddr
*
* @brief
@ -1644,7 +1644,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskAddrFromCoord(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeCmaskCoordFromAddr(
const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
@ -1702,7 +1702,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskCoordFromAddr(
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeTileDataWidthAndHeight
*
* @brief
@ -1713,7 +1713,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskCoordFromAddr(
*
* @note
* MacroWidth and macroHeight are measured in pixels
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrLib1::ComputeTileDataWidthAndHeight(
UINT_32 bpp, ///< [in] bits per pixel
@ -1746,7 +1746,7 @@ VOID AddrLib1::ComputeTileDataWidthAndHeight(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::HwlComputeTileDataWidthAndHeightLinear
*
* @brief
@ -1757,7 +1757,7 @@ VOID AddrLib1::ComputeTileDataWidthAndHeight(
*
* @note
* MacroWidth and macroHeight are measured in pixels
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrLib1::HwlComputeTileDataWidthAndHeightLinear(
UINT_32* pMacroWidth, ///< [out] macro tile width
@ -1772,7 +1772,7 @@ VOID AddrLib1::HwlComputeTileDataWidthAndHeightLinear(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeHtileInfo
*
* @brief
@ -1782,7 +1782,7 @@ VOID AddrLib1::HwlComputeTileDataWidthAndHeightLinear(
* Htile bpp i.e. How many bits for an 8x8 tile
* Also returns by output parameters:
* *Htile pitch, height, total size in bytes, macro-tile dimensions and slice size*
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 AddrLib1::ComputeHtileInfo(
ADDR_HTILE_FLAGS flags, ///< [in] htile flags
@ -1860,7 +1860,7 @@ UINT_32 AddrLib1::ComputeHtileInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeCmaskBaseAlign
*
* @brief
@ -1868,7 +1868,7 @@ UINT_32 AddrLib1::ComputeHtileInfo(
*
* @return
* Cmask base alignment
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 AddrLib1::ComputeCmaskBaseAlign(
ADDR_CMASK_FLAGS flags, ///< [in] Cmask flags
@ -1890,7 +1890,7 @@ UINT_32 AddrLib1::ComputeCmaskBaseAlign(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeCmaskBytes
*
* @brief
@ -1898,7 +1898,7 @@ UINT_32 AddrLib1::ComputeCmaskBaseAlign(
*
* @return
* Cmask size in bytes
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 AddrLib1::ComputeCmaskBytes(
UINT_32 pitch, ///< [in] pitch
@ -1911,7 +1911,7 @@ UINT_64 AddrLib1::ComputeCmaskBytes(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeCmaskInfo
*
* @brief
@ -1920,7 +1920,7 @@ UINT_64 AddrLib1::ComputeCmaskBytes(
* @return
* BlockMax. Also by output parameters: Cmask pitch,height, total size in bytes,
* macro-tile dimensions
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
ADDR_CMASK_FLAGS flags, ///< [in] cmask flags
@ -2026,7 +2026,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeXmaskCoordYFromPipe
*
* @brief
@ -2035,7 +2035,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
* @return
* Y coordinate
*
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 AddrLib1::ComputeXmaskCoordYFromPipe(
UINT_32 pipe, ///< [in] pipe number
@ -2118,7 +2118,7 @@ UINT_32 AddrLib1::ComputeXmaskCoordYFromPipe(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::HwlComputeXmaskCoordFromAddr
*
* @brief
@ -2129,7 +2129,7 @@ UINT_32 AddrLib1::ComputeXmaskCoordYFromPipe(
*
* @note
* This method is reused by htile, so rename to Xmask
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrLib1::HwlComputeXmaskCoordFromAddr(
UINT_64 addr, ///< [in] address
@ -2300,7 +2300,7 @@ VOID AddrLib1::HwlComputeXmaskCoordFromAddr(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::HwlComputeXmaskAddrFromCoord
*
* @brief
@ -2309,7 +2309,7 @@ VOID AddrLib1::HwlComputeXmaskCoordFromAddr(
* @return
* Address in bytes
*
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 AddrLib1::HwlComputeXmaskAddrFromCoord(
UINT_32 pitch, ///< [in] pitch
@ -2512,7 +2512,7 @@ UINT_64 AddrLib1::HwlComputeXmaskAddrFromCoord(
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeSurfaceAddrFromCoordLinear
*
* @brief
@ -2521,7 +2521,7 @@ UINT_64 AddrLib1::HwlComputeXmaskAddrFromCoord(
* @return
* Address in bytes
*
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 AddrLib1::ComputeSurfaceAddrFromCoordLinear(
UINT_32 x, ///< [in] x coord
@ -2550,7 +2550,7 @@ UINT_64 AddrLib1::ComputeSurfaceAddrFromCoordLinear(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeSurfaceCoordFromAddrLinear
*
* @brief
@ -2558,7 +2558,7 @@ UINT_64 AddrLib1::ComputeSurfaceAddrFromCoordLinear(
*
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrLib1::ComputeSurfaceCoordFromAddrLinear(
UINT_64 addr, ///< [in] address
@ -2583,7 +2583,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrLinear(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled
*
* @brief
@ -2591,7 +2591,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrLinear(
*
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled(
UINT_64 addr, ///< [in] address
@ -2705,7 +2705,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputePipeFromAddr
*
* @brief
@ -2714,7 +2714,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled(
* @return
* Pipe number
*
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 AddrLib1::ComputePipeFromAddr(
UINT_64 addr, ///< [in] address
@ -2745,7 +2745,7 @@ UINT_32 AddrLib1::ComputePipeFromAddr(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeMicroTileEquation
*
* @brief
@ -2754,7 +2754,7 @@ UINT_32 AddrLib1::ComputePipeFromAddr(
* @return
* If equation can be computed
*
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeMicroTileEquation(
UINT_32 log2BytesPP, ///< [in] log2 of bytes per pixel
@ -2958,7 +2958,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeMicroTileEquation(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputePixelIndexWithinMicroTile
*
* @brief
@ -2967,7 +2967,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeMicroTileEquation(
* @return
* Pixel index
*
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 AddrLib1::ComputePixelIndexWithinMicroTile(
UINT_32 x, ///< [in] x coord
@ -3173,7 +3173,7 @@ UINT_32 AddrLib1::ComputePixelIndexWithinMicroTile(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::AdjustPitchAlignment
*
* @brief
@ -3182,7 +3182,7 @@ UINT_32 AddrLib1::ComputePixelIndexWithinMicroTile(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrLib1::AdjustPitchAlignment(
ADDR_SURFACE_FLAGS flags, ///< [in] Surface flags
@ -3203,7 +3203,7 @@ VOID AddrLib1::AdjustPitchAlignment(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::PadDimensions
*
* @brief
@ -3212,7 +3212,7 @@ VOID AddrLib1::AdjustPitchAlignment(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrLib1::PadDimensions(
AddrTileMode tileMode, ///< [in] tile mode
@ -3309,7 +3309,7 @@ VOID AddrLib1::PadDimensions(
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::HwlPreHandleBaseLvl3xPitch
*
* @brief
@ -3317,7 +3317,7 @@ VOID AddrLib1::PadDimensions(
*
* @return
* Expected pitch
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input
@ -3340,7 +3340,7 @@ UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::HwlPostHandleBaseLvl3xPitch
*
* @brief
@ -3348,7 +3348,7 @@ UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
*
* @return
* Expected pitch
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input
@ -3371,7 +3371,7 @@ UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::IsMacroTiled
*
* @brief
@ -3379,7 +3379,7 @@ UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
*
* @return
* TRUE if it is macro tiled (2D/2B/3D/3B)
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 AddrLib1::IsMacroTiled(
AddrTileMode tileMode) ///< [in] tile mode
@ -3388,7 +3388,7 @@ BOOL_32 AddrLib1::IsMacroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::IsMacro3dTiled
*
* @brief
@ -3396,7 +3396,7 @@ BOOL_32 AddrLib1::IsMacroTiled(
*
* @return
* TRUE if it is 3D macro tiled
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 AddrLib1::IsMacro3dTiled(
AddrTileMode tileMode) ///< [in] tile mode
@ -3405,7 +3405,7 @@ BOOL_32 AddrLib1::IsMacro3dTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::IsMicroTiled
*
* @brief
@ -3413,7 +3413,7 @@ BOOL_32 AddrLib1::IsMacro3dTiled(
*
* @return
* TRUE if micro tiled
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 AddrLib1::IsMicroTiled(
AddrTileMode tileMode) ///< [in] tile mode
@ -3422,7 +3422,7 @@ BOOL_32 AddrLib1::IsMicroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::IsLinear
*
* @brief
@ -3430,7 +3430,7 @@ BOOL_32 AddrLib1::IsMicroTiled(
*
* @return
* TRUE if linear
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 AddrLib1::IsLinear(
AddrTileMode tileMode) ///< [in] tile mode
@ -3439,14 +3439,14 @@ BOOL_32 AddrLib1::IsLinear(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::IsPrtNoRotationTileMode
*
* @brief
* Return TRUE if it is prt tile without rotation
* @note
* This function just used by CI
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 AddrLib1::IsPrtNoRotationTileMode(
AddrTileMode tileMode)
@ -3455,14 +3455,14 @@ BOOL_32 AddrLib1::IsPrtNoRotationTileMode(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::IsPrtTileMode
*
* @brief
* Return TRUE if it is prt tile
* @note
* This function just used by CI
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 AddrLib1::IsPrtTileMode(
AddrTileMode tileMode)
@ -3471,14 +3471,14 @@ BOOL_32 AddrLib1::IsPrtTileMode(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeMipLevel
*
* @brief
* Compute mipmap level width/height/slices
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrLib1::ComputeMipLevel(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn ///< [in/out] Input structure
@ -3501,14 +3501,14 @@ VOID AddrLib1::ComputeMipLevel(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::OptimizeTileMode
*
* @brief
* Check if base level's tile mode can be optimized (degraded)
* @return
* TRUE if degraded, also returns degraded tile mode (unchanged if not degraded)
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 AddrLib1::OptimizeTileMode(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure for surface info
@ -3571,14 +3571,14 @@ BOOL_32 AddrLib1::OptimizeTileMode(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::DegradeLargeThickTile
*
* @brief
* Check if the thickness needs to be reduced if a tile is too large
* @return
* The degraded tile mode (unchanged if not degraded)
***************************************************************************************************
****************************************************************************************************
*/
AddrTileMode AddrLib1::DegradeLargeThickTile(
AddrTileMode tileMode,
@ -3641,13 +3641,13 @@ AddrTileMode AddrLib1::DegradeLargeThickTile(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::PostComputeMipLevel
* @brief
* Compute MipLevel info (including level 0) after surface adjustment
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::PostComputeMipLevel(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in/out] Input structure
@ -3681,14 +3681,14 @@ ADDR_E_RETURNCODE AddrLib1::PostComputeMipLevel(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::HwlSetupTileCfg
*
* @brief
* Map tile index to tile setting.
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::HwlSetupTileCfg(
UINT_32 bpp, ///< Bits per pixel
@ -3703,14 +3703,14 @@ ADDR_E_RETURNCODE AddrLib1::HwlSetupTileCfg(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::HwlGetPipes
*
* @brief
* Get number pipes
* @return
* num pipes
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 AddrLib1::HwlGetPipes(
const ADDR_TILEINFO* pTileInfo ///< [in] Tile info
@ -3721,14 +3721,14 @@ UINT_32 AddrLib1::HwlGetPipes(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputeQbStereoInfo
*
* @brief
* Get quad buffer stereo information
* @return
* TRUE if no error
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 AddrLib1::ComputeQbStereoInfo(
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [in/out] updated pOut+pStereoInfo
@ -3766,7 +3766,7 @@ BOOL_32 AddrLib1::ComputeQbStereoInfo(
/**
***************************************************************************************************
****************************************************************************************************
* AddrLib1::ComputePrtInfo
*
* @brief
@ -3774,7 +3774,7 @@ BOOL_32 AddrLib1::ComputeQbStereoInfo(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputePrtInfo(
const ADDR_PRT_INFO_INPUT* pIn,

16
src/amd/addrlib/core/addrlib1.h
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file addrlib1.h
* @brief Contains the AddrLib1 base class definition.
***************************************************************************************************
****************************************************************************************************
*/
#ifndef __ADDR_LIB1_H__
@ -38,9 +38,9 @@
/**
***************************************************************************************************
****************************************************************************************************
* @brief Neutral enums that define bank swap size
***************************************************************************************************
****************************************************************************************************
*/
enum AddrSampleSplitSize
{
@ -51,9 +51,9 @@ enum AddrSampleSplitSize
};
/**
***************************************************************************************************
****************************************************************************************************
* @brief Flags for AddrTileMode
***************************************************************************************************
****************************************************************************************************
*/
struct AddrTileModeFlags
{
@ -68,9 +68,9 @@ struct AddrTileModeFlags
};
/**
***************************************************************************************************
****************************************************************************************************
* @brief This class contains asic independent address lib functionalities
***************************************************************************************************
****************************************************************************************************
*/
class AddrLib1 : public AddrLib
{

48
src/amd/addrlib/core/addrobject.cpp
View File

@ -25,22 +25,22 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file addrobject.cpp
* @brief Contains the AddrObject base class implementation.
***************************************************************************************************
****************************************************************************************************
*/
#include "addrinterface.h"
#include "addrobject.h"
/**
***************************************************************************************************
****************************************************************************************************
* AddrObject::AddrObject
*
* @brief
* Constructor for the AddrObject class.
***************************************************************************************************
****************************************************************************************************
*/
AddrObject::AddrObject()
{
@ -51,12 +51,12 @@ AddrObject::AddrObject()
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrObject::AddrObject
*
* @brief
* Constructor for the AddrObject class.
***************************************************************************************************
****************************************************************************************************
*/
AddrObject::AddrObject(const AddrClient* pClient)
{
@ -64,24 +64,24 @@ AddrObject::AddrObject(const AddrClient* pClient)
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrObject::~AddrObject
*
* @brief
* Destructor for the AddrObject class.
***************************************************************************************************
****************************************************************************************************
*/
AddrObject::~AddrObject()
{
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrObject::ClientAlloc
*
* @brief
* Calls instanced allocSysMem inside AddrClient
***************************************************************************************************
****************************************************************************************************
*/
VOID* AddrObject::ClientAlloc(
size_t objSize, ///< [in] Size to allocate
@ -105,12 +105,12 @@ VOID* AddrObject::ClientAlloc(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrObject::AddrMalloc
*
* @brief
* A wrapper of ClientAlloc
***************************************************************************************************
****************************************************************************************************
*/
VOID* AddrObject::AddrMalloc(
size_t objSize) const ///< [in] Size to allocate
@ -119,12 +119,12 @@ VOID* AddrObject::AddrMalloc(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrObject::ClientFree
*
* @brief
* Calls freeSysMem inside AddrClient
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrObject::ClientFree(
VOID* pObjMem, ///< [in] User virtual address to free.
@ -146,12 +146,12 @@ VOID AddrObject::ClientFree(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrObject::AddrFree
*
* @brief
* A wrapper of ClientFree
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrObject::AddrFree(
VOID* pObjMem) const ///< [in] User virtual address to free.
@ -160,7 +160,7 @@ VOID AddrObject::AddrFree(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrObject::operator new
*
* @brief
@ -168,7 +168,7 @@ VOID AddrObject::AddrFree(
*
* @return
* Returns NULL if unsuccessful.
***************************************************************************************************
****************************************************************************************************
*/
VOID* AddrObject::operator new(
size_t objSize, ///< [in] Size to allocate
@ -179,12 +179,12 @@ VOID* AddrObject::operator new(
/**
***************************************************************************************************
****************************************************************************************************
* AddrObject::operator delete
*
* @brief
* Frees AddrObject object memory.
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrObject::operator delete(
VOID* pObjMem, ///< [in] User virtual address to free.
@ -194,12 +194,12 @@ VOID AddrObject::operator delete(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrObject::operator delete
*
* @brief
* Frees AddrObject object memory.
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrObject::operator delete(
VOID* pObjMem) ///< [in] User virtual address to free.
@ -209,7 +209,7 @@ VOID AddrObject::operator delete(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrObject::DebugPrint
*
* @brief
@ -217,7 +217,7 @@ VOID AddrObject::operator delete(
*
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID AddrObject::DebugPrint(
const CHAR* pDebugString, ///< [in] Debug string

12
src/amd/addrlib/core/addrobject.h
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file addrobject.h
* @brief Contains the AddrObject base class definition.
***************************************************************************************************
****************************************************************************************************
*/
#ifndef __ADDR_OBJECT_H__
@ -38,9 +38,9 @@
#include "addrcommon.h"
/**
***************************************************************************************************
****************************************************************************************************
* @brief This structure contains client specific data
***************************************************************************************************
****************************************************************************************************
*/
struct AddrClient
{
@ -48,9 +48,9 @@ struct AddrClient
ADDR_CALLBACKS callbacks;
};
/**
***************************************************************************************************
****************************************************************************************************
* @brief This class is the base class for all ADDR class objects.
***************************************************************************************************
****************************************************************************************************
*/
class AddrObject
{

130
src/amd/addrlib/r800/ciaddrlib.cpp
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file ciaddrlib.cpp
* @brief Contains the implementation for the CiAddrLib class.
***************************************************************************************************
****************************************************************************************************
*/
#include "ciaddrlib.h"
@ -49,14 +49,14 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
****************************************************************************************************
* AddrMask
*
* @brief
* Gets a mask of "width"
* @return
* Bit mask
***************************************************************************************************
****************************************************************************************************
*/
static UINT_64 AddrMask(
UINT_32 width) ///< Width of bits
@ -75,14 +75,14 @@ static UINT_64 AddrMask(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrGetBits
*
* @brief
* Gets bits within a range of [msb, lsb]
* @return
* Bits of this range
***************************************************************************************************
****************************************************************************************************
*/
static UINT_64 AddrGetBits(
UINT_64 bits, ///< Source bits
@ -99,14 +99,14 @@ static UINT_64 AddrGetBits(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrRemoveBits
*
* @brief
* Removes bits within the range of [msb, lsb]
* @return
* Modified bits
***************************************************************************************************
****************************************************************************************************
*/
static UINT_64 AddrRemoveBits(
UINT_64 bits, ///< Source bits
@ -124,14 +124,14 @@ static UINT_64 AddrRemoveBits(
}
/**
***************************************************************************************************
****************************************************************************************************
* AddrInsertBits
*
* @brief
* Inserts new bits into the range of [msb, lsb]
* @return
* Modified bits
***************************************************************************************************
****************************************************************************************************
*/
static UINT_64 AddrInsertBits(
UINT_64 bits, ///< Source bits
@ -152,15 +152,15 @@ static UINT_64 AddrInsertBits(
/**
***************************************************************************************************
* AddrCIHwlInit
****************************************************************************************************
* AddrCiHwlInit
*
* @brief
* Creates an CiAddrLib object.
*
* @return
* Returns an CiAddrLib object pointer.
***************************************************************************************************
****************************************************************************************************
*/
AddrLib* AddrCIHwlInit(const AddrClient* pClient)
{
@ -168,13 +168,13 @@ AddrLib* AddrCIHwlInit(const AddrClient* pClient)
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::CiAddrLib
*
* @brief
* Constructor
*
***************************************************************************************************
****************************************************************************************************
*/
CiAddrLib::CiAddrLib(const AddrClient* pClient) :
SiAddrLib(pClient),
@ -186,26 +186,26 @@ CiAddrLib::CiAddrLib(const AddrClient* pClient) :
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::~CiAddrLib
*
* @brief
* Destructor
***************************************************************************************************
****************************************************************************************************
*/
CiAddrLib::~CiAddrLib()
{
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlComputeDccInfo
*
* @brief
* Compute DCC key size, base alignment
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE CiAddrLib::HwlComputeDccInfo(
const ADDR_COMPUTE_DCCINFO_INPUT* pIn,
@ -280,7 +280,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeDccInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlComputeCmaskAddrFromCoord
*
* @brief
@ -288,7 +288,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeDccInfo(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE CiAddrLib::HwlComputeCmaskAddrFromCoord(
const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] fmask addr/bpp/tile input
@ -324,7 +324,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeCmaskAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlComputeHtileAddrFromCoord
*
* @brief
@ -332,7 +332,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeCmaskAddrFromCoord(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE CiAddrLib::HwlComputeHtileAddrFromCoord(
const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] depth/stencil addr/bpp/tile input
@ -368,14 +368,14 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeHtileAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlConvertChipFamily
*
* @brief
* Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
* @return
* AddrChipFamily
***************************************************************************************************
****************************************************************************************************
*/
AddrChipFamily CiAddrLib::HwlConvertChipFamily(
UINT_32 uChipFamily, ///< [in] chip family defined in atiih.h
@ -418,7 +418,7 @@ AddrChipFamily CiAddrLib::HwlConvertChipFamily(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlInitGlobalParams
*
* @brief
@ -427,7 +427,7 @@ AddrChipFamily CiAddrLib::HwlConvertChipFamily(
* @return
* TRUE if all settings are valid
*
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 CiAddrLib::HwlInitGlobalParams(
const ADDR_CREATE_INPUT* pCreateIn) ///< [in] create input
@ -491,7 +491,7 @@ BOOL_32 CiAddrLib::HwlInitGlobalParams(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlPostCheckTileIndex
*
* @brief
@ -499,7 +499,7 @@ BOOL_32 CiAddrLib::HwlInitGlobalParams(
* tile mode/type/info and change the index if needed
* @return
* Tile index.
***************************************************************************************************
****************************************************************************************************
*/
INT_32 CiAddrLib::HwlPostCheckTileIndex(
const ADDR_TILEINFO* pInfo, ///< [in] Tile Info
@ -582,14 +582,14 @@ INT_32 CiAddrLib::HwlPostCheckTileIndex(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlSetupTileCfg
*
* @brief
* Map tile index to tile setting.
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE CiAddrLib::HwlSetupTileCfg(
UINT_32 bpp, ///< [in] Bits per pixel
@ -681,14 +681,14 @@ ADDR_E_RETURNCODE CiAddrLib::HwlSetupTileCfg(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlComputeSurfaceInfo
*
* @brief
* Entry of ci's ComputeSurfaceInfo
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE CiAddrLib::HwlComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
@ -715,13 +715,13 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeSurfaceInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlFmaskSurfaceInfo
* @brief
* Entry of r800's ComputeFmaskInfo
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE CiAddrLib::HwlComputeFmaskInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
@ -802,14 +802,14 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeFmaskInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlFmaskPreThunkSurfInfo
*
* @brief
* Some preparation before thunking a ComputeSurfaceInfo call for Fmask
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
VOID CiAddrLib::HwlFmaskPreThunkSurfInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pFmaskIn, ///< [in] Input of fmask info
@ -823,14 +823,14 @@ VOID CiAddrLib::HwlFmaskPreThunkSurfInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlFmaskPostThunkSurfInfo
*
* @brief
* Copy hwl extra field after calling thunked ComputeSurfaceInfo
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
VOID CiAddrLib::HwlFmaskPostThunkSurfInfo(
const ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pSurfOut, ///< [in] Output of surface info
@ -842,7 +842,7 @@ VOID CiAddrLib::HwlFmaskPostThunkSurfInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlDegradeThickTileMode
*
* @brief
@ -850,7 +850,7 @@ VOID CiAddrLib::HwlFmaskPostThunkSurfInfo(
*
* @return
* Suitable tile mode
***************************************************************************************************
****************************************************************************************************
*/
AddrTileMode CiAddrLib::HwlDegradeThickTileMode(
AddrTileMode baseTileMode, ///< [in] base tile mode
@ -862,7 +862,7 @@ AddrTileMode CiAddrLib::HwlDegradeThickTileMode(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlOverrideTileMode
*
* @brief
@ -871,7 +871,7 @@ AddrTileMode CiAddrLib::HwlDegradeThickTileMode(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
VOID CiAddrLib::HwlOverrideTileMode(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut ///< [in/out] input output structure
@ -1023,7 +1023,7 @@ VOID CiAddrLib::HwlOverrideTileMode(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlSelectTileMode
*
* @brief
@ -1032,7 +1032,7 @@ VOID CiAddrLib::HwlOverrideTileMode(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
VOID CiAddrLib::HwlSelectTileMode(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut ///< [in/out] input output structure
@ -1119,12 +1119,12 @@ VOID CiAddrLib::HwlSelectTileMode(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlSetupTileInfo
*
* @brief
* Setup default value of tile info for SI
***************************************************************************************************
****************************************************************************************************
*/
VOID CiAddrLib::HwlSetupTileInfo(
AddrTileMode tileMode, ///< [in] Tile mode
@ -1452,14 +1452,14 @@ VOID CiAddrLib::HwlSetupTileInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::ReadGbTileMode
*
* @brief
* Convert GB_TILE_MODE HW value to ADDR_TILE_CONFIG.
* @return
* NA.
***************************************************************************************************
****************************************************************************************************
*/
VOID CiAddrLib::ReadGbTileMode(
UINT_32 regValue, ///< [in] GB_TILE_MODE register
@ -1528,14 +1528,14 @@ VOID CiAddrLib::ReadGbTileMode(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::InitTileSettingTable
*
* @brief
* Initialize the ADDR_TILE_CONFIG table.
* @return
* TRUE if tile table is correctly initialized
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 CiAddrLib::InitTileSettingTable(
const UINT_32* pCfg, ///< [in] Pointer to table of tile configs
@ -1597,14 +1597,14 @@ BOOL_32 CiAddrLib::InitTileSettingTable(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::ReadGbMacroTileCfg
*
* @brief
* Convert GB_MACRO_TILE_CFG HW value to ADDR_TILE_CONFIG.
* @return
* NA.
***************************************************************************************************
****************************************************************************************************
*/
VOID CiAddrLib::ReadGbMacroTileCfg(
UINT_32 regValue, ///< [in] GB_MACRO_TILE_MODE register
@ -1621,14 +1621,14 @@ VOID CiAddrLib::ReadGbMacroTileCfg(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::InitMacroTileCfgTable
*
* @brief
* Initialize the ADDR_MACRO_TILE_CONFIG table.
* @return
* TRUE if macro tile table is correctly initialized
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 CiAddrLib::InitMacroTileCfgTable(
const UINT_32* pCfg, ///< [in] Pointer to table of tile configs
@ -1668,14 +1668,14 @@ BOOL_32 CiAddrLib::InitMacroTileCfgTable(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlComputeMacroModeIndex
*
* @brief
* Computes macro tile mode index
* @return
* TRUE if macro tile table is correctly initialized
***************************************************************************************************
****************************************************************************************************
*/
INT_32 CiAddrLib::HwlComputeMacroModeIndex(
INT_32 tileIndex, ///< [in] Tile mode index
@ -1768,7 +1768,7 @@ INT_32 CiAddrLib::HwlComputeMacroModeIndex(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlComputeTileDataWidthAndHeightLinear
*
* @brief
@ -1779,7 +1779,7 @@ INT_32 CiAddrLib::HwlComputeMacroModeIndex(
*
* @note
* MacroWidth and macroHeight are measured in pixels
***************************************************************************************************
****************************************************************************************************
*/
VOID CiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
UINT_32* pMacroWidth, ///< [out] macro tile width
@ -1813,7 +1813,7 @@ VOID CiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlComputeMetadataNibbleAddress
*
* @brief
@ -1833,7 +1833,7 @@ VOID CiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
* @return
* meta data nibble address (nibble address is used to support DCC compatible cmask)
*
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
UINT_64 uncompressedDataByteAddress,
@ -1934,7 +1934,7 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlPadDimensions
*
* @brief
@ -1943,7 +1943,7 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
VOID CiAddrLib::HwlPadDimensions(
AddrTileMode tileMode, ///< [in] tile mode
@ -2020,14 +2020,14 @@ VOID CiAddrLib::HwlPadDimensions(
}
/**
***************************************************************************************************
****************************************************************************************************
* CiAddrLib::HwlGetMaxAlignments
*
* @brief
* Gets maximum alignments
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE CiAddrLib::HwlGetMaxAlignments(
ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut ///< [out] output structure

12
src/amd/addrlib/r800/ciaddrlib.h
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file ciaddrlib.h
* @brief Contains the CiAddrLib class definition.
***************************************************************************************************
****************************************************************************************************
*/
#ifndef __CI_ADDR_LIB_H__
@ -38,9 +38,9 @@
#include "siaddrlib.h"
/**
***************************************************************************************************
****************************************************************************************************
* @brief CI specific settings structure.
***************************************************************************************************
****************************************************************************************************
*/
struct CIChipSettings
{
@ -69,10 +69,10 @@ struct CIChipSettings
};
/**
***************************************************************************************************
****************************************************************************************************
* @brief This class is the CI specific address library
* function set.
***************************************************************************************************
****************************************************************************************************
*/
class CiAddrLib : public SiAddrLib
{

236
src/amd/addrlib/r800/egbaddrlib.cpp
View File

@ -25,16 +25,16 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file egbaddrlib.cpp
* @brief Contains the EgBasedAddrLib class implementation
***************************************************************************************************
****************************************************************************************************
*/
#include "egbaddrlib.h"
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::EgBasedAddrLib
*
* @brief
@ -42,7 +42,7 @@
*
* @note
*
***************************************************************************************************
****************************************************************************************************
*/
EgBasedAddrLib::EgBasedAddrLib(const AddrClient* pClient) :
AddrLib1(pClient),
@ -53,19 +53,19 @@ EgBasedAddrLib::EgBasedAddrLib(const AddrClient* pClient) :
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::~EgBasedAddrLib
*
* @brief
* Destructor
***************************************************************************************************
****************************************************************************************************
*/
EgBasedAddrLib::~EgBasedAddrLib()
{
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::DispatchComputeSurfaceInfo
*
* @brief
@ -75,7 +75,7 @@ EgBasedAddrLib::~EgBasedAddrLib()
*
* @return
* TRUE if no error occurs
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::DispatchComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
@ -197,7 +197,7 @@ BOOL_32 EgBasedAddrLib::DispatchComputeSurfaceInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceInfoLinear
*
* @brief
@ -207,7 +207,7 @@ BOOL_32 EgBasedAddrLib::DispatchComputeSurfaceInfo(
*
* @return
* TRUE if no error occurs
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoLinear(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure
@ -292,7 +292,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoLinear(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceInfoMicroTiled
*
* @brief
@ -302,7 +302,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoLinear(
*
* @return
* TRUE if no error occurs
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMicroTiled(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure
@ -402,7 +402,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMicroTiled(
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceInfoMacroTiled
*
* @brief
@ -412,7 +412,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMicroTiled(
*
* @return
* TRUE if no error occurs
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMacroTiled(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure
@ -614,7 +614,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMacroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceAlignmentsLinear
*
* @brief
@ -623,7 +623,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMacroTiled(
*
* @return
* TRUE if no error occurs
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsLinear(
AddrTileMode tileMode, ///< [in] tile mode
@ -670,7 +670,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsLinear(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled
*
* @brief
@ -679,7 +679,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsLinear(
*
* @return
* TRUE if no error occurs
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled(
AddrTileMode tileMode, ///< [in] tile mode
@ -720,7 +720,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled(
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlReduceBankWidthHeight
*
* @brief
@ -729,7 +729,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled(
*
* @return
* TRUE if no error occurs
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::HwlReduceBankWidthHeight(
UINT_32 tileSize, ///< [in] tile size
@ -824,7 +824,7 @@ BOOL_32 EgBasedAddrLib::HwlReduceBankWidthHeight(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled
*
* @brief
@ -833,7 +833,7 @@ BOOL_32 EgBasedAddrLib::HwlReduceBankWidthHeight(
*
* @return
* TRUE if no error occurs
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled(
AddrTileMode tileMode, ///< [in] tile mode
@ -948,14 +948,14 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::SanityCheckMacroTiled
*
* @brief
* Check if macro-tiled parameters are valid
* @return
* TRUE if valid
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::SanityCheckMacroTiled(
ADDR_TILEINFO* pTileInfo ///< [in] macro-tiled parameters
@ -1053,7 +1053,7 @@ BOOL_32 EgBasedAddrLib::SanityCheckMacroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceMipLevelTileMode
*
* @brief
@ -1061,7 +1061,7 @@ BOOL_32 EgBasedAddrLib::SanityCheckMacroTiled(
*
* @return
* Suitable tile mode
***************************************************************************************************
****************************************************************************************************
*/
AddrTileMode EgBasedAddrLib::ComputeSurfaceMipLevelTileMode(
AddrTileMode baseTileMode, ///< [in] base tile mode
@ -1145,13 +1145,13 @@ AddrTileMode EgBasedAddrLib::ComputeSurfaceMipLevelTileMode(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlDegradeBaseLevel
* @brief
* Check if degrade is needed for base level
* @return
* TRUE if degrade is suggested
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::HwlDegradeBaseLevel(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn) const
@ -1229,7 +1229,7 @@ BOOL_32 EgBasedAddrLib::HwlDegradeBaseLevel(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlDegradeThickTileMode
*
* @brief
@ -1237,7 +1237,7 @@ BOOL_32 EgBasedAddrLib::HwlDegradeBaseLevel(
*
* @return
* Suitable tile mode
***************************************************************************************************
****************************************************************************************************
*/
AddrTileMode EgBasedAddrLib::HwlDegradeThickTileMode(
AddrTileMode baseTileMode, ///< [in] base tile mode
@ -1302,7 +1302,7 @@ AddrTileMode EgBasedAddrLib::HwlDegradeThickTileMode(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord
*
* @brief
@ -1310,7 +1310,7 @@ AddrTileMode EgBasedAddrLib::HwlDegradeThickTileMode(
*
* @return
* Address in bytes
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord(
const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
@ -1467,14 +1467,14 @@ UINT_64 EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeMacroTileEquation
*
* @brief
* Computes the address equation in macro tile
* @return
* If equation can be computed
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::ComputeMacroTileEquation(
UINT_32 log2BytesPP, ///< [in] log2 of bytes per pixel
@ -1598,7 +1598,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::ComputeMacroTileEquation(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled
*
* @brief
@ -1606,7 +1606,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::ComputeMacroTileEquation(
* coordinate for 2D tilied (macro tiled)
* @return
* The byte address
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMacroTiled(
UINT_32 x, ///< [in] x coordinate
@ -1873,7 +1873,7 @@ UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMacroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled
*
* @brief
@ -1881,7 +1881,7 @@ UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMacroTiled(
* (micro tiled)
* @return
* The byte address
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled(
UINT_32 x, ///< [in] x coordinate
@ -1998,14 +1998,14 @@ UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlComputePixelCoordFromOffset
*
* @brief
* Compute pixel coordinate from offset inside a micro tile
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID EgBasedAddrLib::HwlComputePixelCoordFromOffset(
UINT_32 offset, ///< [in] offset inside micro tile in bits
@ -2187,14 +2187,14 @@ VOID EgBasedAddrLib::HwlComputePixelCoordFromOffset(
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddrDispatch
*
* @brief
* Compute (x,y,slice,sample) coordinates from surface address
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddr(
const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
@ -2332,14 +2332,14 @@ VOID EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddr(
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled
*
* @brief
* Compute surface coordinates from address for macro tiled surface
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled(
UINT_64 addr, ///< [in] byte address
@ -2490,14 +2490,14 @@ VOID EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceCoord2DFromBankPipe
*
* @brief
* Compute surface x,y coordinates from bank/pipe info
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID EgBasedAddrLib::ComputeSurfaceCoord2DFromBankPipe(
AddrTileMode tileMode, ///< [in] tile mode
@ -2676,13 +2676,13 @@ VOID EgBasedAddrLib::ComputeSurfaceCoord2DFromBankPipe(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlExtractBankPipeSwizzle
* @brief
* Entry of EgBasedAddrLib ExtractBankPipeSwizzle
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlExtractBankPipeSwizzle(
const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn, ///< [in] input structure
@ -2699,13 +2699,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlExtractBankPipeSwizzle(
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlCombineBankPipeSwizzle
* @brief
* Combine bank/pipe swizzle
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlCombineBankPipeSwizzle(
UINT_32 bankSwizzle, ///< [in] bank swizzle
@ -2730,13 +2730,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlCombineBankPipeSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlComputeBaseSwizzle
* @brief
* Compute base swizzle
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeBaseSwizzle(
const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn,
@ -2805,13 +2805,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeBaseSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ExtractBankPipeSwizzle
* @brief
* Extract bank/pipe swizzle from base256b
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID EgBasedAddrLib::ExtractBankPipeSwizzle(
UINT_32 base256b, ///< [in] input base256b register value
@ -2843,13 +2843,13 @@ VOID EgBasedAddrLib::ExtractBankPipeSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::GetBankPipeSwizzle
* @brief
* Combine bank/pipe swizzle
* @return
* Base256b bits (only filled bank/pipe bits)
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::GetBankPipeSwizzle(
UINT_32 bankSwizzle, ///< [in] bank swizzle
@ -2869,13 +2869,13 @@ UINT_32 EgBasedAddrLib::GetBankPipeSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeSliceTileSwizzle
* @brief
* Compute cubemap/3d texture faces/slices tile swizzle
* @return
* Tile swizzle
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::ComputeSliceTileSwizzle(
AddrTileMode tileMode, ///< [in] Tile mode
@ -2934,14 +2934,14 @@ UINT_32 EgBasedAddrLib::ComputeSliceTileSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlComputeQbStereoRightSwizzle
*
* @brief
* Compute right eye swizzle
* @return
* swizzle
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::HwlComputeQbStereoRightSwizzle(
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pInfo ///< [in] Surface info, must be valid
@ -2966,14 +2966,14 @@ UINT_32 EgBasedAddrLib::HwlComputeQbStereoRightSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeBankFromCoord
*
* @brief
* Compute bank number from coordinates
* @return
* Bank number
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::ComputeBankFromCoord(
UINT_32 x, ///< [in] x coordinate
@ -3098,14 +3098,14 @@ UINT_32 EgBasedAddrLib::ComputeBankFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeBankFromAddr
*
* @brief
* Compute the bank number from an address
* @return
* Bank number
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::ComputeBankFromAddr(
UINT_64 addr, ///< [in] address
@ -3131,14 +3131,14 @@ UINT_32 EgBasedAddrLib::ComputeBankFromAddr(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputePipeRotation
*
* @brief
* Compute pipe rotation value
* @return
* Pipe rotation
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::ComputePipeRotation(
AddrTileMode tileMode, ///< [in] tile mode
@ -3166,14 +3166,14 @@ UINT_32 EgBasedAddrLib::ComputePipeRotation(
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeBankRotation
*
* @brief
* Compute bank rotation value
* @return
* Bank rotation
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::ComputeBankRotation(
AddrTileMode tileMode, ///< [in] tile mode
@ -3209,7 +3209,7 @@ UINT_32 EgBasedAddrLib::ComputeBankRotation(
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeHtileBytes
*
* @brief
@ -3217,7 +3217,7 @@ UINT_32 EgBasedAddrLib::ComputeBankRotation(
*
* @return
* Htile size in bytes
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::ComputeHtileBytes(
UINT_32 pitch, ///< [in] pitch
@ -3252,7 +3252,7 @@ UINT_64 EgBasedAddrLib::ComputeHtileBytes(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::DispatchComputeFmaskInfo
*
* @brief
@ -3262,7 +3262,7 @@ UINT_64 EgBasedAddrLib::ComputeHtileBytes(
*
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::DispatchComputeFmaskInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
@ -3329,13 +3329,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::DispatchComputeFmaskInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlFmaskSurfaceInfo
* @brief
* Entry of EgBasedAddrLib ComputeFmaskInfo
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
@ -3371,13 +3371,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlComputeFmaskAddrFromCoord
* @brief
* Entry of EgBasedAddrLib ComputeFmaskAddrFromCoord
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskAddrFromCoord(
const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
@ -3404,13 +3404,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlComputeFmaskCoordFromAddr
* @brief
* Entry of EgBasedAddrLib ComputeFmaskCoordFromAddr
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskCoordFromAddr(
const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
@ -3436,14 +3436,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskCoordFromAddr(
#if ADDR_AM_BUILD
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord
*
* @brief
* Computes the FMASK address and bit position from a coordinate.
* @return
* The byte address
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord(
const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
@ -3525,7 +3525,7 @@ UINT_64 EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled
*
* @brief
@ -3533,7 +3533,7 @@ UINT_64 EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord(
* tiled)
* @return
* The byte address
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled(
UINT_32 x, ///< [in] x coordinate
@ -3633,7 +3633,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled
*
* @brief
@ -3641,7 +3641,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled(
* tiled)
* @return
* The byte address
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled(
UINT_32 x, ///< [in] x coordinate
@ -3755,7 +3755,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled
*
* @brief
@ -3763,7 +3763,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled(
UINT_64 addr, ///< [in] byte address
@ -3842,7 +3842,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled
*
* @brief
@ -3851,7 +3851,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled(
UINT_64 addr, ///< [in] byte address
@ -3942,7 +3942,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr
*
* @brief
@ -3951,7 +3951,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
VOID EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr(
const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
@ -4032,7 +4032,7 @@ VOID EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr(
#endif
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples
*
* @brief
@ -4040,7 +4040,7 @@ VOID EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr(
*
* @return
* Number of planes
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples(
UINT_32 numSamples) ///< [in] number of samples
@ -4077,7 +4077,7 @@ UINT_32 EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples
*
* @brief
@ -4085,7 +4085,7 @@ UINT_32 EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples(
*
* @return
* bpp
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples(
UINT_32 numSamples) ///< number of samples
@ -4122,14 +4122,14 @@ UINT_32 EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::IsTileInfoAllZero
*
* @brief
* Return TRUE if all field are zero
* @note
* Since NULL input is consider to be all zero
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::IsTileInfoAllZero(
ADDR_TILEINFO* pTileInfo)
@ -4154,14 +4154,14 @@ BOOL_32 EgBasedAddrLib::IsTileInfoAllZero(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlTileInfoEqual
*
* @brief
* Return TRUE if all field are equal
* @note
* Only takes care of current HWL's data
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::HwlTileInfoEqual(
const ADDR_TILEINFO* pLeft, ///<[in] Left compare operand
@ -4183,13 +4183,13 @@ BOOL_32 EgBasedAddrLib::HwlTileInfoEqual(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlConvertTileInfoToHW
* @brief
* Entry of EgBasedAddrLib ConvertTileInfoToHW
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlConvertTileInfoToHW(
const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
@ -4451,13 +4451,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlConvertTileInfoToHW(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlComputeSurfaceInfo
* @brief
* Entry of EgBasedAddrLib ComputeSurfaceInfo
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
@ -4538,13 +4538,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlComputeSurfaceAddrFromCoord
* @brief
* Entry of EgBasedAddrLib ComputeSurfaceAddrFromCoord
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceAddrFromCoord(
const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
@ -4571,13 +4571,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlComputeSurfaceCoordFromAddr
* @brief
* Entry of EgBasedAddrLib ComputeSurfaceCoordFromAddr
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceCoordFromAddr(
const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
@ -4599,13 +4599,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceCoordFromAddr(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlComputeSliceTileSwizzle
* @brief
* Entry of EgBasedAddrLib ComputeSurfaceCoordFromAddr
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSliceTileSwizzle(
const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn, ///< [in] input structure
@ -4632,7 +4632,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSliceTileSwizzle(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlComputeHtileBpp
*
* @brief
@ -4640,7 +4640,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSliceTileSwizzle(
*
* @return
* Htile bpp
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::HwlComputeHtileBpp(
BOOL_32 isWidth8, ///< [in] TRUE if block width is 8
@ -4653,7 +4653,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBpp(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlComputeHtileBaseAlign
*
* @brief
@ -4661,7 +4661,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBpp(
*
* @return
* Htile base alignment
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::HwlComputeHtileBaseAlign(
BOOL_32 isTcCompatible, ///< [in] if TC compatible
@ -4684,7 +4684,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBaseAlign(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled
*
* @brief
@ -4693,7 +4693,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBaseAlign(
*
* @return
* pitch alignment
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(
AddrTileMode tileMode, ///< [in] tile mode
@ -4733,7 +4733,7 @@ UINT_32 EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled
*
* @brief
@ -4741,7 +4741,7 @@ UINT_32 EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(
*
* @return
* Logical slice size in bytes
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled(
UINT_32 thickness, ///< [in] thickness
@ -4775,7 +4775,7 @@ UINT_64 EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* EgBasedAddrLib::HwlStereoCheckRightOffsetPadding
*
* @brief
@ -4784,7 +4784,7 @@ UINT_64 EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled(
* @return
* TRUE is the extra padding is needed
*
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::HwlStereoCheckRightOffsetPadding(
ADDR_TILEINFO* pTileInfo ///< Tiling info

8
src/amd/addrlib/r800/egbaddrlib.h
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file egbaddrlib.h
* @brief Contains the EgBasedAddrLib class definition.
***************************************************************************************************
****************************************************************************************************
*/
#ifndef __EG_BASED_ADDR_LIB_H__
@ -53,10 +53,10 @@ struct CoordFromBankPipe
};
/**
***************************************************************************************************
****************************************************************************************************
* @brief This class is the Evergreen based address library
* @note Abstract class
***************************************************************************************************
****************************************************************************************************
*/
class EgBasedAddrLib : public AddrLib1
{

194
src/amd/addrlib/r800/siaddrlib.cpp
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file siaddrlib.cpp
* @brief Contains the implementation for the SiAddrLib class.
***************************************************************************************************
****************************************************************************************************
*/
#include "siaddrlib.h"
@ -47,15 +47,15 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
***************************************************************************************************
* AddrSIHwlInit
****************************************************************************************************
* AddrSiHwlInit
*
* @brief
* Creates an SiAddrLib object.
*
* @return
* Returns an SiAddrLib object pointer.
***************************************************************************************************
****************************************************************************************************
*/
AddrLib* AddrSIHwlInit(const AddrClient* pClient)
{
@ -63,13 +63,13 @@ AddrLib* AddrSIHwlInit(const AddrClient* pClient)
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::SiAddrLib
*
* @brief
* Constructor
*
***************************************************************************************************
****************************************************************************************************
*/
SiAddrLib::SiAddrLib(const AddrClient* pClient) :
EgBasedAddrLib(pClient),
@ -81,26 +81,26 @@ SiAddrLib::SiAddrLib(const AddrClient* pClient) :
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::~SiAddrLib
*
* @brief
* Destructor
***************************************************************************************************
****************************************************************************************************
*/
SiAddrLib::~SiAddrLib()
{
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlGetPipes
*
* @brief
* Get number pipes
* @return
* num pipes
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlGetPipes(
const ADDR_TILEINFO* pTileInfo ///< [in] Tile info
@ -122,13 +122,13 @@ UINT_32 SiAddrLib::HwlGetPipes(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::GetPipePerSurf
* @brief
* get pipe num base on inputing tileinfo->pipeconfig
* @return
* pipe number
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 SiAddrLib::GetPipePerSurf(
AddrPipeCfg pipeConfig ///< [in] pipe config
@ -168,7 +168,7 @@ UINT_32 SiAddrLib::GetPipePerSurf(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::ComputeBankEquation
*
* @brief
@ -176,7 +176,7 @@ UINT_32 SiAddrLib::GetPipePerSurf(
*
* @return
* If equation can be computed
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE SiAddrLib::ComputeBankEquation(
UINT_32 log2BytesPP, ///< [in] log2 of bytes per pixel
@ -302,7 +302,7 @@ ADDR_E_RETURNCODE SiAddrLib::ComputeBankEquation(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::ComputePipeEquation
*
* @brief
@ -310,7 +310,7 @@ ADDR_E_RETURNCODE SiAddrLib::ComputeBankEquation(
*
* @return
* If equation can be computed
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE SiAddrLib::ComputePipeEquation(
UINT_32 log2BytesPP, ///< [in] Log2 of bytes per pixel
@ -500,14 +500,14 @@ ADDR_E_RETURNCODE SiAddrLib::ComputePipeEquation(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::ComputePipeFromCoord
*
* @brief
* Compute pipe number from coordinates
* @return
* Pipe number
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 SiAddrLib::ComputePipeFromCoord(
UINT_32 x, ///< [in] x coordinate
@ -651,14 +651,14 @@ UINT_32 SiAddrLib::ComputePipeFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::ComputeTileCoordFromPipeAndElemIdx
*
* @brief
* Compute (x,y) of a tile within a macro tile from address
* @return
* Pipe number
***************************************************************************************************
****************************************************************************************************
*/
VOID SiAddrLib::ComputeTileCoordFromPipeAndElemIdx(
UINT_32 elemIdx, ///< [in] per pipe element index within a macro tile
@ -908,14 +908,14 @@ VOID SiAddrLib::ComputeTileCoordFromPipeAndElemIdx(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::TileCoordToMaskElementIndex
*
* @brief
* Compute element index from coordinates in tiles
* @return
* Element index
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 SiAddrLib::TileCoordToMaskElementIndex(
UINT_32 tx, ///< [in] x coord, in Tiles
@ -1044,7 +1044,7 @@ UINT_32 SiAddrLib::TileCoordToMaskElementIndex(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlComputeTileDataWidthAndHeightLinear
*
* @brief
@ -1055,7 +1055,7 @@ UINT_32 SiAddrLib::TileCoordToMaskElementIndex(
*
* @note
* MacroWidth and macroHeight are measured in pixels
***************************************************************************************************
****************************************************************************************************
*/
VOID SiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
UINT_32* pMacroWidth, ///< [out] macro tile width
@ -1090,7 +1090,7 @@ VOID SiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlComputeHtileBytes
*
* @brief
@ -1098,7 +1098,7 @@ VOID SiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
*
* @return
* Htile size in bytes
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 SiAddrLib::HwlComputeHtileBytes(
UINT_32 pitch, ///< [in] pitch
@ -1114,14 +1114,14 @@ UINT_64 SiAddrLib::HwlComputeHtileBytes(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlComputeXmaskAddrFromCoord
*
* @brief
* Compute address from coordinates for htile/cmask
* @return
* Byte address
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 SiAddrLib::HwlComputeXmaskAddrFromCoord(
UINT_32 pitch, ///< [in] pitch
@ -1269,7 +1269,7 @@ UINT_64 SiAddrLib::HwlComputeXmaskAddrFromCoord(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlComputeXmaskCoordFromAddr
*
* @brief
@ -1280,7 +1280,7 @@ UINT_64 SiAddrLib::HwlComputeXmaskAddrFromCoord(
*
* @note
* This method is reused by htile, so rename to Xmask
***************************************************************************************************
****************************************************************************************************
*/
VOID SiAddrLib::HwlComputeXmaskCoordFromAddr(
UINT_64 addr, ///< [in] address
@ -1475,13 +1475,13 @@ VOID SiAddrLib::HwlComputeXmaskCoordFromAddr(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlGetPitchAlignmentLinear
* @brief
* Get pitch alignment
* @return
* pitch alignment
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlGetPitchAlignmentLinear(
UINT_32 bpp, ///< [in] bits per pixel
@ -1505,7 +1505,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentLinear(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlGetSizeAdjustmentLinear
*
* @brief
@ -1513,7 +1513,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentLinear(
*
* @return
* Logical slice size in bytes
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 SiAddrLib::HwlGetSizeAdjustmentLinear(
AddrTileMode tileMode, ///< [in] tile mode
@ -1566,7 +1566,7 @@ UINT_64 SiAddrLib::HwlGetSizeAdjustmentLinear(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlPreHandleBaseLvl3xPitch
*
* @brief
@ -1574,7 +1574,7 @@ UINT_64 SiAddrLib::HwlGetSizeAdjustmentLinear(
*
* @return
* Expected pitch
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input
@ -1598,7 +1598,7 @@ UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlPostHandleBaseLvl3xPitch
*
* @brief
@ -1606,7 +1606,7 @@ UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
*
* @return
* Expected pitch
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input
@ -1627,7 +1627,7 @@ UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlGetPitchAlignmentMicroTiled
*
* @brief
@ -1635,7 +1635,7 @@ UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
*
* @return
* pitch alignment
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
AddrTileMode tileMode, ///< [in] tile mode
@ -1659,7 +1659,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlGetSizeAdjustmentMicroTiled
*
* @brief
@ -1667,7 +1667,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
*
* @return
* Logical slice size in bytes
***************************************************************************************************
****************************************************************************************************
*/
UINT_64 SiAddrLib::HwlGetSizeAdjustmentMicroTiled(
UINT_32 thickness, ///< [in] thickness
@ -1739,14 +1739,14 @@ UINT_64 SiAddrLib::HwlGetSizeAdjustmentMicroTiled(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlConvertChipFamily
*
* @brief
* Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
* @return
* AddrChipFamily
***************************************************************************************************
****************************************************************************************************
*/
AddrChipFamily SiAddrLib::HwlConvertChipFamily(
UINT_32 uChipFamily, ///< [in] chip family defined in atiih.h
@ -1773,12 +1773,12 @@ AddrChipFamily SiAddrLib::HwlConvertChipFamily(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlSetupTileInfo
*
* @brief
* Setup default value of tile info for SI
***************************************************************************************************
****************************************************************************************************
*/
VOID SiAddrLib::HwlSetupTileInfo(
AddrTileMode tileMode, ///< [in] Tile mode
@ -2096,7 +2096,7 @@ VOID SiAddrLib::HwlSetupTileInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::DecodeGbRegs
*
* @brief
@ -2105,7 +2105,7 @@ VOID SiAddrLib::HwlSetupTileInfo(
* @return
* TRUE if all settings are valid
*
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 SiAddrLib::DecodeGbRegs(
const ADDR_REGISTER_VALUE* pRegValue) ///< [in] create input
@ -2185,7 +2185,7 @@ BOOL_32 SiAddrLib::DecodeGbRegs(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlInitGlobalParams
*
* @brief
@ -2194,7 +2194,7 @@ BOOL_32 SiAddrLib::DecodeGbRegs(
* @return
* TRUE if all settings are valid
*
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 SiAddrLib::HwlInitGlobalParams(
const ADDR_CREATE_INPUT* pCreateIn) ///< [in] create input
@ -2234,13 +2234,13 @@ BOOL_32 SiAddrLib::HwlInitGlobalParams(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlConvertTileInfoToHW
* @brief
* Entry of si's ConvertTileInfoToHW
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE SiAddrLib::HwlConvertTileInfoToHW(
const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
@ -2276,7 +2276,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlConvertTileInfoToHW(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe
*
* @brief
@ -2284,7 +2284,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlConvertTileInfoToHW(
* coord.
* @return
* Y coord
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe(
UINT_32 pipe, ///< [in] pipe id
@ -2299,14 +2299,14 @@ UINT_32 SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe
*
* @brief
* Compute surface x,y coordinates from bank/pipe info
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe(
AddrTileMode tileMode, ///< [in] tile mode
@ -2464,14 +2464,14 @@ VOID SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlPreAdjustBank
*
* @brief
* Adjust bank before calculating address acoording to bank/pipe
* @return
* Adjusted bank
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlPreAdjustBank(
UINT_32 tileX, ///< [in] x coordinate in unit of tile
@ -2496,14 +2496,14 @@ UINT_32 SiAddrLib::HwlPreAdjustBank(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlComputeSurfaceInfo
*
* @brief
* Entry of si's ComputeSurfaceInfo
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE SiAddrLib::HwlComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
@ -2540,13 +2540,13 @@ ADDR_E_RETURNCODE SiAddrLib::HwlComputeSurfaceInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlComputeMipLevel
* @brief
* Compute MipLevel info (including level 0)
* @return
* TRUE if HWL's handled
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 SiAddrLib::HwlComputeMipLevel(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn ///< [in/out] Input structure
@ -2578,14 +2578,14 @@ BOOL_32 SiAddrLib::HwlComputeMipLevel(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlCheckLastMacroTiledLvl
*
* @brief
* Sets pOut->last2DLevel to TRUE if it is
* @note
*
***************************************************************************************************
****************************************************************************************************
*/
VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure
@ -2653,7 +2653,7 @@ VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlDegradeThickTileMode
*
* @brief
@ -2661,7 +2661,7 @@ VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
*
* @return
* Suitable tile mode
***************************************************************************************************
****************************************************************************************************
*/
AddrTileMode SiAddrLib::HwlDegradeThickTileMode(
AddrTileMode baseTileMode, ///< [in] base tile mode
@ -2673,14 +2673,14 @@ AddrTileMode SiAddrLib::HwlDegradeThickTileMode(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlTileInfoEqual
*
* @brief
* Return TRUE if all field are equal
* @note
* Only takes care of current HWL's data
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 SiAddrLib::HwlTileInfoEqual(
const ADDR_TILEINFO* pLeft, ///<[in] Left compare operand
@ -2698,14 +2698,14 @@ BOOL_32 SiAddrLib::HwlTileInfoEqual(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::GetTileSettings
*
* @brief
* Get tile setting infos by index.
* @return
* Tile setting info.
***************************************************************************************************
****************************************************************************************************
*/
const AddrTileConfig* SiAddrLib::GetTileSetting(
UINT_32 index ///< [in] Tile index
@ -2716,7 +2716,7 @@ const AddrTileConfig* SiAddrLib::GetTileSetting(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlPostCheckTileIndex
*
* @brief
@ -2724,7 +2724,7 @@ const AddrTileConfig* SiAddrLib::GetTileSetting(
* tile mode/type/info and change the index if needed
* @return
* Tile index.
***************************************************************************************************
****************************************************************************************************
*/
INT_32 SiAddrLib::HwlPostCheckTileIndex(
const ADDR_TILEINFO* pInfo, ///< [in] Tile Info
@ -2795,14 +2795,14 @@ INT_32 SiAddrLib::HwlPostCheckTileIndex(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlSetupTileCfg
*
* @brief
* Map tile index to tile setting.
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE SiAddrLib::HwlSetupTileCfg(
UINT_32 bpp, ///< [in] Bits per pixel
@ -2876,14 +2876,14 @@ ADDR_E_RETURNCODE SiAddrLib::HwlSetupTileCfg(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::ReadGbTileMode
*
* @brief
* Convert GB_TILE_MODE HW value to ADDR_TILE_CONFIG.
* @return
* NA.
***************************************************************************************************
****************************************************************************************************
*/
VOID SiAddrLib::ReadGbTileMode(
UINT_32 regValue, ///< [in] GB_TILE_MODE register
@ -2916,14 +2916,14 @@ VOID SiAddrLib::ReadGbTileMode(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::InitTileSettingTable
*
* @brief
* Initialize the ADDR_TILE_CONFIG table.
* @return
* TRUE if tile table is correctly initialized
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 SiAddrLib::InitTileSettingTable(
const UINT_32* pCfg, ///< [in] Pointer to table of tile configs
@ -2967,14 +2967,14 @@ BOOL_32 SiAddrLib::InitTileSettingTable(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlGetTileIndex
*
* @brief
* Return the virtual/real index for given mode/type/info
* @return
* ADDR_OK if successful.
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE SiAddrLib::HwlGetTileIndex(
const ADDR_GET_TILEINDEX_INPUT* pIn,
@ -2988,14 +2988,14 @@ ADDR_E_RETURNCODE SiAddrLib::HwlGetTileIndex(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlFmaskPreThunkSurfInfo
*
* @brief
* Some preparation before thunking a ComputeSurfaceInfo call for Fmask
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
VOID SiAddrLib::HwlFmaskPreThunkSurfInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pFmaskIn, ///< [in] Input of fmask info
@ -3008,14 +3008,14 @@ VOID SiAddrLib::HwlFmaskPreThunkSurfInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlFmaskPostThunkSurfInfo
*
* @brief
* Copy hwl extra field after calling thunked ComputeSurfaceInfo
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
VOID SiAddrLib::HwlFmaskPostThunkSurfInfo(
const ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pSurfOut, ///< [in] Output of surface info
@ -3027,13 +3027,13 @@ VOID SiAddrLib::HwlFmaskPostThunkSurfInfo(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlComputeFmaskBits
* @brief
* Computes fmask bits
* @return
* Fmask bits
***************************************************************************************************
****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlComputeFmaskBits(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn,
@ -3128,7 +3128,7 @@ UINT_32 SiAddrLib::HwlComputeFmaskBits(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlOverrideTileMode
*
* @brief
@ -3137,7 +3137,7 @@ UINT_32 SiAddrLib::HwlComputeFmaskBits(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
void SiAddrLib::HwlOverrideTileMode(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut ///< [in/out] input output structure
@ -3198,7 +3198,7 @@ void SiAddrLib::HwlOverrideTileMode(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlSelectTileMode
*
* @brief
@ -3207,7 +3207,7 @@ void SiAddrLib::HwlOverrideTileMode(
* @return
* N/A
*
***************************************************************************************************
****************************************************************************************************
*/
VOID SiAddrLib::HwlSelectTileMode(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut ///< [in/out] input output structure
@ -3274,14 +3274,14 @@ VOID SiAddrLib::HwlSelectTileMode(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::HwlGetMaxAlignments
*
* @brief
* Gets maximum alignments
* @return
* ADDR_E_RETURNCODE
***************************************************************************************************
****************************************************************************************************
*/
ADDR_E_RETURNCODE SiAddrLib::HwlGetMaxAlignments(
ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut ///< [out] output structure
@ -3320,7 +3320,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlGetMaxAlignments(
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::InitEquationTable
*
* @brief
@ -3328,7 +3328,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlGetMaxAlignments(
*
* @return
* N/A
***************************************************************************************************
****************************************************************************************************
*/
VOID SiAddrLib::InitEquationTable()
{
@ -3491,7 +3491,7 @@ VOID SiAddrLib::InitEquationTable()
}
/**
***************************************************************************************************
****************************************************************************************************
* SiAddrLib::IsEquationSupported
*
* @brief
@ -3499,7 +3499,7 @@ VOID SiAddrLib::InitEquationTable()
*
* @return
* TRUE if supported
***************************************************************************************************
****************************************************************************************************
*/
BOOL_32 SiAddrLib::IsEquationSupported(
UINT_32 bpp, ///< Bits per pixel

16
src/amd/addrlib/r800/siaddrlib.h
View File

@ -25,10 +25,10 @@
*/
/**
***************************************************************************************************
****************************************************************************************************
* @file siaddrlib.h
* @brief Contains the R800AddrLib class definition.
***************************************************************************************************
****************************************************************************************************
*/
#ifndef __SI_ADDR_LIB_H__
@ -38,9 +38,9 @@
#include "egbaddrlib.h"
/**
***************************************************************************************************
****************************************************************************************************
* @brief Describes the information in tile mode table
***************************************************************************************************
****************************************************************************************************
*/
struct AddrTileConfig
{
@ -50,9 +50,9 @@ struct AddrTileConfig
};
/**
***************************************************************************************************
****************************************************************************************************
* @brief SI specific settings structure.
***************************************************************************************************
****************************************************************************************************
*/
struct SIChipSettings
{
@ -69,10 +69,10 @@ struct SIChipSettings
};
/**
***************************************************************************************************
****************************************************************************************************
* @brief This class is the SI specific address library
* function set.
***************************************************************************************************
****************************************************************************************************
*/
class SiAddrLib : public EgBasedAddrLib
{