amdgpu/addrlib: Add new flags minimizePadding and maxBaseAlign

[mesa.git] / src / amd / addrlib / addrinterface.cpp

diff --git a/src/amd/addrlib/addrinterface.cpp b/src/amd/addrlib/addrinterface.cpp
index b2120c644bf49c59f1064813ad5d7020dad2d7f7..571a0768490723afb9d7b4eddafbbb42095b3e0c 100644 (file)
--- a/src/amd/addrlib/addrinterface.cpp
+++ b/src/amd/addrlib/addrinterface.cpp
@@ -25,22 +25,24 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  addrinterface.cpp
 * @brief Contains the addrlib interface functions
-***************************************************************************************************
+****************************************************************************************************
 */
 #include "addrinterface.h"
-#include "addrlib.h"
+#include "addrlib1.h"
 
 #include "addrcommon.h"
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+using namespace Addr;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
 //                               Create/Destroy/Config functions
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrCreate
 *
 *   @brief
@@ -48,7 +50,7 @@
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrCreate(
     const ADDR_CREATE_INPUT*    pAddrCreateIn,  ///< [in] infomation for creating address lib object
@@ -56,7 +58,7 @@ ADDR_E_RETURNCODE ADDR_API AddrCreate(
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    returnCode = AddrLib::Create(pAddrCreateIn, pAddrCreateOut);
+    returnCode = Lib::Create(pAddrCreateIn, pAddrCreateOut);
 
     return returnCode;
 }
@@ -64,7 +66,7 @@ ADDR_E_RETURNCODE ADDR_API AddrCreate(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrDestroy
 *
 *   @brief
@@ -72,16 +74,16 @@ ADDR_E_RETURNCODE ADDR_API AddrCreate(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrDestroy(
-    ADDR_HANDLE hLib) ///< [in] address lib handle
+    ADDR_HANDLE hLib) ///< address lib handle
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
     if (hLib)
     {
-        AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+        Lib* pLib = Lib::GetLib(hLib);
         pLib->Destroy();
     }
     else
@@ -94,12 +96,12 @@ ADDR_E_RETURNCODE ADDR_API AddrDestroy(
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
 //                                    Surface functions
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeSurfaceInfo
 *
 *   @brief
@@ -107,14 +109,14 @@ ADDR_E_RETURNCODE ADDR_API AddrDestroy(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
-    ADDR_HANDLE                             hLib, ///< [in] address lib handle
+    ADDR_HANDLE                             hLib, ///< address lib handle
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,  ///< [in] surface information
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut) ///< [out] surface parameters and alignments
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -133,7 +135,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeSurfaceAddrFromCoord
 *
 *   @brief
@@ -141,14 +143,14 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
-    ADDR_HANDLE                                     hLib, ///< [in] address lib handle
+    ADDR_HANDLE                                     hLib, ///< address lib handle
     const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,  ///< [in] surface info and coordinates
     ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT*      pOut) ///< [out] surface address
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -165,7 +167,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeSurfaceCoordFromAddr
 *
 *   @brief
@@ -173,14 +175,14 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
-    ADDR_HANDLE                                     hLib, ///< [in] address lib handle
+    ADDR_HANDLE                                     hLib, ///< address lib handle
     const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,  ///< [in] surface info and address
     ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT*      pOut) ///< [out] coordinates
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -198,12 +200,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
 //                                   HTile functions
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeHtileInfo
 *
 *   @brief
@@ -211,14 +213,14 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
-    ADDR_HANDLE                             hLib, ///< [in] address lib handle
+    ADDR_HANDLE                             hLib, ///< address lib handle
     const ADDR_COMPUTE_HTILE_INFO_INPUT*    pIn,  ///< [in] Htile information
     ADDR_COMPUTE_HTILE_INFO_OUTPUT*         pOut) ///< [out] Htile pitch, height and size in bytes
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -235,7 +237,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeHtileAddrFromCoord
 *
 *   @brief
@@ -243,14 +245,14 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
-    ADDR_HANDLE                                     hLib, ///< [in] address lib handle
+    ADDR_HANDLE                                     hLib, ///< address lib handle
     const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Htile info and coordinates
     ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Htile address
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -267,7 +269,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeHtileCoordFromAddr
 *
 *   @brief
@@ -276,14 +278,14 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
-    ADDR_HANDLE                                     hLib, ///< [in] address lib handle
+    ADDR_HANDLE                                     hLib, ///< address lib handle
     const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT*   pIn,  ///< [in] Htile info and address
     ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Htile coordinates
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -301,12 +303,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
 //                                     C-mask functions
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeCmaskInfo
 *
 *   @brief
@@ -315,14 +317,14 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
-    ADDR_HANDLE                             hLib, ///< [in] address lib handle
+    ADDR_HANDLE                             hLib, ///< address lib handle
     const ADDR_COMPUTE_CMASK_INFO_INPUT*    pIn,  ///< [in] Cmask pitch and height
     ADDR_COMPUTE_CMASK_INFO_OUTPUT*         pOut) ///< [out] Cmask pitch, height and size in bytes
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -339,7 +341,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeCmaskAddrFromCoord
 *
 *   @brief
@@ -347,14 +349,14 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
-    ADDR_HANDLE                                     hLib, ///< [in] address lib handle
+    ADDR_HANDLE                                     hLib, ///< address lib handle
     const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Cmask info and coordinates
     ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Cmask address
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -371,7 +373,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeCmaskCoordFromAddr
 *
 *   @brief
@@ -380,14 +382,14 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
-    ADDR_HANDLE                                     hLib, ///< [in] address lib handle
+    ADDR_HANDLE                                     hLib, ///< address lib handle
     const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT*   pIn,  ///< [in] Cmask info and address
     ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Cmask coordinates
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -405,12 +407,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
 //                                     F-mask functions
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeFmaskInfo
 *
 *   @brief
@@ -418,14 +420,14 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
-    ADDR_HANDLE                             hLib, ///< [in] address lib handle
+    ADDR_HANDLE                             hLib, ///< address lib handle
     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,  ///< [in] Fmask information
     ADDR_COMPUTE_FMASK_INFO_OUTPUT*         pOut) ///< [out] Fmask pitch and height
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -442,7 +444,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeFmaskAddrFromCoord
 *
 *   @brief
@@ -450,14 +452,14 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
-    ADDR_HANDLE                                     hLib, ///< [in] address lib handle
+    ADDR_HANDLE                                     hLib, ///< address lib handle
     const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Fmask info and coordinates
     ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Fmask address
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -474,7 +476,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeFmaskCoordFromAddr
 *
 *   @brief
@@ -482,14 +484,14 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
-    ADDR_HANDLE                                     hLib, ///< [in] address lib handle
+    ADDR_HANDLE                                     hLib, ///< address lib handle
     const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*   pIn,  ///< [in] Fmask info and address
     ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Fmask coordinates
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -507,27 +509,27 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
 //                                     DCC key functions
-///////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   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,   ///< [in] handle of addrlib
+    ADDR_HANDLE                             hLib,   ///< handle of addrlib
     const ADDR_COMPUTE_DCCINFO_INPUT*       pIn,    ///< [in] input
     ADDR_COMPUTE_DCCINFO_OUTPUT*            pOut)   ///< [out] output
 {
     ADDR_E_RETURNCODE returnCode;
 
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -548,19 +550,19 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrGetVersion
 *
 *   @brief
 *       Get AddrLib version number. Client may check this return value against ADDRLIB_VERSION
 *       defined in addrinterface.h to see if there is a mismatch.
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib)
 {
     UINT_32 version = 0;
 
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    Addr::Lib* pLib = Lib::GetLib(hLib);
 
     ADDR_ASSERT(pLib != NULL);
 
@@ -573,18 +575,18 @@ 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)
 {
     BOOL_32 useTileIndex = FALSE;
 
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_ASSERT(pLib != NULL);
 
@@ -597,18 +599,18 @@ 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)
 {
     BOOL_32 useCombinedSwizzle = FALSE;
 
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_ASSERT(pLib != NULL);
 
@@ -621,23 +623,23 @@ 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,     ///< [in] addrlib handle
+    ADDR_HANDLE                                 hLib,     ///< addrlib handle
     const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT*  pIn,      ///< [in] input structure
     ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT*       pOut)     ///< [out] output structure
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -652,14 +654,14 @@ ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrCombineBankPipeSwizzle
 *
 *   @brief
 *       Combine Bank and Pipe swizzle
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
     ADDR_HANDLE                                 hLib,
@@ -668,7 +670,7 @@ ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -683,14 +685,14 @@ ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeSliceSwizzle
 *
 *   @brief
 *       Compute a swizzle for slice from a base swizzle
 *   @return
 *       ADDR_OK if no error
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
     ADDR_HANDLE                                 hLib,
@@ -699,7 +701,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -714,14 +716,14 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeBaseSwizzle
 *
 *   @brief
 *       Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
 *   @return
 *       ADDR_OK if no error
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
     ADDR_HANDLE                             hLib,
@@ -730,7 +732,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -745,7 +747,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ElemFlt32ToDepthPixel
 *
 *   @brief
@@ -754,16 +756,16 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
-    ADDR_HANDLE                         hLib,    ///< [in] addrlib handle
+    ADDR_HANDLE                         hLib,    ///< addrlib handle
     const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,     ///< [in] per-component value
     ELEM_FLT32TODEPTHPIXEL_OUTPUT*      pOut)    ///< [out] final pixel value
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    Lib* pLib = Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -778,7 +780,7 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ElemFlt32ToColorPixel
 *
 *   @brief
@@ -787,16 +789,16 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
-    ADDR_HANDLE                         hLib,    ///< [in] addrlib handle
+    ADDR_HANDLE                         hLib,    ///< addrlib handle
     const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,     ///< [in] format, surface number and swap value
     ELEM_FLT32TOCOLORPIXEL_OUTPUT*      pOut)    ///< [out] final pixel value
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    Lib* pLib = Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -811,7 +813,7 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ElemGetExportNorm
 *
 *   @brief
@@ -820,13 +822,13 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
 *       FP16 can be reported as EXPORT_NORM for rv770 in r600
 *       family
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 ADDR_API ElemGetExportNorm(
-    ADDR_HANDLE                     hLib, ///< [in] addrlib handle
+    ADDR_HANDLE                     hLib, ///< addrlib handle
     const ELEM_GETEXPORTNORM_INPUT* pIn)  ///< [in] input structure
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    Addr::Lib* pLib = Lib::GetLib(hLib);
     BOOL_32 enabled = FALSE;
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -846,7 +848,7 @@ BOOL_32 ADDR_API ElemGetExportNorm(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrConvertTileInfoToHW
 *
 *   @brief
@@ -854,14 +856,14 @@ BOOL_32 ADDR_API ElemGetExportNorm(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
-    ADDR_HANDLE                             hLib, ///< [in] address lib handle
+    ADDR_HANDLE                             hLib, ///< address lib handle
     const ADDR_CONVERT_TILEINFOTOHW_INPUT*  pIn,  ///< [in] tile info with real value
     ADDR_CONVERT_TILEINFOTOHW_OUTPUT*       pOut) ///< [out] tile info with HW register value
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -878,7 +880,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrConvertTileIndex
 *
 *   @brief
@@ -886,14 +888,14 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
-    ADDR_HANDLE                          hLib, ///< [in] address lib handle
+    ADDR_HANDLE                          hLib, ///< address lib handle
     const ADDR_CONVERT_TILEINDEX_INPUT*  pIn,  ///< [in] input - tile index
     ADDR_CONVERT_TILEINDEX_OUTPUT*       pOut) ///< [out] tile mode/type/info
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -910,7 +912,39 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
+*   AddrGetMacroModeIndex
+*
+*   @brief
+*       Get macro mode index based on input parameters
+*
+*   @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
+    const ADDR_GET_MACROMODEINDEX_INPUT* pIn,  ///< [in] input
+    ADDR_GET_MACROMODEINDEX_OUTPUT*      pOut) ///< [out] macro mode index
+{
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
+
+    ADDR_E_RETURNCODE returnCode;
+
+    if (pLib != NULL)
+    {
+        returnCode = pLib->GetMacroModeIndex(pIn, pOut);
+    }
+    else
+    {
+        returnCode = ADDR_ERROR;
+    }
+
+    return returnCode;
+}
+
+/**
+****************************************************************************************************
 *   AddrConvertTileIndex1
 *
 *   @brief
@@ -918,14 +952,14 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
-    ADDR_HANDLE                          hLib, ///< [in] address lib handle
+    ADDR_HANDLE                          hLib, ///< address lib handle
     const ADDR_CONVERT_TILEINDEX1_INPUT* pIn,  ///< [in] input - tile index
     ADDR_CONVERT_TILEINDEX_OUTPUT*       pOut) ///< [out] tile mode/type/info
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -942,7 +976,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrGetTileIndex
 *
 *   @brief
@@ -953,14 +987,14 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
 *
 *   @note
 *       Only meaningful for SI (and above)
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
     ADDR_HANDLE                     hLib,
     const ADDR_GET_TILEINDEX_INPUT* pIn,
     ADDR_GET_TILEINDEX_OUTPUT*      pOut)
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -977,13 +1011,13 @@ ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputePrtInfo
 *
 *   @brief
 *       Interface function for ComputePrtInfo
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
     ADDR_HANDLE                 hLib,
@@ -992,7 +1026,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -1007,7 +1041,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrGetMaxAlignments
 *
 *   @brief
@@ -1015,13 +1049,13 @@ ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
-    ADDR_HANDLE                     hLib, ///< [in] address lib handle
+    ADDR_HANDLE                     hLib, ///< address lib handle
     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut) ///< [out] output structure
 {
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    Addr::Lib* pLib = Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;