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 } ADDR_COMPUTE_HTILE_INFO_OUTPUT;
 910
 911 /**
 912 ****************************************************************************************************
 913 *   AddrComputeHtileInfo
 914 *
 915 *   @brief
 916 *       Compute Htile pitch, height, base alignment and size in bytes
 917 ****************************************************************************************************
 918 */
 919 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
 920     ADDR_HANDLE                             hLib,
 921     const ADDR_COMPUTE_HTILE_INFO_INPUT*    pIn,
 922     ADDR_COMPUTE_HTILE_INFO_OUTPUT*         pOut);
 923
 924
 925
 926 /**
 927 ****************************************************************************************************
 928 *   ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
 929 *
 930 *   @brief
 931 *       Input structure for AddrComputeHtileAddrFromCoord
 932 ****************************************************************************************************
 933 */
 934 typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
 935 {
 936     UINT_32            size;            ///< Size of this structure in bytes
 937
 938     UINT_32            pitch;           ///< Pitch, in pixels
 939     UINT_32            height;          ///< Height in pixels
 940     UINT_32            x;               ///< X coordinate
 941     UINT_32            y;               ///< Y coordinate
 942     UINT_32            slice;           ///< Index of slice
 943     UINT_32            numSlices;       ///< Number of slices
 944     BOOL_32            isLinear;        ///< Linear or tiled HTILE layout
 945     ADDR_HTILE_FLAGS   flags;           ///< htile flags
 946     AddrHtileBlockSize blockWidth;      ///< 4 or 8. 1 means 8, 0 means 4. EG above only support 8
 947     AddrHtileBlockSize blockHeight;     ///< 4 or 8. 1 means 8, 0 means 4. EG above only support 8
 948     ADDR_TILEINFO*     pTileInfo;       ///< Tile info
 949
 950     INT_32             tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
 951                                         ///  while the global useTileIndex is set to 1
 952     INT_32             macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
 953                                         ///< README: When tileIndex is not -1, this must be valid
 954     UINT_32            bpp;             ///< depth/stencil buffer bit per pixel size
 955     UINT_32            zStencilAddr;    ///< tcCompatible Z/Stencil surface address
 956 } ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT;
 957
 958 /**
 959 ****************************************************************************************************
 960 *   ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
 961 *
 962 *   @brief
 963 *       Output structure for AddrComputeHtileAddrFromCoord
 964 ****************************************************************************************************
 965 */
 966 typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
 967 {
 968     UINT_32 size;           ///< Size of this structure in bytes
 969
 970     UINT_64 addr;           ///< Address in bytes
 971     UINT_32 bitPosition;    ///< Bit position, 0 or 4. CMASK and HTILE shares some lib method.
 972                             ///  So we keep bitPosition for HTILE as well
 973 } ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT;
 974
 975 /**
 976 ****************************************************************************************************
 977 *   AddrComputeHtileAddrFromCoord
 978 *
 979 *   @brief
 980 *       Compute Htile address according to coordinates (of depth buffer)
 981 ****************************************************************************************************
 982 */
 983 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
 984     ADDR_HANDLE                                     hLib,
 985     const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*   pIn,
 986     ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT*        pOut);
 987
 988
 989
 990 /**
 991 ****************************************************************************************************
 992 *   ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
 993 *
 994 *   @brief
 995 *       Input structure for AddrComputeHtileCoordFromAddr
 996 ****************************************************************************************************
 997 */
 998 typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
 999 {
1000     UINT_32            size;            ///< Size of this structure in bytes
1001
1002     UINT_64            addr;            ///< Address
1003     UINT_32            bitPosition;     ///< Bit position 0 or 4. CMASK and HTILE share some methods
1004                                         ///  so we keep bitPosition for HTILE as well
1005     UINT_32            pitch;           ///< Pitch, in pixels
1006     UINT_32            height;          ///< Height, in pixels
1007     UINT_32            numSlices;       ///< Number of slices
1008     BOOL_32            isLinear;        ///< Linear or tiled HTILE layout
1009     AddrHtileBlockSize blockWidth;      ///< 4 or 8. 1 means 8, 0 means 4. R8xx/R9xx only support 8
1010     AddrHtileBlockSize blockHeight;     ///< 4 or 8. 1 means 8, 0 means 4. R8xx/R9xx only support 8
1011     ADDR_TILEINFO*     pTileInfo;       ///< Tile info
1012
1013     INT_32             tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
1014                                         ///  while the global useTileIndex is set to 1
1015     INT_32             macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
1016                                         ///< README: When tileIndex is not -1, this must be valid
1017 } ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT;
1018
1019 /**
1020 ****************************************************************************************************
1021 *   ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
1022 *
1023 *   @brief
1024 *       Output structure for AddrComputeHtileCoordFromAddr
1025 ****************************************************************************************************
1026 */
1027 typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
1028 {
1029     UINT_32 size;   ///< Size of this structure in bytes
1030
1031     UINT_32 x;      ///< X coordinate
1032     UINT_32 y;      ///< Y coordinate
1033     UINT_32 slice;  ///< Slice index
1034 } ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT;
1035
1036 /**
1037 ****************************************************************************************************
1038 *   AddrComputeHtileCoordFromAddr
1039 *
1040 *   @brief
1041 *       Compute coordinates within depth buffer (1st pixel of a micro tile) according to
1042 *       Htile address
1043 ****************************************************************************************************
1044 */
1045 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
1046     ADDR_HANDLE                                     hLib,
1047     const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT*   pIn,
1048     ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT*        pOut);
1049
1050
1051
1052 ////////////////////////////////////////////////////////////////////////////////////////////////////
1053 //                                     C-mask functions
1054 ////////////////////////////////////////////////////////////////////////////////////////////////////
1055
1056 /**
1057 ****************************************************************************************************
1058 *   ADDR_CMASK_FLAGS
1059 *
1060 *   @brief
1061 *       CMASK flags
1062 ****************************************************************************************************
1063 */
1064 typedef union _ADDR_CMASK_FLAGS
1065 {
1066     struct
1067     {
1068         UINT_32 tcCompatible  : 1; ///< Flag indicates surface needs to be shader readable
1069         UINT_32 reserved      :31; ///< Reserved bits
1070     };
1071
1072     UINT_32 value;
1073 } ADDR_CMASK_FLAGS;
1074
1075 /**
1076 ****************************************************************************************************
1077 *   ADDR_COMPUTE_CMASK_INFO_INPUT
1078 *
1079 *   @brief
1080 *       Input structure of AddrComputeCmaskInfo
1081 ****************************************************************************************************
1082 */
1083 typedef struct _ADDR_COMPUTE_CMASKINFO_INPUT
1084 {
1085     UINT_32             size;            ///< Size of this structure in bytes
1086
1087     ADDR_CMASK_FLAGS    flags;           ///< CMASK flags
1088     UINT_32             pitch;           ///< Pitch, in pixels, of color buffer
1089     UINT_32             height;          ///< Height, in pixels, of color buffer
1090     UINT_32             numSlices;       ///< Number of slices, of color buffer
1091     BOOL_32             isLinear;        ///< Linear or tiled layout, Only SI can be linear
1092     ADDR_TILEINFO*      pTileInfo;       ///< Tile info
1093
1094     INT_32              tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
1095                                          ///  while the global useTileIndex is set to 1
1096     INT_32              macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
1097                                          ///< README: When tileIndex is not -1, this must be valid
1098 } ADDR_COMPUTE_CMASK_INFO_INPUT;
1099
1100 /**
1101 ****************************************************************************************************
1102 *   ADDR_COMPUTE_CMASK_INFO_OUTPUT
1103 *
1104 *   @brief
1105 *       Output structure of AddrComputeCmaskInfo
1106 ****************************************************************************************************
1107 */
1108 typedef struct _ADDR_COMPUTE_CMASK_INFO_OUTPUT
1109 {
1110     UINT_32 size;           ///< Size of this structure in bytes
1111
1112     UINT_32 pitch;          ///< Pitch in pixels of color buffer which
1113                             ///  this Cmask matches. The size might be larger than
1114                             ///  original color buffer pitch when called with
1115                             ///  an unaligned pitch.
1116     UINT_32 height;         ///< Height in pixels, as above
1117     UINT_64 cmaskBytes;     ///< Size in bytes of CMask buffer
1118     UINT_32 baseAlign;      ///< Base alignment
1119     UINT_32 blockMax;       ///< Cmask block size. Need this to set CB_COLORn_MASK register
1120     UINT_32 macroWidth;     ///< Macro width in pixels, actually squared cache shape
1121     UINT_32 macroHeight;    ///< Macro height in pixels
1122     UINT_64 sliceSize;      ///< Slice size, in bytes.
1123 } ADDR_COMPUTE_CMASK_INFO_OUTPUT;
1124
1125 /**
1126 ****************************************************************************************************
1127 *   AddrComputeCmaskInfo
1128 *
1129 *   @brief
1130 *       Compute Cmask pitch, height, base alignment and size in bytes from color buffer
1131 *       info
1132 ****************************************************************************************************
1133 */
1134 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
1135     ADDR_HANDLE                             hLib,
1136     const ADDR_COMPUTE_CMASK_INFO_INPUT*    pIn,
1137     ADDR_COMPUTE_CMASK_INFO_OUTPUT*         pOut);
1138
1139
1140
1141 /**
1142 ****************************************************************************************************
1143 *   ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
1144 *
1145 *   @brief
1146 *       Input structure for AddrComputeCmaskAddrFromCoord
1147 *
1148 ****************************************************************************************************
1149 */
1150 typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
1151 {
1152     UINT_32          size;           ///< Size of this structure in bytes
1153     UINT_32          x;              ///< X coordinate
1154     UINT_32          y;              ///< Y coordinate
1155     UINT_64          fmaskAddr;      ///< Fmask addr for tc compatible Cmask
1156     UINT_32          slice;          ///< Slice index
1157     UINT_32          pitch;          ///< Pitch in pixels, of color buffer
1158     UINT_32          height;         ///< Height in pixels, of color buffer
1159     UINT_32          numSlices;      ///< Number of slices
1160     UINT_32          bpp;
1161     BOOL_32          isLinear;       ///< Linear or tiled layout, Only SI can be linear
1162     ADDR_CMASK_FLAGS flags;          ///< CMASK flags
1163     ADDR_TILEINFO*   pTileInfo;      ///< Tile info
1164
1165     INT_32           tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1166                                      ///< while the global useTileIndex is set to 1
1167     INT_32           macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1168                                      ///< README: When tileIndex is not -1, this must be valid
1169 } ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT;
1170
1171 /**
1172 ****************************************************************************************************
1173 *   ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
1174 *
1175 *   @brief
1176 *       Output structure for AddrComputeCmaskAddrFromCoord
1177 ****************************************************************************************************
1178 */
1179 typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
1180 {
1181     UINT_32 size;           ///< Size of this structure in bytes
1182
1183     UINT_64 addr;           ///< CMASK address in bytes
1184     UINT_32 bitPosition;    ///< Bit position within addr, 0-7. CMASK is 4 bpp,
1185                             ///  so the address may be located in bit 0 (0) or 4 (4)
1186 } ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT;
1187
1188 /**
1189 ****************************************************************************************************
1190 *   AddrComputeCmaskAddrFromCoord
1191 *
1192 *   @brief
1193 *       Compute Cmask address according to coordinates (of MSAA color buffer)
1194 ****************************************************************************************************
1195 */
1196 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
1197     ADDR_HANDLE                                     hLib,
1198     const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*   pIn,
1199     ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT*        pOut);
1200
1201
1202
1203 /**
1204 ****************************************************************************************************
1205 *   ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
1206 *
1207 *   @brief
1208 *       Input structure for AddrComputeCmaskCoordFromAddr
1209 ****************************************************************************************************
1210 */
1211 typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
1212 {
1213     UINT_32        size;            ///< Size of this structure in bytes
1214
1215     UINT_64        addr;            ///< CMASK address in bytes
1216     UINT_32        bitPosition;     ///< Bit position within addr, 0-7. CMASK is 4 bpp,
1217                                     ///  so the address may be located in bit 0 (0) or 4 (4)
1218     UINT_32        pitch;           ///< Pitch, in pixels
1219     UINT_32        height;          ///< Height in pixels
1220     UINT_32        numSlices;       ///< Number of slices
1221     BOOL_32        isLinear;        ///< Linear or tiled layout, Only SI can be linear
1222     ADDR_TILEINFO* pTileInfo;       ///< Tile info
1223
1224     INT_32         tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
1225                                     ///  while the global useTileIndex is set to 1
1226     INT_32         macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
1227                                     ///< README: When tileIndex is not -1, this must be valid
1228 } ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT;
1229
1230 /**
1231 ****************************************************************************************************
1232 *   ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
1233 *
1234 *   @brief
1235 *       Output structure for AddrComputeCmaskCoordFromAddr
1236 ****************************************************************************************************
1237 */
1238 typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
1239 {
1240     UINT_32 size;   ///< Size of this structure in bytes
1241
1242     UINT_32 x;      ///< X coordinate
1243     UINT_32 y;      ///< Y coordinate
1244     UINT_32 slice;  ///< Slice index
1245 } ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT;
1246
1247 /**
1248 ****************************************************************************************************
1249 *   AddrComputeCmaskCoordFromAddr
1250 *
1251 *   @brief
1252 *       Compute coordinates within color buffer (1st pixel of a micro tile) according to
1253 *       Cmask address
1254 ****************************************************************************************************
1255 */
1256 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
1257     ADDR_HANDLE                                     hLib,
1258     const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT*   pIn,
1259     ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT*        pOut);
1260
1261
1262
1263 ////////////////////////////////////////////////////////////////////////////////////////////////////
1264 //                                     F-mask functions
1265 ////////////////////////////////////////////////////////////////////////////////////////////////////
1266
1267 /**
1268 ****************************************************************************************************
1269 *   ADDR_COMPUTE_FMASK_INFO_INPUT
1270 *
1271 *   @brief
1272 *       Input structure for AddrComputeFmaskInfo
1273 ****************************************************************************************************
1274 */
1275 typedef struct _ADDR_COMPUTE_FMASK_INFO_INPUT
1276 {
1277     UINT_32         size;               ///< Size of this structure in bytes
1278
1279     AddrTileMode    tileMode;           ///< Tile mode
1280     UINT_32         pitch;              ///< Surface pitch, in pixels
1281     UINT_32         height;             ///< Surface height, in pixels
1282     UINT_32         numSlices;          ///< Number of slice/depth
1283     UINT_32         numSamples;         ///< Number of samples
1284     UINT_32         numFrags;           ///< Number of fragments, leave it zero or the same as
1285                                         ///  number of samples for normal AA; Set it to the
1286                                         ///  number of fragments for EQAA
1287     /// r800 and later HWL parameters
1288     struct
1289     {
1290         UINT_32 resolved:   1;          ///< TRUE if the surface is for resolved fmask, only used
1291                                         ///  by H/W clients. S/W should always set it to FALSE.
1292         UINT_32 reserved:  31;          ///< Reserved for future use.
1293     };
1294     ADDR_TILEINFO*  pTileInfo;          ///< 2D tiling parameters. Clients must give valid data
1295     INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
1296                                         ///  while the global useTileIndex is set to 1
1297 } ADDR_COMPUTE_FMASK_INFO_INPUT;
1298
1299 /**
1300 ****************************************************************************************************
1301 *   ADDR_COMPUTE_FMASK_INFO_OUTPUT
1302 *
1303 *   @brief
1304 *       Output structure for AddrComputeFmaskInfo
1305 ****************************************************************************************************
1306 */
1307 typedef struct _ADDR_COMPUTE_FMASK_INFO_OUTPUT
1308 {
1309     UINT_32         size;           ///< Size of this structure in bytes
1310
1311     UINT_32         pitch;          ///< Pitch of fmask in pixels
1312     UINT_32         height;         ///< Height of fmask in pixels
1313     UINT_32         numSlices;      ///< Slices of fmask
1314     UINT_64         fmaskBytes;     ///< Size of fmask in bytes
1315     UINT_32         baseAlign;      ///< Base address alignment
1316     UINT_32         pitchAlign;     ///< Pitch alignment
1317     UINT_32         heightAlign;    ///< Height alignment
1318     UINT_32         bpp;            ///< Bits per pixel of FMASK is: number of bit planes
1319     UINT_32         numSamples;     ///< Number of samples, used for dump, export this since input
1320                                     ///  may be changed in 9xx and above
1321     /// r800 and later HWL parameters
1322     ADDR_TILEINFO*  pTileInfo;      ///< Tile parameters used. Fmask can have different
1323                                     ///  bank_height from color buffer
1324     INT_32          tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1325                                     ///  while the global useTileIndex is set to 1
1326     INT_32          macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1327     UINT_64         sliceSize;      ///< Size of slice in bytes
1328 } ADDR_COMPUTE_FMASK_INFO_OUTPUT;
1329
1330 /**
1331 ****************************************************************************************************
1332 *   AddrComputeFmaskInfo
1333 *
1334 *   @brief
1335 *       Compute Fmask pitch/height/depth/alignments and size in bytes
1336 ****************************************************************************************************
1337 */
1338 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
1339     ADDR_HANDLE                             hLib,
1340     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,
1341     ADDR_COMPUTE_FMASK_INFO_OUTPUT*         pOut);
1342
1343
1344
1345 /**
1346 ****************************************************************************************************
1347 *   ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
1348 *
1349 *   @brief
1350 *       Input structure for AddrComputeFmaskAddrFromCoord
1351 ****************************************************************************************************
1352 */
1353 typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
1354 {
1355     UINT_32         size;               ///< Size of this structure in bytes
1356
1357     UINT_32         x;                  ///< X coordinate
1358     UINT_32         y;                  ///< Y coordinate
1359     UINT_32         slice;              ///< Slice index
1360     UINT_32         plane;              ///< Plane number
1361     UINT_32         sample;             ///< Sample index (fragment index for EQAA)
1362
1363     UINT_32         pitch;              ///< Surface pitch, in pixels
1364     UINT_32         height;             ///< Surface height, in pixels
1365     UINT_32         numSamples;         ///< Number of samples
1366     UINT_32         numFrags;           ///< Number of fragments, leave it zero or the same as
1367                                         ///  number of samples for normal AA; Set it to the
1368                                         ///  number of fragments for EQAA
1369
1370     AddrTileMode    tileMode;           ///< Tile mode
1371     union
1372     {
1373         struct
1374         {
1375             UINT_32  bankSwizzle;       ///< Bank swizzle
1376             UINT_32  pipeSwizzle;       ///< Pipe swizzle
1377         };
1378         UINT_32     tileSwizzle;        ///< Combined swizzle, if useCombinedSwizzle is TRUE
1379     };
1380
1381     /// r800 and later HWL parameters
1382     struct
1383     {
1384         UINT_32 resolved:   1;          ///< TRUE if this is a resolved fmask, used by H/W clients
1385         UINT_32 ignoreSE:   1;          ///< TRUE if shader engines are ignored.
1386         UINT_32 reserved:  30;          ///< Reserved for future use.
1387     };
1388     ADDR_TILEINFO*  pTileInfo;          ///< 2D tiling parameters. Client must provide all data
1389
1390 } ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT;
1391
1392 /**
1393 ****************************************************************************************************
1394 *   ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
1395 *
1396 *   @brief
1397 *       Output structure for AddrComputeFmaskAddrFromCoord
1398 ****************************************************************************************************
1399 */
1400 typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
1401 {
1402     UINT_32 size;           ///< Size of this structure in bytes
1403
1404     UINT_64 addr;           ///< Fmask address
1405     UINT_32 bitPosition;    ///< Bit position within fmaskAddr, 0-7.
1406 } ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT;
1407
1408 /**
1409 ****************************************************************************************************
1410 *   AddrComputeFmaskAddrFromCoord
1411 *
1412 *   @brief
1413 *       Compute Fmask address according to coordinates (x,y,slice,sample,plane)
1414 ****************************************************************************************************
1415 */
1416 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
1417     ADDR_HANDLE                                     hLib,
1418     const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,
1419     ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*        pOut);
1420
1421
1422
1423 /**
1424 ****************************************************************************************************
1425 *   ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
1426 *
1427 *   @brief
1428 *       Input structure for AddrComputeFmaskCoordFromAddr
1429 ****************************************************************************************************
1430 */
1431 typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
1432 {
1433     UINT_32         size;               ///< Size of this structure in bytes
1434
1435     UINT_64         addr;               ///< Address
1436     UINT_32         bitPosition;        ///< Bit position within addr, 0-7.
1437
1438     UINT_32         pitch;              ///< Pitch, in pixels
1439     UINT_32         height;             ///< Height in pixels
1440     UINT_32         numSamples;         ///< Number of samples
1441     UINT_32         numFrags;           ///< Number of fragments
1442     AddrTileMode    tileMode;           ///< Tile mode
1443     union
1444     {
1445         struct
1446         {
1447             UINT_32  bankSwizzle;       ///< Bank swizzle
1448             UINT_32  pipeSwizzle;       ///< Pipe swizzle
1449         };
1450         UINT_32     tileSwizzle;        ///< Combined swizzle, if useCombinedSwizzle is TRUE
1451     };
1452
1453     /// r800 and later HWL parameters
1454     struct
1455     {
1456         UINT_32 resolved:   1;          ///< TRUE if this is a resolved fmask, used by HW components
1457         UINT_32 ignoreSE:   1;          ///< TRUE if shader engines are ignored.
1458         UINT_32 reserved:  30;          ///< Reserved for future use.
1459     };
1460     ADDR_TILEINFO*  pTileInfo;          ///< 2D tile parameters. Client must provide all data
1461
1462 } ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT;
1463
1464 /**
1465 ****************************************************************************************************
1466 *   ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
1467 *
1468 *   @brief
1469 *       Output structure for AddrComputeFmaskCoordFromAddr
1470 ****************************************************************************************************
1471 */
1472 typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
1473 {
1474     UINT_32 size;       ///< Size of this structure in bytes
1475
1476     UINT_32 x;          ///< X coordinate
1477     UINT_32 y;          ///< Y coordinate
1478     UINT_32 slice;      ///< Slice index
1479     UINT_32 plane;      ///< Plane number
1480     UINT_32 sample;     ///< Sample index (fragment index for EQAA)
1481 } ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT;
1482
1483 /**
1484 ****************************************************************************************************
1485 *   AddrComputeFmaskCoordFromAddr
1486 *
1487 *   @brief
1488 *       Compute FMASK coordinate from an given address
1489 ****************************************************************************************************
1490 */
1491 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
1492     ADDR_HANDLE                                     hLib,
1493     const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*   pIn,
1494     ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT*        pOut);
1495
1496
1497
1498 ////////////////////////////////////////////////////////////////////////////////////////////////////
1499 //                          Element/utility functions
1500 ////////////////////////////////////////////////////////////////////////////////////////////////////
1501
1502 /**
1503 ****************************************************************************************************
1504 *   AddrGetVersion
1505 *
1506 *   @brief
1507 *       Get AddrLib version number
1508 ****************************************************************************************************
1509 */
1510 UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib);
1511
1512 /**
1513 ****************************************************************************************************
1514 *   AddrUseTileIndex
1515 *
1516 *   @brief
1517 *       Return TRUE if tileIndex is enabled in this address library
1518 ****************************************************************************************************
1519 */
1520 BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib);
1521
1522 /**
1523 ****************************************************************************************************
1524 *   AddrUseCombinedSwizzle
1525 *
1526 *   @brief
1527 *       Return TRUE if combined swizzle is enabled in this address library
1528 ****************************************************************************************************
1529 */
1530 BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib);
1531
1532 /**
1533 ****************************************************************************************************
1534 *   ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
1535 *
1536 *   @brief
1537 *       Input structure of AddrExtractBankPipeSwizzle
1538 ****************************************************************************************************
1539 */
1540 typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
1541 {
1542     UINT_32         size;           ///< Size of this structure in bytes
1543
1544     UINT_32         base256b;       ///< Base256b value
1545
1546     /// r800 and later HWL parameters
1547     ADDR_TILEINFO*  pTileInfo;      ///< 2D tile parameters. Client must provide all data
1548
1549     INT_32          tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1550                                     ///  while the global useTileIndex is set to 1
1551     INT_32          macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1552                                     ///< README: When tileIndex is not -1, this must be valid
1553 } ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT;
1554
1555 /**
1556 ****************************************************************************************************
1557 *   ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
1558 *
1559 *   @brief
1560 *       Output structure of AddrExtractBankPipeSwizzle
1561 ****************************************************************************************************
1562 */
1563 typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
1564 {
1565     UINT_32 size;           ///< Size of this structure in bytes
1566
1567     UINT_32 bankSwizzle;    ///< Bank swizzle
1568     UINT_32 pipeSwizzle;    ///< Pipe swizzle
1569 } ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT;
1570
1571 /**
1572 ****************************************************************************************************
1573 *   AddrExtractBankPipeSwizzle
1574 *
1575 *   @brief
1576 *       Extract Bank and Pipe swizzle from base256b
1577 *   @return
1578 *       ADDR_OK if no error
1579 ****************************************************************************************************
1580 */
1581 ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
1582     ADDR_HANDLE                                 hLib,
1583     const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT*  pIn,
1584     ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT*       pOut);
1585
1586
1587 /**
1588 ****************************************************************************************************
1589 *   ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
1590 *
1591 *   @brief
1592 *       Input structure of AddrCombineBankPipeSwizzle
1593 ****************************************************************************************************
1594 */
1595 typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
1596 {
1597     UINT_32         size;           ///< Size of this structure in bytes
1598
1599     UINT_32         bankSwizzle;    ///< Bank swizzle
1600     UINT_32         pipeSwizzle;    ///< Pipe swizzle
1601     UINT_64         baseAddr;       ///< Base address (leave it zero for driver clients)
1602
1603     /// r800 and later HWL parameters
1604     ADDR_TILEINFO*  pTileInfo;      ///< 2D tile parameters. Client must provide all data
1605
1606     INT_32          tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1607                                     ///  while the global useTileIndex is set to 1
1608     INT_32          macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1609                                     ///< README: When tileIndex is not -1, this must be valid
1610 } ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT;
1611
1612 /**
1613 ****************************************************************************************************
1614 *   ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
1615 *
1616 *   @brief
1617 *       Output structure of AddrCombineBankPipeSwizzle
1618 ****************************************************************************************************
1619 */
1620 typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
1621 {
1622     UINT_32 size;           ///< Size of this structure in bytes
1623
1624     UINT_32 tileSwizzle;    ///< Combined swizzle
1625 } ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT;
1626
1627 /**
1628 ****************************************************************************************************
1629 *   AddrCombineBankPipeSwizzle
1630 *
1631 *   @brief
1632 *       Combine Bank and Pipe swizzle
1633 *   @return
1634 *       ADDR_OK if no error
1635 *   @note
1636 *       baseAddr here is full MCAddress instead of base256b
1637 ****************************************************************************************************
1638 */
1639 ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
1640     ADDR_HANDLE                                 hLib,
1641     const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT*  pIn,
1642     ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT*       pOut);
1643
1644
1645
1646 /**
1647 ****************************************************************************************************
1648 *   ADDR_COMPUTE_SLICESWIZZLE_INPUT
1649 *
1650 *   @brief
1651 *       Input structure of AddrComputeSliceSwizzle
1652 ****************************************************************************************************
1653 */
1654 typedef struct _ADDR_COMPUTE_SLICESWIZZLE_INPUT
1655 {
1656     UINT_32         size;               ///< Size of this structure in bytes
1657
1658     AddrTileMode    tileMode;           ///< Tile Mode
1659     UINT_32         baseSwizzle;        ///< Base tile swizzle
1660     UINT_32         slice;              ///< Slice index
1661     UINT_64         baseAddr;           ///< Base address, driver should leave it 0 in most cases
1662
1663     /// r800 and later HWL parameters
1664     ADDR_TILEINFO*  pTileInfo;          ///< 2D tile parameters. Actually banks needed here!
1665
1666     INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
1667                                         ///  while the global useTileIndex is set to 1
1668     INT_32          macroModeIndex;     ///< Index in macro tile mode table if there is one (CI)
1669                                         ///< README: When tileIndex is not -1, this must be valid
1670 } ADDR_COMPUTE_SLICESWIZZLE_INPUT;
1671
1672
1673
1674 /**
1675 ****************************************************************************************************
1676 *   ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
1677 *
1678 *   @brief
1679 *       Output structure of AddrComputeSliceSwizzle
1680 ****************************************************************************************************
1681 */
1682 typedef struct _ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
1683 {
1684     UINT_32  size;           ///< Size of this structure in bytes
1685
1686     UINT_32  tileSwizzle;    ///< Recalculated tileSwizzle value
1687 } ADDR_COMPUTE_SLICESWIZZLE_OUTPUT;
1688
1689 /**
1690 ****************************************************************************************************
1691 *   AddrComputeSliceSwizzle
1692 *
1693 *   @brief
1694 *       Extract Bank and Pipe swizzle from base256b
1695 *   @return
1696 *       ADDR_OK if no error
1697 ****************************************************************************************************
1698 */
1699 ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
1700     ADDR_HANDLE                             hLib,
1701     const ADDR_COMPUTE_SLICESWIZZLE_INPUT*  pIn,
1702     ADDR_COMPUTE_SLICESWIZZLE_OUTPUT*       pOut);
1703
1704
1705 /**
1706 ****************************************************************************************************
1707 *   AddrSwizzleGenOption
1708 *
1709 *   @brief
1710 *       Which swizzle generating options: legacy or linear
1711 ****************************************************************************************************
1712 */
1713 typedef enum _AddrSwizzleGenOption
1714 {
1715     ADDR_SWIZZLE_GEN_DEFAULT    = 0,    ///< As is in client driver implemention for swizzle
1716     ADDR_SWIZZLE_GEN_LINEAR     = 1,    ///< Using a linear increment of swizzle
1717 } AddrSwizzleGenOption;
1718
1719 /**
1720 ****************************************************************************************************
1721 *   AddrSwizzleOption
1722 *
1723 *   @brief
1724 *       Controls how swizzle is generated
1725 ****************************************************************************************************
1726 */
1727 typedef union _ADDR_SWIZZLE_OPTION
1728 {
1729     struct
1730     {
1731         UINT_32 genOption       : 1;    ///< The way swizzle is generated, see AddrSwizzleGenOption
1732         UINT_32 reduceBankBit   : 1;    ///< TRUE if we need reduce swizzle bits
1733         UINT_32 reserved        :30;    ///< Reserved bits
1734     };
1735
1736     UINT_32 value;
1737
1738 } ADDR_SWIZZLE_OPTION;
1739
1740 /**
1741 ****************************************************************************************************
1742 *   ADDR_COMPUTE_BASE_SWIZZLE_INPUT
1743 *
1744 *   @brief
1745 *       Input structure of AddrComputeBaseSwizzle
1746 ****************************************************************************************************
1747 */
1748 typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_INPUT
1749 {
1750     UINT_32             size;           ///< Size of this structure in bytes
1751
1752     ADDR_SWIZZLE_OPTION option;         ///< Swizzle option
1753     UINT_32             surfIndex;      ///< Index of this surface type
1754     AddrTileMode        tileMode;       ///< Tile Mode
1755
1756     /// r800 and later HWL parameters
1757     ADDR_TILEINFO*      pTileInfo;      ///< 2D tile parameters. Actually banks needed here!
1758
1759     INT_32              tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1760                                         ///  while the global useTileIndex is set to 1
1761     INT_32              macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1762                                         ///< README: When tileIndex is not -1, this must be valid
1763 } ADDR_COMPUTE_BASE_SWIZZLE_INPUT;
1764
1765 /**
1766 ****************************************************************************************************
1767 *   ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
1768 *
1769 *   @brief
1770 *       Output structure of AddrComputeBaseSwizzle
1771 ****************************************************************************************************
1772 */
1773 typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
1774 {
1775     UINT_32 size;           ///< Size of this structure in bytes
1776
1777     UINT_32 tileSwizzle;    ///< Combined swizzle
1778 } ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT;
1779
1780 /**
1781 ****************************************************************************************************
1782 *   AddrComputeBaseSwizzle
1783 *
1784 *   @brief
1785 *       Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
1786 *   @return
1787 *       ADDR_OK if no error
1788 ****************************************************************************************************
1789 */
1790 ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
1791     ADDR_HANDLE                             hLib,
1792     const ADDR_COMPUTE_BASE_SWIZZLE_INPUT*  pIn,
1793     ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT*       pOut);
1794
1795
1796
1797 /**
1798 ****************************************************************************************************
1799 *   ELEM_GETEXPORTNORM_INPUT
1800 *
1801 *   @brief
1802 *       Input structure for ElemGetExportNorm
1803 *
1804 ****************************************************************************************************
1805 */
1806 typedef struct _ELEM_GETEXPORTNORM_INPUT
1807 {
1808     UINT_32             size;       ///< Size of this structure in bytes
1809
1810     AddrColorFormat     format;     ///< Color buffer format; Client should use ColorFormat
1811     AddrSurfaceNumber   num;        ///< Surface number type; Client should use NumberType
1812     AddrSurfaceSwap     swap;       ///< Surface swap byte swap; Client should use SurfaceSwap
1813     UINT_32             numSamples; ///< Number of samples
1814 } ELEM_GETEXPORTNORM_INPUT;
1815
1816 /**
1817 ****************************************************************************************************
1818 *  ElemGetExportNorm
1819 *
1820 *   @brief
1821 *       Helper function to check one format can be EXPORT_NUM, which is a register
1822 *       CB_COLOR_INFO.SURFACE_FORMAT. FP16 can be reported as EXPORT_NORM for rv770 in r600
1823 *       family
1824 *   @note
1825 *       The implementation is only for r600.
1826 *       00 - EXPORT_FULL: PS exports are 4 pixels with 4 components with 32-bits-per-component. (two
1827 *       clocks per export)
1828 *       01 - EXPORT_NORM: PS exports are 4 pixels with 4 components with 16-bits-per-component. (one
1829 *       clock per export)
1830 *
1831 ****************************************************************************************************
1832 */
1833 BOOL_32 ADDR_API ElemGetExportNorm(
1834     ADDR_HANDLE                     hLib,
1835     const ELEM_GETEXPORTNORM_INPUT* pIn);
1836
1837
1838
1839 /**
1840 ****************************************************************************************************
1841 *   ELEM_FLT32TODEPTHPIXEL_INPUT
1842 *
1843 *   @brief
1844 *       Input structure for addrFlt32ToDepthPixel
1845 *
1846 ****************************************************************************************************
1847 */
1848 typedef struct _ELEM_FLT32TODEPTHPIXEL_INPUT
1849 {
1850     UINT_32         size;           ///< Size of this structure in bytes
1851
1852     AddrDepthFormat format;         ///< Depth buffer format
1853     ADDR_FLT_32     comps[2];       ///< Component values (Z/stencil)
1854 } ELEM_FLT32TODEPTHPIXEL_INPUT;
1855
1856 /**
1857 ****************************************************************************************************
1858 *   ELEM_FLT32TODEPTHPIXEL_INPUT
1859 *
1860 *   @brief
1861 *       Output structure for ElemFlt32ToDepthPixel
1862 *
1863 ****************************************************************************************************
1864 */
1865 typedef struct _ELEM_FLT32TODEPTHPIXEL_OUTPUT
1866 {
1867     UINT_32 size;           ///< Size of this structure in bytes
1868
1869     UINT_8* pPixel;         ///< Real depth value. Same data type as depth buffer.
1870                             ///  Client must provide enough storage for this type.
1871     UINT_32 depthBase;      ///< Tile base in bits for depth bits
1872     UINT_32 stencilBase;    ///< Tile base in bits for stencil bits
1873     UINT_32 depthBits;      ///< Bits for depth
1874     UINT_32 stencilBits;    ///< Bits for stencil
1875 } ELEM_FLT32TODEPTHPIXEL_OUTPUT;
1876
1877 /**
1878 ****************************************************************************************************
1879 *   ElemFlt32ToDepthPixel
1880 *
1881 *   @brief
1882 *       Convert a FLT_32 value to a depth/stencil pixel value
1883 *
1884 *   @return
1885 *       Return code
1886 *
1887 ****************************************************************************************************
1888 */
1889 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
1890     ADDR_HANDLE                         hLib,
1891     const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,
1892     ELEM_FLT32TODEPTHPIXEL_OUTPUT*      pOut);
1893
1894
1895
1896 /**
1897 ****************************************************************************************************
1898 *   ELEM_FLT32TOCOLORPIXEL_INPUT
1899 *
1900 *   @brief
1901 *       Input structure for addrFlt32ToColorPixel
1902 *
1903 ****************************************************************************************************
1904 */
1905 typedef struct _ELEM_FLT32TOCOLORPIXEL_INPUT
1906 {
1907     UINT_32            size;           ///< Size of this structure in bytes
1908
1909     AddrColorFormat    format;         ///< Color buffer format
1910     AddrSurfaceNumber  surfNum;        ///< Surface number
1911     AddrSurfaceSwap    surfSwap;       ///< Surface swap
1912     ADDR_FLT_32        comps[4];       ///< Component values (r/g/b/a)
1913 } ELEM_FLT32TOCOLORPIXEL_INPUT;
1914
1915 /**
1916 ****************************************************************************************************
1917 *   ELEM_FLT32TOCOLORPIXEL_INPUT
1918 *
1919 *   @brief
1920 *       Output structure for ElemFlt32ToColorPixel
1921 *
1922 ****************************************************************************************************
1923 */
1924 typedef struct _ELEM_FLT32TOCOLORPIXEL_OUTPUT
1925 {
1926     UINT_32 size;       ///< Size of this structure in bytes
1927
1928     UINT_8* pPixel;     ///< Real color value. Same data type as color buffer.
1929                         ///  Client must provide enough storage for this type.
1930 } ELEM_FLT32TOCOLORPIXEL_OUTPUT;
1931
1932 /**
1933 ****************************************************************************************************
1934 *   ElemFlt32ToColorPixel
1935 *
1936 *   @brief
1937 *       Convert a FLT_32 value to a red/green/blue/alpha pixel value
1938 *
1939 *   @return
1940 *       Return code
1941 *
1942 ****************************************************************************************************
1943 */
1944 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
1945     ADDR_HANDLE                         hLib,
1946     const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,
1947     ELEM_FLT32TOCOLORPIXEL_OUTPUT*      pOut);
1948
1949
1950 /**
1951 ****************************************************************************************************
1952 *   ADDR_CONVERT_TILEINFOTOHW_INPUT
1953 *
1954 *   @brief
1955 *       Input structure for AddrConvertTileInfoToHW
1956 *   @note
1957 *       When reverse is TRUE, indices are igonred
1958 ****************************************************************************************************
1959 */
1960 typedef struct _ADDR_CONVERT_TILEINFOTOHW_INPUT
1961 {
1962     UINT_32         size;               ///< Size of this structure in bytes
1963     BOOL_32         reverse;            ///< Convert control flag.
1964                                         ///  FALSE: convert from real value to HW value;
1965                                         ///  TRUE: convert from HW value to real value.
1966
1967     /// r800 and later HWL parameters
1968     ADDR_TILEINFO*  pTileInfo;          ///< Tile parameters with real value
1969
1970     INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
1971                                         ///  while the global useTileIndex is set to 1
1972     INT_32          macroModeIndex;     ///< Index in macro tile mode table if there is one (CI)
1973                                         ///< README: When tileIndex is not -1, this must be valid
1974     UINT_32         bpp;                ///< Bits per pixel
1975 } ADDR_CONVERT_TILEINFOTOHW_INPUT;
1976
1977 /**
1978 ****************************************************************************************************
1979 *   ADDR_CONVERT_TILEINFOTOHW_OUTPUT
1980 *
1981 *   @brief
1982 *       Output structure for AddrConvertTileInfoToHW
1983 ****************************************************************************************************
1984 */
1985 typedef struct _ADDR_CONVERT_TILEINFOTOHW_OUTPUT
1986 {
1987     UINT_32             size;               ///< Size of this structure in bytes
1988
1989     /// r800 and later HWL parameters
1990     ADDR_TILEINFO*      pTileInfo;          ///< Tile parameters with hardware register value
1991
1992 } ADDR_CONVERT_TILEINFOTOHW_OUTPUT;
1993
1994 /**
1995 ****************************************************************************************************
1996 *   AddrConvertTileInfoToHW
1997 *
1998 *   @brief
1999 *       Convert tile info from real value to hardware register value
2000 ****************************************************************************************************
2001 */
2002 ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
2003     ADDR_HANDLE                             hLib,
2004     const ADDR_CONVERT_TILEINFOTOHW_INPUT*  pIn,
2005     ADDR_CONVERT_TILEINFOTOHW_OUTPUT*       pOut);
2006
2007
2008
2009 /**
2010 ****************************************************************************************************
2011 *   ADDR_CONVERT_TILEINDEX_INPUT
2012 *
2013 *   @brief
2014 *       Input structure for AddrConvertTileIndex
2015 ****************************************************************************************************
2016 */
2017 typedef struct _ADDR_CONVERT_TILEINDEX_INPUT
2018 {
2019     UINT_32         size;               ///< Size of this structure in bytes
2020
2021     INT_32          tileIndex;          ///< Tile index
2022     INT_32          macroModeIndex;     ///< Index in macro tile mode table if there is one (CI)
2023     UINT_32         bpp;                ///< Bits per pixel
2024     BOOL_32         tileInfoHw;         ///< Set to TRUE if client wants HW enum, otherwise actual
2025 } ADDR_CONVERT_TILEINDEX_INPUT;
2026
2027 /**
2028 ****************************************************************************************************
2029 *   ADDR_CONVERT_TILEINDEX_OUTPUT
2030 *
2031 *   @brief
2032 *       Output structure for AddrConvertTileIndex
2033 ****************************************************************************************************
2034 */
2035 typedef struct _ADDR_CONVERT_TILEINDEX_OUTPUT
2036 {
2037     UINT_32             size;           ///< Size of this structure in bytes
2038
2039     AddrTileMode        tileMode;       ///< Tile mode
2040     AddrTileType        tileType;       ///< Tile type
2041     ADDR_TILEINFO*      pTileInfo;      ///< Tile info
2042
2043 } ADDR_CONVERT_TILEINDEX_OUTPUT;
2044
2045 /**
2046 ****************************************************************************************************
2047 *   AddrConvertTileIndex
2048 *
2049 *   @brief
2050 *       Convert tile index to tile mode/type/info
2051 ****************************************************************************************************
2052 */
2053 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
2054     ADDR_HANDLE                         hLib,
2055     const ADDR_CONVERT_TILEINDEX_INPUT* pIn,
2056     ADDR_CONVERT_TILEINDEX_OUTPUT*      pOut);
2057
2058 /**
2059 ****************************************************************************************************
2060 *   ADDR_GET_MACROMODEINDEX_INPUT
2061 *
2062 *   @brief
2063 *       Input structure for AddrGetMacroModeIndex
2064 ****************************************************************************************************
2065 */
2066 typedef struct _ADDR_GET_MACROMODEINDEX_INPUT
2067 {
2068     UINT_32             size;               ///< Size of this structure in bytes
2069     ADDR_SURFACE_FLAGS  flags;              ///< Surface flag
2070     INT_32              tileIndex;          ///< Tile index
2071     UINT_32             bpp;                ///< Bits per pixel
2072     UINT_32             numFrags;           ///< Number of color fragments
2073 } ADDR_GET_MACROMODEINDEX_INPUT;
2074
2075 /**
2076 ****************************************************************************************************
2077 *   ADDR_GET_MACROMODEINDEX_OUTPUT
2078 *
2079 *   @brief
2080 *       Output structure for AddrGetMacroModeIndex
2081 ****************************************************************************************************
2082 */
2083 typedef struct _ADDR_GET_MACROMODEINDEX_OUTPUT
2084 {
2085     UINT_32             size;            ///< Size of this structure in bytes
2086     INT_32              macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
2087 } ADDR_GET_MACROMODEINDEX_OUTPUT;
2088
2089 /**
2090 ****************************************************************************************************
2091 *   AddrGetMacroModeIndex
2092 *
2093 *   @brief
2094 *       Get macro mode index based on input parameters
2095 ****************************************************************************************************
2096 */
2097 ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
2098     ADDR_HANDLE                          hLib,
2099     const ADDR_GET_MACROMODEINDEX_INPUT* pIn,
2100     ADDR_GET_MACROMODEINDEX_OUTPUT*      pOut);
2101
2102 /**
2103 ****************************************************************************************************
2104 *   ADDR_CONVERT_TILEINDEX1_INPUT
2105 *
2106 *   @brief
2107 *       Input structure for AddrConvertTileIndex1 (without macro mode index)
2108 ****************************************************************************************************
2109 */
2110 typedef struct _ADDR_CONVERT_TILEINDEX1_INPUT
2111 {
2112     UINT_32         size;               ///< Size of this structure in bytes
2113
2114     INT_32          tileIndex;          ///< Tile index
2115     UINT_32         bpp;                ///< Bits per pixel
2116     UINT_32         numSamples;         ///< Number of samples
2117     BOOL_32         tileInfoHw;         ///< Set to TRUE if client wants HW enum, otherwise actual
2118 } ADDR_CONVERT_TILEINDEX1_INPUT;
2119
2120 /**
2121 ****************************************************************************************************
2122 *   AddrConvertTileIndex1
2123 *
2124 *   @brief
2125 *       Convert tile index to tile mode/type/info
2126 ****************************************************************************************************
2127 */
2128 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
2129     ADDR_HANDLE                             hLib,
2130     const ADDR_CONVERT_TILEINDEX1_INPUT*    pIn,
2131     ADDR_CONVERT_TILEINDEX_OUTPUT*          pOut);
2132
2133
2134
2135 /**
2136 ****************************************************************************************************
2137 *   ADDR_GET_TILEINDEX_INPUT
2138 *
2139 *   @brief
2140 *       Input structure for AddrGetTileIndex
2141 ****************************************************************************************************
2142 */
2143 typedef struct _ADDR_GET_TILEINDEX_INPUT
2144 {
2145     UINT_32         size;           ///< Size of this structure in bytes
2146
2147     AddrTileMode    tileMode;       ///< Tile mode
2148     AddrTileType    tileType;       ///< Tile-type: disp/non-disp/...
2149     ADDR_TILEINFO*  pTileInfo;      ///< Pointer to tile-info structure, can be NULL for linear/1D
2150 } ADDR_GET_TILEINDEX_INPUT;
2151
2152 /**
2153 ****************************************************************************************************
2154 *   ADDR_GET_TILEINDEX_OUTPUT
2155 *
2156 *   @brief
2157 *       Output structure for AddrGetTileIndex
2158 ****************************************************************************************************
2159 */
2160 typedef struct _ADDR_GET_TILEINDEX_OUTPUT
2161 {
2162     UINT_32         size;           ///< Size of this structure in bytes
2163
2164     INT_32          index;          ///< index in table
2165 } ADDR_GET_TILEINDEX_OUTPUT;
2166
2167 /**
2168 ****************************************************************************************************
2169 *   AddrGetTileIndex
2170 *
2171 *   @brief
2172 *       Get the tiling mode index in table
2173 ****************************************************************************************************
2174 */
2175 ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
2176     ADDR_HANDLE                     hLib,
2177     const ADDR_GET_TILEINDEX_INPUT* pIn,
2178     ADDR_GET_TILEINDEX_OUTPUT*      pOut);
2179
2180
2181
2182
2183 /**
2184 ****************************************************************************************************
2185 *   ADDR_PRT_INFO_INPUT
2186 *
2187 *   @brief
2188 *       Input structure for AddrComputePrtInfo
2189 ****************************************************************************************************
2190 */
2191 typedef struct _ADDR_PRT_INFO_INPUT
2192 {
2193     AddrFormat          format;        ///< Surface format
2194     UINT_32             baseMipWidth;  ///< Base mipmap width
2195     UINT_32             baseMipHeight; ///< Base mipmap height
2196     UINT_32             baseMipDepth;  ///< Base mipmap depth
2197     UINT_32             numFrags;      ///< Number of fragments,
2198 } ADDR_PRT_INFO_INPUT;
2199
2200 /**
2201 ****************************************************************************************************
2202 *   ADDR_PRT_INFO_OUTPUT
2203 *
2204 *   @brief
2205 *       Input structure for AddrComputePrtInfo
2206 ****************************************************************************************************
2207 */
2208 typedef struct _ADDR_PRT_INFO_OUTPUT
2209 {
2210     UINT_32             prtTileWidth;
2211     UINT_32             prtTileHeight;
2212 } ADDR_PRT_INFO_OUTPUT;
2213
2214 /**
2215 ****************************************************************************************************
2216 *   AddrComputePrtInfo
2217 *
2218 *   @brief
2219 *       Compute prt surface related information
2220 ****************************************************************************************************
2221 */
2222 ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
2223     ADDR_HANDLE                 hLib,
2224     const ADDR_PRT_INFO_INPUT*  pIn,
2225     ADDR_PRT_INFO_OUTPUT*       pOut);
2226
2227 ////////////////////////////////////////////////////////////////////////////////////////////////////
2228 //                                     DCC key functions
2229 ////////////////////////////////////////////////////////////////////////////////////////////////////
2230
2231 /**
2232 ****************************************************************************************************
2233 *   _ADDR_COMPUTE_DCCINFO_INPUT
2234 *
2235 *   @brief
2236 *       Input structure of AddrComputeDccInfo
2237 ****************************************************************************************************
2238 */
2239 typedef struct _ADDR_COMPUTE_DCCINFO_INPUT
2240 {
2241     UINT_32             size;            ///< Size of this structure in bytes
2242     UINT_32             bpp;             ///< BitPP of color surface
2243     UINT_32             numSamples;      ///< Sample number of color surface
2244     UINT_64             colorSurfSize;   ///< Size of color surface to which dcc key is bound
2245     AddrTileMode        tileMode;        ///< Tile mode of color surface
2246     ADDR_TILEINFO       tileInfo;        ///< Tile info of color surface
2247     UINT_32             tileSwizzle;     ///< Tile swizzle
2248     INT_32              tileIndex;       ///< Tile index of color surface,
2249                                          ///< MUST be -1 if you don't want to use it
2250                                          ///< while the global useTileIndex is set to 1
2251     INT_32              macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
2252                                          ///< README: When tileIndex is not -1, this must be valid
2253 } ADDR_COMPUTE_DCCINFO_INPUT;
2254
2255 /**
2256 ****************************************************************************************************
2257 *   ADDR_COMPUTE_DCCINFO_OUTPUT
2258 *
2259 *   @brief
2260 *       Output structure of AddrComputeDccInfo
2261 ****************************************************************************************************
2262 */
2263 typedef struct _ADDR_COMPUTE_DCCINFO_OUTPUT
2264 {
2265     UINT_32 size;                 ///< Size of this structure in bytes
2266     UINT_64 dccRamBaseAlign;      ///< Base alignment of dcc key
2267     UINT_64 dccRamSize;           ///< Size of dcc key
2268     UINT_64 dccFastClearSize;     ///< Size of dcc key portion that can be fast cleared
2269     BOOL_32 subLvlCompressible;   ///< Whether sub resource is compressiable
2270     BOOL_32 dccRamSizeAligned;    ///< Whether the dcc key size is aligned
2271 } ADDR_COMPUTE_DCCINFO_OUTPUT;
2272
2273 /**
2274 ****************************************************************************************************
2275 *   AddrComputeDccInfo
2276 *
2277 *   @brief
2278 *       Compute DCC key size, base alignment
2279 *       info
2280 ****************************************************************************************************
2281 */
2282 ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
2283     ADDR_HANDLE                             hLib,
2284     const ADDR_COMPUTE_DCCINFO_INPUT*       pIn,
2285     ADDR_COMPUTE_DCCINFO_OUTPUT*            pOut);
2286
2287 /**
2288 ****************************************************************************************************
2289 *   ADDR_GET_MAX_ALINGMENTS_OUTPUT
2290 *
2291 *   @brief
2292 *       Output structure of AddrGetMaxAlignments
2293 ****************************************************************************************************
2294 */
2295 typedef struct _ADDR_GET_MAX_ALINGMENTS_OUTPUT
2296 {
2297     UINT_32 size;                   ///< Size of this structure in bytes
2298     UINT_64 baseAlign;              ///< Maximum base alignment in bytes
2299 } ADDR_GET_MAX_ALINGMENTS_OUTPUT;
2300
2301 /**
2302 ****************************************************************************************************
2303 *   AddrGetMaxAlignments
2304 *
2305 *   @brief
2306 *       Gets maximnum alignments
2307 ****************************************************************************************************
2308 */
2309 ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
2310     ADDR_HANDLE                     hLib,
2311     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut);
2312
2313 #if defined(__cplusplus)
2314 }
2315 #endif
2316
2317 #endif // __ADDR_INTERFACE_H__
2318
2319