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