amdgpu/addrlib: Adjust 99 "*" to 100 "*" alignment

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

18 files changed, 895 insertions, 895 deletions

diff --git a/src/amd/addrlib/addrinterface.cpp b/src/amd/addrlib/addrinterface.cpp
index 196cd69f6e1..c3eb598e34a 100644
--- a/src/amd/addrlib/addrinterface.cpp
+++ b/src/amd/addrlib/addrinterface.cpp
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  addrinterface.cpp
 * @brief Contains the addrlib interface functions
-***************************************************************************************************
+****************************************************************************************************
 */
 #include "addrinterface.h"
 #include "addrlib1.h"
@@ -40,7 +40,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrCreate
 *
 *   @brief
@@ -48,7 +48,7 @@
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrCreate(
     const ADDR_CREATE_INPUT*    pAddrCreateIn,  ///< [in] infomation for creating address lib object
@@ -64,7 +64,7 @@ ADDR_E_RETURNCODE ADDR_API AddrCreate(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrDestroy
 *
 *   @brief
@@ -72,7 +72,7 @@ ADDR_E_RETURNCODE ADDR_API AddrCreate(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrDestroy(
     ADDR_HANDLE hLib) ///< address lib handle
@@ -99,7 +99,7 @@ ADDR_E_RETURNCODE ADDR_API AddrDestroy(
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeSurfaceInfo
 *
 *   @brief
@@ -107,7 +107,7 @@ ADDR_E_RETURNCODE ADDR_API AddrDestroy(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
     ADDR_HANDLE                             hLib, ///< address lib handle
@@ -133,7 +133,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeSurfaceAddrFromCoord
 *
 *   @brief
@@ -141,7 +141,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
     ADDR_HANDLE                                     hLib, ///< address lib handle
@@ -165,7 +165,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeSurfaceCoordFromAddr
 *
 *   @brief
@@ -173,7 +173,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
     ADDR_HANDLE                                     hLib, ///< address lib handle
@@ -203,7 +203,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeHtileInfo
 *
 *   @brief
@@ -211,7 +211,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
     ADDR_HANDLE                             hLib, ///< address lib handle
@@ -235,7 +235,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeHtileAddrFromCoord
 *
 *   @brief
@@ -243,7 +243,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
     ADDR_HANDLE                                     hLib, ///< address lib handle
@@ -267,7 +267,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeHtileCoordFromAddr
 *
 *   @brief
@@ -276,7 +276,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
     ADDR_HANDLE                                     hLib, ///< address lib handle
@@ -306,7 +306,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeCmaskInfo
 *
 *   @brief
@@ -315,7 +315,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
     ADDR_HANDLE                             hLib, ///< address lib handle
@@ -339,7 +339,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeCmaskAddrFromCoord
 *
 *   @brief
@@ -347,7 +347,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
     ADDR_HANDLE                                     hLib, ///< address lib handle
@@ -371,7 +371,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeCmaskCoordFromAddr
 *
 *   @brief
@@ -380,7 +380,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
     ADDR_HANDLE                                     hLib, ///< address lib handle
@@ -410,7 +410,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeFmaskInfo
 *
 *   @brief
@@ -418,7 +418,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
     ADDR_HANDLE                             hLib, ///< address lib handle
@@ -442,7 +442,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeFmaskAddrFromCoord
 *
 *   @brief
@@ -450,7 +450,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
     ADDR_HANDLE                                     hLib, ///< address lib handle
@@ -474,7 +474,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeFmaskCoordFromAddr
 *
 *   @brief
@@ -482,7 +482,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
     ADDR_HANDLE                                     hLib, ///< address lib handle
@@ -512,13 +512,13 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeDccInfo
 *
 *   @brief
 *       Compute DCC key size, base alignment based on color surface size, tile info or tile index
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
     ADDR_HANDLE                             hLib,   ///< handle of addrlib
@@ -548,13 +548,13 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrGetVersion
 *
 *   @brief
 *       Get AddrLib version number. Client may check this return value against ADDRLIB_VERSION
 *       defined in addrinterface.h to see if there is a mismatch.
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib)
 {
@@ -573,12 +573,12 @@ UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib)
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrUseTileIndex
 *
 *   @brief
 *       Return TRUE if tileIndex is enabled in this address library
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib)
 {
@@ -597,12 +597,12 @@ BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib)
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrUseCombinedSwizzle
 *
 *   @brief
 *       Return TRUE if combined swizzle is enabled in this address library
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib)
 {
@@ -621,14 +621,14 @@ BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib)
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrExtractBankPipeSwizzle
 *
 *   @brief
 *       Extract Bank and Pipe swizzle from base256b
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
     ADDR_HANDLE                                 hLib,     ///< addrlib handle
@@ -652,14 +652,14 @@ ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrCombineBankPipeSwizzle
 *
 *   @brief
 *       Combine Bank and Pipe swizzle
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
     ADDR_HANDLE                                 hLib,
@@ -683,14 +683,14 @@ ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeSliceSwizzle
 *
 *   @brief
 *       Compute a swizzle for slice from a base swizzle
 *   @return
 *       ADDR_OK if no error
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
     ADDR_HANDLE                                 hLib,
@@ -714,14 +714,14 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeBaseSwizzle
 *
 *   @brief
 *       Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
 *   @return
 *       ADDR_OK if no error
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
     ADDR_HANDLE                             hLib,
@@ -745,7 +745,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ElemFlt32ToDepthPixel
 *
 *   @brief
@@ -754,7 +754,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
     ADDR_HANDLE                         hLib,    ///< addrlib handle
@@ -778,7 +778,7 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ElemFlt32ToColorPixel
 *
 *   @brief
@@ -787,7 +787,7 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
     ADDR_HANDLE                         hLib,    ///< addrlib handle
@@ -811,7 +811,7 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ElemGetExportNorm
 *
 *   @brief
@@ -820,7 +820,7 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
 *       FP16 can be reported as EXPORT_NORM for rv770 in r600
 *       family
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 ADDR_API ElemGetExportNorm(
     ADDR_HANDLE                     hLib, ///< addrlib handle
@@ -846,7 +846,7 @@ BOOL_32 ADDR_API ElemGetExportNorm(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrConvertTileInfoToHW
 *
 *   @brief
@@ -854,7 +854,7 @@ BOOL_32 ADDR_API ElemGetExportNorm(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
     ADDR_HANDLE                             hLib, ///< address lib handle
@@ -878,7 +878,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrConvertTileIndex
 *
 *   @brief
@@ -886,7 +886,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
     ADDR_HANDLE                          hLib, ///< address lib handle
@@ -910,7 +910,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrGetMacroModeIndex
 *
 *   @brief
@@ -918,7 +918,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
     ADDR_HANDLE                          hLib, ///< address lib handle
@@ -942,7 +942,7 @@ ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrConvertTileIndex1
 *
 *   @brief
@@ -950,7 +950,7 @@ ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
     ADDR_HANDLE                          hLib, ///< address lib handle
@@ -974,7 +974,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrGetTileIndex
 *
 *   @brief
@@ -985,7 +985,7 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
 *
 *   @note
 *       Only meaningful for SI (and above)
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
     ADDR_HANDLE                     hLib,
@@ -1009,13 +1009,13 @@ ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputePrtInfo
 *
 *   @brief
 *       Interface function for ComputePrtInfo
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
     ADDR_HANDLE                 hLib,
@@ -1039,7 +1039,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrGetMaxAlignments
 *
 *   @brief
@@ -1047,7 +1047,7 @@ ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
 *
 *   @return
 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
     ADDR_HANDLE                     hLib, ///< address lib handle
diff --git a/src/amd/addrlib/addrinterface.h b/src/amd/addrlib/addrinterface.h
index fef8d495701..3d525366f87 100644
--- a/src/amd/addrlib/addrinterface.h
+++ b/src/amd/addrlib/addrinterface.h
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  addrinterface.h
 * @brief Contains the addrlib interfaces declaration and parameter defines
-***************************************************************************************************
+****************************************************************************************************
 */
 #ifndef __ADDR_INTERFACE_H__
 #define __ADDR_INTERFACE_H__
@@ -118,9 +118,9 @@ typedef VOID*   ADDR_CLIENT_HANDLE;
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief channel setting structure
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef union _ADDR_CHANNEL_SETTING
 {
@@ -134,9 +134,9 @@ typedef union _ADDR_CHANNEL_SETTING
 } ADDR_CHANNEL_SETTING;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief address equation key structure
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef union _ADDR_EQUATION_KEY
 {
@@ -155,9 +155,9 @@ typedef union _ADDR_EQUATION_KEY
 } ADDR_EQUATION_KEY;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief address equation structure
-***************************************************************************************************
+****************************************************************************************************
 */
 #define ADDR_MAX_EQUATION_BIT 20u
 
@@ -177,11 +177,11 @@ typedef struct _ADDR_EQUATION
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief Alloc system memory flags.
 * @note These flags are reserved for future use and if flags are added will minimize the impact
 *       of the client.
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef union _ADDR_ALLOCSYSMEM_FLAGS
 {
@@ -194,9 +194,9 @@ typedef union _ADDR_ALLOCSYSMEM_FLAGS
 } ADDR_ALLOCSYSMEM_FLAGS;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief Alloc system memory input structure
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_ALLOCSYSMEM_INPUT
 {
@@ -208,19 +208,19 @@ typedef struct _ADDR_ALLOCSYSMEM_INPUT
 } ADDR_ALLOCSYSMEM_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * ADDR_ALLOCSYSMEM
 *   @brief
 *       Allocate system memory callback function. Returns valid pointer on success.
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef VOID* (ADDR_API* ADDR_ALLOCSYSMEM)(
     const ADDR_ALLOCSYSMEM_INPUT* pInput);
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief Free system memory input structure
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_FREESYSMEM_INPUT
 {
@@ -231,20 +231,20 @@ typedef struct _ADDR_FREESYSMEM_INPUT
 } ADDR_FREESYSMEM_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * ADDR_FREESYSMEM
 *   @brief
 *       Free system memory callback function.
 *       Returns ADDR_OK on success.
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_FREESYSMEM)(
     const ADDR_FREESYSMEM_INPUT* pInput);
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief Print debug message input structure
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_DEBUGPRINT_INPUT
 {
@@ -256,23 +256,23 @@ typedef struct _ADDR_DEBUGPRINT_INPUT
 } ADDR_DEBUGPRINT_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * ADDR_DEBUGPRINT
 *   @brief
 *       Print debug message callback function.
 *       Returns ADDR_OK on success.
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_DEBUGPRINT)(
     const ADDR_DEBUGPRINT_INPUT* pInput);
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * ADDR_CALLBACKS
 *
 *   @brief
 *       Address Library needs client to provide system memory alloc/free routines.
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_CALLBACKS
 {
@@ -286,13 +286,13 @@ typedef struct _ADDR_CALLBACKS
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * ADDR_CREATE_FLAGS
 *
 *   @brief
 *       This structure is used to pass some setup in creation of AddrLib
 *   @note
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef union _ADDR_CREATE_FLAGS
 {
@@ -313,12 +313,12 @@ typedef union _ADDR_CREATE_FLAGS
 } ADDR_CREATE_FLAGS;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_REGISTER_VALUE
 *
 *   @brief
 *       Data from registers to setup AddrLib global data, used in AddrCreate
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_REGISTER_VALUE
 {
@@ -348,13 +348,13 @@ typedef struct _ADDR_REGISTER_VALUE
 } ADDR_REGISTER_VALUE;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * ADDR_CREATE_INPUT
 *
 *   @brief
 *       Parameters use to create an AddrLib Object. Caller must provide all fields.
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_CREATE_INPUT
 {
@@ -371,13 +371,13 @@ typedef struct _ADDR_CREATE_INPUT
 } ADDR_CREATE_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * ADDR_CREATEINFO_OUTPUT
 *
 *   @brief
 *       Return AddrLib handle to client driver
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_CREATE_OUTPUT
 {
@@ -390,7 +390,7 @@ typedef struct _ADDR_CREATE_OUTPUT
 } ADDR_CREATE_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrCreate
 *
 *   @brief
@@ -398,7 +398,7 @@ typedef struct _ADDR_CREATE_OUTPUT
 *
 *   @return
 *       ADDR_OK if successful
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrCreate(
     const ADDR_CREATE_INPUT*    pAddrCreateIn,
@@ -407,7 +407,7 @@ ADDR_E_RETURNCODE ADDR_API AddrCreate(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrDestroy
 *
 *   @brief
@@ -415,7 +415,7 @@ ADDR_E_RETURNCODE ADDR_API AddrCreate(
 *
 *   @return
 *      ADDR_OK if successful
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrDestroy(
     ADDR_HANDLE hLib);
@@ -427,7 +427,7 @@ ADDR_E_RETURNCODE ADDR_API AddrDestroy(
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief
 *       Bank/tiling parameters. On function input, these can be set as desired or
 *       left 0 for AddrLib to calculate/default. On function output, these are the actual
@@ -440,7 +440,7 @@ ADDR_E_RETURNCODE ADDR_API AddrDestroy(
 *       macro tile as each pipe is selected, so the number of
 *       tiles in the x direction with the same bank number will
 *       be bank_width * num_pipes.
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_TILEINFO
 {
@@ -458,10 +458,10 @@ typedef struct _ADDR_TILEINFO
 typedef ADDR_TILEINFO ADDR_R800_TILEINFO;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief
 *       Information needed by quad buffer stereo support
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_QBSTEREOINFO
 {
@@ -471,12 +471,12 @@ typedef struct _ADDR_QBSTEREOINFO
 } ADDR_QBSTEREOINFO;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_SURFACE_FLAGS
 *
 *   @brief
 *       Surface flags
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef union _ADDR_SURFACE_FLAGS
 {
@@ -522,12 +522,12 @@ typedef union _ADDR_SURFACE_FLAGS
 } ADDR_SURFACE_FLAGS;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_SURFACE_INFO_INPUT
 *
 *   @brief
 *       Input structure for AddrComputeSurfaceInfo
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_SURFACE_INFO_INPUT
 {
@@ -560,7 +560,7 @@ typedef struct _ADDR_COMPUTE_SURFACE_INFO_INPUT
 } ADDR_COMPUTE_SURFACE_INFO_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_SURFACE_INFO_OUTPUT
 *
 *   @brief
@@ -568,7 +568,7 @@ typedef struct _ADDR_COMPUTE_SURFACE_INFO_INPUT
 *   @note
         Element: AddrLib unit for computing. e.g. BCn: 4x4 blocks; R32B32B32: 32bit with 3x pitch
         Pixel: Original pixel
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_SURFACE_INFO_OUTPUT
 {
@@ -623,12 +623,12 @@ typedef struct _ADDR_COMPUTE_SURFACE_INFO_OUTPUT
 } ADDR_COMPUTE_SURFACE_INFO_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeSurfaceInfo
 *
 *   @brief
 *       Compute surface width/height/depth/alignments and suitable tiling mode
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
     ADDR_HANDLE                             hLib,
@@ -638,12 +638,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
 *
 *   @brief
 *       Input structure for AddrComputeSurfaceAddrFromCoord
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
 {
@@ -701,12 +701,12 @@ typedef struct _ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
 } ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
 *
 *   @brief
 *       Output structure for AddrComputeSurfaceAddrFromCoord
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
 {
@@ -719,12 +719,12 @@ typedef struct _ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
 } ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeSurfaceAddrFromCoord
 *
 *   @brief
 *       Compute surface address from a given coordinate.
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
     ADDR_HANDLE                                     hLib,
@@ -734,12 +734,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
 *
 *   @brief
 *       Input structure for AddrComputeSurfaceCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
 {
@@ -789,12 +789,12 @@ typedef struct _ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
 } ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
 *
 *   @brief
 *       Output structure for AddrComputeSurfaceCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
 {
@@ -807,12 +807,12 @@ typedef struct _ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
 } ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeSurfaceCoordFromAddr
 *
 *   @brief
 *       Compute coordinate from a given surface address
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
     ADDR_HANDLE                                     hLib,
@@ -824,12 +824,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_HTILE_FLAGS
 *
 *   @brief
 *       HTILE flags
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef union _ADDR_HTILE_FLAGS
 {
@@ -843,12 +843,12 @@ typedef union _ADDR_HTILE_FLAGS
 } ADDR_HTILE_FLAGS;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_HTILE_INFO_INPUT
 *
 *   @brief
 *       Input structure of AddrComputeHtileInfo
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_HTILE_INFO_INPUT
 {
@@ -870,12 +870,12 @@ typedef struct _ADDR_COMPUTE_HTILE_INFO_INPUT
 } ADDR_COMPUTE_HTILE_INFO_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_HTILE_INFO_OUTPUT
 *
 *   @brief
 *       Output structure of AddrComputeHtileInfo
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_HTILE_INFO_OUTPUT
 {
@@ -894,12 +894,12 @@ typedef struct _ADDR_COMPUTE_HTILE_INFO_OUTPUT
 } ADDR_COMPUTE_HTILE_INFO_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeHtileInfo
 *
 *   @brief
 *       Compute Htile pitch, height, base alignment and size in bytes
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
     ADDR_HANDLE                             hLib,
@@ -909,12 +909,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
 *
 *   @brief
 *       Input structure for AddrComputeHtileAddrFromCoord
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
 {
@@ -941,12 +941,12 @@ typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
 } ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
 *
 *   @brief
 *       Output structure for AddrComputeHtileAddrFromCoord
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
 {
@@ -958,12 +958,12 @@ typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
 } ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeHtileAddrFromCoord
 *
 *   @brief
 *       Compute Htile address according to coordinates (of depth buffer)
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
     ADDR_HANDLE                                     hLib,
@@ -973,12 +973,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
 *
 *   @brief
 *       Input structure for AddrComputeHtileCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
 {
@@ -1002,12 +1002,12 @@ typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
 } ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
 *
 *   @brief
 *       Output structure for AddrComputeHtileCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
 {
@@ -1019,13 +1019,13 @@ typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
 } ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeHtileCoordFromAddr
 *
 *   @brief
 *       Compute coordinates within depth buffer (1st pixel of a micro tile) according to
 *       Htile address
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
     ADDR_HANDLE                                     hLib,
@@ -1039,12 +1039,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_CMASK_FLAGS
 *
 *   @brief
 *       CMASK flags
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef union _ADDR_CMASK_FLAGS
 {
@@ -1058,12 +1058,12 @@ typedef union _ADDR_CMASK_FLAGS
 } ADDR_CMASK_FLAGS;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_CMASK_INFO_INPUT
 *
 *   @brief
 *       Input structure of AddrComputeCmaskInfo
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_CMASKINFO_INPUT
 {
@@ -1083,12 +1083,12 @@ typedef struct _ADDR_COMPUTE_CMASKINFO_INPUT
 } ADDR_COMPUTE_CMASK_INFO_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_CMASK_INFO_OUTPUT
 *
 *   @brief
 *       Output structure of AddrComputeCmaskInfo
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_CMASK_INFO_OUTPUT
 {
@@ -1108,13 +1108,13 @@ typedef struct _ADDR_COMPUTE_CMASK_INFO_OUTPUT
 } ADDR_COMPUTE_CMASK_INFO_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeCmaskInfo
 *
 *   @brief
 *       Compute Cmask pitch, height, base alignment and size in bytes from color buffer
 *       info
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
     ADDR_HANDLE                             hLib,
@@ -1124,13 +1124,13 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
 *
 *   @brief
 *       Input structure for AddrComputeCmaskAddrFromCoord
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
 {
@@ -1154,12 +1154,12 @@ typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
 } ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
 *
 *   @brief
 *       Output structure for AddrComputeCmaskAddrFromCoord
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
 {
@@ -1171,12 +1171,12 @@ typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
 } ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeCmaskAddrFromCoord
 *
 *   @brief
 *       Compute Cmask address according to coordinates (of MSAA color buffer)
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
     ADDR_HANDLE                                     hLib,
@@ -1186,12 +1186,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
 *
 *   @brief
 *       Input structure for AddrComputeCmaskCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
 {
@@ -1213,12 +1213,12 @@ typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
 } ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
 *
 *   @brief
 *       Output structure for AddrComputeCmaskCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
 {
@@ -1230,13 +1230,13 @@ typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
 } ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeCmaskCoordFromAddr
 *
 *   @brief
 *       Compute coordinates within color buffer (1st pixel of a micro tile) according to
 *       Cmask address
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
     ADDR_HANDLE                                     hLib,
@@ -1250,12 +1250,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_FMASK_INFO_INPUT
 *
 *   @brief
 *       Input structure for AddrComputeFmaskInfo
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_FMASK_INFO_INPUT
 {
@@ -1282,12 +1282,12 @@ typedef struct _ADDR_COMPUTE_FMASK_INFO_INPUT
 } ADDR_COMPUTE_FMASK_INFO_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_FMASK_INFO_OUTPUT
 *
 *   @brief
 *       Output structure for AddrComputeFmaskInfo
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_FMASK_INFO_OUTPUT
 {
@@ -1313,12 +1313,12 @@ typedef struct _ADDR_COMPUTE_FMASK_INFO_OUTPUT
 } ADDR_COMPUTE_FMASK_INFO_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeFmaskInfo
 *
 *   @brief
 *       Compute Fmask pitch/height/depth/alignments and size in bytes
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
     ADDR_HANDLE                             hLib,
@@ -1328,12 +1328,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
 *
 *   @brief
 *       Input structure for AddrComputeFmaskAddrFromCoord
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
 {
@@ -1375,12 +1375,12 @@ typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
 } ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
 *
 *   @brief
 *       Output structure for AddrComputeFmaskAddrFromCoord
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
 {
@@ -1391,12 +1391,12 @@ typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
 } ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeFmaskAddrFromCoord
 *
 *   @brief
 *       Compute Fmask address according to coordinates (x,y,slice,sample,plane)
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
     ADDR_HANDLE                                     hLib,
@@ -1406,12 +1406,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
 *
 *   @brief
 *       Input structure for AddrComputeFmaskCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
 {
@@ -1447,12 +1447,12 @@ typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
 } ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
 *
 *   @brief
 *       Output structure for AddrComputeFmaskCoordFromAddr
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
 {
@@ -1466,12 +1466,12 @@ typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
 } ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeFmaskCoordFromAddr
 *
 *   @brief
 *       Compute FMASK coordinate from an given address
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
     ADDR_HANDLE                                     hLib,
@@ -1485,42 +1485,42 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrGetVersion
 *
 *   @brief
 *       Get AddrLib version number
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib);
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrUseTileIndex
 *
 *   @brief
 *       Return TRUE if tileIndex is enabled in this address library
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib);
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrUseCombinedSwizzle
 *
 *   @brief
 *       Return TRUE if combined swizzle is enabled in this address library
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib);
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
 *
 *   @brief
 *       Input structure of AddrExtractBankPipeSwizzle
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
 {
@@ -1538,12 +1538,12 @@ typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
 } ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
 *
 *   @brief
 *       Output structure of AddrExtractBankPipeSwizzle
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
 {
@@ -1554,14 +1554,14 @@ typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
 } ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrExtractBankPipeSwizzle
 *
 *   @brief
 *       Extract Bank and Pipe swizzle from base256b
 *   @return
 *       ADDR_OK if no error
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
     ADDR_HANDLE                                 hLib,
@@ -1570,12 +1570,12 @@ ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
 *
 *   @brief
 *       Input structure of AddrCombineBankPipeSwizzle
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
 {
@@ -1595,12 +1595,12 @@ typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
 } ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
 *
 *   @brief
 *       Output structure of AddrCombineBankPipeSwizzle
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
 {
@@ -1610,7 +1610,7 @@ typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
 } ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrCombineBankPipeSwizzle
 *
 *   @brief
@@ -1619,7 +1619,7 @@ typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
 *       ADDR_OK if no error
 *   @note
 *       baseAddr here is full MCAddress instead of base256b
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
     ADDR_HANDLE                                 hLib,
@@ -1629,12 +1629,12 @@ ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_SLICESWIZZLE_INPUT
 *
 *   @brief
 *       Input structure of AddrComputeSliceSwizzle
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_SLICESWIZZLE_INPUT
 {
@@ -1657,12 +1657,12 @@ typedef struct _ADDR_COMPUTE_SLICESWIZZLE_INPUT
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
 *
 *   @brief
 *       Output structure of AddrComputeSliceSwizzle
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
 {
@@ -1672,14 +1672,14 @@ typedef struct _ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
 } ADDR_COMPUTE_SLICESWIZZLE_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeSliceSwizzle
 *
 *   @brief
 *       Extract Bank and Pipe swizzle from base256b
 *   @return
 *       ADDR_OK if no error
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
     ADDR_HANDLE                             hLib,
@@ -1688,12 +1688,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrSwizzleGenOption
 *
 *   @brief
 *       Which swizzle generating options: legacy or linear
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef enum _AddrSwizzleGenOption
 {
@@ -1702,12 +1702,12 @@ typedef enum _AddrSwizzleGenOption
 } AddrSwizzleGenOption;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrSwizzleOption
 *
 *   @brief
 *       Controls how swizzle is generated
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef union _ADDR_SWIZZLE_OPTION
 {
@@ -1723,12 +1723,12 @@ typedef union _ADDR_SWIZZLE_OPTION
 } ADDR_SWIZZLE_OPTION;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_BASE_SWIZZLE_INPUT
 *
 *   @brief
 *       Input structure of AddrComputeBaseSwizzle
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_INPUT
 {
@@ -1748,12 +1748,12 @@ typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_INPUT
 } ADDR_COMPUTE_BASE_SWIZZLE_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
 *
 *   @brief
 *       Output structure of AddrComputeBaseSwizzle
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
 {
@@ -1763,14 +1763,14 @@ typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
 } ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeBaseSwizzle
 *
 *   @brief
 *       Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
 *   @return
 *       ADDR_OK if no error
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
     ADDR_HANDLE                             hLib,
@@ -1780,13 +1780,13 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ELEM_GETEXPORTNORM_INPUT
 *
 *   @brief
 *       Input structure for ElemGetExportNorm
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ELEM_GETEXPORTNORM_INPUT
 {
@@ -1799,7 +1799,7 @@ typedef struct _ELEM_GETEXPORTNORM_INPUT
 } ELEM_GETEXPORTNORM_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *  ElemGetExportNorm
 *
 *   @brief
@@ -1813,7 +1813,7 @@ typedef struct _ELEM_GETEXPORTNORM_INPUT
 *       01 - EXPORT_NORM: PS exports are 4 pixels with 4 components with 16-bits-per-component. (one
 *       clock per export)
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 ADDR_API ElemGetExportNorm(
     ADDR_HANDLE                     hLib,
@@ -1822,13 +1822,13 @@ BOOL_32 ADDR_API ElemGetExportNorm(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ELEM_FLT32TODEPTHPIXEL_INPUT
 *
 *   @brief
 *       Input structure for addrFlt32ToDepthPixel
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ELEM_FLT32TODEPTHPIXEL_INPUT
 {
@@ -1839,13 +1839,13 @@ typedef struct _ELEM_FLT32TODEPTHPIXEL_INPUT
 } ELEM_FLT32TODEPTHPIXEL_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ELEM_FLT32TODEPTHPIXEL_INPUT
 *
 *   @brief
 *       Output structure for ElemFlt32ToDepthPixel
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ELEM_FLT32TODEPTHPIXEL_OUTPUT
 {
@@ -1860,7 +1860,7 @@ typedef struct _ELEM_FLT32TODEPTHPIXEL_OUTPUT
 } ELEM_FLT32TODEPTHPIXEL_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ElemFlt32ToDepthPixel
 *
 *   @brief
@@ -1869,7 +1869,7 @@ typedef struct _ELEM_FLT32TODEPTHPIXEL_OUTPUT
 *   @return
 *       Return code
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
     ADDR_HANDLE                         hLib,
@@ -1879,13 +1879,13 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ELEM_FLT32TOCOLORPIXEL_INPUT
 *
 *   @brief
 *       Input structure for addrFlt32ToColorPixel
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ELEM_FLT32TOCOLORPIXEL_INPUT
 {
@@ -1898,13 +1898,13 @@ typedef struct _ELEM_FLT32TOCOLORPIXEL_INPUT
 } ELEM_FLT32TOCOLORPIXEL_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ELEM_FLT32TOCOLORPIXEL_INPUT
 *
 *   @brief
 *       Output structure for ElemFlt32ToColorPixel
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ELEM_FLT32TOCOLORPIXEL_OUTPUT
 {
@@ -1915,7 +1915,7 @@ typedef struct _ELEM_FLT32TOCOLORPIXEL_OUTPUT
 } ELEM_FLT32TOCOLORPIXEL_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ElemFlt32ToColorPixel
 *
 *   @brief
@@ -1924,7 +1924,7 @@ typedef struct _ELEM_FLT32TOCOLORPIXEL_OUTPUT
 *   @return
 *       Return code
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
     ADDR_HANDLE                         hLib,
@@ -1933,14 +1933,14 @@ ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_CONVERT_TILEINFOTOHW_INPUT
 *
 *   @brief
 *       Input structure for AddrConvertTileInfoToHW
 *   @note
 *       When reverse is TRUE, indices are igonred
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_CONVERT_TILEINFOTOHW_INPUT
 {
@@ -1960,12 +1960,12 @@ typedef struct _ADDR_CONVERT_TILEINFOTOHW_INPUT
 } ADDR_CONVERT_TILEINFOTOHW_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_CONVERT_TILEINFOTOHW_OUTPUT
 *
 *   @brief
 *       Output structure for AddrConvertTileInfoToHW
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_CONVERT_TILEINFOTOHW_OUTPUT
 {
@@ -1977,12 +1977,12 @@ typedef struct _ADDR_CONVERT_TILEINFOTOHW_OUTPUT
 } ADDR_CONVERT_TILEINFOTOHW_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrConvertTileInfoToHW
 *
 *   @brief
 *       Convert tile info from real value to hardware register value
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
     ADDR_HANDLE                             hLib,
@@ -1992,12 +1992,12 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_CONVERT_TILEINDEX_INPUT
 *
 *   @brief
 *       Input structure for AddrConvertTileIndex
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_CONVERT_TILEINDEX_INPUT
 {
@@ -2010,12 +2010,12 @@ typedef struct _ADDR_CONVERT_TILEINDEX_INPUT
 } ADDR_CONVERT_TILEINDEX_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_CONVERT_TILEINDEX_OUTPUT
 *
 *   @brief
 *       Output structure for AddrConvertTileIndex
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_CONVERT_TILEINDEX_OUTPUT
 {
@@ -2028,12 +2028,12 @@ typedef struct _ADDR_CONVERT_TILEINDEX_OUTPUT
 } ADDR_CONVERT_TILEINDEX_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrConvertTileIndex
 *
 *   @brief
 *       Convert tile index to tile mode/type/info
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
     ADDR_HANDLE                         hLib,
@@ -2041,12 +2041,12 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
     ADDR_CONVERT_TILEINDEX_OUTPUT*      pOut);
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_GET_MACROMODEINDEX_INPUT
 *
 *   @brief
 *       Input structure for AddrGetMacroModeIndex
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_GET_MACROMODEINDEX_INPUT
 {
@@ -2058,12 +2058,12 @@ typedef struct _ADDR_GET_MACROMODEINDEX_INPUT
 } ADDR_GET_MACROMODEINDEX_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_GET_MACROMODEINDEX_OUTPUT
 *
 *   @brief
 *       Output structure for AddrGetMacroModeIndex
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_GET_MACROMODEINDEX_OUTPUT
 {
@@ -2072,12 +2072,12 @@ typedef struct _ADDR_GET_MACROMODEINDEX_OUTPUT
 } ADDR_GET_MACROMODEINDEX_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrGetMacroModeIndex
 *
 *   @brief
 *       Get macro mode index based on input parameters
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
     ADDR_HANDLE                          hLib,
@@ -2085,12 +2085,12 @@ ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
     ADDR_GET_MACROMODEINDEX_OUTPUT*      pOut);
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_CONVERT_TILEINDEX1_INPUT
 *
 *   @brief
 *       Input structure for AddrConvertTileIndex1 (without macro mode index)
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_CONVERT_TILEINDEX1_INPUT
 {
@@ -2103,12 +2103,12 @@ typedef struct _ADDR_CONVERT_TILEINDEX1_INPUT
 } ADDR_CONVERT_TILEINDEX1_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrConvertTileIndex1
 *
 *   @brief
 *       Convert tile index to tile mode/type/info
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
     ADDR_HANDLE                             hLib,
@@ -2118,12 +2118,12 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_GET_TILEINDEX_INPUT
 *
 *   @brief
 *       Input structure for AddrGetTileIndex
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_GET_TILEINDEX_INPUT
 {
@@ -2135,12 +2135,12 @@ typedef struct _ADDR_GET_TILEINDEX_INPUT
 } ADDR_GET_TILEINDEX_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_GET_TILEINDEX_OUTPUT
 *
 *   @brief
 *       Output structure for AddrGetTileIndex
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_GET_TILEINDEX_OUTPUT
 {
@@ -2150,12 +2150,12 @@ typedef struct _ADDR_GET_TILEINDEX_OUTPUT
 } ADDR_GET_TILEINDEX_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrGetTileIndex
 *
 *   @brief
 *       Get the tiling mode index in table
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
     ADDR_HANDLE                     hLib,
@@ -2166,12 +2166,12 @@ ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_PRT_INFO_INPUT
 *
 *   @brief
 *       Input structure for AddrComputePrtInfo
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_PRT_INFO_INPUT
 {
@@ -2183,12 +2183,12 @@ typedef struct _ADDR_PRT_INFO_INPUT
 } ADDR_PRT_INFO_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_PRT_INFO_OUTPUT
 *
 *   @brief
 *       Input structure for AddrComputePrtInfo
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_PRT_INFO_OUTPUT
 {
@@ -2197,12 +2197,12 @@ typedef struct _ADDR_PRT_INFO_OUTPUT
 } ADDR_PRT_INFO_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputePrtInfo
 *
 *   @brief
 *       Compute prt surface related information
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
     ADDR_HANDLE                 hLib,
@@ -2214,12 +2214,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   _ADDR_COMPUTE_DCCINFO_INPUT
 *
 *   @brief
 *       Input structure of AddrComputeDccInfo
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_DCCINFO_INPUT
 {
@@ -2238,12 +2238,12 @@ typedef struct _ADDR_COMPUTE_DCCINFO_INPUT
 } ADDR_COMPUTE_DCCINFO_INPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_COMPUTE_DCCINFO_OUTPUT
 *
 *   @brief
 *       Output structure of AddrComputeDccInfo
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_COMPUTE_DCCINFO_OUTPUT
 {
@@ -2256,13 +2256,13 @@ typedef struct _ADDR_COMPUTE_DCCINFO_OUTPUT
 } ADDR_COMPUTE_DCCINFO_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrComputeDccInfo
 *
 *   @brief
 *       Compute DCC key size, base alignment
 *       info
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
     ADDR_HANDLE                             hLib,
@@ -2270,12 +2270,12 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
     ADDR_COMPUTE_DCCINFO_OUTPUT*            pOut);
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_GET_MAX_ALINGMENTS_OUTPUT
 *
 *   @brief
 *       Output structure of AddrGetMaxAlignments
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef struct _ADDR_GET_MAX_ALINGMENTS_OUTPUT
 {
@@ -2284,12 +2284,12 @@ typedef struct _ADDR_GET_MAX_ALINGMENTS_OUTPUT
 } ADDR_GET_MAX_ALINGMENTS_OUTPUT;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrGetMaxAlignments
 *
 *   @brief
 *       Gets maximnum alignments
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
     ADDR_HANDLE                     hLib,
diff --git a/src/amd/addrlib/addrtypes.h b/src/amd/addrlib/addrtypes.h
index 681bb24aaf5..6fb11d00440 100644
--- a/src/amd/addrlib/addrtypes.h
+++ b/src/amd/addrlib/addrtypes.h
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  addrtypes.h
 * @brief Contains the helper function and constants
-***************************************************************************************************
+****************************************************************************************************
 */
 #ifndef __ADDR_TYPES_H__
 #define __ADDR_TYPES_H__
@@ -62,9 +62,9 @@ typedef int            INT;
 #endif // defined (__APPLE__) && !defined(HAVE_TSERVER)
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   Calling conventions
-***************************************************************************************************
+****************************************************************************************************
 */
 #ifndef ADDR_CDECL
     #if defined(__GNUC__)
@@ -121,9 +121,9 @@ typedef int            INT;
 #define ADDR_API ADDR_FASTCALL //default call convention is fast call
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * Global defines used by other modules
-***************************************************************************************************
+****************************************************************************************************
 */
 #if !defined(TILEINDEX_INVALID)
 #define TILEINDEX_INVALID                -1
@@ -138,9 +138,9 @@ typedef int            INT;
 #endif
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * Return codes
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef enum _ADDR_E_RETURNCODE
 {
@@ -159,14 +159,14 @@ typedef enum _ADDR_E_RETURNCODE
 } ADDR_E_RETURNCODE;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief
 *   Neutral enums that define tile modes for all H/W
 * @note
 *   R600/R800 tiling mode can be cast to hw enums directly but never cast into HW enum from
 *   ADDR_TM_2D_TILED_XTHICK
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef enum _AddrTileMode
 {
@@ -200,13 +200,13 @@ typedef enum _AddrTileMode
 } AddrTileMode;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrFormat
 *
 *   @brief
 *       Neutral enum for SurfaceFormat
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef enum _AddrFormat {
     ADDR_FMT_INVALID                              = 0x00000000,
@@ -276,13 +276,13 @@ typedef enum _AddrFormat {
 } AddrFormat;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrDepthFormat
 *
 *   @brief
 *       Neutral enum for addrFlt32ToDepthPixel
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef enum _AddrDepthFormat
 {
@@ -298,13 +298,13 @@ typedef enum _AddrDepthFormat
 } AddrDepthFormat;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrColorFormat
 *
 *   @brief
 *       Neutral enum for ColorFormat
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef enum _AddrColorFormat
 {
@@ -347,13 +347,13 @@ typedef enum _AddrColorFormat
 } AddrColorFormat;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrSurfaceNumber
 *
 *   @brief
 *       Neutral enum for SurfaceNumber
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef enum _AddrSurfaceNumber {
     ADDR_NUMBER_UNORM                             = 0x00000000,
@@ -367,13 +367,13 @@ typedef enum _AddrSurfaceNumber {
 } AddrSurfaceNumber;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrSurfaceSwap
 *
 *   @brief
 *       Neutral enum for SurfaceSwap
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef enum _AddrSurfaceSwap {
     ADDR_SWAP_STD                                 = 0x00000000,
@@ -383,12 +383,12 @@ typedef enum _AddrSurfaceSwap {
 } AddrSurfaceSwap;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrHtileBlockSize
 *
 *   @brief
 *       Size of HTILE blocks, valid values are 4 or 8 for now
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef enum _AddrHtileBlockSize
 {
@@ -398,7 +398,7 @@ typedef enum _AddrHtileBlockSize
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrPipeCfg
 *
 *   @brief
@@ -411,7 +411,7 @@ typedef enum _AddrHtileBlockSize
 *       For hw configurations w/ non-pow2 memory number of memory channels, it usually matches
 *       the number of ROP units(? TODO: which registers??)
 *       The enum value = hw enum + 1 which is to reserve 0 for requesting default.
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef enum _AddrPipeCfg
 {
@@ -434,12 +434,12 @@ typedef enum _AddrPipeCfg
 } AddrPipeCfg;
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * AddrTileType
 *
 *   @brief
 *       Neutral enums that specifies micro tile type (MICRO_TILE_MODE)
-***************************************************************************************************
+****************************************************************************************************
 */
 typedef enum _AddrTileType
 {
diff --git a/src/amd/addrlib/core/addrcommon.h b/src/amd/addrlib/core/addrcommon.h
index 8199f76e502..5c17f80caf7 100644
--- a/src/amd/addrlib/core/addrcommon.h
+++ b/src/amd/addrlib/core/addrcommon.h
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  addrcommon.h
 * @brief Contains the helper function and constants
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #ifndef __ADDR_COMMON_H__
@@ -75,9 +75,9 @@ static const INT_32 TileIndexNoMacroIndex   = -3;
 #define _BIT(v,b)      (((v) >> (b) ) & 1)
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief Enums to identify AddrLib type
-***************************************************************************************************
+****************************************************************************************************
 */
 enum AddrLibClass
 {
@@ -89,13 +89,13 @@ enum AddrLibClass
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * AddrChipFamily
 *
 *   @brief
 *       Neutral enums that specifies chip family.
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 enum AddrChipFamily
 {
@@ -110,12 +110,12 @@ enum AddrChipFamily
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * AddrConfigFlags
 *
 *   @brief
 *       This structure is used to set configuration flags.
-***************************************************************************************************
+****************************************************************************************************
 */
 union AddrConfigFlags
 {
@@ -261,12 +261,12 @@ union AddrConfigFlags
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrXorReduce
 *
 *   @brief
 *       Xor the right-side numberOfBits bits of x.
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline UINT_32 XorReduce(
     UINT_32 x,
@@ -284,12 +284,12 @@ static inline UINT_32 XorReduce(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   IsPow2
 *
 *   @brief
 *       Check if the size (UINT_32) is pow 2
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline UINT_32 IsPow2(
     UINT_32 dim)        ///< [in] dimension of miplevel
@@ -299,12 +299,12 @@ static inline UINT_32 IsPow2(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   IsPow2
 *
 *   @brief
 *       Check if the size (UINT_64) is pow 2
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline UINT_64 IsPow2(
     UINT_64 dim)        ///< [in] dimension of miplevel
@@ -314,12 +314,12 @@ static inline UINT_64 IsPow2(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ByteAlign
 *
 *   @brief
 *       Align UINT_32 "x" to "align" alignment, "align" should be power of 2
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline UINT_32 PowTwoAlign(
     UINT_32 x,
@@ -333,12 +333,12 @@ static inline UINT_32 PowTwoAlign(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ByteAlign
 *
 *   @brief
 *       Align UINT_64 "x" to "align" alignment, "align" should be power of 2
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline UINT_64 PowTwoAlign(
     UINT_64 x,
@@ -352,12 +352,12 @@ static inline UINT_64 PowTwoAlign(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   Min
 *
 *   @brief
 *       Get the min value between two unsigned values
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline UINT_32 Min(
     UINT_32 value1,
@@ -367,12 +367,12 @@ static inline UINT_32 Min(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   Min
 *
 *   @brief
 *       Get the min value between two signed values
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline INT_32 Min(
     INT_32 value1,
@@ -382,12 +382,12 @@ static inline INT_32 Min(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   Max
 *
 *   @brief
 *       Get the max value between two unsigned values
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline UINT_32 Max(
     UINT_32 value1,
@@ -397,12 +397,12 @@ static inline UINT_32 Max(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   Max
 *
 *   @brief
 *       Get the max value between two signed values
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline INT_32 Max(
     INT_32 value1,
@@ -412,12 +412,12 @@ static inline INT_32 Max(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   NextPow2
 *
 *   @brief
 *       Compute the mipmap's next level dim size
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline UINT_32 NextPow2(
     UINT_32 dim)        ///< [in] dimension of miplevel
@@ -443,12 +443,12 @@ static inline UINT_32 NextPow2(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   Log2NonPow2
 *
 *   @brief
 *       Compute log of base 2 no matter the target is power of 2 or not
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline UINT_32 Log2NonPow2(
     UINT_32 x)      ///< [in] the value should calculate log based 2
@@ -466,12 +466,12 @@ static inline UINT_32 Log2NonPow2(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   Log2
 *
 *   @brief
 *       Compute log of base 2
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline UINT_32 Log2(
     UINT_32 x)      ///< [in] the value should calculate log based 2
@@ -483,12 +483,12 @@ static inline UINT_32 Log2(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   QLog2
 *
 *   @brief
 *       Compute log of base 2 quickly (<= 16)
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline UINT_32 QLog2(
     UINT_32 x)      ///< [in] the value should calculate log based 2
@@ -522,12 +522,12 @@ static inline UINT_32 QLog2(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SafeAssign
 *
 *   @brief
 *       NULL pointer safe assignment
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline VOID SafeAssign(
     UINT_32*    pLVal,  ///< [in] Pointer to left val
@@ -540,12 +540,12 @@ static inline VOID SafeAssign(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SafeAssign
 *
 *   @brief
 *       NULL pointer safe assignment for 64bit values
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline VOID SafeAssign(
     UINT_64*    pLVal,  ///< [in] Pointer to left val
@@ -558,12 +558,12 @@ static inline VOID SafeAssign(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SafeAssign
 *
 *   @brief
 *       NULL pointer safe assignment for AddrTileMode
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline VOID SafeAssign(
     AddrTileMode*    pLVal, ///< [in] Pointer to left val
@@ -576,12 +576,12 @@ static inline VOID SafeAssign(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   InitChannel
 *
 *   @brief
 *       Get channel initialization value
-***************************************************************************************************
+****************************************************************************************************
 */
 static inline ADDR_CHANNEL_SETTING InitChannel(
     UINT_32     valid,     ///< [in] valid setting
diff --git a/src/amd/addrlib/core/addrelemlib.cpp b/src/amd/addrlib/core/addrelemlib.cpp
index 76b1badf958..2ec518f6687 100644
--- a/src/amd/addrlib/core/addrelemlib.cpp
+++ b/src/amd/addrlib/core/addrelemlib.cpp
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  addrelemlib.cpp
 * @brief Contains the class implementation for element/pixel related functions
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #include "addrelemlib.h"
@@ -36,7 +36,7 @@
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::AddrElemLib
 *
 *   @brief
@@ -44,7 +44,7 @@
 *
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrElemLib::AddrElemLib(
     AddrLib* const pAddrLib) :  ///< [in] Parent addrlib instance pointer
@@ -75,7 +75,7 @@ AddrElemLib::AddrElemLib(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::~AddrElemLib
 *
 *   @brief
@@ -83,14 +83,14 @@ AddrElemLib::AddrElemLib(
 *
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrElemLib::~AddrElemLib()
 {
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::Create
 *
 *   @brief
@@ -98,7 +98,7 @@ AddrElemLib::~AddrElemLib()
 *
 *   @return
 *       Returns point to ADDR_CREATEINFO if successful.
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrElemLib* AddrElemLib::Create(
     const AddrLib* const        pAddrLib)   ///< [in] Pointer of parent AddrLib instance
@@ -121,7 +121,7 @@ AddrElemLib* AddrElemLib::Create(
 *
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrElemLib::Flt32sToInt32s(
     ADDR_FLT_32     value,      ///< [in] ADDR_FLT_32 value
@@ -303,7 +303,7 @@ VOID AddrElemLib::Flt32sToInt32s(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::Int32sToPixel
 *
 *   @brief
@@ -318,7 +318,7 @@ VOID AddrElemLib::Flt32sToInt32s(
 *       an uncompressed pixel. The pixel values are specifies in
 *       standard order, e.g. depth/stencil. This routine asserts
 *       if called on compressed pixel.
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrElemLib::Int32sToPixel(
     UINT_32              numComps,      ///< [in] number of components
@@ -376,7 +376,7 @@ VOID AddrElemLib::Int32sToPixel(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   Flt32ToDepthPixel
 *
 *   @brief
@@ -384,7 +384,7 @@ VOID AddrElemLib::Int32sToPixel(
 *
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrElemLib::Flt32ToDepthPixel(
     AddrDepthFormat     format,     ///< [in] Depth format
@@ -445,7 +445,7 @@ VOID AddrElemLib::Flt32ToDepthPixel(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   Flt32ToColorPixel
 *
 *   @brief
@@ -453,7 +453,7 @@ VOID AddrElemLib::Flt32ToDepthPixel(
 *
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrElemLib::Flt32ToColorPixel(
     AddrColorFormat     format,     ///< [in] Color format
@@ -531,7 +531,7 @@ VOID AddrElemLib::Flt32ToColorPixel(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::GetCompType
 *
 *   @brief
@@ -540,7 +540,7 @@ VOID AddrElemLib::Flt32ToColorPixel(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrElemLib::GetCompType(
     AddrColorFormat         format,     ///< [in] surface format
@@ -704,7 +704,7 @@ VOID AddrElemLib::GetCompType(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::GetCompSwap
 *
 *   @brief
@@ -713,7 +713,7 @@ VOID AddrElemLib::GetCompType(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrElemLib::GetCompSwap(
     AddrSurfaceSwap         swap,   ///< [in] swap mode
@@ -794,7 +794,7 @@ VOID AddrElemLib::GetCompSwap(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::GetCompSwap
 *
 *   @brief
@@ -803,7 +803,7 @@ VOID AddrElemLib::GetCompSwap(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrElemLib::SwapComps(
     UINT_32                 c0,     ///< [in] component index 0
@@ -823,7 +823,7 @@ VOID AddrElemLib::SwapComps(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::PixGetColorCompInfo
 *
 *   @brief
@@ -832,7 +832,7 @@ VOID AddrElemLib::SwapComps(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrElemLib::PixGetColorCompInfo(
     AddrColorFormat         format, ///< [in] surface format, read from register
@@ -960,7 +960,7 @@ VOID AddrElemLib::PixGetColorCompInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::PixGetDepthCompInfo
 *
 *   @brief
@@ -969,7 +969,7 @@ VOID AddrElemLib::PixGetColorCompInfo(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrElemLib::PixGetDepthCompInfo(
     AddrDepthFormat         format,     ///< [in] surface format, read from register
@@ -1058,7 +1058,7 @@ VOID AddrElemLib::PixGetDepthCompInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::PixGetExportNorm
 *
 *   @brief
@@ -1067,7 +1067,7 @@ VOID AddrElemLib::PixGetDepthCompInfo(
 *   @return
 *       TRUE if this can be enabled.
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 AddrElemLib::PixGetExportNorm(
     AddrColorFormat     colorFmt,       ///< [in] surface format, read from register
@@ -1110,7 +1110,7 @@ BOOL_32 AddrElemLib::PixGetExportNorm(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::AdjustSurfaceInfo
 *
 *   @brief
@@ -1118,7 +1118,7 @@ BOOL_32 AddrElemLib::PixGetExportNorm(
 *
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrElemLib::AdjustSurfaceInfo(
     AddrElemMode    elemMode,       ///< [in] element mode
@@ -1235,7 +1235,7 @@ VOID AddrElemLib::AdjustSurfaceInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::RestoreSurfaceInfo
 *
 *   @brief
@@ -1243,7 +1243,7 @@ VOID AddrElemLib::AdjustSurfaceInfo(
 *
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrElemLib::RestoreSurfaceInfo(
     AddrElemMode    elemMode,       ///< [in] element mode
@@ -1327,7 +1327,7 @@ VOID AddrElemLib::RestoreSurfaceInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::GetBitsPerPixel
 *
 *   @brief
@@ -1337,7 +1337,7 @@ VOID AddrElemLib::RestoreSurfaceInfo(
 *
 *   @return
 *       Bits per pixel
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 AddrElemLib::GetBitsPerPixel(
     AddrFormat          format,         ///< [in] surface format code
@@ -1496,7 +1496,7 @@ UINT_32 AddrElemLib::GetBitsPerPixel(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::GetCompBits
 *
 *   @brief
@@ -1504,7 +1504,7 @@ UINT_32 AddrElemLib::GetBitsPerPixel(
 *
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrElemLib::GetCompBits(
     UINT_32 c0,                     ///< [in] bits of component 0
@@ -1543,7 +1543,7 @@ VOID AddrElemLib::GetCompBits(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::GetCompBits
 *
 *   @brief
@@ -1555,7 +1555,7 @@ VOID AddrElemLib::GetCompBits(
 *
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrElemLib::SetClearComps(
     ADDR_FLT_32 comps[4],   ///< [in/out] components
@@ -1599,7 +1599,7 @@ VOID AddrElemLib::SetClearComps(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::IsBlockCompressed
 *
 *   @brief
@@ -1609,7 +1609,7 @@ VOID AddrElemLib::SetClearComps(
 *
 *   @return
 *       BOOL_32
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 AddrElemLib::IsBlockCompressed(
     AddrFormat format)  ///< [in] Format
@@ -1619,7 +1619,7 @@ BOOL_32 AddrElemLib::IsBlockCompressed(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::IsCompressed
 *
 *   @brief
@@ -1629,7 +1629,7 @@ BOOL_32 AddrElemLib::IsBlockCompressed(
 *
 *   @return
 *       BOOL_32
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 AddrElemLib::IsCompressed(
     AddrFormat format)  ///< [in] Format
@@ -1638,7 +1638,7 @@ BOOL_32 AddrElemLib::IsCompressed(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrElemLib::IsExpand3x
 *
 *   @brief
@@ -1648,7 +1648,7 @@ BOOL_32 AddrElemLib::IsCompressed(
 *
 *   @return
 *       BOOL_32
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 AddrElemLib::IsExpand3x(
     AddrFormat format)  ///< [in] Format
diff --git a/src/amd/addrlib/core/addrelemlib.h b/src/amd/addrlib/core/addrelemlib.h
index 68dee2d4e57..b47a413a9b4 100644
--- a/src/amd/addrlib/core/addrelemlib.h
+++ b/src/amd/addrlib/core/addrelemlib.h
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  addrelemlib.h
 * @brief Contains the class for element/pixel related functions
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #ifndef __ELEM_LIB_H__
@@ -145,13 +145,13 @@ enum AddrDepthPlanarType
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   ADDR_PIXEL_FORMATINFO
 *
 *   @brief
 *       Per component info
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 struct ADDR_PIXEL_FORMATINFO
 {
@@ -163,9 +163,9 @@ struct ADDR_PIXEL_FORMATINFO
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief This class contains asic indepentent element related attributes and operations
-***************************************************************************************************
+****************************************************************************************************
 */
 class AddrElemLib : public AddrObject
 {
diff --git a/src/amd/addrlib/core/addrlib.cpp b/src/amd/addrlib/core/addrlib.cpp
index 88ff5722b3c..f98a459f372 100644
--- a/src/amd/addrlib/core/addrlib.cpp
+++ b/src/amd/addrlib/core/addrlib.cpp
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  addrlib.cpp
 * @brief Contains the implementation for the AddrLib base class..
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #include "addrinterface.h"
@@ -87,13 +87,13 @@ UINT_32 __umoddi3(UINT_64 n, UINT_32 base)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib::AddrLib
 *
 *   @brief
 *       Constructor for the AddrLib class
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrLib::AddrLib() :
     m_class(BASE_ADDRLIB),
@@ -112,13 +112,13 @@ AddrLib::AddrLib() :
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib::AddrLib
 *
 *   @brief
 *       Constructor for the AddrLib class with hClient as parameter
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrLib::AddrLib(const AddrClient* pClient) :
     AddrObject(pClient),
@@ -138,13 +138,13 @@ AddrLib::AddrLib(const AddrClient* pClient) :
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib::~AddrLib
 *
 *   @brief
 *       Destructor for the AddrLib class
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrLib::~AddrLib()
 {
@@ -161,7 +161,7 @@ AddrLib::~AddrLib()
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib::Create
 *
 *   @brief
@@ -169,7 +169,7 @@ AddrLib::~AddrLib()
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib::Create(
     const ADDR_CREATE_INPUT* pCreateIn,     ///< [in] pointer to ADDR_CREATE_INPUT
@@ -284,14 +284,14 @@ ADDR_E_RETURNCODE AddrLib::Create(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib::SetAddrChipFamily
 *
 *   @brief
 *       Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
 *   @return
 *      N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrLib::SetAddrChipFamily(
     UINT_32 uChipFamily,        ///< [in] chip family defined in atiih.h
@@ -306,7 +306,7 @@ VOID AddrLib::SetAddrChipFamily(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib::SetMinPitchAlignPixels
 *
 *   @brief
@@ -314,7 +314,7 @@ VOID AddrLib::SetAddrChipFamily(
 *
 *   @return
 *      N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrLib::SetMinPitchAlignPixels(
     UINT_32 minPitchAlignPixels)    ///< [in] minmum pitch alignment in pixels
@@ -323,7 +323,7 @@ VOID AddrLib::SetMinPitchAlignPixels(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib::GetAddrLib
 *
 *   @brief
@@ -331,7 +331,7 @@ VOID AddrLib::SetMinPitchAlignPixels(
 *
 *   @return
 *      An AddrLib class pointer
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrLib * AddrLib::GetAddrLib(
     ADDR_HANDLE hLib)   ///< [in] handle of ADDR_HANDLE
@@ -340,7 +340,7 @@ AddrLib * AddrLib::GetAddrLib(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib::GetMaxAlignments
 *
 *   @brief
@@ -348,7 +348,7 @@ AddrLib * AddrLib::GetAddrLib(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib::GetMaxAlignments(
     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut    ///< [out] output structure
@@ -373,7 +373,7 @@ ADDR_E_RETURNCODE AddrLib::GetMaxAlignments(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib::Bits2Number
 *
 *   @brief
@@ -381,7 +381,7 @@ ADDR_E_RETURNCODE AddrLib::GetMaxAlignments(
 *
 *   @return
 *       The number combined with the array of bits
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 AddrLib::Bits2Number(
     UINT_32 bitNum,     ///< [in] how many bits
@@ -413,14 +413,14 @@ UINT_32 AddrLib::Bits2Number(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib::Flt32ToColorPixel
 *
 *   @brief
 *       Convert a FLT_32 value to a depth/stencil pixel value
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib::Flt32ToDepthPixel(
     const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,
@@ -491,14 +491,14 @@ ADDR_E_RETURNCODE AddrLib::Flt32ToDepthPixel(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib::Flt32ToColorPixel
 *
 *   @brief
 *       Convert a FLT_32 value to a red/green/blue/alpha pixel value
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib::Flt32ToColorPixel(
     const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,
@@ -529,14 +529,14 @@ ADDR_E_RETURNCODE AddrLib::Flt32ToColorPixel(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib::GetExportNorm
 *
 *   @brief
 *       Check one format can be EXPORT_NUM
 *   @return
 *       TRUE if EXPORT_NORM can be used
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 AddrLib::GetExportNorm(
     const ELEM_GETEXPORTNORM_INPUT* pIn) const
diff --git a/src/amd/addrlib/core/addrlib.h b/src/amd/addrlib/core/addrlib.h
index 9e46a829500..581ef377f74 100644
--- a/src/amd/addrlib/core/addrlib.h
+++ b/src/amd/addrlib/core/addrlib.h
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  addrlib.h
 * @brief Contains the AddrLib base class definition.
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #ifndef __ADDR_LIB_H__
@@ -61,9 +61,9 @@
 #define CIASICIDGFXENGINE_SEAISLAND 0x0000000B
 #endif
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief Neutral enums that define pipeinterleave
-***************************************************************************************************
+****************************************************************************************************
 */
 enum AddrPipeInterleave
 {
@@ -72,9 +72,9 @@ enum AddrPipeInterleave
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief Neutral enums that define DRAM row size
-***************************************************************************************************
+****************************************************************************************************
 */
 enum AddrRowSize
 {
@@ -85,9 +85,9 @@ enum AddrRowSize
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief Neutral enums that define bank interleave
-***************************************************************************************************
+****************************************************************************************************
 */
 enum AddrBankInterleave
 {
@@ -98,9 +98,9 @@ enum AddrBankInterleave
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief Neutral enums that define MGPU chip tile size
-***************************************************************************************************
+****************************************************************************************************
 */
 enum AddrChipTileSize
 {
@@ -111,9 +111,9 @@ enum AddrChipTileSize
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief Neutral enums that define shader engine tile size
-***************************************************************************************************
+****************************************************************************************************
 */
 enum AddrEngTileSize
 {
@@ -122,9 +122,9 @@ enum AddrEngTileSize
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief Neutral enums that define bank swap size
-***************************************************************************************************
+****************************************************************************************************
 */
 enum AddrBankSwapSize
 {
@@ -136,9 +136,9 @@ enum AddrBankSwapSize
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief This class contains asic independent address lib functionalities
-***************************************************************************************************
+****************************************************************************************************
 */
 class AddrLib : public AddrObject
 {
diff --git a/src/amd/addrlib/core/addrlib1.cpp b/src/amd/addrlib/core/addrlib1.cpp
index e4570cc7c87..4a2b4563eb0 100644
--- a/src/amd/addrlib/core/addrlib1.cpp
+++ b/src/amd/addrlib/core/addrlib1.cpp
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  addr1lib.cpp
 * @brief Contains the implementation for the AddrLib1 base class..
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #include "addrinterface.h"
@@ -75,13 +75,13 @@ const AddrTileModeFlags AddrLib1::ModeFlags[ADDR_TM_COUNT] =
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::AddrLib1
 *
 *   @brief
 *       Constructor for the AddrLib1 class
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrLib1::AddrLib1() :
     AddrLib()
@@ -89,13 +89,13 @@ AddrLib1::AddrLib1() :
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::AddrLib1
 *
 *   @brief
 *       Constructor for the AddrLib1 class with hClient as parameter
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrLib1::AddrLib1(const AddrClient* pClient) :
     AddrLib(pClient)
@@ -103,20 +103,20 @@ AddrLib1::AddrLib1(const AddrClient* pClient) :
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::~AddrLib1
 *
 *   @brief
 *       Destructor for the AddrLib1 class
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrLib1::~AddrLib1()
 {
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::GetAddrLib1
 *
 *   @brief
@@ -124,7 +124,7 @@ AddrLib1::~AddrLib1()
 *
 *   @return
 *      An AddrLib1 class pointer
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrLib1* AddrLib1::GetAddrLib1(
     ADDR_HANDLE hLib)   ///< [in] handle of ADDR_HANDLE
@@ -148,7 +148,7 @@ AddrLib1* AddrLib1::GetAddrLib1(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeSurfaceInfo
 *
 *   @brief
@@ -156,7 +156,7 @@ AddrLib1* AddrLib1::GetAddrLib1(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
      const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn,    ///< [in] input structure
@@ -434,7 +434,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeSurfaceInfo
 *
 *   @brief
@@ -442,7 +442,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceAddrFromCoord(
     const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,    ///< [in] input structure
@@ -514,7 +514,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeSurfaceCoordFromAddr
 *
 *   @brief
@@ -522,7 +522,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceAddrFromCoord(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceCoordFromAddr(
     const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,    ///< [in] input structure
@@ -589,7 +589,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceCoordFromAddr(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeSliceTileSwizzle
 *
 *   @brief
@@ -597,7 +597,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceCoordFromAddr(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeSliceTileSwizzle(
     const ADDR_COMPUTE_SLICESWIZZLE_INPUT*  pIn,    ///< [in] input structure
@@ -642,7 +642,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSliceTileSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ExtractBankPipeSwizzle
 *
 *   @brief
@@ -650,7 +650,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSliceTileSwizzle(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ExtractBankPipeSwizzle(
     const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT*  pIn,    ///< [in] input structure
@@ -694,7 +694,7 @@ ADDR_E_RETURNCODE AddrLib1::ExtractBankPipeSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::CombineBankPipeSwizzle
 *
 *   @brief
@@ -702,7 +702,7 @@ ADDR_E_RETURNCODE AddrLib1::ExtractBankPipeSwizzle(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::CombineBankPipeSwizzle(
     const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT*  pIn,    ///< [in] input structure
@@ -750,14 +750,14 @@ ADDR_E_RETURNCODE AddrLib1::CombineBankPipeSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeBaseSwizzle
 *
 *   @brief
 *       Interface function stub of AddrCompueBaseSwizzle.
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeBaseSwizzle(
     const ADDR_COMPUTE_BASE_SWIZZLE_INPUT*  pIn,
@@ -807,7 +807,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeBaseSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeFmaskInfo
 *
 *   @brief
@@ -815,7 +815,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeBaseSwizzle(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeFmaskInfo(
     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,    ///< [in] input structure
@@ -901,7 +901,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeFmaskAddrFromCoord
 *
 *   @brief
@@ -909,7 +909,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskInfo(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeFmaskAddrFromCoord(
     const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,    ///< [in] input structure
@@ -945,7 +945,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeFmaskCoordFromAddr
 *
 *   @brief
@@ -953,7 +953,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskAddrFromCoord(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeFmaskCoordFromAddr(
     const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*  pIn,     ///< [in] input structure
@@ -989,7 +989,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskCoordFromAddr(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ConvertTileInfoToHW
 *
 *   @brief
@@ -997,7 +997,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskCoordFromAddr(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ConvertTileInfoToHW(
     const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
@@ -1041,7 +1041,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileInfoToHW(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ConvertTileIndex
 *
 *   @brief
@@ -1049,7 +1049,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileInfoToHW(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex(
     const ADDR_CONVERT_TILEINDEX_INPUT* pIn, ///< [in] input structure
@@ -1090,7 +1090,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::GetMacroModeIndex
 *
 *   @brief
@@ -1098,7 +1098,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::GetMacroModeIndex(
     const ADDR_GET_MACROMODEINDEX_INPUT* pIn, ///< [in] input structure
@@ -1127,7 +1127,7 @@ ADDR_E_RETURNCODE AddrLib1::GetMacroModeIndex(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ConvertTileIndex1
 *
 *   @brief
@@ -1135,7 +1135,7 @@ ADDR_E_RETURNCODE AddrLib1::GetMacroModeIndex(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex1(
     const ADDR_CONVERT_TILEINDEX1_INPUT* pIn,   ///< [in] input structure
@@ -1177,7 +1177,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex1(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::GetTileIndex
 *
 *   @brief
@@ -1185,7 +1185,7 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex1(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::GetTileIndex(
     const ADDR_GET_TILEINDEX_INPUT* pIn, ///< [in] input structure
@@ -1212,7 +1212,7 @@ ADDR_E_RETURNCODE AddrLib1::GetTileIndex(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::Thickness
 *
 *   @brief
@@ -1220,7 +1220,7 @@ ADDR_E_RETURNCODE AddrLib1::GetTileIndex(
 *
 *   @return
 *       Tile mode thickness
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 AddrLib1::Thickness(
     AddrTileMode tileMode)    ///< [in] tile mode
@@ -1235,7 +1235,7 @@ UINT_32 AddrLib1::Thickness(
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeHtileInfo
 *
 *   @brief
@@ -1243,7 +1243,7 @@ UINT_32 AddrLib1::Thickness(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeHtileInfo(
     const ADDR_COMPUTE_HTILE_INFO_INPUT*    pIn,    ///< [in] input structure
@@ -1305,7 +1305,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeCmaskInfo
 *
 *   @brief
@@ -1313,7 +1313,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileInfo(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
     const ADDR_COMPUTE_CMASK_INFO_INPUT*    pIn,    ///< [in] input structure
@@ -1371,7 +1371,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeDccInfo
 *
 *   @brief
@@ -1379,7 +1379,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
 *
 *   @return
 *       return code of HwlComputeDccInfo
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeDccInfo(
     const ADDR_COMPUTE_DCCINFO_INPUT*    pIn,    ///< [in] input structure
@@ -1421,7 +1421,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeDccInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeHtileAddrFromCoord
 *
 *   @brief
@@ -1429,7 +1429,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeDccInfo(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeHtileAddrFromCoord(
     const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*   pIn,    ///< [in] input structure
@@ -1496,7 +1496,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeHtileCoordFromAddr
 *
 *   @brief
@@ -1504,7 +1504,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileAddrFromCoord(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeHtileCoordFromAddr(
     const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT*   pIn,    ///< [in] input structure
@@ -1564,7 +1564,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileCoordFromAddr(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeCmaskAddrFromCoord
 *
 *   @brief
@@ -1572,7 +1572,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileCoordFromAddr(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeCmaskAddrFromCoord(
     const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*   pIn,    ///< [in] input structure
@@ -1636,7 +1636,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeCmaskCoordFromAddr
 *
 *   @brief
@@ -1644,7 +1644,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskAddrFromCoord(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeCmaskCoordFromAddr(
     const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT*   pIn,    ///< [in] input structure
@@ -1702,7 +1702,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskCoordFromAddr(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeTileDataWidthAndHeight
 *
 *   @brief
@@ -1713,7 +1713,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskCoordFromAddr(
 *
 *   @note
 *       MacroWidth and macroHeight are measured in pixels
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrLib1::ComputeTileDataWidthAndHeight(
     UINT_32         bpp,             ///< [in] bits per pixel
@@ -1746,7 +1746,7 @@ VOID AddrLib1::ComputeTileDataWidthAndHeight(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::HwlComputeTileDataWidthAndHeightLinear
 *
 *   @brief
@@ -1757,7 +1757,7 @@ VOID AddrLib1::ComputeTileDataWidthAndHeight(
 *
 *   @note
 *       MacroWidth and macroHeight are measured in pixels
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrLib1::HwlComputeTileDataWidthAndHeightLinear(
     UINT_32*        pMacroWidth,     ///< [out] macro tile width
@@ -1772,7 +1772,7 @@ VOID AddrLib1::HwlComputeTileDataWidthAndHeightLinear(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeHtileInfo
 *
 *   @brief
@@ -1782,7 +1782,7 @@ VOID AddrLib1::HwlComputeTileDataWidthAndHeightLinear(
 *       Htile bpp i.e. How many bits for an 8x8 tile
 *       Also returns by output parameters:
 *       *Htile pitch, height, total size in bytes, macro-tile dimensions and slice size*
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 AddrLib1::ComputeHtileInfo(
     ADDR_HTILE_FLAGS flags,             ///< [in] htile flags
@@ -1860,7 +1860,7 @@ UINT_32 AddrLib1::ComputeHtileInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeCmaskBaseAlign
 *
 *   @brief
@@ -1868,7 +1868,7 @@ UINT_32 AddrLib1::ComputeHtileInfo(
 *
 *   @return
 *       Cmask base alignment
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 AddrLib1::ComputeCmaskBaseAlign(
     ADDR_CMASK_FLAGS flags,           ///< [in] Cmask flags
@@ -1890,7 +1890,7 @@ UINT_32 AddrLib1::ComputeCmaskBaseAlign(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeCmaskBytes
 *
 *   @brief
@@ -1898,7 +1898,7 @@ UINT_32 AddrLib1::ComputeCmaskBaseAlign(
 *
 *   @return
 *       Cmask size in bytes
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 AddrLib1::ComputeCmaskBytes(
     UINT_32 pitch,        ///< [in] pitch
@@ -1911,7 +1911,7 @@ UINT_64 AddrLib1::ComputeCmaskBytes(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeCmaskInfo
 *
 *   @brief
@@ -1920,7 +1920,7 @@ UINT_64 AddrLib1::ComputeCmaskBytes(
 *   @return
 *       BlockMax. Also by output parameters: Cmask pitch,height, total size in bytes,
 *       macro-tile dimensions
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
     ADDR_CMASK_FLAGS flags,            ///< [in] cmask flags
@@ -2026,7 +2026,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeXmaskCoordYFromPipe
 *
 *   @brief
@@ -2035,7 +2035,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
 *   @return
 *       Y coordinate
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 AddrLib1::ComputeXmaskCoordYFromPipe(
     UINT_32         pipe,       ///< [in] pipe number
@@ -2118,7 +2118,7 @@ UINT_32 AddrLib1::ComputeXmaskCoordYFromPipe(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::HwlComputeXmaskCoordFromAddr
 *
 *   @brief
@@ -2129,7 +2129,7 @@ UINT_32 AddrLib1::ComputeXmaskCoordYFromPipe(
 *
 *   @note
 *       This method is reused by htile, so rename to Xmask
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrLib1::HwlComputeXmaskCoordFromAddr(
     UINT_64         addr,           ///< [in] address
@@ -2300,7 +2300,7 @@ VOID AddrLib1::HwlComputeXmaskCoordFromAddr(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::HwlComputeXmaskAddrFromCoord
 *
 *   @brief
@@ -2309,7 +2309,7 @@ VOID AddrLib1::HwlComputeXmaskCoordFromAddr(
 *   @return
 *       Address in bytes
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 AddrLib1::HwlComputeXmaskAddrFromCoord(
     UINT_32        pitch,          ///< [in] pitch
@@ -2512,7 +2512,7 @@ UINT_64 AddrLib1::HwlComputeXmaskAddrFromCoord(
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeSurfaceAddrFromCoordLinear
 *
 *   @brief
@@ -2521,7 +2521,7 @@ UINT_64 AddrLib1::HwlComputeXmaskAddrFromCoord(
 *   @return
 *       Address in bytes
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 AddrLib1::ComputeSurfaceAddrFromCoordLinear(
     UINT_32  x,              ///< [in] x coord
@@ -2550,7 +2550,7 @@ UINT_64 AddrLib1::ComputeSurfaceAddrFromCoordLinear(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeSurfaceCoordFromAddrLinear
 *
 *   @brief
@@ -2558,7 +2558,7 @@ UINT_64 AddrLib1::ComputeSurfaceAddrFromCoordLinear(
 *
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrLib1::ComputeSurfaceCoordFromAddrLinear(
     UINT_64  addr,           ///< [in] address
@@ -2583,7 +2583,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrLinear(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled
 *
 *   @brief
@@ -2591,7 +2591,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrLinear(
 *
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled(
     UINT_64         addr,               ///< [in] address
@@ -2705,7 +2705,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputePipeFromAddr
 *
 *   @brief
@@ -2714,7 +2714,7 @@ VOID AddrLib1::ComputeSurfaceCoordFromAddrMicroTiled(
 *   @return
 *       Pipe number
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 AddrLib1::ComputePipeFromAddr(
     UINT_64 addr,        ///< [in] address
@@ -2745,7 +2745,7 @@ UINT_32 AddrLib1::ComputePipeFromAddr(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeMicroTileEquation
 *
 *   @brief
@@ -2754,7 +2754,7 @@ UINT_32 AddrLib1::ComputePipeFromAddr(
 *   @return
 *       If equation can be computed
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputeMicroTileEquation(
     UINT_32         log2BytesPP,    ///< [in] log2 of bytes per pixel
@@ -2958,7 +2958,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeMicroTileEquation(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputePixelIndexWithinMicroTile
 *
 *   @brief
@@ -2967,7 +2967,7 @@ ADDR_E_RETURNCODE AddrLib1::ComputeMicroTileEquation(
 *   @return
 *       Pixel index
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 AddrLib1::ComputePixelIndexWithinMicroTile(
     UINT_32         x,              ///< [in] x coord
@@ -3173,7 +3173,7 @@ UINT_32 AddrLib1::ComputePixelIndexWithinMicroTile(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::AdjustPitchAlignment
 *
 *   @brief
@@ -3182,7 +3182,7 @@ UINT_32 AddrLib1::ComputePixelIndexWithinMicroTile(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrLib1::AdjustPitchAlignment(
     ADDR_SURFACE_FLAGS  flags,      ///< [in] Surface flags
@@ -3203,7 +3203,7 @@ VOID AddrLib1::AdjustPitchAlignment(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::PadDimensions
 *
 *   @brief
@@ -3212,7 +3212,7 @@ VOID AddrLib1::AdjustPitchAlignment(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrLib1::PadDimensions(
     AddrTileMode        tileMode,    ///< [in] tile mode
@@ -3309,7 +3309,7 @@ VOID AddrLib1::PadDimensions(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::HwlPreHandleBaseLvl3xPitch
 *
 *   @brief
@@ -3317,7 +3317,7 @@ VOID AddrLib1::PadDimensions(
 *
 *   @return
 *       Expected pitch
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,        ///< [in] input
@@ -3340,7 +3340,7 @@ UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::HwlPostHandleBaseLvl3xPitch
 *
 *   @brief
@@ -3348,7 +3348,7 @@ UINT_32 AddrLib1::HwlPreHandleBaseLvl3xPitch(
 *
 *   @return
 *       Expected pitch
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,        ///< [in] input
@@ -3371,7 +3371,7 @@ UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::IsMacroTiled
 *
 *   @brief
@@ -3379,7 +3379,7 @@ UINT_32 AddrLib1::HwlPostHandleBaseLvl3xPitch(
 *
 *   @return
 *       TRUE if it is macro tiled (2D/2B/3D/3B)
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 AddrLib1::IsMacroTiled(
     AddrTileMode tileMode)  ///< [in] tile mode
@@ -3388,7 +3388,7 @@ BOOL_32 AddrLib1::IsMacroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::IsMacro3dTiled
 *
 *   @brief
@@ -3396,7 +3396,7 @@ BOOL_32 AddrLib1::IsMacroTiled(
 *
 *   @return
 *       TRUE if it is 3D macro tiled
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 AddrLib1::IsMacro3dTiled(
     AddrTileMode tileMode)  ///< [in] tile mode
@@ -3405,7 +3405,7 @@ BOOL_32 AddrLib1::IsMacro3dTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::IsMicroTiled
 *
 *   @brief
@@ -3413,7 +3413,7 @@ BOOL_32 AddrLib1::IsMacro3dTiled(
 *
 *   @return
 *       TRUE if micro tiled
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 AddrLib1::IsMicroTiled(
     AddrTileMode tileMode)  ///< [in] tile mode
@@ -3422,7 +3422,7 @@ BOOL_32 AddrLib1::IsMicroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::IsLinear
 *
 *   @brief
@@ -3430,7 +3430,7 @@ BOOL_32 AddrLib1::IsMicroTiled(
 *
 *   @return
 *       TRUE if linear
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 AddrLib1::IsLinear(
     AddrTileMode tileMode)  ///< [in] tile mode
@@ -3439,14 +3439,14 @@ BOOL_32 AddrLib1::IsLinear(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::IsPrtNoRotationTileMode
 *
 *   @brief
 *       Return TRUE if it is prt tile without rotation
 *   @note
 *       This function just used by CI
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 AddrLib1::IsPrtNoRotationTileMode(
     AddrTileMode tileMode)
@@ -3455,14 +3455,14 @@ BOOL_32 AddrLib1::IsPrtNoRotationTileMode(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::IsPrtTileMode
 *
 *   @brief
 *       Return TRUE if it is prt tile
 *   @note
 *       This function just used by CI
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 AddrLib1::IsPrtTileMode(
     AddrTileMode tileMode)
@@ -3471,14 +3471,14 @@ BOOL_32 AddrLib1::IsPrtTileMode(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeMipLevel
 *
 *   @brief
 *       Compute mipmap level width/height/slices
 *   @return
 *      N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrLib1::ComputeMipLevel(
     ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn ///< [in/out] Input structure
@@ -3501,14 +3501,14 @@ VOID AddrLib1::ComputeMipLevel(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::OptimizeTileMode
 *
 *   @brief
 *       Check if base level's tile mode can be optimized (degraded)
 *   @return
 *       TRUE if degraded, also returns degraded tile mode (unchanged if not degraded)
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 AddrLib1::OptimizeTileMode(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,        ///< [in] Input structure for surface info
@@ -3571,14 +3571,14 @@ BOOL_32 AddrLib1::OptimizeTileMode(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::DegradeLargeThickTile
 *
 *   @brief
 *       Check if the thickness needs to be reduced if a tile is too large
 *   @return
 *       The degraded tile mode (unchanged if not degraded)
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrTileMode AddrLib1::DegradeLargeThickTile(
     AddrTileMode tileMode,
@@ -3641,13 +3641,13 @@ AddrTileMode AddrLib1::DegradeLargeThickTile(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::PostComputeMipLevel
 *   @brief
 *       Compute MipLevel info (including level 0) after surface adjustment
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::PostComputeMipLevel(
     ADDR_COMPUTE_SURFACE_INFO_INPUT*    pIn,   ///< [in/out] Input structure
@@ -3681,14 +3681,14 @@ ADDR_E_RETURNCODE AddrLib1::PostComputeMipLevel(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::HwlSetupTileCfg
 *
 *   @brief
 *       Map tile index to tile setting.
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::HwlSetupTileCfg(
     UINT_32         bpp,              ///< Bits per pixel
@@ -3703,14 +3703,14 @@ ADDR_E_RETURNCODE AddrLib1::HwlSetupTileCfg(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::HwlGetPipes
 *
 *   @brief
 *       Get number pipes
 *   @return
 *       num pipes
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 AddrLib1::HwlGetPipes(
     const ADDR_TILEINFO* pTileInfo    ///< [in] Tile info
@@ -3721,14 +3721,14 @@ UINT_32 AddrLib1::HwlGetPipes(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputeQbStereoInfo
 *
 *   @brief
 *       Get quad buffer stereo information
 *   @return
 *       TRUE if no error
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 AddrLib1::ComputeQbStereoInfo(
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut    ///< [in/out] updated pOut+pStereoInfo
@@ -3766,7 +3766,7 @@ BOOL_32 AddrLib1::ComputeQbStereoInfo(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrLib1::ComputePrtInfo
 *
 *   @brief
@@ -3774,7 +3774,7 @@ BOOL_32 AddrLib1::ComputeQbStereoInfo(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE AddrLib1::ComputePrtInfo(
     const ADDR_PRT_INFO_INPUT*  pIn,
diff --git a/src/amd/addrlib/core/addrlib1.h b/src/amd/addrlib/core/addrlib1.h
index 99e8a9aed1f..9751d1d4f17 100644
--- a/src/amd/addrlib/core/addrlib1.h
+++ b/src/amd/addrlib/core/addrlib1.h
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  addrlib1.h
 * @brief Contains the AddrLib1 base class definition.
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #ifndef __ADDR_LIB1_H__
@@ -38,9 +38,9 @@
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief Neutral enums that define bank swap size
-***************************************************************************************************
+****************************************************************************************************
 */
 enum AddrSampleSplitSize
 {
@@ -51,9 +51,9 @@ enum AddrSampleSplitSize
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief Flags for AddrTileMode
-***************************************************************************************************
+****************************************************************************************************
 */
 struct AddrTileModeFlags
 {
@@ -68,9 +68,9 @@ struct AddrTileModeFlags
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief This class contains asic independent address lib functionalities
-***************************************************************************************************
+****************************************************************************************************
 */
 class AddrLib1 : public AddrLib
 {
diff --git a/src/amd/addrlib/core/addrobject.cpp b/src/amd/addrlib/core/addrobject.cpp
index 369be8c3046..2d86e033f13 100644
--- a/src/amd/addrlib/core/addrobject.cpp
+++ b/src/amd/addrlib/core/addrobject.cpp
@@ -25,22 +25,22 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  addrobject.cpp
 * @brief Contains the AddrObject base class implementation.
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #include "addrinterface.h"
 #include "addrobject.h"
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrObject::AddrObject
 *
 *   @brief
 *       Constructor for the AddrObject class.
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrObject::AddrObject()
 {
@@ -51,12 +51,12 @@ AddrObject::AddrObject()
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrObject::AddrObject
 *
 *   @brief
 *       Constructor for the AddrObject class.
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrObject::AddrObject(const AddrClient* pClient)
 {
@@ -64,24 +64,24 @@ AddrObject::AddrObject(const AddrClient* pClient)
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrObject::~AddrObject
 *
 *   @brief
 *       Destructor for the AddrObject class.
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrObject::~AddrObject()
 {
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrObject::ClientAlloc
 *
 *   @brief
 *       Calls instanced allocSysMem inside AddrClient
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID* AddrObject::ClientAlloc(
     size_t             objSize,    ///< [in] Size to allocate
@@ -105,12 +105,12 @@ VOID* AddrObject::ClientAlloc(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrObject::AddrMalloc
 *
 *   @brief
 *       A wrapper of ClientAlloc
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID* AddrObject::AddrMalloc(
     size_t objSize) const   ///< [in] Size to allocate
@@ -119,12 +119,12 @@ VOID* AddrObject::AddrMalloc(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrObject::ClientFree
 *
 *   @brief
 *       Calls freeSysMem inside AddrClient
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrObject::ClientFree(
     VOID*              pObjMem,    ///< [in] User virtual address to free.
@@ -146,12 +146,12 @@ VOID AddrObject::ClientFree(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrObject::AddrFree
 *
 *   @brief
 *       A wrapper of ClientFree
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrObject::AddrFree(
     VOID* pObjMem) const                 ///< [in] User virtual address to free.
@@ -160,7 +160,7 @@ VOID AddrObject::AddrFree(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrObject::operator new
 *
 *   @brief
@@ -168,7 +168,7 @@ VOID AddrObject::AddrFree(
 *
 *   @return
 *       Returns NULL if unsuccessful.
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID* AddrObject::operator new(
     size_t             objSize,    ///< [in] Size to allocate
@@ -179,12 +179,12 @@ VOID* AddrObject::operator new(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrObject::operator delete
 *
 *   @brief
 *       Frees AddrObject object memory.
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrObject::operator delete(
     VOID* pObjMem,              ///< [in] User virtual address to free.
@@ -194,12 +194,12 @@ VOID AddrObject::operator delete(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrObject::operator delete
 *
 *   @brief
 *       Frees AddrObject object memory.
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrObject::operator delete(
     VOID* pObjMem)                  ///< [in] User virtual address to free.
@@ -209,7 +209,7 @@ VOID AddrObject::operator delete(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrObject::DebugPrint
 *
 *   @brief
@@ -217,7 +217,7 @@ VOID AddrObject::operator delete(
 *
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID AddrObject::DebugPrint(
     const CHAR* pDebugString,     ///< [in] Debug string
diff --git a/src/amd/addrlib/core/addrobject.h b/src/amd/addrlib/core/addrobject.h
index 35400885afe..e3cf0afbc8f 100644
--- a/src/amd/addrlib/core/addrobject.h
+++ b/src/amd/addrlib/core/addrobject.h
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  addrobject.h
 * @brief Contains the AddrObject base class definition.
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #ifndef __ADDR_OBJECT_H__
@@ -38,9 +38,9 @@
 #include "addrcommon.h"
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief This structure contains client specific data
-***************************************************************************************************
+****************************************************************************************************
 */
 struct AddrClient
 {
@@ -48,9 +48,9 @@ struct AddrClient
     ADDR_CALLBACKS      callbacks;
 };
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief This class is the base class for all ADDR class objects.
-***************************************************************************************************
+****************************************************************************************************
 */
 class AddrObject
 {
diff --git a/src/amd/addrlib/r800/ciaddrlib.cpp b/src/amd/addrlib/r800/ciaddrlib.cpp
index 15aff1652a4..ebaf3e5623b 100644
--- a/src/amd/addrlib/r800/ciaddrlib.cpp
+++ b/src/amd/addrlib/r800/ciaddrlib.cpp
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  ciaddrlib.cpp
 * @brief Contains the implementation for the CiAddrLib class.
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #include "ciaddrlib.h"
@@ -49,14 +49,14 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrMask
 *
 *   @brief
 *       Gets a mask of "width"
 *   @return
 *       Bit mask
-***************************************************************************************************
+****************************************************************************************************
 */
 static UINT_64 AddrMask(
     UINT_32 width)  ///< Width of bits
@@ -75,14 +75,14 @@ static UINT_64 AddrMask(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrGetBits
 *
 *   @brief
 *       Gets bits within a range of [msb, lsb]
 *   @return
 *       Bits of this range
-***************************************************************************************************
+****************************************************************************************************
 */
 static UINT_64 AddrGetBits(
     UINT_64 bits,   ///< Source bits
@@ -99,14 +99,14 @@ static UINT_64 AddrGetBits(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrRemoveBits
 *
 *   @brief
 *       Removes bits within the range of [msb, lsb]
 *   @return
 *       Modified bits
-***************************************************************************************************
+****************************************************************************************************
 */
 static UINT_64 AddrRemoveBits(
     UINT_64 bits,   ///< Source bits
@@ -124,14 +124,14 @@ static UINT_64 AddrRemoveBits(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   AddrInsertBits
 *
 *   @brief
 *       Inserts new bits into the range of [msb, lsb]
 *   @return
 *       Modified bits
-***************************************************************************************************
+****************************************************************************************************
 */
 static UINT_64 AddrInsertBits(
     UINT_64 bits,       ///< Source bits
@@ -152,15 +152,15 @@ static UINT_64 AddrInsertBits(
 
 
 /**
-***************************************************************************************************
-*   AddrCIHwlInit
+****************************************************************************************************
+*   AddrCiHwlInit
 *
 *   @brief
 *       Creates an CiAddrLib object.
 *
 *   @return
 *       Returns an CiAddrLib object pointer.
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrLib* AddrCIHwlInit(const AddrClient* pClient)
 {
@@ -168,13 +168,13 @@ AddrLib* AddrCIHwlInit(const AddrClient* pClient)
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::CiAddrLib
 *
 *   @brief
 *       Constructor
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 CiAddrLib::CiAddrLib(const AddrClient* pClient) :
     SiAddrLib(pClient),
@@ -186,26 +186,26 @@ CiAddrLib::CiAddrLib(const AddrClient* pClient) :
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::~CiAddrLib
 *
 *   @brief
 *       Destructor
-***************************************************************************************************
+****************************************************************************************************
 */
 CiAddrLib::~CiAddrLib()
 {
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlComputeDccInfo
 *
 *   @brief
 *       Compute DCC key size, base alignment
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE CiAddrLib::HwlComputeDccInfo(
     const ADDR_COMPUTE_DCCINFO_INPUT*  pIn,
@@ -280,7 +280,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeDccInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlComputeCmaskAddrFromCoord
 *
 *   @brief
@@ -288,7 +288,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeDccInfo(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE CiAddrLib::HwlComputeCmaskAddrFromCoord(
     const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*  pIn,  ///< [in] fmask addr/bpp/tile input
@@ -324,7 +324,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeCmaskAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlComputeHtileAddrFromCoord
 *
 *   @brief
@@ -332,7 +332,7 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeCmaskAddrFromCoord(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE CiAddrLib::HwlComputeHtileAddrFromCoord(
     const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*  pIn,  ///< [in] depth/stencil addr/bpp/tile input
@@ -368,14 +368,14 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeHtileAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlConvertChipFamily
 *
 *   @brief
 *       Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
 *   @return
 *       AddrChipFamily
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrChipFamily CiAddrLib::HwlConvertChipFamily(
     UINT_32 uChipFamily,        ///< [in] chip family defined in atiih.h
@@ -418,7 +418,7 @@ AddrChipFamily CiAddrLib::HwlConvertChipFamily(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlInitGlobalParams
 *
 *   @brief
@@ -427,7 +427,7 @@ AddrChipFamily CiAddrLib::HwlConvertChipFamily(
 *   @return
 *       TRUE if all settings are valid
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 CiAddrLib::HwlInitGlobalParams(
     const ADDR_CREATE_INPUT* pCreateIn) ///< [in] create input
@@ -491,7 +491,7 @@ BOOL_32 CiAddrLib::HwlInitGlobalParams(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlPostCheckTileIndex
 *
 *   @brief
@@ -499,7 +499,7 @@ BOOL_32 CiAddrLib::HwlInitGlobalParams(
 *       tile mode/type/info and change the index if needed
 *   @return
 *       Tile index.
-***************************************************************************************************
+****************************************************************************************************
 */
 INT_32 CiAddrLib::HwlPostCheckTileIndex(
     const ADDR_TILEINFO* pInfo,     ///< [in] Tile Info
@@ -582,14 +582,14 @@ INT_32 CiAddrLib::HwlPostCheckTileIndex(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlSetupTileCfg
 *
 *   @brief
 *       Map tile index to tile setting.
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE CiAddrLib::HwlSetupTileCfg(
     UINT_32         bpp,            ///< [in] Bits per pixel
@@ -681,14 +681,14 @@ ADDR_E_RETURNCODE CiAddrLib::HwlSetupTileCfg(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlComputeSurfaceInfo
 *
 *   @brief
 *       Entry of ci's ComputeSurfaceInfo
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE CiAddrLib::HwlComputeSurfaceInfo(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,    ///< [in] input structure
@@ -715,13 +715,13 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeSurfaceInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlFmaskSurfaceInfo
 *   @brief
 *       Entry of r800's ComputeFmaskInfo
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE CiAddrLib::HwlComputeFmaskInfo(
     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,   ///< [in] input structure
@@ -802,14 +802,14 @@ ADDR_E_RETURNCODE CiAddrLib::HwlComputeFmaskInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlFmaskPreThunkSurfInfo
 *
 *   @brief
 *       Some preparation before thunking a ComputeSurfaceInfo call for Fmask
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID CiAddrLib::HwlFmaskPreThunkSurfInfo(
     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pFmaskIn,   ///< [in] Input of fmask info
@@ -823,14 +823,14 @@ VOID CiAddrLib::HwlFmaskPreThunkSurfInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlFmaskPostThunkSurfInfo
 *
 *   @brief
 *       Copy hwl extra field after calling thunked ComputeSurfaceInfo
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID CiAddrLib::HwlFmaskPostThunkSurfInfo(
     const ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pSurfOut,   ///< [in] Output of surface info
@@ -842,7 +842,7 @@ VOID CiAddrLib::HwlFmaskPostThunkSurfInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlDegradeThickTileMode
 *
 *   @brief
@@ -850,7 +850,7 @@ VOID CiAddrLib::HwlFmaskPostThunkSurfInfo(
 *
 *   @return
 *       Suitable tile mode
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrTileMode CiAddrLib::HwlDegradeThickTileMode(
     AddrTileMode        baseTileMode,   ///< [in] base tile mode
@@ -862,7 +862,7 @@ AddrTileMode CiAddrLib::HwlDegradeThickTileMode(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlOverrideTileMode
 *
 *   @brief
@@ -871,7 +871,7 @@ AddrTileMode CiAddrLib::HwlDegradeThickTileMode(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID CiAddrLib::HwlOverrideTileMode(
     ADDR_COMPUTE_SURFACE_INFO_INPUT*    pInOut      ///< [in/out] input output structure
@@ -1023,7 +1023,7 @@ VOID CiAddrLib::HwlOverrideTileMode(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlSelectTileMode
 *
 *   @brief
@@ -1032,7 +1032,7 @@ VOID CiAddrLib::HwlOverrideTileMode(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID CiAddrLib::HwlSelectTileMode(
     ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut     ///< [in/out] input output structure
@@ -1119,12 +1119,12 @@ VOID CiAddrLib::HwlSelectTileMode(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlSetupTileInfo
 *
 *   @brief
 *       Setup default value of tile info for SI
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID CiAddrLib::HwlSetupTileInfo(
     AddrTileMode                        tileMode,       ///< [in] Tile mode
@@ -1452,14 +1452,14 @@ VOID CiAddrLib::HwlSetupTileInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::ReadGbTileMode
 *
 *   @brief
 *       Convert GB_TILE_MODE HW value to ADDR_TILE_CONFIG.
 *   @return
 *       NA.
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID CiAddrLib::ReadGbTileMode(
     UINT_32             regValue,   ///< [in] GB_TILE_MODE register
@@ -1528,14 +1528,14 @@ VOID CiAddrLib::ReadGbTileMode(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::InitTileSettingTable
 *
 *   @brief
 *       Initialize the ADDR_TILE_CONFIG table.
 *   @return
 *       TRUE if tile table is correctly initialized
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 CiAddrLib::InitTileSettingTable(
     const UINT_32*  pCfg,           ///< [in] Pointer to table of tile configs
@@ -1597,14 +1597,14 @@ BOOL_32 CiAddrLib::InitTileSettingTable(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::ReadGbMacroTileCfg
 *
 *   @brief
 *       Convert GB_MACRO_TILE_CFG HW value to ADDR_TILE_CONFIG.
 *   @return
 *       NA.
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID CiAddrLib::ReadGbMacroTileCfg(
     UINT_32             regValue,   ///< [in] GB_MACRO_TILE_MODE register
@@ -1621,14 +1621,14 @@ VOID CiAddrLib::ReadGbMacroTileCfg(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::InitMacroTileCfgTable
 *
 *   @brief
 *       Initialize the ADDR_MACRO_TILE_CONFIG table.
 *   @return
 *       TRUE if macro tile table is correctly initialized
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 CiAddrLib::InitMacroTileCfgTable(
     const UINT_32*  pCfg,           ///< [in] Pointer to table of tile configs
@@ -1668,14 +1668,14 @@ BOOL_32 CiAddrLib::InitMacroTileCfgTable(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlComputeMacroModeIndex
 *
 *   @brief
 *       Computes macro tile mode index
 *   @return
 *       TRUE if macro tile table is correctly initialized
-***************************************************************************************************
+****************************************************************************************************
 */
 INT_32 CiAddrLib::HwlComputeMacroModeIndex(
     INT_32              tileIndex,      ///< [in] Tile mode index
@@ -1768,7 +1768,7 @@ INT_32 CiAddrLib::HwlComputeMacroModeIndex(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlComputeTileDataWidthAndHeightLinear
 *
 *   @brief
@@ -1779,7 +1779,7 @@ INT_32 CiAddrLib::HwlComputeMacroModeIndex(
 *
 *   @note
 *       MacroWidth and macroHeight are measured in pixels
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID CiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
     UINT_32*        pMacroWidth,     ///< [out] macro tile width
@@ -1813,7 +1813,7 @@ VOID CiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlComputeMetadataNibbleAddress
 *
 *   @brief
@@ -1833,7 +1833,7 @@ VOID CiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
 *   @return
 *        meta data nibble address (nibble address is used to support DCC compatible cmask)
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
     UINT_64 uncompressedDataByteAddress,
@@ -1934,7 +1934,7 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlPadDimensions
 *
 *   @brief
@@ -1943,7 +1943,7 @@ UINT_64 CiAddrLib::HwlComputeMetadataNibbleAddress(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID CiAddrLib::HwlPadDimensions(
     AddrTileMode        tileMode,    ///< [in] tile mode
@@ -2020,14 +2020,14 @@ VOID CiAddrLib::HwlPadDimensions(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   CiAddrLib::HwlGetMaxAlignments
 *
 *   @brief
 *       Gets maximum alignments
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE CiAddrLib::HwlGetMaxAlignments(
     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut    ///< [out] output structure
diff --git a/src/amd/addrlib/r800/ciaddrlib.h b/src/amd/addrlib/r800/ciaddrlib.h
index 12587cd06c5..69ede03f51c 100644
--- a/src/amd/addrlib/r800/ciaddrlib.h
+++ b/src/amd/addrlib/r800/ciaddrlib.h
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  ciaddrlib.h
 * @brief Contains the CiAddrLib class definition.
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #ifndef __CI_ADDR_LIB_H__
@@ -38,9 +38,9 @@
 #include "siaddrlib.h"
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief CI specific settings structure.
-***************************************************************************************************
+****************************************************************************************************
 */
 struct CIChipSettings
 {
@@ -69,10 +69,10 @@ struct CIChipSettings
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief This class is the CI specific address library
 *        function set.
-***************************************************************************************************
+****************************************************************************************************
 */
 class CiAddrLib : public SiAddrLib
 {
diff --git a/src/amd/addrlib/r800/egbaddrlib.cpp b/src/amd/addrlib/r800/egbaddrlib.cpp
index 0c1ddca10a3..393557741bc 100644
--- a/src/amd/addrlib/r800/egbaddrlib.cpp
+++ b/src/amd/addrlib/r800/egbaddrlib.cpp
@@ -25,16 +25,16 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  egbaddrlib.cpp
 * @brief Contains the EgBasedAddrLib class implementation
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #include "egbaddrlib.h"
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::EgBasedAddrLib
 *
 *   @brief
@@ -42,7 +42,7 @@
 *
 *   @note
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 EgBasedAddrLib::EgBasedAddrLib(const AddrClient* pClient) :
     AddrLib1(pClient),
@@ -53,19 +53,19 @@ EgBasedAddrLib::EgBasedAddrLib(const AddrClient* pClient) :
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::~EgBasedAddrLib
 *
 *   @brief
 *       Destructor
-***************************************************************************************************
+****************************************************************************************************
 */
 EgBasedAddrLib::~EgBasedAddrLib()
 {
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::DispatchComputeSurfaceInfo
 *
 *   @brief
@@ -75,7 +75,7 @@ EgBasedAddrLib::~EgBasedAddrLib()
 *
 *   @return
 *       TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 EgBasedAddrLib::DispatchComputeSurfaceInfo(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,    ///< [in] input structure
@@ -197,7 +197,7 @@ BOOL_32 EgBasedAddrLib::DispatchComputeSurfaceInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeSurfaceInfoLinear
 *
 *   @brief
@@ -207,7 +207,7 @@ BOOL_32 EgBasedAddrLib::DispatchComputeSurfaceInfo(
 *
 *   @return
 *       TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoLinear(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,    ///< [in] Input structure
@@ -292,7 +292,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoLinear(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeSurfaceInfoMicroTiled
 *
 *   @brief
@@ -302,7 +302,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoLinear(
 *
 *   @return
 *       TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMicroTiled(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,        ///< [in] Input structure
@@ -402,7 +402,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMicroTiled(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeSurfaceInfoMacroTiled
 *
 *   @brief
@@ -412,7 +412,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMicroTiled(
 *
 *   @return
 *       TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMacroTiled(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,        ///< [in] Input structure
@@ -614,7 +614,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMacroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeSurfaceAlignmentsLinear
 *
 *   @brief
@@ -623,7 +623,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceInfoMacroTiled(
 *
 *   @return
 *       TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsLinear(
     AddrTileMode        tileMode,          ///< [in] tile mode
@@ -670,7 +670,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsLinear(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled
 *
 *   @brief
@@ -679,7 +679,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsLinear(
 *
 *   @return
 *       TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled(
     AddrTileMode        tileMode,          ///< [in] tile mode
@@ -720,7 +720,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlReduceBankWidthHeight
 *
 *   @brief
@@ -729,7 +729,7 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMicroTiled(
 *
 *   @return
 *       TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 EgBasedAddrLib::HwlReduceBankWidthHeight(
     UINT_32             tileSize,           ///< [in] tile size
@@ -824,7 +824,7 @@ BOOL_32 EgBasedAddrLib::HwlReduceBankWidthHeight(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled
 *
 *   @brief
@@ -833,7 +833,7 @@ BOOL_32 EgBasedAddrLib::HwlReduceBankWidthHeight(
 *
 *   @return
 *       TRUE if no error occurs
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled(
     AddrTileMode        tileMode,           ///< [in] tile mode
@@ -948,14 +948,14 @@ BOOL_32 EgBasedAddrLib::ComputeSurfaceAlignmentsMacroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::SanityCheckMacroTiled
 *
 *   @brief
 *       Check if macro-tiled parameters are valid
 *   @return
 *       TRUE if valid
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 EgBasedAddrLib::SanityCheckMacroTiled(
     ADDR_TILEINFO* pTileInfo   ///< [in] macro-tiled parameters
@@ -1053,7 +1053,7 @@ BOOL_32 EgBasedAddrLib::SanityCheckMacroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeSurfaceMipLevelTileMode
 *
 *   @brief
@@ -1061,7 +1061,7 @@ BOOL_32 EgBasedAddrLib::SanityCheckMacroTiled(
 *
 *   @return
 *       Suitable tile mode
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrTileMode EgBasedAddrLib::ComputeSurfaceMipLevelTileMode(
     AddrTileMode        baseTileMode,   ///< [in] base tile mode
@@ -1145,13 +1145,13 @@ AddrTileMode EgBasedAddrLib::ComputeSurfaceMipLevelTileMode(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlDegradeBaseLevel
 *   @brief
 *       Check if degrade is needed for base level
 *   @return
 *       TRUE if degrade is suggested
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 EgBasedAddrLib::HwlDegradeBaseLevel(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn) const
@@ -1229,7 +1229,7 @@ BOOL_32 EgBasedAddrLib::HwlDegradeBaseLevel(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlDegradeThickTileMode
 *
 *   @brief
@@ -1237,7 +1237,7 @@ BOOL_32 EgBasedAddrLib::HwlDegradeBaseLevel(
 *
 *   @return
 *       Suitable tile mode
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrTileMode EgBasedAddrLib::HwlDegradeThickTileMode(
     AddrTileMode        baseTileMode,   ///< [in] base tile mode
@@ -1302,7 +1302,7 @@ AddrTileMode EgBasedAddrLib::HwlDegradeThickTileMode(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord
 *
 *   @brief
@@ -1310,7 +1310,7 @@ AddrTileMode EgBasedAddrLib::HwlDegradeThickTileMode(
 *
 *   @return
 *       Address in bytes
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord(
     const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,    ///< [in] input structure
@@ -1467,14 +1467,14 @@ UINT_64 EgBasedAddrLib::DispatchComputeSurfaceAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeMacroTileEquation
 *
 *   @brief
 *       Computes the address equation in macro tile
 *   @return
 *       If equation can be computed
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE EgBasedAddrLib::ComputeMacroTileEquation(
     UINT_32             log2BytesPP,            ///< [in] log2 of bytes per pixel
@@ -1598,7 +1598,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::ComputeMacroTileEquation(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled
 *
 *   @brief
@@ -1606,7 +1606,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::ComputeMacroTileEquation(
 *       coordinate for 2D tilied (macro tiled)
 *   @return
 *       The byte address
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMacroTiled(
     UINT_32             x,                      ///< [in] x coordinate
@@ -1873,7 +1873,7 @@ UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMacroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled
 *
 *   @brief
@@ -1881,7 +1881,7 @@ UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMacroTiled(
 *       (micro tiled)
 *   @return
 *       The byte address
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled(
     UINT_32             x,                      ///< [in] x coordinate
@@ -1998,14 +1998,14 @@ UINT_64 EgBasedAddrLib::ComputeSurfaceAddrFromCoordMicroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlComputePixelCoordFromOffset
 *
 *   @brief
 *       Compute pixel coordinate from offset inside a micro tile
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID EgBasedAddrLib::HwlComputePixelCoordFromOffset(
     UINT_32         offset,             ///< [in] offset inside micro tile in bits
@@ -2187,14 +2187,14 @@ VOID EgBasedAddrLib::HwlComputePixelCoordFromOffset(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddrDispatch
 *
 *   @brief
 *       Compute (x,y,slice,sample) coordinates from surface address
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddr(
     const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,    ///< [in] input structure
@@ -2332,14 +2332,14 @@ VOID EgBasedAddrLib::DispatchComputeSurfaceCoordFromAddr(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled
 *
 *   @brief
 *       Compute surface coordinates from address for macro tiled surface
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled(
     UINT_64             addr,               ///< [in] byte address
@@ -2490,14 +2490,14 @@ VOID EgBasedAddrLib::ComputeSurfaceCoordFromAddrMacroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeSurfaceCoord2DFromBankPipe
 *
 *   @brief
 *       Compute surface x,y coordinates from bank/pipe info
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID EgBasedAddrLib::ComputeSurfaceCoord2DFromBankPipe(
     AddrTileMode        tileMode,   ///< [in] tile mode
@@ -2676,13 +2676,13 @@ VOID EgBasedAddrLib::ComputeSurfaceCoord2DFromBankPipe(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlExtractBankPipeSwizzle
 *   @brief
 *       Entry of EgBasedAddrLib ExtractBankPipeSwizzle
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE EgBasedAddrLib::HwlExtractBankPipeSwizzle(
     const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT*  pIn,   ///< [in] input structure
@@ -2699,13 +2699,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlExtractBankPipeSwizzle(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlCombineBankPipeSwizzle
 *   @brief
 *       Combine bank/pipe swizzle
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE EgBasedAddrLib::HwlCombineBankPipeSwizzle(
     UINT_32         bankSwizzle,    ///< [in] bank swizzle
@@ -2730,13 +2730,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlCombineBankPipeSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlComputeBaseSwizzle
 *   @brief
 *       Compute base swizzle
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeBaseSwizzle(
     const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn,
@@ -2805,13 +2805,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeBaseSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ExtractBankPipeSwizzle
 *   @brief
 *       Extract bank/pipe swizzle from base256b
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID EgBasedAddrLib::ExtractBankPipeSwizzle(
     UINT_32         base256b,       ///< [in] input base256b register value
@@ -2843,13 +2843,13 @@ VOID EgBasedAddrLib::ExtractBankPipeSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::GetBankPipeSwizzle
 *   @brief
 *       Combine bank/pipe swizzle
 *   @return
 *       Base256b bits (only filled bank/pipe bits)
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 EgBasedAddrLib::GetBankPipeSwizzle(
     UINT_32         bankSwizzle,    ///< [in] bank swizzle
@@ -2869,13 +2869,13 @@ UINT_32 EgBasedAddrLib::GetBankPipeSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeSliceTileSwizzle
 *   @brief
 *       Compute cubemap/3d texture faces/slices tile swizzle
 *   @return
 *       Tile swizzle
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 EgBasedAddrLib::ComputeSliceTileSwizzle(
     AddrTileMode        tileMode,       ///< [in] Tile mode
@@ -2934,14 +2934,14 @@ UINT_32 EgBasedAddrLib::ComputeSliceTileSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlComputeQbStereoRightSwizzle
 *
 *   @brief
 *       Compute right eye swizzle
 *   @return
 *       swizzle
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 EgBasedAddrLib::HwlComputeQbStereoRightSwizzle(
     ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pInfo  ///< [in] Surface info, must be valid
@@ -2966,14 +2966,14 @@ UINT_32 EgBasedAddrLib::HwlComputeQbStereoRightSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeBankFromCoord
 *
 *   @brief
 *       Compute bank number from coordinates
 *   @return
 *       Bank number
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 EgBasedAddrLib::ComputeBankFromCoord(
     UINT_32         x,              ///< [in] x coordinate
@@ -3098,14 +3098,14 @@ UINT_32 EgBasedAddrLib::ComputeBankFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeBankFromAddr
 *
 *   @brief
 *       Compute the bank number from an address
 *   @return
 *       Bank number
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 EgBasedAddrLib::ComputeBankFromAddr(
     UINT_64 addr,       ///< [in] address
@@ -3131,14 +3131,14 @@ UINT_32 EgBasedAddrLib::ComputeBankFromAddr(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputePipeRotation
 *
 *   @brief
 *       Compute pipe rotation value
 *   @return
 *       Pipe rotation
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 EgBasedAddrLib::ComputePipeRotation(
     AddrTileMode tileMode,  ///< [in] tile mode
@@ -3166,14 +3166,14 @@ UINT_32 EgBasedAddrLib::ComputePipeRotation(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeBankRotation
 *
 *   @brief
 *       Compute bank rotation value
 *   @return
 *       Bank rotation
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 EgBasedAddrLib::ComputeBankRotation(
     AddrTileMode tileMode,  ///< [in] tile mode
@@ -3209,7 +3209,7 @@ UINT_32 EgBasedAddrLib::ComputeBankRotation(
 
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeHtileBytes
 *
 *   @brief
@@ -3217,7 +3217,7 @@ UINT_32 EgBasedAddrLib::ComputeBankRotation(
 *
 *   @return
 *       Htile size in bytes
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 EgBasedAddrLib::ComputeHtileBytes(
     UINT_32 pitch,        ///< [in] pitch
@@ -3252,7 +3252,7 @@ UINT_64 EgBasedAddrLib::ComputeHtileBytes(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::DispatchComputeFmaskInfo
 *
 *   @brief
@@ -3262,7 +3262,7 @@ UINT_64 EgBasedAddrLib::ComputeHtileBytes(
 *
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE EgBasedAddrLib::DispatchComputeFmaskInfo(
     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,   ///< [in] input structure
@@ -3329,13 +3329,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::DispatchComputeFmaskInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlFmaskSurfaceInfo
 *   @brief
 *       Entry of EgBasedAddrLib ComputeFmaskInfo
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskInfo(
     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,   ///< [in] input structure
@@ -3371,13 +3371,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlComputeFmaskAddrFromCoord
 *   @brief
 *       Entry of EgBasedAddrLib ComputeFmaskAddrFromCoord
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskAddrFromCoord(
     const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,    ///< [in] input structure
@@ -3404,13 +3404,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlComputeFmaskCoordFromAddr
 *   @brief
 *       Entry of EgBasedAddrLib ComputeFmaskCoordFromAddr
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskCoordFromAddr(
     const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*   pIn,    ///< [in] input structure
@@ -3436,14 +3436,14 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeFmaskCoordFromAddr(
 
 #if ADDR_AM_BUILD
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord
 *
 *   @brief
 *       Computes the FMASK address and bit position from a coordinate.
 *   @return
 *       The byte address
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord(
     const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,    ///< [in] input structure
@@ -3525,7 +3525,7 @@ UINT_64 EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled
 *
 *   @brief
@@ -3533,7 +3533,7 @@ UINT_64 EgBasedAddrLib::DispatchComputeFmaskAddrFromCoord(
 *       tiled)
 *   @return
 *       The byte address
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled(
     UINT_32             x,              ///< [in] x coordinate
@@ -3633,7 +3633,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled
 *
 *   @brief
@@ -3641,7 +3641,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMicroTiled(
 *       tiled)
 *   @return
 *       The byte address
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled(
     UINT_32             x,              ///< [in] x coordinate
@@ -3755,7 +3755,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled
 *
 *   @brief
@@ -3763,7 +3763,7 @@ UINT_64 EgBasedAddrLib::ComputeFmaskAddrFromCoordMacroTiled(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled(
     UINT_64             addr,       ///< [in] byte address
@@ -3842,7 +3842,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled
 *
 *   @brief
@@ -3851,7 +3851,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMicroTiled(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled(
     UINT_64             addr,       ///< [in] byte address
@@ -3942,7 +3942,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr
 *
 *   @brief
@@ -3951,7 +3951,7 @@ VOID EgBasedAddrLib::ComputeFmaskCoordFromAddrMacroTiled(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr(
     const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*   pIn,    ///< [in] input structure
@@ -4032,7 +4032,7 @@ VOID EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr(
 #endif
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples
 *
 *   @brief
@@ -4040,7 +4040,7 @@ VOID EgBasedAddrLib::DispatchComputeFmaskCoordFromAddr(
 *
 *   @return
 *       Number of planes
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples(
     UINT_32 numSamples)     ///< [in] number of samples
@@ -4077,7 +4077,7 @@ UINT_32 EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples
 *
 *   @brief
@@ -4085,7 +4085,7 @@ UINT_32 EgBasedAddrLib::ComputeFmaskNumPlanesFromNumSamples(
 *
 *   @return
 *       bpp
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples(
     UINT_32 numSamples)     ///< number of samples
@@ -4122,14 +4122,14 @@ UINT_32 EgBasedAddrLib::ComputeFmaskResolvedBppFromNumSamples(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::IsTileInfoAllZero
 *
 *   @brief
 *       Return TRUE if all field are zero
 *   @note
 *       Since NULL input is consider to be all zero
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 EgBasedAddrLib::IsTileInfoAllZero(
     ADDR_TILEINFO* pTileInfo)
@@ -4154,14 +4154,14 @@ BOOL_32 EgBasedAddrLib::IsTileInfoAllZero(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlTileInfoEqual
 *
 *   @brief
 *       Return TRUE if all field are equal
 *   @note
 *       Only takes care of current HWL's data
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 EgBasedAddrLib::HwlTileInfoEqual(
     const ADDR_TILEINFO* pLeft, ///<[in] Left compare operand
@@ -4183,13 +4183,13 @@ BOOL_32 EgBasedAddrLib::HwlTileInfoEqual(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlConvertTileInfoToHW
 *   @brief
 *       Entry of EgBasedAddrLib ConvertTileInfoToHW
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE EgBasedAddrLib::HwlConvertTileInfoToHW(
     const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
@@ -4451,13 +4451,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlConvertTileInfoToHW(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlComputeSurfaceInfo
 *   @brief
 *       Entry of EgBasedAddrLib ComputeSurfaceInfo
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceInfo(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,    ///< [in] input structure
@@ -4538,13 +4538,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlComputeSurfaceAddrFromCoord
 *   @brief
 *       Entry of EgBasedAddrLib ComputeSurfaceAddrFromCoord
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceAddrFromCoord(
     const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,    ///< [in] input structure
@@ -4571,13 +4571,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlComputeSurfaceCoordFromAddr
 *   @brief
 *       Entry of EgBasedAddrLib ComputeSurfaceCoordFromAddr
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceCoordFromAddr(
     const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,    ///< [in] input structure
@@ -4599,13 +4599,13 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSurfaceCoordFromAddr(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlComputeSliceTileSwizzle
 *   @brief
 *       Entry of EgBasedAddrLib ComputeSurfaceCoordFromAddr
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSliceTileSwizzle(
     const ADDR_COMPUTE_SLICESWIZZLE_INPUT*  pIn,    ///< [in] input structure
@@ -4632,7 +4632,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSliceTileSwizzle(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlComputeHtileBpp
 *
 *   @brief
@@ -4640,7 +4640,7 @@ ADDR_E_RETURNCODE EgBasedAddrLib::HwlComputeSliceTileSwizzle(
 *
 *   @return
 *       Htile bpp
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 EgBasedAddrLib::HwlComputeHtileBpp(
     BOOL_32 isWidth8,   ///< [in] TRUE if block width is 8
@@ -4653,7 +4653,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBpp(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlComputeHtileBaseAlign
 *
 *   @brief
@@ -4661,7 +4661,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBpp(
 *
 *   @return
 *       Htile base alignment
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 EgBasedAddrLib::HwlComputeHtileBaseAlign(
     BOOL_32         isTcCompatible, ///< [in] if TC compatible
@@ -4684,7 +4684,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBaseAlign(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled
 *
 *   @brief
@@ -4693,7 +4693,7 @@ UINT_32 EgBasedAddrLib::HwlComputeHtileBaseAlign(
 *
 *   @return
 *       pitch alignment
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(
     AddrTileMode        tileMode,          ///< [in] tile mode
@@ -4733,7 +4733,7 @@ UINT_32 EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled
 *
 *   @brief
@@ -4741,7 +4741,7 @@ UINT_32 EgBasedAddrLib::HwlGetPitchAlignmentMicroTiled(
 *
 *   @return
 *       Logical slice size in bytes
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled(
     UINT_32             thickness,      ///< [in] thickness
@@ -4775,7 +4775,7 @@ UINT_64 EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   EgBasedAddrLib::HwlStereoCheckRightOffsetPadding
 *
 *   @brief
@@ -4784,7 +4784,7 @@ UINT_64 EgBasedAddrLib::HwlGetSizeAdjustmentMicroTiled(
 *   @return
 *       TRUE is the extra padding is needed
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 EgBasedAddrLib::HwlStereoCheckRightOffsetPadding(
     ADDR_TILEINFO* pTileInfo    ///< Tiling info
diff --git a/src/amd/addrlib/r800/egbaddrlib.h b/src/amd/addrlib/r800/egbaddrlib.h
index a4240829fa0..6bc6c53e874 100644
--- a/src/amd/addrlib/r800/egbaddrlib.h
+++ b/src/amd/addrlib/r800/egbaddrlib.h
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  egbaddrlib.h
 * @brief Contains the EgBasedAddrLib class definition.
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #ifndef __EG_BASED_ADDR_LIB_H__
@@ -53,10 +53,10 @@ struct CoordFromBankPipe
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief This class is the Evergreen based address library
 * @note  Abstract class
-***************************************************************************************************
+****************************************************************************************************
 */
 class EgBasedAddrLib : public AddrLib1
 {
diff --git a/src/amd/addrlib/r800/siaddrlib.cpp b/src/amd/addrlib/r800/siaddrlib.cpp
index 30f99349a1b..964f2fd28cc 100644
--- a/src/amd/addrlib/r800/siaddrlib.cpp
+++ b/src/amd/addrlib/r800/siaddrlib.cpp
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  siaddrlib.cpp
 * @brief Contains the implementation for the SiAddrLib class.
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #include "siaddrlib.h"
@@ -47,15 +47,15 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
-***************************************************************************************************
-*   AddrSIHwlInit
+****************************************************************************************************
+*   AddrSiHwlInit
 *
 *   @brief
 *       Creates an SiAddrLib object.
 *
 *   @return
 *       Returns an SiAddrLib object pointer.
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrLib* AddrSIHwlInit(const AddrClient* pClient)
 {
@@ -63,13 +63,13 @@ AddrLib* AddrSIHwlInit(const AddrClient* pClient)
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::SiAddrLib
 *
 *   @brief
 *       Constructor
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 SiAddrLib::SiAddrLib(const AddrClient* pClient) :
     EgBasedAddrLib(pClient),
@@ -81,26 +81,26 @@ SiAddrLib::SiAddrLib(const AddrClient* pClient) :
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::~SiAddrLib
 *
 *   @brief
 *       Destructor
-***************************************************************************************************
+****************************************************************************************************
 */
 SiAddrLib::~SiAddrLib()
 {
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlGetPipes
 *
 *   @brief
 *       Get number pipes
 *   @return
 *       num pipes
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 SiAddrLib::HwlGetPipes(
     const ADDR_TILEINFO* pTileInfo    ///< [in] Tile info
@@ -122,13 +122,13 @@ UINT_32 SiAddrLib::HwlGetPipes(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::GetPipePerSurf
 *   @brief
 *       get pipe num base on inputing tileinfo->pipeconfig
 *   @return
 *       pipe number
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 SiAddrLib::GetPipePerSurf(
     AddrPipeCfg pipeConfig   ///< [in] pipe config
@@ -168,7 +168,7 @@ UINT_32 SiAddrLib::GetPipePerSurf(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::ComputeBankEquation
 *
 *   @brief
@@ -176,7 +176,7 @@ UINT_32 SiAddrLib::GetPipePerSurf(
 *
 *   @return
 *       If equation can be computed
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE SiAddrLib::ComputeBankEquation(
     UINT_32         log2BytesPP,    ///< [in] log2 of bytes per pixel
@@ -302,7 +302,7 @@ ADDR_E_RETURNCODE SiAddrLib::ComputeBankEquation(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::ComputePipeEquation
 *
 *   @brief
@@ -310,7 +310,7 @@ ADDR_E_RETURNCODE SiAddrLib::ComputeBankEquation(
 *
 *   @return
 *       If equation can be computed
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE SiAddrLib::ComputePipeEquation(
     UINT_32        log2BytesPP, ///< [in] Log2 of bytes per pixel
@@ -500,14 +500,14 @@ ADDR_E_RETURNCODE SiAddrLib::ComputePipeEquation(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::ComputePipeFromCoord
 *
 *   @brief
 *       Compute pipe number from coordinates
 *   @return
 *       Pipe number
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 SiAddrLib::ComputePipeFromCoord(
     UINT_32         x,              ///< [in] x coordinate
@@ -651,14 +651,14 @@ UINT_32 SiAddrLib::ComputePipeFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::ComputeTileCoordFromPipeAndElemIdx
 *
 *   @brief
 *       Compute (x,y) of a tile within a macro tile from address
 *   @return
 *       Pipe number
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID SiAddrLib::ComputeTileCoordFromPipeAndElemIdx(
     UINT_32         elemIdx,          ///< [in] per pipe element index within a macro tile
@@ -908,14 +908,14 @@ VOID SiAddrLib::ComputeTileCoordFromPipeAndElemIdx(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::TileCoordToMaskElementIndex
 *
 *   @brief
 *       Compute element index from coordinates in tiles
 *   @return
 *       Element index
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 SiAddrLib::TileCoordToMaskElementIndex(
     UINT_32         tx,                 ///< [in] x coord, in Tiles
@@ -1044,7 +1044,7 @@ UINT_32 SiAddrLib::TileCoordToMaskElementIndex(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlComputeTileDataWidthAndHeightLinear
 *
 *   @brief
@@ -1055,7 +1055,7 @@ UINT_32 SiAddrLib::TileCoordToMaskElementIndex(
 *
 *   @note
 *       MacroWidth and macroHeight are measured in pixels
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID SiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
     UINT_32*        pMacroWidth,     ///< [out] macro tile width
@@ -1090,7 +1090,7 @@ VOID SiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlComputeHtileBytes
 *
 *   @brief
@@ -1098,7 +1098,7 @@ VOID SiAddrLib::HwlComputeTileDataWidthAndHeightLinear(
 *
 *   @return
 *       Htile size in bytes
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 SiAddrLib::HwlComputeHtileBytes(
     UINT_32     pitch,          ///< [in] pitch
@@ -1114,14 +1114,14 @@ UINT_64 SiAddrLib::HwlComputeHtileBytes(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlComputeXmaskAddrFromCoord
 *
 *   @brief
 *       Compute address from coordinates for htile/cmask
 *   @return
 *       Byte address
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 SiAddrLib::HwlComputeXmaskAddrFromCoord(
     UINT_32        pitch,          ///< [in] pitch
@@ -1269,7 +1269,7 @@ UINT_64 SiAddrLib::HwlComputeXmaskAddrFromCoord(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlComputeXmaskCoordFromAddr
 *
 *   @brief
@@ -1280,7 +1280,7 @@ UINT_64 SiAddrLib::HwlComputeXmaskAddrFromCoord(
 *
 *   @note
 *       This method is reused by htile, so rename to Xmask
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID SiAddrLib::HwlComputeXmaskCoordFromAddr(
     UINT_64         addr,           ///< [in] address
@@ -1475,13 +1475,13 @@ VOID SiAddrLib::HwlComputeXmaskCoordFromAddr(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlGetPitchAlignmentLinear
 *   @brief
 *       Get pitch alignment
 *   @return
 *       pitch alignment
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 SiAddrLib::HwlGetPitchAlignmentLinear(
     UINT_32             bpp,    ///< [in] bits per pixel
@@ -1505,7 +1505,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentLinear(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlGetSizeAdjustmentLinear
 *
 *   @brief
@@ -1513,7 +1513,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentLinear(
 *
 *   @return
 *       Logical slice size in bytes
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 SiAddrLib::HwlGetSizeAdjustmentLinear(
     AddrTileMode        tileMode,       ///< [in] tile mode
@@ -1566,7 +1566,7 @@ UINT_64 SiAddrLib::HwlGetSizeAdjustmentLinear(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlPreHandleBaseLvl3xPitch
 *
 *   @brief
@@ -1574,7 +1574,7 @@ UINT_64 SiAddrLib::HwlGetSizeAdjustmentLinear(
 *
 *   @return
 *       Expected pitch
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,        ///< [in] input
@@ -1598,7 +1598,7 @@ UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlPostHandleBaseLvl3xPitch
 *
 *   @brief
@@ -1606,7 +1606,7 @@ UINT_32 SiAddrLib::HwlPreHandleBaseLvl3xPitch(
 *
 *   @return
 *       Expected pitch
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,        ///< [in] input
@@ -1627,7 +1627,7 @@ UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlGetPitchAlignmentMicroTiled
 *
 *   @brief
@@ -1635,7 +1635,7 @@ UINT_32 SiAddrLib::HwlPostHandleBaseLvl3xPitch(
 *
 *   @return
 *       pitch alignment
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
     AddrTileMode        tileMode,          ///< [in] tile mode
@@ -1659,7 +1659,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlGetSizeAdjustmentMicroTiled
 *
 *   @brief
@@ -1667,7 +1667,7 @@ UINT_32 SiAddrLib::HwlGetPitchAlignmentMicroTiled(
 *
 *   @return
 *       Logical slice size in bytes
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_64 SiAddrLib::HwlGetSizeAdjustmentMicroTiled(
     UINT_32             thickness,      ///< [in] thickness
@@ -1739,14 +1739,14 @@ UINT_64 SiAddrLib::HwlGetSizeAdjustmentMicroTiled(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlConvertChipFamily
 *
 *   @brief
 *       Convert familyID defined in atiid.h to AddrChipFamily and set m_chipFamily/m_chipRevision
 *   @return
 *       AddrChipFamily
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrChipFamily SiAddrLib::HwlConvertChipFamily(
     UINT_32 uChipFamily,        ///< [in] chip family defined in atiih.h
@@ -1773,12 +1773,12 @@ AddrChipFamily SiAddrLib::HwlConvertChipFamily(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlSetupTileInfo
 *
 *   @brief
 *       Setup default value of tile info for SI
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID SiAddrLib::HwlSetupTileInfo(
     AddrTileMode                        tileMode,       ///< [in] Tile mode
@@ -2096,7 +2096,7 @@ VOID SiAddrLib::HwlSetupTileInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::DecodeGbRegs
 *
 *   @brief
@@ -2105,7 +2105,7 @@ VOID SiAddrLib::HwlSetupTileInfo(
 *   @return
 *       TRUE if all settings are valid
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 SiAddrLib::DecodeGbRegs(
     const ADDR_REGISTER_VALUE* pRegValue) ///< [in] create input
@@ -2185,7 +2185,7 @@ BOOL_32 SiAddrLib::DecodeGbRegs(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlInitGlobalParams
 *
 *   @brief
@@ -2194,7 +2194,7 @@ BOOL_32 SiAddrLib::DecodeGbRegs(
 *   @return
 *       TRUE if all settings are valid
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 SiAddrLib::HwlInitGlobalParams(
     const ADDR_CREATE_INPUT* pCreateIn) ///< [in] create input
@@ -2234,13 +2234,13 @@ BOOL_32 SiAddrLib::HwlInitGlobalParams(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlConvertTileInfoToHW
 *   @brief
 *       Entry of si's ConvertTileInfoToHW
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE SiAddrLib::HwlConvertTileInfoToHW(
     const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] input structure
@@ -2276,7 +2276,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlConvertTileInfoToHW(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe
 *
 *   @brief
@@ -2284,7 +2284,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlConvertTileInfoToHW(
 *       coord.
 *   @return
 *       Y coord
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe(
     UINT_32         pipe,       ///< [in] pipe id
@@ -2299,14 +2299,14 @@ UINT_32 SiAddrLib::HwlComputeXmaskCoordYFrom8Pipe(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe
 *
 *   @brief
 *       Compute surface x,y coordinates from bank/pipe info
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe(
     AddrTileMode        tileMode,   ///< [in] tile mode
@@ -2464,14 +2464,14 @@ VOID SiAddrLib::HwlComputeSurfaceCoord2DFromBankPipe(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlPreAdjustBank
 *
 *   @brief
 *       Adjust bank before calculating address acoording to bank/pipe
 *   @return
 *       Adjusted bank
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 SiAddrLib::HwlPreAdjustBank(
     UINT_32         tileX,      ///< [in] x coordinate in unit of tile
@@ -2496,14 +2496,14 @@ UINT_32 SiAddrLib::HwlPreAdjustBank(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlComputeSurfaceInfo
 *
 *   @brief
 *       Entry of si's ComputeSurfaceInfo
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE SiAddrLib::HwlComputeSurfaceInfo(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,    ///< [in] input structure
@@ -2540,13 +2540,13 @@ ADDR_E_RETURNCODE SiAddrLib::HwlComputeSurfaceInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlComputeMipLevel
 *   @brief
 *       Compute MipLevel info (including level 0)
 *   @return
 *       TRUE if HWL's handled
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 SiAddrLib::HwlComputeMipLevel(
     ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn ///< [in/out] Input structure
@@ -2578,14 +2578,14 @@ BOOL_32 SiAddrLib::HwlComputeMipLevel(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlCheckLastMacroTiledLvl
 *
 *   @brief
 *       Sets pOut->last2DLevel to TRUE if it is
 *   @note
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
     const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] Input structure
@@ -2653,7 +2653,7 @@ VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlDegradeThickTileMode
 *
 *   @brief
@@ -2661,7 +2661,7 @@ VOID SiAddrLib::HwlCheckLastMacroTiledLvl(
 *
 *   @return
 *       Suitable tile mode
-***************************************************************************************************
+****************************************************************************************************
 */
 AddrTileMode SiAddrLib::HwlDegradeThickTileMode(
     AddrTileMode        baseTileMode,   ///< [in] base tile mode
@@ -2673,14 +2673,14 @@ AddrTileMode SiAddrLib::HwlDegradeThickTileMode(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlTileInfoEqual
 *
 *   @brief
 *       Return TRUE if all field are equal
 *   @note
 *       Only takes care of current HWL's data
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 SiAddrLib::HwlTileInfoEqual(
     const ADDR_TILEINFO* pLeft, ///<[in] Left compare operand
@@ -2698,14 +2698,14 @@ BOOL_32 SiAddrLib::HwlTileInfoEqual(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::GetTileSettings
 *
 *   @brief
 *       Get tile setting infos by index.
 *   @return
 *       Tile setting info.
-***************************************************************************************************
+****************************************************************************************************
 */
 const AddrTileConfig* SiAddrLib::GetTileSetting(
     UINT_32 index          ///< [in] Tile index
@@ -2716,7 +2716,7 @@ const AddrTileConfig* SiAddrLib::GetTileSetting(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlPostCheckTileIndex
 *
 *   @brief
@@ -2724,7 +2724,7 @@ const AddrTileConfig* SiAddrLib::GetTileSetting(
 *       tile mode/type/info and change the index if needed
 *   @return
 *       Tile index.
-***************************************************************************************************
+****************************************************************************************************
 */
 INT_32 SiAddrLib::HwlPostCheckTileIndex(
     const ADDR_TILEINFO* pInfo,     ///< [in] Tile Info
@@ -2795,14 +2795,14 @@ INT_32 SiAddrLib::HwlPostCheckTileIndex(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlSetupTileCfg
 *
 *   @brief
 *       Map tile index to tile setting.
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE SiAddrLib::HwlSetupTileCfg(
     UINT_32         bpp,            ///< [in] Bits per pixel
@@ -2876,14 +2876,14 @@ ADDR_E_RETURNCODE SiAddrLib::HwlSetupTileCfg(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::ReadGbTileMode
 *
 *   @brief
 *       Convert GB_TILE_MODE HW value to ADDR_TILE_CONFIG.
 *   @return
 *       NA.
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID SiAddrLib::ReadGbTileMode(
     UINT_32             regValue,   ///< [in] GB_TILE_MODE register
@@ -2916,14 +2916,14 @@ VOID SiAddrLib::ReadGbTileMode(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::InitTileSettingTable
 *
 *   @brief
 *       Initialize the ADDR_TILE_CONFIG table.
 *   @return
 *       TRUE if tile table is correctly initialized
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 SiAddrLib::InitTileSettingTable(
     const UINT_32*  pCfg,           ///< [in] Pointer to table of tile configs
@@ -2967,14 +2967,14 @@ BOOL_32 SiAddrLib::InitTileSettingTable(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlGetTileIndex
 *
 *   @brief
 *       Return the virtual/real index for given mode/type/info
 *   @return
 *       ADDR_OK if successful.
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE SiAddrLib::HwlGetTileIndex(
     const ADDR_GET_TILEINDEX_INPUT* pIn,
@@ -2988,14 +2988,14 @@ ADDR_E_RETURNCODE SiAddrLib::HwlGetTileIndex(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlFmaskPreThunkSurfInfo
 *
 *   @brief
 *       Some preparation before thunking a ComputeSurfaceInfo call for Fmask
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID SiAddrLib::HwlFmaskPreThunkSurfInfo(
     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pFmaskIn,   ///< [in] Input of fmask info
@@ -3008,14 +3008,14 @@ VOID SiAddrLib::HwlFmaskPreThunkSurfInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlFmaskPostThunkSurfInfo
 *
 *   @brief
 *       Copy hwl extra field after calling thunked ComputeSurfaceInfo
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID SiAddrLib::HwlFmaskPostThunkSurfInfo(
     const ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pSurfOut,   ///< [in] Output of surface info
@@ -3027,13 +3027,13 @@ VOID SiAddrLib::HwlFmaskPostThunkSurfInfo(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlComputeFmaskBits
 *   @brief
 *       Computes fmask bits
 *   @return
 *       Fmask bits
-***************************************************************************************************
+****************************************************************************************************
 */
 UINT_32 SiAddrLib::HwlComputeFmaskBits(
     const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn,
@@ -3128,7 +3128,7 @@ UINT_32 SiAddrLib::HwlComputeFmaskBits(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlOverrideTileMode
 *
 *   @brief
@@ -3137,7 +3137,7 @@ UINT_32 SiAddrLib::HwlComputeFmaskBits(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 void SiAddrLib::HwlOverrideTileMode(
     ADDR_COMPUTE_SURFACE_INFO_INPUT*    pInOut          ///< [in/out] input output structure
@@ -3198,7 +3198,7 @@ void SiAddrLib::HwlOverrideTileMode(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlSelectTileMode
 *
 *   @brief
@@ -3207,7 +3207,7 @@ void SiAddrLib::HwlOverrideTileMode(
 *   @return
 *       N/A
 *
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID SiAddrLib::HwlSelectTileMode(
     ADDR_COMPUTE_SURFACE_INFO_INPUT* pInOut     ///< [in/out] input output structure
@@ -3274,14 +3274,14 @@ VOID SiAddrLib::HwlSelectTileMode(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::HwlGetMaxAlignments
 *
 *   @brief
 *       Gets maximum alignments
 *   @return
 *       ADDR_E_RETURNCODE
-***************************************************************************************************
+****************************************************************************************************
 */
 ADDR_E_RETURNCODE SiAddrLib::HwlGetMaxAlignments(
     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut    ///< [out] output structure
@@ -3320,7 +3320,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlGetMaxAlignments(
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::InitEquationTable
 *
 *   @brief
@@ -3328,7 +3328,7 @@ ADDR_E_RETURNCODE SiAddrLib::HwlGetMaxAlignments(
 *
 *   @return
 *       N/A
-***************************************************************************************************
+****************************************************************************************************
 */
 VOID SiAddrLib::InitEquationTable()
 {
@@ -3491,7 +3491,7 @@ VOID SiAddrLib::InitEquationTable()
 }
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 *   SiAddrLib::IsEquationSupported
 *
 *   @brief
@@ -3499,7 +3499,7 @@ VOID SiAddrLib::InitEquationTable()
 *
 *   @return
 *       TRUE if supported
-***************************************************************************************************
+****************************************************************************************************
 */
 BOOL_32 SiAddrLib::IsEquationSupported(
     UINT_32        bpp,         ///< Bits per pixel
diff --git a/src/amd/addrlib/r800/siaddrlib.h b/src/amd/addrlib/r800/siaddrlib.h
index 7619cfec3ee..ef24dfbe560 100644
--- a/src/amd/addrlib/r800/siaddrlib.h
+++ b/src/amd/addrlib/r800/siaddrlib.h
@@ -25,10 +25,10 @@
  */
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @file  siaddrlib.h
 * @brief Contains the R800AddrLib class definition.
-***************************************************************************************************
+****************************************************************************************************
 */
 
 #ifndef __SI_ADDR_LIB_H__
@@ -38,9 +38,9 @@
 #include "egbaddrlib.h"
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief Describes the information in tile mode table
-***************************************************************************************************
+****************************************************************************************************
 */
 struct AddrTileConfig
 {
@@ -50,9 +50,9 @@ struct AddrTileConfig
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief SI specific settings structure.
-***************************************************************************************************
+****************************************************************************************************
 */
 struct SIChipSettings
 {
@@ -69,10 +69,10 @@ struct SIChipSettings
 };
 
 /**
-***************************************************************************************************
+****************************************************************************************************
 * @brief This class is the SI specific address library
 *        function set.
-***************************************************************************************************
+****************************************************************************************************
 */
 class SiAddrLib : public EgBasedAddrLib
 {