src/amd/addrlib/addrinterface.h

   1 /*
   2  * Copyright © 2014 Advanced Micro Devices, Inc.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sub license, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  14  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  15  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  16  * NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
  17  * AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  20  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * The above copyright notice and this permission notice (including the
  23  * next paragraph) shall be included in all copies or substantial portions
  24  * of the Software.
  25  */
  26
  27 /**
  28 ****************************************************************************************************
  29 * @file  addrinterface.h
  30 * @brief Contains the addrlib interfaces declaration and parameter defines
  31 ****************************************************************************************************
  32 */
  33 #ifndef __ADDR_INTERFACE_H__
  34 #define __ADDR_INTERFACE_H__
  35
  36 #include "addrtypes.h"
  37
  38 #if defined(__cplusplus)
  39 extern "C"
  40 {
  41 #endif
  42
  43 #define ADDRLIB_VERSION_MAJOR 5
  44 #define ADDRLIB_VERSION_MINOR 25
  45 #define ADDRLIB_VERSION ((ADDRLIB_VERSION_MAJOR << 16) | ADDRLIB_VERSION_MINOR)
  46
  47 /// Virtually all interface functions need ADDR_HANDLE as first parameter
  48 typedef VOID*   ADDR_HANDLE;
  49
  50 /// Client handle used in callbacks
  51 typedef VOID*   ADDR_CLIENT_HANDLE;
  52
  53 /**
  54 * /////////////////////////////////////////////////////////////////////////////////////////////////
  55 * //                                  Callback functions
  56 * /////////////////////////////////////////////////////////////////////////////////////////////////
  57 *    typedef VOID* (ADDR_API* ADDR_ALLOCSYSMEM)(
  58 *         const ADDR_ALLOCSYSMEM_INPUT* pInput);
  59 *    typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_FREESYSMEM)(
  60 *         VOID* pVirtAddr);
  61 *    typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_DEBUGPRINT)(
  62 *         const ADDR_DEBUGPRINT_INPUT* pInput);
  63 *
  64 * /////////////////////////////////////////////////////////////////////////////////////////////////
  65 * //                               Create/Destroy/Config functions
  66 * /////////////////////////////////////////////////////////////////////////////////////////////////
  67 *     AddrCreate()
  68 *     AddrDestroy()
  69 *
  70 * /////////////////////////////////////////////////////////////////////////////////////////////////
  71 * //                                  Surface functions
  72 * /////////////////////////////////////////////////////////////////////////////////////////////////
  73 *     AddrComputeSurfaceInfo()
  74 *     AddrComputeSurfaceAddrFromCoord()
  75 *     AddrComputeSurfaceCoordFromAddr()
  76 *
  77 * /////////////////////////////////////////////////////////////////////////////////////////////////
  78 * //                                   HTile functions
  79 * /////////////////////////////////////////////////////////////////////////////////////////////////
  80 *     AddrComputeHtileInfo()
  81 *     AddrComputeHtileAddrFromCoord()
  82 *     AddrComputeHtileCoordFromAddr()
  83 *
  84 * /////////////////////////////////////////////////////////////////////////////////////////////////
  85 * //                                   C-mask functions
  86 * /////////////////////////////////////////////////////////////////////////////////////////////////
  87 *     AddrComputeCmaskInfo()
  88 *     AddrComputeCmaskAddrFromCoord()
  89 *     AddrComputeCmaskCoordFromAddr()
  90 *
  91 * /////////////////////////////////////////////////////////////////////////////////////////////////
  92 * //                                   F-mask functions
  93 * /////////////////////////////////////////////////////////////////////////////////////////////////
  94 *     AddrComputeFmaskInfo()
  95 *     AddrComputeFmaskAddrFromCoord()
  96 *     AddrComputeFmaskCoordFromAddr()
  97 *
  98 * /////////////////////////////////////////////////////////////////////////////////////////////////
  99 * //                               Element/Utility functions
 100 * /////////////////////////////////////////////////////////////////////////////////////////////////
 101 *     ElemFlt32ToDepthPixel()
 102 *     ElemFlt32ToColorPixel()
 103 *     AddrExtractBankPipeSwizzle()
 104 *     AddrCombineBankPipeSwizzle()
 105 *     AddrComputeSliceSwizzle()
 106 *     AddrConvertTileInfoToHW()
 107 *     AddrConvertTileIndex()
 108 *     AddrConvertTileIndex1()
 109 *     AddrGetTileIndex()
 110 *     AddrComputeBaseSwizzle()
 111 *     AddrUseTileIndex()
 112 *     AddrUseCombinedSwizzle()
 113 *
 114 **/
 115
 116 ////////////////////////////////////////////////////////////////////////////////////////////////////
 117 //                                      Callback functions
 118 ////////////////////////////////////////////////////////////////////////////////////////////////////
 119
 120 /**
 121 ****************************************************************************************************
 122 * @brief channel setting structure
 123 ****************************************************************************************************
 124 */
 125 typedef union _ADDR_CHANNEL_SETTING
 126 {
 127     struct
 128     {
 129         UINT_8 valid   : 1;    ///< Indicate whehter this channel setting is valid
 130         UINT_8 channel : 2;    ///< 0 for x channel, 1 for y channel, 2 for z channel
 131         UINT_8 index   : 5;    ///< Channel index
 132     };
 133     UINT_8 value;              ///< Value
 134 } ADDR_CHANNEL_SETTING;
 135
 136 /**
 137 ****************************************************************************************************
 138 * @brief address equation key structure
 139 ****************************************************************************************************
 140 */
 141 typedef union _ADDR_EQUATION_KEY
 142 {
 143     struct
 144     {
 145         UINT_32 log2ElementBytes : 3; ///< Log2 of Bytes per pixel
 146         UINT_32 tileMode         : 5; ///< Tile mode
 147         UINT_32 microTileType    : 3; ///< Micro tile type
 148         UINT_32 pipeConfig       : 5; ///< pipe config
 149         UINT_32 numBanksLog2     : 3; ///< Number of banks log2
 150         UINT_32 bankWidth        : 4; ///< Bank width
 151         UINT_32 bankHeight       : 4; ///< Bank height
 152         UINT_32 macroAspectRatio : 3; ///< Macro tile aspect ratio
 153         UINT_32 prt              : 1; ///< SI only, indicate whether this equation is for prt
 154         UINT_32 reserved         : 1; ///< Reserved bit
 155     } fields;
 156     UINT_32 value;
 157 } ADDR_EQUATION_KEY;
 158
 159 /**
 160 ****************************************************************************************************
 161 * @brief address equation structure
 162 ****************************************************************************************************
 163 */
 164 #define ADDR_MAX_EQUATION_BIT 20u
 165
 166 // Invalid equation index
 167 #define ADDR_INVALID_EQUATION_INDEX 0xFFFFFFFF
 168
 169 typedef struct _ADDR_EQUATION
 170 {
 171     ADDR_CHANNEL_SETTING addr[ADDR_MAX_EQUATION_BIT];  ///< addr setting
 172                                                        ///< each bit is result of addr ^ xor ^ xor2
 173     ADDR_CHANNEL_SETTING xor1[ADDR_MAX_EQUATION_BIT];  ///< xor setting
 174     ADDR_CHANNEL_SETTING xor2[ADDR_MAX_EQUATION_BIT];  ///< xor2 setting
 175     UINT_32              numBits;                      ///< The number of bits in equation
 176     BOOL_32              stackedDepthSlices;           ///< TRUE if depth slices are treated as being
 177                                                        ///< stacked vertically prior to swizzling
 178 } ADDR_EQUATION;
 179
 180
 181 /**
 182 ****************************************************************************************************
 183 * @brief Alloc system memory flags.
 184 * @note These flags are reserved for future use and if flags are added will minimize the impact
 185 *       of the client.
 186 ****************************************************************************************************
 187 */
 188 typedef union _ADDR_ALLOCSYSMEM_FLAGS
 189 {
 190     struct
 191     {
 192         UINT_32 reserved    : 32;  ///< Reserved for future use.
 193     } fields;
 194     UINT_32 value;
 195
 196 } ADDR_ALLOCSYSMEM_FLAGS;
 197
 198 /**
 199 ****************************************************************************************************
 200 * @brief Alloc system memory input structure
 201 ****************************************************************************************************
 202 */
 203 typedef struct _ADDR_ALLOCSYSMEM_INPUT
 204 {
 205     UINT_32                 size;           ///< Size of this structure in bytes
 206
 207     ADDR_ALLOCSYSMEM_FLAGS  flags;          ///< System memory flags.
 208     UINT_32                 sizeInBytes;    ///< System memory allocation size in bytes.
 209     ADDR_CLIENT_HANDLE      hClient;        ///< Client handle
 210 } ADDR_ALLOCSYSMEM_INPUT;
 211
 212 /**
 213 ****************************************************************************************************
 214 * ADDR_ALLOCSYSMEM
 215 *   @brief
 216 *       Allocate system memory callback function. Returns valid pointer on success.
 217 ****************************************************************************************************
 218 */
 219 typedef VOID* (ADDR_API* ADDR_ALLOCSYSMEM)(
 220     const ADDR_ALLOCSYSMEM_INPUT* pInput);
 221
 222 /**
 223 ****************************************************************************************************
 224 * @brief Free system memory input structure
 225 ****************************************************************************************************
 226 */
 227 typedef struct _ADDR_FREESYSMEM_INPUT
 228 {
 229     UINT_32                 size;           ///< Size of this structure in bytes
 230
 231     VOID*                   pVirtAddr;      ///< Virtual address
 232     ADDR_CLIENT_HANDLE      hClient;        ///< Client handle
 233 } ADDR_FREESYSMEM_INPUT;
 234
 235 /**
 236 ****************************************************************************************************
 237 * ADDR_FREESYSMEM
 238 *   @brief
 239 *       Free system memory callback function.
 240 *       Returns ADDR_OK on success.
 241 ****************************************************************************************************
 242 */
 243 typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_FREESYSMEM)(
 244     const ADDR_FREESYSMEM_INPUT* pInput);
 245
 246 /**
 247 ****************************************************************************************************
 248 * @brief Print debug message input structure
 249 ****************************************************************************************************
 250 */
 251 typedef struct _ADDR_DEBUGPRINT_INPUT
 252 {
 253     UINT_32             size;           ///< Size of this structure in bytes
 254
 255     CHAR*               pDebugString;   ///< Debug print string
 256     va_list             ap;             ///< Variable argument list
 257     ADDR_CLIENT_HANDLE  hClient;        ///< Client handle
 258 } ADDR_DEBUGPRINT_INPUT;
 259
 260 /**
 261 ****************************************************************************************************
 262 * ADDR_DEBUGPRINT
 263 *   @brief
 264 *       Print debug message callback function.
 265 *       Returns ADDR_OK on success.
 266 ****************************************************************************************************
 267 */
 268 typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_DEBUGPRINT)(
 269     const ADDR_DEBUGPRINT_INPUT* pInput);
 270
 271 /**
 272 ****************************************************************************************************
 273 * ADDR_CALLBACKS
 274 *
 275 *   @brief
 276 *       Address Library needs client to provide system memory alloc/free routines.
 277 ****************************************************************************************************
 278 */
 279 typedef struct _ADDR_CALLBACKS
 280 {
 281     ADDR_ALLOCSYSMEM allocSysMem;   ///< Routine to allocate system memory
 282     ADDR_FREESYSMEM  freeSysMem;    ///< Routine to free system memory
 283     ADDR_DEBUGPRINT  debugPrint;    ///< Routine to print debug message
 284 } ADDR_CALLBACKS;
 285
 286 ////////////////////////////////////////////////////////////////////////////////////////////////////
 287 //                               Create/Destroy functions
 288 ////////////////////////////////////////////////////////////////////////////////////////////////////
 289
 290 /**
 291 ****************************************************************************************************
 292 * ADDR_CREATE_FLAGS
 293 *
 294 *   @brief
 295 *       This structure is used to pass some setup in creation of AddrLib
 296 *   @note
 297 ****************************************************************************************************
 298 */
 299 typedef union _ADDR_CREATE_FLAGS
 300 {
 301     struct
 302     {
 303         UINT_32 noCubeMipSlicesPad     : 1;    ///< Turn cubemap faces padding off
 304         UINT_32 fillSizeFields         : 1;    ///< If clients fill size fields in all input and
 305                                                ///  output structure
 306         UINT_32 useTileIndex           : 1;    ///< Make tileIndex field in input valid
 307         UINT_32 useCombinedSwizzle     : 1;    ///< Use combined tile swizzle
 308         UINT_32 checkLast2DLevel       : 1;    ///< Check the last 2D mip sub level
 309         UINT_32 useHtileSliceAlign     : 1;    ///< Do htile single slice alignment
 310         UINT_32 allowLargeThickTile    : 1;    ///< Allow 64*thickness*bytesPerPixel > rowSize
 311         UINT_32 reserved               : 25;   ///< Reserved bits for future use
 312     };
 313
 314     UINT_32 value;
 315 } ADDR_CREATE_FLAGS;
 316
 317 /**
 318 ****************************************************************************************************
 319 *   ADDR_REGISTER_VALUE
 320 *
 321 *   @brief
 322 *       Data from registers to setup AddrLib global data, used in AddrCreate
 323 ****************************************************************************************************
 324 */
 325 typedef struct _ADDR_REGISTER_VALUE
 326 {
 327     UINT_32  gbAddrConfig;       ///< For R8xx, use GB_ADDR_CONFIG register value.
 328                                  ///  For R6xx/R7xx, use GB_TILING_CONFIG.
 329                                  ///  But they can be treated as the same.
 330                                  ///  if this value is 0, use chip to set default value
 331     UINT_32  backendDisables;    ///< 1 bit per backend, starting with LSB. 1=disabled,0=enabled.
 332                                  ///  Register value of CC_RB_BACKEND_DISABLE.BACKEND_DISABLE
 333
 334                                  ///  R800 registers-----------------------------------------------
 335     UINT_32  noOfBanks;          ///< Number of h/w ram banks - For r800: MC_ARB_RAMCFG.NOOFBANK
 336                                  ///  No enums for this value in h/w header files
 337                                  ///  0: 4
 338                                  ///  1: 8
 339                                  ///  2: 16
 340     UINT_32  noOfRanks;          ///  MC_ARB_RAMCFG.NOOFRANK
 341                                  ///  0: 1
 342                                  ///  1: 2
 343                                  ///  SI (R1000) registers-----------------------------------------
 344     const UINT_32* pTileConfig;  ///< Global tile setting tables
 345     UINT_32  noOfEntries;        ///< Number of entries in pTileConfig
 346
 347                                  ///< CI registers-------------------------------------------------
 348     const UINT_32* pMacroTileConfig;    ///< Global macro tile mode table
 349     UINT_32  noOfMacroEntries;   ///< Number of entries in pMacroTileConfig
 350 } ADDR_REGISTER_VALUE;
 351
 352 /**
 353 ****************************************************************************************************
 354 * ADDR_CREATE_INPUT
 355 *
 356 *   @brief
 357 *       Parameters use to create an AddrLib Object. Caller must provide all fields.
 358 *
 359 ****************************************************************************************************
 360 */
 361 typedef struct _ADDR_CREATE_INPUT
 362 {
 363     UINT_32             size;                ///< Size of this structure in bytes
 364
 365     UINT_32             chipEngine;          ///< Chip Engine
 366     UINT_32             chipFamily;          ///< Chip Family
 367     UINT_32             chipRevision;        ///< Chip Revision
 368     ADDR_CALLBACKS      callbacks;           ///< Callbacks for sysmem alloc/free/print
 369     ADDR_CREATE_FLAGS   createFlags;         ///< Flags to setup AddrLib
 370     ADDR_REGISTER_VALUE regValue;            ///< Data from registers to setup AddrLib global data
 371     ADDR_CLIENT_HANDLE  hClient;             ///< Client handle
 372     UINT_32             minPitchAlignPixels; ///< Minimum pitch alignment in pixels
 373 } ADDR_CREATE_INPUT;
 374
 375 /**
 376 ****************************************************************************************************
 377 * ADDR_CREATEINFO_OUTPUT
 378 *
 379 *   @brief
 380 *       Return AddrLib handle to client driver
 381 *
 382 ****************************************************************************************************
 383 */
 384 typedef struct _ADDR_CREATE_OUTPUT
 385 {
 386     UINT_32              size;            ///< Size of this structure in bytes
 387
 388     ADDR_HANDLE          hLib;            ///< Address lib handle
 389
 390     UINT_32              numEquations;    ///< Number of equations in the table
 391     const ADDR_EQUATION* pEquationTable;  ///< Pointer to the equation table
 392 } ADDR_CREATE_OUTPUT;
 393
 394 /**
 395 ****************************************************************************************************
 396 *   AddrCreate
 397 *
 398 *   @brief
 399 *       Create AddrLib object, must be called before any interface calls
 400 *
 401 *   @return
 402 *       ADDR_OK if successful
 403 ****************************************************************************************************
 404 */
 405 ADDR_E_RETURNCODE ADDR_API AddrCreate(
 406     const ADDR_CREATE_INPUT*    pAddrCreateIn,
 407     ADDR_CREATE_OUTPUT*         pAddrCreateOut);
 408
 409
 410
 411 /**
 412 ****************************************************************************************************
 413 *   AddrDestroy
 414 *
 415 *   @brief
 416 *       Destroy AddrLib object, must be called to free internally allocated resources.
 417 *
 418 *   @return
 419 *      ADDR_OK if successful
 420 ****************************************************************************************************
 421 */
 422 ADDR_E_RETURNCODE ADDR_API AddrDestroy(
 423     ADDR_HANDLE hLib);
 424
 425
 426
 427 ////////////////////////////////////////////////////////////////////////////////////////////////////
 428 //                                    Surface functions
 429 ////////////////////////////////////////////////////////////////////////////////////////////////////
 430
 431 /**
 432 ****************************************************************************************************
 433 * @brief
 434 *       Bank/tiling parameters. On function input, these can be set as desired or
 435 *       left 0 for AddrLib to calculate/default. On function output, these are the actual
 436 *       parameters used.
 437 * @note
 438 *       Valid bankWidth/bankHeight value:
 439 *       1,2,4,8. They are factors instead of pixels or bytes.
 440 *
 441 *       The bank number remains constant across each row of the
 442 *       macro tile as each pipe is selected, so the number of
 443 *       tiles in the x direction with the same bank number will
 444 *       be bank_width * num_pipes.
 445 ****************************************************************************************************
 446 */
 447 typedef struct _ADDR_TILEINFO
 448 {
 449     ///  Any of these parameters can be set to 0 to use the HW default.
 450     UINT_32     banks;              ///< Number of banks, numerical value
 451     UINT_32     bankWidth;          ///< Number of tiles in the X direction in the same bank
 452     UINT_32     bankHeight;         ///< Number of tiles in the Y direction in the same bank
 453     UINT_32     macroAspectRatio;   ///< Macro tile aspect ratio. 1-1:1, 2-4:1, 4-16:1, 8-64:1
 454     UINT_32     tileSplitBytes;     ///< Tile split size, in bytes
 455     AddrPipeCfg pipeConfig;         ///< Pipe Config = HW enum + 1
 456 } ADDR_TILEINFO;
 457
 458 // Create a define to avoid client change. The removal of R800 is because we plan to implement SI
 459 // within 800 HWL - An AddrPipeCfg is added in above data structure
 460 typedef ADDR_TILEINFO ADDR_R800_TILEINFO;
 461
 462 /**
 463 ****************************************************************************************************
 464 * @brief
 465 *       Information needed by quad buffer stereo support
 466 ****************************************************************************************************
 467 */
 468 typedef struct _ADDR_QBSTEREOINFO
 469 {
 470     UINT_32         eyeHeight;          ///< Height (in pixel rows) to right eye
 471     UINT_32         rightOffset;        ///< Offset (in bytes) to right eye
 472     UINT_32         rightSwizzle;       ///< TileSwizzle for right eyes
 473 } ADDR_QBSTEREOINFO;
 474
 475 /**
 476 ****************************************************************************************************
 477 *   ADDR_SURFACE_FLAGS
 478 *
 479 *   @brief
 480 *       Surface flags
 481 ****************************************************************************************************
 482 */
 483 typedef union _ADDR_SURFACE_FLAGS
 484 {
 485     struct
 486     {
 487         UINT_32 color                : 1; ///< Flag indicates this is a color buffer
 488         UINT_32 depth                : 1; ///< Flag indicates this is a depth/stencil buffer
 489         UINT_32 stencil              : 1; ///< Flag indicates this is a stencil buffer
 490         UINT_32 texture              : 1; ///< Flag indicates this is a texture
 491         UINT_32 cube                 : 1; ///< Flag indicates this is a cubemap
 492         UINT_32 volume               : 1; ///< Flag indicates this is a volume texture
 493         UINT_32 fmask                : 1; ///< Flag indicates this is an fmask
 494         UINT_32 cubeAsArray          : 1; ///< Flag indicates if treat cubemap as arrays
 495         UINT_32 compressZ            : 1; ///< Flag indicates z buffer is compressed
 496         UINT_32 overlay              : 1; ///< Flag indicates this is an overlay surface
 497         UINT_32 noStencil            : 1; ///< Flag indicates this depth has no separate stencil
 498         UINT_32 display              : 1; ///< Flag indicates this should match display controller req.
 499         UINT_32 opt4Space            : 1; ///< Flag indicates this surface should be optimized for space
 500                                           ///  i.e. save some memory but may lose performance
 501         UINT_32 prt                  : 1; ///< Flag for partially resident texture
 502         UINT_32 qbStereo             : 1; ///< Quad buffer stereo surface
 503         UINT_32 pow2Pad              : 1; ///< SI: Pad to pow2, must set for mipmap (include level0)
 504         UINT_32 interleaved          : 1; ///< Special flag for interleaved YUV surface padding
 505         UINT_32 tcCompatible         : 1; ///< Flag indicates surface needs to be shader readable
 506         UINT_32 dispTileType         : 1; ///< NI: force display Tiling for 128 bit shared resoruce
 507         UINT_32 dccCompatible        : 1; ///< VI: whether to support dcc fast clear
 508         UINT_32 czDispCompatible     : 1; ///< SI+: CZ family has a HW bug needs special alignment.
 509                                           ///  This flag indicates we need to follow the
 510                                           ///  alignment with CZ families or other ASICs under
 511                                           ///  PX configuration + CZ.
 512         UINT_32 nonSplit             : 1; ///< CI: depth texture should not be split
 513         UINT_32 disableLinearOpt     : 1; ///< Disable tile mode optimization to linear
 514         UINT_32 needEquation         : 1; ///< Make the surface tile setting equation compatible.
 515                                           ///  This flag indicates we need to override tile
 516                                           ///  mode to PRT_* tile mode to disable slice rotation,
 517                                           ///  which is needed by swizzle pattern equation.
 518         UINT_32 skipIndicesOutput    : 1; ///< Skipping indices in output.
 519         UINT_32 rotateDisplay        : 1; ///< Rotate micro tile type
 520         UINT_32 minimizeAlignment    : 1; ///< Minimize alignment
 521         UINT_32 preferEquation       : 1; ///< Return equation index without adjusting tile mode
 522         UINT_32 matchStencilTileCfg  : 1; ///< Select tile index of stencil as well as depth surface
 523                                           ///  to make sure they share same tile config parameters
 524         UINT_32 reserved             : 3; ///< Reserved bits
 525     };
 526
 527     UINT_32 value;
 528 } ADDR_SURFACE_FLAGS;
 529
 530 /**
 531 ****************************************************************************************************
 532 *   ADDR_COMPUTE_SURFACE_INFO_INPUT
 533 *
 534 *   @brief
 535 *       Input structure for AddrComputeSurfaceInfo
 536 ****************************************************************************************************
 537 */
 538 typedef struct _ADDR_COMPUTE_SURFACE_INFO_INPUT
 539 {
 540     UINT_32             size;               ///< Size of this structure in bytes
 541
 542     AddrTileMode        tileMode;           ///< Tile mode
 543     AddrFormat          format;             ///< If format is set to valid one, bpp/width/height
 544                                             ///  might be overwritten
 545     UINT_32             bpp;                ///< Bits per pixel
 546     UINT_32             numSamples;         ///< Number of samples
 547     UINT_32             width;              ///< Width, in pixels
 548     UINT_32             height;             ///< Height, in pixels
 549     UINT_32             numSlices;          ///< Number of surface slices or depth
 550     UINT_32             slice;              ///< Slice index
 551     UINT_32             mipLevel;           ///< Current mipmap level
 552     UINT_32             numMipLevels;       ///< Number of mips in mip chain
 553     ADDR_SURFACE_FLAGS  flags;              ///< Surface type flags
 554     UINT_32             numFrags;           ///< Number of fragments, leave it zero or the same as
 555                                             ///  number of samples for normal AA; Set it to the
 556                                             ///  number of fragments for EQAA
 557     /// r800 and later HWL parameters
 558     // Needed by 2D tiling, for linear and 1D tiling, just keep them 0's
 559     ADDR_TILEINFO*      pTileInfo;          ///< 2D tile parameters. Set to 0 to default/calculate
 560     AddrTileType        tileType;           ///< Micro tiling type, not needed when tileIndex != -1
 561     INT_32              tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
 562                                             ///  while the global useTileIndex is set to 1
 563     UINT_32             basePitch;          ///< Base level pitch in pixels, 0 means ignored, is a
 564                                             ///  must for mip levels from SI+.
 565                                             ///  Don't use pitch in blocks for compressed formats!
 566     UINT_32             maxBaseAlign;       ///< Max base alignment request from client
 567     UINT_32             pitchAlign;         ///< Pitch alignment request from client
 568     UINT_32             heightAlign;        ///< Height alignment request from client
 569 } ADDR_COMPUTE_SURFACE_INFO_INPUT;
 570
 571 /**
 572 ****************************************************************************************************
 573 *   ADDR_COMPUTE_SURFACE_INFO_OUTPUT
 574 *
 575 *   @brief
 576 *       Output structure for AddrComputeSurfInfo
 577 *   @note
 578         Element: AddrLib unit for computing. e.g. BCn: 4x4 blocks; R32B32B32: 32bit with 3x pitch
 579         Pixel: Original pixel
 580 ****************************************************************************************************
 581 */
 582 typedef struct _ADDR_COMPUTE_SURFACE_INFO_OUTPUT
 583 {
 584     UINT_32         size;           ///< Size of this structure in bytes
 585
 586     UINT_32         pitch;          ///< Pitch in elements (in blocks for compressed formats)
 587     UINT_32         height;         ///< Height in elements (in blocks for compressed formats)
 588     UINT_32         depth;          ///< Number of slice/depth
 589     UINT_64         surfSize;       ///< Surface size in bytes
 590     AddrTileMode    tileMode;       ///< Actual tile mode. May differ from that in input
 591     UINT_32         baseAlign;      ///< Base address alignment
 592     UINT_32         pitchAlign;     ///< Pitch alignment, in elements
 593     UINT_32         heightAlign;    ///< Height alignment, in elements
 594     UINT_32         depthAlign;     ///< Depth alignment, aligned to thickness, for 3d texture
 595     UINT_32         bpp;            ///< Bits per elements (e.g. blocks for BCn, 1/3 for 96bit)
 596     UINT_32         pixelPitch;     ///< Pitch in original pixels
 597     UINT_32         pixelHeight;    ///< Height in original pixels
 598     UINT_32         pixelBits;      ///< Original bits per pixel, passed from input
 599     UINT_64         sliceSize;      ///< Size of slice specified by input's slice
 600                                     ///  The result is controlled by surface flags & createFlags
 601                                     ///  By default this value equals to surfSize for volume
 602     UINT_32         pitchTileMax;   ///< PITCH_TILE_MAX value for h/w register
 603     UINT_32         heightTileMax;  ///< HEIGHT_TILE_MAX value for h/w register
 604     UINT_32         sliceTileMax;   ///< SLICE_TILE_MAX value for h/w register
 605
 606     UINT_32         numSamples;     ///< Pass the effective numSamples processed in this call
 607
 608     /// r800 and later HWL parameters
 609     ADDR_TILEINFO*  pTileInfo;      ///< Tile parameters used. Filled in if 0 on input
 610     AddrTileType    tileType;       ///< Micro tiling type, only valid when tileIndex != -1
 611     INT_32          tileIndex;      ///< Tile index, MAY be "downgraded"
 612
 613     INT_32          macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
 614     /// Output flags
 615     struct
 616     {
 617         /// Special information to work around SI mipmap swizzle bug UBTS #317508
 618         UINT_32     last2DLevel  : 1;  ///< TRUE if this is the last 2D(3D) tiled
 619                                        ///< Only meaningful when create flag checkLast2DLevel is set
 620         UINT_32     tcCompatible : 1;  ///< If the surface can be shader compatible
 621         UINT_32     dccUnsupport : 1;  ///< If the surface can support DCC compressed rendering
 622         UINT_32     prtTileIndex : 1;  ///< SI only, indicate the returned tile index is for PRT
 623                                        ///< If address lib return true for mip 0, client should set prt flag
 624                                        ///< for child mips in subsequent compute surface info calls
 625         UINT_32     reserved     :28;  ///< Reserved bits
 626     };
 627
 628     UINT_32         equationIndex;     ///< Equation index in the equation table;
 629
 630     UINT_32         blockWidth;        ///< Width in element inside one block(1D->Micro, 2D->Macro)
 631     UINT_32         blockHeight;       ///< Height in element inside one block(1D->Micro, 2D->Macro)
 632     UINT_32         blockSlices;       ///< Slice number inside one block(1D->Micro, 2D->Macro)
 633
 634     /// Stereo info
 635     ADDR_QBSTEREOINFO*  pStereoInfo;///< Stereo information, needed when .qbStereo flag is TRUE
 636
 637     INT_32          stencilTileIdx; ///< stencil tile index output when matchStencilTileCfg was set
 638 } ADDR_COMPUTE_SURFACE_INFO_OUTPUT;
 639
 640 /**
 641 ****************************************************************************************************
 642 *   AddrComputeSurfaceInfo
 643 *
 644 *   @brief
 645 *       Compute surface width/height/depth/alignments and suitable tiling mode
 646 ****************************************************************************************************
 647 */
 648 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
 649     ADDR_HANDLE                             hLib,
 650     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,
 651     ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut);
 652
 653
 654
 655 /**
 656 ****************************************************************************************************
 657 *   ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
 658 *
 659 *   @brief
 660 *       Input structure for AddrComputeSurfaceAddrFromCoord
 661 ****************************************************************************************************
 662 */
 663 typedef struct _ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
 664 {
 665     UINT_32         size;               ///< Size of this structure in bytes
 666
 667     UINT_32         x;                  ///< X coordinate
 668     UINT_32         y;                  ///< Y coordinate
 669     UINT_32         slice;              ///< Slice index
 670     UINT_32         sample;             ///< Sample index, use fragment index for EQAA
 671
 672     UINT_32         bpp;                ///< Bits per pixel
 673     UINT_32         pitch;              ///< Surface pitch, in pixels
 674     UINT_32         height;             ///< Surface height, in pixels
 675     UINT_32         numSlices;          ///< Surface depth
 676     UINT_32         numSamples;         ///< Number of samples
 677
 678     AddrTileMode    tileMode;           ///< Tile mode
 679     BOOL_32         isDepth;            ///< TRUE if the surface uses depth sample ordering within
 680                                         ///  micro tile. Textures can also choose depth sample order
 681     UINT_32         tileBase;           ///< Base offset (in bits) inside micro tile which handles
 682                                         ///  the case that components are stored separately
 683     UINT_32         compBits;           ///< The component bits actually needed(for planar surface)
 684
 685     UINT_32         numFrags;           ///< Number of fragments, leave it zero or the same as
 686                                         ///  number of samples for normal AA; Set it to the
 687                                         ///  number of fragments for EQAA
 688     /// r800 and later HWL parameters
 689     // Used for 1D tiling above
 690     AddrTileType    tileType;           ///< See defintion of AddrTileType
 691     struct
 692     {
 693         UINT_32     ignoreSE : 1;       ///< TRUE if shader engines are ignored. This is texture
 694                                         ///  only flag. Only non-RT texture can set this to TRUE
 695         UINT_32     reserved :31;       ///< Reserved for future use.
 696     };
 697     // 2D tiling needs following structure
 698     ADDR_TILEINFO*  pTileInfo;          ///< 2D tile parameters. Client must provide all data
 699     INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
 700                                         ///  while the global useTileIndex is set to 1
 701     union
 702     {
 703         struct
 704         {
 705             UINT_32  bankSwizzle;       ///< Bank swizzle
 706             UINT_32  pipeSwizzle;       ///< Pipe swizzle
 707         };
 708         UINT_32     tileSwizzle;        ///< Combined swizzle, if useCombinedSwizzle is TRUE
 709     };
 710
 711 #if ADDR_AM_BUILD // These two fields are not valid in SW blt since no HTILE access
 712     UINT_32         addr5Swizzle;       ///< ADDR5_SWIZZLE_MASK of DB_DEPTH_INFO
 713     BOOL_32         is32ByteTile;       ///< Caller must have access to HTILE buffer and know if
 714                                         ///  this tile is compressed to 32B
 715 #endif
 716 } ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT;
 717
 718 /**
 719 ****************************************************************************************************
 720 *   ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
 721 *
 722 *   @brief
 723 *       Output structure for AddrComputeSurfaceAddrFromCoord
 724 ****************************************************************************************************
 725 */
 726 typedef struct _ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
 727 {
 728     UINT_32 size;           ///< Size of this structure in bytes
 729
 730     UINT_64 addr;           ///< Byte address
 731     UINT_32 bitPosition;    ///< Bit position within surfaceAddr, 0-7.
 732                             ///  For surface bpp < 8, e.g. FMT_1.
 733     UINT_32 prtBlockIndex;  ///< Index of a PRT tile (64K block)
 734 } ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT;
 735
 736 /**
 737 ****************************************************************************************************
 738 *   AddrComputeSurfaceAddrFromCoord
 739 *
 740 *   @brief
 741 *       Compute surface address from a given coordinate.
 742 ****************************************************************************************************
 743 */
 744 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
 745     ADDR_HANDLE                                     hLib,
 746     const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,
 747     ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT*      pOut);
 748
 749
 750
 751 /**
 752 ****************************************************************************************************
 753 *   ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
 754 *
 755 *   @brief
 756 *       Input structure for AddrComputeSurfaceCoordFromAddr
 757 ****************************************************************************************************
 758 */
 759 typedef struct _ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
 760 {
 761     UINT_32         size;               ///< Size of this structure in bytes
 762
 763     UINT_64         addr;               ///< Address in bytes
 764     UINT_32         bitPosition;        ///< Bit position in addr. 0-7. for surface bpp < 8,
 765                                         ///  e.g. FMT_1;
 766     UINT_32         bpp;                ///< Bits per pixel
 767     UINT_32         pitch;              ///< Pitch, in pixels
 768     UINT_32         height;             ///< Height in pixels
 769     UINT_32         numSlices;          ///< Surface depth
 770     UINT_32         numSamples;         ///< Number of samples
 771
 772     AddrTileMode    tileMode;           ///< Tile mode
 773     BOOL_32         isDepth;            ///< Surface uses depth sample ordering within micro tile.
 774                                         ///  Note: Textures can choose depth sample order as well.
 775     UINT_32         tileBase;           ///< Base offset (in bits) inside micro tile which handles
 776                                         ///  the case that components are stored separately
 777     UINT_32         compBits;           ///< The component bits actually needed(for planar surface)
 778
 779     UINT_32         numFrags;           ///< Number of fragments, leave it zero or the same as
 780                                         ///  number of samples for normal AA; Set it to the
 781                                         ///  number of fragments for EQAA
 782     /// r800 and later HWL parameters
 783     // Used for 1D tiling above
 784     AddrTileType    tileType;           ///< See defintion of AddrTileType
 785     struct
 786     {
 787         UINT_32     ignoreSE : 1;       ///< TRUE if shader engines are ignored. This is texture
 788                                         ///  only flag. Only non-RT texture can set this to TRUE
 789         UINT_32     reserved :31;       ///< Reserved for future use.
 790     };
 791     // 2D tiling needs following structure
 792     ADDR_TILEINFO*  pTileInfo;          ///< 2D tile parameters. Client must provide all data
 793     INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
 794                                         ///  while the global useTileIndex is set to 1
 795     union
 796     {
 797         struct
 798         {
 799             UINT_32  bankSwizzle;       ///< Bank swizzle
 800             UINT_32  pipeSwizzle;       ///< Pipe swizzle
 801         };
 802         UINT_32     tileSwizzle;        ///< Combined swizzle, if useCombinedSwizzle is TRUE
 803     };
 804 } ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT;
 805
 806 /**
 807 ****************************************************************************************************
 808 *   ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
 809 *
 810 *   @brief
 811 *       Output structure for AddrComputeSurfaceCoordFromAddr
 812 ****************************************************************************************************
 813 */
 814 typedef struct _ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
 815 {
 816     UINT_32 size;   ///< Size of this structure in bytes
 817
 818     UINT_32 x;      ///< X coordinate
 819     UINT_32 y;      ///< Y coordinate
 820     UINT_32 slice;  ///< Index of slices
 821     UINT_32 sample; ///< Index of samples, means fragment index for EQAA
 822 } ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT;
 823
 824 /**
 825 ****************************************************************************************************
 826 *   AddrComputeSurfaceCoordFromAddr
 827 *
 828 *   @brief
 829 *       Compute coordinate from a given surface address
 830 ****************************************************************************************************
 831 */
 832 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
 833     ADDR_HANDLE                                     hLib,
 834     const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,
 835     ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT*      pOut);
 836
 837 ////////////////////////////////////////////////////////////////////////////////////////////////////
 838 //                                   HTile functions
 839 ////////////////////////////////////////////////////////////////////////////////////////////////////
 840
 841 /**
 842 ****************************************************************************************************
 843 *   ADDR_HTILE_FLAGS
 844 *
 845 *   @brief
 846 *       HTILE flags
 847 ****************************************************************************************************
 848 */
 849 typedef union _ADDR_HTILE_FLAGS
 850 {
 851     struct
 852     {
 853         UINT_32 tcCompatible  : 1; ///< Flag indicates surface needs to be shader readable
 854         UINT_32 reserved      :31; ///< Reserved bits
 855     };
 856
 857     UINT_32 value;
 858 } ADDR_HTILE_FLAGS;
 859
 860 /**
 861 ****************************************************************************************************
 862 *   ADDR_COMPUTE_HTILE_INFO_INPUT
 863 *
 864 *   @brief
 865 *       Input structure of AddrComputeHtileInfo
 866 ****************************************************************************************************
 867 */
 868 typedef struct _ADDR_COMPUTE_HTILE_INFO_INPUT
 869 {
 870     UINT_32            size;            ///< Size of this structure in bytes
 871
 872     ADDR_HTILE_FLAGS   flags;           ///< HTILE flags
 873     UINT_32            pitch;           ///< Surface pitch, in pixels
 874     UINT_32            height;          ///< Surface height, in pixels
 875     UINT_32            numSlices;       ///< Number of slices
 876     BOOL_32            isLinear;        ///< Linear or tiled HTILE layout
 877     AddrHtileBlockSize blockWidth;      ///< 4 or 8. EG above only support 8
 878     AddrHtileBlockSize blockHeight;     ///< 4 or 8. EG above only support 8
 879     ADDR_TILEINFO*     pTileInfo;       ///< Tile info
 880
 881     INT_32             tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
 882                                         ///  while the global useTileIndex is set to 1
 883     INT_32             macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
 884                                         ///< README: When tileIndex is not -1, this must be valid
 885 } ADDR_COMPUTE_HTILE_INFO_INPUT;
 886
 887 /**
 888 ****************************************************************************************************
 889 *   ADDR_COMPUTE_HTILE_INFO_OUTPUT
 890 *
 891 *   @brief
 892 *       Output structure of AddrComputeHtileInfo
 893 ****************************************************************************************************
 894 */
 895 typedef struct _ADDR_COMPUTE_HTILE_INFO_OUTPUT
 896 {
 897     UINT_32 size;               ///< Size of this structure in bytes
 898
 899     UINT_32 pitch;              ///< Pitch in pixels of depth buffer represented in this
 900                                 ///  HTile buffer. This might be larger than original depth
 901                                 ///  buffer pitch when called with an unaligned pitch.
 902     UINT_32 height;             ///< Height in pixels, as above
 903     UINT_64 htileBytes;         ///< Size of HTILE buffer, in bytes
 904     UINT_32 baseAlign;          ///< Base alignment
 905     UINT_32 bpp;                ///< Bits per pixel for HTILE is how many bits for an 8x8 block!
 906     UINT_32 macroWidth;         ///< Macro width in pixels, actually squared cache shape
 907     UINT_32 macroHeight;        ///< Macro height in pixels
 908     UINT_64 sliceSize;          ///< Slice size, in bytes.
 909     BOOL_32 sliceInterleaved;   ///< Flag to indicate if different slice's htile is interleaved
 910                                 ///  Compute engine clear can't be used if htile is interleaved
 911 } ADDR_COMPUTE_HTILE_INFO_OUTPUT;
 912
 913 /**
 914 ****************************************************************************************************
 915 *   AddrComputeHtileInfo
 916 *
 917 *   @brief
 918 *       Compute Htile pitch, height, base alignment and size in bytes
 919 ****************************************************************************************************
 920 */
 921 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
 922     ADDR_HANDLE                             hLib,
 923     const ADDR_COMPUTE_HTILE_INFO_INPUT*    pIn,
 924     ADDR_COMPUTE_HTILE_INFO_OUTPUT*         pOut);
 925
 926
 927
 928 /**
 929 ****************************************************************************************************
 930 *   ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
 931 *
 932 *   @brief
 933 *       Input structure for AddrComputeHtileAddrFromCoord
 934 ****************************************************************************************************
 935 */
 936 typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
 937 {
 938     UINT_32            size;            ///< Size of this structure in bytes
 939
 940     UINT_32            pitch;           ///< Pitch, in pixels
 941     UINT_32            height;          ///< Height in pixels
 942     UINT_32            x;               ///< X coordinate
 943     UINT_32            y;               ///< Y coordinate
 944     UINT_32            slice;           ///< Index of slice
 945     UINT_32            numSlices;       ///< Number of slices
 946     BOOL_32            isLinear;        ///< Linear or tiled HTILE layout
 947     ADDR_HTILE_FLAGS   flags;           ///< htile flags
 948     AddrHtileBlockSize blockWidth;      ///< 4 or 8. 1 means 8, 0 means 4. EG above only support 8
 949     AddrHtileBlockSize blockHeight;     ///< 4 or 8. 1 means 8, 0 means 4. EG above only support 8
 950     ADDR_TILEINFO*     pTileInfo;       ///< Tile info
 951
 952     INT_32             tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
 953                                         ///  while the global useTileIndex is set to 1
 954     INT_32             macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
 955                                         ///< README: When tileIndex is not -1, this must be valid
 956     UINT_32            bpp;             ///< depth/stencil buffer bit per pixel size
 957     UINT_32            zStencilAddr;    ///< tcCompatible Z/Stencil surface address
 958 } ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT;
 959
 960 /**
 961 ****************************************************************************************************
 962 *   ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
 963 *
 964 *   @brief
 965 *       Output structure for AddrComputeHtileAddrFromCoord
 966 ****************************************************************************************************
 967 */
 968 typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
 969 {
 970     UINT_32 size;           ///< Size of this structure in bytes
 971
 972     UINT_64 addr;           ///< Address in bytes
 973     UINT_32 bitPosition;    ///< Bit position, 0 or 4. CMASK and HTILE shares some lib method.
 974                             ///  So we keep bitPosition for HTILE as well
 975 } ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT;
 976
 977 /**
 978 ****************************************************************************************************
 979 *   AddrComputeHtileAddrFromCoord
 980 *
 981 *   @brief
 982 *       Compute Htile address according to coordinates (of depth buffer)
 983 ****************************************************************************************************
 984 */
 985 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
 986     ADDR_HANDLE                                     hLib,
 987     const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*   pIn,
 988     ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT*        pOut);
 989
 990
 991
 992 /**
 993 ****************************************************************************************************
 994 *   ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
 995 *
 996 *   @brief
 997 *       Input structure for AddrComputeHtileCoordFromAddr
 998 ****************************************************************************************************
 999 */
1000 typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
1001 {
1002     UINT_32            size;            ///< Size of this structure in bytes
1003
1004     UINT_64            addr;            ///< Address
1005     UINT_32            bitPosition;     ///< Bit position 0 or 4. CMASK and HTILE share some methods
1006                                         ///  so we keep bitPosition for HTILE as well
1007     UINT_32            pitch;           ///< Pitch, in pixels
1008     UINT_32            height;          ///< Height, in pixels
1009     UINT_32            numSlices;       ///< Number of slices
1010     BOOL_32            isLinear;        ///< Linear or tiled HTILE layout
1011     AddrHtileBlockSize blockWidth;      ///< 4 or 8. 1 means 8, 0 means 4. R8xx/R9xx only support 8
1012     AddrHtileBlockSize blockHeight;     ///< 4 or 8. 1 means 8, 0 means 4. R8xx/R9xx only support 8
1013     ADDR_TILEINFO*     pTileInfo;       ///< Tile info
1014
1015     INT_32             tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
1016                                         ///  while the global useTileIndex is set to 1
1017     INT_32             macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
1018                                         ///< README: When tileIndex is not -1, this must be valid
1019 } ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT;
1020
1021 /**
1022 ****************************************************************************************************
1023 *   ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
1024 *
1025 *   @brief
1026 *       Output structure for AddrComputeHtileCoordFromAddr
1027 ****************************************************************************************************
1028 */
1029 typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
1030 {
1031     UINT_32 size;   ///< Size of this structure in bytes
1032
1033     UINT_32 x;      ///< X coordinate
1034     UINT_32 y;      ///< Y coordinate
1035     UINT_32 slice;  ///< Slice index
1036 } ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT;
1037
1038 /**
1039 ****************************************************************************************************
1040 *   AddrComputeHtileCoordFromAddr
1041 *
1042 *   @brief
1043 *       Compute coordinates within depth buffer (1st pixel of a micro tile) according to
1044 *       Htile address
1045 ****************************************************************************************************
1046 */
1047 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
1048     ADDR_HANDLE                                     hLib,
1049     const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT*   pIn,
1050     ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT*        pOut);
1051
1052
1053
1054 ////////////////////////////////////////////////////////////////////////////////////////////////////
1055 //                                     C-mask functions
1056 ////////////////////////////////////////////////////////////////////////////////////////////////////
1057
1058 /**
1059 ****************************************************************************************************
1060 *   ADDR_CMASK_FLAGS
1061 *
1062 *   @brief
1063 *       CMASK flags
1064 ****************************************************************************************************
1065 */
1066 typedef union _ADDR_CMASK_FLAGS
1067 {
1068     struct
1069     {
1070         UINT_32 tcCompatible  : 1; ///< Flag indicates surface needs to be shader readable
1071         UINT_32 reserved      :31; ///< Reserved bits
1072     };
1073
1074     UINT_32 value;
1075 } ADDR_CMASK_FLAGS;
1076
1077 /**
1078 ****************************************************************************************************
1079 *   ADDR_COMPUTE_CMASK_INFO_INPUT
1080 *
1081 *   @brief
1082 *       Input structure of AddrComputeCmaskInfo
1083 ****************************************************************************************************
1084 */
1085 typedef struct _ADDR_COMPUTE_CMASKINFO_INPUT
1086 {
1087     UINT_32             size;            ///< Size of this structure in bytes
1088
1089     ADDR_CMASK_FLAGS    flags;           ///< CMASK flags
1090     UINT_32             pitch;           ///< Pitch, in pixels, of color buffer
1091     UINT_32             height;          ///< Height, in pixels, of color buffer
1092     UINT_32             numSlices;       ///< Number of slices, of color buffer
1093     BOOL_32             isLinear;        ///< Linear or tiled layout, Only SI can be linear
1094     ADDR_TILEINFO*      pTileInfo;       ///< Tile info
1095
1096     INT_32              tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
1097                                          ///  while the global useTileIndex is set to 1
1098     INT_32              macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
1099                                          ///< README: When tileIndex is not -1, this must be valid
1100 } ADDR_COMPUTE_CMASK_INFO_INPUT;
1101
1102 /**
1103 ****************************************************************************************************
1104 *   ADDR_COMPUTE_CMASK_INFO_OUTPUT
1105 *
1106 *   @brief
1107 *       Output structure of AddrComputeCmaskInfo
1108 ****************************************************************************************************
1109 */
1110 typedef struct _ADDR_COMPUTE_CMASK_INFO_OUTPUT
1111 {
1112     UINT_32 size;           ///< Size of this structure in bytes
1113
1114     UINT_32 pitch;          ///< Pitch in pixels of color buffer which
1115                             ///  this Cmask matches. The size might be larger than
1116                             ///  original color buffer pitch when called with
1117                             ///  an unaligned pitch.
1118     UINT_32 height;         ///< Height in pixels, as above
1119     UINT_64 cmaskBytes;     ///< Size in bytes of CMask buffer
1120     UINT_32 baseAlign;      ///< Base alignment
1121     UINT_32 blockMax;       ///< Cmask block size. Need this to set CB_COLORn_MASK register
1122     UINT_32 macroWidth;     ///< Macro width in pixels, actually squared cache shape
1123     UINT_32 macroHeight;    ///< Macro height in pixels
1124     UINT_64 sliceSize;      ///< Slice size, in bytes.
1125 } ADDR_COMPUTE_CMASK_INFO_OUTPUT;
1126
1127 /**
1128 ****************************************************************************************************
1129 *   AddrComputeCmaskInfo
1130 *
1131 *   @brief
1132 *       Compute Cmask pitch, height, base alignment and size in bytes from color buffer
1133 *       info
1134 ****************************************************************************************************
1135 */
1136 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
1137     ADDR_HANDLE                             hLib,
1138     const ADDR_COMPUTE_CMASK_INFO_INPUT*    pIn,
1139     ADDR_COMPUTE_CMASK_INFO_OUTPUT*         pOut);
1140
1141
1142
1143 /**
1144 ****************************************************************************************************
1145 *   ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
1146 *
1147 *   @brief
1148 *       Input structure for AddrComputeCmaskAddrFromCoord
1149 *
1150 ****************************************************************************************************
1151 */
1152 typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
1153 {
1154     UINT_32          size;           ///< Size of this structure in bytes
1155     UINT_32          x;              ///< X coordinate
1156     UINT_32          y;              ///< Y coordinate
1157     UINT_64          fmaskAddr;      ///< Fmask addr for tc compatible Cmask
1158     UINT_32          slice;          ///< Slice index
1159     UINT_32          pitch;          ///< Pitch in pixels, of color buffer
1160     UINT_32          height;         ///< Height in pixels, of color buffer
1161     UINT_32          numSlices;      ///< Number of slices
1162     UINT_32          bpp;
1163     BOOL_32          isLinear;       ///< Linear or tiled layout, Only SI can be linear
1164     ADDR_CMASK_FLAGS flags;          ///< CMASK flags
1165     ADDR_TILEINFO*   pTileInfo;      ///< Tile info
1166
1167     INT_32           tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1168                                      ///< while the global useTileIndex is set to 1
1169     INT_32           macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1170                                      ///< README: When tileIndex is not -1, this must be valid
1171 } ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT;
1172
1173 /**
1174 ****************************************************************************************************
1175 *   ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
1176 *
1177 *   @brief
1178 *       Output structure for AddrComputeCmaskAddrFromCoord
1179 ****************************************************************************************************
1180 */
1181 typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
1182 {
1183     UINT_32 size;           ///< Size of this structure in bytes
1184
1185     UINT_64 addr;           ///< CMASK address in bytes
1186     UINT_32 bitPosition;    ///< Bit position within addr, 0-7. CMASK is 4 bpp,
1187                             ///  so the address may be located in bit 0 (0) or 4 (4)
1188 } ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT;
1189
1190 /**
1191 ****************************************************************************************************
1192 *   AddrComputeCmaskAddrFromCoord
1193 *
1194 *   @brief
1195 *       Compute Cmask address according to coordinates (of MSAA color buffer)
1196 ****************************************************************************************************
1197 */
1198 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
1199     ADDR_HANDLE                                     hLib,
1200     const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*   pIn,
1201     ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT*        pOut);
1202
1203
1204
1205 /**
1206 ****************************************************************************************************
1207 *   ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
1208 *
1209 *   @brief
1210 *       Input structure for AddrComputeCmaskCoordFromAddr
1211 ****************************************************************************************************
1212 */
1213 typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
1214 {
1215     UINT_32        size;            ///< Size of this structure in bytes
1216
1217     UINT_64        addr;            ///< CMASK address in bytes
1218     UINT_32        bitPosition;     ///< Bit position within addr, 0-7. CMASK is 4 bpp,
1219                                     ///  so the address may be located in bit 0 (0) or 4 (4)
1220     UINT_32        pitch;           ///< Pitch, in pixels
1221     UINT_32        height;          ///< Height in pixels
1222     UINT_32        numSlices;       ///< Number of slices
1223     BOOL_32        isLinear;        ///< Linear or tiled layout, Only SI can be linear
1224     ADDR_TILEINFO* pTileInfo;       ///< Tile info
1225
1226     INT_32         tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
1227                                     ///  while the global useTileIndex is set to 1
1228     INT_32         macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
1229                                     ///< README: When tileIndex is not -1, this must be valid
1230 } ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT;
1231
1232 /**
1233 ****************************************************************************************************
1234 *   ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
1235 *
1236 *   @brief
1237 *       Output structure for AddrComputeCmaskCoordFromAddr
1238 ****************************************************************************************************
1239 */
1240 typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
1241 {
1242     UINT_32 size;   ///< Size of this structure in bytes
1243
1244     UINT_32 x;      ///< X coordinate
1245     UINT_32 y;      ///< Y coordinate
1246     UINT_32 slice;  ///< Slice index
1247 } ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT;
1248
1249 /**
1250 ****************************************************************************************************
1251 *   AddrComputeCmaskCoordFromAddr
1252 *
1253 *   @brief
1254 *       Compute coordinates within color buffer (1st pixel of a micro tile) according to
1255 *       Cmask address
1256 ****************************************************************************************************
1257 */
1258 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
1259     ADDR_HANDLE                                     hLib,
1260     const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT*   pIn,
1261     ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT*        pOut);
1262
1263
1264
1265 ////////////////////////////////////////////////////////////////////////////////////////////////////
1266 //                                     F-mask functions
1267 ////////////////////////////////////////////////////////////////////////////////////////////////////
1268
1269 /**
1270 ****************************************************************************************************
1271 *   ADDR_COMPUTE_FMASK_INFO_INPUT
1272 *
1273 *   @brief
1274 *       Input structure for AddrComputeFmaskInfo
1275 ****************************************************************************************************
1276 */
1277 typedef struct _ADDR_COMPUTE_FMASK_INFO_INPUT
1278 {
1279     UINT_32         size;               ///< Size of this structure in bytes
1280
1281     AddrTileMode    tileMode;           ///< Tile mode
1282     UINT_32         pitch;              ///< Surface pitch, in pixels
1283     UINT_32         height;             ///< Surface height, in pixels
1284     UINT_32         numSlices;          ///< Number of slice/depth
1285     UINT_32         numSamples;         ///< Number of samples
1286     UINT_32         numFrags;           ///< Number of fragments, leave it zero or the same as
1287                                         ///  number of samples for normal AA; Set it to the
1288                                         ///  number of fragments for EQAA
1289     /// r800 and later HWL parameters
1290     struct
1291     {
1292         UINT_32 resolved:   1;          ///< TRUE if the surface is for resolved fmask, only used
1293                                         ///  by H/W clients. S/W should always set it to FALSE.
1294         UINT_32 reserved:  31;          ///< Reserved for future use.
1295     };
1296     ADDR_TILEINFO*  pTileInfo;          ///< 2D tiling parameters. Clients must give valid data
1297     INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
1298                                         ///  while the global useTileIndex is set to 1
1299 } ADDR_COMPUTE_FMASK_INFO_INPUT;
1300
1301 /**
1302 ****************************************************************************************************
1303 *   ADDR_COMPUTE_FMASK_INFO_OUTPUT
1304 *
1305 *   @brief
1306 *       Output structure for AddrComputeFmaskInfo
1307 ****************************************************************************************************
1308 */
1309 typedef struct _ADDR_COMPUTE_FMASK_INFO_OUTPUT
1310 {
1311     UINT_32         size;           ///< Size of this structure in bytes
1312
1313     UINT_32         pitch;          ///< Pitch of fmask in pixels
1314     UINT_32         height;         ///< Height of fmask in pixels
1315     UINT_32         numSlices;      ///< Slices of fmask
1316     UINT_64         fmaskBytes;     ///< Size of fmask in bytes
1317     UINT_32         baseAlign;      ///< Base address alignment
1318     UINT_32         pitchAlign;     ///< Pitch alignment
1319     UINT_32         heightAlign;    ///< Height alignment
1320     UINT_32         bpp;            ///< Bits per pixel of FMASK is: number of bit planes
1321     UINT_32         numSamples;     ///< Number of samples, used for dump, export this since input
1322                                     ///  may be changed in 9xx and above
1323     /// r800 and later HWL parameters
1324     ADDR_TILEINFO*  pTileInfo;      ///< Tile parameters used. Fmask can have different
1325                                     ///  bank_height from color buffer
1326     INT_32          tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1327                                     ///  while the global useTileIndex is set to 1
1328     INT_32          macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1329     UINT_64         sliceSize;      ///< Size of slice in bytes
1330 } ADDR_COMPUTE_FMASK_INFO_OUTPUT;
1331
1332 /**
1333 ****************************************************************************************************
1334 *   AddrComputeFmaskInfo
1335 *
1336 *   @brief
1337 *       Compute Fmask pitch/height/depth/alignments and size in bytes
1338 ****************************************************************************************************
1339 */
1340 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
1341     ADDR_HANDLE                             hLib,
1342     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,
1343     ADDR_COMPUTE_FMASK_INFO_OUTPUT*         pOut);
1344
1345
1346
1347 /**
1348 ****************************************************************************************************
1349 *   ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
1350 *
1351 *   @brief
1352 *       Input structure for AddrComputeFmaskAddrFromCoord
1353 ****************************************************************************************************
1354 */
1355 typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
1356 {
1357     UINT_32         size;               ///< Size of this structure in bytes
1358
1359     UINT_32         x;                  ///< X coordinate
1360     UINT_32         y;                  ///< Y coordinate
1361     UINT_32         slice;              ///< Slice index
1362     UINT_32         plane;              ///< Plane number
1363     UINT_32         sample;             ///< Sample index (fragment index for EQAA)
1364
1365     UINT_32         pitch;              ///< Surface pitch, in pixels
1366     UINT_32         height;             ///< Surface height, in pixels
1367     UINT_32         numSamples;         ///< Number of samples
1368     UINT_32         numFrags;           ///< Number of fragments, leave it zero or the same as
1369                                         ///  number of samples for normal AA; Set it to the
1370                                         ///  number of fragments for EQAA
1371
1372     AddrTileMode    tileMode;           ///< Tile mode
1373     union
1374     {
1375         struct
1376         {
1377             UINT_32  bankSwizzle;       ///< Bank swizzle
1378             UINT_32  pipeSwizzle;       ///< Pipe swizzle
1379         };
1380         UINT_32     tileSwizzle;        ///< Combined swizzle, if useCombinedSwizzle is TRUE
1381     };
1382
1383     /// r800 and later HWL parameters
1384     struct
1385     {
1386         UINT_32 resolved:   1;          ///< TRUE if this is a resolved fmask, used by H/W clients
1387         UINT_32 ignoreSE:   1;          ///< TRUE if shader engines are ignored.
1388         UINT_32 reserved:  30;          ///< Reserved for future use.
1389     };
1390     ADDR_TILEINFO*  pTileInfo;          ///< 2D tiling parameters. Client must provide all data
1391
1392 } ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT;
1393
1394 /**
1395 ****************************************************************************************************
1396 *   ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
1397 *
1398 *   @brief
1399 *       Output structure for AddrComputeFmaskAddrFromCoord
1400 ****************************************************************************************************
1401 */
1402 typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
1403 {
1404     UINT_32 size;           ///< Size of this structure in bytes
1405
1406     UINT_64 addr;           ///< Fmask address
1407     UINT_32 bitPosition;    ///< Bit position within fmaskAddr, 0-7.
1408 } ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT;
1409
1410 /**
1411 ****************************************************************************************************
1412 *   AddrComputeFmaskAddrFromCoord
1413 *
1414 *   @brief
1415 *       Compute Fmask address according to coordinates (x,y,slice,sample,plane)
1416 ****************************************************************************************************
1417 */
1418 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
1419     ADDR_HANDLE                                     hLib,
1420     const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,
1421     ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*        pOut);
1422
1423
1424
1425 /**
1426 ****************************************************************************************************
1427 *   ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
1428 *
1429 *   @brief
1430 *       Input structure for AddrComputeFmaskCoordFromAddr
1431 ****************************************************************************************************
1432 */
1433 typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
1434 {
1435     UINT_32         size;               ///< Size of this structure in bytes
1436
1437     UINT_64         addr;               ///< Address
1438     UINT_32         bitPosition;        ///< Bit position within addr, 0-7.
1439
1440     UINT_32         pitch;              ///< Pitch, in pixels
1441     UINT_32         height;             ///< Height in pixels
1442     UINT_32         numSamples;         ///< Number of samples
1443     UINT_32         numFrags;           ///< Number of fragments
1444     AddrTileMode    tileMode;           ///< Tile mode
1445     union
1446     {
1447         struct
1448         {
1449             UINT_32  bankSwizzle;       ///< Bank swizzle
1450             UINT_32  pipeSwizzle;       ///< Pipe swizzle
1451         };
1452         UINT_32     tileSwizzle;        ///< Combined swizzle, if useCombinedSwizzle is TRUE
1453     };
1454
1455     /// r800 and later HWL parameters
1456     struct
1457     {
1458         UINT_32 resolved:   1;          ///< TRUE if this is a resolved fmask, used by HW components
1459         UINT_32 ignoreSE:   1;          ///< TRUE if shader engines are ignored.
1460         UINT_32 reserved:  30;          ///< Reserved for future use.
1461     };
1462     ADDR_TILEINFO*  pTileInfo;          ///< 2D tile parameters. Client must provide all data
1463
1464 } ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT;
1465
1466 /**
1467 ****************************************************************************************************
1468 *   ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
1469 *
1470 *   @brief
1471 *       Output structure for AddrComputeFmaskCoordFromAddr
1472 ****************************************************************************************************
1473 */
1474 typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
1475 {
1476     UINT_32 size;       ///< Size of this structure in bytes
1477
1478     UINT_32 x;          ///< X coordinate
1479     UINT_32 y;          ///< Y coordinate
1480     UINT_32 slice;      ///< Slice index
1481     UINT_32 plane;      ///< Plane number
1482     UINT_32 sample;     ///< Sample index (fragment index for EQAA)
1483 } ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT;
1484
1485 /**
1486 ****************************************************************************************************
1487 *   AddrComputeFmaskCoordFromAddr
1488 *
1489 *   @brief
1490 *       Compute FMASK coordinate from an given address
1491 ****************************************************************************************************
1492 */
1493 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
1494     ADDR_HANDLE                                     hLib,
1495     const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*   pIn,
1496     ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT*        pOut);
1497
1498
1499
1500 ////////////////////////////////////////////////////////////////////////////////////////////////////
1501 //                          Element/utility functions
1502 ////////////////////////////////////////////////////////////////////////////////////////////////////
1503
1504 /**
1505 ****************************************************************************************************
1506 *   AddrGetVersion
1507 *
1508 *   @brief
1509 *       Get AddrLib version number
1510 ****************************************************************************************************
1511 */
1512 UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib);
1513
1514 /**
1515 ****************************************************************************************************
1516 *   AddrUseTileIndex
1517 *
1518 *   @brief
1519 *       Return TRUE if tileIndex is enabled in this address library
1520 ****************************************************************************************************
1521 */
1522 BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib);
1523
1524 /**
1525 ****************************************************************************************************
1526 *   AddrUseCombinedSwizzle
1527 *
1528 *   @brief
1529 *       Return TRUE if combined swizzle is enabled in this address library
1530 ****************************************************************************************************
1531 */
1532 BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib);
1533
1534 /**
1535 ****************************************************************************************************
1536 *   ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
1537 *
1538 *   @brief
1539 *       Input structure of AddrExtractBankPipeSwizzle
1540 ****************************************************************************************************
1541 */
1542 typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
1543 {
1544     UINT_32         size;           ///< Size of this structure in bytes
1545
1546     UINT_32         base256b;       ///< Base256b value
1547
1548     /// r800 and later HWL parameters
1549     ADDR_TILEINFO*  pTileInfo;      ///< 2D tile parameters. Client must provide all data
1550
1551     INT_32          tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1552                                     ///  while the global useTileIndex is set to 1
1553     INT_32          macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1554                                     ///< README: When tileIndex is not -1, this must be valid
1555 } ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT;
1556
1557 /**
1558 ****************************************************************************************************
1559 *   ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
1560 *
1561 *   @brief
1562 *       Output structure of AddrExtractBankPipeSwizzle
1563 ****************************************************************************************************
1564 */
1565 typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
1566 {
1567     UINT_32 size;           ///< Size of this structure in bytes
1568
1569     UINT_32 bankSwizzle;    ///< Bank swizzle
1570     UINT_32 pipeSwizzle;    ///< Pipe swizzle
1571 } ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT;
1572
1573 /**
1574 ****************************************************************************************************
1575 *   AddrExtractBankPipeSwizzle
1576 *
1577 *   @brief
1578 *       Extract Bank and Pipe swizzle from base256b
1579 *   @return
1580 *       ADDR_OK if no error
1581 ****************************************************************************************************
1582 */
1583 ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
1584     ADDR_HANDLE                                 hLib,
1585     const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT*  pIn,
1586     ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT*       pOut);
1587
1588
1589 /**
1590 ****************************************************************************************************
1591 *   ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
1592 *
1593 *   @brief
1594 *       Input structure of AddrCombineBankPipeSwizzle
1595 ****************************************************************************************************
1596 */
1597 typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
1598 {
1599     UINT_32         size;           ///< Size of this structure in bytes
1600
1601     UINT_32         bankSwizzle;    ///< Bank swizzle
1602     UINT_32         pipeSwizzle;    ///< Pipe swizzle
1603     UINT_64         baseAddr;       ///< Base address (leave it zero for driver clients)
1604
1605     /// r800 and later HWL parameters
1606     ADDR_TILEINFO*  pTileInfo;      ///< 2D tile parameters. Client must provide all data
1607
1608     INT_32          tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1609                                     ///  while the global useTileIndex is set to 1
1610     INT_32          macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1611                                     ///< README: When tileIndex is not -1, this must be valid
1612 } ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT;
1613
1614 /**
1615 ****************************************************************************************************
1616 *   ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
1617 *
1618 *   @brief
1619 *       Output structure of AddrCombineBankPipeSwizzle
1620 ****************************************************************************************************
1621 */
1622 typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
1623 {
1624     UINT_32 size;           ///< Size of this structure in bytes
1625
1626     UINT_32 tileSwizzle;    ///< Combined swizzle
1627 } ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT;
1628
1629 /**
1630 ****************************************************************************************************
1631 *   AddrCombineBankPipeSwizzle
1632 *
1633 *   @brief
1634 *       Combine Bank and Pipe swizzle
1635 *   @return
1636 *       ADDR_OK if no error
1637 *   @note
1638 *       baseAddr here is full MCAddress instead of base256b
1639 ****************************************************************************************************
1640 */
1641 ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
1642     ADDR_HANDLE                                 hLib,
1643     const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT*  pIn,
1644     ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT*       pOut);
1645
1646
1647
1648 /**
1649 ****************************************************************************************************
1650 *   ADDR_COMPUTE_SLICESWIZZLE_INPUT
1651 *
1652 *   @brief
1653 *       Input structure of AddrComputeSliceSwizzle
1654 ****************************************************************************************************
1655 */
1656 typedef struct _ADDR_COMPUTE_SLICESWIZZLE_INPUT
1657 {
1658     UINT_32         size;               ///< Size of this structure in bytes
1659
1660     AddrTileMode    tileMode;           ///< Tile Mode
1661     UINT_32         baseSwizzle;        ///< Base tile swizzle
1662     UINT_32         slice;              ///< Slice index
1663     UINT_64         baseAddr;           ///< Base address, driver should leave it 0 in most cases
1664
1665     /// r800 and later HWL parameters
1666     ADDR_TILEINFO*  pTileInfo;          ///< 2D tile parameters. Actually banks needed here!
1667
1668     INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
1669                                         ///  while the global useTileIndex is set to 1
1670     INT_32          macroModeIndex;     ///< Index in macro tile mode table if there is one (CI)
1671                                         ///< README: When tileIndex is not -1, this must be valid
1672 } ADDR_COMPUTE_SLICESWIZZLE_INPUT;
1673
1674
1675
1676 /**
1677 ****************************************************************************************************
1678 *   ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
1679 *
1680 *   @brief
1681 *       Output structure of AddrComputeSliceSwizzle
1682 ****************************************************************************************************
1683 */
1684 typedef struct _ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
1685 {
1686     UINT_32  size;           ///< Size of this structure in bytes
1687
1688     UINT_32  tileSwizzle;    ///< Recalculated tileSwizzle value
1689 } ADDR_COMPUTE_SLICESWIZZLE_OUTPUT;
1690
1691 /**
1692 ****************************************************************************************************
1693 *   AddrComputeSliceSwizzle
1694 *
1695 *   @brief
1696 *       Extract Bank and Pipe swizzle from base256b
1697 *   @return
1698 *       ADDR_OK if no error
1699 ****************************************************************************************************
1700 */
1701 ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
1702     ADDR_HANDLE                             hLib,
1703     const ADDR_COMPUTE_SLICESWIZZLE_INPUT*  pIn,
1704     ADDR_COMPUTE_SLICESWIZZLE_OUTPUT*       pOut);
1705
1706
1707 /**
1708 ****************************************************************************************************
1709 *   AddrSwizzleGenOption
1710 *
1711 *   @brief
1712 *       Which swizzle generating options: legacy or linear
1713 ****************************************************************************************************
1714 */
1715 typedef enum _AddrSwizzleGenOption
1716 {
1717     ADDR_SWIZZLE_GEN_DEFAULT    = 0,    ///< As is in client driver implemention for swizzle
1718     ADDR_SWIZZLE_GEN_LINEAR     = 1,    ///< Using a linear increment of swizzle
1719 } AddrSwizzleGenOption;
1720
1721 /**
1722 ****************************************************************************************************
1723 *   AddrSwizzleOption
1724 *
1725 *   @brief
1726 *       Controls how swizzle is generated
1727 ****************************************************************************************************
1728 */
1729 typedef union _ADDR_SWIZZLE_OPTION
1730 {
1731     struct
1732     {
1733         UINT_32 genOption       : 1;    ///< The way swizzle is generated, see AddrSwizzleGenOption
1734         UINT_32 reduceBankBit   : 1;    ///< TRUE if we need reduce swizzle bits
1735         UINT_32 reserved        :30;    ///< Reserved bits
1736     };
1737
1738     UINT_32 value;
1739
1740 } ADDR_SWIZZLE_OPTION;
1741
1742 /**
1743 ****************************************************************************************************
1744 *   ADDR_COMPUTE_BASE_SWIZZLE_INPUT
1745 *
1746 *   @brief
1747 *       Input structure of AddrComputeBaseSwizzle
1748 ****************************************************************************************************
1749 */
1750 typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_INPUT
1751 {
1752     UINT_32             size;           ///< Size of this structure in bytes
1753
1754     ADDR_SWIZZLE_OPTION option;         ///< Swizzle option
1755     UINT_32             surfIndex;      ///< Index of this surface type
1756     AddrTileMode        tileMode;       ///< Tile Mode
1757
1758     /// r800 and later HWL parameters
1759     ADDR_TILEINFO*      pTileInfo;      ///< 2D tile parameters. Actually banks needed here!
1760
1761     INT_32              tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1762                                         ///  while the global useTileIndex is set to 1
1763     INT_32              macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1764                                         ///< README: When tileIndex is not -1, this must be valid
1765 } ADDR_COMPUTE_BASE_SWIZZLE_INPUT;
1766
1767 /**
1768 ****************************************************************************************************
1769 *   ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
1770 *
1771 *   @brief
1772 *       Output structure of AddrComputeBaseSwizzle
1773 ****************************************************************************************************
1774 */
1775 typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
1776 {
1777     UINT_32 size;           ///< Size of this structure in bytes
1778
1779     UINT_32 tileSwizzle;    ///< Combined swizzle
1780 } ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT;
1781
1782 /**
1783 ****************************************************************************************************
1784 *   AddrComputeBaseSwizzle
1785 *
1786 *   @brief
1787 *       Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
1788 *   @return
1789 *       ADDR_OK if no error
1790 ****************************************************************************************************
1791 */
1792 ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
1793     ADDR_HANDLE                             hLib,
1794     const ADDR_COMPUTE_BASE_SWIZZLE_INPUT*  pIn,
1795     ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT*       pOut);
1796
1797
1798
1799 /**
1800 ****************************************************************************************************
1801 *   ELEM_GETEXPORTNORM_INPUT
1802 *
1803 *   @brief
1804 *       Input structure for ElemGetExportNorm
1805 *
1806 ****************************************************************************************************
1807 */
1808 typedef struct _ELEM_GETEXPORTNORM_INPUT
1809 {
1810     UINT_32             size;       ///< Size of this structure in bytes
1811
1812     AddrColorFormat     format;     ///< Color buffer format; Client should use ColorFormat
1813     AddrSurfaceNumber   num;        ///< Surface number type; Client should use NumberType
1814     AddrSurfaceSwap     swap;       ///< Surface swap byte swap; Client should use SurfaceSwap
1815     UINT_32             numSamples; ///< Number of samples
1816 } ELEM_GETEXPORTNORM_INPUT;
1817
1818 /**
1819 ****************************************************************************************************
1820 *  ElemGetExportNorm
1821 *
1822 *   @brief
1823 *       Helper function to check one format can be EXPORT_NUM, which is a register
1824 *       CB_COLOR_INFO.SURFACE_FORMAT. FP16 can be reported as EXPORT_NORM for rv770 in r600
1825 *       family
1826 *   @note
1827 *       The implementation is only for r600.
1828 *       00 - EXPORT_FULL: PS exports are 4 pixels with 4 components with 32-bits-per-component. (two
1829 *       clocks per export)
1830 *       01 - EXPORT_NORM: PS exports are 4 pixels with 4 components with 16-bits-per-component. (one
1831 *       clock per export)
1832 *
1833 ****************************************************************************************************
1834 */
1835 BOOL_32 ADDR_API ElemGetExportNorm(
1836     ADDR_HANDLE                     hLib,
1837     const ELEM_GETEXPORTNORM_INPUT* pIn);
1838
1839
1840
1841 /**
1842 ****************************************************************************************************
1843 *   ELEM_FLT32TODEPTHPIXEL_INPUT
1844 *
1845 *   @brief
1846 *       Input structure for addrFlt32ToDepthPixel
1847 *
1848 ****************************************************************************************************
1849 */
1850 typedef struct _ELEM_FLT32TODEPTHPIXEL_INPUT
1851 {
1852     UINT_32         size;           ///< Size of this structure in bytes
1853
1854     AddrDepthFormat format;         ///< Depth buffer format
1855     ADDR_FLT_32     comps[2];       ///< Component values (Z/stencil)
1856 } ELEM_FLT32TODEPTHPIXEL_INPUT;
1857
1858 /**
1859 ****************************************************************************************************
1860 *   ELEM_FLT32TODEPTHPIXEL_INPUT
1861 *
1862 *   @brief
1863 *       Output structure for ElemFlt32ToDepthPixel
1864 *
1865 ****************************************************************************************************
1866 */
1867 typedef struct _ELEM_FLT32TODEPTHPIXEL_OUTPUT
1868 {
1869     UINT_32 size;           ///< Size of this structure in bytes
1870
1871     UINT_8* pPixel;         ///< Real depth value. Same data type as depth buffer.
1872                             ///  Client must provide enough storage for this type.
1873     UINT_32 depthBase;      ///< Tile base in bits for depth bits
1874     UINT_32 stencilBase;    ///< Tile base in bits for stencil bits
1875     UINT_32 depthBits;      ///< Bits for depth
1876     UINT_32 stencilBits;    ///< Bits for stencil
1877 } ELEM_FLT32TODEPTHPIXEL_OUTPUT;
1878
1879 /**
1880 ****************************************************************************************************
1881 *   ElemFlt32ToDepthPixel
1882 *
1883 *   @brief
1884 *       Convert a FLT_32 value to a depth/stencil pixel value
1885 *
1886 *   @return
1887 *       Return code
1888 *
1889 ****************************************************************************************************
1890 */
1891 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
1892     ADDR_HANDLE                         hLib,
1893     const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,
1894     ELEM_FLT32TODEPTHPIXEL_OUTPUT*      pOut);
1895
1896
1897
1898 /**
1899 ****************************************************************************************************
1900 *   ELEM_FLT32TOCOLORPIXEL_INPUT
1901 *
1902 *   @brief
1903 *       Input structure for addrFlt32ToColorPixel
1904 *
1905 ****************************************************************************************************
1906 */
1907 typedef struct _ELEM_FLT32TOCOLORPIXEL_INPUT
1908 {
1909     UINT_32            size;           ///< Size of this structure in bytes
1910
1911     AddrColorFormat    format;         ///< Color buffer format
1912     AddrSurfaceNumber  surfNum;        ///< Surface number
1913     AddrSurfaceSwap    surfSwap;       ///< Surface swap
1914     ADDR_FLT_32        comps[4];       ///< Component values (r/g/b/a)
1915 } ELEM_FLT32TOCOLORPIXEL_INPUT;
1916
1917 /**
1918 ****************************************************************************************************
1919 *   ELEM_FLT32TOCOLORPIXEL_INPUT
1920 *
1921 *   @brief
1922 *       Output structure for ElemFlt32ToColorPixel
1923 *
1924 ****************************************************************************************************
1925 */
1926 typedef struct _ELEM_FLT32TOCOLORPIXEL_OUTPUT
1927 {
1928     UINT_32 size;       ///< Size of this structure in bytes
1929
1930     UINT_8* pPixel;     ///< Real color value. Same data type as color buffer.
1931                         ///  Client must provide enough storage for this type.
1932 } ELEM_FLT32TOCOLORPIXEL_OUTPUT;
1933
1934 /**
1935 ****************************************************************************************************
1936 *   ElemFlt32ToColorPixel
1937 *
1938 *   @brief
1939 *       Convert a FLT_32 value to a red/green/blue/alpha pixel value
1940 *
1941 *   @return
1942 *       Return code
1943 *
1944 ****************************************************************************************************
1945 */
1946 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
1947     ADDR_HANDLE                         hLib,
1948     const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,
1949     ELEM_FLT32TOCOLORPIXEL_OUTPUT*      pOut);
1950
1951
1952 /**
1953 ****************************************************************************************************
1954 *   ADDR_CONVERT_TILEINFOTOHW_INPUT
1955 *
1956 *   @brief
1957 *       Input structure for AddrConvertTileInfoToHW
1958 *   @note
1959 *       When reverse is TRUE, indices are igonred
1960 ****************************************************************************************************
1961 */
1962 typedef struct _ADDR_CONVERT_TILEINFOTOHW_INPUT
1963 {
1964     UINT_32         size;               ///< Size of this structure in bytes
1965     BOOL_32         reverse;            ///< Convert control flag.
1966                                         ///  FALSE: convert from real value to HW value;
1967                                         ///  TRUE: convert from HW value to real value.
1968
1969     /// r800 and later HWL parameters
1970     ADDR_TILEINFO*  pTileInfo;          ///< Tile parameters with real value
1971
1972     INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
1973                                         ///  while the global useTileIndex is set to 1
1974     INT_32          macroModeIndex;     ///< Index in macro tile mode table if there is one (CI)
1975                                         ///< README: When tileIndex is not -1, this must be valid
1976     UINT_32         bpp;                ///< Bits per pixel
1977 } ADDR_CONVERT_TILEINFOTOHW_INPUT;
1978
1979 /**
1980 ****************************************************************************************************
1981 *   ADDR_CONVERT_TILEINFOTOHW_OUTPUT
1982 *
1983 *   @brief
1984 *       Output structure for AddrConvertTileInfoToHW
1985 ****************************************************************************************************
1986 */
1987 typedef struct _ADDR_CONVERT_TILEINFOTOHW_OUTPUT
1988 {
1989     UINT_32             size;               ///< Size of this structure in bytes
1990
1991     /// r800 and later HWL parameters
1992     ADDR_TILEINFO*      pTileInfo;          ///< Tile parameters with hardware register value
1993
1994 } ADDR_CONVERT_TILEINFOTOHW_OUTPUT;
1995
1996 /**
1997 ****************************************************************************************************
1998 *   AddrConvertTileInfoToHW
1999 *
2000 *   @brief
2001 *       Convert tile info from real value to hardware register value
2002 ****************************************************************************************************
2003 */
2004 ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
2005     ADDR_HANDLE                             hLib,
2006     const ADDR_CONVERT_TILEINFOTOHW_INPUT*  pIn,
2007     ADDR_CONVERT_TILEINFOTOHW_OUTPUT*       pOut);
2008
2009
2010
2011 /**
2012 ****************************************************************************************************
2013 *   ADDR_CONVERT_TILEINDEX_INPUT
2014 *
2015 *   @brief
2016 *       Input structure for AddrConvertTileIndex
2017 ****************************************************************************************************
2018 */
2019 typedef struct _ADDR_CONVERT_TILEINDEX_INPUT
2020 {
2021     UINT_32         size;               ///< Size of this structure in bytes
2022
2023     INT_32          tileIndex;          ///< Tile index
2024     INT_32          macroModeIndex;     ///< Index in macro tile mode table if there is one (CI)
2025     UINT_32         bpp;                ///< Bits per pixel
2026     BOOL_32         tileInfoHw;         ///< Set to TRUE if client wants HW enum, otherwise actual
2027 } ADDR_CONVERT_TILEINDEX_INPUT;
2028
2029 /**
2030 ****************************************************************************************************
2031 *   ADDR_CONVERT_TILEINDEX_OUTPUT
2032 *
2033 *   @brief
2034 *       Output structure for AddrConvertTileIndex
2035 ****************************************************************************************************
2036 */
2037 typedef struct _ADDR_CONVERT_TILEINDEX_OUTPUT
2038 {
2039     UINT_32             size;           ///< Size of this structure in bytes
2040
2041     AddrTileMode        tileMode;       ///< Tile mode
2042     AddrTileType        tileType;       ///< Tile type
2043     ADDR_TILEINFO*      pTileInfo;      ///< Tile info
2044
2045 } ADDR_CONVERT_TILEINDEX_OUTPUT;
2046
2047 /**
2048 ****************************************************************************************************
2049 *   AddrConvertTileIndex
2050 *
2051 *   @brief
2052 *       Convert tile index to tile mode/type/info
2053 ****************************************************************************************************
2054 */
2055 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
2056     ADDR_HANDLE                         hLib,
2057     const ADDR_CONVERT_TILEINDEX_INPUT* pIn,
2058     ADDR_CONVERT_TILEINDEX_OUTPUT*      pOut);
2059
2060 /**
2061 ****************************************************************************************************
2062 *   ADDR_GET_MACROMODEINDEX_INPUT
2063 *
2064 *   @brief
2065 *       Input structure for AddrGetMacroModeIndex
2066 ****************************************************************************************************
2067 */
2068 typedef struct _ADDR_GET_MACROMODEINDEX_INPUT
2069 {
2070     UINT_32             size;               ///< Size of this structure in bytes
2071     ADDR_SURFACE_FLAGS  flags;              ///< Surface flag
2072     INT_32              tileIndex;          ///< Tile index
2073     UINT_32             bpp;                ///< Bits per pixel
2074     UINT_32             numFrags;           ///< Number of color fragments
2075 } ADDR_GET_MACROMODEINDEX_INPUT;
2076
2077 /**
2078 ****************************************************************************************************
2079 *   ADDR_GET_MACROMODEINDEX_OUTPUT
2080 *
2081 *   @brief
2082 *       Output structure for AddrGetMacroModeIndex
2083 ****************************************************************************************************
2084 */
2085 typedef struct _ADDR_GET_MACROMODEINDEX_OUTPUT
2086 {
2087     UINT_32             size;            ///< Size of this structure in bytes
2088     INT_32              macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
2089 } ADDR_GET_MACROMODEINDEX_OUTPUT;
2090
2091 /**
2092 ****************************************************************************************************
2093 *   AddrGetMacroModeIndex
2094 *
2095 *   @brief
2096 *       Get macro mode index based on input parameters
2097 ****************************************************************************************************
2098 */
2099 ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
2100     ADDR_HANDLE                          hLib,
2101     const ADDR_GET_MACROMODEINDEX_INPUT* pIn,
2102     ADDR_GET_MACROMODEINDEX_OUTPUT*      pOut);
2103
2104 /**
2105 ****************************************************************************************************
2106 *   ADDR_CONVERT_TILEINDEX1_INPUT
2107 *
2108 *   @brief
2109 *       Input structure for AddrConvertTileIndex1 (without macro mode index)
2110 ****************************************************************************************************
2111 */
2112 typedef struct _ADDR_CONVERT_TILEINDEX1_INPUT
2113 {
2114     UINT_32         size;               ///< Size of this structure in bytes
2115
2116     INT_32          tileIndex;          ///< Tile index
2117     UINT_32         bpp;                ///< Bits per pixel
2118     UINT_32         numSamples;         ///< Number of samples
2119     BOOL_32         tileInfoHw;         ///< Set to TRUE if client wants HW enum, otherwise actual
2120 } ADDR_CONVERT_TILEINDEX1_INPUT;
2121
2122 /**
2123 ****************************************************************************************************
2124 *   AddrConvertTileIndex1
2125 *
2126 *   @brief
2127 *       Convert tile index to tile mode/type/info
2128 ****************************************************************************************************
2129 */
2130 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
2131     ADDR_HANDLE                             hLib,
2132     const ADDR_CONVERT_TILEINDEX1_INPUT*    pIn,
2133     ADDR_CONVERT_TILEINDEX_OUTPUT*          pOut);
2134
2135
2136
2137 /**
2138 ****************************************************************************************************
2139 *   ADDR_GET_TILEINDEX_INPUT
2140 *
2141 *   @brief
2142 *       Input structure for AddrGetTileIndex
2143 ****************************************************************************************************
2144 */
2145 typedef struct _ADDR_GET_TILEINDEX_INPUT
2146 {
2147     UINT_32         size;           ///< Size of this structure in bytes
2148
2149     AddrTileMode    tileMode;       ///< Tile mode
2150     AddrTileType    tileType;       ///< Tile-type: disp/non-disp/...
2151     ADDR_TILEINFO*  pTileInfo;      ///< Pointer to tile-info structure, can be NULL for linear/1D
2152 } ADDR_GET_TILEINDEX_INPUT;
2153
2154 /**
2155 ****************************************************************************************************
2156 *   ADDR_GET_TILEINDEX_OUTPUT
2157 *
2158 *   @brief
2159 *       Output structure for AddrGetTileIndex
2160 ****************************************************************************************************
2161 */
2162 typedef struct _ADDR_GET_TILEINDEX_OUTPUT
2163 {
2164     UINT_32         size;           ///< Size of this structure in bytes
2165
2166     INT_32          index;          ///< index in table
2167 } ADDR_GET_TILEINDEX_OUTPUT;
2168
2169 /**
2170 ****************************************************************************************************
2171 *   AddrGetTileIndex
2172 *
2173 *   @brief
2174 *       Get the tiling mode index in table
2175 ****************************************************************************************************
2176 */
2177 ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
2178     ADDR_HANDLE                     hLib,
2179     const ADDR_GET_TILEINDEX_INPUT* pIn,
2180     ADDR_GET_TILEINDEX_OUTPUT*      pOut);
2181
2182
2183
2184
2185 /**
2186 ****************************************************************************************************
2187 *   ADDR_PRT_INFO_INPUT
2188 *
2189 *   @brief
2190 *       Input structure for AddrComputePrtInfo
2191 ****************************************************************************************************
2192 */
2193 typedef struct _ADDR_PRT_INFO_INPUT
2194 {
2195     AddrFormat          format;        ///< Surface format
2196     UINT_32             baseMipWidth;  ///< Base mipmap width
2197     UINT_32             baseMipHeight; ///< Base mipmap height
2198     UINT_32             baseMipDepth;  ///< Base mipmap depth
2199     UINT_32             numFrags;      ///< Number of fragments,
2200 } ADDR_PRT_INFO_INPUT;
2201
2202 /**
2203 ****************************************************************************************************
2204 *   ADDR_PRT_INFO_OUTPUT
2205 *
2206 *   @brief
2207 *       Input structure for AddrComputePrtInfo
2208 ****************************************************************************************************
2209 */
2210 typedef struct _ADDR_PRT_INFO_OUTPUT
2211 {
2212     UINT_32             prtTileWidth;
2213     UINT_32             prtTileHeight;
2214 } ADDR_PRT_INFO_OUTPUT;
2215
2216 /**
2217 ****************************************************************************************************
2218 *   AddrComputePrtInfo
2219 *
2220 *   @brief
2221 *       Compute prt surface related information
2222 ****************************************************************************************************
2223 */
2224 ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
2225     ADDR_HANDLE                 hLib,
2226     const ADDR_PRT_INFO_INPUT*  pIn,
2227     ADDR_PRT_INFO_OUTPUT*       pOut);
2228
2229 ////////////////////////////////////////////////////////////////////////////////////////////////////
2230 //                                     DCC key functions
2231 ////////////////////////////////////////////////////////////////////////////////////////////////////
2232
2233 /**
2234 ****************************************************************************************************
2235 *   _ADDR_COMPUTE_DCCINFO_INPUT
2236 *
2237 *   @brief
2238 *       Input structure of AddrComputeDccInfo
2239 ****************************************************************************************************
2240 */
2241 typedef struct _ADDR_COMPUTE_DCCINFO_INPUT
2242 {
2243     UINT_32             size;            ///< Size of this structure in bytes
2244     UINT_32             bpp;             ///< BitPP of color surface
2245     UINT_32             numSamples;      ///< Sample number of color surface
2246     UINT_64             colorSurfSize;   ///< Size of color surface to which dcc key is bound
2247     AddrTileMode        tileMode;        ///< Tile mode of color surface
2248     ADDR_TILEINFO       tileInfo;        ///< Tile info of color surface
2249     UINT_32             tileSwizzle;     ///< Tile swizzle
2250     INT_32              tileIndex;       ///< Tile index of color surface,
2251                                          ///< MUST be -1 if you don't want to use it
2252                                          ///< while the global useTileIndex is set to 1
2253     INT_32              macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
2254                                          ///< README: When tileIndex is not -1, this must be valid
2255 } ADDR_COMPUTE_DCCINFO_INPUT;
2256
2257 /**
2258 ****************************************************************************************************
2259 *   ADDR_COMPUTE_DCCINFO_OUTPUT
2260 *
2261 *   @brief
2262 *       Output structure of AddrComputeDccInfo
2263 ****************************************************************************************************
2264 */
2265 typedef struct _ADDR_COMPUTE_DCCINFO_OUTPUT
2266 {
2267     UINT_32 size;                 ///< Size of this structure in bytes
2268     UINT_64 dccRamBaseAlign;      ///< Base alignment of dcc key
2269     UINT_64 dccRamSize;           ///< Size of dcc key
2270     UINT_64 dccFastClearSize;     ///< Size of dcc key portion that can be fast cleared
2271     BOOL_32 subLvlCompressible;   ///< Whether sub resource is compressiable
2272     BOOL_32 dccRamSizeAligned;    ///< Whether the dcc key size is aligned
2273 } ADDR_COMPUTE_DCCINFO_OUTPUT;
2274
2275 /**
2276 ****************************************************************************************************
2277 *   AddrComputeDccInfo
2278 *
2279 *   @brief
2280 *       Compute DCC key size, base alignment
2281 *       info
2282 ****************************************************************************************************
2283 */
2284 ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
2285     ADDR_HANDLE                             hLib,
2286     const ADDR_COMPUTE_DCCINFO_INPUT*       pIn,
2287     ADDR_COMPUTE_DCCINFO_OUTPUT*            pOut);
2288
2289 /**
2290 ****************************************************************************************************
2291 *   ADDR_GET_MAX_ALINGMENTS_OUTPUT
2292 *
2293 *   @brief
2294 *       Output structure of AddrGetMaxAlignments
2295 ****************************************************************************************************
2296 */
2297 typedef struct _ADDR_GET_MAX_ALINGMENTS_OUTPUT
2298 {
2299     UINT_32 size;                   ///< Size of this structure in bytes
2300     UINT_64 baseAlign;              ///< Maximum base alignment in bytes
2301 } ADDR_GET_MAX_ALINGMENTS_OUTPUT;
2302
2303 /**
2304 ****************************************************************************************************
2305 *   AddrGetMaxAlignments
2306 *
2307 *   @brief
2308 *       Gets maximnum alignments
2309 ****************************************************************************************************
2310 */
2311 ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
2312     ADDR_HANDLE                     hLib,
2313     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut);
2314
2315 #if defined(__cplusplus)
2316 }
2317 #endif
2318
2319 #endif // __ADDR_INTERFACE_H__
2320
2321