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