amdgpu/addrlib: Use namespaces

Signed-off-by: Nicolai Hähnle <[email protected]>

16 files changed, 969 insertions, 892 deletions

diff --git a/src/amd/addrlib/addrinterface.cpp b/src/amd/addrlib/addrinterface.cpp
index c3eb598e34a..efb6ff50841 100644
--- a/src/amd/addrlib/addrinterface.cpp
+++ b/src/amd/addrlib/addrinterface.cpp
@@ -35,6 +35,8 @@
 
 #include "addrcommon.h"
 
+using namespace Addr;
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 //                               Create/Destroy/Config functions
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -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;
 }
@@ -81,7 +83,7 @@ ADDR_E_RETURNCODE ADDR_API AddrDestroy(
 
     if (hLib)
     {
-        AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+        Lib* pLib = Lib::GetLib(hLib);
         pLib->Destroy();
     }
     else
@@ -114,7 +116,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,  ///< [in] surface information
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut) ///< [out] surface parameters and alignments
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -148,7 +150,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
     const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,  ///< [in] surface info and coordinates
     ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT*      pOut) ///< [out] surface address
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -180,7 +182,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
     const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,  ///< [in] surface info and address
     ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT*      pOut) ///< [out] coordinates
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -218,7 +220,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
     const ADDR_COMPUTE_HTILE_INFO_INPUT*    pIn,  ///< [in] Htile information
     ADDR_COMPUTE_HTILE_INFO_OUTPUT*         pOut) ///< [out] Htile pitch, height and size in bytes
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -250,7 +252,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
     const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Htile info and coordinates
     ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Htile address
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -283,7 +285,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
     const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT*   pIn,  ///< [in] Htile info and address
     ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Htile coordinates
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -322,7 +324,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
     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
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -354,7 +356,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
     const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Cmask info and coordinates
     ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Cmask address
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -387,7 +389,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
     const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT*   pIn,  ///< [in] Cmask info and address
     ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Cmask coordinates
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -425,7 +427,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,  ///< [in] Fmask information
     ADDR_COMPUTE_FMASK_INFO_OUTPUT*         pOut) ///< [out] Fmask pitch and height
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -457,7 +459,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
     const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Fmask info and coordinates
     ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Fmask address
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -489,7 +491,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
     const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*   pIn,  ///< [in] Fmask info and address
     ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Fmask coordinates
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -527,7 +529,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
 {
     ADDR_E_RETURNCODE returnCode;
 
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -560,7 +562,7 @@ 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);
 
@@ -584,7 +586,7 @@ BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib)
 {
     BOOL_32 useTileIndex = FALSE;
 
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_ASSERT(pLib != NULL);
 
@@ -608,7 +610,7 @@ BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib)
 {
     BOOL_32 useCombinedSwizzle = FALSE;
 
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_ASSERT(pLib != NULL);
 
@@ -637,7 +639,7 @@ ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -668,7 +670,7 @@ ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -699,7 +701,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -730,7 +732,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -763,7 +765,7 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    Lib* pLib = Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -796,7 +798,7 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    AddrLib* pLib = AddrLib::GetAddrLib(hLib);
+    Lib* pLib = Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -826,7 +828,7 @@ BOOL_32 ADDR_API ElemGetExportNorm(
     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;
@@ -861,7 +863,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
     const ADDR_CONVERT_TILEINFOTOHW_INPUT*  pIn,  ///< [in] tile info with real value
     ADDR_CONVERT_TILEINFOTOHW_OUTPUT*       pOut) ///< [out] tile info with HW register value
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -893,7 +895,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
     const ADDR_CONVERT_TILEINDEX_INPUT*  pIn,  ///< [in] input - tile index
     ADDR_CONVERT_TILEINDEX_OUTPUT*       pOut) ///< [out] tile mode/type/info
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -925,7 +927,7 @@ ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
     const ADDR_GET_MACROMODEINDEX_INPUT* pIn,  ///< [in] input
     ADDR_GET_MACROMODEINDEX_OUTPUT*      pOut) ///< [out] macro mode index
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode;
 
@@ -957,7 +959,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
     const ADDR_CONVERT_TILEINDEX1_INPUT* pIn,  ///< [in] input - tile index
     ADDR_CONVERT_TILEINDEX_OUTPUT*       pOut) ///< [out] tile mode/type/info
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -992,7 +994,7 @@ ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
     const ADDR_GET_TILEINDEX_INPUT* pIn,
     ADDR_GET_TILEINDEX_OUTPUT*      pOut)
 {
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
@@ -1024,7 +1026,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
-    AddrLib1* pLib = AddrLib1::GetAddrLib1(hLib);
+    V1::Lib* pLib = V1::Lib::GetLib(hLib);
 
     if (pLib != NULL)
     {
@@ -1053,7 +1055,7 @@ ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
     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;
 
diff --git a/src/amd/addrlib/core/addrcommon.h b/src/amd/addrlib/core/addrcommon.h
index 5c17f80caf7..9b0cc6dafa9 100644
--- a/src/amd/addrlib/core/addrcommon.h
+++ b/src/amd/addrlib/core/addrcommon.h
@@ -47,99 +47,6 @@
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// Common constants
-///////////////////////////////////////////////////////////////////////////////////////////////////
-static const UINT_32 MicroTileWidth      = 8;       ///< Micro tile width, for 1D and 2D tiling
-static const UINT_32 MicroTileHeight     = 8;       ///< Micro tile height, for 1D and 2D tiling
-static const UINT_32 ThickTileThickness  = 4;       ///< Micro tile thickness, for THICK modes
-static const UINT_32 XThickTileThickness = 8;       ///< Extra thick tiling thickness
-static const UINT_32 PowerSaveTileBytes  = 64;      ///< Nuber of bytes per tile for power save 64
-static const UINT_32 CmaskCacheBits      = 1024;    ///< Number of bits for CMASK cache
-static const UINT_32 CmaskElemBits       = 4;       ///< Number of bits for CMASK element
-static const UINT_32 HtileCacheBits      = 16384;   ///< Number of bits for HTILE cache 512*32
-
-static const UINT_32 MicroTilePixels     = MicroTileWidth * MicroTileHeight;
-
-static const INT_32 TileIndexInvalid        = TILEINDEX_INVALID;
-static const INT_32 TileIndexLinearGeneral  = TILEINDEX_LINEAR_GENERAL;
-static const INT_32 TileIndexNoMacroIndex   = -3;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Common macros
-///////////////////////////////////////////////////////////////////////////////////////////////////
-#define BITS_PER_BYTE 8
-#define BITS_TO_BYTES(x) ( ((x) + (BITS_PER_BYTE-1)) / BITS_PER_BYTE )
-#define BYTES_TO_BITS(x) ( (x) * BITS_PER_BYTE )
-
-/// Helper macros to select a single bit from an int (undefined later in section)
-#define _BIT(v,b)      (((v) >> (b) ) & 1)
-
-/**
-****************************************************************************************************
-* @brief Enums to identify AddrLib type
-****************************************************************************************************
-*/
-enum AddrLibClass
-{
-    BASE_ADDRLIB = 0x0,
-    R600_ADDRLIB = 0x6,
-    R800_ADDRLIB = 0x8,
-    SI_ADDRLIB   = 0xa,
-    CI_ADDRLIB   = 0xb,
-};
-
-/**
-****************************************************************************************************
-* AddrChipFamily
-*
-*   @brief
-*       Neutral enums that specifies chip family.
-*
-****************************************************************************************************
-*/
-enum AddrChipFamily
-{
-    ADDR_CHIP_FAMILY_IVLD,    ///< Invalid family
-    ADDR_CHIP_FAMILY_R6XX,
-    ADDR_CHIP_FAMILY_R7XX,
-    ADDR_CHIP_FAMILY_R8XX,
-    ADDR_CHIP_FAMILY_NI,
-    ADDR_CHIP_FAMILY_SI,
-    ADDR_CHIP_FAMILY_CI,
-    ADDR_CHIP_FAMILY_VI,
-};
-
-/**
-****************************************************************************************************
-* AddrConfigFlags
-*
-*   @brief
-*       This structure is used to set configuration flags.
-****************************************************************************************************
-*/
-union AddrConfigFlags
-{
-    struct
-    {
-        /// These flags are set up internally thru AddrLib::Create() based on ADDR_CREATE_FLAGS
-        UINT_32 optimalBankSwap        : 1;    ///< New bank tiling for RV770 only
-        UINT_32 noCubeMipSlicesPad     : 1;    ///< Disables faces padding for cubemap mipmaps
-        UINT_32 fillSizeFields         : 1;    ///< If clients fill size fields in all input and
-                                               ///  output structure
-        UINT_32 ignoreTileInfo         : 1;    ///< Don't use tile info structure
-        UINT_32 useTileIndex           : 1;    ///< Make tileIndex field in input valid
-        UINT_32 useCombinedSwizzle     : 1;    ///< Use combined swizzle
-        UINT_32 checkLast2DLevel       : 1;    ///< Check the last 2D mip sub level
-        UINT_32 useHtileSliceAlign     : 1;    ///< Do htile single slice alignment
-        UINT_32 allowLargeThickTile    : 1;    ///< Allow 64*thickness*bytesPerPixel > rowSize
-        UINT_32 disableLinearOpt       : 1;    ///< Disallow tile modes to be optimized to linear
-        UINT_32 reserved               : 22;   ///< Reserved bits for future use
-    };
-
-    UINT_32 value;
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
 // Platform specific debug break defines
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 #if DEBUG
@@ -186,7 +93,7 @@ union AddrConfigFlags
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 #if DEBUG
 
-#define ADDR_PRNT(a)    AddrObject::DebugPrint a
+#define ADDR_PRNT(a)    Object::DebugPrint a
 
 /// @brief Macro for reporting informational messages
 /// @ingroup util
@@ -256,6 +163,106 @@ union AddrConfigFlags
 #endif // DEBUG
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+namespace Addr
+{
+
+namespace V1
+{
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Common constants
+///////////////////////////////////////////////////////////////////////////////////////////////////
+static const UINT_32 MicroTileWidth      = 8;       ///< Micro tile width, for 1D and 2D tiling
+static const UINT_32 MicroTileHeight     = 8;       ///< Micro tile height, for 1D and 2D tiling
+static const UINT_32 ThickTileThickness  = 4;       ///< Micro tile thickness, for THICK modes
+static const UINT_32 XThickTileThickness = 8;       ///< Extra thick tiling thickness
+static const UINT_32 PowerSaveTileBytes  = 64;      ///< Nuber of bytes per tile for power save 64
+static const UINT_32 CmaskCacheBits      = 1024;    ///< Number of bits for CMASK cache
+static const UINT_32 CmaskElemBits       = 4;       ///< Number of bits for CMASK element
+static const UINT_32 HtileCacheBits      = 16384;   ///< Number of bits for HTILE cache 512*32
+
+static const UINT_32 MicroTilePixels     = MicroTileWidth * MicroTileHeight;
+
+static const INT_32 TileIndexInvalid        = TILEINDEX_INVALID;
+static const INT_32 TileIndexLinearGeneral  = TILEINDEX_LINEAR_GENERAL;
+static const INT_32 TileIndexNoMacroIndex   = -3;
+
+} // V1
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Common macros
+///////////////////////////////////////////////////////////////////////////////////////////////////
+#define BITS_PER_BYTE 8
+#define BITS_TO_BYTES(x) ( ((x) + (BITS_PER_BYTE-1)) / BITS_PER_BYTE )
+#define BYTES_TO_BITS(x) ( (x) * BITS_PER_BYTE )
+
+/// Helper macros to select a single bit from an int (undefined later in section)
+#define _BIT(v,b)      (((v) >> (b) ) & 1)
+
+/**
+****************************************************************************************************
+* @brief Enums to identify AddrLib type
+****************************************************************************************************
+*/
+enum LibClass
+{
+    BASE_ADDRLIB = 0x0,
+    R600_ADDRLIB = 0x6,
+    R800_ADDRLIB = 0x8,
+    SI_ADDRLIB   = 0xa,
+    CI_ADDRLIB   = 0xb,
+};
+
+/**
+****************************************************************************************************
+* ChipFamily
+*
+*   @brief
+*       Neutral enums that specifies chip family.
+*
+****************************************************************************************************
+*/
+enum ChipFamily
+{
+    ADDR_CHIP_FAMILY_IVLD,    ///< Invalid family
+    ADDR_CHIP_FAMILY_R6XX,
+    ADDR_CHIP_FAMILY_R7XX,
+    ADDR_CHIP_FAMILY_R8XX,
+    ADDR_CHIP_FAMILY_NI,
+    ADDR_CHIP_FAMILY_SI,
+    ADDR_CHIP_FAMILY_CI,
+    ADDR_CHIP_FAMILY_VI,
+};
+
+/**
+****************************************************************************************************
+* ConfigFlags
+*
+*   @brief
+*       This structure is used to set configuration flags.
+****************************************************************************************************
+*/
+union ConfigFlags
+{
+    struct
+    {
+        /// These flags are set up internally thru AddrLib::Create() based on ADDR_CREATE_FLAGS
+        UINT_32 optimalBankSwap        : 1;    ///< New bank tiling for RV770 only
+        UINT_32 noCubeMipSlicesPad     : 1;    ///< Disables faces padding for cubemap mipmaps
+        UINT_32 fillSizeFields         : 1;    ///< If clients fill size fields in all input and
+                                               ///  output structure
+        UINT_32 ignoreTileInfo         : 1;    ///< Don't use tile info structure
+        UINT_32 useTileIndex           : 1;    ///< Make tileIndex field in input valid
+        UINT_32 useCombinedSwizzle     : 1;    ///< Use combined swizzle
+        UINT_32 checkLast2DLevel       : 1;    ///< Check the last 2D mip sub level
+        UINT_32 useHtileSliceAlign     : 1;    ///< Do htile single slice alignment
+        UINT_32 allowLargeThickTile    : 1;    ///< Allow 64*thickness*bytesPerPixel > rowSize
+        UINT_32 disableLinearOpt       : 1;    ///< Disallow tile modes to be optimized to linear
+        UINT_32 reserved               : 22;   ///< Reserved bits for future use
+    };
+
+    UINT_32 value;
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Misc helper functions
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -596,5 +603,7 @@ static inline ADDR_CHANNEL_SETTING InitChannel(
     return t;
 }
 
+} // Addr
+
 #endif // __ADDR_COMMON_H__
 
diff --git a/src/amd/addrlib/core/addrelemlib.cpp b/src/amd/addrlib/core/addrelemlib.cpp
index 2ec518f6687..b894f49cca6 100644
--- a/src/amd/addrlib/core/addrelemlib.cpp
+++ b/src/amd/addrlib/core/addrelemlib.cpp
@@ -34,10 +34,12 @@
 #include "addrelemlib.h"
 #include "addrlib.h"
 
+namespace Addr
+{
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::AddrElemLib
+*   ElemLib::ElemLib
 *
 *   @brief
 *       constructor
@@ -46,12 +48,13 @@
 *       N/A
 ****************************************************************************************************
 */
-AddrElemLib::AddrElemLib(
-    AddrLib* const pAddrLib) :  ///< [in] Parent addrlib instance pointer
-    AddrObject(pAddrLib->GetClient()),
+ElemLib::ElemLib(
+    Lib* pAddrLib)  ///< [in] Parent addrlib instance pointer
+    :
+    Object(pAddrLib->GetClient()),
     m_pAddrLib(pAddrLib)
 {
-    switch (m_pAddrLib->GetAddrChipFamily())
+    switch (m_pAddrLib->GetChipFamily())
     {
         case ADDR_CHIP_FAMILY_R6XX:
             m_depthPlanarType = ADDR_DEPTH_PLANAR_R600;
@@ -76,7 +79,7 @@ AddrElemLib::AddrElemLib(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::~AddrElemLib
+*   ElemLib::~ElemLib
 *
 *   @brief
 *       destructor
@@ -85,13 +88,13 @@ AddrElemLib::AddrElemLib(
 *       N/A
 ****************************************************************************************************
 */
-AddrElemLib::~AddrElemLib()
+ElemLib::~ElemLib()
 {
 }
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::Create
+*   ElemLib::Create
 *
 *   @brief
 *       Creates and initializes AddrLib object.
@@ -100,21 +103,21 @@ AddrElemLib::~AddrElemLib()
 *       Returns point to ADDR_CREATEINFO if successful.
 ****************************************************************************************************
 */
-AddrElemLib* AddrElemLib::Create(
-    const AddrLib* const        pAddrLib)   ///< [in] Pointer of parent AddrLib instance
+ElemLib* ElemLib::Create(
+    const Lib* pAddrLib)   ///< [in] Pointer of parent AddrLib instance
 {
-    AddrElemLib* pElemLib = NULL;
+    ElemLib* pElemLib = NULL;
 
     if (pAddrLib)
     {
-        pElemLib = new(pAddrLib->GetClient()) AddrElemLib(const_cast<AddrLib* const>(pAddrLib));
+        pElemLib = new(pAddrLib->GetClient()) ElemLib(const_cast<Lib* const>(pAddrLib));
     }
 
     return pElemLib;
 }
 
 /**************************************************************************************************
-*   AddrElemLib::Flt32sToInt32s
+*   ElemLib::Flt32sToInt32s
 *
 *   @brief
 *       Convert a ADDR_FLT_32 value to Int32 value
@@ -123,10 +126,10 @@ AddrElemLib* AddrElemLib::Create(
 *       N/A
 ****************************************************************************************************
 */
-VOID AddrElemLib::Flt32sToInt32s(
+VOID ElemLib::Flt32sToInt32s(
     ADDR_FLT_32     value,      ///< [in] ADDR_FLT_32 value
     UINT_32         bits,       ///< [in] nubmer of bits in value
-    AddrNumberType  numberType, ///< [in] the type of number
+    NumberType      numberType, ///< [in] the type of number
     UINT_32*        pResult)    ///< [out] Int32 value
 {
     UINT_8 round = 128;    //ADDR_ROUND_BY_HALF
@@ -304,7 +307,7 @@ VOID AddrElemLib::Flt32sToInt32s(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::Int32sToPixel
+*   ElemLib::Int32sToPixel
 *
 *   @brief
 *       Pack 32-bit integer values into an uncompressed pixel,
@@ -320,12 +323,12 @@ VOID AddrElemLib::Flt32sToInt32s(
 *       if called on compressed pixel.
 ****************************************************************************************************
 */
-VOID AddrElemLib::Int32sToPixel(
+VOID ElemLib::Int32sToPixel(
     UINT_32              numComps,      ///< [in] number of components
     UINT_32*             pComps,        ///< [in] compnents
     UINT_32*             pCompBits,     ///< [in] total bits in each component
     UINT_32*             pCompStart,    ///< [in] the first bit position of each component
-    ADDR_COMPONENT_FLAGS properties,    ///< [in] properties about byteAligned, exportNorm
+    ComponentFlags       properties,    ///< [in] properties about byteAligned, exportNorm
     UINT_32              resultBits,    ///< [in] result bits: total bpp after decompression
     UINT_8*              pPixel)        ///< [out] a depth/stencil pixel value
 {
@@ -386,7 +389,7 @@ VOID AddrElemLib::Int32sToPixel(
 *       N/A
 ****************************************************************************************************
 */
-VOID AddrElemLib::Flt32ToDepthPixel(
+VOID ElemLib::Flt32ToDepthPixel(
     AddrDepthFormat     format,     ///< [in] Depth format
     const ADDR_FLT_32   comps[2],   ///< [in] two components of depth
     UINT_8*             pPixel      ///< [out] depth pixel value
@@ -394,10 +397,10 @@ VOID AddrElemLib::Flt32ToDepthPixel(
 {
     UINT_32 i;
     UINT_32 values[2];
-    ADDR_COMPONENT_FLAGS properties;    // byteAligned, exportNorm
-    UINT_32 resultBits = 0;             // result bits: total bits per pixel after decompression
+    ComponentFlags properties;  // byteAligned, exportNorm
+    UINT_32 resultBits = 0;     // result bits: total bits per pixel after decompression
 
-    ADDR_PIXEL_FORMATINFO fmt;
+    PixelFormatInfo fmt;
 
     // get type for each component
     PixGetDepthCompInfo(format, &fmt);
@@ -455,7 +458,7 @@ VOID AddrElemLib::Flt32ToDepthPixel(
 *       N/A
 ****************************************************************************************************
 */
-VOID AddrElemLib::Flt32ToColorPixel(
+VOID ElemLib::Flt32ToColorPixel(
     AddrColorFormat     format,     ///< [in] Color format
     AddrSurfaceNumber   surfNum,    ///< [in] Surface number
     AddrSurfaceSwap     surfSwap,   ///< [in] Surface swap
@@ -463,14 +466,14 @@ VOID AddrElemLib::Flt32ToColorPixel(
     UINT_8*             pPixel      ///< [out] a red/green/blue/alpha pixel value
     ) const
 {
-    ADDR_PIXEL_FORMATINFO pixelInfo;
+    PixelFormatInfo pixelInfo;
 
     UINT_32 i;
     UINT_32 values[4];
-    ADDR_COMPONENT_FLAGS properties;    // byteAligned, exportNorm
-    UINT_32 resultBits = 0;             // result bits: total bits per pixel after decompression
+    ComponentFlags properties;    // byteAligned, exportNorm
+    UINT_32 resultBits = 0;       // result bits: total bits per pixel after decompression
 
-    memset(&pixelInfo, 0, sizeof(ADDR_PIXEL_FORMATINFO));
+    memset(&pixelInfo, 0, sizeof(PixelFormatInfo));
 
     PixGetColorCompInfo(format, surfNum, surfSwap, &pixelInfo);
 
@@ -532,7 +535,7 @@ VOID AddrElemLib::Flt32ToColorPixel(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::GetCompType
+*   ElemLib::GetCompType
 *
 *   @brief
 *       Fill per component info
@@ -542,10 +545,10 @@ VOID AddrElemLib::Flt32ToColorPixel(
 *
 ****************************************************************************************************
 */
-VOID AddrElemLib::GetCompType(
-    AddrColorFormat         format,     ///< [in] surface format
-    AddrSurfaceNumber       numType,  ///< [in] number type
-    ADDR_PIXEL_FORMATINFO*  pInfo)       ///< [in][out] per component info out
+VOID ElemLib::GetCompType(
+    AddrColorFormat   format,     ///< [in] surface format
+    AddrSurfaceNumber numType,  ///< [in] number type
+    PixelFormatInfo*  pInfo)       ///< [in][out] per component info out
 {
     BOOL_32 handled = FALSE;
 
@@ -705,7 +708,7 @@ VOID AddrElemLib::GetCompType(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::GetCompSwap
+*   ElemLib::GetCompSwap
 *
 *   @brief
 *       Get components swapped for color surface
@@ -715,9 +718,9 @@ VOID AddrElemLib::GetCompType(
 *
 ****************************************************************************************************
 */
-VOID AddrElemLib::GetCompSwap(
-    AddrSurfaceSwap         swap,   ///< [in] swap mode
-    ADDR_PIXEL_FORMATINFO*  pInfo)  ///< [in/out] output per component info
+VOID ElemLib::GetCompSwap(
+    AddrSurfaceSwap  swap,   ///< [in] swap mode
+    PixelFormatInfo* pInfo)  ///< [in/out] output per component info
 {
     switch (pInfo->comps)
     {
@@ -795,7 +798,7 @@ VOID AddrElemLib::GetCompSwap(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::GetCompSwap
+*   ElemLib::GetCompSwap
 *
 *   @brief
 *       Get components swapped for color surface
@@ -805,10 +808,10 @@ VOID AddrElemLib::GetCompSwap(
 *
 ****************************************************************************************************
 */
-VOID AddrElemLib::SwapComps(
-    UINT_32                 c0,     ///< [in] component index 0
-    UINT_32                 c1,     ///< [in] component index 1
-    ADDR_PIXEL_FORMATINFO*  pInfo)  ///< [in/out] output per component info
+VOID ElemLib::SwapComps(
+    UINT_32          c0,     ///< [in] component index 0
+    UINT_32          c1,     ///< [in] component index 1
+    PixelFormatInfo* pInfo)  ///< [in/out] output per component info
 {
     UINT_32 start;
     UINT_32 bits;
@@ -824,7 +827,7 @@ VOID AddrElemLib::SwapComps(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::PixGetColorCompInfo
+*   ElemLib::PixGetColorCompInfo
 *
 *   @brief
 *       Get per component info for color surface
@@ -834,11 +837,11 @@ VOID AddrElemLib::SwapComps(
 *
 ****************************************************************************************************
 */
-VOID AddrElemLib::PixGetColorCompInfo(
-    AddrColorFormat         format, ///< [in] surface format, read from register
-    AddrSurfaceNumber       number, ///< [in] pixel number type
-    AddrSurfaceSwap         swap,   ///< [in] component swap mode
-    ADDR_PIXEL_FORMATINFO*  pInfo   ///< [out] output per component info
+VOID ElemLib::PixGetColorCompInfo(
+    AddrColorFormat   format, ///< [in] surface format, read from register
+    AddrSurfaceNumber number, ///< [in] pixel number type
+    AddrSurfaceSwap   swap,   ///< [in] component swap mode
+    PixelFormatInfo*  pInfo   ///< [out] output per component info
     ) const
 {
     // 1. Get componet bits
@@ -961,7 +964,7 @@ VOID AddrElemLib::PixGetColorCompInfo(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::PixGetDepthCompInfo
+*   ElemLib::PixGetDepthCompInfo
 *
 *   @brief
 *       Get per component info for depth surface
@@ -971,9 +974,9 @@ VOID AddrElemLib::PixGetColorCompInfo(
 *
 ****************************************************************************************************
 */
-VOID AddrElemLib::PixGetDepthCompInfo(
-    AddrDepthFormat         format,     ///< [in] surface format, read from register
-    ADDR_PIXEL_FORMATINFO*  pInfo       ///< [out] output per component bits and type
+VOID ElemLib::PixGetDepthCompInfo(
+    AddrDepthFormat  format,     ///< [in] surface format, read from register
+    PixelFormatInfo* pInfo       ///< [out] output per component bits and type
     ) const
 {
     if (m_depthPlanarType == ADDR_DEPTH_PLANAR_R800)
@@ -1059,7 +1062,7 @@ VOID AddrElemLib::PixGetDepthCompInfo(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::PixGetExportNorm
+*   ElemLib::PixGetExportNorm
 *
 *   @brief
 *       Check if fp16 export norm can be enabled.
@@ -1069,7 +1072,7 @@ VOID AddrElemLib::PixGetDepthCompInfo(
 *
 ****************************************************************************************************
 */
-BOOL_32 AddrElemLib::PixGetExportNorm(
+BOOL_32 ElemLib::PixGetExportNorm(
     AddrColorFormat     colorFmt,       ///< [in] surface format, read from register
     AddrSurfaceNumber   numberFmt,      ///< [in] pixel number type
     AddrSurfaceSwap     swap            ///< [in] components swap type
@@ -1077,7 +1080,7 @@ BOOL_32 AddrElemLib::PixGetExportNorm(
 {
     BOOL_32 enabled = TRUE;
 
-    ADDR_PIXEL_FORMATINFO formatInfo;
+    PixelFormatInfo formatInfo;
 
     PixGetColorCompInfo(colorFmt, numberFmt, swap, &formatInfo);
 
@@ -1111,7 +1114,7 @@ BOOL_32 AddrElemLib::PixGetExportNorm(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::AdjustSurfaceInfo
+*   ElemLib::AdjustSurfaceInfo
 *
 *   @brief
 *       Adjust bpp/base pitch/width/height according to elemMode and expandX/Y
@@ -1120,8 +1123,8 @@ BOOL_32 AddrElemLib::PixGetExportNorm(
 *       N/A
 ****************************************************************************************************
 */
-VOID AddrElemLib::AdjustSurfaceInfo(
-    AddrElemMode    elemMode,       ///< [in] element mode
+VOID ElemLib::AdjustSurfaceInfo(
+    ElemMode        elemMode,       ///< [in] element mode
     UINT_32         expandX,        ///< [in] decompression expansion factor in X
     UINT_32         expandY,        ///< [in] decompression expansion factor in Y
     UINT_32*        pBpp,           ///< [in/out] bpp
@@ -1199,7 +1202,7 @@ VOID AddrElemLib::AdjustSurfaceInfo(
             else
             {
                 // Evergreen family workaround
-                if (bBCnFormat && (m_pAddrLib->GetAddrChipFamily() == ADDR_CHIP_FAMILY_R8XX))
+                if (bBCnFormat && (m_pAddrLib->GetChipFamily() == ADDR_CHIP_FAMILY_R8XX))
                 {
                     // For BCn we now pad it to POW2 at the beginning so it is safe to
                     // divide by 4 directly
@@ -1236,7 +1239,7 @@ VOID AddrElemLib::AdjustSurfaceInfo(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::RestoreSurfaceInfo
+*   ElemLib::RestoreSurfaceInfo
 *
 *   @brief
 *       Reverse operation of AdjustSurfaceInfo
@@ -1245,8 +1248,8 @@ VOID AddrElemLib::AdjustSurfaceInfo(
 *       N/A
 ****************************************************************************************************
 */
-VOID AddrElemLib::RestoreSurfaceInfo(
-    AddrElemMode    elemMode,       ///< [in] element mode
+VOID ElemLib::RestoreSurfaceInfo(
+    ElemMode        elemMode,       ///< [in] element mode
     UINT_32         expandX,        ///< [in] decompression expansion factor in X
     UINT_32         expandY,        ///< [out] decompression expansion factor in Y
     UINT_32*        pBpp,           ///< [in/out] bpp
@@ -1328,7 +1331,7 @@ VOID AddrElemLib::RestoreSurfaceInfo(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::GetBitsPerPixel
+*   ElemLib::GetBitsPerPixel
 *
 *   @brief
 *       Compute the total bits per element according to a format
@@ -1339,9 +1342,9 @@ VOID AddrElemLib::RestoreSurfaceInfo(
 *       Bits per pixel
 ****************************************************************************************************
 */
-UINT_32 AddrElemLib::GetBitsPerPixel(
+UINT_32 ElemLib::GetBitsPerPixel(
     AddrFormat          format,         ///< [in] surface format code
-    AddrElemMode*       pElemMode,      ///< [out] element mode
+    ElemMode*           pElemMode,      ///< [out] element mode
     UINT_32*            pExpandX,       ///< [out] decompression expansion factor in X
     UINT_32*            pExpandY,       ///< [out] decompression expansion factor in Y
     UINT_32*            pUnusedBits)    ///< [out] bits unused
@@ -1350,7 +1353,7 @@ UINT_32 AddrElemLib::GetBitsPerPixel(
     UINT_32 expandX = 1;
     UINT_32 expandY = 1;
     UINT_32 bitUnused = 0;
-    AddrElemMode elemMode = ADDR_UNCOMPRESSED; // default value
+    ElemMode elemMode = ADDR_UNCOMPRESSED; // default value
 
     switch (format)
     {
@@ -1497,7 +1500,7 @@ UINT_32 AddrElemLib::GetBitsPerPixel(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::GetCompBits
+*   ElemLib::GetCompBits
 *
 *   @brief
 *       Set each component's bit size and bit start. And set element mode and number type
@@ -1506,13 +1509,13 @@ UINT_32 AddrElemLib::GetBitsPerPixel(
 *       N/A
 ****************************************************************************************************
 */
-VOID AddrElemLib::GetCompBits(
-    UINT_32 c0,                     ///< [in] bits of component 0
-    UINT_32 c1,                     ///< [in] bits of component 1
-    UINT_32 c2,                     ///< [in] bits of component 2
-    UINT_32 c3,                     ///< [in] bits of component 3
-    ADDR_PIXEL_FORMATINFO* pInfo,   ///< [out] per component info out
-    AddrElemMode elemMode)          ///< [in] element mode
+VOID ElemLib::GetCompBits(
+    UINT_32          c0,        ///< [in] bits of component 0
+    UINT_32          c1,        ///< [in] bits of component 1
+    UINT_32          c2,        ///< [in] bits of component 2
+    UINT_32          c3,        ///< [in] bits of component 3
+    PixelFormatInfo* pInfo,     ///< [out] per component info out
+    ElemMode         elemMode)  ///< [in] element mode
 {
     pInfo->comps = 0;
 
@@ -1544,7 +1547,7 @@ VOID AddrElemLib::GetCompBits(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::GetCompBits
+*   ElemLib::GetCompBits
 *
 *   @brief
 *       Set the clear color (or clear depth/stencil) for a surface
@@ -1557,7 +1560,7 @@ VOID AddrElemLib::GetCompBits(
 *       N/A
 ****************************************************************************************************
 */
-VOID AddrElemLib::SetClearComps(
+VOID ElemLib::SetClearComps(
     ADDR_FLT_32 comps[4],   ///< [in/out] components
     BOOL_32 clearColor,     ///< [in] TRUE if clear color is set (CLEAR_COLOR)
     BOOL_32 float32)        ///< [in] TRUE if float32 component (BLEND_FLOAT32)
@@ -1600,7 +1603,7 @@ VOID AddrElemLib::SetClearComps(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::IsBlockCompressed
+*   ElemLib::IsBlockCompressed
 *
 *   @brief
 *       TRUE if this is block compressed format
@@ -1611,7 +1614,7 @@ VOID AddrElemLib::SetClearComps(
 *       BOOL_32
 ****************************************************************************************************
 */
-BOOL_32 AddrElemLib::IsBlockCompressed(
+BOOL_32 ElemLib::IsBlockCompressed(
     AddrFormat format)  ///< [in] Format
 {
     return format >= ADDR_FMT_BC1 && format <= ADDR_FMT_BC7;
@@ -1620,7 +1623,7 @@ BOOL_32 AddrElemLib::IsBlockCompressed(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::IsCompressed
+*   ElemLib::IsCompressed
 *
 *   @brief
 *       TRUE if this is block compressed format or 1 bit format
@@ -1631,7 +1634,7 @@ BOOL_32 AddrElemLib::IsBlockCompressed(
 *       BOOL_32
 ****************************************************************************************************
 */
-BOOL_32 AddrElemLib::IsCompressed(
+BOOL_32 ElemLib::IsCompressed(
     AddrFormat format)  ///< [in] Format
 {
     return IsBlockCompressed(format) || format == ADDR_FMT_BC1 || format == ADDR_FMT_BC7;
@@ -1639,7 +1642,7 @@ BOOL_32 AddrElemLib::IsCompressed(
 
 /**
 ****************************************************************************************************
-*   AddrElemLib::IsExpand3x
+*   ElemLib::IsExpand3x
 *
 *   @brief
 *       TRUE if this is 3x expand format
@@ -1650,7 +1653,7 @@ BOOL_32 AddrElemLib::IsCompressed(
 *       BOOL_32
 ****************************************************************************************************
 */
-BOOL_32 AddrElemLib::IsExpand3x(
+BOOL_32 ElemLib::IsExpand3x(
     AddrFormat format)  ///< [in] Format
 {
     BOOL_32 is3x = FALSE;
@@ -1671,4 +1674,4 @@ BOOL_32 AddrElemLib::IsExpand3x(
     return is3x;
 }
 
-
+}
diff --git a/src/amd/addrlib/core/addrelemlib.h b/src/amd/addrlib/core/addrelemlib.h
index b47a413a9b4..2875026e32e 100644
--- a/src/amd/addrlib/core/addrelemlib.h
+++ b/src/amd/addrlib/core/addrelemlib.h
@@ -38,10 +38,13 @@
 #include "addrobject.h"
 #include "addrcommon.h"
 
-class AddrLib;
+namespace Addr
+{
+
+class Lib;
 
 // The masks for property bits within the Properties INT_32
-union ADDR_COMPONENT_FLAGS
+union ComponentFlags
 {
     struct
     {
@@ -53,8 +56,8 @@ union ADDR_COMPONENT_FLAGS
     UINT_32 value;
 };
 
-// Copy from legacy lib's AddrNumberType
-enum AddrNumberType
+// Copy from legacy lib's NumberType
+enum NumberType
 {
     // The following number types have the range [-1..1]
     ADDR_NO_NUMBER,         // This component doesn't exist and has no default value
@@ -109,7 +112,7 @@ enum AddrNumberType
 };
 
 // Copy from legacy lib's AddrElement
-enum AddrElemMode
+enum ElemMode
 {
     // These formats allow both packing an unpacking
     ADDR_ROUND_BY_HALF,     // add 1/2 and truncate when packing this element
@@ -137,7 +140,7 @@ enum AddrElemMode
     ADDR_END_ELEMENT        // Used for range comparisons
 };
 
-enum AddrDepthPlanarType
+enum DepthPlanarType
 {
     ADDR_DEPTH_PLANAR_NONE = 0, // No plane z/stencl
     ADDR_DEPTH_PLANAR_R600 = 1, // R600 z and stencil planes are store within a tile
@@ -146,19 +149,19 @@ enum AddrDepthPlanarType
 
 /**
 ****************************************************************************************************
-*   ADDR_PIXEL_FORMATINFO
+*   PixelFormatInfo
 *
 *   @brief
 *       Per component info
 *
 ****************************************************************************************************
 */
-struct ADDR_PIXEL_FORMATINFO
+struct PixelFormatInfo
 {
     UINT_32             compBit[4];
-    AddrNumberType      numType[4];
+    NumberType          numType[4];
     UINT_32             compStart[4];
-    AddrElemMode        elemMode;
+    ElemMode            elemMode;
     UINT_32             comps;          ///< Number of components
 };
 
@@ -167,18 +170,18 @@ struct ADDR_PIXEL_FORMATINFO
 * @brief This class contains asic indepentent element related attributes and operations
 ****************************************************************************************************
 */
-class AddrElemLib : public AddrObject
+class ElemLib : public Object
 {
 protected:
-    AddrElemLib(AddrLib* const pAddrLib);
+    ElemLib(Lib* pAddrLib);
 
 public:
 
     /// Makes this class virtual
-    virtual ~AddrElemLib();
+    virtual ~ElemLib();
 
-    static AddrElemLib *Create(
-        const AddrLib* const pAddrLib);
+    static ElemLib* Create(
+        const Lib* pAddrLib);
 
     /// The implementation is only for R6xx/R7xx, so make it virtual in case we need for R8xx
     BOOL_32 PixGetExportNorm(
@@ -196,32 +199,32 @@ public:
         const ADDR_FLT_32 comps[4], UINT_8 *pPixel) const;
 
     static VOID    Flt32sToInt32s(
-        ADDR_FLT_32 value, UINT_32 bits, AddrNumberType numberType, UINT_32* pResult);
+        ADDR_FLT_32 value, UINT_32 bits, NumberType numberType, UINT_32* pResult);
 
     static VOID    Int32sToPixel(
         UINT_32 numComps, UINT_32* pComps, UINT_32* pCompBits, UINT_32* pCompStart,
-        ADDR_COMPONENT_FLAGS properties, UINT_32 resultBits, UINT_8* pPixel);
+        ComponentFlags properties, UINT_32 resultBits, UINT_8* pPixel);
 
     VOID    PixGetColorCompInfo(
         AddrColorFormat format, AddrSurfaceNumber number, AddrSurfaceSwap swap,
-        ADDR_PIXEL_FORMATINFO* pInfo) const;
+        PixelFormatInfo* pInfo) const;
 
     VOID    PixGetDepthCompInfo(
-        AddrDepthFormat format, ADDR_PIXEL_FORMATINFO* pInfo) const;
+        AddrDepthFormat format, PixelFormatInfo* pInfo) const;
 
     UINT_32 GetBitsPerPixel(
-        AddrFormat format, AddrElemMode* pElemMode,
+        AddrFormat format, ElemMode* pElemMode,
         UINT_32* pExpandX = NULL, UINT_32* pExpandY = NULL, UINT_32* pBitsUnused = NULL);
 
     static VOID    SetClearComps(
         ADDR_FLT_32 comps[4], BOOL_32 clearColor, BOOL_32 float32);
 
     VOID    AdjustSurfaceInfo(
-        AddrElemMode elemMode, UINT_32 expandX, UINT_32 expandY,
+        ElemMode elemMode, UINT_32 expandX, UINT_32 expandY,
         UINT_32* pBpp, UINT_32* pBasePitch, UINT_32* pWidth, UINT_32* pHeight);
 
     VOID    RestoreSurfaceInfo(
-        AddrElemMode elemMode, UINT_32 expandX, UINT_32 expandY,
+        ElemMode elemMode, UINT_32 expandX, UINT_32 expandY,
         UINT_32* pBpp, UINT_32* pWidth, UINT_32* pHeight);
 
     /// Checks if depth and stencil are planar inside a tile
@@ -231,7 +234,7 @@ public:
     }
 
     /// Sets m_configFlags, copied from AddrLib
-    VOID    SetConfigFlags(AddrConfigFlags flags)
+    VOID    SetConfigFlags(ConfigFlags flags)
     {
         m_configFlags = flags;
     }
@@ -244,27 +247,29 @@ protected:
 
     static VOID    GetCompBits(
         UINT_32 c0, UINT_32 c1, UINT_32 c2, UINT_32 c3,
-        ADDR_PIXEL_FORMATINFO* pInfo,
-        AddrElemMode elemMode = ADDR_ROUND_BY_HALF);
+        PixelFormatInfo* pInfo,
+        ElemMode elemMode = ADDR_ROUND_BY_HALF);
 
     static VOID    GetCompType(
         AddrColorFormat format, AddrSurfaceNumber numType,
-        ADDR_PIXEL_FORMATINFO* pInfo);
+        PixelFormatInfo* pInfo);
 
     static VOID    GetCompSwap(
-        AddrSurfaceSwap swap, ADDR_PIXEL_FORMATINFO* pInfo);
+        AddrSurfaceSwap swap, PixelFormatInfo* pInfo);
 
     static VOID    SwapComps(
-        UINT_32 c0, UINT_32 c1, ADDR_PIXEL_FORMATINFO* pInfo);
+        UINT_32 c0, UINT_32 c1, PixelFormatInfo* pInfo);
 
 private:
 
     UINT_32             m_fp16ExportNorm;   ///< If allow FP16 to be reported as EXPORT_NORM
-    AddrDepthPlanarType m_depthPlanarType;
+    DepthPlanarType     m_depthPlanarType;
 
-    AddrConfigFlags   m_configFlags;      ///< Copy of AddrLib's configFlags
-    AddrLib* const      m_pAddrLib;         ///< Pointer to parent addrlib instance
+    ConfigFlags         m_configFlags;      ///< Copy of AddrLib's configFlags
+    Addr::Lib* const    m_pAddrLib;         ///< Pointer to parent addrlib instance
 };
 
+} //Addr
+
 #endif
 
diff --git a/src/amd/addrlib/core/addrlib.cpp b/src/amd/addrlib/core/addrlib.cpp
index f98a459f372..8553ca6569f 100644
--- a/src/amd/addrlib/core/addrlib.cpp
+++ b/src/amd/addrlib/core/addrlib.cpp
@@ -81,6 +81,8 @@ UINT_32 __umoddi3(UINT_64 n, UINT_32 base)
 
 #endif // __APPLE__
 
+namespace Addr
+{
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 //                               Constructor/Destructor
@@ -88,14 +90,14 @@ UINT_32 __umoddi3(UINT_64 n, UINT_32 base)
 
 /**
 ****************************************************************************************************
-*   AddrLib::AddrLib
+*   Lib::Lib
 *
 *   @brief
 *       Constructor for the AddrLib class
 *
 ****************************************************************************************************
 */
-AddrLib::AddrLib() :
+Lib::Lib() :
     m_class(BASE_ADDRLIB),
     m_chipFamily(ADDR_CHIP_FAMILY_IVLD),
     m_chipRevision(0),
@@ -113,15 +115,15 @@ AddrLib::AddrLib() :
 
 /**
 ****************************************************************************************************
-*   AddrLib::AddrLib
+*   Lib::Lib
 *
 *   @brief
 *       Constructor for the AddrLib class with hClient as parameter
 *
 ****************************************************************************************************
 */
-AddrLib::AddrLib(const AddrClient* pClient) :
-    AddrObject(pClient),
+Lib::Lib(const Client* pClient) :
+    Object(pClient),
     m_class(BASE_ADDRLIB),
     m_chipFamily(ADDR_CHIP_FAMILY_IVLD),
     m_chipRevision(0),
@@ -139,14 +141,14 @@ AddrLib::AddrLib(const AddrClient* pClient) :
 
 /**
 ****************************************************************************************************
-*   AddrLib::~AddrLib
+*   Lib::~AddrLib
 *
 *   @brief
 *       Destructor for the AddrLib class
 *
 ****************************************************************************************************
 */
-AddrLib::~AddrLib()
+Lib::~Lib()
 {
     if (m_pElemLib)
     {
@@ -162,7 +164,7 @@ AddrLib::~AddrLib()
 
 /**
 ****************************************************************************************************
-*   AddrLib::Create
+*   Lib::Create
 *
 *   @brief
 *       Creates and initializes AddrLib object.
@@ -171,11 +173,11 @@ AddrLib::~AddrLib()
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib::Create(
+ADDR_E_RETURNCODE Lib::Create(
     const ADDR_CREATE_INPUT* pCreateIn,     ///< [in] pointer to ADDR_CREATE_INPUT
     ADDR_CREATE_OUTPUT*      pCreateOut)    ///< [out] pointer to ADDR_CREATE_OUTPUT
 {
-    AddrLib* pLib = NULL;
+    Lib* pLib = NULL;
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 
     if (pCreateIn->createFlags.fillSizeFields == TRUE)
@@ -191,7 +193,7 @@ ADDR_E_RETURNCODE AddrLib::Create(
         (pCreateIn->callbacks.allocSysMem != NULL) &&
         (pCreateIn->callbacks.freeSysMem != NULL))
     {
-        AddrClient client = {
+        Client client = {
             pCreateIn->hClient,
             pCreateIn->callbacks
         };
@@ -202,13 +204,13 @@ ADDR_E_RETURNCODE AddrLib::Create(
                 switch (pCreateIn->chipFamily)
                 {
                     case FAMILY_SI:
-                        pLib = AddrSIHwlInit(&client);
+                        pLib = SiHwlInit(&client);
                         break;
                     case FAMILY_VI:
                     case FAMILY_CZ: // VI based fusion(carrizo)
                     case FAMILY_CI:
                     case FAMILY_KV: // CI based fusion
-                        pLib = AddrCIHwlInit(&client);
+                        pLib = CiHwlInit(&client);
                         break;
                     default:
                         ADDR_ASSERT_ALWAYS();
@@ -235,7 +237,7 @@ ADDR_E_RETURNCODE AddrLib::Create(
         pLib->m_configFlags.allowLargeThickTile = pCreateIn->createFlags.allowLargeThickTile;
         pLib->m_configFlags.disableLinearOpt    = FALSE;
 
-        pLib->SetAddrChipFamily(pCreateIn->chipFamily, pCreateIn->chipRevision);
+        pLib->SetChipFamily(pCreateIn->chipFamily, pCreateIn->chipRevision);
 
         pLib->SetMinPitchAlignPixels(pCreateIn->minPitchAlignPixels);
 
@@ -244,7 +246,7 @@ ADDR_E_RETURNCODE AddrLib::Create(
 
         if (initValid)
         {
-            pLib->m_pElemLib = AddrElemLib::Create(pLib);
+            pLib->m_pElemLib = ElemLib::Create(pLib);
         }
         else
         {
@@ -285,19 +287,19 @@ ADDR_E_RETURNCODE AddrLib::Create(
 
 /**
 ****************************************************************************************************
-*   AddrLib::SetAddrChipFamily
+*   Lib::SetChipFamily
 *
 *   @brief
-*       Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
+*       Convert familyID defined in atiid.h to ChipFamily and set m_chipFamily/m_chipRevision
 *   @return
 *      N/A
 ****************************************************************************************************
 */
-VOID AddrLib::SetAddrChipFamily(
+VOID Lib::SetChipFamily(
     UINT_32 uChipFamily,        ///< [in] chip family defined in atiih.h
     UINT_32 uChipRevision)      ///< [in] chip revision defined in "asic_family"_id.h
 {
-    AddrChipFamily family = HwlConvertChipFamily(uChipFamily, uChipRevision);
+    ChipFamily family = HwlConvertChipFamily(uChipFamily, uChipRevision);
 
     ADDR_ASSERT(family != ADDR_CHIP_FAMILY_IVLD);
 
@@ -307,7 +309,7 @@ VOID AddrLib::SetAddrChipFamily(
 
 /**
 ****************************************************************************************************
-*   AddrLib::SetMinPitchAlignPixels
+*   Lib::SetMinPitchAlignPixels
 *
 *   @brief
 *       Set m_minPitchAlignPixels with input param
@@ -316,7 +318,7 @@ VOID AddrLib::SetAddrChipFamily(
 *      N/A
 ****************************************************************************************************
 */
-VOID AddrLib::SetMinPitchAlignPixels(
+VOID Lib::SetMinPitchAlignPixels(
     UINT_32 minPitchAlignPixels)    ///< [in] minmum pitch alignment in pixels
 {
     m_minPitchAlignPixels = (minPitchAlignPixels == 0) ? 1 : minPitchAlignPixels;
@@ -324,7 +326,7 @@ VOID AddrLib::SetMinPitchAlignPixels(
 
 /**
 ****************************************************************************************************
-*   AddrLib::GetAddrLib
+*   Lib::GetLib
 *
 *   @brief
 *       Get AddrLib pointer
@@ -333,15 +335,15 @@ VOID AddrLib::SetMinPitchAlignPixels(
 *      An AddrLib class pointer
 ****************************************************************************************************
 */
-AddrLib * AddrLib::GetAddrLib(
+Lib* Lib::GetLib(
     ADDR_HANDLE hLib)   ///< [in] handle of ADDR_HANDLE
 {
-    return static_cast<AddrLib *>(hLib);
+    return static_cast<Addr::Lib*>(hLib);
 }
 
 /**
 ****************************************************************************************************
-*   AddrLib::GetMaxAlignments
+*   Lib::GetMaxAlignments
 *
 *   @brief
 *       Gets maximum alignments
@@ -350,7 +352,7 @@ AddrLib * AddrLib::GetAddrLib(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib::GetMaxAlignments(
+ADDR_E_RETURNCODE Lib::GetMaxAlignments(
     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut    ///< [out] output structure
     ) const
 {
@@ -374,7 +376,7 @@ ADDR_E_RETURNCODE AddrLib::GetMaxAlignments(
 
 /**
 ****************************************************************************************************
-*   AddrLib::Bits2Number
+*   Lib::Bits2Number
 *
 *   @brief
 *       Cat a array of binary bit to a number
@@ -383,7 +385,7 @@ ADDR_E_RETURNCODE AddrLib::GetMaxAlignments(
 *       The number combined with the array of bits
 ****************************************************************************************************
 */
-UINT_32 AddrLib::Bits2Number(
+UINT_32 Lib::Bits2Number(
     UINT_32 bitNum,     ///< [in] how many bits
     ...)                ///< [in] varaible bits value starting from MSB
 {
@@ -414,7 +416,7 @@ UINT_32 AddrLib::Bits2Number(
 
 /**
 ****************************************************************************************************
-*   AddrLib::Flt32ToColorPixel
+*   Lib::Flt32ToColorPixel
 *
 *   @brief
 *       Convert a FLT_32 value to a depth/stencil pixel value
@@ -422,7 +424,7 @@ UINT_32 AddrLib::Bits2Number(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib::Flt32ToDepthPixel(
+ADDR_E_RETURNCODE Lib::Flt32ToDepthPixel(
     const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,
     ELEM_FLT32TODEPTHPIXEL_OUTPUT* pOut) const
 {
@@ -492,7 +494,7 @@ ADDR_E_RETURNCODE AddrLib::Flt32ToDepthPixel(
 
 /**
 ****************************************************************************************************
-*   AddrLib::Flt32ToColorPixel
+*   Lib::Flt32ToColorPixel
 *
 *   @brief
 *       Convert a FLT_32 value to a red/green/blue/alpha pixel value
@@ -500,7 +502,7 @@ ADDR_E_RETURNCODE AddrLib::Flt32ToDepthPixel(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib::Flt32ToColorPixel(
+ADDR_E_RETURNCODE Lib::Flt32ToColorPixel(
     const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,
     ELEM_FLT32TOCOLORPIXEL_OUTPUT* pOut) const
 {
@@ -530,7 +532,7 @@ ADDR_E_RETURNCODE AddrLib::Flt32ToColorPixel(
 
 /**
 ****************************************************************************************************
-*   AddrLib::GetExportNorm
+*   Lib::GetExportNorm
 *
 *   @brief
 *       Check one format can be EXPORT_NUM
@@ -538,7 +540,7 @@ ADDR_E_RETURNCODE AddrLib::Flt32ToColorPixel(
 *       TRUE if EXPORT_NORM can be used
 ****************************************************************************************************
 */
-BOOL_32 AddrLib::GetExportNorm(
+BOOL_32 Lib::GetExportNorm(
     const ELEM_GETEXPORTNORM_INPUT* pIn) const
 {
     ADDR_E_RETURNCODE returnCode = ADDR_OK;
@@ -561,3 +563,4 @@ BOOL_32 AddrLib::GetExportNorm(
     return enabled;
 }
 
+} // Addr
diff --git a/src/amd/addrlib/core/addrlib.h b/src/amd/addrlib/core/addrlib.h
index 581ef377f74..10d029f34fe 100644
--- a/src/amd/addrlib/core/addrlib.h
+++ b/src/amd/addrlib/core/addrlib.h
@@ -34,7 +34,6 @@
 #ifndef __ADDR_LIB_H__
 #define __ADDR_LIB_H__
 
-
 #include "addrinterface.h"
 #include "addrobject.h"
 #include "addrelemlib.h"
@@ -60,12 +59,16 @@
 #ifndef CIASICIDGFXENGINE_SEAISLAND
 #define CIASICIDGFXENGINE_SEAISLAND 0x0000000B
 #endif
+
+namespace Addr
+{
+
 /**
 ****************************************************************************************************
 * @brief Neutral enums that define pipeinterleave
 ****************************************************************************************************
 */
-enum AddrPipeInterleave
+enum PipeInterleave
 {
     ADDR_PIPEINTERLEAVE_256B = 256,
     ADDR_PIPEINTERLEAVE_512B = 512,
@@ -76,7 +79,7 @@ enum AddrPipeInterleave
 * @brief Neutral enums that define DRAM row size
 ****************************************************************************************************
 */
-enum AddrRowSize
+enum RowSize
 {
     ADDR_ROWSIZE_1KB = 1024,
     ADDR_ROWSIZE_2KB = 2048,
@@ -89,7 +92,7 @@ enum AddrRowSize
 * @brief Neutral enums that define bank interleave
 ****************************************************************************************************
 */
-enum AddrBankInterleave
+enum BankInterleave
 {
     ADDR_BANKINTERLEAVE_1 = 1,
     ADDR_BANKINTERLEAVE_2 = 2,
@@ -99,23 +102,10 @@ enum AddrBankInterleave
 
 /**
 ****************************************************************************************************
-* @brief Neutral enums that define MGPU chip tile size
-****************************************************************************************************
-*/
-enum AddrChipTileSize
-{
-    ADDR_CHIPTILESIZE_16 = 16,
-    ADDR_CHIPTILESIZE_32 = 32,
-    ADDR_CHIPTILESIZE_64 = 64,
-    ADDR_CHIPTILESIZE_128 = 128,
-};
-
-/**
-****************************************************************************************************
 * @brief Neutral enums that define shader engine tile size
 ****************************************************************************************************
 */
-enum AddrEngTileSize
+enum ShaderEngineTileSize
 {
     ADDR_SE_TILESIZE_16 = 16,
     ADDR_SE_TILESIZE_32 = 32,
@@ -126,7 +116,7 @@ enum AddrEngTileSize
 * @brief Neutral enums that define bank swap size
 ****************************************************************************************************
 */
-enum AddrBankSwapSize
+enum BankSwapSize
 {
     ADDR_BANKSWAP_128B = 128,
     ADDR_BANKSWAP_256B = 256,
@@ -134,16 +124,15 @@ enum AddrBankSwapSize
     ADDR_BANKSWAP_1KB = 1024,
 };
 
-
 /**
 ****************************************************************************************************
 * @brief This class contains asic independent address lib functionalities
 ****************************************************************************************************
 */
-class AddrLib : public AddrObject
+class Lib : public Object
 {
 public:
-    virtual ~AddrLib();
+    virtual ~Lib();
 
     static ADDR_E_RETURNCODE Create(
         const ADDR_CREATE_INPUT* pCreateInfo, ADDR_CREATE_OUTPUT* pCreateOut);
@@ -154,7 +143,7 @@ public:
         delete this;
     }
 
-    static AddrLib* GetAddrLib(ADDR_HANDLE hLib);
+    static Lib* GetLib(ADDR_HANDLE hLib);
 
     /// Returns AddrLib version (from compiled binary instead include file)
     UINT_32 GetVersion()
@@ -163,7 +152,7 @@ public:
     }
 
     /// Returns asic chip family name defined by AddrLib
-    AddrChipFamily GetAddrChipFamily()
+    ChipFamily GetChipFamily()
     {
         return m_chipFamily;
     }
@@ -181,8 +170,8 @@ public:
     ADDR_E_RETURNCODE GetMaxAlignments(ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut) const;
 
 protected:
-    AddrLib();  // Constructor is protected
-    AddrLib(const AddrClient* pClient);
+    Lib();  // Constructor is protected
+    Lib(const Client* pClient);
 
     /// Pure virtual function to get max alignments
     virtual ADDR_E_RETURNCODE HwlGetMaxAlignments(ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut) const = 0;
@@ -194,7 +183,7 @@ protected:
     virtual BOOL_32 HwlInitGlobalParams(const ADDR_CREATE_INPUT* pCreateIn) = 0;
 
     /// Pure Virtual function for Hwl converting chip family
-    virtual AddrChipFamily HwlConvertChipFamily(UINT_32 uChipFamily, UINT_32 uChipRevision) = 0;
+    virtual ChipFamily HwlConvertChipFamily(UINT_32 uChipFamily, UINT_32 uChipRevision) = 0;
 
     /// Get equation table pointer and number of equations
     virtual UINT_32 HwlGetEquationTableInfo(const ADDR_EQUATION** ppEquationTable) const
@@ -207,15 +196,15 @@ protected:
     //
     // Misc helper
     //
-    static UINT_32 Bits2Number(UINT_32 bitNum,...);
+    static UINT_32 Bits2Number(UINT_32 bitNum, ...);
 
     static UINT_32 GetNumFragments(UINT_32 numSamples, UINT_32 numFrags)
     {
         return (numFrags != 0) ? numFrags : Max(1u, numSamples);
     }
 
-    /// Returns pointer of AddrElemLib
-    AddrElemLib* GetElemLib() const
+    /// Returns pointer of ElemLib
+    ElemLib* GetElemLib() const
     {
         return m_pElemLib;
     }
@@ -228,19 +217,19 @@ protected:
 
 private:
     // Disallow the copy constructor
-    AddrLib(const AddrLib& a);
+    Lib(const Lib& a);
 
     // Disallow the assignment operator
-    AddrLib& operator=(const AddrLib& a);
+    Lib& operator=(const Lib& a);
 
-    VOID SetAddrChipFamily(UINT_32 uChipFamily, UINT_32 uChipRevision);
+    VOID SetChipFamily(UINT_32 uChipFamily, UINT_32 uChipRevision);
 
     VOID SetMinPitchAlignPixels(UINT_32 minPitchAlignPixels);
 
 protected:
-    AddrLibClass        m_class;        ///< Store class type (HWL type)
+    LibClass            m_class;        ///< Store class type (HWL type)
 
-    AddrChipFamily      m_chipFamily;   ///< Chip family translated from the one in atiid.h
+    ChipFamily          m_chipFamily;   ///< Chip family translated from the one in atiid.h
 
     UINT_32             m_chipRevision; ///< Revision id from xxx_id.h
 
@@ -249,7 +238,7 @@ protected:
     //
     // Global parameters
     //
-    AddrConfigFlags   m_configFlags;  ///< Global configuration flags. Note this is setup by
+    ConfigFlags         m_configFlags;    ///< Global configuration flags. Note this is setup by
                                         ///  AddrLib instead of Client except forceLinearAligned
 
     UINT_32             m_pipes;        ///< Number of pipes
@@ -267,11 +256,13 @@ protected:
     UINT_32             m_minPitchAlignPixels; ///< Minimum pitch alignment in pixels
     UINT_32             m_maxSamples;   ///< Max numSamples
 private:
-    AddrElemLib*        m_pElemLib;     ///< Element Lib pointer
+    ElemLib*            m_pElemLib;     ///< Element Lib pointer
 };
 
-AddrLib* AddrSIHwlInit  (const AddrClient* pClient);
-AddrLib* AddrCIHwlInit  (const AddrClient* pClient);
+Lib* SiHwlInit  (const Client* pClient);
+Lib* CiHwlInit  (const Client* pClient);
+
+} // Addr
 
 #endif
 
diff --git a/src/amd/addrlib/core/addrlib1.cpp b/src/amd/addrlib/core/addrlib1.cpp
index 4a2b4563eb0..e7ac3859a81 100644
--- a/src/amd/addrlib/core/addrlib1.cpp
+++ b/src/amd/addrlib/core/addrlib1.cpp
@@ -35,12 +35,16 @@
 #include "addrlib1.h"
 #include "addrcommon.h"
 
+namespace Addr
+{
+namespace V1
+{
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 //                               Static Const Member
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-const AddrTileModeFlags AddrLib1::ModeFlags[ADDR_TM_COUNT] =
+const TileModeFlags Lib::ModeFlags[ADDR_TM_COUNT] =
 {// T   L  1  2  3  P  Pr B
     {1, 1, 0, 0, 0, 0, 0, 0}, // ADDR_TM_LINEAR_GENERAL
     {1, 1, 0, 0, 0, 0, 0, 0}, // ADDR_TM_LINEAR_ALIGNED
@@ -76,69 +80,71 @@ const AddrTileModeFlags AddrLib1::ModeFlags[ADDR_TM_COUNT] =
 
 /**
 ****************************************************************************************************
-*   AddrLib1::AddrLib1
+*   Lib::AddrLib1
 *
 *   @brief
 *       Constructor for the AddrLib1 class
 *
 ****************************************************************************************************
 */
-AddrLib1::AddrLib1() :
-    AddrLib()
+Lib::Lib()
+    :
+    Addr::Lib()
 {
 }
 
 /**
 ****************************************************************************************************
-*   AddrLib1::AddrLib1
+*   Lib::Lib
 *
 *   @brief
-*       Constructor for the AddrLib1 class with hClient as parameter
+*       Constructor for the Addr::V1::Lib class with hClient as parameter
 *
 ****************************************************************************************************
 */
-AddrLib1::AddrLib1(const AddrClient* pClient) :
-    AddrLib(pClient)
+Lib::Lib(const Client* pClient)
+    :
+    Addr::Lib(pClient)
 {
 }
 
 /**
 ****************************************************************************************************
-*   AddrLib1::~AddrLib1
+*   Lib::~AddrLib1
 *
 *   @brief
 *       Destructor for the AddrLib1 class
 *
 ****************************************************************************************************
 */
-AddrLib1::~AddrLib1()
+Lib::~Lib()
 {
 }
 
 /**
 ****************************************************************************************************
-*   AddrLib1::GetAddrLib1
+*   Lib::GetLib
 *
 *   @brief
 *       Get AddrLib1 pointer
 *
 *   @return
-*      An AddrLib1 class pointer
+*      An Addr::V1::Lib class pointer
 ****************************************************************************************************
 */
-AddrLib1* AddrLib1::GetAddrLib1(
+Lib* Lib::GetLib(
     ADDR_HANDLE hLib)   ///< [in] handle of ADDR_HANDLE
 {
-    AddrLib* pAddrLib = AddrLib::GetAddrLib(hLib);
+    Addr::Lib* pAddrLib = Addr::Lib::GetLib(hLib);
     if ((pAddrLib != NULL) &&
-        ((pAddrLib->GetAddrChipFamily() == ADDR_CHIP_FAMILY_IVLD) ||
-         (pAddrLib->GetAddrChipFamily() > ADDR_CHIP_FAMILY_VI)))
+        ((pAddrLib->GetChipFamily() == ADDR_CHIP_FAMILY_IVLD) ||
+         (pAddrLib->GetChipFamily() > ADDR_CHIP_FAMILY_VI)))
     {
         // only valid and pre-VI AISC can use AddrLib1 function.
         ADDR_ASSERT_ALWAYS();
         hLib = NULL;
     }
-    return static_cast<AddrLib1 *>(hLib);
+    return static_cast<Lib*>(hLib);
 }
 
 
@@ -149,7 +155,7 @@ AddrLib1* AddrLib1::GetAddrLib1(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeSurfaceInfo
+*   Lib::ComputeSurfaceInfo
 *
 *   @brief
 *       Interface function stub of AddrComputeSurfaceInfo.
@@ -158,7 +164,7 @@ AddrLib1* AddrLib1::GetAddrLib1(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
+ADDR_E_RETURNCODE Lib::ComputeSurfaceInfo(
      const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn,    ///< [in] input structure
      ADDR_COMPUTE_SURFACE_INFO_OUTPUT*      pOut    ///< [out] output structure
      ) const
@@ -222,7 +228,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
 
         UINT_32 expandX = 1;
         UINT_32 expandY = 1;
-        AddrElemMode elemMode;
+        ElemMode elemMode;
 
         // Save outputs that may not go through HWL
         pOut->pixelBits = localIn.bpp;
@@ -435,7 +441,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeSurfaceInfo
+*   Lib::ComputeSurfaceInfo
 *
 *   @brief
 *       Interface function stub of AddrComputeSurfaceInfo.
@@ -444,7 +450,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceAddrFromCoord(
+ADDR_E_RETURNCODE Lib::ComputeSurfaceAddrFromCoord(
     const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,    ///< [in] input structure
     ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT*      pOut    ///< [out] output structure
     ) const
@@ -515,7 +521,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceAddrFromCoord(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeSurfaceCoordFromAddr
+*   Lib::ComputeSurfaceCoordFromAddr
 *
 *   @brief
 *       Interface function stub of ComputeSurfaceCoordFromAddr.
@@ -524,7 +530,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceAddrFromCoord(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceCoordFromAddr(
+ADDR_E_RETURNCODE Lib::ComputeSurfaceCoordFromAddr(
     const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,    ///< [in] input structure
     ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT*      pOut    ///< [out] output structure
     ) const
@@ -590,7 +596,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceCoordFromAddr(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeSliceTileSwizzle
+*   Lib::ComputeSliceTileSwizzle
 *
 *   @brief
 *       Interface function stub of ComputeSliceTileSwizzle.
@@ -599,7 +605,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceCoordFromAddr(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeSliceTileSwizzle(
+ADDR_E_RETURNCODE Lib::ComputeSliceTileSwizzle(
     const ADDR_COMPUTE_SLICESWIZZLE_INPUT*  pIn,    ///< [in] input structure
     ADDR_COMPUTE_SLICESWIZZLE_OUTPUT*       pOut    ///< [out] output structure
     ) const
@@ -643,7 +649,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSliceTileSwizzle(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ExtractBankPipeSwizzle
+*   Lib::ExtractBankPipeSwizzle
 *
 *   @brief
 *       Interface function stub of AddrExtractBankPipeSwizzle.
@@ -652,7 +658,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSliceTileSwizzle(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ExtractBankPipeSwizzle(
+ADDR_E_RETURNCODE Lib::ExtractBankPipeSwizzle(
     const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT*  pIn,    ///< [in] input structure
     ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT*       pOut    ///< [out] output structure
     ) const
@@ -695,7 +701,7 @@ ADDR_E_RETURNCODE AddrLib1::ExtractBankPipeSwizzle(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::CombineBankPipeSwizzle
+*   Lib::CombineBankPipeSwizzle
 *
 *   @brief
 *       Interface function stub of AddrCombineBankPipeSwizzle.
@@ -704,7 +710,7 @@ ADDR_E_RETURNCODE AddrLib1::ExtractBankPipeSwizzle(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::CombineBankPipeSwizzle(
+ADDR_E_RETURNCODE Lib::CombineBankPipeSwizzle(
     const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT*  pIn,    ///< [in] input structure
     ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT*       pOut    ///< [out] output structure
     ) const
@@ -751,7 +757,7 @@ ADDR_E_RETURNCODE AddrLib1::CombineBankPipeSwizzle(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeBaseSwizzle
+*   Lib::ComputeBaseSwizzle
 *
 *   @brief
 *       Interface function stub of AddrCompueBaseSwizzle.
@@ -759,7 +765,7 @@ ADDR_E_RETURNCODE AddrLib1::CombineBankPipeSwizzle(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeBaseSwizzle(
+ADDR_E_RETURNCODE Lib::ComputeBaseSwizzle(
     const ADDR_COMPUTE_BASE_SWIZZLE_INPUT*  pIn,
     ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT* pOut) const
 {
@@ -808,7 +814,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeBaseSwizzle(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeFmaskInfo
+*   Lib::ComputeFmaskInfo
 *
 *   @brief
 *       Interface function stub of ComputeFmaskInfo.
@@ -817,7 +823,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeBaseSwizzle(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeFmaskInfo(
+ADDR_E_RETURNCODE Lib::ComputeFmaskInfo(
     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,    ///< [in] input structure
     ADDR_COMPUTE_FMASK_INFO_OUTPUT*         pOut    ///< [out] output structure
     )
@@ -902,7 +908,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskInfo(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeFmaskAddrFromCoord
+*   Lib::ComputeFmaskAddrFromCoord
 *
 *   @brief
 *       Interface function stub of ComputeFmaskAddrFromCoord.
@@ -911,7 +917,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskInfo(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeFmaskAddrFromCoord(
+ADDR_E_RETURNCODE Lib::ComputeFmaskAddrFromCoord(
     const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,    ///< [in] input structure
     ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*        pOut    ///< [out] output structure
     ) const
@@ -946,7 +952,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskAddrFromCoord(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeFmaskCoordFromAddr
+*   Lib::ComputeFmaskCoordFromAddr
 *
 *   @brief
 *       Interface function stub of ComputeFmaskAddrFromCoord.
@@ -955,7 +961,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskAddrFromCoord(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeFmaskCoordFromAddr(
+ADDR_E_RETURNCODE Lib::ComputeFmaskCoordFromAddr(
     const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*  pIn,     ///< [in] input structure
     ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut           ///< [out] output structure
     ) const
@@ -990,7 +996,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskCoordFromAddr(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ConvertTileInfoToHW
+*   Lib::ConvertTileInfoToHW
 *
 *   @brief
 *       Convert tile info from real value to HW register value in HW layer
@@ -999,7 +1005,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskCoordFromAddr(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ConvertTileInfoToHW(
+ADDR_E_RETURNCODE Lib::ConvertTileInfoToHW(
     const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
     ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut      ///< [out] output structure
     ) const
@@ -1042,7 +1048,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileInfoToHW(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ConvertTileIndex
+*   Lib::ConvertTileIndex
 *
 *   @brief
 *       Convert tile index to tile mode/type/info
@@ -1051,7 +1057,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileInfoToHW(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex(
+ADDR_E_RETURNCODE Lib::ConvertTileIndex(
     const ADDR_CONVERT_TILEINDEX_INPUT* pIn, ///< [in] input structure
     ADDR_CONVERT_TILEINDEX_OUTPUT* pOut      ///< [out] output structure
     ) const
@@ -1091,7 +1097,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::GetMacroModeIndex
+*   Lib::GetMacroModeIndex
 *
 *   @brief
 *       Get macro mode index based on input info
@@ -1100,7 +1106,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::GetMacroModeIndex(
+ADDR_E_RETURNCODE Lib::GetMacroModeIndex(
     const ADDR_GET_MACROMODEINDEX_INPUT* pIn, ///< [in] input structure
     ADDR_GET_MACROMODEINDEX_OUTPUT*      pOut ///< [out] output structure
     ) const
@@ -1128,7 +1134,7 @@ ADDR_E_RETURNCODE AddrLib1::GetMacroModeIndex(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ConvertTileIndex1
+*   Lib::ConvertTileIndex1
 *
 *   @brief
 *       Convert tile index to tile mode/type/info
@@ -1137,7 +1143,7 @@ ADDR_E_RETURNCODE AddrLib1::GetMacroModeIndex(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex1(
+ADDR_E_RETURNCODE Lib::ConvertTileIndex1(
     const ADDR_CONVERT_TILEINDEX1_INPUT* pIn,   ///< [in] input structure
     ADDR_CONVERT_TILEINDEX_OUTPUT* pOut         ///< [out] output structure
     ) const
@@ -1178,7 +1184,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex1(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::GetTileIndex
+*   Lib::GetTileIndex
 *
 *   @brief
 *       Get tile index from tile mode/type/info
@@ -1187,7 +1193,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex1(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::GetTileIndex(
+ADDR_E_RETURNCODE Lib::GetTileIndex(
     const ADDR_GET_TILEINDEX_INPUT* pIn, ///< [in] input structure
     ADDR_GET_TILEINDEX_OUTPUT* pOut      ///< [out] output structure
     ) const
@@ -1213,7 +1219,7 @@ ADDR_E_RETURNCODE AddrLib1::GetTileIndex(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::Thickness
+*   Lib::Thickness
 *
 *   @brief
 *       Get tile mode thickness
@@ -1222,7 +1228,7 @@ ADDR_E_RETURNCODE AddrLib1::GetTileIndex(
 *       Tile mode thickness
 ****************************************************************************************************
 */
-UINT_32 AddrLib1::Thickness(
+UINT_32 Lib::Thickness(
     AddrTileMode tileMode)    ///< [in] tile mode
 {
     return ModeFlags[tileMode].thickness;
@@ -1236,7 +1242,7 @@ UINT_32 AddrLib1::Thickness(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeHtileInfo
+*   Lib::ComputeHtileInfo
 *
 *   @brief
 *       Interface function stub of AddrComputeHtilenfo
@@ -1245,7 +1251,7 @@ UINT_32 AddrLib1::Thickness(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeHtileInfo(
+ADDR_E_RETURNCODE Lib::ComputeHtileInfo(
     const ADDR_COMPUTE_HTILE_INFO_INPUT*    pIn,    ///< [in] input structure
     ADDR_COMPUTE_HTILE_INFO_OUTPUT*         pOut    ///< [out] output structure
     ) const
@@ -1306,7 +1312,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileInfo(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeCmaskInfo
+*   Lib::ComputeCmaskInfo
 *
 *   @brief
 *       Interface function stub of AddrComputeCmaskInfo
@@ -1315,7 +1321,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileInfo(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
+ADDR_E_RETURNCODE Lib::ComputeCmaskInfo(
     const ADDR_COMPUTE_CMASK_INFO_INPUT*    pIn,    ///< [in] input structure
     ADDR_COMPUTE_CMASK_INFO_OUTPUT*         pOut    ///< [out] output structure
     ) const
@@ -1372,7 +1378,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeDccInfo
+*   Lib::ComputeDccInfo
 *
 *   @brief
 *       Interface function to compute DCC key info
@@ -1381,7 +1387,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
 *       return code of HwlComputeDccInfo
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeDccInfo(
+ADDR_E_RETURNCODE Lib::ComputeDccInfo(
     const ADDR_COMPUTE_DCCINFO_INPUT*    pIn,    ///< [in] input structure
     ADDR_COMPUTE_DCCINFO_OUTPUT*         pOut    ///< [out] output structure
     ) const
@@ -1422,7 +1428,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeDccInfo(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeHtileAddrFromCoord
+*   Lib::ComputeHtileAddrFromCoord
 *
 *   @brief
 *       Interface function stub of AddrComputeHtileAddrFromCoord
@@ -1431,7 +1437,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeDccInfo(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeHtileAddrFromCoord(
+ADDR_E_RETURNCODE Lib::ComputeHtileAddrFromCoord(
     const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*   pIn,    ///< [in] input structure
     ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT*        pOut    ///< [out] output structure
     ) const
@@ -1497,7 +1503,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileAddrFromCoord(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeHtileCoordFromAddr
+*   Lib::ComputeHtileCoordFromAddr
 *
 *   @brief
 *       Interface function stub of AddrComputeHtileCoordFromAddr
@@ -1506,7 +1512,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileAddrFromCoord(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeHtileCoordFromAddr(
+ADDR_E_RETURNCODE Lib::ComputeHtileCoordFromAddr(
     const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT*   pIn,    ///< [in] input structure
     ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT*        pOut    ///< [out] output structure
     ) const
@@ -1565,7 +1571,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileCoordFromAddr(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeCmaskAddrFromCoord
+*   Lib::ComputeCmaskAddrFromCoord
 *
 *   @brief
 *       Interface function stub of AddrComputeCmaskAddrFromCoord
@@ -1574,7 +1580,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileCoordFromAddr(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeCmaskAddrFromCoord(
+ADDR_E_RETURNCODE Lib::ComputeCmaskAddrFromCoord(
     const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*   pIn,    ///< [in] input structure
     ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT*        pOut    ///< [out] output structure
     ) const
@@ -1637,7 +1643,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskAddrFromCoord(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeCmaskCoordFromAddr
+*   Lib::ComputeCmaskCoordFromAddr
 *
 *   @brief
 *       Interface function stub of AddrComputeCmaskCoordFromAddr
@@ -1646,7 +1652,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskAddrFromCoord(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeCmaskCoordFromAddr(
+ADDR_E_RETURNCODE Lib::ComputeCmaskCoordFromAddr(
     const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT*   pIn,    ///< [in] input structure
     ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT*        pOut    ///< [out] output structure
     ) const
@@ -1703,7 +1709,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskCoordFromAddr(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeTileDataWidthAndHeight
+*   Lib::ComputeTileDataWidthAndHeight
 *
 *   @brief
 *       Compute the squared cache shape for per-tile data (CMASK and HTILE)
@@ -1715,7 +1721,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskCoordFromAddr(
 *       MacroWidth and macroHeight are measured in pixels
 ****************************************************************************************************
 */
-VOID AddrLib1::ComputeTileDataWidthAndHeight(
+VOID Lib::ComputeTileDataWidthAndHeight(
     UINT_32         bpp,             ///< [in] bits per pixel
     UINT_32         cacheBits,       ///< [in] bits of cache
     ADDR_TILEINFO*  pTileInfo,       ///< [in] Tile info
@@ -1747,7 +1753,7 @@ VOID AddrLib1::ComputeTileDataWidthAndHeight(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::HwlComputeTileDataWidthAndHeightLinear
+*   Lib::HwlComputeTileDataWidthAndHeightLinear
 *
 *   @brief
 *       Compute the squared cache shape for per-tile data (CMASK and HTILE) for linear layout
@@ -1759,7 +1765,7 @@ VOID AddrLib1::ComputeTileDataWidthAndHeight(
 *       MacroWidth and macroHeight are measured in pixels
 ****************************************************************************************************
 */
-VOID AddrLib1::HwlComputeTileDataWidthAndHeightLinear(
+VOID Lib::HwlComputeTileDataWidthAndHeightLinear(
     UINT_32*        pMacroWidth,     ///< [out] macro tile width
     UINT_32*        pMacroHeight,    ///< [out] macro tile height
     UINT_32         bpp,             ///< [in] bits per pixel
@@ -1773,7 +1779,7 @@ VOID AddrLib1::HwlComputeTileDataWidthAndHeightLinear(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeHtileInfo
+*   Lib::ComputeHtileInfo
 *
 *   @brief
 *       Compute htile pitch,width, bytes per 2D slice
@@ -1784,7 +1790,7 @@ VOID AddrLib1::HwlComputeTileDataWidthAndHeightLinear(
 *       *Htile pitch, height, total size in bytes, macro-tile dimensions and slice size*
 ****************************************************************************************************
 */
-UINT_32 AddrLib1::ComputeHtileInfo(
+UINT_32 Lib::ComputeHtileInfo(
     ADDR_HTILE_FLAGS flags,             ///< [in] htile flags
     UINT_32          pitchIn,           ///< [in] pitch input
     UINT_32          heightIn,          ///< [in] height input
@@ -1861,7 +1867,7 @@ UINT_32 AddrLib1::ComputeHtileInfo(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeCmaskBaseAlign
+*   Lib::ComputeCmaskBaseAlign
 *
 *   @brief
 *       Compute cmask base alignment
@@ -1870,7 +1876,7 @@ UINT_32 AddrLib1::ComputeHtileInfo(
 *       Cmask base alignment
 ****************************************************************************************************
 */
-UINT_32 AddrLib1::ComputeCmaskBaseAlign(
+UINT_32 Lib::ComputeCmaskBaseAlign(
     ADDR_CMASK_FLAGS flags,           ///< [in] Cmask flags
     ADDR_TILEINFO*   pTileInfo        ///< [in] Tile info
     ) const
@@ -1891,7 +1897,7 @@ UINT_32 AddrLib1::ComputeCmaskBaseAlign(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeCmaskBytes
+*   Lib::ComputeCmaskBytes
 *
 *   @brief
 *       Compute cmask size in bytes
@@ -1900,7 +1906,7 @@ UINT_32 AddrLib1::ComputeCmaskBaseAlign(
 *       Cmask size in bytes
 ****************************************************************************************************
 */
-UINT_64 AddrLib1::ComputeCmaskBytes(
+UINT_64 Lib::ComputeCmaskBytes(
     UINT_32 pitch,        ///< [in] pitch
     UINT_32 height,       ///< [in] height
     UINT_32 numSlices     ///< [in] number of slices
@@ -1912,7 +1918,7 @@ UINT_64 AddrLib1::ComputeCmaskBytes(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeCmaskInfo
+*   Lib::ComputeCmaskInfo
 *
 *   @brief
 *       Compute cmask pitch,width, bytes per 2D slice
@@ -1922,7 +1928,7 @@ UINT_64 AddrLib1::ComputeCmaskBytes(
 *       macro-tile dimensions
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
+ADDR_E_RETURNCODE Lib::ComputeCmaskInfo(
     ADDR_CMASK_FLAGS flags,            ///< [in] cmask flags
     UINT_32          pitchIn,           ///< [in] pitch input
     UINT_32          heightIn,          ///< [in] height input
@@ -2027,7 +2033,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeXmaskCoordYFromPipe
+*   Lib::ComputeXmaskCoordYFromPipe
 *
 *   @brief
 *       Compute the Y coord from pipe number for cmask/htile
@@ -2037,7 +2043,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
 *
 ****************************************************************************************************
 */
-UINT_32 AddrLib1::ComputeXmaskCoordYFromPipe(
+UINT_32 Lib::ComputeXmaskCoordYFromPipe(
     UINT_32         pipe,       ///< [in] pipe number
     UINT_32         x           ///< [in] x coordinate
     ) const
@@ -2119,7 +2125,7 @@ UINT_32 AddrLib1::ComputeXmaskCoordYFromPipe(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::HwlComputeXmaskCoordFromAddr
+*   Lib::HwlComputeXmaskCoordFromAddr
 *
 *   @brief
 *       Compute the coord from an address of a cmask/htile
@@ -2131,7 +2137,7 @@ UINT_32 AddrLib1::ComputeXmaskCoordYFromPipe(
 *       This method is reused by htile, so rename to Xmask
 ****************************************************************************************************
 */
-VOID AddrLib1::HwlComputeXmaskCoordFromAddr(
+VOID Lib::HwlComputeXmaskCoordFromAddr(
     UINT_64         addr,           ///< [in] address
     UINT_32         bitPosition,    ///< [in] bitPosition in a byte
     UINT_32         pitch,          ///< [in] pitch
@@ -2301,7 +2307,7 @@ VOID AddrLib1::HwlComputeXmaskCoordFromAddr(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::HwlComputeXmaskAddrFromCoord
+*   Lib::HwlComputeXmaskAddrFromCoord
 *
 *   @brief
 *       Compute the address from an address of cmask (prior to si)
@@ -2311,7 +2317,7 @@ VOID AddrLib1::HwlComputeXmaskCoordFromAddr(
 *
 ****************************************************************************************************
 */
-UINT_64 AddrLib1::HwlComputeXmaskAddrFromCoord(
+UINT_64 Lib::HwlComputeXmaskAddrFromCoord(
     UINT_32        pitch,          ///< [in] pitch
     UINT_32        height,         ///< [in] height
     UINT_32        x,              ///< [in] x coord
@@ -2513,7 +2519,7 @@ UINT_64 AddrLib1::HwlComputeXmaskAddrFromCoord(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeSurfaceAddrFromCoordLinear
+*   Lib::ComputeSurfaceAddrFromCoordLinear
 *
 *   @brief
 *       Compute address from coord for linear surface
@@ -2523,7 +2529,7 @@ UINT_64 AddrLib1::HwlComputeXmaskAddrFromCoord(
 *
 ****************************************************************************************************
 */
-UINT_64 AddrLib1::ComputeSurfaceAddrFromCoordLinear(
+UINT_64 Lib::ComputeSurfaceAddrFromCoordLinear(
     UINT_32  x,              ///< [in] x coord
     UINT_32  y,              ///< [in] y coord
     UINT_32  slice,          ///< [in] slice/depth index
@@ -2551,7 +2557,7 @@ UINT_64 AddrLib1::ComputeSurfaceAddrFromCoordLinear(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeSurfaceCoordFromAddrLinear
+*   Lib::ComputeSurfaceCoordFromAddrLinear
 *
 *   @brief
 *       Compute the coord from an address of a linear surface
@@ -2560,7 +2566,7 @@ UINT_64 AddrLib1::ComputeSurfaceAddrFromCoordLinear(
 *       N/A
 ****************************************************************************************************
 */
-VOID AddrLib1::ComputeSurfaceCoordFromAddrLinear(
+VOID Lib::ComputeSurfaceCoordFromAddrLinear(
     UINT_64  addr,           ///< [in] address
     UINT_32  bitPosition,    ///< [in] bitPosition in a byte
     UINT_32  bpp,            ///< [in] bits per pixel
@@ -2584,7 +2590,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrLinear(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled
+*   Lib::ComputeSurfaceCoordFromAddrMicroTiled
 *
 *   @brief
 *       Compute the coord from an address of a micro tiled surface
@@ -2593,7 +2599,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrLinear(
 *       N/A
 ****************************************************************************************************
 */
-VOID AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled(
+VOID Lib::ComputeSurfaceCoordFromAddrMicroTiled(
     UINT_64         addr,               ///< [in] address
     UINT_32         bitPosition,        ///< [in] bitPosition in a byte
     UINT_32         bpp,                ///< [in] bits per pixel
@@ -2706,7 +2712,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputePipeFromAddr
+*   Lib::ComputePipeFromAddr
 *
 *   @brief
 *       Compute the pipe number from an address
@@ -2716,7 +2722,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled(
 *
 ****************************************************************************************************
 */
-UINT_32 AddrLib1::ComputePipeFromAddr(
+UINT_32 Lib::ComputePipeFromAddr(
     UINT_64 addr,        ///< [in] address
     UINT_32 numPipes     ///< [in] number of banks
     ) const
@@ -2746,7 +2752,7 @@ UINT_32 AddrLib1::ComputePipeFromAddr(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeMicroTileEquation
+*   Lib::ComputeMicroTileEquation
 *
 *   @brief
 *       Compute micro tile equation
@@ -2756,7 +2762,7 @@ UINT_32 AddrLib1::ComputePipeFromAddr(
 *
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputeMicroTileEquation(
+ADDR_E_RETURNCODE Lib::ComputeMicroTileEquation(
     UINT_32         log2BytesPP,    ///< [in] log2 of bytes per pixel
     AddrTileMode    tileMode,       ///< [in] tile mode
     AddrTileType    microTileType,  ///< [in] pixel order in display/non-display mode
@@ -2959,7 +2965,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeMicroTileEquation(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputePixelIndexWithinMicroTile
+*   Lib::ComputePixelIndexWithinMicroTile
 *
 *   @brief
 *       Compute the pixel index inside a micro tile of surface
@@ -2969,7 +2975,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeMicroTileEquation(
 *
 ****************************************************************************************************
 */
-UINT_32 AddrLib1::ComputePixelIndexWithinMicroTile(
+UINT_32 Lib::ComputePixelIndexWithinMicroTile(
     UINT_32         x,              ///< [in] x coord
     UINT_32         y,              ///< [in] y coord
     UINT_32         z,              ///< [in] slice/depth index
@@ -3174,7 +3180,7 @@ UINT_32 AddrLib1::ComputePixelIndexWithinMicroTile(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::AdjustPitchAlignment
+*   Lib::AdjustPitchAlignment
 *
 *   @brief
 *       Adjusts pitch alignment for flipping surface
@@ -3184,7 +3190,7 @@ UINT_32 AddrLib1::ComputePixelIndexWithinMicroTile(
 *
 ****************************************************************************************************
 */
-VOID AddrLib1::AdjustPitchAlignment(
+VOID Lib::AdjustPitchAlignment(
     ADDR_SURFACE_FLAGS  flags,      ///< [in] Surface flags
     UINT_32*            pPitchAlign ///< [out] Pointer to pitch alignment
     ) const
@@ -3204,7 +3210,7 @@ VOID AddrLib1::AdjustPitchAlignment(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::PadDimensions
+*   Lib::PadDimensions
 *
 *   @brief
 *       Helper function to pad dimensions
@@ -3214,7 +3220,7 @@ VOID AddrLib1::AdjustPitchAlignment(
 *
 ****************************************************************************************************
 */
-VOID AddrLib1::PadDimensions(
+VOID Lib::PadDimensions(
     AddrTileMode        tileMode,    ///< [in] tile mode
     UINT_32             bpp,         ///< [in] bits per pixel
     ADDR_SURFACE_FLAGS  flags,       ///< [in] surface flags
@@ -3310,7 +3316,7 @@ VOID AddrLib1::PadDimensions(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::HwlPreHandleBaseLvl3xPitch
+*   Lib::HwlPreHandleBaseLvl3xPitch
 *
 *   @brief
 *       Pre-handler of 3x pitch (96 bit) adjustment
@@ -3319,7 +3325,7 @@ VOID AddrLib1::PadDimensions(
 *       Expected pitch
 ****************************************************************************************************
 */
-UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
+UINT_32 Lib::HwlPreHandleBaseLvl3xPitch(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,        ///< [in] input
     UINT_32                                 expPitch    ///< [in] pitch
     ) const
@@ -3328,7 +3334,7 @@ UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
     //
     // If pitch is pre-multiplied by 3, we retrieve original one here to get correct miplevel size
     //
-    if (AddrElemLib::IsExpand3x(pIn->format) &&
+    if (ElemLib::IsExpand3x(pIn->format) &&
         pIn->mipLevel == 0 &&
         pIn->tileMode == ADDR_TM_LINEAR_ALIGNED)
     {
@@ -3341,7 +3347,7 @@ UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::HwlPostHandleBaseLvl3xPitch
+*   Lib::HwlPostHandleBaseLvl3xPitch
 *
 *   @brief
 *       Post-handler of 3x pitch adjustment
@@ -3350,7 +3356,7 @@ UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
 *       Expected pitch
 ****************************************************************************************************
 */
-UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
+UINT_32 Lib::HwlPostHandleBaseLvl3xPitch(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,        ///< [in] input
     UINT_32                                 expPitch    ///< [in] pitch
     ) const
@@ -3359,7 +3365,7 @@ UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
     // 96 bits surface of sub levels require element pitch of 32 bits instead
     // So we just return pitch in 32 bit pixels without timing 3
     //
-    if (AddrElemLib::IsExpand3x(pIn->format) &&
+    if (ElemLib::IsExpand3x(pIn->format) &&
         pIn->mipLevel == 0 &&
         pIn->tileMode == ADDR_TM_LINEAR_ALIGNED)
     {
@@ -3372,7 +3378,7 @@ UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::IsMacroTiled
+*   Lib::IsMacroTiled
 *
 *   @brief
 *       Check if the tile mode is macro tiled
@@ -3381,7 +3387,7 @@ UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
 *       TRUE if it is macro tiled (2D/2B/3D/3B)
 ****************************************************************************************************
 */
-BOOL_32 AddrLib1::IsMacroTiled(
+BOOL_32 Lib::IsMacroTiled(
     AddrTileMode tileMode)  ///< [in] tile mode
 {
    return ModeFlags[tileMode].isMacro;
@@ -3389,7 +3395,7 @@ BOOL_32 AddrLib1::IsMacroTiled(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::IsMacro3dTiled
+*   Lib::IsMacro3dTiled
 *
 *   @brief
 *       Check if the tile mode is 3D macro tiled
@@ -3398,7 +3404,7 @@ BOOL_32 AddrLib1::IsMacroTiled(
 *       TRUE if it is 3D macro tiled
 ****************************************************************************************************
 */
-BOOL_32 AddrLib1::IsMacro3dTiled(
+BOOL_32 Lib::IsMacro3dTiled(
     AddrTileMode tileMode)  ///< [in] tile mode
 {
     return ModeFlags[tileMode].isMacro3d;
@@ -3406,7 +3412,7 @@ BOOL_32 AddrLib1::IsMacro3dTiled(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::IsMicroTiled
+*   Lib::IsMicroTiled
 *
 *   @brief
 *       Check if the tile mode is micro tiled
@@ -3415,7 +3421,7 @@ BOOL_32 AddrLib1::IsMacro3dTiled(
 *       TRUE if micro tiled
 ****************************************************************************************************
 */
-BOOL_32 AddrLib1::IsMicroTiled(
+BOOL_32 Lib::IsMicroTiled(
     AddrTileMode tileMode)  ///< [in] tile mode
 {
     return ModeFlags[tileMode].isMicro;
@@ -3423,7 +3429,7 @@ BOOL_32 AddrLib1::IsMicroTiled(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::IsLinear
+*   Lib::IsLinear
 *
 *   @brief
 *       Check if the tile mode is linear
@@ -3432,7 +3438,7 @@ BOOL_32 AddrLib1::IsMicroTiled(
 *       TRUE if linear
 ****************************************************************************************************
 */
-BOOL_32 AddrLib1::IsLinear(
+BOOL_32 Lib::IsLinear(
     AddrTileMode tileMode)  ///< [in] tile mode
 {
     return ModeFlags[tileMode].isLinear;
@@ -3440,7 +3446,7 @@ BOOL_32 AddrLib1::IsLinear(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::IsPrtNoRotationTileMode
+*   Lib::IsPrtNoRotationTileMode
 *
 *   @brief
 *       Return TRUE if it is prt tile without rotation
@@ -3448,7 +3454,7 @@ BOOL_32 AddrLib1::IsLinear(
 *       This function just used by CI
 ****************************************************************************************************
 */
-BOOL_32 AddrLib1::IsPrtNoRotationTileMode(
+BOOL_32 Lib::IsPrtNoRotationTileMode(
     AddrTileMode tileMode)
 {
     return ModeFlags[tileMode].isPrtNoRotation;
@@ -3456,7 +3462,7 @@ BOOL_32 AddrLib1::IsPrtNoRotationTileMode(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::IsPrtTileMode
+*   Lib::IsPrtTileMode
 *
 *   @brief
 *       Return TRUE if it is prt tile
@@ -3464,7 +3470,7 @@ BOOL_32 AddrLib1::IsPrtNoRotationTileMode(
 *       This function just used by CI
 ****************************************************************************************************
 */
-BOOL_32 AddrLib1::IsPrtTileMode(
+BOOL_32 Lib::IsPrtTileMode(
     AddrTileMode tileMode)
 {
     return ModeFlags[tileMode].isPrt;
@@ -3472,7 +3478,7 @@ BOOL_32 AddrLib1::IsPrtTileMode(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeMipLevel
+*   Lib::ComputeMipLevel
 *
 *   @brief
 *       Compute mipmap level width/height/slices
@@ -3480,11 +3486,11 @@ BOOL_32 AddrLib1::IsPrtTileMode(
 *      N/A
 ****************************************************************************************************
 */
-VOID AddrLib1::ComputeMipLevel(
+VOID Lib::ComputeMipLevel(
     ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn ///< [in/out] Input structure
     ) const
 {
-    if (AddrElemLib::IsBlockCompressed(pIn->format))
+    if (ElemLib::IsBlockCompressed(pIn->format))
     {
         if (pIn->mipLevel == 0)
         {
@@ -3502,7 +3508,7 @@ VOID AddrLib1::ComputeMipLevel(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::OptimizeTileMode
+*   Lib::OptimizeTileMode
 *
 *   @brief
 *       Check if base level's tile mode can be optimized (degraded)
@@ -3510,7 +3516,7 @@ VOID AddrLib1::ComputeMipLevel(
 *       TRUE if degraded, also returns degraded tile mode (unchanged if not degraded)
 ****************************************************************************************************
 */
-BOOL_32 AddrLib1::OptimizeTileMode(
+BOOL_32 Lib::OptimizeTileMode(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,        ///< [in] Input structure for surface info
     AddrTileMode*                           pTileMode   ///< [out] Degraded tile mode
     ) const
@@ -3529,7 +3535,7 @@ BOOL_32 AddrLib1::OptimizeTileMode(
         // Check if linear mode is optimal
         if ((pIn->height == 1) &&
             (IsLinear(tileMode) == FALSE) &&
-            (AddrElemLib::IsBlockCompressed(pIn->format) == FALSE) &&
+            (ElemLib::IsBlockCompressed(pIn->format) == FALSE) &&
             (pIn->flags.depth == FALSE) &&
             (pIn->flags.stencil == FALSE) &&
             (m_configFlags.disableLinearOpt == FALSE) &&
@@ -3572,7 +3578,7 @@ BOOL_32 AddrLib1::OptimizeTileMode(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::DegradeLargeThickTile
+*   Lib::DegradeLargeThickTile
 *
 *   @brief
 *       Check if the thickness needs to be reduced if a tile is too large
@@ -3580,7 +3586,7 @@ BOOL_32 AddrLib1::OptimizeTileMode(
 *       The degraded tile mode (unchanged if not degraded)
 ****************************************************************************************************
 */
-AddrTileMode AddrLib1::DegradeLargeThickTile(
+AddrTileMode Lib::DegradeLargeThickTile(
     AddrTileMode tileMode,
     UINT_32 bpp) const
 {
@@ -3642,14 +3648,14 @@ AddrTileMode AddrLib1::DegradeLargeThickTile(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::PostComputeMipLevel
+*   Lib::PostComputeMipLevel
 *   @brief
 *       Compute MipLevel info (including level 0) after surface adjustment
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::PostComputeMipLevel(
+ADDR_E_RETURNCODE Lib::PostComputeMipLevel(
     ADDR_COMPUTE_SURFACE_INFO_INPUT*    pIn,   ///< [in/out] Input structure
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT*   pOut   ///< [out] Output structure
     ) const
@@ -3682,7 +3688,7 @@ ADDR_E_RETURNCODE AddrLib1::PostComputeMipLevel(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::HwlSetupTileCfg
+*   Lib::HwlSetupTileCfg
 *
 *   @brief
 *       Map tile index to tile setting.
@@ -3690,7 +3696,7 @@ ADDR_E_RETURNCODE AddrLib1::PostComputeMipLevel(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::HwlSetupTileCfg(
+ADDR_E_RETURNCODE Lib::HwlSetupTileCfg(
     UINT_32         bpp,              ///< Bits per pixel
     INT_32          index,            ///< [in] Tile index
     INT_32          macroModeIndex,   ///< [in] Index in macro tile mode table(CI)
@@ -3704,7 +3710,7 @@ ADDR_E_RETURNCODE AddrLib1::HwlSetupTileCfg(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::HwlGetPipes
+*   Lib::HwlGetPipes
 *
 *   @brief
 *       Get number pipes
@@ -3712,7 +3718,7 @@ ADDR_E_RETURNCODE AddrLib1::HwlSetupTileCfg(
 *       num pipes
 ****************************************************************************************************
 */
-UINT_32 AddrLib1::HwlGetPipes(
+UINT_32 Lib::HwlGetPipes(
     const ADDR_TILEINFO* pTileInfo    ///< [in] Tile info
     ) const
 {
@@ -3722,7 +3728,7 @@ UINT_32 AddrLib1::HwlGetPipes(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputeQbStereoInfo
+*   Lib::ComputeQbStereoInfo
 *
 *   @brief
 *       Get quad buffer stereo information
@@ -3730,7 +3736,7 @@ UINT_32 AddrLib1::HwlGetPipes(
 *       TRUE if no error
 ****************************************************************************************************
 */
-BOOL_32 AddrLib1::ComputeQbStereoInfo(
+BOOL_32 Lib::ComputeQbStereoInfo(
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut    ///< [in/out] updated pOut+pStereoInfo
     ) const
 {
@@ -3767,7 +3773,7 @@ BOOL_32 AddrLib1::ComputeQbStereoInfo(
 
 /**
 ****************************************************************************************************
-*   AddrLib1::ComputePrtInfo
+*   Lib::ComputePrtInfo
 *
 *   @brief
 *       Compute prt surface related info
@@ -3776,7 +3782,7 @@ BOOL_32 AddrLib1::ComputeQbStereoInfo(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE AddrLib1::ComputePrtInfo(
+ADDR_E_RETURNCODE Lib::ComputePrtInfo(
     const ADDR_PRT_INFO_INPUT*  pIn,
     ADDR_PRT_INFO_OUTPUT*       pOut) const
 {
@@ -3786,12 +3792,12 @@ ADDR_E_RETURNCODE AddrLib1::ComputePrtInfo(
 
     UINT_32     expandX = 1;
     UINT_32     expandY = 1;
-    AddrElemMode elemMode;
+    ElemMode    elemMode;
 
     UINT_32     bpp = GetElemLib()->GetBitsPerPixel(pIn->format,
-                                                &elemMode,
-                                                &expandX,
-                                                &expandY);
+                                                    &elemMode,
+                                                    &expandX,
+                                                    &expandY);
 
     if (bpp <8 || bpp == 24 || bpp == 48 || bpp == 96)
     {
@@ -3895,3 +3901,5 @@ ADDR_E_RETURNCODE AddrLib1::ComputePrtInfo(
     return returnCode;
 }
 
+} // V1
+} // Addr
diff --git a/src/amd/addrlib/core/addrlib1.h b/src/amd/addrlib/core/addrlib1.h
index 9751d1d4f17..7c19d102c16 100644
--- a/src/amd/addrlib/core/addrlib1.h
+++ b/src/amd/addrlib/core/addrlib1.h
@@ -27,7 +27,7 @@
 /**
 ****************************************************************************************************
 * @file  addrlib1.h
-* @brief Contains the AddrLib1 base class definition.
+* @brief Contains the Lib base class definition.
 ****************************************************************************************************
 */
 
@@ -36,13 +36,17 @@
 
 #include "addrlib.h"
 
+namespace Addr
+{
+namespace V1
+{
 
 /**
 ****************************************************************************************************
 * @brief Neutral enums that define bank swap size
 ****************************************************************************************************
 */
-enum AddrSampleSplitSize
+enum SampleSplitSize
 {
     ADDR_SAMPLESPLIT_1KB = 1024,
     ADDR_SAMPLESPLIT_2KB = 2048,
@@ -55,7 +59,7 @@ enum AddrSampleSplitSize
 * @brief Flags for AddrTileMode
 ****************************************************************************************************
 */
-struct AddrTileModeFlags
+struct TileModeFlags
 {
     UINT_32 thickness       : 4;
     UINT_32 isLinear        : 1;
@@ -72,12 +76,12 @@ struct AddrTileModeFlags
 * @brief This class contains asic independent address lib functionalities
 ****************************************************************************************************
 */
-class AddrLib1 : public AddrLib
+class Lib : public Addr::Lib
 {
 public:
-    virtual ~AddrLib1();
+    virtual ~Lib();
 
-    static AddrLib1* GetAddrLib1(
+    static Lib* GetLib(
         ADDR_HANDLE hLib);
 
     /// Returns tileIndex support
@@ -187,8 +191,8 @@ public:
         const ADDR_PRT_INFO_INPUT*  pIn,
         ADDR_PRT_INFO_OUTPUT*       pOut) const;
 protected:
-    AddrLib1();  // Constructor is protected
-    AddrLib1(const AddrClient* pClient);
+    Lib();  // Constructor is protected
+    Lib(const Client* pClient);
 
     /// Pure Virtual function for Hwl computing surface info
     virtual ADDR_E_RETURNCODE HwlComputeSurfaceInfo(
@@ -434,7 +438,7 @@ protected:
     //
     // Misc helper
     //
-    static const AddrTileModeFlags ModeFlags[ADDR_TM_COUNT];
+    static const TileModeFlags ModeFlags[ADDR_TM_COUNT];
 
     static UINT_32 Thickness(
         AddrTileMode tileMode);
@@ -495,10 +499,10 @@ protected:
 
 private:
     // Disallow the copy constructor
-    AddrLib1(const AddrLib1& a);
+    Lib(const Lib& a);
 
     // Disallow the assignment operator
-    AddrLib1& operator=(const AddrLib1& a);
+    Lib& operator=(const Lib& a);
 
     UINT_32 ComputeCmaskBaseAlign(
         ADDR_CMASK_FLAGS flags, ADDR_TILEINFO*  pTileInfo) const;
@@ -517,5 +521,8 @@ private:
         UINT_32 pipe, UINT_32 x) const;
 };
 
+} // V1
+} // Addr
+
 #endif
 
diff --git a/src/amd/addrlib/core/addrobject.cpp b/src/amd/addrlib/core/addrobject.cpp
index 2d86e033f13..0c5f81a5185 100644
--- a/src/amd/addrlib/core/addrobject.cpp
+++ b/src/amd/addrlib/core/addrobject.cpp
@@ -26,23 +26,26 @@
 
 /**
 ****************************************************************************************************
-* @file  addrobject.cpp
-* @brief Contains the AddrObject base class implementation.
+* @file  Object.cpp
+* @brief Contains the Object base class implementation.
 ****************************************************************************************************
 */
 
 #include "addrinterface.h"
 #include "addrobject.h"
 
+namespace Addr
+{
+
 /**
 ****************************************************************************************************
-*   AddrObject::AddrObject
+*   Object::Object
 *
 *   @brief
-*       Constructor for the AddrObject class.
+*       Constructor for the Object class.
 ****************************************************************************************************
 */
-AddrObject::AddrObject()
+Object::Object()
 {
     m_client.handle = NULL;
     m_client.callbacks.allocSysMem = NULL;
@@ -52,40 +55,40 @@ AddrObject::AddrObject()
 
 /**
 ****************************************************************************************************
-*   AddrObject::AddrObject
+*   Object::Object
 *
 *   @brief
-*       Constructor for the AddrObject class.
+*       Constructor for the Object class.
 ****************************************************************************************************
 */
-AddrObject::AddrObject(const AddrClient* pClient)
+Object::Object(const Client* pClient)
 {
     m_client = *pClient;
 }
 
 /**
 ****************************************************************************************************
-*   AddrObject::~AddrObject
+*   Object::~Object
 *
 *   @brief
-*       Destructor for the AddrObject class.
+*       Destructor for the Object class.
 ****************************************************************************************************
 */
-AddrObject::~AddrObject()
+Object::~Object()
 {
 }
 
 /**
 ****************************************************************************************************
-*   AddrObject::ClientAlloc
+*   Object::ClientAlloc
 *
 *   @brief
-*       Calls instanced allocSysMem inside AddrClient
+*       Calls instanced allocSysMem inside Client
 ****************************************************************************************************
 */
-VOID* AddrObject::ClientAlloc(
+VOID* Object::ClientAlloc(
     size_t             objSize,    ///< [in] Size to allocate
-    const AddrClient*  pClient)    ///< [in] Client pointer
+    const Client*  pClient)    ///< [in] Client pointer
 {
     VOID* pObjMem = NULL;
 
@@ -106,13 +109,13 @@ VOID* AddrObject::ClientAlloc(
 
 /**
 ****************************************************************************************************
-*   AddrObject::AddrMalloc
+*   Object::Alloc
 *
 *   @brief
 *       A wrapper of ClientAlloc
 ****************************************************************************************************
 */
-VOID* AddrObject::AddrMalloc(
+VOID* Object::Alloc(
     size_t objSize) const   ///< [in] Size to allocate
 {
     return ClientAlloc(objSize, &m_client);
@@ -120,15 +123,15 @@ VOID* AddrObject::AddrMalloc(
 
 /**
 ****************************************************************************************************
-*   AddrObject::ClientFree
+*   Object::ClientFree
 *
 *   @brief
-*       Calls freeSysMem inside AddrClient
+*       Calls freeSysMem inside Client
 ****************************************************************************************************
 */
-VOID AddrObject::ClientFree(
+VOID Object::ClientFree(
     VOID*              pObjMem,    ///< [in] User virtual address to free.
-    const AddrClient*  pClient)    ///< [in] Client pointer
+    const Client*  pClient)    ///< [in] Client pointer
 {
     if (pClient->callbacks.freeSysMem != NULL)
     {
@@ -147,13 +150,13 @@ VOID AddrObject::ClientFree(
 
 /**
 ****************************************************************************************************
-*   AddrObject::AddrFree
+*   Object::Free
 *
 *   @brief
 *       A wrapper of ClientFree
 ****************************************************************************************************
 */
-VOID AddrObject::AddrFree(
+VOID Object::Free(
     VOID* pObjMem) const                 ///< [in] User virtual address to free.
 {
     ClientFree(pObjMem, &m_client);
@@ -161,18 +164,18 @@ VOID AddrObject::AddrFree(
 
 /**
 ****************************************************************************************************
-*   AddrObject::operator new
+*   Object::operator new
 *
 *   @brief
-*       Allocates memory needed for AddrObject object. (with ADDR_CLIENT_HANDLE)
+*       Allocates memory needed for Object object. (with ADDR_CLIENT_HANDLE)
 *
 *   @return
 *       Returns NULL if unsuccessful.
 ****************************************************************************************************
 */
-VOID* AddrObject::operator new(
+VOID* Object::operator new(
     size_t             objSize,    ///< [in] Size to allocate
-    const AddrClient*  pClient)    ///< [in] Client pointer
+    const Client*  pClient)    ///< [in] Client pointer
 {
     return ClientAlloc(objSize, pClient);
 }
@@ -180,37 +183,37 @@ VOID* AddrObject::operator new(
 
 /**
 ****************************************************************************************************
-*   AddrObject::operator delete
+*   Object::operator delete
 *
 *   @brief
-*       Frees AddrObject object memory.
+*       Frees Object object memory.
 ****************************************************************************************************
 */
-VOID AddrObject::operator delete(
+VOID Object::operator delete(
     VOID* pObjMem,              ///< [in] User virtual address to free.
-    const AddrClient* pClient)  ///< [in] Client handle
+    const Client* pClient)  ///< [in] Client handle
 {
     ClientFree(pObjMem, pClient);
 }
 
 /**
 ****************************************************************************************************
-*   AddrObject::operator delete
+*   Object::operator delete
 *
 *   @brief
-*       Frees AddrObject object memory.
+*       Frees Object object memory.
 ****************************************************************************************************
 */
-VOID AddrObject::operator delete(
+VOID Object::operator delete(
     VOID* pObjMem)                  ///< [in] User virtual address to free.
 {
-    AddrObject* pObj = static_cast<AddrObject*>(pObjMem);
+    Object* pObj = static_cast<Object*>(pObjMem);
     ClientFree(pObjMem, &pObj->m_client);
 }
 
 /**
 ****************************************************************************************************
-*   AddrObject::DebugPrint
+*   Object::DebugPrint
 *
 *   @brief
 *       Print debug message
@@ -219,7 +222,7 @@ VOID AddrObject::operator delete(
 *       N/A
 ****************************************************************************************************
 */
-VOID AddrObject::DebugPrint(
+VOID Object::DebugPrint(
     const CHAR* pDebugString,     ///< [in] Debug string
     ...) const
 {
@@ -244,3 +247,4 @@ VOID AddrObject::DebugPrint(
 #endif
 }
 
+} // Addr
diff --git a/src/amd/addrlib/core/addrobject.h b/src/amd/addrlib/core/addrobject.h
index e3cf0afbc8f..c6483862b56 100644
--- a/src/amd/addrlib/core/addrobject.h
+++ b/src/amd/addrlib/core/addrobject.h
@@ -26,8 +26,8 @@
 
 /**
 ****************************************************************************************************
-* @file  addrobject.h
-* @brief Contains the AddrObject base class definition.
+* @file  Object.h
+* @brief Contains the Object base class definition.
 ****************************************************************************************************
 */
 
@@ -37,12 +37,15 @@
 #include "addrtypes.h"
 #include "addrcommon.h"
 
+namespace Addr
+{
+
 /**
 ****************************************************************************************************
 * @brief This structure contains client specific data
 ****************************************************************************************************
 */
-struct AddrClient
+struct Client
 {
     ADDR_CLIENT_HANDLE  handle;
     ADDR_CALLBACKS      callbacks;
@@ -52,38 +55,39 @@ struct AddrClient
 * @brief This class is the base class for all ADDR class objects.
 ****************************************************************************************************
 */
-class AddrObject
+class Object
 {
 public:
-    AddrObject();
-    AddrObject(const AddrClient* pClient);
-    virtual ~AddrObject();
+    Object();
+    Object(const Client* pClient);
+    virtual ~Object();
 
-    VOID* operator new(size_t size, const AddrClient* pClient);
-    VOID  operator delete(VOID* pObj, const AddrClient* pClient);
+    VOID* operator new(size_t size, const Client* pClient);
+    VOID  operator delete(VOID* pObj, const Client* pClient);
     VOID  operator delete(VOID* pObj);
-    VOID* AddrMalloc(size_t size) const;
-    VOID  AddrFree(VOID* pObj) const;
+    VOID* Alloc(size_t size) const;
+    VOID  Free(VOID* pObj) const;
 
     VOID DebugPrint(
         const CHAR* pDebugString,
         ...) const;
 
-    const AddrClient* GetClient() const {return &m_client;}
+    const Client* GetClient() const {return &m_client;}
 
 protected:
-    AddrClient m_client;
+    Client m_client;
 
 private:
-    static VOID* ClientAlloc(size_t size, const AddrClient* pClient);
-    static VOID  ClientFree(VOID* pObj, const AddrClient* pClient);
+    static VOID* ClientAlloc(size_t size, const Client* pClient);
+    static VOID  ClientFree(VOID* pObj, const Client* pClient);
 
     // disallow the copy constructor
-    AddrObject(const AddrObject& a);
+    Object(const Object& a);
 
     // disallow the assignment operator
-    AddrObject& operator=(const AddrObject& a);
+    Object& operator=(const Object& a);
 };
 
+} // Addr
 #endif
 
diff --git a/src/amd/addrlib/r800/ciaddrlib.cpp b/src/amd/addrlib/r800/ciaddrlib.cpp
index ebaf3e5623b..839a26833a6 100644
--- a/src/amd/addrlib/r800/ciaddrlib.cpp
+++ b/src/amd/addrlib/r800/ciaddrlib.cpp
@@ -27,7 +27,7 @@
 /**
 ****************************************************************************************************
 * @file  ciaddrlib.cpp
-* @brief Contains the implementation for the CiAddrLib class.
+* @brief Contains the implementation for the CiLib class.
 ****************************************************************************************************
 */
 
@@ -48,9 +48,31 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+namespace Addr
+{
+
+/**
+****************************************************************************************************
+*   CiHwlInit
+*
+*   @brief
+*       Creates an CiLib object.
+*
+*   @return
+*       Returns an CiLib object pointer.
+****************************************************************************************************
+*/
+Lib* CiHwlInit(const Client* pClient)
+{
+    return V1::CiLib::CreateObj(pClient);
+}
+
+namespace V1
+{
+
 /**
 ****************************************************************************************************
-*   AddrMask
+*   Mask
 *
 *   @brief
 *       Gets a mask of "width"
@@ -58,7 +80,7 @@
 *       Bit mask
 ****************************************************************************************************
 */
-static UINT_64 AddrMask(
+static UINT_64 Mask(
     UINT_32 width)  ///< Width of bits
 {
     UINT_64 ret;
@@ -76,7 +98,7 @@ static UINT_64 AddrMask(
 
 /**
 ****************************************************************************************************
-*   AddrGetBits
+*   GetBits
 *
 *   @brief
 *       Gets bits within a range of [msb, lsb]
@@ -84,7 +106,7 @@ static UINT_64 AddrMask(
 *       Bits of this range
 ****************************************************************************************************
 */
-static UINT_64 AddrGetBits(
+static UINT_64 GetBits(
     UINT_64 bits,   ///< Source bits
     UINT_32 msb,    ///< Most signicant bit
     UINT_32 lsb)    ///< Least signicant bit
@@ -93,14 +115,14 @@ static UINT_64 AddrGetBits(
 
     if (msb >= lsb)
     {
-        ret = (bits >> lsb) & (AddrMask(1 + msb - lsb));
+        ret = (bits >> lsb) & (Mask(1 + msb - lsb));
     }
     return ret;
 }
 
 /**
 ****************************************************************************************************
-*   AddrRemoveBits
+*   RemoveBits
 *
 *   @brief
 *       Removes bits within the range of [msb, lsb]
@@ -108,7 +130,7 @@ static UINT_64 AddrGetBits(
 *       Modified bits
 ****************************************************************************************************
 */
-static UINT_64 AddrRemoveBits(
+static UINT_64 RemoveBits(
     UINT_64 bits,   ///< Source bits
     UINT_32 msb,    ///< Most signicant bit
     UINT_32 lsb)    ///< Least signicant bit
@@ -117,15 +139,15 @@ static UINT_64 AddrRemoveBits(
 
     if (msb >= lsb)
     {
-        ret = AddrGetBits(bits, lsb - 1, 0) // low bits
-            | (AddrGetBits(bits, 8 * sizeof(bits) - 1, msb + 1) << lsb); //high bits
+        ret = GetBits(bits, lsb - 1, 0) // low bits
+            | (GetBits(bits, 8 * sizeof(bits) - 1, msb + 1) << lsb); //high bits
     }
     return ret;
 }
 
 /**
 ****************************************************************************************************
-*   AddrInsertBits
+*   InsertBits
 *
 *   @brief
 *       Inserts new bits into the range of [msb, lsb]
@@ -133,7 +155,7 @@ static UINT_64 AddrRemoveBits(
 *       Modified bits
 ****************************************************************************************************
 */
-static UINT_64 AddrInsertBits(
+static UINT_64 InsertBits(
     UINT_64 bits,       ///< Source bits
     UINT_64 newBits,    ///< New bits to be inserted
     UINT_32 msb,        ///< Most signicant bit
@@ -143,41 +165,25 @@ static UINT_64 AddrInsertBits(
 
     if (msb >= lsb)
     {
-        ret = AddrGetBits(bits, lsb - 1, 0) // old low bitss
-             | (AddrGetBits(newBits, msb - lsb, 0) << lsb) //new bits
-             | (AddrGetBits(bits, 8 * sizeof(bits) - 1, lsb) << (msb + 1)); //old high bits
+        ret = GetBits(bits, lsb - 1, 0) // old low bitss
+             | (GetBits(newBits, msb - lsb, 0) << lsb) //new bits
+             | (GetBits(bits, 8 * sizeof(bits) - 1, lsb) << (msb + 1)); //old high bits
     }
     return ret;
 }
 
-
-/**
-****************************************************************************************************
-*   AddrCiHwlInit
-*
-*   @brief
-*       Creates an CiAddrLib object.
-*
-*   @return
-*       Returns an CiAddrLib object pointer.
-****************************************************************************************************
-*/
-AddrLib* AddrCIHwlInit(const AddrClient* pClient)
-{
-    return CiAddrLib::CreateObj(pClient);
-}
-
 /**
 ****************************************************************************************************
-*   CiAddrLib::CiAddrLib
+*   CiLib::CiLib
 *
 *   @brief
 *       Constructor
 *
 ****************************************************************************************************
 */
-CiAddrLib::CiAddrLib(const AddrClient* pClient) :
-    SiAddrLib(pClient),
+CiLib::CiLib(const Client* pClient)
+    :
+    SiLib(pClient),
     m_noOfMacroEntries(0),
     m_allowNonDispThickModes(FALSE)
 {
@@ -187,19 +193,19 @@ CiAddrLib::CiAddrLib(const AddrClient* pClient) :
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::~CiAddrLib
+*   CiLib::~CiLib
 *
 *   @brief
 *       Destructor
 ****************************************************************************************************
 */
-CiAddrLib::~CiAddrLib()
+CiLib::~CiLib()
 {
 }
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlComputeDccInfo
+*   CiLib::HwlComputeDccInfo
 *
 *   @brief
 *       Compute DCC key size, base alignment
@@ -207,7 +213,7 @@ CiAddrLib::~CiAddrLib()
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE CiAddrLib::HwlComputeDccInfo(
+ADDR_E_RETURNCODE CiLib::HwlComputeDccInfo(
     const ADDR_COMPUTE_DCCINFO_INPUT*  pIn,
     ADDR_COMPUTE_DCCINFO_OUTPUT*       pOut) const
 {
@@ -281,7 +287,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeDccInfo(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlComputeCmaskAddrFromCoord
+*   CiLib::HwlComputeCmaskAddrFromCoord
 *
 *   @brief
 *       Compute tc compatible Cmask address from fmask ram address
@@ -290,7 +296,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeDccInfo(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE CiAddrLib::HwlComputeCmaskAddrFromCoord(
+ADDR_E_RETURNCODE CiLib::HwlComputeCmaskAddrFromCoord(
     const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*  pIn,  ///< [in] fmask addr/bpp/tile input
     ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT*       pOut  ///< [out] cmask address
     ) const
@@ -325,7 +331,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeCmaskAddrFromCoord(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlComputeHtileAddrFromCoord
+*   CiLib::HwlComputeHtileAddrFromCoord
 *
 *   @brief
 *       Compute tc compatible Htile address from depth/stencil address
@@ -334,7 +340,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeCmaskAddrFromCoord(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE CiAddrLib::HwlComputeHtileAddrFromCoord(
+ADDR_E_RETURNCODE CiLib::HwlComputeHtileAddrFromCoord(
     const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*  pIn,  ///< [in] depth/stencil addr/bpp/tile input
     ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT*       pOut  ///< [out] htile address
     ) const
@@ -369,19 +375,19 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeHtileAddrFromCoord(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlConvertChipFamily
+*   CiLib::HwlConvertChipFamily
 *
 *   @brief
-*       Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
+*       Convert familyID defined in atiid.h to ChipFamily and set m_chipFamily/m_chipRevision
 *   @return
-*       AddrChipFamily
+*       ChipFamily
 ****************************************************************************************************
 */
-AddrChipFamily CiAddrLib::HwlConvertChipFamily(
+ChipFamily CiLib::HwlConvertChipFamily(
     UINT_32 uChipFamily,        ///< [in] chip family defined in atiih.h
     UINT_32 uChipRevision)      ///< [in] chip revision defined in "asic_family"_id.h
 {
-    AddrChipFamily family = ADDR_CHIP_FAMILY_CI;
+    ChipFamily family = ADDR_CHIP_FAMILY_CI;
 
     switch (uChipFamily)
     {
@@ -419,7 +425,7 @@ AddrChipFamily CiAddrLib::HwlConvertChipFamily(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlInitGlobalParams
+*   CiLib::HwlInitGlobalParams
 *
 *   @brief
 *       Initializes global parameters
@@ -429,7 +435,7 @@ AddrChipFamily CiAddrLib::HwlConvertChipFamily(
 *
 ****************************************************************************************************
 */
-BOOL_32 CiAddrLib::HwlInitGlobalParams(
+BOOL_32 CiLib::HwlInitGlobalParams(
     const ADDR_CREATE_INPUT* pCreateIn) ///< [in] create input
 {
     BOOL_32  valid = TRUE;
@@ -492,7 +498,7 @@ BOOL_32 CiAddrLib::HwlInitGlobalParams(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlPostCheckTileIndex
+*   CiLib::HwlPostCheckTileIndex
 *
 *   @brief
 *       Map a tile setting to index if curIndex is invalid, otherwise check if curIndex matches
@@ -501,7 +507,7 @@ BOOL_32 CiAddrLib::HwlInitGlobalParams(
 *       Tile index.
 ****************************************************************************************************
 */
-INT_32 CiAddrLib::HwlPostCheckTileIndex(
+INT_32 CiLib::HwlPostCheckTileIndex(
     const ADDR_TILEINFO* pInfo,     ///< [in] Tile Info
     AddrTileMode         mode,      ///< [in] Tile mode
     AddrTileType         type,      ///< [in] Tile type
@@ -583,7 +589,7 @@ INT_32 CiAddrLib::HwlPostCheckTileIndex(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlSetupTileCfg
+*   CiLib::HwlSetupTileCfg
 *
 *   @brief
 *       Map tile index to tile setting.
@@ -591,7 +597,7 @@ INT_32 CiAddrLib::HwlPostCheckTileIndex(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE CiAddrLib::HwlSetupTileCfg(
+ADDR_E_RETURNCODE CiLib::HwlSetupTileCfg(
     UINT_32         bpp,            ///< [in] Bits per pixel
     INT_32          index,          ///< [in] Tile index
     INT_32          macroModeIndex, ///< [in] Index in macro tile mode table(CI)
@@ -620,7 +626,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlSetupTileCfg(
         }
         else
         {
-            const AddrTileConfig* pCfgTable = GetTileSetting(index);
+            const TileConfig* pCfgTable = GetTileSetting(index);
 
             if (pInfo != NULL)
             {
@@ -682,15 +688,15 @@ ADDR_E_RETURNCODE CiAddrLib::HwlSetupTileCfg(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlComputeSurfaceInfo
+*   CiLib::HwlComputeSurfaceInfo
 *
 *   @brief
-*       Entry of ci's ComputeSurfaceInfo
+*       Entry of CI's ComputeSurfaceInfo
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE CiAddrLib::HwlComputeSurfaceInfo(
+ADDR_E_RETURNCODE CiLib::HwlComputeSurfaceInfo(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,    ///< [in] input structure
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut    ///< [out] output structure
     ) const
@@ -704,7 +710,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeSurfaceInfo(
     // Pass tcCompatible flag from input to output; and turn off it if tile split occurs
     pOut->tcCompatible = pIn->flags.tcCompatible;
 
-    ADDR_E_RETURNCODE retCode = SiAddrLib::HwlComputeSurfaceInfo(pIn,pOut);
+    ADDR_E_RETURNCODE retCode = SiLib::HwlComputeSurfaceInfo(pIn,pOut);
 
     if (pOut->macroModeIndex == TileIndexNoMacroIndex)
     {
@@ -716,14 +722,14 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeSurfaceInfo(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlFmaskSurfaceInfo
+*   CiLib::HwlFmaskSurfaceInfo
 *   @brief
 *       Entry of r800's ComputeFmaskInfo
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE CiAddrLib::HwlComputeFmaskInfo(
+ADDR_E_RETURNCODE CiLib::HwlComputeFmaskInfo(
     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,   ///< [in] input structure
     ADDR_COMPUTE_FMASK_INFO_OUTPUT*         pOut   ///< [out] output structure
     )
@@ -803,7 +809,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeFmaskInfo(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlFmaskPreThunkSurfInfo
+*   CiLib::HwlFmaskPreThunkSurfInfo
 *
 *   @brief
 *       Some preparation before thunking a ComputeSurfaceInfo call for Fmask
@@ -811,7 +817,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeFmaskInfo(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-VOID CiAddrLib::HwlFmaskPreThunkSurfInfo(
+VOID CiLib::HwlFmaskPreThunkSurfInfo(
     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pFmaskIn,   ///< [in] Input of fmask info
     const ADDR_COMPUTE_FMASK_INFO_OUTPUT*   pFmaskOut,  ///< [in] Output of fmask info
     ADDR_COMPUTE_SURFACE_INFO_INPUT*        pSurfIn,    ///< [out] Input of thunked surface info
@@ -824,7 +830,7 @@ VOID CiAddrLib::HwlFmaskPreThunkSurfInfo(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlFmaskPostThunkSurfInfo
+*   CiLib::HwlFmaskPostThunkSurfInfo
 *
 *   @brief
 *       Copy hwl extra field after calling thunked ComputeSurfaceInfo
@@ -832,7 +838,7 @@ VOID CiAddrLib::HwlFmaskPreThunkSurfInfo(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-VOID CiAddrLib::HwlFmaskPostThunkSurfInfo(
+VOID CiLib::HwlFmaskPostThunkSurfInfo(
     const ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pSurfOut,   ///< [in] Output of surface info
     ADDR_COMPUTE_FMASK_INFO_OUTPUT* pFmaskOut           ///< [out] Output of fmask info
     ) const
@@ -843,7 +849,7 @@ VOID CiAddrLib::HwlFmaskPostThunkSurfInfo(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlDegradeThickTileMode
+*   CiLib::HwlDegradeThickTileMode
 *
 *   @brief
 *       Degrades valid tile mode for thick modes if needed
@@ -852,7 +858,7 @@ VOID CiAddrLib::HwlFmaskPostThunkSurfInfo(
 *       Suitable tile mode
 ****************************************************************************************************
 */
-AddrTileMode CiAddrLib::HwlDegradeThickTileMode(
+AddrTileMode CiLib::HwlDegradeThickTileMode(
     AddrTileMode        baseTileMode,   ///< [in] base tile mode
     UINT_32             numSlices,      ///< [in] current number of slices
     UINT_32*            pBytesPerTile   ///< [in/out] pointer to bytes per slice
@@ -863,7 +869,7 @@ AddrTileMode CiAddrLib::HwlDegradeThickTileMode(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlOverrideTileMode
+*   CiLib::HwlOverrideTileMode
 *
 *   @brief
 *       Override THICK to THIN, for specific formats on CI
@@ -873,7 +879,7 @@ AddrTileMode CiAddrLib::HwlDegradeThickTileMode(
 *
 ****************************************************************************************************
 */
-VOID CiAddrLib::HwlOverrideTileMode(
+VOID CiLib::HwlOverrideTileMode(
     ADDR_COMPUTE_SURFACE_INFO_INPUT*    pInOut      ///< [in/out] input output structure
     ) const
 {
@@ -1024,7 +1030,7 @@ VOID CiAddrLib::HwlOverrideTileMode(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlSelectTileMode
+*   CiLib::HwlSelectTileMode
 *
 *   @brief
 *       Select tile modes.
@@ -1034,7 +1040,7 @@ VOID CiAddrLib::HwlOverrideTileMode(
 *
 ****************************************************************************************************
 */
-VOID CiAddrLib::HwlSelectTileMode(
+VOID CiLib::HwlSelectTileMode(
     ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut     ///< [in/out] input output structure
     ) const
 {
@@ -1120,13 +1126,13 @@ VOID CiAddrLib::HwlSelectTileMode(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlSetupTileInfo
+*   CiLib::HwlSetupTileInfo
 *
 *   @brief
 *       Setup default value of tile info for SI
 ****************************************************************************************************
 */
-VOID CiAddrLib::HwlSetupTileInfo(
+VOID CiLib::HwlSetupTileInfo(
     AddrTileMode                        tileMode,       ///< [in] Tile mode
     ADDR_SURFACE_FLAGS                  flags,          ///< [in] Surface type flags
     UINT_32                             bpp,            ///< [in] Bits per pixel
@@ -1453,7 +1459,7 @@ VOID CiAddrLib::HwlSetupTileInfo(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::ReadGbTileMode
+*   CiLib::ReadGbTileMode
 *
 *   @brief
 *       Convert GB_TILE_MODE HW value to ADDR_TILE_CONFIG.
@@ -1461,9 +1467,9 @@ VOID CiAddrLib::HwlSetupTileInfo(
 *       NA.
 ****************************************************************************************************
 */
-VOID CiAddrLib::ReadGbTileMode(
-    UINT_32             regValue,   ///< [in] GB_TILE_MODE register
-    AddrTileConfig*     pCfg        ///< [out] output structure
+VOID CiLib::ReadGbTileMode(
+    UINT_32       regValue,   ///< [in] GB_TILE_MODE register
+    TileConfig*   pCfg        ///< [out] output structure
     ) const
 {
     GB_TILE_MODE gbTileMode;
@@ -1529,7 +1535,7 @@ VOID CiAddrLib::ReadGbTileMode(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::InitTileSettingTable
+*   CiLib::InitTileSettingTable
 *
 *   @brief
 *       Initialize the ADDR_TILE_CONFIG table.
@@ -1537,7 +1543,7 @@ VOID CiAddrLib::ReadGbTileMode(
 *       TRUE if tile table is correctly initialized
 ****************************************************************************************************
 */
-BOOL_32 CiAddrLib::InitTileSettingTable(
+BOOL_32 CiLib::InitTileSettingTable(
     const UINT_32*  pCfg,           ///< [in] Pointer to table of tile configs
     UINT_32         noOfEntries     ///< [in] Numbe of entries in the table above
     )
@@ -1598,7 +1604,7 @@ BOOL_32 CiAddrLib::InitTileSettingTable(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::ReadGbMacroTileCfg
+*   CiLib::ReadGbMacroTileCfg
 *
 *   @brief
 *       Convert GB_MACRO_TILE_CFG HW value to ADDR_TILE_CONFIG.
@@ -1606,7 +1612,7 @@ BOOL_32 CiAddrLib::InitTileSettingTable(
 *       NA.
 ****************************************************************************************************
 */
-VOID CiAddrLib::ReadGbMacroTileCfg(
+VOID CiLib::ReadGbMacroTileCfg(
     UINT_32             regValue,   ///< [in] GB_MACRO_TILE_MODE register
     ADDR_TILEINFO*      pCfg        ///< [out] output structure
     ) const
@@ -1622,7 +1628,7 @@ VOID CiAddrLib::ReadGbMacroTileCfg(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::InitMacroTileCfgTable
+*   CiLib::InitMacroTileCfgTable
 *
 *   @brief
 *       Initialize the ADDR_MACRO_TILE_CONFIG table.
@@ -1630,7 +1636,7 @@ VOID CiAddrLib::ReadGbMacroTileCfg(
 *       TRUE if macro tile table is correctly initialized
 ****************************************************************************************************
 */
-BOOL_32 CiAddrLib::InitMacroTileCfgTable(
+BOOL_32 CiLib::InitMacroTileCfgTable(
     const UINT_32*  pCfg,           ///< [in] Pointer to table of tile configs
     UINT_32         noOfMacroEntries     ///< [in] Numbe of entries in the table above
     )
@@ -1669,7 +1675,7 @@ BOOL_32 CiAddrLib::InitMacroTileCfgTable(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlComputeMacroModeIndex
+*   CiLib::HwlComputeMacroModeIndex
 *
 *   @brief
 *       Computes macro tile mode index
@@ -1677,7 +1683,7 @@ BOOL_32 CiAddrLib::InitMacroTileCfgTable(
 *       TRUE if macro tile table is correctly initialized
 ****************************************************************************************************
 */
-INT_32 CiAddrLib::HwlComputeMacroModeIndex(
+INT_32 CiLib::HwlComputeMacroModeIndex(
     INT_32              tileIndex,      ///< [in] Tile mode index
     ADDR_SURFACE_FLAGS  flags,          ///< [in] Surface flags
     UINT_32             bpp,            ///< [in] Bit per pixel
@@ -1769,7 +1775,7 @@ INT_32 CiAddrLib::HwlComputeMacroModeIndex(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlComputeTileDataWidthAndHeightLinear
+*   CiLib::HwlComputeTileDataWidthAndHeightLinear
 *
 *   @brief
 *       Compute the squared cache shape for per-tile data (CMASK and HTILE) for linear layout
@@ -1781,7 +1787,7 @@ INT_32 CiAddrLib::HwlComputeMacroModeIndex(
 *       MacroWidth and macroHeight are measured in pixels
 ****************************************************************************************************
 */
-VOID CiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
+VOID CiLib::HwlComputeTileDataWidthAndHeightLinear(
     UINT_32*        pMacroWidth,     ///< [out] macro tile width
     UINT_32*        pMacroHeight,    ///< [out] macro tile height
     UINT_32         bpp,             ///< [in] bits per pixel
@@ -1814,7 +1820,7 @@ VOID CiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlComputeMetadataNibbleAddress
+*   CiLib::HwlComputeMetadataNibbleAddress
 *
 *   @brief
 *        calculate meta data address based on input information
@@ -1835,7 +1841,7 @@ VOID CiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
 *
 ****************************************************************************************************
 */
-UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
+UINT_64 CiLib::HwlComputeMetadataNibbleAddress(
     UINT_64 uncompressedDataByteAddress,
     UINT_64 dataBaseByteAddress,
     UINT_64 metadataBaseByteAddress,
@@ -1883,7 +1889,7 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
     UINT_32 lsb = pipeBits + pipeInterleaveBits;
     UINT_32 msb = bankBits - 1 + lsb;
 
-    UINT_64 bankDataBits = AddrGetBits(offset, msb, lsb);
+    UINT_64 bankDataBits = GetBits(offset, msb, lsb);
 
     ///--------------------------------------------------------------------------------------------
     /// Save pipe data bits
@@ -1891,7 +1897,7 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
     lsb = pipeInterleaveBits;
     msb = pipeBits - 1 + lsb;
 
-    UINT_64 pipeDataBits = AddrGetBits(offset, msb, lsb);
+    UINT_64 pipeDataBits = GetBits(offset, msb, lsb);
 
     ///--------------------------------------------------------------------------------------------
     /// Remove pipe and bank bits
@@ -1899,7 +1905,7 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
     lsb = pipeInterleaveBits;
     msb = dataMacrotileBits - 1;
 
-    UINT_64 offsetWithoutPipeBankBits = AddrRemoveBits(offset, msb, lsb);
+    UINT_64 offsetWithoutPipeBankBits = RemoveBits(offset, msb, lsb);
 
     ADDR_ASSERT((0 != blockByteSize));
     UINT_64 blockInBankpipe = offsetWithoutPipeBankBits / blockByteSize;
@@ -1917,7 +1923,7 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
     }
     msb = bankBits - 1 + lsb;
 
-    UINT_64 blockInBankpipeWithBankBits = AddrInsertBits(blockInBankpipe, bankDataBits, msb, lsb);
+    UINT_64 blockInBankpipeWithBankBits = InsertBits(blockInBankpipe, bankDataBits, msb, lsb);
 
     /// NOTE *2 because we are converting to Nibble address in this step
     UINT_64 metaAddressInPipe = blockInBankpipeWithBankBits * 2 * metadataBitSize / 8;
@@ -1928,14 +1934,14 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
     ///--------------------------------------------------------------------------------------------
     lsb = pipeInterleaveBits + 1; ///<+1 due to Nibble address now gives interleave bits extra lsb.
     msb = pipeBits - 1 + lsb;
-    UINT_64 metadataAddress = AddrInsertBits(metaAddressInPipe, pipeDataBits, msb, lsb);
+    UINT_64 metadataAddress = InsertBits(metaAddressInPipe, pipeDataBits, msb, lsb);
 
     return metadataAddress;
 }
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlPadDimensions
+*   CiLib::HwlPadDimensions
 *
 *   @brief
 *       Helper function to pad dimensions
@@ -1945,7 +1951,7 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
 *
 ****************************************************************************************************
 */
-VOID CiAddrLib::HwlPadDimensions(
+VOID CiLib::HwlPadDimensions(
     AddrTileMode        tileMode,    ///< [in] tile mode
     UINT_32             bpp,         ///< [in] bits per pixel
     ADDR_SURFACE_FLAGS  flags,       ///< [in] surface flags
@@ -2021,7 +2027,7 @@ VOID CiAddrLib::HwlPadDimensions(
 
 /**
 ****************************************************************************************************
-*   CiAddrLib::HwlGetMaxAlignments
+*   CiLib::HwlGetMaxAlignments
 *
 *   @brief
 *       Gets maximum alignments
@@ -2029,7 +2035,7 @@ VOID CiAddrLib::HwlPadDimensions(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE CiAddrLib::HwlGetMaxAlignments(
+ADDR_E_RETURNCODE CiLib::HwlGetMaxAlignments(
     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut    ///< [out] output structure
     ) const
 {
@@ -2060,4 +2066,5 @@ ADDR_E_RETURNCODE CiAddrLib::HwlGetMaxAlignments(
     return ADDR_OK;
 }
 
-
+} // V1
+} // Addr
diff --git a/src/amd/addrlib/r800/ciaddrlib.h b/src/amd/addrlib/r800/ciaddrlib.h
index 69ede03f51c..438790a5895 100644
--- a/src/amd/addrlib/r800/ciaddrlib.h
+++ b/src/amd/addrlib/r800/ciaddrlib.h
@@ -27,7 +27,7 @@
 /**
 ****************************************************************************************************
 * @file  ciaddrlib.h
-* @brief Contains the CiAddrLib class definition.
+* @brief Contains the CiLib class definition.
 ****************************************************************************************************
 */
 
@@ -37,6 +37,11 @@
 #include "addrlib1.h"
 #include "siaddrlib.h"
 
+namespace Addr
+{
+namespace V1
+{
+
 /**
 ****************************************************************************************************
 * @brief CI specific settings structure.
@@ -74,18 +79,18 @@ struct CIChipSettings
 *        function set.
 ****************************************************************************************************
 */
-class CiAddrLib : public SiAddrLib
+class CiLib : public SiLib
 {
 public:
-    /// Creates CiAddrLib object
-    static AddrLib* CreateObj(const AddrClient* pClient)
+    /// Creates CiLib object
+    static Addr::Lib* CreateObj(const Client* pClient)
     {
-        return new(pClient) CiAddrLib(pClient);
+        return new(pClient) CiLib(pClient);
     }
 
 private:
-    CiAddrLib(const AddrClient* pClient);
-    virtual ~CiAddrLib();
+    CiLib(const Client* pClient);
+    virtual ~CiLib();
 
 protected:
 
@@ -98,7 +103,7 @@ protected:
         const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn,
         ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut);
 
-    virtual AddrChipFamily HwlConvertChipFamily(
+    virtual ChipFamily HwlConvertChipFamily(
         UINT_32 uChipFamily, UINT_32 uChipRevision);
 
     virtual BOOL_32 HwlInitGlobalParams(
@@ -117,7 +122,7 @@ protected:
         ADDR_TILEINFO* pTileInfo, AddrTileMode* pTileMode = NULL, AddrTileType* pTileType = NULL
         ) const;
 
-    // Sub-hwl interface - defined in EgBasedAddrLib
+    // Sub-hwl interface - defined in EgBasedLib
     virtual VOID HwlSetupTileInfo(
         AddrTileMode tileMode, ADDR_SURFACE_FLAGS flags,
         UINT_32 bpp, UINT_32 pitch, UINT_32 height, UINT_32 numSamples,
@@ -167,7 +172,7 @@ protected:
 
 private:
     VOID ReadGbTileMode(
-        UINT_32 regValue, AddrTileConfig* pCfg) const;
+        UINT_32 regValue, TileConfig* pCfg) const;
 
     VOID ReadGbMacroTileCfg(
         UINT_32 regValue, ADDR_TILEINFO* pCfg) const;
@@ -198,6 +203,9 @@ private:
     CIChipSettings          m_settings;
 };
 
+} // V1
+} // Addr
+
 #endif
 
 
diff --git a/src/amd/addrlib/r800/egbaddrlib.cpp b/src/amd/addrlib/r800/egbaddrlib.cpp
index 393557741bc..5de3f996f08 100644
--- a/src/amd/addrlib/r800/egbaddrlib.cpp
+++ b/src/amd/addrlib/r800/egbaddrlib.cpp
@@ -27,15 +27,20 @@
 /**
 ****************************************************************************************************
 * @file  egbaddrlib.cpp
-* @brief Contains the EgBasedAddrLib class implementation
+* @brief Contains the EgBasedLib class implementation
 ****************************************************************************************************
 */
 
 #include "egbaddrlib.h"
 
+namespace Addr
+{
+namespace V1
+{
+
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::EgBasedAddrLib
+*   EgBasedLib::EgBasedLib
 *
 *   @brief
 *       Constructor
@@ -44,8 +49,8 @@
 *
 ****************************************************************************************************
 */
-EgBasedAddrLib::EgBasedAddrLib(const AddrClient* pClient) :
-    AddrLib1(pClient),
+EgBasedLib::EgBasedLib(const Client* pClient) :
+    Lib(pClient),
     m_ranks(0),
     m_logicalBanks(0),
     m_bankInterleave(1)
@@ -54,19 +59,19 @@ EgBasedAddrLib::EgBasedAddrLib(const AddrClient* pClient) :
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::~EgBasedAddrLib
+*   EgBasedLib::~EgBasedLib
 *
 *   @brief
 *       Destructor
 ****************************************************************************************************
 */
-EgBasedAddrLib::~EgBasedAddrLib()
+EgBasedLib::~EgBasedLib()
 {
 }
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::DispatchComputeSurfaceInfo
+*   EgBasedLib::DispatchComputeSurfaceInfo
 *
 *   @brief
 *       Compute surface sizes include padded pitch,height,slices,total size in bytes,
@@ -77,7 +82,7 @@ EgBasedAddrLib::~EgBasedAddrLib()
 *       TRUE if no error occurs
 ****************************************************************************************************
 */
-BOOL_32 EgBasedAddrLib::DispatchComputeSurfaceInfo(
+BOOL_32 EgBasedLib::DispatchComputeSurfaceInfo(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,    ///< [in] input structure
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut    ///< [out] output structure
     ) const
@@ -198,7 +203,7 @@ BOOL_32 EgBasedAddrLib::DispatchComputeSurfaceInfo(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeSurfaceInfoLinear
+*   EgBasedLib::ComputeSurfaceInfoLinear
 *
 *   @brief
 *       Compute linear surface sizes include padded pitch, height, slices, total size in
@@ -209,7 +214,7 @@ BOOL_32 EgBasedAddrLib::DispatchComputeSurfaceInfo(
 *       TRUE if no error occurs
 ****************************************************************************************************
 */
-BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoLinear(
+BOOL_32 EgBasedLib::ComputeSurfaceInfoLinear(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,    ///< [in] Input structure
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut,   ///< [out] Output structure
     UINT_32                                 padDims ///< [in] Dimensions to padd
@@ -293,7 +298,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoLinear(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeSurfaceInfoMicroTiled
+*   EgBasedLib::ComputeSurfaceInfoMicroTiled
 *
 *   @brief
 *       Compute 1D/Micro Tiled surface sizes include padded pitch, height, slices, total
@@ -304,7 +309,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoLinear(
 *       TRUE if no error occurs
 ****************************************************************************************************
 */
-BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMicroTiled(
+BOOL_32 EgBasedLib::ComputeSurfaceInfoMicroTiled(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,        ///< [in] Input structure
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut,       ///< [out] Output structure
     UINT_32                                 padDims,    ///< [in] Dimensions to padd
@@ -403,7 +408,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMicroTiled(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeSurfaceInfoMacroTiled
+*   EgBasedLib::ComputeSurfaceInfoMacroTiled
 *
 *   @brief
 *       Compute 2D/macro tiled surface sizes include padded pitch, height, slices, total
@@ -414,7 +419,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMicroTiled(
 *       TRUE if no error occurs
 ****************************************************************************************************
 */
-BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMacroTiled(
+BOOL_32 EgBasedLib::ComputeSurfaceInfoMacroTiled(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,        ///< [in] Input structure
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut,       ///< [out] Output structure
     UINT_32                                 padDims,    ///< [in] Dimensions to padd
@@ -615,7 +620,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMacroTiled(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeSurfaceAlignmentsLinear
+*   EgBasedLib::ComputeSurfaceAlignmentsLinear
 *
 *   @brief
 *       Compute linear surface alignment, calculation results are returned through
@@ -625,7 +630,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMacroTiled(
 *       TRUE if no error occurs
 ****************************************************************************************************
 */
-BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsLinear(
+BOOL_32 EgBasedLib::ComputeSurfaceAlignmentsLinear(
     AddrTileMode        tileMode,          ///< [in] tile mode
     UINT_32             bpp,               ///< [in] bits per pixel
     ADDR_SURFACE_FLAGS  flags,             ///< [in] surface flags
@@ -671,7 +676,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsLinear(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled
+*   EgBasedLib::ComputeSurfaceAlignmentsMicroTiled
 *
 *   @brief
 *       Compute 1D tiled surface alignment, calculation results are returned through
@@ -681,7 +686,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsLinear(
 *       TRUE if no error occurs
 ****************************************************************************************************
 */
-BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled(
+BOOL_32 EgBasedLib::ComputeSurfaceAlignmentsMicroTiled(
     AddrTileMode        tileMode,          ///< [in] tile mode
     UINT_32             bpp,               ///< [in] bits per pixel
     ADDR_SURFACE_FLAGS  flags,             ///< [in] surface flags
@@ -721,7 +726,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlReduceBankWidthHeight
+*   EgBasedLib::HwlReduceBankWidthHeight
 *
 *   @brief
 *       Additional checks, reduce bankHeight/bankWidth if needed and possible
@@ -731,7 +736,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled(
 *       TRUE if no error occurs
 ****************************************************************************************************
 */
-BOOL_32 EgBasedAddrLib::HwlReduceBankWidthHeight(
+BOOL_32 EgBasedLib::HwlReduceBankWidthHeight(
     UINT_32             tileSize,           ///< [in] tile size
     UINT_32             bpp,                ///< [in] bits per pixel
     ADDR_SURFACE_FLAGS  flags,              ///< [in] surface flags
@@ -825,7 +830,7 @@ BOOL_32 EgBasedAddrLib::HwlReduceBankWidthHeight(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled
+*   EgBasedLib::ComputeSurfaceAlignmentsMacroTiled
 *
 *   @brief
 *       Compute 2D tiled surface alignment, calculation results are returned through
@@ -835,7 +840,7 @@ BOOL_32 EgBasedAddrLib::HwlReduceBankWidthHeight(
 *       TRUE if no error occurs
 ****************************************************************************************************
 */
-BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled(
+BOOL_32 EgBasedLib::ComputeSurfaceAlignmentsMacroTiled(
     AddrTileMode        tileMode,           ///< [in] tile mode
     UINT_32             bpp,                ///< [in] bits per pixel
     ADDR_SURFACE_FLAGS  flags,              ///< [in] surface flags
@@ -949,7 +954,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::SanityCheckMacroTiled
+*   EgBasedLib::SanityCheckMacroTiled
 *
 *   @brief
 *       Check if macro-tiled parameters are valid
@@ -957,7 +962,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled(
 *       TRUE if valid
 ****************************************************************************************************
 */
-BOOL_32 EgBasedAddrLib::SanityCheckMacroTiled(
+BOOL_32 EgBasedLib::SanityCheckMacroTiled(
     ADDR_TILEINFO* pTileInfo   ///< [in] macro-tiled parameters
     ) const
 {
@@ -1054,7 +1059,7 @@ BOOL_32 EgBasedAddrLib::SanityCheckMacroTiled(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeSurfaceMipLevelTileMode
+*   EgBasedLib::ComputeSurfaceMipLevelTileMode
 *
 *   @brief
 *       Compute valid tile mode for surface mipmap sub-levels
@@ -1063,7 +1068,7 @@ BOOL_32 EgBasedAddrLib::SanityCheckMacroTiled(
 *       Suitable tile mode
 ****************************************************************************************************
 */
-AddrTileMode EgBasedAddrLib::ComputeSurfaceMipLevelTileMode(
+AddrTileMode EgBasedLib::ComputeSurfaceMipLevelTileMode(
     AddrTileMode        baseTileMode,   ///< [in] base tile mode
     UINT_32             bpp,            ///< [in] bits per pixels
     UINT_32             pitch,          ///< [in] current level pitch
@@ -1146,14 +1151,14 @@ AddrTileMode EgBasedAddrLib::ComputeSurfaceMipLevelTileMode(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlDegradeBaseLevel
+*   EgBasedLib::HwlDegradeBaseLevel
 *   @brief
 *       Check if degrade is needed for base level
 *   @return
 *       TRUE if degrade is suggested
 ****************************************************************************************************
 */
-BOOL_32 EgBasedAddrLib::HwlDegradeBaseLevel(
+BOOL_32 EgBasedLib::HwlDegradeBaseLevel(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn) const
 {
     BOOL_32 degrade = FALSE;
@@ -1230,7 +1235,7 @@ BOOL_32 EgBasedAddrLib::HwlDegradeBaseLevel(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlDegradeThickTileMode
+*   EgBasedLib::HwlDegradeThickTileMode
 *
 *   @brief
 *       Degrades valid tile mode for thick modes if needed
@@ -1239,7 +1244,7 @@ BOOL_32 EgBasedAddrLib::HwlDegradeBaseLevel(
 *       Suitable tile mode
 ****************************************************************************************************
 */
-AddrTileMode EgBasedAddrLib::HwlDegradeThickTileMode(
+AddrTileMode EgBasedLib::HwlDegradeThickTileMode(
     AddrTileMode        baseTileMode,   ///< [in] base tile mode
     UINT_32             numSlices,      ///< [in] current number of slices
     UINT_32*            pBytesPerTile   ///< [in/out] pointer to bytes per slice
@@ -1303,7 +1308,7 @@ AddrTileMode EgBasedAddrLib::HwlDegradeThickTileMode(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord
+*   EgBasedLib::DispatchComputeSurfaceAddrFromCoord
 *
 *   @brief
 *       Compute surface address from given coord (x, y, slice,sample)
@@ -1312,7 +1317,7 @@ AddrTileMode EgBasedAddrLib::HwlDegradeThickTileMode(
 *       Address in bytes
 ****************************************************************************************************
 */
-UINT_64 EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord(
+UINT_64 EgBasedLib::DispatchComputeSurfaceAddrFromCoord(
     const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,    ///< [in] input structure
     ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT*      pOut    ///< [out] output structure
     ) const
@@ -1468,7 +1473,7 @@ UINT_64 EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeMacroTileEquation
+*   EgBasedLib::ComputeMacroTileEquation
 *
 *   @brief
 *       Computes the address equation in macro tile
@@ -1476,7 +1481,7 @@ UINT_64 EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord(
 *       If equation can be computed
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE EgBasedAddrLib::ComputeMacroTileEquation(
+ADDR_E_RETURNCODE EgBasedLib::ComputeMacroTileEquation(
     UINT_32             log2BytesPP,            ///< [in] log2 of bytes per pixel
     AddrTileMode        tileMode,               ///< [in] tile mode
     AddrTileType        microTileType,          ///< [in] micro tiling type
@@ -1599,7 +1604,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::ComputeMacroTileEquation(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled
+*   EgBasedLib::ComputeSurfaceAddrFromCoordMicroTiled
 *
 *   @brief
 *       Computes the surface address and bit position from a
@@ -1608,7 +1613,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::ComputeMacroTileEquation(
 *       The byte address
 ****************************************************************************************************
 */
-UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMacroTiled(
+UINT_64 EgBasedLib::ComputeSurfaceAddrFromCoordMacroTiled(
     UINT_32             x,                      ///< [in] x coordinate
     UINT_32             y,                      ///< [in] y coordinate
     UINT_32             slice,                  ///< [in] slice index
@@ -1874,7 +1879,7 @@ UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMacroTiled(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled
+*   EgBasedLib::ComputeSurfaceAddrFromCoordMicroTiled
 *
 *   @brief
 *       Computes the surface address and bit position from a coordinate for 1D tilied
@@ -1883,7 +1888,7 @@ UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMacroTiled(
 *       The byte address
 ****************************************************************************************************
 */
-UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled(
+UINT_64 EgBasedLib::ComputeSurfaceAddrFromCoordMicroTiled(
     UINT_32             x,                      ///< [in] x coordinate
     UINT_32             y,                      ///< [in] y coordinate
     UINT_32             slice,                  ///< [in] slice index
@@ -1999,7 +2004,7 @@ UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlComputePixelCoordFromOffset
+*   EgBasedLib::HwlComputePixelCoordFromOffset
 *
 *   @brief
 *       Compute pixel coordinate from offset inside a micro tile
@@ -2007,7 +2012,7 @@ UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled(
 *       N/A
 ****************************************************************************************************
 */
-VOID EgBasedAddrLib::HwlComputePixelCoordFromOffset(
+VOID EgBasedLib::HwlComputePixelCoordFromOffset(
     UINT_32         offset,             ///< [in] offset inside micro tile in bits
     UINT_32         bpp,                ///< [in] bits per pixel
     UINT_32         numSamples,         ///< [in] number of samples
@@ -2188,7 +2193,7 @@ VOID EgBasedAddrLib::HwlComputePixelCoordFromOffset(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddrDispatch
+*   EgBasedLib::DispatchComputeSurfaceCoordFromAddrDispatch
 *
 *   @brief
 *       Compute (x,y,slice,sample) coordinates from surface address
@@ -2196,7 +2201,7 @@ VOID EgBasedAddrLib::HwlComputePixelCoordFromOffset(
 *       N/A
 ****************************************************************************************************
 */
-VOID EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddr(
+VOID EgBasedLib::DispatchComputeSurfaceCoordFromAddr(
     const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,    ///< [in] input structure
     ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT*      pOut    ///< [out] output structure
     ) const
@@ -2333,7 +2338,7 @@ VOID EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddr(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled
+*   EgBasedLib::ComputeSurfaceCoordFromAddrMacroTiled
 *
 *   @brief
 *       Compute surface coordinates from address for macro tiled surface
@@ -2341,7 +2346,7 @@ VOID EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddr(
 *       N/A
 ****************************************************************************************************
 */
-VOID EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled(
+VOID EgBasedLib::ComputeSurfaceCoordFromAddrMacroTiled(
     UINT_64             addr,               ///< [in] byte address
     UINT_32             bitPosition,        ///< [in] bit position
     UINT_32             bpp,                ///< [in] bits per pixel
@@ -2491,7 +2496,7 @@ VOID EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeSurfaceCoord2DFromBankPipe
+*   EgBasedLib::ComputeSurfaceCoord2DFromBankPipe
 *
 *   @brief
 *       Compute surface x,y coordinates from bank/pipe info
@@ -2499,7 +2504,7 @@ VOID EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled(
 *       N/A
 ****************************************************************************************************
 */
-VOID EgBasedAddrLib::ComputeSurfaceCoord2DFromBankPipe(
+VOID EgBasedLib::ComputeSurfaceCoord2DFromBankPipe(
     AddrTileMode        tileMode,   ///< [in] tile mode
     UINT_32             x,          ///< [in] x coordinate
     UINT_32             y,          ///< [in] y coordinate
@@ -2677,14 +2682,14 @@ VOID EgBasedAddrLib::ComputeSurfaceCoord2DFromBankPipe(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlExtractBankPipeSwizzle
+*   EgBasedLib::HwlExtractBankPipeSwizzle
 *   @brief
-*       Entry of EgBasedAddrLib ExtractBankPipeSwizzle
+*       Entry of EgBasedLib ExtractBankPipeSwizzle
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlExtractBankPipeSwizzle(
+ADDR_E_RETURNCODE EgBasedLib::HwlExtractBankPipeSwizzle(
     const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT*  pIn,   ///< [in] input structure
     ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT*       pOut   ///< [out] output structure
     ) const
@@ -2700,14 +2705,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlExtractBankPipeSwizzle(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlCombineBankPipeSwizzle
+*   EgBasedLib::HwlCombineBankPipeSwizzle
 *   @brief
 *       Combine bank/pipe swizzle
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlCombineBankPipeSwizzle(
+ADDR_E_RETURNCODE EgBasedLib::HwlCombineBankPipeSwizzle(
     UINT_32         bankSwizzle,    ///< [in] bank swizzle
     UINT_32         pipeSwizzle,    ///< [in] pipe swizzle
     ADDR_TILEINFO*  pTileInfo,      ///< [in] tile info
@@ -2731,14 +2736,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlCombineBankPipeSwizzle(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlComputeBaseSwizzle
+*   EgBasedLib::HwlComputeBaseSwizzle
 *   @brief
 *       Compute base swizzle
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeBaseSwizzle(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeBaseSwizzle(
     const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn,
     ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT* pOut
     ) const
@@ -2806,14 +2811,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeBaseSwizzle(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ExtractBankPipeSwizzle
+*   EgBasedLib::ExtractBankPipeSwizzle
 *   @brief
 *       Extract bank/pipe swizzle from base256b
 *   @return
 *       N/A
 ****************************************************************************************************
 */
-VOID EgBasedAddrLib::ExtractBankPipeSwizzle(
+VOID EgBasedLib::ExtractBankPipeSwizzle(
     UINT_32         base256b,       ///< [in] input base256b register value
     ADDR_TILEINFO*  pTileInfo,      ///< [in] 2D tile parameters. Client must provide all data
     UINT_32*        pBankSwizzle,   ///< [out] bank swizzle
@@ -2844,14 +2849,14 @@ VOID EgBasedAddrLib::ExtractBankPipeSwizzle(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::GetBankPipeSwizzle
+*   EgBasedLib::GetBankPipeSwizzle
 *   @brief
 *       Combine bank/pipe swizzle
 *   @return
 *       Base256b bits (only filled bank/pipe bits)
 ****************************************************************************************************
 */
-UINT_32 EgBasedAddrLib::GetBankPipeSwizzle(
+UINT_32 EgBasedLib::GetBankPipeSwizzle(
     UINT_32         bankSwizzle,    ///< [in] bank swizzle
     UINT_32         pipeSwizzle,    ///< [in] pipe swizzle
     UINT_64         baseAddr,       ///< [in] base address
@@ -2870,14 +2875,14 @@ UINT_32 EgBasedAddrLib::GetBankPipeSwizzle(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeSliceTileSwizzle
+*   EgBasedLib::ComputeSliceTileSwizzle
 *   @brief
 *       Compute cubemap/3d texture faces/slices tile swizzle
 *   @return
 *       Tile swizzle
 ****************************************************************************************************
 */
-UINT_32 EgBasedAddrLib::ComputeSliceTileSwizzle(
+UINT_32 EgBasedLib::ComputeSliceTileSwizzle(
     AddrTileMode        tileMode,       ///< [in] Tile mode
     UINT_32             baseSwizzle,    ///< [in] Base swizzle
     UINT_32             slice,          ///< [in] Slice index, Cubemap face index, 0 means +X
@@ -2935,7 +2940,7 @@ UINT_32 EgBasedAddrLib::ComputeSliceTileSwizzle(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlComputeQbStereoRightSwizzle
+*   EgBasedLib::HwlComputeQbStereoRightSwizzle
 *
 *   @brief
 *       Compute right eye swizzle
@@ -2943,7 +2948,7 @@ UINT_32 EgBasedAddrLib::ComputeSliceTileSwizzle(
 *       swizzle
 ****************************************************************************************************
 */
-UINT_32 EgBasedAddrLib::HwlComputeQbStereoRightSwizzle(
+UINT_32 EgBasedLib::HwlComputeQbStereoRightSwizzle(
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pInfo  ///< [in] Surface info, must be valid
     ) const
 {
@@ -2967,7 +2972,7 @@ UINT_32 EgBasedAddrLib::HwlComputeQbStereoRightSwizzle(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeBankFromCoord
+*   EgBasedLib::ComputeBankFromCoord
 *
 *   @brief
 *       Compute bank number from coordinates
@@ -2975,7 +2980,7 @@ UINT_32 EgBasedAddrLib::HwlComputeQbStereoRightSwizzle(
 *       Bank number
 ****************************************************************************************************
 */
-UINT_32 EgBasedAddrLib::ComputeBankFromCoord(
+UINT_32 EgBasedLib::ComputeBankFromCoord(
     UINT_32         x,              ///< [in] x coordinate
     UINT_32         y,              ///< [in] y coordinate
     UINT_32         slice,          ///< [in] slice index
@@ -3099,7 +3104,7 @@ UINT_32 EgBasedAddrLib::ComputeBankFromCoord(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeBankFromAddr
+*   EgBasedLib::ComputeBankFromAddr
 *
 *   @brief
 *       Compute the bank number from an address
@@ -3107,7 +3112,7 @@ UINT_32 EgBasedAddrLib::ComputeBankFromCoord(
 *       Bank number
 ****************************************************************************************************
 */
-UINT_32 EgBasedAddrLib::ComputeBankFromAddr(
+UINT_32 EgBasedLib::ComputeBankFromAddr(
     UINT_64 addr,       ///< [in] address
     UINT_32 numBanks,   ///< [in] number of banks
     UINT_32 numPipes    ///< [in] number of pipes
@@ -3132,7 +3137,7 @@ UINT_32 EgBasedAddrLib::ComputeBankFromAddr(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputePipeRotation
+*   EgBasedLib::ComputePipeRotation
 *
 *   @brief
 *       Compute pipe rotation value
@@ -3140,7 +3145,7 @@ UINT_32 EgBasedAddrLib::ComputeBankFromAddr(
 *       Pipe rotation
 ****************************************************************************************************
 */
-UINT_32 EgBasedAddrLib::ComputePipeRotation(
+UINT_32 EgBasedLib::ComputePipeRotation(
     AddrTileMode tileMode,  ///< [in] tile mode
     UINT_32      numPipes   ///< [in] number of pipes
     ) const
@@ -3167,7 +3172,7 @@ UINT_32 EgBasedAddrLib::ComputePipeRotation(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeBankRotation
+*   EgBasedLib::ComputeBankRotation
 *
 *   @brief
 *       Compute bank rotation value
@@ -3175,7 +3180,7 @@ UINT_32 EgBasedAddrLib::ComputePipeRotation(
 *       Bank rotation
 ****************************************************************************************************
 */
-UINT_32 EgBasedAddrLib::ComputeBankRotation(
+UINT_32 EgBasedLib::ComputeBankRotation(
     AddrTileMode tileMode,  ///< [in] tile mode
     UINT_32      numBanks,  ///< [in] number of banks
     UINT_32      numPipes   ///< [in] number of pipes
@@ -3210,7 +3215,7 @@ UINT_32 EgBasedAddrLib::ComputeBankRotation(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeHtileBytes
+*   EgBasedLib::ComputeHtileBytes
 *
 *   @brief
 *       Compute htile size in bytes
@@ -3219,7 +3224,7 @@ UINT_32 EgBasedAddrLib::ComputeBankRotation(
 *       Htile size in bytes
 ****************************************************************************************************
 */
-UINT_64 EgBasedAddrLib::ComputeHtileBytes(
+UINT_64 EgBasedLib::ComputeHtileBytes(
     UINT_32 pitch,        ///< [in] pitch
     UINT_32 height,       ///< [in] height
     UINT_32 bpp,          ///< [in] bits per pixel
@@ -3253,7 +3258,7 @@ UINT_64 EgBasedAddrLib::ComputeHtileBytes(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::DispatchComputeFmaskInfo
+*   EgBasedLib::DispatchComputeFmaskInfo
 *
 *   @brief
 *       Compute fmask sizes include padded pitch, height, slices, total size in bytes,
@@ -3264,7 +3269,7 @@ UINT_64 EgBasedAddrLib::ComputeHtileBytes(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE EgBasedAddrLib::DispatchComputeFmaskInfo(
+ADDR_E_RETURNCODE EgBasedLib::DispatchComputeFmaskInfo(
     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,   ///< [in] input structure
     ADDR_COMPUTE_FMASK_INFO_OUTPUT*         pOut)  ///< [out] output structure
 {
@@ -3330,14 +3335,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::DispatchComputeFmaskInfo(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlFmaskSurfaceInfo
+*   EgBasedLib::HwlFmaskSurfaceInfo
 *   @brief
-*       Entry of EgBasedAddrLib ComputeFmaskInfo
+*       Entry of EgBasedLib ComputeFmaskInfo
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskInfo(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeFmaskInfo(
     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,   ///< [in] input structure
     ADDR_COMPUTE_FMASK_INFO_OUTPUT*         pOut   ///< [out] output structure
     )
@@ -3372,14 +3377,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskInfo(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlComputeFmaskAddrFromCoord
+*   EgBasedLib::HwlComputeFmaskAddrFromCoord
 *   @brief
-*       Entry of EgBasedAddrLib ComputeFmaskAddrFromCoord
+*       Entry of EgBasedLib ComputeFmaskAddrFromCoord
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskAddrFromCoord(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeFmaskAddrFromCoord(
     const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,    ///< [in] input structure
     ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*        pOut    ///< [out] output structure
     ) const
@@ -3405,14 +3410,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskAddrFromCoord(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlComputeFmaskCoordFromAddr
+*   EgBasedLib::HwlComputeFmaskCoordFromAddr
 *   @brief
-*       Entry of EgBasedAddrLib ComputeFmaskCoordFromAddr
+*       Entry of EgBasedLib ComputeFmaskCoordFromAddr
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskCoordFromAddr(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeFmaskCoordFromAddr(
     const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*   pIn,    ///< [in] input structure
     ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT*        pOut    ///< [out] output structure
     ) const
@@ -3437,7 +3442,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskCoordFromAddr(
 #if ADDR_AM_BUILD
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord
+*   EgBasedLib::DispatchComputeFmaskAddrFromCoord
 *
 *   @brief
 *       Computes the FMASK address and bit position from a coordinate.
@@ -3445,7 +3450,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskCoordFromAddr(
 *       The byte address
 ****************************************************************************************************
 */
-UINT_64 EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord(
+UINT_64 EgBasedLib::DispatchComputeFmaskAddrFromCoord(
     const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,    ///< [in] input structure
     ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*        pOut    ///< [out] output structure
     ) const
@@ -3526,7 +3531,7 @@ UINT_64 EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled
+*   EgBasedLib::ComputeFmaskAddrFromCoordMicroTiled
 *
 *   @brief
 *       Computes the FMASK address and bit position from a coordinate for 1D tilied (micro
@@ -3535,7 +3540,7 @@ UINT_64 EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord(
 *       The byte address
 ****************************************************************************************************
 */
-UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled(
+UINT_64 EgBasedLib::ComputeFmaskAddrFromCoordMicroTiled(
     UINT_32             x,              ///< [in] x coordinate
     UINT_32             y,              ///< [in] y coordinate
     UINT_32             slice,          ///< [in] slice index
@@ -3634,7 +3639,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled
+*   EgBasedLib::ComputeFmaskAddrFromCoordMacroTiled
 *
 *   @brief
 *       Computes the FMASK address and bit position from a coordinate for 2D tilied (macro
@@ -3643,7 +3648,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled(
 *       The byte address
 ****************************************************************************************************
 */
-UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled(
+UINT_64 EgBasedLib::ComputeFmaskAddrFromCoordMacroTiled(
     UINT_32             x,              ///< [in] x coordinate
     UINT_32             y,              ///< [in] y coordinate
     UINT_32             slice,          ///< [in] slice index
@@ -3756,7 +3761,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled
+*   EgBasedLib::ComputeFmaskCoordFromAddrMicroTiled
 *
 *   @brief
 *       Compute (x,y,slice,sample,plane) coordinates from fmask address
@@ -3765,7 +3770,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled(
 *
 ****************************************************************************************************
 */
-VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled(
+VOID EgBasedLib::ComputeFmaskCoordFromAddrMicroTiled(
     UINT_64             addr,       ///< [in] byte address
     UINT_32             bitPosition,///< [in] bit position
     UINT_32             pitch,      ///< [in] pitch in pixels
@@ -3843,7 +3848,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled
+*   EgBasedLib::ComputeFmaskCoordFromAddrMacroTiled
 *
 *   @brief
 *       Compute (x,y,slice,sample,plane) coordinates from
@@ -3853,7 +3858,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled(
 *
 ****************************************************************************************************
 */
-VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled(
+VOID EgBasedLib::ComputeFmaskCoordFromAddrMacroTiled(
     UINT_64             addr,       ///< [in] byte address
     UINT_32             bitPosition,///< [in] bit position
     UINT_32             pitch,      ///< [in] pitch in pixels
@@ -3943,7 +3948,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr
+*   EgBasedLib::DispatchComputeFmaskCoordFromAddr
 *
 *   @brief
 *       Compute (x,y,slice,sample,plane) coordinates from
@@ -3953,7 +3958,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled(
 *
 ****************************************************************************************************
 */
-VOID EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr(
+VOID EgBasedLib::DispatchComputeFmaskCoordFromAddr(
     const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*   pIn,    ///< [in] input structure
     ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT*        pOut    ///< [out] output structure
     ) const
@@ -4033,7 +4038,7 @@ VOID EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples
+*   EgBasedLib::ComputeFmaskNumPlanesFromNumSamples
 *
 *   @brief
 *       Compute fmask number of planes from number of samples
@@ -4042,7 +4047,7 @@ VOID EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr(
 *       Number of planes
 ****************************************************************************************************
 */
-UINT_32 EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples(
+UINT_32 EgBasedLib::ComputeFmaskNumPlanesFromNumSamples(
     UINT_32 numSamples)     ///< [in] number of samples
 {
     UINT_32 numPlanes;
@@ -4078,7 +4083,7 @@ UINT_32 EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples
+*   EgBasedLib::ComputeFmaskResolvedBppFromNumSamples
 *
 *   @brief
 *       Compute resolved fmask effective bpp based on number of samples
@@ -4087,7 +4092,7 @@ UINT_32 EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples(
 *       bpp
 ****************************************************************************************************
 */
-UINT_32 EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples(
+UINT_32 EgBasedLib::ComputeFmaskResolvedBppFromNumSamples(
     UINT_32 numSamples)     ///< number of samples
 {
     UINT_32 bpp;
@@ -4123,7 +4128,7 @@ UINT_32 EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::IsTileInfoAllZero
+*   EgBasedLib::IsTileInfoAllZero
 *
 *   @brief
 *       Return TRUE if all field are zero
@@ -4131,7 +4136,7 @@ UINT_32 EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples(
 *       Since NULL input is consider to be all zero
 ****************************************************************************************************
 */
-BOOL_32 EgBasedAddrLib::IsTileInfoAllZero(
+BOOL_32 EgBasedLib::IsTileInfoAllZero(
     ADDR_TILEINFO* pTileInfo)
 {
     BOOL_32 allZero = TRUE;
@@ -4155,7 +4160,7 @@ BOOL_32 EgBasedAddrLib::IsTileInfoAllZero(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlTileInfoEqual
+*   EgBasedLib::HwlTileInfoEqual
 *
 *   @brief
 *       Return TRUE if all field are equal
@@ -4163,7 +4168,7 @@ BOOL_32 EgBasedAddrLib::IsTileInfoAllZero(
 *       Only takes care of current HWL's data
 ****************************************************************************************************
 */
-BOOL_32 EgBasedAddrLib::HwlTileInfoEqual(
+BOOL_32 EgBasedLib::HwlTileInfoEqual(
     const ADDR_TILEINFO* pLeft, ///<[in] Left compare operand
     const ADDR_TILEINFO* pRight ///<[in] Right compare operand
     ) const
@@ -4184,14 +4189,14 @@ BOOL_32 EgBasedAddrLib::HwlTileInfoEqual(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlConvertTileInfoToHW
+*   EgBasedLib::HwlConvertTileInfoToHW
 *   @brief
-*       Entry of EgBasedAddrLib ConvertTileInfoToHW
+*       Entry of EgBasedLib ConvertTileInfoToHW
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlConvertTileInfoToHW(
+ADDR_E_RETURNCODE EgBasedLib::HwlConvertTileInfoToHW(
     const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
     ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut      ///< [out] output structure
     ) const
@@ -4452,14 +4457,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlConvertTileInfoToHW(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlComputeSurfaceInfo
+*   EgBasedLib::HwlComputeSurfaceInfo
 *   @brief
-*       Entry of EgBasedAddrLib ComputeSurfaceInfo
+*       Entry of EgBasedLib ComputeSurfaceInfo
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceInfo(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeSurfaceInfo(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,    ///< [in] input structure
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut    ///< [out] output structure
     ) const
@@ -4539,14 +4544,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceInfo(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlComputeSurfaceAddrFromCoord
+*   EgBasedLib::HwlComputeSurfaceAddrFromCoord
 *   @brief
-*       Entry of EgBasedAddrLib ComputeSurfaceAddrFromCoord
+*       Entry of EgBasedLib ComputeSurfaceAddrFromCoord
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceAddrFromCoord(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeSurfaceAddrFromCoord(
     const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,    ///< [in] input structure
     ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT*      pOut    ///< [out] output structure
     ) const
@@ -4572,14 +4577,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceAddrFromCoord(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlComputeSurfaceCoordFromAddr
+*   EgBasedLib::HwlComputeSurfaceCoordFromAddr
 *   @brief
-*       Entry of EgBasedAddrLib ComputeSurfaceCoordFromAddr
+*       Entry of EgBasedLib ComputeSurfaceCoordFromAddr
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceCoordFromAddr(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeSurfaceCoordFromAddr(
     const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,    ///< [in] input structure
     ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT*      pOut    ///< [out] output structure
     ) const
@@ -4600,14 +4605,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceCoordFromAddr(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlComputeSliceTileSwizzle
+*   EgBasedLib::HwlComputeSliceTileSwizzle
 *   @brief
-*       Entry of EgBasedAddrLib ComputeSurfaceCoordFromAddr
+*       Entry of EgBasedLib ComputeSurfaceCoordFromAddr
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSliceTileSwizzle(
+ADDR_E_RETURNCODE EgBasedLib::HwlComputeSliceTileSwizzle(
     const ADDR_COMPUTE_SLICESWIZZLE_INPUT*  pIn,    ///< [in] input structure
     ADDR_COMPUTE_SLICESWIZZLE_OUTPUT*       pOut    ///< [out] output structure
     ) const
@@ -4633,7 +4638,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSliceTileSwizzle(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlComputeHtileBpp
+*   EgBasedLib::HwlComputeHtileBpp
 *
 *   @brief
 *       Compute htile bpp
@@ -4642,7 +4647,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSliceTileSwizzle(
 *       Htile bpp
 ****************************************************************************************************
 */
-UINT_32 EgBasedAddrLib::HwlComputeHtileBpp(
+UINT_32 EgBasedLib::HwlComputeHtileBpp(
     BOOL_32 isWidth8,   ///< [in] TRUE if block width is 8
     BOOL_32 isHeight8   ///< [in] TRUE if block height is 8
     ) const
@@ -4654,7 +4659,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBpp(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlComputeHtileBaseAlign
+*   EgBasedLib::HwlComputeHtileBaseAlign
 *
 *   @brief
 *       Compute htile base alignment
@@ -4663,7 +4668,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBpp(
 *       Htile base alignment
 ****************************************************************************************************
 */
-UINT_32 EgBasedAddrLib::HwlComputeHtileBaseAlign(
+UINT_32 EgBasedLib::HwlComputeHtileBaseAlign(
     BOOL_32         isTcCompatible, ///< [in] if TC compatible
     BOOL_32         isLinear,       ///< [in] if it is linear mode
     ADDR_TILEINFO*  pTileInfo       ///< [in] Tile info
@@ -4685,7 +4690,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBaseAlign(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled
+*   EgBasedLib::HwlGetPitchAlignmentMicroTiled
 *
 *   @brief
 *       Compute 1D tiled surface pitch alignment, calculation results are returned through
@@ -4695,7 +4700,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBaseAlign(
 *       pitch alignment
 ****************************************************************************************************
 */
-UINT_32 EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(
+UINT_32 EgBasedLib::HwlGetPitchAlignmentMicroTiled(
     AddrTileMode        tileMode,          ///< [in] tile mode
     UINT_32             bpp,               ///< [in] bits per pixel
     ADDR_SURFACE_FLAGS  flags,             ///< [in] surface flags
@@ -4734,7 +4739,7 @@ UINT_32 EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled
+*   EgBasedLib::HwlGetSizeAdjustmentMicroTiled
 *
 *   @brief
 *       Adjust 1D tiled surface pitch and slice size
@@ -4743,7 +4748,7 @@ UINT_32 EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(
 *       Logical slice size in bytes
 ****************************************************************************************************
 */
-UINT_64 EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled(
+UINT_64 EgBasedLib::HwlGetSizeAdjustmentMicroTiled(
     UINT_32             thickness,      ///< [in] thickness
     UINT_32             bpp,            ///< [in] bits per pixel
     ADDR_SURFACE_FLAGS  flags,          ///< [in] surface flags
@@ -4776,7 +4781,7 @@ UINT_64 EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled(
 
 /**
 ****************************************************************************************************
-*   EgBasedAddrLib::HwlStereoCheckRightOffsetPadding
+*   EgBasedLib::HwlStereoCheckRightOffsetPadding
 *
 *   @brief
 *       check if the height needs extra padding for stereo right eye offset, to avoid swizzling
@@ -4786,7 +4791,7 @@ UINT_64 EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled(
 *
 ****************************************************************************************************
 */
-UINT_32 EgBasedAddrLib::HwlStereoCheckRightOffsetPadding(
+UINT_32 EgBasedLib::HwlStereoCheckRightOffsetPadding(
     ADDR_TILEINFO* pTileInfo    ///< Tiling info
     ) const
 {
@@ -4809,3 +4814,5 @@ UINT_32 EgBasedAddrLib::HwlStereoCheckRightOffsetPadding(
     return stereoHeightAlign;
 }
 
+} // V1
+} // Addr
diff --git a/src/amd/addrlib/r800/egbaddrlib.h b/src/amd/addrlib/r800/egbaddrlib.h
index 6bc6c53e874..c397cfc4f81 100644
--- a/src/amd/addrlib/r800/egbaddrlib.h
+++ b/src/amd/addrlib/r800/egbaddrlib.h
@@ -27,7 +27,7 @@
 /**
 ****************************************************************************************************
 * @file  egbaddrlib.h
-* @brief Contains the EgBasedAddrLib class definition.
+* @brief Contains the EgBasedLib class definition.
 ****************************************************************************************************
 */
 
@@ -36,7 +36,10 @@
 
 #include "addrlib1.h"
 
-
+namespace Addr
+{
+namespace V1
+{
 /// Structures for functions
 struct CoordFromBankPipe
 {
@@ -58,11 +61,11 @@ struct CoordFromBankPipe
 * @note  Abstract class
 ****************************************************************************************************
 */
-class EgBasedAddrLib : public AddrLib1
+class EgBasedLib : public Lib
 {
 protected:
-    EgBasedAddrLib(const AddrClient* pClient);
-    virtual ~EgBasedAddrLib();
+    EgBasedLib(const Client* pClient);
+    virtual ~EgBasedLib();
 
 public:
 
@@ -415,5 +418,8 @@ protected:
     UINT_32 m_bankInterleave;       ///< Bank interleave, as a multiple of pipe interleave size
 };
 
+} // V1
+} // Addr
+
 #endif
 
diff --git a/src/amd/addrlib/r800/siaddrlib.cpp b/src/amd/addrlib/r800/siaddrlib.cpp
index 964f2fd28cc..9d3f5aa9367 100644
--- a/src/amd/addrlib/r800/siaddrlib.cpp
+++ b/src/amd/addrlib/r800/siaddrlib.cpp
@@ -27,7 +27,7 @@
 /**
 ****************************************************************************************************
 * @file  siaddrlib.cpp
-* @brief Contains the implementation for the SiAddrLib class.
+* @brief Contains the implementation for the SiLib class.
 ****************************************************************************************************
 */
 
@@ -45,34 +45,40 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////////////
+namespace Addr
+{
 
 /**
 ****************************************************************************************************
-*   AddrSiHwlInit
+*   SiHwlInit
 *
 *   @brief
-*       Creates an SiAddrLib object.
+*       Creates an SiLib object.
 *
 *   @return
-*       Returns an SiAddrLib object pointer.
+*       Returns an SiLib object pointer.
 ****************************************************************************************************
 */
-AddrLib* AddrSIHwlInit(const AddrClient* pClient)
+Lib* SiHwlInit(const Client* pClient)
 {
-    return SiAddrLib::CreateObj(pClient);
+    return V1::SiLib::CreateObj(pClient);
 }
 
+namespace V1
+{
+
 /**
 ****************************************************************************************************
-*   SiAddrLib::SiAddrLib
+*   SiLib::SiLib
 *
 *   @brief
 *       Constructor
 *
 ****************************************************************************************************
 */
-SiAddrLib::SiAddrLib(const AddrClient* pClient) :
-    EgBasedAddrLib(pClient),
+SiLib::SiLib(const Client* pClient)
+    :
+    EgBasedLib(pClient),
     m_noOfEntries(0),
     m_numEquations(0)
 {
@@ -82,19 +88,19 @@ SiAddrLib::SiAddrLib(const AddrClient* pClient) :
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::~SiAddrLib
+*   SiLib::~SiLib
 *
 *   @brief
 *       Destructor
 ****************************************************************************************************
 */
-SiAddrLib::~SiAddrLib()
+SiLib::~SiLib()
 {
 }
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlGetPipes
+*   SiLib::HwlGetPipes
 *
 *   @brief
 *       Get number pipes
@@ -102,7 +108,7 @@ SiAddrLib::~SiAddrLib()
 *       num pipes
 ****************************************************************************************************
 */
-UINT_32 SiAddrLib::HwlGetPipes(
+UINT_32 SiLib::HwlGetPipes(
     const ADDR_TILEINFO* pTileInfo    ///< [in] Tile info
     ) const
 {
@@ -123,14 +129,14 @@ UINT_32 SiAddrLib::HwlGetPipes(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::GetPipePerSurf
+*   SiLib::GetPipePerSurf
 *   @brief
 *       get pipe num base on inputing tileinfo->pipeconfig
 *   @return
 *       pipe number
 ****************************************************************************************************
 */
-UINT_32 SiAddrLib::GetPipePerSurf(
+UINT_32 SiLib::GetPipePerSurf(
     AddrPipeCfg pipeConfig   ///< [in] pipe config
     ) const
 {
@@ -169,7 +175,7 @@ UINT_32 SiAddrLib::GetPipePerSurf(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::ComputeBankEquation
+*   SiLib::ComputeBankEquation
 *
 *   @brief
 *       Compute bank equation
@@ -178,7 +184,7 @@ UINT_32 SiAddrLib::GetPipePerSurf(
 *       If equation can be computed
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE SiAddrLib::ComputeBankEquation(
+ADDR_E_RETURNCODE SiLib::ComputeBankEquation(
     UINT_32         log2BytesPP,    ///< [in] log2 of bytes per pixel
     UINT_32         threshX,        ///< [in] threshold for x channel
     UINT_32         threshY,        ///< [in] threshold for y channel
@@ -303,7 +309,7 @@ ADDR_E_RETURNCODE SiAddrLib::ComputeBankEquation(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::ComputePipeEquation
+*   SiLib::ComputePipeEquation
 *
 *   @brief
 *       Compute pipe equation
@@ -312,7 +318,7 @@ ADDR_E_RETURNCODE SiAddrLib::ComputeBankEquation(
 *       If equation can be computed
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE SiAddrLib::ComputePipeEquation(
+ADDR_E_RETURNCODE SiLib::ComputePipeEquation(
     UINT_32        log2BytesPP, ///< [in] Log2 of bytes per pixel
     UINT_32        threshX,     ///< [in] Threshold for X channel
     UINT_32        threshY,     ///< [in] Threshold for Y channel
@@ -501,7 +507,7 @@ ADDR_E_RETURNCODE SiAddrLib::ComputePipeEquation(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::ComputePipeFromCoord
+*   SiLib::ComputePipeFromCoord
 *
 *   @brief
 *       Compute pipe number from coordinates
@@ -509,7 +515,7 @@ ADDR_E_RETURNCODE SiAddrLib::ComputePipeEquation(
 *       Pipe number
 ****************************************************************************************************
 */
-UINT_32 SiAddrLib::ComputePipeFromCoord(
+UINT_32 SiLib::ComputePipeFromCoord(
     UINT_32         x,              ///< [in] x coordinate
     UINT_32         y,              ///< [in] y coordinate
     UINT_32         slice,          ///< [in] slice index
@@ -652,7 +658,7 @@ UINT_32 SiAddrLib::ComputePipeFromCoord(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::ComputeTileCoordFromPipeAndElemIdx
+*   SiLib::ComputeTileCoordFromPipeAndElemIdx
 *
 *   @brief
 *       Compute (x,y) of a tile within a macro tile from address
@@ -660,7 +666,7 @@ UINT_32 SiAddrLib::ComputePipeFromCoord(
 *       Pipe number
 ****************************************************************************************************
 */
-VOID SiAddrLib::ComputeTileCoordFromPipeAndElemIdx(
+VOID SiLib::ComputeTileCoordFromPipeAndElemIdx(
     UINT_32         elemIdx,          ///< [in] per pipe element index within a macro tile
     UINT_32         pipe,             ///< [in] pipe index
     AddrPipeCfg     pipeCfg,          ///< [in] pipe config
@@ -909,7 +915,7 @@ VOID SiAddrLib::ComputeTileCoordFromPipeAndElemIdx(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::TileCoordToMaskElementIndex
+*   SiLib::TileCoordToMaskElementIndex
 *
 *   @brief
 *       Compute element index from coordinates in tiles
@@ -917,7 +923,7 @@ VOID SiAddrLib::ComputeTileCoordFromPipeAndElemIdx(
 *       Element index
 ****************************************************************************************************
 */
-UINT_32 SiAddrLib::TileCoordToMaskElementIndex(
+UINT_32 SiLib::TileCoordToMaskElementIndex(
     UINT_32         tx,                 ///< [in] x coord, in Tiles
     UINT_32         ty,                 ///< [in] y coord, in Tiles
     AddrPipeCfg     pipeConfig,         ///< [in] pipe config
@@ -1045,7 +1051,7 @@ UINT_32 SiAddrLib::TileCoordToMaskElementIndex(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlComputeTileDataWidthAndHeightLinear
+*   SiLib::HwlComputeTileDataWidthAndHeightLinear
 *
 *   @brief
 *       Compute the squared cache shape for per-tile data (CMASK and HTILE) for linear layout
@@ -1057,7 +1063,7 @@ UINT_32 SiAddrLib::TileCoordToMaskElementIndex(
 *       MacroWidth and macroHeight are measured in pixels
 ****************************************************************************************************
 */
-VOID SiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
+VOID SiLib::HwlComputeTileDataWidthAndHeightLinear(
     UINT_32*        pMacroWidth,     ///< [out] macro tile width
     UINT_32*        pMacroHeight,    ///< [out] macro tile height
     UINT_32         bpp,             ///< [in] bits per pixel
@@ -1091,7 +1097,7 @@ VOID SiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlComputeHtileBytes
+*   SiLib::HwlComputeHtileBytes
 *
 *   @brief
 *       Compute htile size in bytes
@@ -1100,7 +1106,7 @@ VOID SiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
 *       Htile size in bytes
 ****************************************************************************************************
 */
-UINT_64 SiAddrLib::HwlComputeHtileBytes(
+UINT_64 SiLib::HwlComputeHtileBytes(
     UINT_32     pitch,          ///< [in] pitch
     UINT_32     height,         ///< [in] height
     UINT_32     bpp,            ///< [in] bits per pixel
@@ -1115,7 +1121,7 @@ UINT_64 SiAddrLib::HwlComputeHtileBytes(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlComputeXmaskAddrFromCoord
+*   SiLib::HwlComputeXmaskAddrFromCoord
 *
 *   @brief
 *       Compute address from coordinates for htile/cmask
@@ -1123,7 +1129,7 @@ UINT_64 SiAddrLib::HwlComputeHtileBytes(
 *       Byte address
 ****************************************************************************************************
 */
-UINT_64 SiAddrLib::HwlComputeXmaskAddrFromCoord(
+UINT_64 SiLib::HwlComputeXmaskAddrFromCoord(
     UINT_32        pitch,          ///< [in] pitch
     UINT_32        height,         ///< [in] height
     UINT_32        x,              ///< [in] x coord
@@ -1270,7 +1276,7 @@ UINT_64 SiAddrLib::HwlComputeXmaskAddrFromCoord(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlComputeXmaskCoordFromAddr
+*   SiLib::HwlComputeXmaskCoordFromAddr
 *
 *   @brief
 *       Compute the coord from an address of a cmask/htile
@@ -1282,7 +1288,7 @@ UINT_64 SiAddrLib::HwlComputeXmaskAddrFromCoord(
 *       This method is reused by htile, so rename to Xmask
 ****************************************************************************************************
 */
-VOID SiAddrLib::HwlComputeXmaskCoordFromAddr(
+VOID SiLib::HwlComputeXmaskCoordFromAddr(
     UINT_64         addr,           ///< [in] address
     UINT_32         bitPosition,    ///< [in] bitPosition in a byte
     UINT_32         pitch,          ///< [in] pitch
@@ -1476,14 +1482,14 @@ VOID SiAddrLib::HwlComputeXmaskCoordFromAddr(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlGetPitchAlignmentLinear
+*   SiLib::HwlGetPitchAlignmentLinear
 *   @brief
 *       Get pitch alignment
 *   @return
 *       pitch alignment
 ****************************************************************************************************
 */
-UINT_32 SiAddrLib::HwlGetPitchAlignmentLinear(
+UINT_32 SiLib::HwlGetPitchAlignmentLinear(
     UINT_32             bpp,    ///< [in] bits per pixel
     ADDR_SURFACE_FLAGS  flags   ///< [in] surface flags
     ) const
@@ -1506,7 +1512,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentLinear(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlGetSizeAdjustmentLinear
+*   SiLib::HwlGetSizeAdjustmentLinear
 *
 *   @brief
 *       Adjust linear surface pitch and slice size
@@ -1515,7 +1521,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentLinear(
 *       Logical slice size in bytes
 ****************************************************************************************************
 */
-UINT_64 SiAddrLib::HwlGetSizeAdjustmentLinear(
+UINT_64 SiLib::HwlGetSizeAdjustmentLinear(
     AddrTileMode        tileMode,       ///< [in] tile mode
     UINT_32             bpp,            ///< [in] bits per pixel
     UINT_32             numSamples,     ///< [in] number of samples
@@ -1567,7 +1573,7 @@ UINT_64 SiAddrLib::HwlGetSizeAdjustmentLinear(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlPreHandleBaseLvl3xPitch
+*   SiLib::HwlPreHandleBaseLvl3xPitch
 *
 *   @brief
 *       Pre-handler of 3x pitch (96 bit) adjustment
@@ -1576,7 +1582,7 @@ UINT_64 SiAddrLib::HwlGetSizeAdjustmentLinear(
 *       Expected pitch
 ****************************************************************************************************
 */
-UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
+UINT_32 SiLib::HwlPreHandleBaseLvl3xPitch(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,        ///< [in] input
     UINT_32                                 expPitch    ///< [in] pitch
     ) const
@@ -1587,7 +1593,7 @@ UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
     // do here
     if (pIn->flags.pow2Pad == FALSE)
     {
-        AddrLib1::HwlPreHandleBaseLvl3xPitch(pIn, expPitch);
+        Addr::V1::Lib::HwlPreHandleBaseLvl3xPitch(pIn, expPitch);
     }
     else
     {
@@ -1599,7 +1605,7 @@ UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlPostHandleBaseLvl3xPitch
+*   SiLib::HwlPostHandleBaseLvl3xPitch
 *
 *   @brief
 *       Post-handler of 3x pitch adjustment
@@ -1608,7 +1614,7 @@ UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
 *       Expected pitch
 ****************************************************************************************************
 */
-UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
+UINT_32 SiLib::HwlPostHandleBaseLvl3xPitch(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,        ///< [in] input
     UINT_32                                 expPitch    ///< [in] pitch
     ) const
@@ -1620,7 +1626,7 @@ UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
     // From SI, the pitch is expanded 3x first, then padded to pow2, so no special handler here
     if (pIn->flags.pow2Pad == FALSE)
     {
-        AddrLib1::HwlPostHandleBaseLvl3xPitch(pIn, expPitch);
+        Addr::V1::Lib::HwlPostHandleBaseLvl3xPitch(pIn, expPitch);
     }
 
     return expPitch;
@@ -1628,7 +1634,7 @@ UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlGetPitchAlignmentMicroTiled
+*   SiLib::HwlGetPitchAlignmentMicroTiled
 *
 *   @brief
 *       Compute 1D tiled surface pitch alignment
@@ -1637,7 +1643,7 @@ UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
 *       pitch alignment
 ****************************************************************************************************
 */
-UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
+UINT_32 SiLib::HwlGetPitchAlignmentMicroTiled(
     AddrTileMode        tileMode,          ///< [in] tile mode
     UINT_32             bpp,               ///< [in] bits per pixel
     ADDR_SURFACE_FLAGS  flags,             ///< [in] surface flags
@@ -1648,7 +1654,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
 
     if (flags.qbStereo)
     {
-        pitchAlign = EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(tileMode,bpp,flags,numSamples);
+        pitchAlign = EgBasedLib::HwlGetPitchAlignmentMicroTiled(tileMode,bpp,flags,numSamples);
     }
     else
     {
@@ -1660,7 +1666,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlGetSizeAdjustmentMicroTiled
+*   SiLib::HwlGetSizeAdjustmentMicroTiled
 *
 *   @brief
 *       Adjust 1D tiled surface pitch and slice size
@@ -1669,7 +1675,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
 *       Logical slice size in bytes
 ****************************************************************************************************
 */
-UINT_64 SiAddrLib::HwlGetSizeAdjustmentMicroTiled(
+UINT_64 SiLib::HwlGetSizeAdjustmentMicroTiled(
     UINT_32             thickness,      ///< [in] thickness
     UINT_32             bpp,            ///< [in] bits per pixel
     ADDR_SURFACE_FLAGS  flags,          ///< [in] surface flags
@@ -1740,19 +1746,19 @@ UINT_64 SiAddrLib::HwlGetSizeAdjustmentMicroTiled(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlConvertChipFamily
+*   SiLib::HwlConvertChipFamily
 *
 *   @brief
-*       Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
+*       Convert familyID defined in atiid.h to ChipFamily and set m_chipFamily/m_chipRevision
 *   @return
-*       AddrChipFamily
+*       ChipFamily
 ****************************************************************************************************
 */
-AddrChipFamily SiAddrLib::HwlConvertChipFamily(
+ChipFamily SiLib::HwlConvertChipFamily(
     UINT_32 uChipFamily,        ///< [in] chip family defined in atiih.h
     UINT_32 uChipRevision)      ///< [in] chip revision defined in "asic_family"_id.h
 {
-    AddrChipFamily family = ADDR_CHIP_FAMILY_SI;
+    ChipFamily family = ADDR_CHIP_FAMILY_SI;
 
     switch (uChipFamily)
     {
@@ -1774,13 +1780,13 @@ AddrChipFamily SiAddrLib::HwlConvertChipFamily(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlSetupTileInfo
+*   SiLib::HwlSetupTileInfo
 *
 *   @brief
 *       Setup default value of tile info for SI
 ****************************************************************************************************
 */
-VOID SiAddrLib::HwlSetupTileInfo(
+VOID SiLib::HwlSetupTileInfo(
     AddrTileMode                        tileMode,       ///< [in] Tile mode
     ADDR_SURFACE_FLAGS                  flags,          ///< [in] Surface type flags
     UINT_32                             bpp,            ///< [in] Bits per pixel
@@ -2097,7 +2103,7 @@ VOID SiAddrLib::HwlSetupTileInfo(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::DecodeGbRegs
+*   SiLib::DecodeGbRegs
 *
 *   @brief
 *       Decodes GB_ADDR_CONFIG and noOfBanks/noOfRanks
@@ -2107,7 +2113,7 @@ VOID SiAddrLib::HwlSetupTileInfo(
 *
 ****************************************************************************************************
 */
-BOOL_32 SiAddrLib::DecodeGbRegs(
+BOOL_32 SiLib::DecodeGbRegs(
     const ADDR_REGISTER_VALUE* pRegValue) ///< [in] create input
 {
     GB_ADDR_CONFIG  reg;
@@ -2186,7 +2192,7 @@ BOOL_32 SiAddrLib::DecodeGbRegs(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlInitGlobalParams
+*   SiLib::HwlInitGlobalParams
 *
 *   @brief
 *       Initializes global parameters
@@ -2196,7 +2202,7 @@ BOOL_32 SiAddrLib::DecodeGbRegs(
 *
 ****************************************************************************************************
 */
-BOOL_32 SiAddrLib::HwlInitGlobalParams(
+BOOL_32 SiLib::HwlInitGlobalParams(
     const ADDR_CREATE_INPUT* pCreateIn) ///< [in] create input
 {
     BOOL_32 valid = TRUE;
@@ -2235,21 +2241,21 @@ BOOL_32 SiAddrLib::HwlInitGlobalParams(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlConvertTileInfoToHW
+*   SiLib::HwlConvertTileInfoToHW
 *   @brief
 *       Entry of si's ConvertTileInfoToHW
 *   @return
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE SiAddrLib::HwlConvertTileInfoToHW(
+ADDR_E_RETURNCODE SiLib::HwlConvertTileInfoToHW(
     const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
     ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut      ///< [out] output structure
     ) const
 {
     ADDR_E_RETURNCODE retCode   = ADDR_OK;
 
-    retCode = EgBasedAddrLib::HwlConvertTileInfoToHW(pIn, pOut);
+    retCode = EgBasedLib::HwlConvertTileInfoToHW(pIn, pOut);
 
     if (retCode == ADDR_OK)
     {
@@ -2277,7 +2283,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlConvertTileInfoToHW(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe
+*   SiLib::HwlComputeXmaskCoordYFrom8Pipe
 *
 *   @brief
 *       Compute the Y coord which will be added to Xmask Y
@@ -2286,7 +2292,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlConvertTileInfoToHW(
 *       Y coord
 ****************************************************************************************************
 */
-UINT_32 SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe(
+UINT_32 SiLib::HwlComputeXmaskCoordYFrom8Pipe(
     UINT_32         pipe,       ///< [in] pipe id
     UINT_32         x           ///< [in] tile coord x, which is original x coord / 8
     ) const
@@ -2300,7 +2306,7 @@ UINT_32 SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe
+*   SiLib::HwlComputeSurfaceCoord2DFromBankPipe
 *
 *   @brief
 *       Compute surface x,y coordinates from bank/pipe info
@@ -2308,7 +2314,7 @@ UINT_32 SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe(
 *       N/A
 ****************************************************************************************************
 */
-VOID SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe(
+VOID SiLib::HwlComputeSurfaceCoord2DFromBankPipe(
     AddrTileMode        tileMode,   ///< [in] tile mode
     UINT_32*            pX,         ///< [in/out] x coordinate
     UINT_32*            pY,         ///< [in/out] y coordinate
@@ -2465,7 +2471,7 @@ VOID SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlPreAdjustBank
+*   SiLib::HwlPreAdjustBank
 *
 *   @brief
 *       Adjust bank before calculating address acoording to bank/pipe
@@ -2473,7 +2479,7 @@ VOID SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe(
 *       Adjusted bank
 ****************************************************************************************************
 */
-UINT_32 SiAddrLib::HwlPreAdjustBank(
+UINT_32 SiLib::HwlPreAdjustBank(
     UINT_32         tileX,      ///< [in] x coordinate in unit of tile
     UINT_32         bank,       ///< [in] bank
     ADDR_TILEINFO*  pTileInfo   ///< [in] tile info
@@ -2497,7 +2503,7 @@ UINT_32 SiAddrLib::HwlPreAdjustBank(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlComputeSurfaceInfo
+*   SiLib::HwlComputeSurfaceInfo
 *
 *   @brief
 *       Entry of si's ComputeSurfaceInfo
@@ -2505,14 +2511,14 @@ UINT_32 SiAddrLib::HwlPreAdjustBank(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE SiAddrLib::HwlComputeSurfaceInfo(
+ADDR_E_RETURNCODE SiLib::HwlComputeSurfaceInfo(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,    ///< [in] input structure
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut    ///< [out] output structure
     ) const
 {
     pOut->tileIndex = pIn->tileIndex;
 
-    ADDR_E_RETURNCODE retCode = EgBasedAddrLib::HwlComputeSurfaceInfo(pIn, pOut);
+    ADDR_E_RETURNCODE retCode = EgBasedLib::HwlComputeSurfaceInfo(pIn, pOut);
 
     UINT_32 tileIndex = static_cast<UINT_32>(pOut->tileIndex);
 
@@ -2541,14 +2547,14 @@ ADDR_E_RETURNCODE SiAddrLib::HwlComputeSurfaceInfo(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlComputeMipLevel
+*   SiLib::HwlComputeMipLevel
 *   @brief
 *       Compute MipLevel info (including level 0)
 *   @return
 *       TRUE if HWL's handled
 ****************************************************************************************************
 */
-BOOL_32 SiAddrLib::HwlComputeMipLevel(
+BOOL_32 SiLib::HwlComputeMipLevel(
     ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn ///< [in/out] Input structure
     ) const
 {
@@ -2558,7 +2564,7 @@ BOOL_32 SiAddrLib::HwlComputeMipLevel(
         // Note: Don't check expand 3x formats(96 bit) as the basePitch is not pow2 even if
         // we explicity set pow2Pad flag. The 3x base pitch is padded to pow2 but after being
         // divided by expandX factor (3) - to program texture pitch, the basePitch is never pow2.
-        if (AddrElemLib::IsExpand3x(pIn->format) == FALSE)
+        if (ElemLib::IsExpand3x(pIn->format) == FALSE)
         {
             // Sublevel pitches are generated from base level pitch instead of width on SI
             // If pow2Pad is 0, we don't assert - as this is not really used for a mip chain
@@ -2579,7 +2585,7 @@ BOOL_32 SiAddrLib::HwlComputeMipLevel(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlCheckLastMacroTiledLvl
+*   SiLib::HwlCheckLastMacroTiledLvl
 *
 *   @brief
 *       Sets pOut->last2DLevel to TRUE if it is
@@ -2587,7 +2593,7 @@ BOOL_32 SiAddrLib::HwlComputeMipLevel(
 *
 ****************************************************************************************************
 */
-VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
+VOID SiLib::HwlCheckLastMacroTiledLvl(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut      ///< [in/out] Output structure (used as input, too)
     ) const
@@ -2622,7 +2628,7 @@ VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
         nextHeight = pOut->height >> 1;
         // Special format such as FMT_1 and FMT_32_32_32 can be linear only so we consider block
         // compressed foramts
-        if (AddrElemLib::IsBlockCompressed(pIn->format))
+        if (ElemLib::IsBlockCompressed(pIn->format))
         {
             nextHeight = (nextHeight + 3) / 4;
         }
@@ -2654,7 +2660,7 @@ VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlDegradeThickTileMode
+*   SiLib::HwlDegradeThickTileMode
 *
 *   @brief
 *       Degrades valid tile mode for thick modes if needed
@@ -2663,18 +2669,18 @@ VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
 *       Suitable tile mode
 ****************************************************************************************************
 */
-AddrTileMode SiAddrLib::HwlDegradeThickTileMode(
+AddrTileMode SiLib::HwlDegradeThickTileMode(
     AddrTileMode        baseTileMode,   ///< [in] base tile mode
     UINT_32             numSlices,      ///< [in] current number of slices
     UINT_32*            pBytesPerTile   ///< [in/out] pointer to bytes per slice
     ) const
 {
-    return EgBasedAddrLib::HwlDegradeThickTileMode(baseTileMode, numSlices, pBytesPerTile);
+    return EgBasedLib::HwlDegradeThickTileMode(baseTileMode, numSlices, pBytesPerTile);
 }
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlTileInfoEqual
+*   SiLib::HwlTileInfoEqual
 *
 *   @brief
 *       Return TRUE if all field are equal
@@ -2682,7 +2688,7 @@ AddrTileMode SiAddrLib::HwlDegradeThickTileMode(
 *       Only takes care of current HWL's data
 ****************************************************************************************************
 */
-BOOL_32 SiAddrLib::HwlTileInfoEqual(
+BOOL_32 SiLib::HwlTileInfoEqual(
     const ADDR_TILEINFO* pLeft, ///<[in] Left compare operand
     const ADDR_TILEINFO* pRight ///<[in] Right compare operand
     ) const
@@ -2691,7 +2697,7 @@ BOOL_32 SiAddrLib::HwlTileInfoEqual(
 
     if (pLeft->pipeConfig == pRight->pipeConfig)
     {
-        equal =  EgBasedAddrLib::HwlTileInfoEqual(pLeft, pRight);
+        equal =  EgBasedLib::HwlTileInfoEqual(pLeft, pRight);
     }
 
     return equal;
@@ -2699,7 +2705,7 @@ BOOL_32 SiAddrLib::HwlTileInfoEqual(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::GetTileSettings
+*   SiLib::GetTileSettings
 *
 *   @brief
 *       Get tile setting infos by index.
@@ -2707,7 +2713,7 @@ BOOL_32 SiAddrLib::HwlTileInfoEqual(
 *       Tile setting info.
 ****************************************************************************************************
 */
-const AddrTileConfig* SiAddrLib::GetTileSetting(
+const TileConfig* SiLib::GetTileSetting(
     UINT_32 index          ///< [in] Tile index
     ) const
 {
@@ -2717,7 +2723,7 @@ const AddrTileConfig* SiAddrLib::GetTileSetting(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlPostCheckTileIndex
+*   SiLib::HwlPostCheckTileIndex
 *
 *   @brief
 *       Map a tile setting to index if curIndex is invalid, otherwise check if curIndex matches
@@ -2726,7 +2732,7 @@ const AddrTileConfig* SiAddrLib::GetTileSetting(
 *       Tile index.
 ****************************************************************************************************
 */
-INT_32 SiAddrLib::HwlPostCheckTileIndex(
+INT_32 SiLib::HwlPostCheckTileIndex(
     const ADDR_TILEINFO* pInfo,     ///< [in] Tile Info
     AddrTileMode         mode,      ///< [in] Tile mode
     AddrTileType         type,      ///< [in] Tile type
@@ -2796,7 +2802,7 @@ INT_32 SiAddrLib::HwlPostCheckTileIndex(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlSetupTileCfg
+*   SiLib::HwlSetupTileCfg
 *
 *   @brief
 *       Map tile index to tile setting.
@@ -2804,7 +2810,7 @@ INT_32 SiAddrLib::HwlPostCheckTileIndex(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE SiAddrLib::HwlSetupTileCfg(
+ADDR_E_RETURNCODE SiLib::HwlSetupTileCfg(
     UINT_32         bpp,            ///< [in] Bits per pixel
     INT_32          index,          ///< [in] Tile index
     INT_32          macroModeIndex, ///< [in] Index in macro tile mode table(CI)
@@ -2846,7 +2852,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlSetupTileCfg(
         }
         else
         {
-            const AddrTileConfig* pCfgTable = GetTileSetting(index);
+            const TileConfig* pCfgTable = GetTileSetting(index);
 
             if (pInfo)
             {
@@ -2877,17 +2883,17 @@ ADDR_E_RETURNCODE SiAddrLib::HwlSetupTileCfg(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::ReadGbTileMode
+*   SiLib::ReadGbTileMode
 *
 *   @brief
-*       Convert GB_TILE_MODE HW value to ADDR_TILE_CONFIG.
+*       Convert GB_TILE_MODE HW value to TileConfig.
 *   @return
 *       NA.
 ****************************************************************************************************
 */
-VOID SiAddrLib::ReadGbTileMode(
-    UINT_32             regValue,   ///< [in] GB_TILE_MODE register
-    AddrTileConfig*     pCfg        ///< [out] output structure
+VOID SiLib::ReadGbTileMode(
+    UINT_32     regValue,   ///< [in] GB_TILE_MODE register
+    TileConfig* pCfg        ///< [out] output structure
     ) const
 {
     GB_TILE_MODE gbTileMode;
@@ -2917,7 +2923,7 @@ VOID SiAddrLib::ReadGbTileMode(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::InitTileSettingTable
+*   SiLib::InitTileSettingTable
 *
 *   @brief
 *       Initialize the ADDR_TILE_CONFIG table.
@@ -2925,7 +2931,7 @@ VOID SiAddrLib::ReadGbTileMode(
 *       TRUE if tile table is correctly initialized
 ****************************************************************************************************
 */
-BOOL_32 SiAddrLib::InitTileSettingTable(
+BOOL_32 SiLib::InitTileSettingTable(
     const UINT_32*  pCfg,           ///< [in] Pointer to table of tile configs
     UINT_32         noOfEntries     ///< [in] Numbe of entries in the table above
     )
@@ -2968,7 +2974,7 @@ BOOL_32 SiAddrLib::InitTileSettingTable(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlGetTileIndex
+*   SiLib::HwlGetTileIndex
 *
 *   @brief
 *       Return the virtual/real index for given mode/type/info
@@ -2976,7 +2982,7 @@ BOOL_32 SiAddrLib::InitTileSettingTable(
 *       ADDR_OK if successful.
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE SiAddrLib::HwlGetTileIndex(
+ADDR_E_RETURNCODE SiLib::HwlGetTileIndex(
     const ADDR_GET_TILEINDEX_INPUT* pIn,
     ADDR_GET_TILEINDEX_OUTPUT*      pOut) const
 {
@@ -2989,7 +2995,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlGetTileIndex(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlFmaskPreThunkSurfInfo
+*   SiLib::HwlFmaskPreThunkSurfInfo
 *
 *   @brief
 *       Some preparation before thunking a ComputeSurfaceInfo call for Fmask
@@ -2997,7 +3003,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlGetTileIndex(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-VOID SiAddrLib::HwlFmaskPreThunkSurfInfo(
+VOID SiLib::HwlFmaskPreThunkSurfInfo(
     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pFmaskIn,   ///< [in] Input of fmask info
     const ADDR_COMPUTE_FMASK_INFO_OUTPUT*   pFmaskOut,  ///< [in] Output of fmask info
     ADDR_COMPUTE_SURFACE_INFO_INPUT*        pSurfIn,    ///< [out] Input of thunked surface info
@@ -3009,7 +3015,7 @@ VOID SiAddrLib::HwlFmaskPreThunkSurfInfo(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlFmaskPostThunkSurfInfo
+*   SiLib::HwlFmaskPostThunkSurfInfo
 *
 *   @brief
 *       Copy hwl extra field after calling thunked ComputeSurfaceInfo
@@ -3017,7 +3023,7 @@ VOID SiAddrLib::HwlFmaskPreThunkSurfInfo(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-VOID SiAddrLib::HwlFmaskPostThunkSurfInfo(
+VOID SiLib::HwlFmaskPostThunkSurfInfo(
     const ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pSurfOut,   ///< [in] Output of surface info
     ADDR_COMPUTE_FMASK_INFO_OUTPUT* pFmaskOut           ///< [out] Output of fmask info
     ) const
@@ -3028,14 +3034,14 @@ VOID SiAddrLib::HwlFmaskPostThunkSurfInfo(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlComputeFmaskBits
+*   SiLib::HwlComputeFmaskBits
 *   @brief
 *       Computes fmask bits
 *   @return
 *       Fmask bits
 ****************************************************************************************************
 */
-UINT_32 SiAddrLib::HwlComputeFmaskBits(
+UINT_32 SiLib::HwlComputeFmaskBits(
     const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn,
     UINT_32* pNumSamples
     ) const
@@ -3129,7 +3135,7 @@ UINT_32 SiAddrLib::HwlComputeFmaskBits(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlOverrideTileMode
+*   SiLib::HwlOverrideTileMode
 *
 *   @brief
 *       Override tile modes (for PRT only, avoid client passes in an invalid PRT mode for SI.
@@ -3139,7 +3145,7 @@ UINT_32 SiAddrLib::HwlComputeFmaskBits(
 *
 ****************************************************************************************************
 */
-void SiAddrLib::HwlOverrideTileMode(
+VOID SiLib::HwlOverrideTileMode(
     ADDR_COMPUTE_SURFACE_INFO_INPUT*    pInOut          ///< [in/out] input output structure
     ) const
 {
@@ -3199,7 +3205,7 @@ void SiAddrLib::HwlOverrideTileMode(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlSelectTileMode
+*   SiLib::HwlSelectTileMode
 *
 *   @brief
 *       Select tile modes.
@@ -3209,7 +3215,7 @@ void SiAddrLib::HwlOverrideTileMode(
 *
 ****************************************************************************************************
 */
-VOID SiAddrLib::HwlSelectTileMode(
+VOID SiLib::HwlSelectTileMode(
     ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut     ///< [in/out] input output structure
     ) const
 {
@@ -3275,7 +3281,7 @@ VOID SiAddrLib::HwlSelectTileMode(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::HwlGetMaxAlignments
+*   SiLib::HwlGetMaxAlignments
 *
 *   @brief
 *       Gets maximum alignments
@@ -3283,7 +3289,7 @@ VOID SiAddrLib::HwlSelectTileMode(
 *       ADDR_E_RETURNCODE
 ****************************************************************************************************
 */
-ADDR_E_RETURNCODE SiAddrLib::HwlGetMaxAlignments(
+ADDR_E_RETURNCODE SiLib::HwlGetMaxAlignments(
     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut    ///< [out] output structure
     ) const
 {
@@ -3321,7 +3327,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlGetMaxAlignments(
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::InitEquationTable
+*   SiLib::InitEquationTable
 *
 *   @brief
 *       Initialize Equation table.
@@ -3330,7 +3336,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlGetMaxAlignments(
 *       N/A
 ****************************************************************************************************
 */
-VOID SiAddrLib::InitEquationTable()
+VOID SiLib::InitEquationTable()
 {
     ADDR_EQUATION_KEY equationKeyTable[EquationTableSize];
     memset(equationKeyTable, 0, sizeof(equationKeyTable));
@@ -3354,7 +3360,7 @@ VOID SiAddrLib::InitEquationTable()
         {
             UINT_32 equationIndex = ADDR_INVALID_EQUATION_INDEX;
 
-            AddrTileConfig tileConfig = m_tileTable[tileIndex];
+            TileConfig tileConfig = m_tileTable[tileIndex];
 
             ADDR_SURFACE_FLAGS flags = {{0}};
 
@@ -3492,7 +3498,7 @@ VOID SiAddrLib::InitEquationTable()
 
 /**
 ****************************************************************************************************
-*   SiAddrLib::IsEquationSupported
+*   SiLib::IsEquationSupported
 *
 *   @brief
 *       Check if it is supported for given bpp and tile config to generate a equation.
@@ -3501,9 +3507,9 @@ VOID SiAddrLib::InitEquationTable()
 *       TRUE if supported
 ****************************************************************************************************
 */
-BOOL_32 SiAddrLib::IsEquationSupported(
+BOOL_32 SiLib::IsEquationSupported(
     UINT_32        bpp,         ///< Bits per pixel
-    AddrTileConfig tileConfig,  ///< Tile config
+    TileConfig tileConfig,  ///< Tile config
     INT_32         tileIndex    ///< Tile index
     ) const
 {
@@ -3540,7 +3546,7 @@ BOOL_32 SiAddrLib::IsEquationSupported(
 
         if ((supported == TRUE) && (m_chipFamily == ADDR_CHIP_FAMILY_SI))
         {
-            // Please refer to SiAddrLib::HwlSetupTileInfo for PRT tile index selecting
+            // Please refer to SiLib::HwlSetupTileInfo for PRT tile index selecting
             // Tile index 3, 6, 21-25 are for PRT single sample
             if (tileIndex == 3)
             {
@@ -3564,4 +3570,5 @@ BOOL_32 SiAddrLib::IsEquationSupported(
     return supported;
 }
 
-
+} // V1
+} // Addr
diff --git a/src/amd/addrlib/r800/siaddrlib.h b/src/amd/addrlib/r800/siaddrlib.h
index ef24dfbe560..b63d7e878dc 100644
--- a/src/amd/addrlib/r800/siaddrlib.h
+++ b/src/amd/addrlib/r800/siaddrlib.h
@@ -27,7 +27,7 @@
 /**
 ****************************************************************************************************
 * @file  siaddrlib.h
-* @brief Contains the R800AddrLib class definition.
+* @brief Contains the R800Lib class definition.
 ****************************************************************************************************
 */
 
@@ -37,12 +37,17 @@
 #include "addrlib1.h"
 #include "egbaddrlib.h"
 
+namespace Addr
+{
+namespace V1
+{
+
 /**
 ****************************************************************************************************
 * @brief Describes the information in tile mode table
 ****************************************************************************************************
 */
-struct AddrTileConfig
+struct TileConfig
 {
     AddrTileMode  mode;
     AddrTileType  type;
@@ -74,18 +79,18 @@ struct SIChipSettings
 *        function set.
 ****************************************************************************************************
 */
-class SiAddrLib : public EgBasedAddrLib
+class SiLib : public EgBasedLib
 {
 public:
-    /// Creates SIAddrLib object
-    static AddrLib* CreateObj(const AddrClient* pClient)
+    /// Creates SiLib object
+    static Addr::Lib* CreateObj(const Client* pClient)
     {
-        return new(pClient) SiAddrLib(pClient);
+        return new(pClient) SiLib(pClient);
     }
 
 protected:
-    SiAddrLib(const AddrClient* pClient);
-    virtual ~SiAddrLib();
+    SiLib(const Client* pClient);
+    virtual ~SiLib();
 
     // Hwl interface - defined in AddrLib1
     virtual ADDR_E_RETURNCODE HwlComputeSurfaceInfo(
@@ -113,7 +118,7 @@ protected:
     virtual BOOL_32 HwlComputeMipLevel(
         ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn) const;
 
-    virtual AddrChipFamily HwlConvertChipFamily(
+    virtual ChipFamily HwlConvertChipFamily(
         UINT_32 uChipFamily, UINT_32 uChipRevision);
 
     virtual BOOL_32 HwlInitGlobalParams(
@@ -157,7 +162,7 @@ protected:
     virtual UINT_32 HwlComputeXmaskCoordYFrom8Pipe(
         UINT_32 pipe, UINT_32 x) const;
 
-    // Sub-hwl interface - defined in EgBasedAddrLib
+    // Sub-hwl interface - defined in EgBasedLib
     virtual VOID HwlSetupTileInfo(
         AddrTileMode tileMode, ADDR_SURFACE_FLAGS flags,
         UINT_32 bpp, UINT_32 pitch, UINT_32 height, UINT_32 numSamples,
@@ -246,7 +251,7 @@ protected:
 
     // Check if it is supported for given bpp and tile config to generate an equation
     BOOL_32 IsEquationSupported(
-        UINT_32 bpp, AddrTileConfig tileConfig, INT_32 tileIndex) const;
+        UINT_32 bpp, TileConfig tileConfig, INT_32 tileIndex) const;
 
     // Protected non-virtual functions
     VOID ComputeTileCoordFromPipeAndElemIdx(
@@ -260,14 +265,14 @@ protected:
     BOOL_32 DecodeGbRegs(
         const ADDR_REGISTER_VALUE* pRegValue);
 
-    const AddrTileConfig* GetTileSetting(
+    const TileConfig* GetTileSetting(
         UINT_32 index) const;
 
     // Initialize equation table
     VOID InitEquationTable();
 
     static const UINT_32    TileTableSize = 32;
-    AddrTileConfig          m_tileTable[TileTableSize];
+    TileConfig          m_tileTable[TileTableSize];
     UINT_32                 m_noOfEntries;
 
     // Max number of bpp (8bpp/16bpp/32bpp/64bpp/128bpp)
@@ -288,13 +293,14 @@ private:
 
     UINT_32 GetPipePerSurf(AddrPipeCfg pipeConfig) const;
 
-    VOID ReadGbTileMode(
-        UINT_32 regValue, AddrTileConfig* pCfg) const;
-    BOOL_32 InitTileSettingTable(
-        const UINT_32 *pSetting, UINT_32 noOfEntries);
+    VOID ReadGbTileMode(UINT_32 regValue, TileConfig* pCfg) const;
+    BOOL_32 InitTileSettingTable(const UINT_32 *pSetting, UINT_32 noOfEntries);
 
     SIChipSettings          m_settings;
 };
 
+} // V1
+} // Addr
+
 #endif