From: Xavi Zhang <[email protected]> Find ^/{80,99}$ and replace them to 100 "/"
Signed-off-by: Nicolai Hähnle <[email protected]> --- src/amd/addrlib/addrinterface.cpp | 24 ++++++++++++------------ src/amd/addrlib/addrinterface.h | 32 ++++++++++++++++---------------- src/amd/addrlib/addrtypes.h | 8 ++++---- src/amd/addrlib/core/addrcommon.h | 28 ++++++++++++++-------------- src/amd/addrlib/core/addrlib.cpp | 12 ++++++------ src/amd/addrlib/core/addrlib1.cpp | 20 ++++++++++---------- src/amd/addrlib/r800/ciaddrlib.cpp | 4 ++-- src/amd/addrlib/r800/siaddrlib.cpp | 4 ++-- 8 files changed, 66 insertions(+), 66 deletions(-) diff --git a/src/amd/addrlib/addrinterface.cpp b/src/amd/addrlib/addrinterface.cpp index efb6ff5..571a076 100644 --- a/src/amd/addrlib/addrinterface.cpp +++ b/src/amd/addrlib/addrinterface.cpp @@ -30,23 +30,23 @@ * @brief Contains the addrlib interface functions **************************************************************************************************** */ #include "addrinterface.h" #include "addrlib1.h" #include "addrcommon.h" using namespace Addr; -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Create/Destroy/Config functions -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * AddrCreate * * @brief * Create address lib object * * @return * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE @@ -89,23 +89,23 @@ ADDR_E_RETURNCODE ADDR_API AddrDestroy( else { returnCode = ADDR_ERROR; } return returnCode; } -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Surface functions -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * AddrComputeSurfaceInfo * * @brief * Calculate surface width/height/depth/alignments and suitable tiling mode * * @return * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE @@ -193,23 +193,23 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr( else { returnCode = ADDR_ERROR; } return returnCode; } -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // HTile functions -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * AddrComputeHtileInfo * * @brief * Compute Htile pitch, height, base alignment and size in bytes * * @return * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE @@ -296,23 +296,23 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr( else { returnCode = ADDR_ERROR; } return returnCode; } -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // C-mask functions -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * AddrComputeCmaskInfo * * @brief * Compute Cmask pitch, height, base alignment and size in bytes from color buffer * info * * @return @@ -400,23 +400,23 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr( else { returnCode = ADDR_ERROR; } return returnCode; } -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // F-mask functions -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * AddrComputeFmaskInfo * * @brief * Compute Fmask pitch/height/depth/alignments and size in bytes * * @return * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE @@ -502,23 +502,23 @@ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr( else { returnCode = ADDR_ERROR; } return returnCode; } -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // DCC key functions -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * AddrComputeDccInfo * * @brief * Compute DCC key size, base alignment based on color surface size, tile info or tile index * **************************************************************************************************** */ diff --git a/src/amd/addrlib/addrinterface.h b/src/amd/addrlib/addrinterface.h index 3d52536..55f3ebc 100644 --- a/src/amd/addrlib/addrinterface.h +++ b/src/amd/addrlib/addrinterface.h @@ -106,23 +106,23 @@ typedef VOID* ADDR_CLIENT_HANDLE; * AddrConvertTileInfoToHW() * AddrConvertTileIndex() * AddrConvertTileIndex1() * AddrGetTileIndex() * AddrComputeBaseSwizzle() * AddrUseTileIndex() * AddrUseCombinedSwizzle() * **/ -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Callback functions -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * @brief channel setting structure **************************************************************************************************** */ typedef union _ADDR_CHANNEL_SETTING { struct { @@ -274,23 +274,23 @@ typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_DEBUGPRINT)( * Address Library needs client to provide system memory alloc/free routines. **************************************************************************************************** */ typedef struct _ADDR_CALLBACKS { ADDR_ALLOCSYSMEM allocSysMem; ///< Routine to allocate system memory ADDR_FREESYSMEM freeSysMem; ///< Routine to free system memory ADDR_DEBUGPRINT debugPrint; ///< Routine to print debug message } ADDR_CALLBACKS; -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Create/Destroy functions -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * ADDR_CREATE_FLAGS * * @brief * This structure is used to pass some setup in creation of AddrLib * @note **************************************************************************************************** */ @@ -415,23 +415,23 @@ ADDR_E_RETURNCODE ADDR_API AddrCreate( * * @return * ADDR_OK if successful **************************************************************************************************** */ ADDR_E_RETURNCODE ADDR_API AddrDestroy( ADDR_HANDLE hLib); -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Surface functions -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * @brief * Bank/tiling parameters. On function input, these can be set as desired or * left 0 for AddrLib to calculate/default. On function output, these are the actual * parameters used. * @note * Valid bankWidth/bankHeight value: * 1,2,4,8. They are factors instead of pixels or bytes. @@ -812,23 +812,23 @@ typedef struct _ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT * * @brief * Compute coordinate from a given surface address **************************************************************************************************** */ ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr( ADDR_HANDLE hLib, const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut); -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // HTile functions -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * ADDR_HTILE_FLAGS * * @brief * HTILE flags **************************************************************************************************** */ typedef union _ADDR_HTILE_FLAGS @@ -1027,23 +1027,23 @@ typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT * Htile address **************************************************************************************************** */ ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr( ADDR_HANDLE hLib, const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut); -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // C-mask functions -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * ADDR_CMASK_FLAGS * * @brief * CMASK flags **************************************************************************************************** */ typedef union _ADDR_CMASK_FLAGS @@ -1238,23 +1238,23 @@ typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT * Cmask address **************************************************************************************************** */ ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr( ADDR_HANDLE hLib, const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut); -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // F-mask functions -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * ADDR_COMPUTE_FMASK_INFO_INPUT * * @brief * Input structure for AddrComputeFmaskInfo **************************************************************************************************** */ typedef struct _ADDR_COMPUTE_FMASK_INFO_INPUT @@ -1473,23 +1473,23 @@ typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT * Compute FMASK coordinate from an given address **************************************************************************************************** */ ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr( ADDR_HANDLE hLib, const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut); -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Element/utility functions -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * AddrGetVersion * * @brief * Get AddrLib version number **************************************************************************************************** */ UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib); @@ -2202,23 +2202,23 @@ typedef struct _ADDR_PRT_INFO_OUTPUT * * @brief * Compute prt surface related information **************************************************************************************************** */ ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo( ADDR_HANDLE hLib, const ADDR_PRT_INFO_INPUT* pIn, ADDR_PRT_INFO_OUTPUT* pOut); -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // DCC key functions -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * _ADDR_COMPUTE_DCCINFO_INPUT * * @brief * Input structure of AddrComputeDccInfo **************************************************************************************************** */ typedef struct _ADDR_COMPUTE_DCCINFO_INPUT diff --git a/src/amd/addrlib/addrtypes.h b/src/amd/addrlib/addrtypes.h index 6fb11d0..4d09c43 100644 --- a/src/amd/addrlib/addrtypes.h +++ b/src/amd/addrlib/addrtypes.h @@ -443,25 +443,25 @@ typedef enum _AddrPipeCfg */ typedef enum _AddrTileType { ADDR_DISPLAYABLE = 0, ///< Displayable tiling ADDR_NON_DISPLAYABLE = 1, ///< Non-displayable tiling, a.k.a thin micro tiling ADDR_DEPTH_SAMPLE_ORDER = 2, ///< Same as non-displayable plus depth-sample-order ADDR_ROTATED = 3, ///< Rotated displayable tiling ADDR_THICK = 4, ///< Thick micro-tiling, only valid for THICK and XTHICK } AddrTileType; -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // // Type definitions: short system-independent names for address library types // -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// #if !defined(__APPLE__) || defined(HAVE_TSERVER) #ifndef BOOL_32 // no bool type in C /// @brief Boolean type, since none is defined in C /// @ingroup type #define BOOL_32 int #endif #ifndef INT_32 @@ -568,25 +568,25 @@ typedef enum _AddrTileType /// Therefore, all address library routines that pass or return 32-bit /// floating point data do so by passing or returning a FLT_32. /// typedef union { INT_32 i; UINT_32 u; float f; } ADDR_FLT_32; -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // // Macros for controlling linking and building on multiple systems // -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// #if defined(_MSC_VER) #if defined(va_copy) #undef va_copy //redefine va_copy to support VC2013 #endif #endif #if !defined(va_copy) #define va_copy(dst, src) \ ((void) memcpy(&(dst), &(src), sizeof(va_list))) #endif diff --git a/src/amd/addrlib/core/addrcommon.h b/src/amd/addrlib/core/addrcommon.h index caed63f..664ab6c 100644 --- a/src/amd/addrlib/core/addrcommon.h +++ b/src/amd/addrlib/core/addrcommon.h @@ -39,39 +39,39 @@ // ADDR_LNX_KERNEL_BUILD is for internal build // Moved from addrinterface.h so __KERNEL__ is not needed any more #if ADDR_LNX_KERNEL_BUILD // || (defined(__GNUC__) && defined(__KERNEL__)) #include "lnx_common_defs.h" // ported from cmmqs #elif !defined(__APPLE__) || defined(HAVE_TSERVER) #include <stdlib.h> #include <string.h> #endif -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Platform specific debug break defines -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// #if DEBUG #if defined(__GNUC__) #define ADDR_DBG_BREAK() #elif defined(__APPLE__) #define ADDR_DBG_BREAK() { IOPanic("");} #else #define ADDR_DBG_BREAK() { __debugbreak(); } #endif #else #define ADDR_DBG_BREAK() #endif -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Debug assertions used in AddrLib -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// #if defined(_WIN32) && (_MSC_VER >= 1400) #define ADDR_ANALYSIS_ASSUME(expr) __analysis_assume(expr) #else #define ADDR_ANALYSIS_ASSUME(expr) do { } while (0) #endif #if DEBUG #define ADDR_ASSERT(__e) \ do { \ ADDR_ANALYSIS_ASSUME(__e); \ @@ -79,25 +79,25 @@ } while (0) #define ADDR_ASSERT_ALWAYS() ADDR_DBG_BREAK() #define ADDR_UNHANDLED_CASE() ADDR_ASSERT(!"Unhandled case") #define ADDR_NOT_IMPLEMENTED() ADDR_ASSERT(!"Not implemented"); #else //DEBUG #define ADDR_ASSERT(__e) ADDR_ANALYSIS_ASSUME(__e) #define ADDR_ASSERT_ALWAYS() #define ADDR_UNHANDLED_CASE() #define ADDR_NOT_IMPLEMENTED() #endif //DEBUG -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Debug print macro from legacy address library -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// #if DEBUG #define ADDR_PRNT(a) Object::DebugPrint a /// @brief Macro for reporting informational messages /// @ingroup util /// /// This macro optionally prints an informational message to stdout. /// The first parameter is a condition -- if it is true, nothing is done. /// The second pararmeter MUST be a parenthesis-enclosed list of arguments, @@ -154,50 +154,50 @@ #define ADDR_DBG_BREAK() #define ADDR_INFO(cond, a) #define ADDR_WARN(cond, a) #define ADDR_EXIT(cond, a) #endif // DEBUG -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// namespace Addr { namespace V1 { -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Common constants -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// static const UINT_32 MicroTileWidth = 8; ///< Micro tile width, for 1D and 2D tiling static const UINT_32 MicroTileHeight = 8; ///< Micro tile height, for 1D and 2D tiling static const UINT_32 ThickTileThickness = 4; ///< Micro tile thickness, for THICK modes static const UINT_32 XThickTileThickness = 8; ///< Extra thick tiling thickness static const UINT_32 PowerSaveTileBytes = 64; ///< Nuber of bytes per tile for power save 64 static const UINT_32 CmaskCacheBits = 1024; ///< Number of bits for CMASK cache static const UINT_32 CmaskElemBits = 4; ///< Number of bits for CMASK element static const UINT_32 HtileCacheBits = 16384; ///< Number of bits for HTILE cache 512*32 static const UINT_32 MicroTilePixels = MicroTileWidth * MicroTileHeight; static const INT_32 TileIndexInvalid = TILEINDEX_INVALID; static const INT_32 TileIndexLinearGeneral = TILEINDEX_LINEAR_GENERAL; static const INT_32 TileIndexNoMacroIndex = -3; } // V1 -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Common macros -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// #define BITS_PER_BYTE 8 #define BITS_TO_BYTES(x) ( ((x) + (BITS_PER_BYTE-1)) / BITS_PER_BYTE ) #define BYTES_TO_BITS(x) ( (x) * BITS_PER_BYTE ) /// Helper macros to select a single bit from an int (undefined later in section) #define _BIT(v,b) (((v) >> (b) ) & 1) /** **************************************************************************************************** * @brief Enums to identify AddrLib type @@ -256,21 +256,21 @@ union ConfigFlags UINT_32 checkLast2DLevel : 1; ///< Check the last 2D mip sub level UINT_32 useHtileSliceAlign : 1; ///< Do htile single slice alignment UINT_32 allowLargeThickTile : 1; ///< Allow 64*thickness*bytesPerPixel > rowSize UINT_32 disableLinearOpt : 1; ///< Disallow tile modes to be optimized to linear UINT_32 reserved : 22; ///< Reserved bits for future use }; UINT_32 value; }; -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Misc helper functions //////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * AddrXorReduce * * @brief * Xor the right-side numberOfBits bits of x. **************************************************************************************************** diff --git a/src/amd/addrlib/core/addrlib.cpp b/src/amd/addrlib/core/addrlib.cpp index d4b31e6..9af742f 100644 --- a/src/amd/addrlib/core/addrlib.cpp +++ b/src/amd/addrlib/core/addrlib.cpp @@ -77,23 +77,23 @@ extern "C" UINT_32 __umoddi3(UINT_64 n, UINT_32 base) { return div64_32(n, base); } #endif // __APPLE__ namespace Addr { -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Constructor/Destructor -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * Lib::Lib * * @brief * Constructor for the AddrLib class * **************************************************************************************************** */ @@ -151,23 +151,23 @@ Lib::Lib(const Client* pClient) : Lib::~Lib() { if (m_pElemLib) { delete m_pElemLib; m_pElemLib = NULL; } } -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Initialization/Helper -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * Lib::Create * * @brief * Creates and initializes AddrLib object. * * @return * ADDR_E_RETURNCODE @@ -402,23 +402,23 @@ UINT_32 Lib::Bits2Number( } number >>= 1; va_end(bits_ptr); return number; } -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Element lib -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * Lib::Flt32ToColorPixel * * @brief * Convert a FLT_32 value to a depth/stencil pixel value * @return * ADDR_E_RETURNCODE diff --git a/src/amd/addrlib/core/addrlib1.cpp b/src/amd/addrlib/core/addrlib1.cpp index f0cd58c..d48aa7c 100644 --- a/src/amd/addrlib/core/addrlib1.cpp +++ b/src/amd/addrlib/core/addrlib1.cpp @@ -33,23 +33,23 @@ #include "addrinterface.h" #include "addrlib1.h" #include "addrcommon.h" namespace Addr { namespace V1 { -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Static Const Member -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// const TileModeFlags Lib::ModeFlags[ADDR_TM_COUNT] = {// T L 1 2 3 P Pr B {1, 1, 0, 0, 0, 0, 0, 0}, // ADDR_TM_LINEAR_GENERAL {1, 1, 0, 0, 0, 0, 0, 0}, // ADDR_TM_LINEAR_ALIGNED {1, 0, 1, 0, 0, 0, 0, 0}, // ADDR_TM_1D_TILED_THIN1 {4, 0, 1, 0, 0, 0, 0, 0}, // ADDR_TM_1D_TILED_THICK {1, 0, 0, 1, 0, 0, 0, 0}, // ADDR_TM_2D_TILED_THIN1 {1, 0, 0, 1, 0, 0, 0, 0}, // ADDR_TM_2D_TILED_THIN2 {1, 0, 0, 1, 0, 0, 0, 0}, // ADDR_TM_2D_TILED_THIN4 @@ -67,23 +67,23 @@ const TileModeFlags Lib::ModeFlags[ADDR_TM_COUNT] = {1, 0, 0, 0, 0, 0, 0, 0}, // ADDR_TM_POWER_SAVE {1, 0, 0, 1, 0, 1, 1, 0}, // ADDR_TM_PRT_TILED_THIN1 {1, 0, 0, 1, 0, 1, 0, 0}, // ADDR_TM_PRT_2D_TILED_THIN1 {1, 0, 0, 1, 1, 1, 0, 0}, // ADDR_TM_PRT_3D_TILED_THIN1 {4, 0, 0, 1, 0, 1, 1, 0}, // ADDR_TM_PRT_TILED_THICK {4, 0, 0, 1, 0, 1, 0, 0}, // ADDR_TM_PRT_2D_TILED_THICK {4, 0, 0, 1, 1, 1, 0, 0}, // ADDR_TM_PRT_3D_TILED_THICK {0, 0, 0, 0, 0, 0, 0, 0}, // ADDR_TM_UNKNOWN }; -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Constructor/Destructor -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * Lib::AddrLib1 * * @brief * Constructor for the AddrLib1 class * **************************************************************************************************** */ @@ -141,23 +141,23 @@ Lib* Lib::GetLib( (pAddrLib->GetChipFamily() > ADDR_CHIP_FAMILY_VI))) { // only valid and pre-VI AISC can use AddrLib1 function. ADDR_ASSERT_ALWAYS(); hLib = NULL; } return static_cast<Lib*>(hLib); } -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Surface Methods -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * Lib::ComputeSurfaceInfo * * @brief * Interface function stub of AddrComputeSurfaceInfo. * * @return @@ -1229,23 +1229,23 @@ ADDR_E_RETURNCODE Lib::GetTileIndex( **************************************************************************************************** */ UINT_32 Lib::Thickness( AddrTileMode tileMode) ///< [in] tile mode { return ModeFlags[tileMode].thickness; } -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // CMASK/HTILE -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * Lib::ComputeHtileInfo * * @brief * Interface function stub of AddrComputeHtilenfo * * @return * ADDR_E_RETURNCODE @@ -2505,23 +2505,23 @@ UINT_64 Lib::HwlComputeXmaskAddrFromCoord( // // Compute the bit position. The lower nibble is used when the x coordinate within the macro // tile is less than half of the macro tile width, and the upper nibble is used when the x // coordinate within the macro tile is greater than or equal to half the macro tile width. // *pBitPosition = ((x % macroTileWidth) < (macroTileWidth / factor)) ? 0 : 4; return addr; } -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// // Surface Addressing Shared -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// /** **************************************************************************************************** * Lib::ComputeSurfaceAddrFromCoordLinear * * @brief * Compute address from coord for linear surface * * @return * Address in bytes diff --git a/src/amd/addrlib/r800/ciaddrlib.cpp b/src/amd/addrlib/r800/ciaddrlib.cpp index 3c0607e..3986c3b 100644 --- a/src/amd/addrlib/r800/ciaddrlib.cpp +++ b/src/amd/addrlib/r800/ciaddrlib.cpp @@ -38,22 +38,22 @@ #include "si_ci_vi_merged_enum.h" #if BRAHMA_BUILD #include "amdgpu_id.h" #else #include "ci_id.h" #include "kv_id.h" #include "vi_id.h" #endif -/////////////////////////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// namespace Addr { /** **************************************************************************************************** * CiHwlInit * * @brief * Creates an CiLib object. diff --git a/src/amd/addrlib/r800/siaddrlib.cpp b/src/amd/addrlib/r800/siaddrlib.cpp index f1f5a1b..512fb27 100644 --- a/src/amd/addrlib/r800/siaddrlib.cpp +++ b/src/amd/addrlib/r800/siaddrlib.cpp @@ -36,22 +36,22 @@ #include "si_gb_reg.h" #include "si_ci_vi_merged_enum.h" #if BRAHMA_BUILD #include "amdgpu_id.h" #else #include "si_id.h" #endif -/////////////////////////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// namespace Addr { /** **************************************************************************************************** * SiHwlInit * * @brief * Creates an SiLib object. * -- 2.7.4 _______________________________________________ mesa-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/mesa-dev
