*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @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
+{
+ struct
+ {
+ UINT_8 valid : 1; ///< Indicate whehter this channel setting is valid
+ UINT_8 channel : 2; ///< 0 for x channel, 1 for y channel, 2 for z channel
+ UINT_8 index : 5; ///< Channel index
+ };
+ UINT_8 value; ///< Value
+} ADDR_CHANNEL_SETTING;
+
+/**
+****************************************************************************************************
+* @brief address equation key structure
+****************************************************************************************************
+*/
+typedef union _ADDR_EQUATION_KEY
+{
+ struct
+ {
+ UINT_32 log2ElementBytes : 3; ///< Log2 of Bytes per pixel
+ UINT_32 tileMode : 5; ///< Tile mode
+ UINT_32 microTileType : 3; ///< Micro tile type
+ UINT_32 pipeConfig : 5; ///< pipe config
+ 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
+
+// Invalid equation index
+#define ADDR_INVALID_EQUATION_INDEX 0xFFFFFFFF
+
+typedef struct _ADDR_EQUATION
+{
+ ADDR_CHANNEL_SETTING addr[ADDR_MAX_EQUATION_BIT]; ///< addr setting
+ ///< each bit is result of addr ^ xor ^ xor2
+ ADDR_CHANNEL_SETTING xor1[ADDR_MAX_EQUATION_BIT]; ///< xor setting
+ ADDR_CHANNEL_SETTING xor2[ADDR_MAX_EQUATION_BIT]; ///< xor2 setting
+ UINT_32 numBits; ///< The number of bits in equation
+ BOOL_32 stackedDepthSlices; ///< TRUE if depth slices are treated as being
+ ///< stacked vertically prior to swizzling
+} ADDR_EQUATION;
+
+
+/**
+****************************************************************************************************
* @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
{
///< CI registers-------------------------------------------------
const UINT_32* pMacroTileConfig; ///< Global macro tile mode table
UINT_32 noOfMacroEntries; ///< Number of entries in pMacroTileConfig
-
} 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
{
- UINT_32 size; ///< Size of this structure in bytes
+ UINT_32 size; ///< Size of this structure in bytes
- ADDR_HANDLE hLib; ///< Address lib handle
+ ADDR_HANDLE hLib; ///< Address lib handle
+
+ UINT_32 numEquations; ///< Number of equations in the table
+ const ADDR_EQUATION* pEquationTable; ///< Pointer to the equation table
} 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
{
struct
{
- UINT_32 color : 1; ///< Flag indicates this is a color buffer
- UINT_32 depth : 1; ///< Flag indicates this is a depth/stencil buffer
- UINT_32 stencil : 1; ///< Flag indicates this is a stencil buffer
- UINT_32 texture : 1; ///< Flag indicates this is a texture
- UINT_32 cube : 1; ///< Flag indicates this is a cubemap
- UINT_32 volume : 1; ///< Flag indicates this is a volume texture
- UINT_32 fmask : 1; ///< Flag indicates this is an fmask
- UINT_32 cubeAsArray : 1; ///< Flag indicates if treat cubemap as arrays
- UINT_32 compressZ : 1; ///< Flag indicates z buffer is compressed
- UINT_32 overlay : 1; ///< Flag indicates this is an overlay surface
- UINT_32 noStencil : 1; ///< Flag indicates this depth has no separate stencil
- UINT_32 display : 1; ///< Flag indicates this should match display controller req.
- UINT_32 opt4Space : 1; ///< Flag indicates this surface should be optimized for space
- /// i.e. save some memory but may lose performance
- UINT_32 prt : 1; ///< Flag for partially resident texture
- UINT_32 qbStereo : 1; ///< Quad buffer stereo surface
- UINT_32 pow2Pad : 1; ///< SI: Pad to pow2, must set for mipmap (include level0)
- UINT_32 interleaved : 1; ///< Special flag for interleaved YUV surface padding
- UINT_32 tcCompatible : 1; ///< Flag indicates surface needs to be shader readable
- UINT_32 dispTileType : 1; ///< NI: force display Tiling for 128 bit shared resoruce
- UINT_32 dccCompatible : 1; ///< VI: whether to support dcc fast clear
- UINT_32 czDispCompatible: 1; ///< SI+: CZ family has a HW bug needs special alignment.
- /// This flag indicates we need to follow the alignment with
- /// CZ families or other ASICs under PX configuration + CZ.
- UINT_32 nonSplit : 1; ///< CI: depth texture should not be split
- UINT_32 disableLinearOpt: 1; ///< Disable tile mode optimization to linear
- UINT_32 reserved : 9; ///< Reserved bits
+ UINT_32 color : 1; ///< Flag indicates this is a color buffer
+ UINT_32 depth : 1; ///< Flag indicates this is a depth/stencil buffer
+ UINT_32 stencil : 1; ///< Flag indicates this is a stencil buffer
+ UINT_32 texture : 1; ///< Flag indicates this is a texture
+ UINT_32 cube : 1; ///< Flag indicates this is a cubemap
+ UINT_32 volume : 1; ///< Flag indicates this is a volume texture
+ UINT_32 fmask : 1; ///< Flag indicates this is an fmask
+ UINT_32 cubeAsArray : 1; ///< Flag indicates if treat cubemap as arrays
+ UINT_32 compressZ : 1; ///< Flag indicates z buffer is compressed
+ UINT_32 overlay : 1; ///< Flag indicates this is an overlay surface
+ UINT_32 noStencil : 1; ///< Flag indicates this depth has no separate stencil
+ UINT_32 display : 1; ///< Flag indicates this should match display controller req.
+ UINT_32 opt4Space : 1; ///< Flag indicates this surface should be optimized for space
+ /// i.e. save some memory but may lose performance
+ UINT_32 prt : 1; ///< Flag for partially resident texture
+ UINT_32 qbStereo : 1; ///< Quad buffer stereo surface
+ UINT_32 pow2Pad : 1; ///< SI: Pad to pow2, must set for mipmap (include level0)
+ UINT_32 interleaved : 1; ///< Special flag for interleaved YUV surface padding
+ UINT_32 tcCompatible : 1; ///< Flag indicates surface needs to be shader readable
+ UINT_32 dispTileType : 1; ///< NI: force display Tiling for 128 bit shared resoruce
+ UINT_32 dccCompatible : 1; ///< VI: whether to support dcc fast clear
+ UINT_32 czDispCompatible : 1; ///< SI+: CZ family has a HW bug needs special alignment.
+ /// This flag indicates we need to follow the
+ /// alignment with CZ families or other ASICs under
+ /// PX configuration + CZ.
+ UINT_32 nonSplit : 1; ///< CI: depth texture should not be split
+ UINT_32 disableLinearOpt : 1; ///< Disable tile mode optimization to linear
+ UINT_32 needEquation : 1; ///< Make the surface tile setting equation compatible.
+ /// This flag indicates we need to override tile
+ /// 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 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 numSlices; ///< Number of surface slices or depth
UINT_32 slice; ///< Slice index
UINT_32 mipLevel; ///< Current mipmap level
+ UINT_32 numMipLevels; ///< Number of mips in mip chain
ADDR_SURFACE_FLAGS flags; ///< Surface type flags
UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
/// number of samples for normal AA; Set it to the
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;
+
+ UINT_32 blockWidth; ///< Width in element inside one block(1D->Micro, 2D->Macro)
+ UINT_32 blockHeight; ///< Height in element inside one block(1D->Micro, 2D->Macro)
+ UINT_32 blockSlices; ///< Slice number inside one block(1D->Micro, 2D->Macro)
+
/// 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 size; ///< Size of this structure in bytes
-
- UINT_32 pitch; ///< Pitch in pixels of depth buffer represented in this
- /// HTile buffer. This might be larger than original depth
- /// buffer pitch when called with an unaligned pitch.
- UINT_32 height; ///< Height in pixels, as above
- UINT_64 htileBytes; ///< Size of HTILE buffer, in bytes
- UINT_32 baseAlign; ///< Base alignment
- UINT_32 bpp; ///< Bits per pixel for HTILE is how many bits for an 8x8 block!
- 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.
+ UINT_32 size; ///< Size of this structure in bytes
+
+ UINT_32 pitch; ///< Pitch in pixels of depth buffer represented in this
+ /// HTile buffer. This might be larger than original depth
+ /// buffer pitch when called with an unaligned pitch.
+ UINT_32 height; ///< Height in pixels, as above
+ UINT_64 htileBytes; ///< Size of HTILE buffer, in bytes
+ UINT_32 baseAlign; ///< Base alignment
+ UINT_32 bpp; ///< Bits per pixel for HTILE is how many bits for an 8x8 block!
+ 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
{
UINT_32 slice; ///< Index of slice
UINT_32 numSlices; ///< Number of slices
BOOL_32 isLinear; ///< Linear or tiled HTILE layout
+ ADDR_HTILE_FLAGS flags; ///< htile flags
AddrHtileBlockSize blockWidth; ///< 4 or 8. 1 means 8, 0 means 4. EG above only support 8
AddrHtileBlockSize blockHeight; ///< 4 or 8. 1 means 8, 0 means 4. EG above only support 8
ADDR_TILEINFO* pTileInfo; ///< Tile info
/// while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
///< README: When tileIndex is not -1, this must be valid
+ UINT_32 bpp; ///< depth/stencil buffer bit per pixel size
+ UINT_32 zStencilAddr; ///< tcCompatible Z/Stencil surface address
} 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
{
/// while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
///< README: When tileIndex is not -1, this must be valid
+ UINT_32 bpp; ///< Bits per pixel
} 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
{
INT_32 tileIndex; ///< Tile index
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
+ UINT_32 bpp; ///< Bits per pixel
BOOL_32 tileInfoHw; ///< Set to TRUE if client wants HW enum, otherwise actual
} 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,
const ADDR_CONVERT_TILEINDEX_INPUT* pIn,
ADDR_CONVERT_TILEINDEX_OUTPUT* pOut);
+/**
+****************************************************************************************************
+* ADDR_GET_MACROMODEINDEX_INPUT
+*
+* @brief
+* Input structure for AddrGetMacroModeIndex
+****************************************************************************************************
+*/
+typedef struct _ADDR_GET_MACROMODEINDEX_INPUT
+{
+ UINT_32 size; ///< Size of this structure in bytes
+ ADDR_SURFACE_FLAGS flags; ///< Surface flag
+ INT_32 tileIndex; ///< Tile index
+ UINT_32 bpp; ///< Bits per pixel
+ UINT_32 numFrags; ///< Number of color fragments
+} ADDR_GET_MACROMODEINDEX_INPUT;
+/**
+****************************************************************************************************
+* ADDR_GET_MACROMODEINDEX_OUTPUT
+*
+* @brief
+* Output structure for AddrGetMacroModeIndex
+****************************************************************************************************
+*/
+typedef struct _ADDR_GET_MACROMODEINDEX_OUTPUT
+{
+ UINT_32 size; ///< Size of this structure in bytes
+ INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
+} ADDR_GET_MACROMODEINDEX_OUTPUT;
+
+/**
+****************************************************************************************************
+* AddrGetMacroModeIndex
+*
+* @brief
+* Get macro mode index based on input parameters
+****************************************************************************************************
+*/
+ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
+ ADDR_HANDLE hLib,
+ const ADDR_GET_MACROMODEINDEX_INPUT* pIn,
+ 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
{
UINT_64 dccRamBaseAlign; ///< Base alignment of dcc key
UINT_64 dccRamSize; ///< Size of dcc key
UINT_64 dccFastClearSize; ///< Size of dcc key portion that can be fast cleared
- BOOL_32 subLvlCompressible; ///< whether sub resource is compressiable
+ BOOL_32 subLvlCompressible; ///< Whether sub resource is compressiable
+ BOOL_32 dccRamSizeAligned; ///< Whether the dcc key size is aligned
} 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,
projects / mesa.git / blobdiff