*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file addrinterface.h
* @brief Contains the addrlib interfaces declaration and parameter defines
-***************************************************************************************************
+****************************************************************************************************
*/
#ifndef __ADDR_INTERFACE_H__
#define __ADDR_INTERFACE_H__
*
**/
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
// Callback functions
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief channel setting structure
-***************************************************************************************************
+****************************************************************************************************
*/
typedef union _ADDR_CHANNEL_SETTING
{
} ADDR_CHANNEL_SETTING;
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief address equation key structure
-***************************************************************************************************
+****************************************************************************************************
*/
typedef union _ADDR_EQUATION_KEY
{
UINT_32 tileMode : 5; ///< Tile mode
UINT_32 microTileType : 3; ///< Micro tile type
UINT_32 pipeConfig : 5; ///< pipe config
- UINT_32 numBanks : 5; ///< Number of banks
+ UINT_32 numBanksLog2 : 3; ///< Number of banks log2
UINT_32 bankWidth : 4; ///< Bank width
UINT_32 bankHeight : 4; ///< Bank height
UINT_32 macroAspectRatio : 3; ///< Macro tile aspect ratio
+ UINT_32 prt : 1; ///< SI only, indicate whether this equation is for prt
+ UINT_32 reserved : 1; ///< Reserved bit
} fields;
UINT_32 value;
} ADDR_EQUATION_KEY;
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief address equation structure
-***************************************************************************************************
+****************************************************************************************************
*/
#define ADDR_MAX_EQUATION_BIT 20u
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief Alloc system memory flags.
* @note These flags are reserved for future use and if flags are added will minimize the impact
* of the client.
-***************************************************************************************************
+****************************************************************************************************
*/
typedef union _ADDR_ALLOCSYSMEM_FLAGS
{
} ADDR_ALLOCSYSMEM_FLAGS;
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief Alloc system memory input structure
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_ALLOCSYSMEM_INPUT
{
} ADDR_ALLOCSYSMEM_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_ALLOCSYSMEM
* @brief
* Allocate system memory callback function. Returns valid pointer on success.
-***************************************************************************************************
+****************************************************************************************************
*/
typedef VOID* (ADDR_API* ADDR_ALLOCSYSMEM)(
const ADDR_ALLOCSYSMEM_INPUT* pInput);
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief Free system memory input structure
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_FREESYSMEM_INPUT
{
} ADDR_FREESYSMEM_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_FREESYSMEM
* @brief
* Free system memory callback function.
* Returns ADDR_OK on success.
-***************************************************************************************************
+****************************************************************************************************
*/
typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_FREESYSMEM)(
const ADDR_FREESYSMEM_INPUT* pInput);
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief Print debug message input structure
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_DEBUGPRINT_INPUT
{
} ADDR_DEBUGPRINT_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_DEBUGPRINT
* @brief
* Print debug message callback function.
* Returns ADDR_OK on success.
-***************************************************************************************************
+****************************************************************************************************
*/
typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_DEBUGPRINT)(
const ADDR_DEBUGPRINT_INPUT* pInput);
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_CALLBACKS
*
* @brief
* Address Library needs client to provide system memory alloc/free routines.
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_CALLBACKS
{
ADDR_DEBUGPRINT debugPrint; ///< Routine to print debug message
} ADDR_CALLBACKS;
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
// Create/Destroy functions
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_CREATE_FLAGS
*
* @brief
* This structure is used to pass some setup in creation of AddrLib
* @note
-***************************************************************************************************
+****************************************************************************************************
*/
typedef union _ADDR_CREATE_FLAGS
{
} ADDR_CREATE_FLAGS;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_REGISTER_VALUE
*
* @brief
* Data from registers to setup AddrLib global data, used in AddrCreate
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_REGISTER_VALUE
{
} ADDR_REGISTER_VALUE;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_CREATE_INPUT
*
* @brief
* Parameters use to create an AddrLib Object. Caller must provide all fields.
*
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_CREATE_INPUT
{
} ADDR_CREATE_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_CREATEINFO_OUTPUT
*
* @brief
* Return AddrLib handle to client driver
*
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_CREATE_OUTPUT
{
} ADDR_CREATE_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrCreate
*
* @brief
*
* @return
* ADDR_OK if successful
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrCreate(
const ADDR_CREATE_INPUT* pAddrCreateIn,
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrDestroy
*
* @brief
*
* @return
* ADDR_OK if successful
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrDestroy(
ADDR_HANDLE hLib);
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
// Surface functions
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief
* Bank/tiling parameters. On function input, these can be set as desired or
* left 0 for AddrLib to calculate/default. On function output, these are the actual
* macro tile as each pipe is selected, so the number of
* tiles in the x direction with the same bank number will
* be bank_width * num_pipes.
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_TILEINFO
{
typedef ADDR_TILEINFO ADDR_R800_TILEINFO;
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief
* Information needed by quad buffer stereo support
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_QBSTEREOINFO
{
} ADDR_QBSTEREOINFO;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_SURFACE_FLAGS
*
* @brief
* Surface flags
-***************************************************************************************************
+****************************************************************************************************
*/
typedef union _ADDR_SURFACE_FLAGS
{
/// mode to PRT_* tile mode to disable slice rotation,
/// which is needed by swizzle pattern equation.
UINT_32 skipIndicesOutput : 1; ///< Skipping indices in output.
- UINT_32 reserved : 7; ///< Reserved bits
+ UINT_32 rotateDisplay : 1; ///< Rotate micro tile type
+ UINT_32 minimizeAlignment : 1; ///< Minimize alignment
+ UINT_32 preferEquation : 1; ///< Return equation index without adjusting tile mode
+ UINT_32 matchStencilTileCfg : 1; ///< Select tile index of stencil as well as depth surface
+ /// to make sure they share same tile config parameters
+ UINT_32 reserved : 3; ///< Reserved bits
};
UINT_32 value;
} ADDR_SURFACE_FLAGS;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_SURFACE_INFO_INPUT
*
* @brief
* Input structure for AddrComputeSurfaceInfo
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SURFACE_INFO_INPUT
{
UINT_32 basePitch; ///< Base level pitch in pixels, 0 means ignored, is a
/// must for mip levels from SI+.
/// Don't use pitch in blocks for compressed formats!
+ UINT_32 maxBaseAlign; ///< Max base alignment request from client
+ UINT_32 pitchAlign; ///< Pitch alignment request from client
+ UINT_32 heightAlign; ///< Height alignment request from client
} ADDR_COMPUTE_SURFACE_INFO_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_SURFACE_INFO_OUTPUT
*
* @brief
* @note
Element: AddrLib unit for computing. e.g. BCn: 4x4 blocks; R32B32B32: 32bit with 3x pitch
Pixel: Original pixel
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SURFACE_INFO_OUTPUT
{
UINT_32 last2DLevel : 1; ///< TRUE if this is the last 2D(3D) tiled
///< Only meaningful when create flag checkLast2DLevel is set
UINT_32 tcCompatible : 1; ///< If the surface can be shader compatible
- UINT_32 reserved :30; ///< Reserved bits
+ UINT_32 dccUnsupport : 1; ///< If the surface can support DCC compressed rendering
+ UINT_32 prtTileIndex : 1; ///< SI only, indicate the returned tile index is for PRT
+ ///< If address lib return true for mip 0, client should set prt flag
+ ///< for child mips in subsequent compute surface info calls
+ UINT_32 reserved :28; ///< Reserved bits
};
UINT_32 equationIndex; ///< Equation index in the equation table;
/// Stereo info
ADDR_QBSTEREOINFO* pStereoInfo;///< Stereo information, needed when .qbStereo flag is TRUE
+
+ INT_32 stencilTileIdx; ///< stencil tile index output when matchStencilTileCfg was set
} ADDR_COMPUTE_SURFACE_INFO_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeSurfaceInfo
*
* @brief
* Compute surface width/height/depth/alignments and suitable tiling mode
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
*
* @brief
* Input structure for AddrComputeSurfaceAddrFromCoord
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
{
} ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
*
* @brief
* Output structure for AddrComputeSurfaceAddrFromCoord
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
{
} ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeSurfaceAddrFromCoord
*
* @brief
* Compute surface address from a given coordinate.
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
*
* @brief
* Input structure for AddrComputeSurfaceCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
{
} ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
*
* @brief
* Output structure for AddrComputeSurfaceCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
{
} ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeSurfaceCoordFromAddr
*
* @brief
* Compute coordinate from a given surface address
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,
ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut);
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
// HTile functions
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_HTILE_FLAGS
*
* @brief
* HTILE flags
-***************************************************************************************************
+****************************************************************************************************
*/
typedef union _ADDR_HTILE_FLAGS
{
} ADDR_HTILE_FLAGS;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_HTILE_INFO_INPUT
*
* @brief
* Input structure of AddrComputeHtileInfo
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_HTILE_INFO_INPUT
{
} ADDR_COMPUTE_HTILE_INFO_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_HTILE_INFO_OUTPUT
*
* @brief
* Output structure of AddrComputeHtileInfo
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_HTILE_INFO_OUTPUT
{
UINT_32 macroWidth; ///< Macro width in pixels, actually squared cache shape
UINT_32 macroHeight; ///< Macro height in pixels
UINT_64 sliceSize; ///< Slice size, in bytes.
+ BOOL_32 sliceInterleaved; ///< Flag to indicate if different slice's htile is interleaved
+ /// Compute engine clear can't be used if htile is interleaved
} ADDR_COMPUTE_HTILE_INFO_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeHtileInfo
*
* @brief
* Compute Htile pitch, height, base alignment and size in bytes
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
*
* @brief
* Input structure for AddrComputeHtileAddrFromCoord
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
{
} ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
*
* @brief
* Output structure for AddrComputeHtileAddrFromCoord
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
{
} ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeHtileAddrFromCoord
*
* @brief
* Compute Htile address according to coordinates (of depth buffer)
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
*
* @brief
* Input structure for AddrComputeHtileCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
{
} ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
*
* @brief
* Output structure for AddrComputeHtileCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
{
} ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeHtileCoordFromAddr
*
* @brief
* Compute coordinates within depth buffer (1st pixel of a micro tile) according to
* Htile address
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
ADDR_HANDLE hLib,
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
// C-mask functions
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_CMASK_FLAGS
*
* @brief
* CMASK flags
-***************************************************************************************************
+****************************************************************************************************
*/
typedef union _ADDR_CMASK_FLAGS
{
} ADDR_CMASK_FLAGS;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_CMASK_INFO_INPUT
*
* @brief
* Input structure of AddrComputeCmaskInfo
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_CMASKINFO_INPUT
{
} ADDR_COMPUTE_CMASK_INFO_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_CMASK_INFO_OUTPUT
*
* @brief
* Output structure of AddrComputeCmaskInfo
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_CMASK_INFO_OUTPUT
{
} ADDR_COMPUTE_CMASK_INFO_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeCmaskInfo
*
* @brief
* Compute Cmask pitch, height, base alignment and size in bytes from color buffer
* info
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
*
* @brief
* Input structure for AddrComputeCmaskAddrFromCoord
*
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
{
} ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
*
* @brief
* Output structure for AddrComputeCmaskAddrFromCoord
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
{
} ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeCmaskAddrFromCoord
*
* @brief
* Compute Cmask address according to coordinates (of MSAA color buffer)
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
*
* @brief
* Input structure for AddrComputeCmaskCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
{
} ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
*
* @brief
* Output structure for AddrComputeCmaskCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
{
} ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeCmaskCoordFromAddr
*
* @brief
* Compute coordinates within color buffer (1st pixel of a micro tile) according to
* Cmask address
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
ADDR_HANDLE hLib,
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
// F-mask functions
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_FMASK_INFO_INPUT
*
* @brief
* Input structure for AddrComputeFmaskInfo
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_FMASK_INFO_INPUT
{
} ADDR_COMPUTE_FMASK_INFO_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_FMASK_INFO_OUTPUT
*
* @brief
* Output structure for AddrComputeFmaskInfo
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_FMASK_INFO_OUTPUT
{
} ADDR_COMPUTE_FMASK_INFO_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeFmaskInfo
*
* @brief
* Compute Fmask pitch/height/depth/alignments and size in bytes
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
*
* @brief
* Input structure for AddrComputeFmaskAddrFromCoord
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
{
} ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
*
* @brief
* Output structure for AddrComputeFmaskAddrFromCoord
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
{
} ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeFmaskAddrFromCoord
*
* @brief
* Compute Fmask address according to coordinates (x,y,slice,sample,plane)
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
*
* @brief
* Input structure for AddrComputeFmaskCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
{
} ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
*
* @brief
* Output structure for AddrComputeFmaskCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
{
} ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeFmaskCoordFromAddr
*
* @brief
* Compute FMASK coordinate from an given address
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
ADDR_HANDLE hLib,
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
// Element/utility functions
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrGetVersion
*
* @brief
* Get AddrLib version number
-***************************************************************************************************
+****************************************************************************************************
*/
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);
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrUseCombinedSwizzle
*
* @brief
* Return TRUE if combined swizzle is enabled in this address library
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib);
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
*
* @brief
* Input structure of AddrExtractBankPipeSwizzle
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
{
} ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
*
* @brief
* Output structure of AddrExtractBankPipeSwizzle
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
{
} ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrExtractBankPipeSwizzle
*
* @brief
* Extract Bank and Pipe swizzle from base256b
* @return
* ADDR_OK if no error
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
*
* @brief
* Input structure of AddrCombineBankPipeSwizzle
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
{
} ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
*
* @brief
* Output structure of AddrCombineBankPipeSwizzle
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
{
} ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrCombineBankPipeSwizzle
*
* @brief
* ADDR_OK if no error
* @note
* baseAddr here is full MCAddress instead of base256b
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_SLICESWIZZLE_INPUT
*
* @brief
* Input structure of AddrComputeSliceSwizzle
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SLICESWIZZLE_INPUT
{
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
*
* @brief
* Output structure of AddrComputeSliceSwizzle
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
{
} ADDR_COMPUTE_SLICESWIZZLE_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeSliceSwizzle
*
* @brief
* Extract Bank and Pipe swizzle from base256b
* @return
* ADDR_OK if no error
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrSwizzleGenOption
*
* @brief
* Which swizzle generating options: legacy or linear
-***************************************************************************************************
+****************************************************************************************************
*/
typedef enum _AddrSwizzleGenOption
{
} AddrSwizzleGenOption;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrSwizzleOption
*
* @brief
* Controls how swizzle is generated
-***************************************************************************************************
+****************************************************************************************************
*/
typedef union _ADDR_SWIZZLE_OPTION
{
} ADDR_SWIZZLE_OPTION;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_BASE_SWIZZLE_INPUT
*
* @brief
* Input structure of AddrComputeBaseSwizzle
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_INPUT
{
} ADDR_COMPUTE_BASE_SWIZZLE_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
*
* @brief
* Output structure of AddrComputeBaseSwizzle
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
{
} ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* 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,
/**
-***************************************************************************************************
+****************************************************************************************************
* ELEM_GETEXPORTNORM_INPUT
*
* @brief
* Input structure for ElemGetExportNorm
*
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ELEM_GETEXPORTNORM_INPUT
{
} ELEM_GETEXPORTNORM_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ElemGetExportNorm
*
* @brief
* 01 - EXPORT_NORM: PS exports are 4 pixels with 4 components with 16-bits-per-component. (one
* clock per export)
*
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 ADDR_API ElemGetExportNorm(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ELEM_FLT32TODEPTHPIXEL_INPUT
*
* @brief
* Input structure for addrFlt32ToDepthPixel
*
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ELEM_FLT32TODEPTHPIXEL_INPUT
{
} ELEM_FLT32TODEPTHPIXEL_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ELEM_FLT32TODEPTHPIXEL_INPUT
*
* @brief
* Output structure for ElemFlt32ToDepthPixel
*
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ELEM_FLT32TODEPTHPIXEL_OUTPUT
{
} ELEM_FLT32TODEPTHPIXEL_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ElemFlt32ToDepthPixel
*
* @brief
* @return
* Return code
*
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ELEM_FLT32TOCOLORPIXEL_INPUT
*
* @brief
* Input structure for addrFlt32ToColorPixel
*
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ELEM_FLT32TOCOLORPIXEL_INPUT
{
} ELEM_FLT32TOCOLORPIXEL_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ELEM_FLT32TOCOLORPIXEL_INPUT
*
* @brief
* Output structure for ElemFlt32ToColorPixel
*
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ELEM_FLT32TOCOLORPIXEL_OUTPUT
{
} ELEM_FLT32TOCOLORPIXEL_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ElemFlt32ToColorPixel
*
* @brief
* @return
* Return code
*
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_CONVERT_TILEINFOTOHW_INPUT
*
* @brief
* Input structure for AddrConvertTileInfoToHW
* @note
* When reverse is TRUE, indices are igonred
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_CONVERT_TILEINFOTOHW_INPUT
{
} ADDR_CONVERT_TILEINFOTOHW_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_CONVERT_TILEINFOTOHW_OUTPUT
*
* @brief
* Output structure for AddrConvertTileInfoToHW
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_CONVERT_TILEINFOTOHW_OUTPUT
{
} ADDR_CONVERT_TILEINFOTOHW_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrConvertTileInfoToHW
*
* @brief
* Convert tile info from real value to hardware register value
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_CONVERT_TILEINDEX_INPUT
*
* @brief
* Input structure for AddrConvertTileIndex
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_CONVERT_TILEINDEX_INPUT
{
} ADDR_CONVERT_TILEINDEX_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_CONVERT_TILEINDEX_OUTPUT
*
* @brief
* Output structure for AddrConvertTileIndex
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_CONVERT_TILEINDEX_OUTPUT
{
} ADDR_CONVERT_TILEINDEX_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrConvertTileIndex
*
* @brief
* Convert tile index to tile mode/type/info
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
ADDR_HANDLE hLib,
ADDR_CONVERT_TILEINDEX_OUTPUT* pOut);
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_GET_MACROMODEINDEX_INPUT
*
* @brief
* Input structure for AddrGetMacroModeIndex
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_GET_MACROMODEINDEX_INPUT
{
} ADDR_GET_MACROMODEINDEX_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_GET_MACROMODEINDEX_OUTPUT
*
* @brief
* Output structure for AddrGetMacroModeIndex
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_GET_MACROMODEINDEX_OUTPUT
{
} ADDR_GET_MACROMODEINDEX_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrGetMacroModeIndex
*
* @brief
* Get macro mode index based on input parameters
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
ADDR_HANDLE hLib,
ADDR_GET_MACROMODEINDEX_OUTPUT* pOut);
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_CONVERT_TILEINDEX1_INPUT
*
* @brief
* Input structure for AddrConvertTileIndex1 (without macro mode index)
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_CONVERT_TILEINDEX1_INPUT
{
} ADDR_CONVERT_TILEINDEX1_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrConvertTileIndex1
*
* @brief
* Convert tile index to tile mode/type/info
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_GET_TILEINDEX_INPUT
*
* @brief
* Input structure for AddrGetTileIndex
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_GET_TILEINDEX_INPUT
{
} ADDR_GET_TILEINDEX_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_GET_TILEINDEX_OUTPUT
*
* @brief
* Output structure for AddrGetTileIndex
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_GET_TILEINDEX_OUTPUT
{
} ADDR_GET_TILEINDEX_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrGetTileIndex
*
* @brief
* Get the tiling mode index in table
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
ADDR_HANDLE hLib,
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_PRT_INFO_INPUT
*
* @brief
* Input structure for AddrComputePrtInfo
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_PRT_INFO_INPUT
{
} ADDR_PRT_INFO_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_PRT_INFO_OUTPUT
*
* @brief
* Input structure for AddrComputePrtInfo
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_PRT_INFO_OUTPUT
{
} ADDR_PRT_INFO_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputePrtInfo
*
* @brief
* Compute prt surface related information
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
ADDR_HANDLE hLib,
const ADDR_PRT_INFO_INPUT* pIn,
ADDR_PRT_INFO_OUTPUT* pOut);
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
// DCC key functions
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* _ADDR_COMPUTE_DCCINFO_INPUT
*
* @brief
* Input structure of AddrComputeDccInfo
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_DCCINFO_INPUT
{
} ADDR_COMPUTE_DCCINFO_INPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_DCCINFO_OUTPUT
*
* @brief
* Output structure of AddrComputeDccInfo
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_DCCINFO_OUTPUT
{
} ADDR_COMPUTE_DCCINFO_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeDccInfo
*
* @brief
* Compute DCC key size, base alignment
* info
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
ADDR_HANDLE hLib,
ADDR_COMPUTE_DCCINFO_OUTPUT* pOut);
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_GET_MAX_ALINGMENTS_OUTPUT
*
* @brief
* Output structure of AddrGetMaxAlignments
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_GET_MAX_ALINGMENTS_OUTPUT
{
} ADDR_GET_MAX_ALINGMENTS_OUTPUT;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrGetMaxAlignments
*
* @brief
* Gets maximnum alignments
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
ADDR_HANDLE hLib,