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