From: Nicolai Hähnle <nicolai.haeh...@amd.com>
When clients queries tile Info from tile index and expects accurate
tileSplit info, bits per pixel info is required to be provided since
this is necessary for computing tileSplitBytes; otherwise Addrlib will
return value of "tileBytes" instead if bpp is 0 - which is also
current logic. If clients don't need tileSplit info, it's OK to pass
bpp with value 0.
---
src/amd/addrlib/addrinterface.h | 2 ++
src/amd/addrlib/core/addrlib1.cpp | 37 +++++++++++++++++++-----------------
src/amd/addrlib/core/addrlib1.h | 2 +-
src/amd/addrlib/r800/ciaddrlib.cpp | 39 ++++++++++++++++++++++++++------------
src/amd/addrlib/r800/ciaddrlib.h | 2 +-
src/amd/addrlib/r800/siaddrlib.cpp | 1 +
src/amd/addrlib/r800/siaddrlib.h | 2 +-
7 files changed, 53 insertions(+), 32 deletions(-)
diff --git a/src/amd/addrlib/addrinterface.h b/src/amd/addrlib/addrinterface.h
index bd10310..01d8788 100644
--- a/src/amd/addrlib/addrinterface.h
+++ b/src/amd/addrlib/addrinterface.h
@@ -1870,20 +1870,21 @@ typedef struct _ADDR_CONVERT_TILEINFOTOHW_INPUT
/// FALSE: convert from real value to
HW value;
/// TRUE: convert from HW value to
real value.
/// r800 and later HWL parameters
ADDR_TILEINFO* pTileInfo; ///< Tile parameters with real value
INT_32 tileIndex; ///< Tile index, MUST be -1 if you
don't want to use it
/// while the global useTileIndex is
set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if
there is one (CI)
///< README: When tileIndex is not -1,
this must be valid
+ UINT_32 bpp; ///< Bits per pixel
} ADDR_CONVERT_TILEINFOTOHW_INPUT;
/**
***************************************************************************************************
* ADDR_CONVERT_TILEINFOTOHW_OUTPUT
*
* @brief
* Output structure for AddrConvertTileInfoToHW
***************************************************************************************************
*/
@@ -1918,20 +1919,21 @@ ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
* @brief
* Input structure for AddrConvertTileIndex
***************************************************************************************************
*/
typedef struct _ADDR_CONVERT_TILEINDEX_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
INT_32 tileIndex; ///< Tile index
INT_32 macroModeIndex; ///< Index in macro tile mode table if
there is one (CI)
+ UINT_32 bpp; ///< Bits per pixel
BOOL_32 tileInfoHw; ///< Set to TRUE if client wants HW
enum, otherwise actual
} ADDR_CONVERT_TILEINDEX_INPUT;
/**
***************************************************************************************************
* ADDR_CONVERT_TILEINDEX_OUTPUT
*
* @brief
* Output structure for AddrConvertTileIndex
***************************************************************************************************
diff --git a/src/amd/addrlib/core/addrlib1.cpp
b/src/amd/addrlib/core/addrlib1.cpp
index 3252fd4..1dc61e0 100644
--- a/src/amd/addrlib/core/addrlib1.cpp
+++ b/src/amd/addrlib/core/addrlib1.cpp
@@ -300,21 +300,22 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceInfo(
localIn.bpp,
numSamples,
localIn.pTileInfo,
&localIn.tileMode,
&localIn.tileType);
}
// If macroModeIndex is not needed, then call HwlSetupTileCfg
to get tile info
if (macroModeIndex == TileIndexNoMacroIndex)
{
- returnCode = HwlSetupTileCfg(localIn.tileIndex,
macroModeIndex,
+ returnCode = HwlSetupTileCfg(localIn.bpp,
+ localIn.tileIndex,
macroModeIndex,
localIn.pTileInfo,
&localIn.tileMode,
&localIn.tileType);
}
// If macroModeIndex is invalid, then assert this is not macro
tiled
else if (macroModeIndex == TileIndexInvalid)
{
ADDR_ASSERT(!IsMacroTiled(localIn.tileMode));
}
pOut->macroModeIndex = macroModeIndex;
@@ -468,21 +469,21 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceAddrFromCoord(
flags,
input.bpp,
numSamples,
input.pTileInfo,
&input.tileMode,
&input.tileType);
// If macroModeIndex is not needed, then call HwlSetupTileCfg to
get tile info
if (macroModeIndex == TileIndexNoMacroIndex)
{
- returnCode = HwlSetupTileCfg(input.tileIndex, macroModeIndex,
+ returnCode = HwlSetupTileCfg(input.bpp, input.tileIndex,
macroModeIndex,
input.pTileInfo, &input.tileMode,
&input.tileType);
}
// If macroModeIndex is invalid, then assert this is not macro
tiled
else if (macroModeIndex == TileIndexInvalid)
{
ADDR_ASSERT(!IsMacroTiled(input.tileMode));
}
// Change the input structure
pIn = &input;
@@ -548,21 +549,21 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSurfaceCoordFromAddr(
flags,
input.bpp,
numSamples,
input.pTileInfo,
&input.tileMode,
&input.tileType);
// If macroModeIndex is not needed, then call HwlSetupTileCfg to
get tile info
if (macroModeIndex == TileIndexNoMacroIndex)
{
- returnCode = HwlSetupTileCfg(input.tileIndex, macroModeIndex,
+ returnCode = HwlSetupTileCfg(input.bpp, input.tileIndex,
macroModeIndex,
input.pTileInfo, &input.tileMode,
&input.tileType);
}
// If macroModeIndex is invalid, then assert this is not macro
tiled
else if (macroModeIndex == TileIndexInvalid)
{
ADDR_ASSERT(!IsMacroTiled(input.tileMode));
}
// Change the input structure
pIn = &input;
@@ -608,21 +609,21 @@ ADDR_E_RETURNCODE AddrLib1::ComputeSliceTileSwizzle(
{
ADDR_TILEINFO tileInfoNull;
ADDR_COMPUTE_SLICESWIZZLE_INPUT input;
if (UseTileIndex(pIn->tileIndex))
{
input = *pIn;
// Use temp tile info for calcalation
input.pTileInfo = &tileInfoNull;
- returnCode = HwlSetupTileCfg(input.tileIndex, input.macroModeIndex,
+ returnCode = HwlSetupTileCfg(0, input.tileIndex,
input.macroModeIndex,
input.pTileInfo, &input.tileMode);
// Change the input structure
pIn = &input;
}
if (returnCode == ADDR_OK)
{
returnCode = HwlComputeSliceTileSwizzle(pIn, pOut);
}
}
@@ -661,21 +662,21 @@ ADDR_E_RETURNCODE AddrLib1::ExtractBankPipeSwizzle(
{
ADDR_TILEINFO tileInfoNull;
ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT input;
if (UseTileIndex(pIn->tileIndex))
{
input = *pIn;
// Use temp tile info for calcalation
input.pTileInfo = &tileInfoNull;
- returnCode = HwlSetupTileCfg(input.tileIndex,
input.macroModeIndex, input.pTileInfo);
+ returnCode = HwlSetupTileCfg(0, input.tileIndex,
input.macroModeIndex, input.pTileInfo);
// Change the input structure
pIn = &input;
}
if (returnCode == ADDR_OK)
{
returnCode = HwlExtractBankPipeSwizzle(pIn, pOut);
}
}
@@ -713,21 +714,21 @@ ADDR_E_RETURNCODE AddrLib1::CombineBankPipeSwizzle(
{
ADDR_TILEINFO tileInfoNull;
ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT input;
if (UseTileIndex(pIn->tileIndex))
{
input = *pIn;
// Use temp tile info for calcalation
input.pTileInfo = &tileInfoNull;
- returnCode = HwlSetupTileCfg(input.tileIndex,
input.macroModeIndex, input.pTileInfo);
+ returnCode = HwlSetupTileCfg(0, input.tileIndex,
input.macroModeIndex, input.pTileInfo);
// Change the input structure
pIn = &input;
}
if (returnCode == ADDR_OK)
{
returnCode = HwlCombineBankPipeSwizzle(pIn->bankSwizzle,
pIn->pipeSwizzle,
pIn->pTileInfo,
pIn->baseAddr,
@@ -767,21 +768,21 @@ ADDR_E_RETURNCODE AddrLib1::ComputeBaseSwizzle(
{
ADDR_TILEINFO tileInfoNull;
ADDR_COMPUTE_BASE_SWIZZLE_INPUT input;
if (UseTileIndex(pIn->tileIndex))
{
input = *pIn;
// Use temp tile info for calcalation
input.pTileInfo = &tileInfoNull;
- returnCode = HwlSetupTileCfg(input.tileIndex,
input.macroModeIndex, input.pTileInfo);
+ returnCode = HwlSetupTileCfg(0, input.tileIndex,
input.macroModeIndex, input.pTileInfo);
// Change the input structure
pIn = &input;
}
if (returnCode == ADDR_OK)
{
if (IsMacroTiled(pIn->tileMode))
{
returnCode = HwlComputeBaseSwizzle(pIn, pOut);
}
@@ -854,21 +855,21 @@ ADDR_E_RETURNCODE AddrLib1::ComputeFmaskInfo(
INT_32 macroModeIndex = HwlComputeMacroModeIndex(pIn->tileIndex,
flags,
HwlComputeFmaskBits(pIn, NULL),
pIn->numSamples,
input.pTileInfo,
&input.tileMode);
// If macroModeIndex is not needed, then call HwlSetupTileCfg to
get tile info
if (macroModeIndex == TileIndexNoMacroIndex)
{
- returnCode = HwlSetupTileCfg(input.tileIndex, macroModeIndex,
+ returnCode = HwlSetupTileCfg(0, input.tileIndex,
macroModeIndex,
input.pTileInfo, &input.tileMode);
}
ADDR_ASSERT(macroModeIndex != TileIndexInvalid);
// Change the input structure
pIn = &input;
}
if (returnCode == ADDR_OK)
@@ -1007,21 +1008,22 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileInfoToHW(
if (returnCode == ADDR_OK)
{
ADDR_TILEINFO tileInfoNull;
ADDR_CONVERT_TILEINFOTOHW_INPUT input;
// if pIn->reverse is TRUE, indices are ignored
if (pIn->reverse == FALSE && UseTileIndex(pIn->tileIndex))
{
input = *pIn;
input.pTileInfo = &tileInfoNull;
- returnCode = HwlSetupTileCfg(input.tileIndex,
input.macroModeIndex, input.pTileInfo);
+ returnCode = HwlSetupTileCfg(input.bpp, input.tileIndex,
+ input.macroModeIndex,
input.pTileInfo);
pIn = &input;
}
if (returnCode == ADDR_OK)
{
returnCode = HwlConvertTileInfoToHW(pIn, pOut);
}
}
@@ -1051,21 +1053,21 @@ ADDR_E_RETURNCODE AddrLib1::ConvertTileIndex(
if ((pIn->size != sizeof(ADDR_CONVERT_TILEINDEX_INPUT)) ||
(pOut->size != sizeof(ADDR_CONVERT_TILEINDEX_OUTPUT)))
{
returnCode = ADDR_PARAMSIZEMISMATCH;
}
}
if (returnCode == ADDR_OK)
{
- returnCode = HwlSetupTileCfg(pIn->tileIndex, pIn->macroModeIndex,
+ returnCode = HwlSetupTileCfg(pIn->bpp, pIn->tileIndex,
pIn->macroModeIndex,
pOut->pTileInfo, &pOut->tileMode,
&pOut->tileType);
if (returnCode == ADDR_OK && pIn->tileInfoHw)
{
ADDR_CONVERT_TILEINFOTOHW_INPUT hwInput = {0};
ADDR_CONVERT_TILEINFOTOHW_OUTPUT hwOutput = {0};
hwInput.pTileInfo = pOut->pTileInfo;
hwInput.tileIndex = -1;
hwOutput.pTileInfo = pOut->pTileInfo;
@@ -1219,21 +1221,21 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileInfo(
{
ADDR_TILEINFO tileInfoNull;
ADDR_COMPUTE_HTILE_INFO_INPUT input;
if (UseTileIndex(pIn->tileIndex))
{
input = *pIn;
// Use temp tile info for calcalation
input.pTileInfo = &tileInfoNull;
- returnCode = HwlSetupTileCfg(input.tileIndex,
input.macroModeIndex, input.pTileInfo);
+ returnCode = HwlSetupTileCfg(0, input.tileIndex,
input.macroModeIndex, input.pTileInfo);
// Change the input structure
pIn = &input;
}
if (returnCode == ADDR_OK)
{
pOut->bpp = ComputeHtileInfo(pIn->flags,
pIn->pitch,
pIn->height,
@@ -1286,21 +1288,21 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskInfo(
{
ADDR_TILEINFO tileInfoNull;
ADDR_COMPUTE_CMASK_INFO_INPUT input;
if (UseTileIndex(pIn->tileIndex))
{
input = *pIn;
// Use temp tile info for calcalation
input.pTileInfo = &tileInfoNull;
- returnCode = HwlSetupTileCfg(input.tileIndex,
input.macroModeIndex, input.pTileInfo);
+ returnCode = HwlSetupTileCfg(0, input.tileIndex,
input.macroModeIndex, input.pTileInfo);
// Change the input structure
pIn = &input;
}
if (returnCode == ADDR_OK)
{
returnCode = ComputeCmaskInfo(pIn->flags,
pIn->pitch,
pIn->height,
@@ -1349,21 +1351,21 @@ ADDR_E_RETURNCODE AddrLib1::ComputeDccInfo(
}
if (ret == ADDR_OK)
{
ADDR_COMPUTE_DCCINFO_INPUT input;
if (UseTileIndex(pIn->tileIndex))
{
input = *pIn;
- ret = HwlSetupTileCfg(input.tileIndex, input.macroModeIndex,
+ ret = HwlSetupTileCfg(input.bpp, input.tileIndex,
input.macroModeIndex,
&input.tileInfo, &input.tileMode);
pIn = &input;
}
if (ADDR_OK == ret)
{
ret = HwlComputeDccInfo(pIn, pOut);
}
}
@@ -1405,21 +1407,21 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileAddrFromCoord(
{
ADDR_TILEINFO tileInfoNull;
ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT input;
if (UseTileIndex(pIn->tileIndex))
{
input = *pIn;
// Use temp tile info for calcalation
input.pTileInfo = &tileInfoNull;
- returnCode = HwlSetupTileCfg(input.tileIndex,
input.macroModeIndex, input.pTileInfo);
+ returnCode = HwlSetupTileCfg(0, input.tileIndex,
input.macroModeIndex, input.pTileInfo);
// Change the input structure
pIn = &input;
}
if (returnCode == ADDR_OK)
{
pOut->addr = HwlComputeXmaskAddrFromCoord(pIn->pitch,
pIn->height,
pIn->x,
@@ -1473,21 +1475,21 @@ ADDR_E_RETURNCODE AddrLib1::ComputeHtileCoordFromAddr(
{
ADDR_TILEINFO tileInfoNull;
ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT input;
if (UseTileIndex(pIn->tileIndex))
{
input = *pIn;
// Use temp tile info for calcalation
input.pTileInfo = &tileInfoNull;
- returnCode = HwlSetupTileCfg(input.tileIndex,
input.macroModeIndex, input.pTileInfo);
+ returnCode = HwlSetupTileCfg(0, input.tileIndex,
input.macroModeIndex, input.pTileInfo);
// Change the input structure
pIn = &input;
}
if (returnCode == ADDR_OK)
{
HwlComputeXmaskCoordFromAddr(pIn->addr,
pIn->bitPosition,
pIn->pitch,
@@ -1538,21 +1540,21 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskAddrFromCoord(
{
ADDR_TILEINFO tileInfoNull;
ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT input;
if (UseTileIndex(pIn->tileIndex))
{
input = *pIn;
// Use temp tile info for calcalation
input.pTileInfo = &tileInfoNull;
- returnCode = HwlSetupTileCfg(input.tileIndex,
input.macroModeIndex, input.pTileInfo);
+ returnCode = HwlSetupTileCfg(0, input.tileIndex,
input.macroModeIndex, input.pTileInfo);
// Change the input structure
pIn = &input;
}
if (returnCode == ADDR_OK)
{
if (pIn->flags.tcCompatible == TRUE)
{
returnCode = HwlComputeCmaskAddrFromCoord(pIn, pOut);
@@ -1610,21 +1612,21 @@ ADDR_E_RETURNCODE AddrLib1::ComputeCmaskCoordFromAddr(
{
ADDR_TILEINFO tileInfoNull;
ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT input;
if (UseTileIndex(pIn->tileIndex))
{
input = *pIn;
// Use temp tile info for calcalation
input.pTileInfo = &tileInfoNull;
- returnCode = HwlSetupTileCfg(input.tileIndex,
input.macroModeIndex, input.pTileInfo);
+ returnCode = HwlSetupTileCfg(0, input.tileIndex,
input.macroModeIndex, input.pTileInfo);
// Change the input structure
pIn = &input;
}
if (returnCode == ADDR_OK)
{
HwlComputeXmaskCoordFromAddr(pIn->addr,
pIn->bitPosition,
pIn->pitch,
@@ -3415,20 +3417,21 @@ 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
INT_32 index, ///< [in] Tile index
INT_32 macroModeIndex, ///< [in] Index in macro tile mode
table(CI)
ADDR_TILEINFO* pInfo, ///< [out] Tile Info
AddrTileMode* pMode, ///< [out] Tile mode
AddrTileType* pType ///< [out] Tile type
) const
{
return ADDR_NOTSUPPORTED;
}
diff --git a/src/amd/addrlib/core/addrlib1.h b/src/amd/addrlib/core/addrlib1.h
index 9e21684..1bdfd5b 100644
--- a/src/amd/addrlib/core/addrlib1.h
+++ b/src/amd/addrlib/core/addrlib1.h
@@ -429,21 +429,21 @@ protected:
{
return !m_configFlags.ignoreTileInfo;
}
/// Adjusts pitch alignment for flipping surface
VOID AdjustPitchAlignment(
ADDR_SURFACE_FLAGS flags, UINT_32* pPitchAlign) const;
/// Overwrite tile config according to tile index
virtual ADDR_E_RETURNCODE HwlSetupTileCfg(
- INT_32 index, INT_32 macroModeIndex,
+ UINT_32 bpp, INT_32 index, INT_32 macroModeIndex,
ADDR_TILEINFO* pInfo, AddrTileMode* mode = NULL, AddrTileType* type =
NULL) const;
/// Overwrite macro tile config according to tile index
virtual INT_32 HwlComputeMacroModeIndex(
INT_32 index, ADDR_SURFACE_FLAGS flags, UINT_32 bpp, UINT_32
numSamples,
ADDR_TILEINFO* pTileInfo, AddrTileMode *pTileMode = NULL, AddrTileType
*pTileType = NULL
) const
{
return TileIndexNoMacroIndex;
}
diff --git a/src/amd/addrlib/r800/ciaddrlib.cpp
b/src/amd/addrlib/r800/ciaddrlib.cpp
index 64fa669..f72f5a2 100644
--- a/src/amd/addrlib/r800/ciaddrlib.cpp
+++ b/src/amd/addrlib/r800/ciaddrlib.cpp
@@ -535,20 +535,21 @@ 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
INT_32 index, ///< [in] Tile index
INT_32 macroModeIndex, ///< [in] Index in macro tile mode
table(CI)
ADDR_TILEINFO* pInfo, ///< [out] Tile Info
AddrTileMode* pMode, ///< [out] Tile mode
AddrTileType* pType ///< [out] Tile type
) const
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
// Global flag to control usage of tileIndex
@@ -559,37 +560,51 @@ ADDR_E_RETURNCODE CiAddrLib::HwlSetupTileCfg(
returnCode = ADDR_INVALIDPARAMS;
}
else
{
const ADDR_TILECONFIG* pCfgTable = GetTileSetting(index);
if (pInfo != NULL)
{
if (IsMacroTiled(pCfgTable->mode))
{
- ADDR_ASSERT(((macroModeIndex != TileIndexInvalid)
- && (macroModeIndex != TileIndexNoMacroIndex)));
- // Here we used tile_bytes to replace of tile_split
- // According info as below:
- // "tile_split_c = MIN(ROW_SIZE, tile_split)
- // "tile_bytes = MIN(tile_split_c, num_samples *
tile_bytes_1x)
- // when using tile_bytes replacing of tile_split, the
result of
- // alignment and others(such as slicesPerTile) are
unaffected -
- // since if tile_split_c is larger, split won't happen,
otherwise
- // (num_samples * tile_bytes_1x is larger), a correct
tile_split is
- // returned.
+ ADDR_ASSERT((macroModeIndex != TileIndexInvalid) &&
+ (macroModeIndex != TileIndexNoMacroIndex));
+
+ UINT_32 tileSplit;
+
*pInfo = m_macroTileTable[macroModeIndex];
if (pCfgTable->type == ADDR_DEPTH_SAMPLE_ORDER)
{
- pInfo->tileSplitBytes = pCfgTable->info.tileSplitBytes;
+ tileSplit = pCfgTable->info.tileSplitBytes;
}
+ else
+ {
+ if (bpp > 0)
+ {
+ UINT_32 thickness =
ComputeSurfaceThickness(pCfgTable->mode);
+ UINT_32 tileBytes1x = BITS_TO_BYTES(bpp *
MicroTilePixels * thickness);
+ // Non-depth entries store a split factor
+ UINT_32 sampleSplit =
m_tileTable[index].info.tileSplitBytes;
+ tileSplit = Max(256u, sampleSplit * tileBytes1x);
+ }
+ else
+ {
+ // Return tileBytes instead if not enough info
+ tileSplit = pInfo->tileSplitBytes;
+ }
+ }
+
+ // Clamp to row_size
+ pInfo->tileSplitBytes = Min(m_rowSize, tileSplit);
+
pInfo->pipeConfig = pCfgTable->info.pipeConfig;
}
else // 1D and linear modes, we return default value stored in
table
{
*pInfo = pCfgTable->info;
}
}
if (pMode != NULL)
{
diff --git a/src/amd/addrlib/r800/ciaddrlib.h b/src/amd/addrlib/r800/ciaddrlib.h
index 92997a5..1e3dc56 100644
--- a/src/amd/addrlib/r800/ciaddrlib.h
+++ b/src/amd/addrlib/r800/ciaddrlib.h
@@ -98,21 +98,21 @@ protected:
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn,
ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut);
virtual AddrChipFamily HwlConvertChipFamily(
UINT_32 uChipFamily, UINT_32 uChipRevision);
virtual BOOL_32 HwlInitGlobalParams(
const ADDR_CREATE_INPUT* pCreateIn);
virtual ADDR_E_RETURNCODE HwlSetupTileCfg(
- INT_32 index, INT_32 macroModeIndex, ADDR_TILEINFO* pInfo,
+ UINT_32 bpp, INT_32 index, INT_32 macroModeIndex, ADDR_TILEINFO* pInfo,
AddrTileMode* pMode = 0, AddrTileType* pType = 0) const;
virtual VOID HwlComputeTileDataWidthAndHeightLinear(
UINT_32* pMacroWidth, UINT_32* pMacroHeight,
UINT_32 bpp, ADDR_TILEINFO* pTileInfo) const;
virtual INT_32 HwlComputeMacroModeIndex(
INT_32 tileIndex, ADDR_SURFACE_FLAGS flags, UINT_32 bpp, UINT_32
numSamples,
ADDR_TILEINFO* pTileInfo, AddrTileMode* pTileMode = NULL,
AddrTileType* pTileType = NULL
) const;
diff --git a/src/amd/addrlib/r800/siaddrlib.cpp
b/src/amd/addrlib/r800/siaddrlib.cpp
index 869cc56..296391a 100644
--- a/src/amd/addrlib/r800/siaddrlib.cpp
+++ b/src/amd/addrlib/r800/siaddrlib.cpp
@@ -2436,20 +2436,21 @@ 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
INT_32 index, ///< [in] Tile index
INT_32 macroModeIndex, ///< [in] Index in macro tile mode
table(CI)
ADDR_TILEINFO* pInfo, ///< [out] Tile Info
AddrTileMode* pMode, ///< [out] Tile mode
AddrTileType* pType ///< [out] Tile type
) const
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
// Global flag to control usage of tileIndex
diff --git a/src/amd/addrlib/r800/siaddrlib.h b/src/amd/addrlib/r800/siaddrlib.h
index 50373cc..9201fb2 100644
--- a/src/amd/addrlib/r800/siaddrlib.h
+++ b/src/amd/addrlib/r800/siaddrlib.h
@@ -113,21 +113,21 @@ protected:
virtual BOOL_32 HwlComputeMipLevel(
ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn) const;
virtual AddrChipFamily HwlConvertChipFamily(
UINT_32 uChipFamily, UINT_32 uChipRevision);
virtual BOOL_32 HwlInitGlobalParams(
const ADDR_CREATE_INPUT* pCreateIn);
virtual ADDR_E_RETURNCODE HwlSetupTileCfg(
- INT_32 index, INT_32 macroModeIndex,
+ UINT_32 bpp, INT_32 index, INT_32 macroModeIndex,
ADDR_TILEINFO* pInfo, AddrTileMode* pMode = 0, AddrTileType* pType =
0) const;
virtual VOID HwlComputeTileDataWidthAndHeightLinear(
UINT_32* pMacroWidth, UINT_32* pMacroHeight,
UINT_32 bpp, ADDR_TILEINFO* pTileInfo) const;
virtual UINT_64 HwlComputeHtileBytes(
UINT_32 pitch, UINT_32 height, UINT_32 bpp,
BOOL_32 isLinear, UINT_32 numSlices, UINT_64* pSliceBytes, UINT_32
baseAlign) const;
--
2.7.4
_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/mesa-dev
