path: root/src/amd/addrlib/r800/egbaddrlib.h

/*
 * Copyright © 2014 Advanced Micro Devices, Inc.
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
 * AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 */

/**
***************************************************************************************************
* @file  egbaddrlib.h
* @brief Contains the EgBasedAddrLib class definition.
***************************************************************************************************
*/

#ifndef __EG_BASED_ADDR_LIB_H__
#define __EG_BASED_ADDR_LIB_H__

#include "addrlib1.h"


/// Structures for functions
struct CoordFromBankPipe
{
    UINT_32 xBits : 3;
    UINT_32 yBits : 4;

    UINT_32 xBit3 : 1;
    UINT_32 xBit4 : 1;
    UINT_32 xBit5 : 1;
    UINT_32 yBit3 : 1;
    UINT_32 yBit4 : 1;
    UINT_32 yBit5 : 1;
    UINT_32 yBit6 : 1;
};

/**
***************************************************************************************************
* @brief This class is the Evergreen based address library
* @note  Abstract class
***************************************************************************************************
*/
class EgBasedAddrLib : public AddrLib1
{
protected:
    EgBasedAddrLib(const AddrClient* pClient);
    virtual ~EgBasedAddrLib();

public:

    /// Surface info functions

    // NOTE: DispatchComputeSurfaceInfo using TileInfo takes both an input and an output.
    //       On input:
    //       One or more fields may be 0 to be calculated/defaulted - pre-SI h/w.
    //       H/W using tile mode index only accepts none or all 0's - SI and newer h/w.
    //       It then returns the actual tiling configuration used.
    //       Other methods' TileInfo must be valid on entry
    BOOL_32 DispatchComputeSurfaceInfo(
        const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn,
        ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const;

    ADDR_E_RETURNCODE DispatchComputeFmaskInfo(
        const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn,
        ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut);

protected:
    // Hwl interface
    virtual ADDR_E_RETURNCODE HwlComputeSurfaceInfo(
        const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn,
        ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const;

    virtual ADDR_E_RETURNCODE HwlComputeSurfaceAddrFromCoord(
        const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,
        ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const;

    virtual ADDR_E_RETURNCODE HwlComputeSurfaceCoordFromAddr(
        const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,
        ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) const;

    virtual ADDR_E_RETURNCODE HwlComputeSliceTileSwizzle(
        const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn,
        ADDR_COMPUTE_SLICESWIZZLE_OUTPUT* pOut) const;

    virtual ADDR_E_RETURNCODE HwlExtractBankPipeSwizzle(
        const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn,
        ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT* pOut) const;

    virtual ADDR_E_RETURNCODE HwlCombineBankPipeSwizzle(
        UINT_32 bankSwizzle, UINT_32 pipeSwizzle, ADDR_TILEINFO*  pTileInfo,
        UINT_64 baseAddr, UINT_32* pTileSwizzle) const;

    virtual ADDR_E_RETURNCODE HwlComputeBaseSwizzle(
        const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn,
        ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT* pOut) const;

    virtual ADDR_E_RETURNCODE HwlConvertTileInfoToHW(
        const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn,
        ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut) const;

    virtual UINT_32 HwlComputeHtileBpp(
        BOOL_32 isWidth8, BOOL_32 isHeight8) const;

    virtual UINT_32 HwlComputeHtileBaseAlign(
        BOOL_32 isTcCompatible, BOOL_32 isLinear, ADDR_TILEINFO* pTileInfo) const;

    virtual ADDR_E_RETURNCODE HwlComputeFmaskInfo(
        const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn,
        ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut);

    virtual ADDR_E_RETURNCODE HwlComputeFmaskAddrFromCoord(
        const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn,
        ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut) const;

    virtual ADDR_E_RETURNCODE HwlComputeFmaskCoordFromAddr(
        const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn,
        ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut) const;

    virtual BOOL_32 HwlDegradeBaseLevel(
        const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn) const;

    virtual UINT_32 HwlComputeQbStereoRightSwizzle(
        ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pInfo) const;

    virtual VOID HwlComputePixelCoordFromOffset(
        UINT_32 offset, UINT_32 bpp, UINT_32 numSamples,
        AddrTileMode tileMode, UINT_32 tileBase, UINT_32 compBits,
        UINT_32* pX, UINT_32* pY, UINT_32* pSlice, UINT_32* pSample,
        AddrTileType microTileType, BOOL_32 isDepthSampleOrder) const;

    /// Return Cmask block max
    virtual BOOL_32 HwlGetMaxCmaskBlockMax() const
    {
        return 0x3FFF; // 14 bits, 0n16383
    }

    // Sub-hwl interface
    /// Pure virtual function to setup tile info (indices) if client requests to do so
    virtual VOID HwlSetupTileInfo(
        AddrTileMode tileMode, ADDR_SURFACE_FLAGS flags,
        UINT_32 bpp, UINT_32 pitch, UINT_32 height, UINT_32 numSamples,
        ADDR_TILEINFO* inputTileInfo, ADDR_TILEINFO* outputTileInfo,
        AddrTileType inTileType, ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const = 0;

    /// Pure virtual function to get pitch alignment for linear modes
    virtual UINT_32 HwlGetPitchAlignmentLinear(UINT_32 bpp, ADDR_SURFACE_FLAGS flags) const = 0;

    /// Pure virtual function to get size adjustment for linear modes
    virtual UINT_64 HwlGetSizeAdjustmentLinear(
        AddrTileMode tileMode,
        UINT_32 bpp, UINT_32 numSamples, UINT_32 baseAlign, UINT_32 pitchAlign,
        UINT_32 *pPitch, UINT_32 *pHeight, UINT_32 *pHeightAlign) const = 0;

    virtual UINT_32 HwlGetPitchAlignmentMicroTiled(
        AddrTileMode tileMode, UINT_32 bpp, ADDR_SURFACE_FLAGS flags, UINT_32 numSamples) const;

    virtual UINT_64 HwlGetSizeAdjustmentMicroTiled(
        UINT_32 thickness, UINT_32 bpp, ADDR_SURFACE_FLAGS flags, UINT_32 numSamples,
        UINT_32 baseAlign, UINT_32 pitchAlign,
        UINT_32 *pPitch, UINT_32 *pHeight) const;

        /// Pure virtual function to do extra sanity check
    virtual BOOL_32 HwlSanityCheckMacroTiled(
        ADDR_TILEINFO* pTileInfo) const = 0;

    /// Pure virtual function to check current level to be the last macro tiled one
    virtual VOID HwlCheckLastMacroTiledLvl(
        const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn,
        ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) const = 0;

    /// Adjusts bank before bank is modified by rotation
    virtual UINT_32 HwlPreAdjustBank(
        UINT_32 tileX, UINT_32 bank, ADDR_TILEINFO*  pTileInfo) const = 0;

    virtual VOID HwlComputeSurfaceCoord2DFromBankPipe(
        AddrTileMode tileMode, UINT_32* pX, UINT_32* pY, UINT_32 slice,
        UINT_32 bank, UINT_32 pipe,
        UINT_32 bankSwizzle, UINT_32 pipeSwizzle, UINT_32 tileSlices,
        BOOL_32 ignoreSE,
        ADDR_TILEINFO* pTileInfo) const = 0;

    virtual BOOL_32 HwlTileInfoEqual(
        const ADDR_TILEINFO* pLeft, const ADDR_TILEINFO* pRight) const;

    virtual AddrTileMode HwlDegradeThickTileMode(
        AddrTileMode baseTileMode, UINT_32 numSlices, UINT_32* pBytesPerTile) const;

    virtual INT_32 HwlPostCheckTileIndex(
        const ADDR_TILEINFO* pInfo, AddrTileMode mode, AddrTileType type,
        INT curIndex = TileIndexInvalid) const
    {
        return TileIndexInvalid;
    }

    virtual VOID HwlFmaskPreThunkSurfInfo(
        const ADDR_COMPUTE_FMASK_INFO_INPUT* pFmaskIn,
        const ADDR_COMPUTE_FMASK_INFO_OUTPUT* pFmaskOut,
        ADDR_COMPUTE_SURFACE_INFO_INPUT* pSurfIn,
        ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pSurfOut) const
    {
    }

    virtual VOID HwlFmaskPostThunkSurfInfo(
        const ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pSurfOut,
        ADDR_COMPUTE_FMASK_INFO_OUTPUT* pFmaskOut) const
    {
    }

    virtual UINT_32 HwlStereoCheckRightOffsetPadding(ADDR_TILEINFO* pTileInfo) const;

    virtual BOOL_32 HwlReduceBankWidthHeight(
        UINT_32 tileSize, UINT_32 bpp, ADDR_SURFACE_FLAGS flags, UINT_32 numSamples,
        UINT_32 bankHeightAlign, UINT_32 pipes,
        ADDR_TILEINFO* pTileInfo) const;

    // Protected non-virtual functions

    /// Mip level functions
    AddrTileMode ComputeSurfaceMipLevelTileMode(
        AddrTileMode baseTileMode, UINT_32 bpp,
        UINT_32 pitch, UINT_32 height, UINT_32 numSlices, UINT_32 numSamples,
        UINT_32 pitchAlign, UINT_32 heightAlign,
        ADDR_TILEINFO* pTileInfo) const;

    /// Swizzle functions
    VOID ExtractBankPipeSwizzle(
        UINT_32 base256b, ADDR_TILEINFO* pTileInfo,
        UINT_32* pBankSwizzle, UINT_32* pPipeSwizzle) const;

    UINT_32 GetBankPipeSwizzle(
        UINT_32 bankSwizzle, UINT_32 pipeSwizzle,
        UINT_64 baseAddr, ADDR_TILEINFO*  pTileInfo) const;

    UINT_32 ComputeSliceTileSwizzle(
        AddrTileMode tileMode, UINT_32 baseSwizzle, UINT_32 slice, UINT_64 baseAddr,
        ADDR_TILEINFO* pTileInfo) const;

    /// Addressing functions
    virtual ADDR_E_RETURNCODE ComputeBankEquation(
        UINT_32 log2BytesPP, UINT_32 threshX, UINT_32 threshY,
        ADDR_TILEINFO* pTileInfo, ADDR_EQUATION* pEquation) const
    {
        return ADDR_NOTSUPPORTED;
    }

    UINT_32 ComputeBankFromCoord(
        UINT_32 x, UINT_32 y, UINT_32 slice,
        AddrTileMode tileMode, UINT_32 bankSwizzle, UINT_32 tileSpitSlice,
        ADDR_TILEINFO* pTileInfo) const;

    UINT_32 ComputeBankFromAddr(
        UINT_64 addr, UINT_32 numBanks, UINT_32 numPipes) const;

    UINT_32 ComputePipeRotation(
        AddrTileMode tileMode, UINT_32 numPipes) const;

    UINT_32 ComputeBankRotation(
        AddrTileMode tileMode, UINT_32 numBanks,
        UINT_32 numPipes) const;

    VOID ComputeSurfaceCoord2DFromBankPipe(
        AddrTileMode tileMode, UINT_32 x, UINT_32 y, UINT_32 slice,
        UINT_32 bank, UINT_32 pipe,
        UINT_32 bankSwizzle, UINT_32 pipeSwizzle, UINT_32 tileSlices,
        ADDR_TILEINFO* pTileInfo,
        CoordFromBankPipe *pOutput) const;

    /// Htile/Cmask functions
    UINT_64 ComputeHtileBytes(
        UINT_32 pitch, UINT_32 height, UINT_32 bpp,
        BOOL_32 isLinear, UINT_32 numSlices, UINT_64* sliceBytes, UINT_32 baseAlign) const;

    ADDR_E_RETURNCODE ComputeMacroTileEquation(
        UINT_32 log2BytesPP, AddrTileMode tileMode, AddrTileType microTileType,
        ADDR_TILEINFO* pTileInfo, ADDR_EQUATION* pEquation) const;

    // Static functions
    static BOOL_32 IsTileInfoAllZero(ADDR_TILEINFO* pTileInfo);
    static UINT_32 ComputeFmaskNumPlanesFromNumSamples(UINT_32 numSamples);
    static UINT_32 ComputeFmaskResolvedBppFromNumSamples(UINT_32 numSamples);

private:

    BOOL_32 ComputeSurfaceInfoLinear(
        const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn,
        ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut,
        UINT_32 padDims) const;

    BOOL_32 ComputeSurfaceInfoMicroTiled(
        const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn,
        ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut,
        UINT_32 padDims,
        AddrTileMode expTileMode) const;

    BOOL_32 ComputeSurfaceInfoMacroTiled(
        const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn,
        ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut,
        UINT_32 padDims,
        AddrTileMode expTileMode) const;

    BOOL_32 ComputeSurfaceAlignmentsLinear(
        AddrTileMode tileMode, UINT_32 bpp, ADDR_SURFACE_FLAGS flags,
        UINT_32* pBaseAlign, UINT_32* pPitchAlign, UINT_32* pHeightAlign) const;

    BOOL_32 ComputeSurfaceAlignmentsMicroTiled(
        AddrTileMode tileMode, UINT_32 bpp, ADDR_SURFACE_FLAGS flags,
        UINT_32 mipLevel, UINT_32 numSamples,
        UINT_32* pBaseAlign, UINT_32* pPitchAlign, UINT_32* pHeightAlign) const;

    BOOL_32 ComputeSurfaceAlignmentsMacroTiled(
        AddrTileMode tileMode, UINT_32 bpp, ADDR_SURFACE_FLAGS flags,
        UINT_32 mipLevel, UINT_32 numSamples,
        ADDR_TILEINFO* pTileInfo,
        UINT_32* pBaseAlign, UINT_32* pPitchAlign, UINT_32* pHeightAlign,
        UINT_32* pMacroTileWidth, UINT_32* pMacroTileHeight) const;

    /// Surface addressing functions
    UINT_64 DispatchComputeSurfaceAddrFromCoord(
        const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,
        ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) const;

    VOID DispatchComputeSurfaceCoordFromAddr(
        const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,
        ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) const;

    UINT_64 ComputeSurfaceAddrFromCoordMicroTiled(
        UINT_32 x, UINT_32 y, UINT_32 slice, UINT_32 sample,
        UINT_32 bpp, UINT_32 pitch, UINT_32 height, UINT_32 numSamples,
        AddrTileMode tileMode,
        AddrTileType microTileType, BOOL_32 isDepthSampleOrder,
        UINT_32* pBitPosition) const;

    UINT_64 ComputeSurfaceAddrFromCoordMacroTiled(
        UINT_32 x, UINT_32 y, UINT_32 slice, UINT_32 sample,
        UINT_32 bpp, UINT_32 pitch, UINT_32 height, UINT_32 numSamples,
        AddrTileMode tileMode,
        AddrTileType microTileType, BOOL_32 ignoreSE, BOOL_32 isDepthSampleOrder,
        UINT_32 pipeSwizzle, UINT_32 bankSwizzle,
        ADDR_TILEINFO* pTileInfo,
        UINT_32* pBitPosition) const;

    VOID ComputeSurfaceCoordFromAddrMacroTiled(
        UINT_64 addr, UINT_32 bitPosition,
        UINT_32 bpp, UINT_32 pitch, UINT_32 height, UINT_32 numSamples,
        AddrTileMode tileMode, UINT_32 tileBase, UINT_32 compBits,
        AddrTileType microTileType, BOOL_32 ignoreSE, BOOL_32 isDepthSampleOrder,
        UINT_32 pipeSwizzle, UINT_32 bankSwizzle,
        ADDR_TILEINFO* pTileInfo,
        UINT_32* pX, UINT_32* pY, UINT_32* pSlice, UINT_32* pSample) const;

    /// Fmask functions
    UINT_64 DispatchComputeFmaskAddrFromCoord(
        const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn,
        ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut) const;

    VOID DispatchComputeFmaskCoordFromAddr(
        const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn,
        ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut) const;

    // FMASK related methods - private
    UINT_64 ComputeFmaskAddrFromCoordMicroTiled(
        UINT_32 x, UINT_32 y, UINT_32 slice, UINT_32 sample, UINT_32 plane,
        UINT_32 pitch, UINT_32 height, UINT_32 numSamples, AddrTileMode tileMode,
        BOOL_32 resolved, UINT_32* pBitPosition) const;

    VOID ComputeFmaskCoordFromAddrMicroTiled(
        UINT_64 addr, UINT_32 bitPosition,
        UINT_32 pitch, UINT_32 height, UINT_32 numSamples,
        AddrTileMode tileMode, BOOL_32 resolved,
        UINT_32* pX, UINT_32* pY, UINT_32* pSlice, UINT_32* pSample, UINT_32* pPlane) const;

    VOID ComputeFmaskCoordFromAddrMacroTiled(
        UINT_64 addr, UINT_32 bitPosition,
        UINT_32 pitch, UINT_32 height, UINT_32 numSamples, AddrTileMode tileMode,
        UINT_32 pipeSwizzle, UINT_32 bankSwizzle,
        BOOL_32 ignoreSE,
        ADDR_TILEINFO* pTileInfo,
        BOOL_32 resolved,
        UINT_32* pX, UINT_32* pY, UINT_32* pSlice, UINT_32* pSample, UINT_32* pPlane) const;

    UINT_64 ComputeFmaskAddrFromCoordMacroTiled(
        UINT_32 x, UINT_32 y, UINT_32 slice, UINT_32 sample, UINT_32 plane,
        UINT_32 pitch, UINT_32 height, UINT_32 numSamples,
        AddrTileMode tileMode, UINT_32 pipeSwizzle, UINT_32 bankSwizzle,
        BOOL_32 ignoreSE,
        ADDR_TILEINFO* pTileInfo,
        BOOL_32 resolved,
        UINT_32* pBitPosition) const;

    /// Sanity check functions
    BOOL_32 SanityCheckMacroTiled(
        ADDR_TILEINFO* pTileInfo) const;

protected:
    UINT_32 m_ranks;                ///< Number of ranks - MC_ARB_RAMCFG.NOOFRANK
    UINT_32 m_logicalBanks;         ///< Logical banks = m_banks * m_ranks if m_banks != 16
    UINT_32 m_bankInterleave;       ///< Bank interleave, as a multiple of pipe interleave size
};

#endif