*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file addrinterface.cpp
* @brief Contains the addrlib interface functions
-***************************************************************************************************
+****************************************************************************************************
*/
#include "addrinterface.h"
#include "addrlib1.h"
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrCreate
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrCreate(
const ADDR_CREATE_INPUT* pAddrCreateIn, ///< [in] infomation for creating address lib object
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrDestroy
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrDestroy(
ADDR_HANDLE hLib) ///< address lib handle
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeSurfaceInfo
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
ADDR_HANDLE hLib, ///< address lib handle
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeSurfaceAddrFromCoord
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
ADDR_HANDLE hLib, ///< address lib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeSurfaceCoordFromAddr
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
ADDR_HANDLE hLib, ///< address lib handle
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeHtileInfo
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
ADDR_HANDLE hLib, ///< address lib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeHtileAddrFromCoord
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
ADDR_HANDLE hLib, ///< address lib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeHtileCoordFromAddr
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
ADDR_HANDLE hLib, ///< address lib handle
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeCmaskInfo
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
ADDR_HANDLE hLib, ///< address lib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeCmaskAddrFromCoord
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
ADDR_HANDLE hLib, ///< address lib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeCmaskCoordFromAddr
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
ADDR_HANDLE hLib, ///< address lib handle
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeFmaskInfo
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
ADDR_HANDLE hLib, ///< address lib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeFmaskAddrFromCoord
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
ADDR_HANDLE hLib, ///< address lib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeFmaskCoordFromAddr
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
ADDR_HANDLE hLib, ///< address lib handle
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeDccInfo
*
* @brief
* Compute DCC key size, base alignment based on color surface size, tile info or tile index
*
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
ADDR_HANDLE hLib, ///< handle of addrlib
///////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrGetVersion
*
* @brief
* Get AddrLib version number. Client may check this return value against ADDRLIB_VERSION
* defined in addrinterface.h to see if there is a mismatch.
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib)
{
}
/**
-***************************************************************************************************
+****************************************************************************************************
* 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)
{
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrExtractBankPipeSwizzle
*
* @brief
* Extract Bank and Pipe swizzle from base256b
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
ADDR_HANDLE hLib, ///< addrlib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrCombineBankPipeSwizzle
*
* @brief
* Combine Bank and Pipe swizzle
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
ADDR_HANDLE hLib,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputeSliceSwizzle
*
* @brief
* Compute a swizzle for slice from a base swizzle
* @return
* ADDR_OK if no error
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
ADDR_HANDLE hLib,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* 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,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* ElemFlt32ToDepthPixel
*
* @brief
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
*
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
ADDR_HANDLE hLib, ///< addrlib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* ElemFlt32ToColorPixel
*
* @brief
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
*
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
ADDR_HANDLE hLib, ///< addrlib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* ElemGetExportNorm
*
* @brief
* FP16 can be reported as EXPORT_NORM for rv770 in r600
* family
*
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 ADDR_API ElemGetExportNorm(
ADDR_HANDLE hLib, ///< addrlib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrConvertTileInfoToHW
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
ADDR_HANDLE hLib, ///< address lib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrConvertTileIndex
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
ADDR_HANDLE hLib, ///< address lib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrGetMacroModeIndex
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
ADDR_HANDLE hLib, ///< address lib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrConvertTileIndex1
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
ADDR_HANDLE hLib, ///< address lib handle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrGetTileIndex
*
* @brief
*
* @note
* Only meaningful for SI (and above)
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
ADDR_HANDLE hLib,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrComputePrtInfo
*
* @brief
* Interface function for ComputePrtInfo
*
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
ADDR_HANDLE hLib,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrGetMaxAlignments
*
* @brief
*
* @return
* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
ADDR_HANDLE hLib, ///< address lib handle
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file addrinterface.h
* @brief Contains the addrlib interfaces declaration and parameter defines
-***************************************************************************************************
+****************************************************************************************************
*/
#ifndef __ADDR_INTERFACE_H__
#define __ADDR_INTERFACE_H__
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief channel setting structure
-***************************************************************************************************
+****************************************************************************************************
*/
typedef union _ADDR_CHANNEL_SETTING
{
} ADDR_CHANNEL_SETTING;
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief address equation key structure
-***************************************************************************************************
+****************************************************************************************************
*/
typedef union _ADDR_EQUATION_KEY
{
} 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_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);
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* @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
{
} ADDR_SURFACE_FLAGS;
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_COMPUTE_SURFACE_INFO_INPUT
*
* @brief
* Input structure for AddrComputeSurfaceInfo
-***************************************************************************************************
+****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SURFACE_INFO_INPUT
{
} 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
{
} 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,
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* 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
{
} 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,
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* 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,
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* 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,
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* 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,
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* _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,
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file addrtypes.h
* @brief Contains the helper function and constants
-***************************************************************************************************
+****************************************************************************************************
*/
#ifndef __ADDR_TYPES_H__
#define __ADDR_TYPES_H__
#endif // defined (__APPLE__) && !defined(HAVE_TSERVER)
/**
-***************************************************************************************************
+****************************************************************************************************
* Calling conventions
-***************************************************************************************************
+****************************************************************************************************
*/
#ifndef ADDR_CDECL
#if defined(__GNUC__)
#define ADDR_API ADDR_FASTCALL //default call convention is fast call
/**
-***************************************************************************************************
+****************************************************************************************************
* Global defines used by other modules
-***************************************************************************************************
+****************************************************************************************************
*/
#if !defined(TILEINDEX_INVALID)
#define TILEINDEX_INVALID -1
#endif
/**
-***************************************************************************************************
+****************************************************************************************************
* Return codes
-***************************************************************************************************
+****************************************************************************************************
*/
typedef enum _ADDR_E_RETURNCODE
{
} ADDR_E_RETURNCODE;
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief
* Neutral enums that define tile modes for all H/W
* @note
* R600/R800 tiling mode can be cast to hw enums directly but never cast into HW enum from
* ADDR_TM_2D_TILED_XTHICK
*
-***************************************************************************************************
+****************************************************************************************************
*/
typedef enum _AddrTileMode
{
} AddrTileMode;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrFormat
*
* @brief
* Neutral enum for SurfaceFormat
*
-***************************************************************************************************
+****************************************************************************************************
*/
typedef enum _AddrFormat {
ADDR_FMT_INVALID = 0x00000000,
} AddrFormat;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrDepthFormat
*
* @brief
* Neutral enum for addrFlt32ToDepthPixel
*
-***************************************************************************************************
+****************************************************************************************************
*/
typedef enum _AddrDepthFormat
{
} AddrDepthFormat;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrColorFormat
*
* @brief
* Neutral enum for ColorFormat
*
-***************************************************************************************************
+****************************************************************************************************
*/
typedef enum _AddrColorFormat
{
} AddrColorFormat;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrSurfaceNumber
*
* @brief
* Neutral enum for SurfaceNumber
*
-***************************************************************************************************
+****************************************************************************************************
*/
typedef enum _AddrSurfaceNumber {
ADDR_NUMBER_UNORM = 0x00000000,
} AddrSurfaceNumber;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrSurfaceSwap
*
* @brief
* Neutral enum for SurfaceSwap
*
-***************************************************************************************************
+****************************************************************************************************
*/
typedef enum _AddrSurfaceSwap {
ADDR_SWAP_STD = 0x00000000,
} AddrSurfaceSwap;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrHtileBlockSize
*
* @brief
* Size of HTILE blocks, valid values are 4 or 8 for now
-***************************************************************************************************
+****************************************************************************************************
*/
typedef enum _AddrHtileBlockSize
{
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrPipeCfg
*
* @brief
* For hw configurations w/ non-pow2 memory number of memory channels, it usually matches
* the number of ROP units(? TODO: which registers??)
* The enum value = hw enum + 1 which is to reserve 0 for requesting default.
-***************************************************************************************************
+****************************************************************************************************
*/
typedef enum _AddrPipeCfg
{
} AddrPipeCfg;
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrTileType
*
* @brief
* Neutral enums that specifies micro tile type (MICRO_TILE_MODE)
-***************************************************************************************************
+****************************************************************************************************
*/
typedef enum _AddrTileType
{
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file addrcommon.h
* @brief Contains the helper function and constants
-***************************************************************************************************
+****************************************************************************************************
*/
#ifndef __ADDR_COMMON_H__
#define _BIT(v,b) (((v) >> (b) ) & 1)
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief Enums to identify AddrLib type
-***************************************************************************************************
+****************************************************************************************************
*/
enum AddrLibClass
{
};
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrChipFamily
*
* @brief
* Neutral enums that specifies chip family.
*
-***************************************************************************************************
+****************************************************************************************************
*/
enum AddrChipFamily
{
};
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrConfigFlags
*
* @brief
* This structure is used to set configuration flags.
-***************************************************************************************************
+****************************************************************************************************
*/
union AddrConfigFlags
{
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrXorReduce
*
* @brief
* Xor the right-side numberOfBits bits of x.
-***************************************************************************************************
+****************************************************************************************************
*/
static inline UINT_32 XorReduce(
UINT_32 x,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* IsPow2
*
* @brief
* Check if the size (UINT_32) is pow 2
-***************************************************************************************************
+****************************************************************************************************
*/
static inline UINT_32 IsPow2(
UINT_32 dim) ///< [in] dimension of miplevel
}
/**
-***************************************************************************************************
+****************************************************************************************************
* IsPow2
*
* @brief
* Check if the size (UINT_64) is pow 2
-***************************************************************************************************
+****************************************************************************************************
*/
static inline UINT_64 IsPow2(
UINT_64 dim) ///< [in] dimension of miplevel
}
/**
-***************************************************************************************************
+****************************************************************************************************
* ByteAlign
*
* @brief
* Align UINT_32 "x" to "align" alignment, "align" should be power of 2
-***************************************************************************************************
+****************************************************************************************************
*/
static inline UINT_32 PowTwoAlign(
UINT_32 x,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* ByteAlign
*
* @brief
* Align UINT_64 "x" to "align" alignment, "align" should be power of 2
-***************************************************************************************************
+****************************************************************************************************
*/
static inline UINT_64 PowTwoAlign(
UINT_64 x,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* Min
*
* @brief
* Get the min value between two unsigned values
-***************************************************************************************************
+****************************************************************************************************
*/
static inline UINT_32 Min(
UINT_32 value1,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* Min
*
* @brief
* Get the min value between two signed values
-***************************************************************************************************
+****************************************************************************************************
*/
static inline INT_32 Min(
INT_32 value1,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* Max
*
* @brief
* Get the max value between two unsigned values
-***************************************************************************************************
+****************************************************************************************************
*/
static inline UINT_32 Max(
UINT_32 value1,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* Max
*
* @brief
* Get the max value between two signed values
-***************************************************************************************************
+****************************************************************************************************
*/
static inline INT_32 Max(
INT_32 value1,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* NextPow2
*
* @brief
* Compute the mipmap's next level dim size
-***************************************************************************************************
+****************************************************************************************************
*/
static inline UINT_32 NextPow2(
UINT_32 dim) ///< [in] dimension of miplevel
}
/**
-***************************************************************************************************
+****************************************************************************************************
* Log2NonPow2
*
* @brief
* Compute log of base 2 no matter the target is power of 2 or not
-***************************************************************************************************
+****************************************************************************************************
*/
static inline UINT_32 Log2NonPow2(
UINT_32 x) ///< [in] the value should calculate log based 2
}
/**
-***************************************************************************************************
+****************************************************************************************************
* Log2
*
* @brief
* Compute log of base 2
-***************************************************************************************************
+****************************************************************************************************
*/
static inline UINT_32 Log2(
UINT_32 x) ///< [in] the value should calculate log based 2
}
/**
-***************************************************************************************************
+****************************************************************************************************
* QLog2
*
* @brief
* Compute log of base 2 quickly (<= 16)
-***************************************************************************************************
+****************************************************************************************************
*/
static inline UINT_32 QLog2(
UINT_32 x) ///< [in] the value should calculate log based 2
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SafeAssign
*
* @brief
* NULL pointer safe assignment
-***************************************************************************************************
+****************************************************************************************************
*/
static inline VOID SafeAssign(
UINT_32* pLVal, ///< [in] Pointer to left val
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SafeAssign
*
* @brief
* NULL pointer safe assignment for 64bit values
-***************************************************************************************************
+****************************************************************************************************
*/
static inline VOID SafeAssign(
UINT_64* pLVal, ///< [in] Pointer to left val
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SafeAssign
*
* @brief
* NULL pointer safe assignment for AddrTileMode
-***************************************************************************************************
+****************************************************************************************************
*/
static inline VOID SafeAssign(
AddrTileMode* pLVal, ///< [in] Pointer to left val
}
/**
-***************************************************************************************************
+****************************************************************************************************
* InitChannel
*
* @brief
* Get channel initialization value
-***************************************************************************************************
+****************************************************************************************************
*/
static inline ADDR_CHANNEL_SETTING InitChannel(
UINT_32 valid, ///< [in] valid setting
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file addrelemlib.cpp
* @brief Contains the class implementation for element/pixel related functions
-***************************************************************************************************
+****************************************************************************************************
*/
#include "addrelemlib.h"
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::AddrElemLib
*
* @brief
*
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
AddrElemLib::AddrElemLib(
AddrLib* const pAddrLib) : ///< [in] Parent addrlib instance pointer
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::~AddrElemLib
*
* @brief
*
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
AddrElemLib::~AddrElemLib()
{
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::Create
*
* @brief
*
* @return
* Returns point to ADDR_CREATEINFO if successful.
-***************************************************************************************************
+****************************************************************************************************
*/
AddrElemLib* AddrElemLib::Create(
const AddrLib* const pAddrLib) ///< [in] Pointer of parent AddrLib instance
*
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrElemLib::Flt32sToInt32s(
ADDR_FLT_32 value, ///< [in] ADDR_FLT_32 value
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::Int32sToPixel
*
* @brief
* an uncompressed pixel. The pixel values are specifies in
* standard order, e.g. depth/stencil. This routine asserts
* if called on compressed pixel.
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrElemLib::Int32sToPixel(
UINT_32 numComps, ///< [in] number of components
}
/**
-***************************************************************************************************
+****************************************************************************************************
* Flt32ToDepthPixel
*
* @brief
*
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrElemLib::Flt32ToDepthPixel(
AddrDepthFormat format, ///< [in] Depth format
}
/**
-***************************************************************************************************
+****************************************************************************************************
* Flt32ToColorPixel
*
* @brief
*
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrElemLib::Flt32ToColorPixel(
AddrColorFormat format, ///< [in] Color format
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::GetCompType
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrElemLib::GetCompType(
AddrColorFormat format, ///< [in] surface format
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::GetCompSwap
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrElemLib::GetCompSwap(
AddrSurfaceSwap swap, ///< [in] swap mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::GetCompSwap
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrElemLib::SwapComps(
UINT_32 c0, ///< [in] component index 0
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::PixGetColorCompInfo
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrElemLib::PixGetColorCompInfo(
AddrColorFormat format, ///< [in] surface format, read from register
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::PixGetDepthCompInfo
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrElemLib::PixGetDepthCompInfo(
AddrDepthFormat format, ///< [in] surface format, read from register
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::PixGetExportNorm
*
* @brief
* @return
* TRUE if this can be enabled.
*
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 AddrElemLib::PixGetExportNorm(
AddrColorFormat colorFmt, ///< [in] surface format, read from register
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::AdjustSurfaceInfo
*
* @brief
*
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrElemLib::AdjustSurfaceInfo(
AddrElemMode elemMode, ///< [in] element mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::RestoreSurfaceInfo
*
* @brief
*
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrElemLib::RestoreSurfaceInfo(
AddrElemMode elemMode, ///< [in] element mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::GetBitsPerPixel
*
* @brief
*
* @return
* Bits per pixel
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 AddrElemLib::GetBitsPerPixel(
AddrFormat format, ///< [in] surface format code
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::GetCompBits
*
* @brief
*
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrElemLib::GetCompBits(
UINT_32 c0, ///< [in] bits of component 0
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::GetCompBits
*
* @brief
*
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrElemLib::SetClearComps(
ADDR_FLT_32 comps[4], ///< [in/out] components
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::IsBlockCompressed
*
* @brief
*
* @return
* BOOL_32
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 AddrElemLib::IsBlockCompressed(
AddrFormat format) ///< [in] Format
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::IsCompressed
*
* @brief
*
* @return
* BOOL_32
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 AddrElemLib::IsCompressed(
AddrFormat format) ///< [in] Format
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrElemLib::IsExpand3x
*
* @brief
*
* @return
* BOOL_32
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 AddrElemLib::IsExpand3x(
AddrFormat format) ///< [in] Format
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file addrelemlib.h
* @brief Contains the class for element/pixel related functions
-***************************************************************************************************
+****************************************************************************************************
*/
#ifndef __ELEM_LIB_H__
};
/**
-***************************************************************************************************
+****************************************************************************************************
* ADDR_PIXEL_FORMATINFO
*
* @brief
* Per component info
*
-***************************************************************************************************
+****************************************************************************************************
*/
struct ADDR_PIXEL_FORMATINFO
{
};
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief This class contains asic indepentent element related attributes and operations
-***************************************************************************************************
+****************************************************************************************************
*/
class AddrElemLib : public AddrObject
{
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file addrlib.cpp
* @brief Contains the implementation for the AddrLib base class..
-***************************************************************************************************
+****************************************************************************************************
*/
#include "addrinterface.h"
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib::AddrLib
*
* @brief
* Constructor for the AddrLib class
*
-***************************************************************************************************
+****************************************************************************************************
*/
AddrLib::AddrLib() :
m_class(BASE_ADDRLIB),
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib::AddrLib
*
* @brief
* Constructor for the AddrLib class with hClient as parameter
*
-***************************************************************************************************
+****************************************************************************************************
*/
AddrLib::AddrLib(const AddrClient* pClient) :
AddrObject(pClient),
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib::~AddrLib
*
* @brief
* Destructor for the AddrLib class
*
-***************************************************************************************************
+****************************************************************************************************
*/
AddrLib::~AddrLib()
{
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib::Create
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib::Create(
const ADDR_CREATE_INPUT* pCreateIn, ///< [in] pointer to ADDR_CREATE_INPUT
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib::SetAddrChipFamily
*
* @brief
* Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrLib::SetAddrChipFamily(
UINT_32 uChipFamily, ///< [in] chip family defined in atiih.h
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib::SetMinPitchAlignPixels
*
* @brief
*
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrLib::SetMinPitchAlignPixels(
UINT_32 minPitchAlignPixels) ///< [in] minmum pitch alignment in pixels
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib::GetAddrLib
*
* @brief
*
* @return
* An AddrLib class pointer
-***************************************************************************************************
+****************************************************************************************************
*/
AddrLib * AddrLib::GetAddrLib(
ADDR_HANDLE hLib) ///< [in] handle of ADDR_HANDLE
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib::GetMaxAlignments
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib::GetMaxAlignments(
ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut ///< [out] output structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib::Bits2Number
*
* @brief
*
* @return
* The number combined with the array of bits
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 AddrLib::Bits2Number(
UINT_32 bitNum, ///< [in] how many bits
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib::Flt32ToColorPixel
*
* @brief
* Convert a FLT_32 value to a depth/stencil pixel value
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib::Flt32ToDepthPixel(
const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib::Flt32ToColorPixel
*
* @brief
* Convert a FLT_32 value to a red/green/blue/alpha pixel value
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib::Flt32ToColorPixel(
const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib::GetExportNorm
*
* @brief
* Check one format can be EXPORT_NUM
* @return
* TRUE if EXPORT_NORM can be used
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 AddrLib::GetExportNorm(
const ELEM_GETEXPORTNORM_INPUT* pIn) const
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file addrlib.h
* @brief Contains the AddrLib base class definition.
-***************************************************************************************************
+****************************************************************************************************
*/
#ifndef __ADDR_LIB_H__
#define CIASICIDGFXENGINE_SEAISLAND 0x0000000B
#endif
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief Neutral enums that define pipeinterleave
-***************************************************************************************************
+****************************************************************************************************
*/
enum AddrPipeInterleave
{
};
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief Neutral enums that define DRAM row size
-***************************************************************************************************
+****************************************************************************************************
*/
enum AddrRowSize
{
};
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief Neutral enums that define bank interleave
-***************************************************************************************************
+****************************************************************************************************
*/
enum AddrBankInterleave
{
};
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief Neutral enums that define MGPU chip tile size
-***************************************************************************************************
+****************************************************************************************************
*/
enum AddrChipTileSize
{
};
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief Neutral enums that define shader engine tile size
-***************************************************************************************************
+****************************************************************************************************
*/
enum AddrEngTileSize
{
};
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief Neutral enums that define bank swap size
-***************************************************************************************************
+****************************************************************************************************
*/
enum AddrBankSwapSize
{
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief This class contains asic independent address lib functionalities
-***************************************************************************************************
+****************************************************************************************************
*/
class AddrLib : public AddrObject
{
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file addr1lib.cpp
* @brief Contains the implementation for the AddrLib1 base class..
-***************************************************************************************************
+****************************************************************************************************
*/
#include "addrinterface.h"
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::AddrLib1
*
* @brief
* Constructor for the AddrLib1 class
*
-***************************************************************************************************
+****************************************************************************************************
*/
AddrLib1::AddrLib1() :
AddrLib()
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::AddrLib1
*
* @brief
* Constructor for the AddrLib1 class with hClient as parameter
*
-***************************************************************************************************
+****************************************************************************************************
*/
AddrLib1::AddrLib1(const AddrClient* pClient) :
AddrLib(pClient)
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::~AddrLib1
*
* @brief
* Destructor for the AddrLib1 class
*
-***************************************************************************************************
+****************************************************************************************************
*/
AddrLib1::~AddrLib1()
{
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::GetAddrLib1
*
* @brief
*
* @return
* An AddrLib1 class pointer
-***************************************************************************************************
+****************************************************************************************************
*/
AddrLib1* AddrLib1::GetAddrLib1(
ADDR_HANDLE hLib) ///< [in] handle of ADDR_HANDLE
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeSurfaceInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeSurfaceInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceAddrFromCoord(
const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeSurfaceCoordFromAddr
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceCoordFromAddr(
const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeSliceTileSwizzle
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeSliceTileSwizzle(
const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ExtractBankPipeSwizzle
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ExtractBankPipeSwizzle(
const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::CombineBankPipeSwizzle
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::CombineBankPipeSwizzle(
const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeBaseSwizzle
*
* @brief
* Interface function stub of AddrCompueBaseSwizzle.
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeBaseSwizzle(
const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeFmaskInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeFmaskInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeFmaskAddrFromCoord
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeFmaskAddrFromCoord(
const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeFmaskCoordFromAddr
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeFmaskCoordFromAddr(
const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ConvertTileInfoToHW
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ConvertTileInfoToHW(
const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ConvertTileIndex
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex(
const ADDR_CONVERT_TILEINDEX_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::GetMacroModeIndex
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::GetMacroModeIndex(
const ADDR_GET_MACROMODEINDEX_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ConvertTileIndex1
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex1(
const ADDR_CONVERT_TILEINDEX1_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::GetTileIndex
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::GetTileIndex(
const ADDR_GET_TILEINDEX_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::Thickness
*
* @brief
*
* @return
* Tile mode thickness
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 AddrLib1::Thickness(
AddrTileMode tileMode) ///< [in] tile mode
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeHtileInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeHtileInfo(
const ADDR_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeCmaskInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
const ADDR_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeDccInfo
*
* @brief
*
* @return
* return code of HwlComputeDccInfo
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeDccInfo(
const ADDR_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeHtileAddrFromCoord
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeHtileAddrFromCoord(
const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeHtileCoordFromAddr
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeHtileCoordFromAddr(
const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeCmaskAddrFromCoord
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeCmaskAddrFromCoord(
const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeCmaskCoordFromAddr
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeCmaskCoordFromAddr(
const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeTileDataWidthAndHeight
*
* @brief
*
* @note
* MacroWidth and macroHeight are measured in pixels
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrLib1::ComputeTileDataWidthAndHeight(
UINT_32 bpp, ///< [in] bits per pixel
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::HwlComputeTileDataWidthAndHeightLinear
*
* @brief
*
* @note
* MacroWidth and macroHeight are measured in pixels
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrLib1::HwlComputeTileDataWidthAndHeightLinear(
UINT_32* pMacroWidth, ///< [out] macro tile width
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeHtileInfo
*
* @brief
* Htile bpp i.e. How many bits for an 8x8 tile
* Also returns by output parameters:
* *Htile pitch, height, total size in bytes, macro-tile dimensions and slice size*
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 AddrLib1::ComputeHtileInfo(
ADDR_HTILE_FLAGS flags, ///< [in] htile flags
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeCmaskBaseAlign
*
* @brief
*
* @return
* Cmask base alignment
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 AddrLib1::ComputeCmaskBaseAlign(
ADDR_CMASK_FLAGS flags, ///< [in] Cmask flags
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeCmaskBytes
*
* @brief
*
* @return
* Cmask size in bytes
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 AddrLib1::ComputeCmaskBytes(
UINT_32 pitch, ///< [in] pitch
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeCmaskInfo
*
* @brief
* @return
* BlockMax. Also by output parameters: Cmask pitch,height, total size in bytes,
* macro-tile dimensions
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
ADDR_CMASK_FLAGS flags, ///< [in] cmask flags
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeXmaskCoordYFromPipe
*
* @brief
* @return
* Y coordinate
*
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 AddrLib1::ComputeXmaskCoordYFromPipe(
UINT_32 pipe, ///< [in] pipe number
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::HwlComputeXmaskCoordFromAddr
*
* @brief
*
* @note
* This method is reused by htile, so rename to Xmask
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrLib1::HwlComputeXmaskCoordFromAddr(
UINT_64 addr, ///< [in] address
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::HwlComputeXmaskAddrFromCoord
*
* @brief
* @return
* Address in bytes
*
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 AddrLib1::HwlComputeXmaskAddrFromCoord(
UINT_32 pitch, ///< [in] pitch
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeSurfaceAddrFromCoordLinear
*
* @brief
* @return
* Address in bytes
*
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 AddrLib1::ComputeSurfaceAddrFromCoordLinear(
UINT_32 x, ///< [in] x coord
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeSurfaceCoordFromAddrLinear
*
* @brief
*
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrLib1::ComputeSurfaceCoordFromAddrLinear(
UINT_64 addr, ///< [in] address
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled
*
* @brief
*
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled(
UINT_64 addr, ///< [in] address
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputePipeFromAddr
*
* @brief
* @return
* Pipe number
*
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 AddrLib1::ComputePipeFromAddr(
UINT_64 addr, ///< [in] address
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeMicroTileEquation
*
* @brief
* @return
* If equation can be computed
*
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputeMicroTileEquation(
UINT_32 log2BytesPP, ///< [in] log2 of bytes per pixel
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputePixelIndexWithinMicroTile
*
* @brief
* @return
* Pixel index
*
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 AddrLib1::ComputePixelIndexWithinMicroTile(
UINT_32 x, ///< [in] x coord
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::AdjustPitchAlignment
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrLib1::AdjustPitchAlignment(
ADDR_SURFACE_FLAGS flags, ///< [in] Surface flags
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::PadDimensions
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrLib1::PadDimensions(
AddrTileMode tileMode, ///< [in] tile mode
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::HwlPreHandleBaseLvl3xPitch
*
* @brief
*
* @return
* Expected pitch
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::HwlPostHandleBaseLvl3xPitch
*
* @brief
*
* @return
* Expected pitch
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::IsMacroTiled
*
* @brief
*
* @return
* TRUE if it is macro tiled (2D/2B/3D/3B)
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 AddrLib1::IsMacroTiled(
AddrTileMode tileMode) ///< [in] tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::IsMacro3dTiled
*
* @brief
*
* @return
* TRUE if it is 3D macro tiled
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 AddrLib1::IsMacro3dTiled(
AddrTileMode tileMode) ///< [in] tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::IsMicroTiled
*
* @brief
*
* @return
* TRUE if micro tiled
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 AddrLib1::IsMicroTiled(
AddrTileMode tileMode) ///< [in] tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::IsLinear
*
* @brief
*
* @return
* TRUE if linear
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 AddrLib1::IsLinear(
AddrTileMode tileMode) ///< [in] tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::IsPrtNoRotationTileMode
*
* @brief
* Return TRUE if it is prt tile without rotation
* @note
* This function just used by CI
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 AddrLib1::IsPrtNoRotationTileMode(
AddrTileMode tileMode)
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::IsPrtTileMode
*
* @brief
* Return TRUE if it is prt tile
* @note
* This function just used by CI
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 AddrLib1::IsPrtTileMode(
AddrTileMode tileMode)
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeMipLevel
*
* @brief
* Compute mipmap level width/height/slices
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrLib1::ComputeMipLevel(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn ///< [in/out] Input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::OptimizeTileMode
*
* @brief
* Check if base level's tile mode can be optimized (degraded)
* @return
* TRUE if degraded, also returns degraded tile mode (unchanged if not degraded)
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 AddrLib1::OptimizeTileMode(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure for surface info
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::DegradeLargeThickTile
*
* @brief
* Check if the thickness needs to be reduced if a tile is too large
* @return
* The degraded tile mode (unchanged if not degraded)
-***************************************************************************************************
+****************************************************************************************************
*/
AddrTileMode AddrLib1::DegradeLargeThickTile(
AddrTileMode tileMode,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::PostComputeMipLevel
* @brief
* Compute MipLevel info (including level 0) after surface adjustment
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::PostComputeMipLevel(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in/out] Input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::HwlSetupTileCfg
*
* @brief
* Map tile index to tile setting.
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::HwlSetupTileCfg(
UINT_32 bpp, ///< Bits per pixel
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::HwlGetPipes
*
* @brief
* Get number pipes
* @return
* num pipes
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 AddrLib1::HwlGetPipes(
const ADDR_TILEINFO* pTileInfo ///< [in] Tile info
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputeQbStereoInfo
*
* @brief
* Get quad buffer stereo information
* @return
* TRUE if no error
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 AddrLib1::ComputeQbStereoInfo(
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [in/out] updated pOut+pStereoInfo
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrLib1::ComputePrtInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE AddrLib1::ComputePrtInfo(
const ADDR_PRT_INFO_INPUT* pIn,
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file addrlib1.h
* @brief Contains the AddrLib1 base class definition.
-***************************************************************************************************
+****************************************************************************************************
*/
#ifndef __ADDR_LIB1_H__
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief Neutral enums that define bank swap size
-***************************************************************************************************
+****************************************************************************************************
*/
enum AddrSampleSplitSize
{
};
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief Flags for AddrTileMode
-***************************************************************************************************
+****************************************************************************************************
*/
struct AddrTileModeFlags
{
};
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief This class contains asic independent address lib functionalities
-***************************************************************************************************
+****************************************************************************************************
*/
class AddrLib1 : public AddrLib
{
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file addrobject.cpp
* @brief Contains the AddrObject base class implementation.
-***************************************************************************************************
+****************************************************************************************************
*/
#include "addrinterface.h"
#include "addrobject.h"
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrObject::AddrObject
*
* @brief
* Constructor for the AddrObject class.
-***************************************************************************************************
+****************************************************************************************************
*/
AddrObject::AddrObject()
{
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrObject::AddrObject
*
* @brief
* Constructor for the AddrObject class.
-***************************************************************************************************
+****************************************************************************************************
*/
AddrObject::AddrObject(const AddrClient* pClient)
{
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrObject::~AddrObject
*
* @brief
* Destructor for the AddrObject class.
-***************************************************************************************************
+****************************************************************************************************
*/
AddrObject::~AddrObject()
{
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrObject::ClientAlloc
*
* @brief
* Calls instanced allocSysMem inside AddrClient
-***************************************************************************************************
+****************************************************************************************************
*/
VOID* AddrObject::ClientAlloc(
size_t objSize, ///< [in] Size to allocate
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrObject::AddrMalloc
*
* @brief
* A wrapper of ClientAlloc
-***************************************************************************************************
+****************************************************************************************************
*/
VOID* AddrObject::AddrMalloc(
size_t objSize) const ///< [in] Size to allocate
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrObject::ClientFree
*
* @brief
* Calls freeSysMem inside AddrClient
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrObject::ClientFree(
VOID* pObjMem, ///< [in] User virtual address to free.
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrObject::AddrFree
*
* @brief
* A wrapper of ClientFree
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrObject::AddrFree(
VOID* pObjMem) const ///< [in] User virtual address to free.
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrObject::operator new
*
* @brief
*
* @return
* Returns NULL if unsuccessful.
-***************************************************************************************************
+****************************************************************************************************
*/
VOID* AddrObject::operator new(
size_t objSize, ///< [in] Size to allocate
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrObject::operator delete
*
* @brief
* Frees AddrObject object memory.
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrObject::operator delete(
VOID* pObjMem, ///< [in] User virtual address to free.
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrObject::operator delete
*
* @brief
* Frees AddrObject object memory.
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrObject::operator delete(
VOID* pObjMem) ///< [in] User virtual address to free.
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrObject::DebugPrint
*
* @brief
*
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID AddrObject::DebugPrint(
const CHAR* pDebugString, ///< [in] Debug string
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file addrobject.h
* @brief Contains the AddrObject base class definition.
-***************************************************************************************************
+****************************************************************************************************
*/
#ifndef __ADDR_OBJECT_H__
#include "addrcommon.h"
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief This structure contains client specific data
-***************************************************************************************************
+****************************************************************************************************
*/
struct AddrClient
{
ADDR_CALLBACKS callbacks;
};
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief This class is the base class for all ADDR class objects.
-***************************************************************************************************
+****************************************************************************************************
*/
class AddrObject
{
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file ciaddrlib.cpp
* @brief Contains the implementation for the CiAddrLib class.
-***************************************************************************************************
+****************************************************************************************************
*/
#include "ciaddrlib.h"
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrMask
*
* @brief
* Gets a mask of "width"
* @return
* Bit mask
-***************************************************************************************************
+****************************************************************************************************
*/
static UINT_64 AddrMask(
UINT_32 width) ///< Width of bits
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrGetBits
*
* @brief
* Gets bits within a range of [msb, lsb]
* @return
* Bits of this range
-***************************************************************************************************
+****************************************************************************************************
*/
static UINT_64 AddrGetBits(
UINT_64 bits, ///< Source bits
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrRemoveBits
*
* @brief
* Removes bits within the range of [msb, lsb]
* @return
* Modified bits
-***************************************************************************************************
+****************************************************************************************************
*/
static UINT_64 AddrRemoveBits(
UINT_64 bits, ///< Source bits
}
/**
-***************************************************************************************************
+****************************************************************************************************
* AddrInsertBits
*
* @brief
* Inserts new bits into the range of [msb, lsb]
* @return
* Modified bits
-***************************************************************************************************
+****************************************************************************************************
*/
static UINT_64 AddrInsertBits(
UINT_64 bits, ///< Source bits
/**
-***************************************************************************************************
-* AddrCIHwlInit
+****************************************************************************************************
+* AddrCiHwlInit
*
* @brief
* Creates an CiAddrLib object.
*
* @return
* Returns an CiAddrLib object pointer.
-***************************************************************************************************
+****************************************************************************************************
*/
AddrLib* AddrCIHwlInit(const AddrClient* pClient)
{
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::CiAddrLib
*
* @brief
* Constructor
*
-***************************************************************************************************
+****************************************************************************************************
*/
CiAddrLib::CiAddrLib(const AddrClient* pClient) :
SiAddrLib(pClient),
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::~CiAddrLib
*
* @brief
* Destructor
-***************************************************************************************************
+****************************************************************************************************
*/
CiAddrLib::~CiAddrLib()
{
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlComputeDccInfo
*
* @brief
* Compute DCC key size, base alignment
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE CiAddrLib::HwlComputeDccInfo(
const ADDR_COMPUTE_DCCINFO_INPUT* pIn,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlComputeCmaskAddrFromCoord
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE CiAddrLib::HwlComputeCmaskAddrFromCoord(
const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] fmask addr/bpp/tile input
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlComputeHtileAddrFromCoord
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE CiAddrLib::HwlComputeHtileAddrFromCoord(
const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] depth/stencil addr/bpp/tile input
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlConvertChipFamily
*
* @brief
* Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
* @return
* AddrChipFamily
-***************************************************************************************************
+****************************************************************************************************
*/
AddrChipFamily CiAddrLib::HwlConvertChipFamily(
UINT_32 uChipFamily, ///< [in] chip family defined in atiih.h
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlInitGlobalParams
*
* @brief
* @return
* TRUE if all settings are valid
*
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 CiAddrLib::HwlInitGlobalParams(
const ADDR_CREATE_INPUT* pCreateIn) ///< [in] create input
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlPostCheckTileIndex
*
* @brief
* tile mode/type/info and change the index if needed
* @return
* Tile index.
-***************************************************************************************************
+****************************************************************************************************
*/
INT_32 CiAddrLib::HwlPostCheckTileIndex(
const ADDR_TILEINFO* pInfo, ///< [in] Tile Info
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlSetupTileCfg
*
* @brief
* Map tile index to tile setting.
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE CiAddrLib::HwlSetupTileCfg(
UINT_32 bpp, ///< [in] Bits per pixel
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlComputeSurfaceInfo
*
* @brief
* Entry of ci's ComputeSurfaceInfo
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE CiAddrLib::HwlComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlFmaskSurfaceInfo
* @brief
* Entry of r800's ComputeFmaskInfo
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE CiAddrLib::HwlComputeFmaskInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlFmaskPreThunkSurfInfo
*
* @brief
* Some preparation before thunking a ComputeSurfaceInfo call for Fmask
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
VOID CiAddrLib::HwlFmaskPreThunkSurfInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pFmaskIn, ///< [in] Input of fmask info
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlFmaskPostThunkSurfInfo
*
* @brief
* Copy hwl extra field after calling thunked ComputeSurfaceInfo
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
VOID CiAddrLib::HwlFmaskPostThunkSurfInfo(
const ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pSurfOut, ///< [in] Output of surface info
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlDegradeThickTileMode
*
* @brief
*
* @return
* Suitable tile mode
-***************************************************************************************************
+****************************************************************************************************
*/
AddrTileMode CiAddrLib::HwlDegradeThickTileMode(
AddrTileMode baseTileMode, ///< [in] base tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlOverrideTileMode
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID CiAddrLib::HwlOverrideTileMode(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut ///< [in/out] input output structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlSelectTileMode
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID CiAddrLib::HwlSelectTileMode(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut ///< [in/out] input output structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlSetupTileInfo
*
* @brief
* Setup default value of tile info for SI
-***************************************************************************************************
+****************************************************************************************************
*/
VOID CiAddrLib::HwlSetupTileInfo(
AddrTileMode tileMode, ///< [in] Tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::ReadGbTileMode
*
* @brief
* Convert GB_TILE_MODE HW value to ADDR_TILE_CONFIG.
* @return
* NA.
-***************************************************************************************************
+****************************************************************************************************
*/
VOID CiAddrLib::ReadGbTileMode(
UINT_32 regValue, ///< [in] GB_TILE_MODE register
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::InitTileSettingTable
*
* @brief
* Initialize the ADDR_TILE_CONFIG table.
* @return
* TRUE if tile table is correctly initialized
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 CiAddrLib::InitTileSettingTable(
const UINT_32* pCfg, ///< [in] Pointer to table of tile configs
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::ReadGbMacroTileCfg
*
* @brief
* Convert GB_MACRO_TILE_CFG HW value to ADDR_TILE_CONFIG.
* @return
* NA.
-***************************************************************************************************
+****************************************************************************************************
*/
VOID CiAddrLib::ReadGbMacroTileCfg(
UINT_32 regValue, ///< [in] GB_MACRO_TILE_MODE register
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::InitMacroTileCfgTable
*
* @brief
* Initialize the ADDR_MACRO_TILE_CONFIG table.
* @return
* TRUE if macro tile table is correctly initialized
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 CiAddrLib::InitMacroTileCfgTable(
const UINT_32* pCfg, ///< [in] Pointer to table of tile configs
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlComputeMacroModeIndex
*
* @brief
* Computes macro tile mode index
* @return
* TRUE if macro tile table is correctly initialized
-***************************************************************************************************
+****************************************************************************************************
*/
INT_32 CiAddrLib::HwlComputeMacroModeIndex(
INT_32 tileIndex, ///< [in] Tile mode index
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlComputeTileDataWidthAndHeightLinear
*
* @brief
*
* @note
* MacroWidth and macroHeight are measured in pixels
-***************************************************************************************************
+****************************************************************************************************
*/
VOID CiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
UINT_32* pMacroWidth, ///< [out] macro tile width
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlComputeMetadataNibbleAddress
*
* @brief
* @return
* meta data nibble address (nibble address is used to support DCC compatible cmask)
*
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
UINT_64 uncompressedDataByteAddress,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlPadDimensions
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID CiAddrLib::HwlPadDimensions(
AddrTileMode tileMode, ///< [in] tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* CiAddrLib::HwlGetMaxAlignments
*
* @brief
* Gets maximum alignments
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE CiAddrLib::HwlGetMaxAlignments(
ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut ///< [out] output structure
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file ciaddrlib.h
* @brief Contains the CiAddrLib class definition.
-***************************************************************************************************
+****************************************************************************************************
*/
#ifndef __CI_ADDR_LIB_H__
#include "siaddrlib.h"
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief CI specific settings structure.
-***************************************************************************************************
+****************************************************************************************************
*/
struct CIChipSettings
{
};
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief This class is the CI specific address library
* function set.
-***************************************************************************************************
+****************************************************************************************************
*/
class CiAddrLib : public SiAddrLib
{
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file egbaddrlib.cpp
* @brief Contains the EgBasedAddrLib class implementation
-***************************************************************************************************
+****************************************************************************************************
*/
#include "egbaddrlib.h"
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::EgBasedAddrLib
*
* @brief
*
* @note
*
-***************************************************************************************************
+****************************************************************************************************
*/
EgBasedAddrLib::EgBasedAddrLib(const AddrClient* pClient) :
AddrLib1(pClient),
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::~EgBasedAddrLib
*
* @brief
* Destructor
-***************************************************************************************************
+****************************************************************************************************
*/
EgBasedAddrLib::~EgBasedAddrLib()
{
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::DispatchComputeSurfaceInfo
*
* @brief
*
* @return
* TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::DispatchComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceInfoLinear
*
* @brief
*
* @return
* TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoLinear(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceInfoMicroTiled
*
* @brief
*
* @return
* TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMicroTiled(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceInfoMacroTiled
*
* @brief
*
* @return
* TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMacroTiled(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceAlignmentsLinear
*
* @brief
*
* @return
* TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsLinear(
AddrTileMode tileMode, ///< [in] tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled
*
* @brief
*
* @return
* TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled(
AddrTileMode tileMode, ///< [in] tile mode
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlReduceBankWidthHeight
*
* @brief
*
* @return
* TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::HwlReduceBankWidthHeight(
UINT_32 tileSize, ///< [in] tile size
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled
*
* @brief
*
* @return
* TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled(
AddrTileMode tileMode, ///< [in] tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::SanityCheckMacroTiled
*
* @brief
* Check if macro-tiled parameters are valid
* @return
* TRUE if valid
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::SanityCheckMacroTiled(
ADDR_TILEINFO* pTileInfo ///< [in] macro-tiled parameters
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceMipLevelTileMode
*
* @brief
*
* @return
* Suitable tile mode
-***************************************************************************************************
+****************************************************************************************************
*/
AddrTileMode EgBasedAddrLib::ComputeSurfaceMipLevelTileMode(
AddrTileMode baseTileMode, ///< [in] base tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlDegradeBaseLevel
* @brief
* Check if degrade is needed for base level
* @return
* TRUE if degrade is suggested
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::HwlDegradeBaseLevel(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn) const
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlDegradeThickTileMode
*
* @brief
*
* @return
* Suitable tile mode
-***************************************************************************************************
+****************************************************************************************************
*/
AddrTileMode EgBasedAddrLib::HwlDegradeThickTileMode(
AddrTileMode baseTileMode, ///< [in] base tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord
*
* @brief
*
* @return
* Address in bytes
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord(
const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeMacroTileEquation
*
* @brief
* Computes the address equation in macro tile
* @return
* If equation can be computed
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::ComputeMacroTileEquation(
UINT_32 log2BytesPP, ///< [in] log2 of bytes per pixel
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled
*
* @brief
* coordinate for 2D tilied (macro tiled)
* @return
* The byte address
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMacroTiled(
UINT_32 x, ///< [in] x coordinate
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled
*
* @brief
* (micro tiled)
* @return
* The byte address
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled(
UINT_32 x, ///< [in] x coordinate
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlComputePixelCoordFromOffset
*
* @brief
* Compute pixel coordinate from offset inside a micro tile
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID EgBasedAddrLib::HwlComputePixelCoordFromOffset(
UINT_32 offset, ///< [in] offset inside micro tile in bits
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddrDispatch
*
* @brief
* Compute (x,y,slice,sample) coordinates from surface address
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddr(
const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled
*
* @brief
* Compute surface coordinates from address for macro tiled surface
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled(
UINT_64 addr, ///< [in] byte address
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeSurfaceCoord2DFromBankPipe
*
* @brief
* Compute surface x,y coordinates from bank/pipe info
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID EgBasedAddrLib::ComputeSurfaceCoord2DFromBankPipe(
AddrTileMode tileMode, ///< [in] tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlExtractBankPipeSwizzle
* @brief
* Entry of EgBasedAddrLib ExtractBankPipeSwizzle
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlExtractBankPipeSwizzle(
const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn, ///< [in] input structure
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlCombineBankPipeSwizzle
* @brief
* Combine bank/pipe swizzle
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlCombineBankPipeSwizzle(
UINT_32 bankSwizzle, ///< [in] bank swizzle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlComputeBaseSwizzle
* @brief
* Compute base swizzle
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeBaseSwizzle(
const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ExtractBankPipeSwizzle
* @brief
* Extract bank/pipe swizzle from base256b
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID EgBasedAddrLib::ExtractBankPipeSwizzle(
UINT_32 base256b, ///< [in] input base256b register value
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::GetBankPipeSwizzle
* @brief
* Combine bank/pipe swizzle
* @return
* Base256b bits (only filled bank/pipe bits)
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::GetBankPipeSwizzle(
UINT_32 bankSwizzle, ///< [in] bank swizzle
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeSliceTileSwizzle
* @brief
* Compute cubemap/3d texture faces/slices tile swizzle
* @return
* Tile swizzle
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::ComputeSliceTileSwizzle(
AddrTileMode tileMode, ///< [in] Tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlComputeQbStereoRightSwizzle
*
* @brief
* Compute right eye swizzle
* @return
* swizzle
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::HwlComputeQbStereoRightSwizzle(
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pInfo ///< [in] Surface info, must be valid
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeBankFromCoord
*
* @brief
* Compute bank number from coordinates
* @return
* Bank number
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::ComputeBankFromCoord(
UINT_32 x, ///< [in] x coordinate
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeBankFromAddr
*
* @brief
* Compute the bank number from an address
* @return
* Bank number
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::ComputeBankFromAddr(
UINT_64 addr, ///< [in] address
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputePipeRotation
*
* @brief
* Compute pipe rotation value
* @return
* Pipe rotation
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::ComputePipeRotation(
AddrTileMode tileMode, ///< [in] tile mode
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeBankRotation
*
* @brief
* Compute bank rotation value
* @return
* Bank rotation
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::ComputeBankRotation(
AddrTileMode tileMode, ///< [in] tile mode
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeHtileBytes
*
* @brief
*
* @return
* Htile size in bytes
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::ComputeHtileBytes(
UINT_32 pitch, ///< [in] pitch
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::DispatchComputeFmaskInfo
*
* @brief
*
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::DispatchComputeFmaskInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlFmaskSurfaceInfo
* @brief
* Entry of EgBasedAddrLib ComputeFmaskInfo
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlComputeFmaskAddrFromCoord
* @brief
* Entry of EgBasedAddrLib ComputeFmaskAddrFromCoord
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskAddrFromCoord(
const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlComputeFmaskCoordFromAddr
* @brief
* Entry of EgBasedAddrLib ComputeFmaskCoordFromAddr
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskCoordFromAddr(
const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
#if ADDR_AM_BUILD
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord
*
* @brief
* Computes the FMASK address and bit position from a coordinate.
* @return
* The byte address
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord(
const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled
*
* @brief
* tiled)
* @return
* The byte address
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled(
UINT_32 x, ///< [in] x coordinate
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled
*
* @brief
* tiled)
* @return
* The byte address
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled(
UINT_32 x, ///< [in] x coordinate
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled(
UINT_64 addr, ///< [in] byte address
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled(
UINT_64 addr, ///< [in] byte address
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr(
const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
#endif
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples
*
* @brief
*
* @return
* Number of planes
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples(
UINT_32 numSamples) ///< [in] number of samples
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples
*
* @brief
*
* @return
* bpp
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples(
UINT_32 numSamples) ///< number of samples
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::IsTileInfoAllZero
*
* @brief
* Return TRUE if all field are zero
* @note
* Since NULL input is consider to be all zero
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::IsTileInfoAllZero(
ADDR_TILEINFO* pTileInfo)
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlTileInfoEqual
*
* @brief
* Return TRUE if all field are equal
* @note
* Only takes care of current HWL's data
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 EgBasedAddrLib::HwlTileInfoEqual(
const ADDR_TILEINFO* pLeft, ///<[in] Left compare operand
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlConvertTileInfoToHW
* @brief
* Entry of EgBasedAddrLib ConvertTileInfoToHW
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlConvertTileInfoToHW(
const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlComputeSurfaceInfo
* @brief
* Entry of EgBasedAddrLib ComputeSurfaceInfo
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlComputeSurfaceAddrFromCoord
* @brief
* Entry of EgBasedAddrLib ComputeSurfaceAddrFromCoord
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceAddrFromCoord(
const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlComputeSurfaceCoordFromAddr
* @brief
* Entry of EgBasedAddrLib ComputeSurfaceCoordFromAddr
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceCoordFromAddr(
const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlComputeSliceTileSwizzle
* @brief
* Entry of EgBasedAddrLib ComputeSurfaceCoordFromAddr
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSliceTileSwizzle(
const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlComputeHtileBpp
*
* @brief
*
* @return
* Htile bpp
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::HwlComputeHtileBpp(
BOOL_32 isWidth8, ///< [in] TRUE if block width is 8
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlComputeHtileBaseAlign
*
* @brief
*
* @return
* Htile base alignment
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::HwlComputeHtileBaseAlign(
BOOL_32 isTcCompatible, ///< [in] if TC compatible
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled
*
* @brief
*
* @return
* pitch alignment
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(
AddrTileMode tileMode, ///< [in] tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled
*
* @brief
*
* @return
* Logical slice size in bytes
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled(
UINT_32 thickness, ///< [in] thickness
}
/**
-***************************************************************************************************
+****************************************************************************************************
* EgBasedAddrLib::HwlStereoCheckRightOffsetPadding
*
* @brief
* @return
* TRUE is the extra padding is needed
*
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 EgBasedAddrLib::HwlStereoCheckRightOffsetPadding(
ADDR_TILEINFO* pTileInfo ///< Tiling info
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file egbaddrlib.h
* @brief Contains the EgBasedAddrLib class definition.
-***************************************************************************************************
+****************************************************************************************************
*/
#ifndef __EG_BASED_ADDR_LIB_H__
};
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief This class is the Evergreen based address library
* @note Abstract class
-***************************************************************************************************
+****************************************************************************************************
*/
class EgBasedAddrLib : public AddrLib1
{
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file siaddrlib.cpp
* @brief Contains the implementation for the SiAddrLib class.
-***************************************************************************************************
+****************************************************************************************************
*/
#include "siaddrlib.h"
///////////////////////////////////////////////////////////////////////////////////////////////////
/**
-***************************************************************************************************
-* AddrSIHwlInit
+****************************************************************************************************
+* AddrSiHwlInit
*
* @brief
* Creates an SiAddrLib object.
*
* @return
* Returns an SiAddrLib object pointer.
-***************************************************************************************************
+****************************************************************************************************
*/
AddrLib* AddrSIHwlInit(const AddrClient* pClient)
{
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::SiAddrLib
*
* @brief
* Constructor
*
-***************************************************************************************************
+****************************************************************************************************
*/
SiAddrLib::SiAddrLib(const AddrClient* pClient) :
EgBasedAddrLib(pClient),
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::~SiAddrLib
*
* @brief
* Destructor
-***************************************************************************************************
+****************************************************************************************************
*/
SiAddrLib::~SiAddrLib()
{
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlGetPipes
*
* @brief
* Get number pipes
* @return
* num pipes
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlGetPipes(
const ADDR_TILEINFO* pTileInfo ///< [in] Tile info
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::GetPipePerSurf
* @brief
* get pipe num base on inputing tileinfo->pipeconfig
* @return
* pipe number
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 SiAddrLib::GetPipePerSurf(
AddrPipeCfg pipeConfig ///< [in] pipe config
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::ComputeBankEquation
*
* @brief
*
* @return
* If equation can be computed
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE SiAddrLib::ComputeBankEquation(
UINT_32 log2BytesPP, ///< [in] log2 of bytes per pixel
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::ComputePipeEquation
*
* @brief
*
* @return
* If equation can be computed
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE SiAddrLib::ComputePipeEquation(
UINT_32 log2BytesPP, ///< [in] Log2 of bytes per pixel
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::ComputePipeFromCoord
*
* @brief
* Compute pipe number from coordinates
* @return
* Pipe number
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 SiAddrLib::ComputePipeFromCoord(
UINT_32 x, ///< [in] x coordinate
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::ComputeTileCoordFromPipeAndElemIdx
*
* @brief
* Compute (x,y) of a tile within a macro tile from address
* @return
* Pipe number
-***************************************************************************************************
+****************************************************************************************************
*/
VOID SiAddrLib::ComputeTileCoordFromPipeAndElemIdx(
UINT_32 elemIdx, ///< [in] per pipe element index within a macro tile
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::TileCoordToMaskElementIndex
*
* @brief
* Compute element index from coordinates in tiles
* @return
* Element index
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 SiAddrLib::TileCoordToMaskElementIndex(
UINT_32 tx, ///< [in] x coord, in Tiles
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlComputeTileDataWidthAndHeightLinear
*
* @brief
*
* @note
* MacroWidth and macroHeight are measured in pixels
-***************************************************************************************************
+****************************************************************************************************
*/
VOID SiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
UINT_32* pMacroWidth, ///< [out] macro tile width
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlComputeHtileBytes
*
* @brief
*
* @return
* Htile size in bytes
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 SiAddrLib::HwlComputeHtileBytes(
UINT_32 pitch, ///< [in] pitch
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlComputeXmaskAddrFromCoord
*
* @brief
* Compute address from coordinates for htile/cmask
* @return
* Byte address
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 SiAddrLib::HwlComputeXmaskAddrFromCoord(
UINT_32 pitch, ///< [in] pitch
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlComputeXmaskCoordFromAddr
*
* @brief
*
* @note
* This method is reused by htile, so rename to Xmask
-***************************************************************************************************
+****************************************************************************************************
*/
VOID SiAddrLib::HwlComputeXmaskCoordFromAddr(
UINT_64 addr, ///< [in] address
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlGetPitchAlignmentLinear
* @brief
* Get pitch alignment
* @return
* pitch alignment
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlGetPitchAlignmentLinear(
UINT_32 bpp, ///< [in] bits per pixel
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlGetSizeAdjustmentLinear
*
* @brief
*
* @return
* Logical slice size in bytes
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 SiAddrLib::HwlGetSizeAdjustmentLinear(
AddrTileMode tileMode, ///< [in] tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlPreHandleBaseLvl3xPitch
*
* @brief
*
* @return
* Expected pitch
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlPostHandleBaseLvl3xPitch
*
* @brief
*
* @return
* Expected pitch
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlGetPitchAlignmentMicroTiled
*
* @brief
*
* @return
* pitch alignment
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
AddrTileMode tileMode, ///< [in] tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlGetSizeAdjustmentMicroTiled
*
* @brief
*
* @return
* Logical slice size in bytes
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_64 SiAddrLib::HwlGetSizeAdjustmentMicroTiled(
UINT_32 thickness, ///< [in] thickness
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlConvertChipFamily
*
* @brief
* Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
* @return
* AddrChipFamily
-***************************************************************************************************
+****************************************************************************************************
*/
AddrChipFamily SiAddrLib::HwlConvertChipFamily(
UINT_32 uChipFamily, ///< [in] chip family defined in atiih.h
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlSetupTileInfo
*
* @brief
* Setup default value of tile info for SI
-***************************************************************************************************
+****************************************************************************************************
*/
VOID SiAddrLib::HwlSetupTileInfo(
AddrTileMode tileMode, ///< [in] Tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::DecodeGbRegs
*
* @brief
* @return
* TRUE if all settings are valid
*
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 SiAddrLib::DecodeGbRegs(
const ADDR_REGISTER_VALUE* pRegValue) ///< [in] create input
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlInitGlobalParams
*
* @brief
* @return
* TRUE if all settings are valid
*
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 SiAddrLib::HwlInitGlobalParams(
const ADDR_CREATE_INPUT* pCreateIn) ///< [in] create input
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlConvertTileInfoToHW
* @brief
* Entry of si's ConvertTileInfoToHW
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE SiAddrLib::HwlConvertTileInfoToHW(
const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe
*
* @brief
* coord.
* @return
* Y coord
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe(
UINT_32 pipe, ///< [in] pipe id
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe
*
* @brief
* Compute surface x,y coordinates from bank/pipe info
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe(
AddrTileMode tileMode, ///< [in] tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlPreAdjustBank
*
* @brief
* Adjust bank before calculating address acoording to bank/pipe
* @return
* Adjusted bank
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlPreAdjustBank(
UINT_32 tileX, ///< [in] x coordinate in unit of tile
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlComputeSurfaceInfo
*
* @brief
* Entry of si's ComputeSurfaceInfo
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE SiAddrLib::HwlComputeSurfaceInfo(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlComputeMipLevel
* @brief
* Compute MipLevel info (including level 0)
* @return
* TRUE if HWL's handled
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 SiAddrLib::HwlComputeMipLevel(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn ///< [in/out] Input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlCheckLastMacroTiledLvl
*
* @brief
* Sets pOut->last2DLevel to TRUE if it is
* @note
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlDegradeThickTileMode
*
* @brief
*
* @return
* Suitable tile mode
-***************************************************************************************************
+****************************************************************************************************
*/
AddrTileMode SiAddrLib::HwlDegradeThickTileMode(
AddrTileMode baseTileMode, ///< [in] base tile mode
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlTileInfoEqual
*
* @brief
* Return TRUE if all field are equal
* @note
* Only takes care of current HWL's data
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 SiAddrLib::HwlTileInfoEqual(
const ADDR_TILEINFO* pLeft, ///<[in] Left compare operand
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::GetTileSettings
*
* @brief
* Get tile setting infos by index.
* @return
* Tile setting info.
-***************************************************************************************************
+****************************************************************************************************
*/
const AddrTileConfig* SiAddrLib::GetTileSetting(
UINT_32 index ///< [in] Tile index
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlPostCheckTileIndex
*
* @brief
* tile mode/type/info and change the index if needed
* @return
* Tile index.
-***************************************************************************************************
+****************************************************************************************************
*/
INT_32 SiAddrLib::HwlPostCheckTileIndex(
const ADDR_TILEINFO* pInfo, ///< [in] Tile Info
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlSetupTileCfg
*
* @brief
* Map tile index to tile setting.
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE SiAddrLib::HwlSetupTileCfg(
UINT_32 bpp, ///< [in] Bits per pixel
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::ReadGbTileMode
*
* @brief
* Convert GB_TILE_MODE HW value to ADDR_TILE_CONFIG.
* @return
* NA.
-***************************************************************************************************
+****************************************************************************************************
*/
VOID SiAddrLib::ReadGbTileMode(
UINT_32 regValue, ///< [in] GB_TILE_MODE register
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::InitTileSettingTable
*
* @brief
* Initialize the ADDR_TILE_CONFIG table.
* @return
* TRUE if tile table is correctly initialized
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 SiAddrLib::InitTileSettingTable(
const UINT_32* pCfg, ///< [in] Pointer to table of tile configs
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlGetTileIndex
*
* @brief
* Return the virtual/real index for given mode/type/info
* @return
* ADDR_OK if successful.
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE SiAddrLib::HwlGetTileIndex(
const ADDR_GET_TILEINDEX_INPUT* pIn,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlFmaskPreThunkSurfInfo
*
* @brief
* Some preparation before thunking a ComputeSurfaceInfo call for Fmask
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
VOID SiAddrLib::HwlFmaskPreThunkSurfInfo(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pFmaskIn, ///< [in] Input of fmask info
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlFmaskPostThunkSurfInfo
*
* @brief
* Copy hwl extra field after calling thunked ComputeSurfaceInfo
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
VOID SiAddrLib::HwlFmaskPostThunkSurfInfo(
const ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pSurfOut, ///< [in] Output of surface info
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlComputeFmaskBits
* @brief
* Computes fmask bits
* @return
* Fmask bits
-***************************************************************************************************
+****************************************************************************************************
*/
UINT_32 SiAddrLib::HwlComputeFmaskBits(
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn,
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlOverrideTileMode
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
void SiAddrLib::HwlOverrideTileMode(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut ///< [in/out] input output structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlSelectTileMode
*
* @brief
* @return
* N/A
*
-***************************************************************************************************
+****************************************************************************************************
*/
VOID SiAddrLib::HwlSelectTileMode(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut ///< [in/out] input output structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::HwlGetMaxAlignments
*
* @brief
* Gets maximum alignments
* @return
* ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
*/
ADDR_E_RETURNCODE SiAddrLib::HwlGetMaxAlignments(
ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut ///< [out] output structure
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::InitEquationTable
*
* @brief
*
* @return
* N/A
-***************************************************************************************************
+****************************************************************************************************
*/
VOID SiAddrLib::InitEquationTable()
{
}
/**
-***************************************************************************************************
+****************************************************************************************************
* SiAddrLib::IsEquationSupported
*
* @brief
*
* @return
* TRUE if supported
-***************************************************************************************************
+****************************************************************************************************
*/
BOOL_32 SiAddrLib::IsEquationSupported(
UINT_32 bpp, ///< Bits per pixel
*/
/**
-***************************************************************************************************
+****************************************************************************************************
* @file siaddrlib.h
* @brief Contains the R800AddrLib class definition.
-***************************************************************************************************
+****************************************************************************************************
*/
#ifndef __SI_ADDR_LIB_H__
#include "egbaddrlib.h"
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief Describes the information in tile mode table
-***************************************************************************************************
+****************************************************************************************************
*/
struct AddrTileConfig
{
};
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief SI specific settings structure.
-***************************************************************************************************
+****************************************************************************************************
*/
struct SIChipSettings
{
};
/**
-***************************************************************************************************
+****************************************************************************************************
* @brief This class is the SI specific address library
* function set.
-***************************************************************************************************
+****************************************************************************************************
*/
class SiAddrLib : public EgBasedAddrLib
{
projects / mesa.git / commitdiff