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 } ADDR_REGISTER_VALUE;
 290
 291 /**
 292 ***************************************************************************************************
 293 * ADDR_CREATE_INPUT
 294 *
 295 *   @brief
 296 *       Parameters use to create an AddrLib Object. Caller must provide all fields.
 297 *
 298 ***************************************************************************************************
 299 */
 300 typedef struct _ADDR_CREATE_INPUT
 301 {
 302     UINT_32             size;                ///< Size of this structure in bytes
 303
 304     UINT_32             chipEngine;          ///< Chip Engine
 305     UINT_32             chipFamily;          ///< Chip Family
 306     UINT_32             chipRevision;        ///< Chip Revision
 307     ADDR_CALLBACKS      callbacks;           ///< Callbacks for sysmem alloc/free/print
 308     ADDR_CREATE_FLAGS   createFlags;         ///< Flags to setup AddrLib
 309     ADDR_REGISTER_VALUE regValue;            ///< Data from registers to setup AddrLib global data
 310     ADDR_CLIENT_HANDLE  hClient;             ///< Client handle
 311     UINT_32             minPitchAlignPixels; ///< Minimum pitch alignment in pixels
 312 } ADDR_CREATE_INPUT;
 313
 314 /**
 315 ***************************************************************************************************
 316 * ADDR_CREATEINFO_OUTPUT
 317 *
 318 *   @brief
 319 *       Return AddrLib handle to client driver
 320 *
 321 ***************************************************************************************************
 322 */
 323 typedef struct _ADDR_CREATE_OUTPUT
 324 {
 325     UINT_32     size;    ///< Size of this structure in bytes
 326
 327     ADDR_HANDLE hLib;    ///< Address lib handle
 328 } ADDR_CREATE_OUTPUT;
 329
 330 /**
 331 ***************************************************************************************************
 332 *   AddrCreate
 333 *
 334 *   @brief
 335 *       Create AddrLib object, must be called before any interface calls
 336 *
 337 *   @return
 338 *       ADDR_OK if successful
 339 ***************************************************************************************************
 340 */
 341 ADDR_E_RETURNCODE ADDR_API AddrCreate(
 342     const ADDR_CREATE_INPUT*    pAddrCreateIn,
 343     ADDR_CREATE_OUTPUT*         pAddrCreateOut);
 344
 345
 346
 347 /**
 348 ***************************************************************************************************
 349 *   AddrDestroy
 350 *
 351 *   @brief
 352 *       Destroy AddrLib object, must be called to free internally allocated resources.
 353 *
 354 *   @return
 355 *      ADDR_OK if successful
 356 ***************************************************************************************************
 357 */
 358 ADDR_E_RETURNCODE ADDR_API AddrDestroy(
 359     ADDR_HANDLE hLib);
 360
 361
 362
 363 ///////////////////////////////////////////////////////////////////////////////////////////////////
 364 //                                    Surface functions
 365 ///////////////////////////////////////////////////////////////////////////////////////////////////
 366
 367 /**
 368 ***************************************************************************************************
 369 * @brief
 370 *       Bank/tiling parameters. On function input, these can be set as desired or
 371 *       left 0 for AddrLib to calculate/default. On function output, these are the actual
 372 *       parameters used.
 373 * @note
 374 *       Valid bankWidth/bankHeight value:
 375 *       1,2,4,8. They are factors instead of pixels or bytes.
 376 *
 377 *       The bank number remains constant across each row of the
 378 *       macro tile as each pipe is selected, so the number of
 379 *       tiles in the x direction with the same bank number will
 380 *       be bank_width * num_pipes.
 381 ***************************************************************************************************
 382 */
 383 typedef struct _ADDR_TILEINFO
 384 {
 385     ///  Any of these parameters can be set to 0 to use the HW default.
 386     UINT_32     banks;              ///< Number of banks, numerical value
 387     UINT_32     bankWidth;          ///< Number of tiles in the X direction in the same bank
 388     UINT_32     bankHeight;         ///< Number of tiles in the Y direction in the same bank
 389     UINT_32     macroAspectRatio;   ///< Macro tile aspect ratio. 1-1:1, 2-4:1, 4-16:1, 8-64:1
 390     UINT_32     tileSplitBytes;     ///< Tile split size, in bytes
 391     AddrPipeCfg pipeConfig;         ///< Pipe Config = HW enum + 1
 392 } ADDR_TILEINFO;
 393
 394 // Create a define to avoid client change. The removal of R800 is because we plan to implement SI
 395 // within 800 HWL - An AddrPipeCfg is added in above data structure
 396 typedef ADDR_TILEINFO ADDR_R800_TILEINFO;
 397
 398 /**
 399 ***************************************************************************************************
 400 * @brief
 401 *       Information needed by quad buffer stereo support
 402 ***************************************************************************************************
 403 */
 404 typedef struct _ADDR_QBSTEREOINFO
 405 {
 406     UINT_32         eyeHeight;          ///< Height (in pixel rows) to right eye
 407     UINT_32         rightOffset;        ///< Offset (in bytes) to right eye
 408     UINT_32         rightSwizzle;       ///< TileSwizzle for right eyes
 409 } ADDR_QBSTEREOINFO;
 410
 411 /**
 412 ***************************************************************************************************
 413 *   ADDR_SURFACE_FLAGS
 414 *
 415 *   @brief
 416 *       Surface flags
 417 ***************************************************************************************************
 418 */
 419 typedef union _ADDR_SURFACE_FLAGS
 420 {
 421     struct
 422     {
 423         UINT_32 color           : 1; ///< Flag indicates this is a color buffer
 424         UINT_32 depth           : 1; ///< Flag indicates this is a depth/stencil buffer
 425         UINT_32 stencil         : 1; ///< Flag indicates this is a stencil buffer
 426         UINT_32 texture         : 1; ///< Flag indicates this is a texture
 427         UINT_32 cube            : 1; ///< Flag indicates this is a cubemap
 428         UINT_32 volume          : 1; ///< Flag indicates this is a volume texture
 429         UINT_32 fmask           : 1; ///< Flag indicates this is an fmask
 430         UINT_32 cubeAsArray     : 1; ///< Flag indicates if treat cubemap as arrays
 431         UINT_32 compressZ       : 1; ///< Flag indicates z buffer is compressed
 432         UINT_32 overlay         : 1; ///< Flag indicates this is an overlay surface
 433         UINT_32 noStencil       : 1; ///< Flag indicates this depth has no separate stencil
 434         UINT_32 display         : 1; ///< Flag indicates this should match display controller req.
 435         UINT_32 opt4Space       : 1; ///< Flag indicates this surface should be optimized for space
 436                                      ///  i.e. save some memory but may lose performance
 437         UINT_32 prt             : 1; ///< Flag for partially resident texture
 438         UINT_32 qbStereo        : 1; ///< Quad buffer stereo surface
 439         UINT_32 pow2Pad         : 1; ///< SI: Pad to pow2, must set for mipmap (include level0)
 440         UINT_32 interleaved     : 1; ///< Special flag for interleaved YUV surface padding
 441         UINT_32 tcCompatible    : 1; ///< Flag indicates surface needs to be shader readable
 442         UINT_32 dispTileType    : 1; ///< NI: force display Tiling for 128 bit shared resoruce
 443         UINT_32 dccCompatible   : 1; ///< VI: whether to support dcc fast clear
 444         UINT_32 czDispCompatible: 1; ///< SI+: CZ family has a HW bug needs special alignment.
 445                                      ///  This flag indicates we need to follow the alignment with
 446                                      ///  CZ families or other ASICs under PX configuration + CZ.
 447         UINT_32 nonSplit        : 1; ///< CI: depth texture should not be split
 448         UINT_32 disableLinearOpt: 1; ///< Disable tile mode optimization to linear
 449         UINT_32 reserved        : 9; ///< 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     ADDR_HTILE_FLAGS   flags;           ///< htile flags
 855     AddrHtileBlockSize blockWidth;      ///< 4 or 8. 1 means 8, 0 means 4. EG above only support 8
 856     AddrHtileBlockSize blockHeight;     ///< 4 or 8. 1 means 8, 0 means 4. EG above only support 8
 857     ADDR_TILEINFO*     pTileInfo;       ///< Tile info
 858
 859     INT_32             tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
 860                                         ///  while the global useTileIndex is set to 1
 861     INT_32             macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
 862                                         ///< README: When tileIndex is not -1, this must be valid
 863     UINT_32            bpp;             ///< depth/stencil buffer bit per pixel size
 864     UINT_32            zStencilAddr;    ///< tcCompatible Z/Stencil surface address
 865 } ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT;
 866
 867 /**
 868 ***************************************************************************************************
 869 *   ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
 870 *
 871 *   @brief
 872 *       Output structure for AddrComputeHtileAddrFromCoord
 873 ***************************************************************************************************
 874 */
 875 typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
 876 {
 877     UINT_32 size;           ///< Size of this structure in bytes
 878
 879     UINT_64 addr;           ///< Address in bytes
 880     UINT_32 bitPosition;    ///< Bit position, 0 or 4. CMASK and HTILE shares some lib method.
 881                             ///  So we keep bitPosition for HTILE as well
 882 } ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT;
 883
 884 /**
 885 ***************************************************************************************************
 886 *   AddrComputeHtileAddrFromCoord
 887 *
 888 *   @brief
 889 *       Compute Htile address according to coordinates (of depth buffer)
 890 ***************************************************************************************************
 891 */
 892 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
 893     ADDR_HANDLE                                     hLib,
 894     const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*   pIn,
 895     ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT*        pOut);
 896
 897
 898
 899 /**
 900 ***************************************************************************************************
 901 *   ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
 902 *
 903 *   @brief
 904 *       Input structure for AddrComputeHtileCoordFromAddr
 905 ***************************************************************************************************
 906 */
 907 typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
 908 {
 909     UINT_32            size;            ///< Size of this structure in bytes
 910
 911     UINT_64            addr;            ///< Address
 912     UINT_32            bitPosition;     ///< Bit position 0 or 4. CMASK and HTILE share some methods
 913                                         ///  so we keep bitPosition for HTILE as well
 914     UINT_32            pitch;           ///< Pitch, in pixels
 915     UINT_32            height;          ///< Height, in pixels
 916     UINT_32            numSlices;       ///< Number of slices
 917     BOOL_32            isLinear;        ///< Linear or tiled HTILE layout
 918     AddrHtileBlockSize blockWidth;      ///< 4 or 8. 1 means 8, 0 means 4. R8xx/R9xx only support 8
 919     AddrHtileBlockSize blockHeight;     ///< 4 or 8. 1 means 8, 0 means 4. R8xx/R9xx only support 8
 920     ADDR_TILEINFO*     pTileInfo;       ///< Tile info
 921
 922     INT_32             tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
 923                                         ///  while the global useTileIndex is set to 1
 924     INT_32             macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
 925                                         ///< README: When tileIndex is not -1, this must be valid
 926 } ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT;
 927
 928 /**
 929 ***************************************************************************************************
 930 *   ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
 931 *
 932 *   @brief
 933 *       Output structure for AddrComputeHtileCoordFromAddr
 934 ***************************************************************************************************
 935 */
 936 typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
 937 {
 938     UINT_32 size;   ///< Size of this structure in bytes
 939
 940     UINT_32 x;      ///< X coordinate
 941     UINT_32 y;      ///< Y coordinate
 942     UINT_32 slice;  ///< Slice index
 943 } ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT;
 944
 945 /**
 946 ***************************************************************************************************
 947 *   AddrComputeHtileCoordFromAddr
 948 *
 949 *   @brief
 950 *       Compute coordinates within depth buffer (1st pixel of a micro tile) according to
 951 *       Htile address
 952 ***************************************************************************************************
 953 */
 954 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
 955     ADDR_HANDLE                                     hLib,
 956     const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT*   pIn,
 957     ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT*        pOut);
 958
 959
 960
 961 ///////////////////////////////////////////////////////////////////////////////////////////////////
 962 //                                     C-mask functions
 963 ///////////////////////////////////////////////////////////////////////////////////////////////////
 964
 965 /**
 966 ***************************************************************************************************
 967 *   ADDR_CMASK_FLAGS
 968 *
 969 *   @brief
 970 *       CMASK flags
 971 ***************************************************************************************************
 972 */
 973 typedef union _ADDR_CMASK_FLAGS
 974 {
 975     struct
 976     {
 977         UINT_32 tcCompatible  : 1; ///< Flag indicates surface needs to be shader readable
 978         UINT_32 reserved      :31; ///< Reserved bits
 979     };
 980
 981     UINT_32 value;
 982 } ADDR_CMASK_FLAGS;
 983
 984 /**
 985 ***************************************************************************************************
 986 *   ADDR_COMPUTE_CMASK_INFO_INPUT
 987 *
 988 *   @brief
 989 *       Input structure of AddrComputeCmaskInfo
 990 ***************************************************************************************************
 991 */
 992 typedef struct _ADDR_COMPUTE_CMASKINFO_INPUT
 993 {
 994     UINT_32             size;            ///< Size of this structure in bytes
 995
 996     ADDR_CMASK_FLAGS    flags;           ///< CMASK flags
 997     UINT_32             pitch;           ///< Pitch, in pixels, of color buffer
 998     UINT_32             height;          ///< Height, in pixels, of color buffer
 999     UINT_32             numSlices;       ///< Number of slices, of color buffer
1000     BOOL_32             isLinear;        ///< Linear or tiled layout, Only SI can be linear
1001     ADDR_TILEINFO*      pTileInfo;       ///< Tile info
1002
1003     INT_32              tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
1004                                          ///  while the global useTileIndex is set to 1
1005     INT_32              macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
1006                                          ///< README: When tileIndex is not -1, this must be valid
1007 } ADDR_COMPUTE_CMASK_INFO_INPUT;
1008
1009 /**
1010 ***************************************************************************************************
1011 *   ADDR_COMPUTE_CMASK_INFO_OUTPUT
1012 *
1013 *   @brief
1014 *       Output structure of AddrComputeCmaskInfo
1015 ***************************************************************************************************
1016 */
1017 typedef struct _ADDR_COMPUTE_CMASK_INFO_OUTPUT
1018 {
1019     UINT_32 size;           ///< Size of this structure in bytes
1020
1021     UINT_32 pitch;          ///< Pitch in pixels of color buffer which
1022                             ///  this Cmask matches. The size might be larger than
1023                             ///  original color buffer pitch when called with
1024                             ///  an unaligned pitch.
1025     UINT_32 height;         ///< Height in pixels, as above
1026     UINT_64 cmaskBytes;     ///< Size in bytes of CMask buffer
1027     UINT_32 baseAlign;      ///< Base alignment
1028     UINT_32 blockMax;       ///< Cmask block size. Need this to set CB_COLORn_MASK register
1029     UINT_32 macroWidth;     ///< Macro width in pixels, actually squared cache shape
1030     UINT_32 macroHeight;    ///< Macro height in pixels
1031     UINT_64 sliceSize;      ///< Slice size, in bytes.
1032 } ADDR_COMPUTE_CMASK_INFO_OUTPUT;
1033
1034 /**
1035 ***************************************************************************************************
1036 *   AddrComputeCmaskInfo
1037 *
1038 *   @brief
1039 *       Compute Cmask pitch, height, base alignment and size in bytes from color buffer
1040 *       info
1041 ***************************************************************************************************
1042 */
1043 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
1044     ADDR_HANDLE                             hLib,
1045     const ADDR_COMPUTE_CMASK_INFO_INPUT*    pIn,
1046     ADDR_COMPUTE_CMASK_INFO_OUTPUT*         pOut);
1047
1048
1049
1050 /**
1051 ***************************************************************************************************
1052 *   ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
1053 *
1054 *   @brief
1055 *       Input structure for AddrComputeCmaskAddrFromCoord
1056 *
1057 ***************************************************************************************************
1058 */
1059 typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
1060 {
1061     UINT_32          size;           ///< Size of this structure in bytes
1062     UINT_32          x;              ///< X coordinate
1063     UINT_32          y;              ///< Y coordinate
1064     UINT_64          fmaskAddr;      ///< Fmask addr for tc compatible Cmask
1065     UINT_32          slice;          ///< Slice index
1066     UINT_32          pitch;          ///< Pitch in pixels, of color buffer
1067     UINT_32          height;         ///< Height in pixels, of color buffer
1068     UINT_32          numSlices;      ///< Number of slices
1069     UINT_32          bpp;
1070     BOOL_32          isLinear;       ///< Linear or tiled layout, Only SI can be linear
1071     ADDR_CMASK_FLAGS flags;          ///< CMASK flags
1072     ADDR_TILEINFO*   pTileInfo;      ///< Tile info
1073
1074     INT_32           tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1075                                      ///< while the global useTileIndex is set to 1
1076     INT_32           macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1077                                      ///< README: When tileIndex is not -1, this must be valid
1078 } ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT;
1079
1080 /**
1081 ***************************************************************************************************
1082 *   ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
1083 *
1084 *   @brief
1085 *       Output structure for AddrComputeCmaskAddrFromCoord
1086 ***************************************************************************************************
1087 */
1088 typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
1089 {
1090     UINT_32 size;           ///< Size of this structure in bytes
1091
1092     UINT_64 addr;           ///< CMASK address in bytes
1093     UINT_32 bitPosition;    ///< Bit position within addr, 0-7. CMASK is 4 bpp,
1094                             ///  so the address may be located in bit 0 (0) or 4 (4)
1095 } ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT;
1096
1097 /**
1098 ***************************************************************************************************
1099 *   AddrComputeCmaskAddrFromCoord
1100 *
1101 *   @brief
1102 *       Compute Cmask address according to coordinates (of MSAA color buffer)
1103 ***************************************************************************************************
1104 */
1105 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
1106     ADDR_HANDLE                                     hLib,
1107     const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*   pIn,
1108     ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT*        pOut);
1109
1110
1111
1112 /**
1113 ***************************************************************************************************
1114 *   ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
1115 *
1116 *   @brief
1117 *       Input structure for AddrComputeCmaskCoordFromAddr
1118 ***************************************************************************************************
1119 */
1120 typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
1121 {
1122     UINT_32        size;            ///< Size of this structure in bytes
1123
1124     UINT_64        addr;            ///< CMASK address in bytes
1125     UINT_32        bitPosition;     ///< Bit position within addr, 0-7. CMASK is 4 bpp,
1126                                     ///  so the address may be located in bit 0 (0) or 4 (4)
1127     UINT_32        pitch;           ///< Pitch, in pixels
1128     UINT_32        height;          ///< Height in pixels
1129     UINT_32        numSlices;       ///< Number of slices
1130     BOOL_32        isLinear;        ///< Linear or tiled layout, Only SI can be linear
1131     ADDR_TILEINFO* pTileInfo;       ///< Tile info
1132
1133     INT_32         tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
1134                                     ///  while the global useTileIndex is set to 1
1135     INT_32         macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
1136                                     ///< README: When tileIndex is not -1, this must be valid
1137 } ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT;
1138
1139 /**
1140 ***************************************************************************************************
1141 *   ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
1142 *
1143 *   @brief
1144 *       Output structure for AddrComputeCmaskCoordFromAddr
1145 ***************************************************************************************************
1146 */
1147 typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
1148 {
1149     UINT_32 size;   ///< Size of this structure in bytes
1150
1151     UINT_32 x;      ///< X coordinate
1152     UINT_32 y;      ///< Y coordinate
1153     UINT_32 slice;  ///< Slice index
1154 } ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT;
1155
1156 /**
1157 ***************************************************************************************************
1158 *   AddrComputeCmaskCoordFromAddr
1159 *
1160 *   @brief
1161 *       Compute coordinates within color buffer (1st pixel of a micro tile) according to
1162 *       Cmask address
1163 ***************************************************************************************************
1164 */
1165 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
1166     ADDR_HANDLE                                     hLib,
1167     const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT*   pIn,
1168     ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT*        pOut);
1169
1170
1171
1172 ///////////////////////////////////////////////////////////////////////////////////////////////////
1173 //                                     F-mask functions
1174 ///////////////////////////////////////////////////////////////////////////////////////////////////
1175
1176 /**
1177 ***************************************************************************************************
1178 *   ADDR_COMPUTE_FMASK_INFO_INPUT
1179 *
1180 *   @brief
1181 *       Input structure for AddrComputeFmaskInfo
1182 ***************************************************************************************************
1183 */
1184 typedef struct _ADDR_COMPUTE_FMASK_INFO_INPUT
1185 {
1186     UINT_32         size;               ///< Size of this structure in bytes
1187
1188     AddrTileMode    tileMode;           ///< Tile mode
1189     UINT_32         pitch;              ///< Surface pitch, in pixels
1190     UINT_32         height;             ///< Surface height, in pixels
1191     UINT_32         numSlices;          ///< Number of slice/depth
1192     UINT_32         numSamples;         ///< Number of samples
1193     UINT_32         numFrags;           ///< Number of fragments, leave it zero or the same as
1194                                         ///  number of samples for normal AA; Set it to the
1195                                         ///  number of fragments for EQAA
1196     /// r800 and later HWL parameters
1197     struct
1198     {
1199         UINT_32 resolved:   1;          ///< TRUE if the surface is for resolved fmask, only used
1200                                         ///  by H/W clients. S/W should always set it to FALSE.
1201         UINT_32 reserved:  31;          ///< Reserved for future use.
1202     };
1203     ADDR_TILEINFO*  pTileInfo;          ///< 2D tiling parameters. Clients must give valid data
1204     INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
1205                                         ///  while the global useTileIndex is set to 1
1206 } ADDR_COMPUTE_FMASK_INFO_INPUT;
1207
1208 /**
1209 ***************************************************************************************************
1210 *   ADDR_COMPUTE_FMASK_INFO_OUTPUT
1211 *
1212 *   @brief
1213 *       Output structure for AddrComputeFmaskInfo
1214 ***************************************************************************************************
1215 */
1216 typedef struct _ADDR_COMPUTE_FMASK_INFO_OUTPUT
1217 {
1218     UINT_32         size;           ///< Size of this structure in bytes
1219
1220     UINT_32         pitch;          ///< Pitch of fmask in pixels
1221     UINT_32         height;         ///< Height of fmask in pixels
1222     UINT_32         numSlices;      ///< Slices of fmask
1223     UINT_64         fmaskBytes;     ///< Size of fmask in bytes
1224     UINT_32         baseAlign;      ///< Base address alignment
1225     UINT_32         pitchAlign;     ///< Pitch alignment
1226     UINT_32         heightAlign;    ///< Height alignment
1227     UINT_32         bpp;            ///< Bits per pixel of FMASK is: number of bit planes
1228     UINT_32         numSamples;     ///< Number of samples, used for dump, export this since input
1229                                     ///  may be changed in 9xx and above
1230     /// r800 and later HWL parameters
1231     ADDR_TILEINFO*  pTileInfo;      ///< Tile parameters used. Fmask can have different
1232                                     ///  bank_height from color buffer
1233     INT_32          tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1234                                     ///  while the global useTileIndex is set to 1
1235     INT_32          macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1236     UINT_64         sliceSize;      ///< Size of slice in bytes
1237 } ADDR_COMPUTE_FMASK_INFO_OUTPUT;
1238
1239 /**
1240 ***************************************************************************************************
1241 *   AddrComputeFmaskInfo
1242 *
1243 *   @brief
1244 *       Compute Fmask pitch/height/depth/alignments and size in bytes
1245 ***************************************************************************************************
1246 */
1247 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
1248     ADDR_HANDLE                             hLib,
1249     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,
1250     ADDR_COMPUTE_FMASK_INFO_OUTPUT*         pOut);
1251
1252
1253
1254 /**
1255 ***************************************************************************************************
1256 *   ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
1257 *
1258 *   @brief
1259 *       Input structure for AddrComputeFmaskAddrFromCoord
1260 ***************************************************************************************************
1261 */
1262 typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
1263 {
1264     UINT_32         size;               ///< Size of this structure in bytes
1265
1266     UINT_32         x;                  ///< X coordinate
1267     UINT_32         y;                  ///< Y coordinate
1268     UINT_32         slice;              ///< Slice index
1269     UINT_32         plane;              ///< Plane number
1270     UINT_32         sample;             ///< Sample index (fragment index for EQAA)
1271
1272     UINT_32         pitch;              ///< Surface pitch, in pixels
1273     UINT_32         height;             ///< Surface height, in pixels
1274     UINT_32         numSamples;         ///< Number of samples
1275     UINT_32         numFrags;           ///< Number of fragments, leave it zero or the same as
1276                                         ///  number of samples for normal AA; Set it to the
1277                                         ///  number of fragments for EQAA
1278
1279     AddrTileMode    tileMode;           ///< Tile mode
1280     union
1281     {
1282         struct
1283         {
1284             UINT_32  bankSwizzle;       ///< Bank swizzle
1285             UINT_32  pipeSwizzle;       ///< Pipe swizzle
1286         };
1287         UINT_32     tileSwizzle;        ///< Combined swizzle, if useCombinedSwizzle is TRUE
1288     };
1289
1290     /// r800 and later HWL parameters
1291     struct
1292     {
1293         UINT_32 resolved:   1;          ///< TRUE if this is a resolved fmask, used by H/W clients
1294         UINT_32 ignoreSE:   1;          ///< TRUE if shader engines are ignored.
1295         UINT_32 reserved:  30;          ///< Reserved for future use.
1296     };
1297     ADDR_TILEINFO*  pTileInfo;          ///< 2D tiling parameters. Client must provide all data
1298
1299 } ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT;
1300
1301 /**
1302 ***************************************************************************************************
1303 *   ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
1304 *
1305 *   @brief
1306 *       Output structure for AddrComputeFmaskAddrFromCoord
1307 ***************************************************************************************************
1308 */
1309 typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
1310 {
1311     UINT_32 size;           ///< Size of this structure in bytes
1312
1313     UINT_64 addr;           ///< Fmask address
1314     UINT_32 bitPosition;    ///< Bit position within fmaskAddr, 0-7.
1315 } ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT;
1316
1317 /**
1318 ***************************************************************************************************
1319 *   AddrComputeFmaskAddrFromCoord
1320 *
1321 *   @brief
1322 *       Compute Fmask address according to coordinates (x,y,slice,sample,plane)
1323 ***************************************************************************************************
1324 */
1325 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
1326     ADDR_HANDLE                                     hLib,
1327     const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,
1328     ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*        pOut);
1329
1330
1331
1332 /**
1333 ***************************************************************************************************
1334 *   ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
1335 *
1336 *   @brief
1337 *       Input structure for AddrComputeFmaskCoordFromAddr
1338 ***************************************************************************************************
1339 */
1340 typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
1341 {
1342     UINT_32         size;               ///< Size of this structure in bytes
1343
1344     UINT_64         addr;               ///< Address
1345     UINT_32         bitPosition;        ///< Bit position within addr, 0-7.
1346
1347     UINT_32         pitch;              ///< Pitch, in pixels
1348     UINT_32         height;             ///< Height in pixels
1349     UINT_32         numSamples;         ///< Number of samples
1350     UINT_32         numFrags;           ///< Number of fragments
1351     AddrTileMode    tileMode;           ///< Tile mode
1352     union
1353     {
1354         struct
1355         {
1356             UINT_32  bankSwizzle;       ///< Bank swizzle
1357             UINT_32  pipeSwizzle;       ///< Pipe swizzle
1358         };
1359         UINT_32     tileSwizzle;        ///< Combined swizzle, if useCombinedSwizzle is TRUE
1360     };
1361
1362     /// r800 and later HWL parameters
1363     struct
1364     {
1365         UINT_32 resolved:   1;          ///< TRUE if this is a resolved fmask, used by HW components
1366         UINT_32 ignoreSE:   1;          ///< TRUE if shader engines are ignored.
1367         UINT_32 reserved:  30;          ///< Reserved for future use.
1368     };
1369     ADDR_TILEINFO*  pTileInfo;          ///< 2D tile parameters. Client must provide all data
1370
1371 } ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT;
1372
1373 /**
1374 ***************************************************************************************************
1375 *   ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
1376 *
1377 *   @brief
1378 *       Output structure for AddrComputeFmaskCoordFromAddr
1379 ***************************************************************************************************
1380 */
1381 typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
1382 {
1383     UINT_32 size;       ///< Size of this structure in bytes
1384
1385     UINT_32 x;          ///< X coordinate
1386     UINT_32 y;          ///< Y coordinate
1387     UINT_32 slice;      ///< Slice index
1388     UINT_32 plane;      ///< Plane number
1389     UINT_32 sample;     ///< Sample index (fragment index for EQAA)
1390 } ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT;
1391
1392 /**
1393 ***************************************************************************************************
1394 *   AddrComputeFmaskCoordFromAddr
1395 *
1396 *   @brief
1397 *       Compute FMASK coordinate from an given address
1398 ***************************************************************************************************
1399 */
1400 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
1401     ADDR_HANDLE                                     hLib,
1402     const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*   pIn,
1403     ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT*        pOut);
1404
1405
1406
1407 ///////////////////////////////////////////////////////////////////////////////////////////////////
1408 //                          Element/utility functions
1409 ///////////////////////////////////////////////////////////////////////////////////////////////////
1410
1411 /**
1412 ***************************************************************************************************
1413 *   AddrGetVersion
1414 *
1415 *   @brief
1416 *       Get AddrLib version number
1417 ***************************************************************************************************
1418 */
1419 UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib);
1420
1421 /**
1422 ***************************************************************************************************
1423 *   AddrUseTileIndex
1424 *
1425 *   @brief
1426 *       Return TRUE if tileIndex is enabled in this address library
1427 ***************************************************************************************************
1428 */
1429 BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib);
1430
1431 /**
1432 ***************************************************************************************************
1433 *   AddrUseCombinedSwizzle
1434 *
1435 *   @brief
1436 *       Return TRUE if combined swizzle is enabled in this address library
1437 ***************************************************************************************************
1438 */
1439 BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib);
1440
1441 /**
1442 ***************************************************************************************************
1443 *   ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
1444 *
1445 *   @brief
1446 *       Input structure of AddrExtractBankPipeSwizzle
1447 ***************************************************************************************************
1448 */
1449 typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
1450 {
1451     UINT_32         size;           ///< Size of this structure in bytes
1452
1453     UINT_32         base256b;       ///< Base256b value
1454
1455     /// r800 and later HWL parameters
1456     ADDR_TILEINFO*  pTileInfo;      ///< 2D tile parameters. Client must provide all data
1457
1458     INT_32          tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1459                                     ///  while the global useTileIndex is set to 1
1460     INT_32          macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1461                                     ///< README: When tileIndex is not -1, this must be valid
1462 } ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT;
1463
1464 /**
1465 ***************************************************************************************************
1466 *   ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
1467 *
1468 *   @brief
1469 *       Output structure of AddrExtractBankPipeSwizzle
1470 ***************************************************************************************************
1471 */
1472 typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
1473 {
1474     UINT_32 size;           ///< Size of this structure in bytes
1475
1476     UINT_32 bankSwizzle;    ///< Bank swizzle
1477     UINT_32 pipeSwizzle;    ///< Pipe swizzle
1478 } ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT;
1479
1480 /**
1481 ***************************************************************************************************
1482 *   AddrExtractBankPipeSwizzle
1483 *
1484 *   @brief
1485 *       Extract Bank and Pipe swizzle from base256b
1486 *   @return
1487 *       ADDR_OK if no error
1488 ***************************************************************************************************
1489 */
1490 ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
1491     ADDR_HANDLE                                 hLib,
1492     const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT*  pIn,
1493     ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT*       pOut);
1494
1495
1496 /**
1497 ***************************************************************************************************
1498 *   ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
1499 *
1500 *   @brief
1501 *       Input structure of AddrCombineBankPipeSwizzle
1502 ***************************************************************************************************
1503 */
1504 typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
1505 {
1506     UINT_32         size;           ///< Size of this structure in bytes
1507
1508     UINT_32         bankSwizzle;    ///< Bank swizzle
1509     UINT_32         pipeSwizzle;    ///< Pipe swizzle
1510     UINT_64         baseAddr;       ///< Base address (leave it zero for driver clients)
1511
1512     /// r800 and later HWL parameters
1513     ADDR_TILEINFO*  pTileInfo;      ///< 2D tile parameters. Client must provide all data
1514
1515     INT_32          tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1516                                     ///  while the global useTileIndex is set to 1
1517     INT_32          macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1518                                     ///< README: When tileIndex is not -1, this must be valid
1519 } ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT;
1520
1521 /**
1522 ***************************************************************************************************
1523 *   ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
1524 *
1525 *   @brief
1526 *       Output structure of AddrCombineBankPipeSwizzle
1527 ***************************************************************************************************
1528 */
1529 typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
1530 {
1531     UINT_32 size;           ///< Size of this structure in bytes
1532
1533     UINT_32 tileSwizzle;    ///< Combined swizzle
1534 } ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT;
1535
1536 /**
1537 ***************************************************************************************************
1538 *   AddrCombineBankPipeSwizzle
1539 *
1540 *   @brief
1541 *       Combine Bank and Pipe swizzle
1542 *   @return
1543 *       ADDR_OK if no error
1544 *   @note
1545 *       baseAddr here is full MCAddress instead of base256b
1546 ***************************************************************************************************
1547 */
1548 ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
1549     ADDR_HANDLE                                 hLib,
1550     const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT*  pIn,
1551     ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT*       pOut);
1552
1553
1554
1555 /**
1556 ***************************************************************************************************
1557 *   ADDR_COMPUTE_SLICESWIZZLE_INPUT
1558 *
1559 *   @brief
1560 *       Input structure of AddrComputeSliceSwizzle
1561 ***************************************************************************************************
1562 */
1563 typedef struct _ADDR_COMPUTE_SLICESWIZZLE_INPUT
1564 {
1565     UINT_32         size;               ///< Size of this structure in bytes
1566
1567     AddrTileMode    tileMode;           ///< Tile Mode
1568     UINT_32         baseSwizzle;        ///< Base tile swizzle
1569     UINT_32         slice;              ///< Slice index
1570     UINT_64         baseAddr;           ///< Base address, driver should leave it 0 in most cases
1571
1572     /// r800 and later HWL parameters
1573     ADDR_TILEINFO*  pTileInfo;          ///< 2D tile parameters. Actually banks needed here!
1574
1575     INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
1576                                         ///  while the global useTileIndex is set to 1
1577     INT_32          macroModeIndex;     ///< Index in macro tile mode table if there is one (CI)
1578                                         ///< README: When tileIndex is not -1, this must be valid
1579 } ADDR_COMPUTE_SLICESWIZZLE_INPUT;
1580
1581
1582
1583 /**
1584 ***************************************************************************************************
1585 *   ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
1586 *
1587 *   @brief
1588 *       Output structure of AddrComputeSliceSwizzle
1589 ***************************************************************************************************
1590 */
1591 typedef struct _ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
1592 {
1593     UINT_32  size;           ///< Size of this structure in bytes
1594
1595     UINT_32  tileSwizzle;    ///< Recalculated tileSwizzle value
1596 } ADDR_COMPUTE_SLICESWIZZLE_OUTPUT;
1597
1598 /**
1599 ***************************************************************************************************
1600 *   AddrComputeSliceSwizzle
1601 *
1602 *   @brief
1603 *       Extract Bank and Pipe swizzle from base256b
1604 *   @return
1605 *       ADDR_OK if no error
1606 ***************************************************************************************************
1607 */
1608 ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
1609     ADDR_HANDLE                             hLib,
1610     const ADDR_COMPUTE_SLICESWIZZLE_INPUT*  pIn,
1611     ADDR_COMPUTE_SLICESWIZZLE_OUTPUT*       pOut);
1612
1613
1614 /**
1615 ***************************************************************************************************
1616 *   AddrSwizzleGenOption
1617 *
1618 *   @brief
1619 *       Which swizzle generating options: legacy or linear
1620 ***************************************************************************************************
1621 */
1622 typedef enum _AddrSwizzleGenOption
1623 {
1624     ADDR_SWIZZLE_GEN_DEFAULT    = 0,    ///< As is in client driver implemention for swizzle
1625     ADDR_SWIZZLE_GEN_LINEAR     = 1,    ///< Using a linear increment of swizzle
1626 } AddrSwizzleGenOption;
1627
1628 /**
1629 ***************************************************************************************************
1630 *   AddrSwizzleOption
1631 *
1632 *   @brief
1633 *       Controls how swizzle is generated
1634 ***************************************************************************************************
1635 */
1636 typedef union _ADDR_SWIZZLE_OPTION
1637 {
1638     struct
1639     {
1640         UINT_32 genOption       : 1;    ///< The way swizzle is generated, see AddrSwizzleGenOption
1641         UINT_32 reduceBankBit   : 1;    ///< TRUE if we need reduce swizzle bits
1642         UINT_32 reserved        :30;    ///< Reserved bits
1643     };
1644
1645     UINT_32 value;
1646
1647 } ADDR_SWIZZLE_OPTION;
1648
1649 /**
1650 ***************************************************************************************************
1651 *   ADDR_COMPUTE_BASE_SWIZZLE_INPUT
1652 *
1653 *   @brief
1654 *       Input structure of AddrComputeBaseSwizzle
1655 ***************************************************************************************************
1656 */
1657 typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_INPUT
1658 {
1659     UINT_32             size;           ///< Size of this structure in bytes
1660
1661     ADDR_SWIZZLE_OPTION option;         ///< Swizzle option
1662     UINT_32             surfIndex;      ///< Index of this surface type
1663     AddrTileMode        tileMode;       ///< Tile Mode
1664
1665     /// r800 and later HWL parameters
1666     ADDR_TILEINFO*      pTileInfo;      ///< 2D tile parameters. Actually banks needed here!
1667
1668     INT_32              tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
1669                                         ///  while the global useTileIndex is set to 1
1670     INT_32              macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
1671                                         ///< README: When tileIndex is not -1, this must be valid
1672 } ADDR_COMPUTE_BASE_SWIZZLE_INPUT;
1673
1674 /**
1675 ***************************************************************************************************
1676 *   ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
1677 *
1678 *   @brief
1679 *       Output structure of AddrComputeBaseSwizzle
1680 ***************************************************************************************************
1681 */
1682 typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
1683 {
1684     UINT_32 size;           ///< Size of this structure in bytes
1685
1686     UINT_32 tileSwizzle;    ///< Combined swizzle
1687 } ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT;
1688
1689 /**
1690 ***************************************************************************************************
1691 *   AddrComputeBaseSwizzle
1692 *
1693 *   @brief
1694 *       Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
1695 *   @return
1696 *       ADDR_OK if no error
1697 ***************************************************************************************************
1698 */
1699 ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
1700     ADDR_HANDLE                             hLib,
1701     const ADDR_COMPUTE_BASE_SWIZZLE_INPUT*  pIn,
1702     ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT*       pOut);
1703
1704
1705
1706 /**
1707 ***************************************************************************************************
1708 *   ELEM_GETEXPORTNORM_INPUT
1709 *
1710 *   @brief
1711 *       Input structure for ElemGetExportNorm
1712 *
1713 ***************************************************************************************************
1714 */
1715 typedef struct _ELEM_GETEXPORTNORM_INPUT
1716 {
1717     UINT_32             size;       ///< Size of this structure in bytes
1718
1719     AddrColorFormat     format;     ///< Color buffer format; Client should use ColorFormat
1720     AddrSurfaceNumber   num;        ///< Surface number type; Client should use NumberType
1721     AddrSurfaceSwap     swap;       ///< Surface swap byte swap; Client should use SurfaceSwap
1722     UINT_32             numSamples; ///< Number of samples
1723 } ELEM_GETEXPORTNORM_INPUT;
1724
1725 /**
1726 ***************************************************************************************************
1727 *  ElemGetExportNorm
1728 *
1729 *   @brief
1730 *       Helper function to check one format can be EXPORT_NUM, which is a register
1731 *       CB_COLOR_INFO.SURFACE_FORMAT. FP16 can be reported as EXPORT_NORM for rv770 in r600
1732 *       family
1733 *   @note
1734 *       The implementation is only for r600.
1735 *       00 - EXPORT_FULL: PS exports are 4 pixels with 4 components with 32-bits-per-component. (two
1736 *       clocks per export)
1737 *       01 - EXPORT_NORM: PS exports are 4 pixels with 4 components with 16-bits-per-component. (one
1738 *       clock per export)
1739 *
1740 ***************************************************************************************************
1741 */
1742 BOOL_32 ADDR_API ElemGetExportNorm(
1743     ADDR_HANDLE                     hLib,
1744     const ELEM_GETEXPORTNORM_INPUT* pIn);
1745
1746
1747
1748 /**
1749 ***************************************************************************************************
1750 *   ELEM_FLT32TODEPTHPIXEL_INPUT
1751 *
1752 *   @brief
1753 *       Input structure for addrFlt32ToDepthPixel
1754 *
1755 ***************************************************************************************************
1756 */
1757 typedef struct _ELEM_FLT32TODEPTHPIXEL_INPUT
1758 {
1759     UINT_32         size;           ///< Size of this structure in bytes
1760
1761     AddrDepthFormat format;         ///< Depth buffer format
1762     ADDR_FLT_32     comps[2];       ///< Component values (Z/stencil)
1763 } ELEM_FLT32TODEPTHPIXEL_INPUT;
1764
1765 /**
1766 ***************************************************************************************************
1767 *   ELEM_FLT32TODEPTHPIXEL_INPUT
1768 *
1769 *   @brief
1770 *       Output structure for ElemFlt32ToDepthPixel
1771 *
1772 ***************************************************************************************************
1773 */
1774 typedef struct _ELEM_FLT32TODEPTHPIXEL_OUTPUT
1775 {
1776     UINT_32 size;           ///< Size of this structure in bytes
1777
1778     UINT_8* pPixel;         ///< Real depth value. Same data type as depth buffer.
1779                             ///  Client must provide enough storage for this type.
1780     UINT_32 depthBase;      ///< Tile base in bits for depth bits
1781     UINT_32 stencilBase;    ///< Tile base in bits for stencil bits
1782     UINT_32 depthBits;      ///< Bits for depth
1783     UINT_32 stencilBits;    ///< Bits for stencil
1784 } ELEM_FLT32TODEPTHPIXEL_OUTPUT;
1785
1786 /**
1787 ***************************************************************************************************
1788 *   ElemFlt32ToDepthPixel
1789 *
1790 *   @brief
1791 *       Convert a FLT_32 value to a depth/stencil pixel value
1792 *
1793 *   @return
1794 *       Return code
1795 *
1796 ***************************************************************************************************
1797 */
1798 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
1799     ADDR_HANDLE                         hLib,
1800     const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,
1801     ELEM_FLT32TODEPTHPIXEL_OUTPUT*      pOut);
1802
1803
1804
1805 /**
1806 ***************************************************************************************************
1807 *   ELEM_FLT32TOCOLORPIXEL_INPUT
1808 *
1809 *   @brief
1810 *       Input structure for addrFlt32ToColorPixel
1811 *
1812 ***************************************************************************************************
1813 */
1814 typedef struct _ELEM_FLT32TOCOLORPIXEL_INPUT
1815 {
1816     UINT_32            size;           ///< Size of this structure in bytes
1817
1818     AddrColorFormat    format;         ///< Color buffer format
1819     AddrSurfaceNumber  surfNum;        ///< Surface number
1820     AddrSurfaceSwap    surfSwap;       ///< Surface swap
1821     ADDR_FLT_32        comps[4];       ///< Component values (r/g/b/a)
1822 } ELEM_FLT32TOCOLORPIXEL_INPUT;
1823
1824 /**
1825 ***************************************************************************************************
1826 *   ELEM_FLT32TOCOLORPIXEL_INPUT
1827 *
1828 *   @brief
1829 *       Output structure for ElemFlt32ToColorPixel
1830 *
1831 ***************************************************************************************************
1832 */
1833 typedef struct _ELEM_FLT32TOCOLORPIXEL_OUTPUT
1834 {
1835     UINT_32 size;       ///< Size of this structure in bytes
1836
1837     UINT_8* pPixel;     ///< Real color value. Same data type as color buffer.
1838                         ///  Client must provide enough storage for this type.
1839 } ELEM_FLT32TOCOLORPIXEL_OUTPUT;
1840
1841 /**
1842 ***************************************************************************************************
1843 *   ElemFlt32ToColorPixel
1844 *
1845 *   @brief
1846 *       Convert a FLT_32 value to a red/green/blue/alpha pixel value
1847 *
1848 *   @return
1849 *       Return code
1850 *
1851 ***************************************************************************************************
1852 */
1853 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
1854     ADDR_HANDLE                         hLib,
1855     const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,
1856     ELEM_FLT32TOCOLORPIXEL_OUTPUT*      pOut);
1857
1858
1859 /**
1860 ***************************************************************************************************
1861 *   ADDR_CONVERT_TILEINFOTOHW_INPUT
1862 *
1863 *   @brief
1864 *       Input structure for AddrConvertTileInfoToHW
1865 *   @note
1866 *       When reverse is TRUE, indices are igonred
1867 ***************************************************************************************************
1868 */
1869 typedef struct _ADDR_CONVERT_TILEINFOTOHW_INPUT
1870 {
1871     UINT_32         size;               ///< Size of this structure in bytes
1872     BOOL_32         reverse;            ///< Convert control flag.
1873                                         ///  FALSE: convert from real value to HW value;
1874                                         ///  TRUE: convert from HW value to real value.
1875
1876     /// r800 and later HWL parameters
1877     ADDR_TILEINFO*  pTileInfo;          ///< Tile parameters with real value
1878
1879     INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
1880                                         ///  while the global useTileIndex is set to 1
1881     INT_32          macroModeIndex;     ///< Index in macro tile mode table if there is one (CI)
1882                                         ///< README: When tileIndex is not -1, this must be valid
1883     UINT_32         bpp;                ///< Bits per pixel
1884 } ADDR_CONVERT_TILEINFOTOHW_INPUT;
1885
1886 /**
1887 ***************************************************************************************************
1888 *   ADDR_CONVERT_TILEINFOTOHW_OUTPUT
1889 *
1890 *   @brief
1891 *       Output structure for AddrConvertTileInfoToHW
1892 ***************************************************************************************************
1893 */
1894 typedef struct _ADDR_CONVERT_TILEINFOTOHW_OUTPUT
1895 {
1896     UINT_32             size;               ///< Size of this structure in bytes
1897
1898     /// r800 and later HWL parameters
1899     ADDR_TILEINFO*      pTileInfo;          ///< Tile parameters with hardware register value
1900
1901 } ADDR_CONVERT_TILEINFOTOHW_OUTPUT;
1902
1903 /**
1904 ***************************************************************************************************
1905 *   AddrConvertTileInfoToHW
1906 *
1907 *   @brief
1908 *       Convert tile info from real value to hardware register value
1909 ***************************************************************************************************
1910 */
1911 ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
1912     ADDR_HANDLE                             hLib,
1913     const ADDR_CONVERT_TILEINFOTOHW_INPUT*  pIn,
1914     ADDR_CONVERT_TILEINFOTOHW_OUTPUT*       pOut);
1915
1916
1917
1918 /**
1919 ***************************************************************************************************
1920 *   ADDR_CONVERT_TILEINDEX_INPUT
1921 *
1922 *   @brief
1923 *       Input structure for AddrConvertTileIndex
1924 ***************************************************************************************************
1925 */
1926 typedef struct _ADDR_CONVERT_TILEINDEX_INPUT
1927 {
1928     UINT_32         size;               ///< Size of this structure in bytes
1929
1930     INT_32          tileIndex;          ///< Tile index
1931     INT_32          macroModeIndex;     ///< Index in macro tile mode table if there is one (CI)
1932     UINT_32         bpp;                ///< Bits per pixel
1933     BOOL_32         tileInfoHw;         ///< Set to TRUE if client wants HW enum, otherwise actual
1934 } ADDR_CONVERT_TILEINDEX_INPUT;
1935
1936 /**
1937 ***************************************************************************************************
1938 *   ADDR_CONVERT_TILEINDEX_OUTPUT
1939 *
1940 *   @brief
1941 *       Output structure for AddrConvertTileIndex
1942 ***************************************************************************************************
1943 */
1944 typedef struct _ADDR_CONVERT_TILEINDEX_OUTPUT
1945 {
1946     UINT_32             size;           ///< Size of this structure in bytes
1947
1948     AddrTileMode        tileMode;       ///< Tile mode
1949     AddrTileType        tileType;       ///< Tile type
1950     ADDR_TILEINFO*      pTileInfo;      ///< Tile info
1951
1952 } ADDR_CONVERT_TILEINDEX_OUTPUT;
1953
1954 /**
1955 ***************************************************************************************************
1956 *   AddrConvertTileIndex
1957 *
1958 *   @brief
1959 *       Convert tile index to tile mode/type/info
1960 ***************************************************************************************************
1961 */
1962 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
1963     ADDR_HANDLE                         hLib,
1964     const ADDR_CONVERT_TILEINDEX_INPUT* pIn,
1965     ADDR_CONVERT_TILEINDEX_OUTPUT*      pOut);
1966
1967
1968
1969 /**
1970 ***************************************************************************************************
1971 *   ADDR_CONVERT_TILEINDEX1_INPUT
1972 *
1973 *   @brief
1974 *       Input structure for AddrConvertTileIndex1 (without macro mode index)
1975 ***************************************************************************************************
1976 */
1977 typedef struct _ADDR_CONVERT_TILEINDEX1_INPUT
1978 {
1979     UINT_32         size;               ///< Size of this structure in bytes
1980
1981     INT_32          tileIndex;          ///< Tile index
1982     UINT_32         bpp;                ///< Bits per pixel
1983     UINT_32         numSamples;         ///< Number of samples
1984     BOOL_32         tileInfoHw;         ///< Set to TRUE if client wants HW enum, otherwise actual
1985 } ADDR_CONVERT_TILEINDEX1_INPUT;
1986
1987 /**
1988 ***************************************************************************************************
1989 *   AddrConvertTileIndex1
1990 *
1991 *   @brief
1992 *       Convert tile index to tile mode/type/info
1993 ***************************************************************************************************
1994 */
1995 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
1996     ADDR_HANDLE                             hLib,
1997     const ADDR_CONVERT_TILEINDEX1_INPUT*    pIn,
1998     ADDR_CONVERT_TILEINDEX_OUTPUT*          pOut);
1999
2000
2001
2002 /**
2003 ***************************************************************************************************
2004 *   ADDR_GET_TILEINDEX_INPUT
2005 *
2006 *   @brief
2007 *       Input structure for AddrGetTileIndex
2008 ***************************************************************************************************
2009 */
2010 typedef struct _ADDR_GET_TILEINDEX_INPUT
2011 {
2012     UINT_32         size;           ///< Size of this structure in bytes
2013
2014     AddrTileMode    tileMode;       ///< Tile mode
2015     AddrTileType    tileType;       ///< Tile-type: disp/non-disp/...
2016     ADDR_TILEINFO*  pTileInfo;      ///< Pointer to tile-info structure, can be NULL for linear/1D
2017 } ADDR_GET_TILEINDEX_INPUT;
2018
2019 /**
2020 ***************************************************************************************************
2021 *   ADDR_GET_TILEINDEX_OUTPUT
2022 *
2023 *   @brief
2024 *       Output structure for AddrGetTileIndex
2025 ***************************************************************************************************
2026 */
2027 typedef struct _ADDR_GET_TILEINDEX_OUTPUT
2028 {
2029     UINT_32         size;           ///< Size of this structure in bytes
2030
2031     INT_32          index;          ///< index in table
2032 } ADDR_GET_TILEINDEX_OUTPUT;
2033
2034 /**
2035 ***************************************************************************************************
2036 *   AddrGetTileIndex
2037 *
2038 *   @brief
2039 *       Get the tiling mode index in table
2040 ***************************************************************************************************
2041 */
2042 ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
2043     ADDR_HANDLE                     hLib,
2044     const ADDR_GET_TILEINDEX_INPUT* pIn,
2045     ADDR_GET_TILEINDEX_OUTPUT*      pOut);
2046
2047
2048
2049
2050 /**
2051 ***************************************************************************************************
2052 *   ADDR_PRT_INFO_INPUT
2053 *
2054 *   @brief
2055 *       Input structure for AddrComputePrtInfo
2056 ***************************************************************************************************
2057 */
2058 typedef struct _ADDR_PRT_INFO_INPUT
2059 {
2060     AddrFormat          format;        ///< Surface format
2061     UINT_32             baseMipWidth;  ///< Base mipmap width
2062     UINT_32             baseMipHeight; ///< Base mipmap height
2063     UINT_32             baseMipDepth;  ///< Base mipmap depth
2064     UINT_32             numFrags;      ///< Number of fragments,
2065 } ADDR_PRT_INFO_INPUT;
2066
2067 /**
2068 ***************************************************************************************************
2069 *   ADDR_PRT_INFO_OUTPUT
2070 *
2071 *   @brief
2072 *       Input structure for AddrComputePrtInfo
2073 ***************************************************************************************************
2074 */
2075 typedef struct _ADDR_PRT_INFO_OUTPUT
2076 {
2077     UINT_32             prtTileWidth;
2078     UINT_32             prtTileHeight;
2079 } ADDR_PRT_INFO_OUTPUT;
2080
2081 /**
2082 ***************************************************************************************************
2083 *   AddrComputePrtInfo
2084 *
2085 *   @brief
2086 *       Compute prt surface related information
2087 ***************************************************************************************************
2088 */
2089 ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
2090     ADDR_HANDLE                 hLib,
2091     const ADDR_PRT_INFO_INPUT*  pIn,
2092     ADDR_PRT_INFO_OUTPUT*       pOut);
2093
2094 ///////////////////////////////////////////////////////////////////////////////////////////////////
2095 //                                     DCC key functions
2096 ///////////////////////////////////////////////////////////////////////////////////////////////////
2097
2098 /**
2099 ***************************************************************************************************
2100 *   _ADDR_COMPUTE_DCCINFO_INPUT
2101 *
2102 *   @brief
2103 *       Input structure of AddrComputeDccInfo
2104 ***************************************************************************************************
2105 */
2106 typedef struct _ADDR_COMPUTE_DCCINFO_INPUT
2107 {
2108     UINT_32             size;            ///< Size of this structure in bytes
2109     UINT_32             bpp;             ///< BitPP of color surface
2110     UINT_32             numSamples;      ///< Sample number of color surface
2111     UINT_64             colorSurfSize;   ///< Size of color surface to which dcc key is bound
2112     AddrTileMode        tileMode;        ///< Tile mode of color surface
2113     ADDR_TILEINFO       tileInfo;        ///< Tile info of color surface
2114     UINT_32             tileSwizzle;     ///< Tile swizzle
2115     INT_32              tileIndex;       ///< Tile index of color surface,
2116                                          ///< MUST be -1 if you don't want to use it
2117                                          ///< while the global useTileIndex is set to 1
2118     INT_32              macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
2119                                          ///< README: When tileIndex is not -1, this must be valid
2120 } ADDR_COMPUTE_DCCINFO_INPUT;
2121
2122 /**
2123 ***************************************************************************************************
2124 *   ADDR_COMPUTE_DCCINFO_OUTPUT
2125 *
2126 *   @brief
2127 *       Output structure of AddrComputeDccInfo
2128 ***************************************************************************************************
2129 */
2130 typedef struct _ADDR_COMPUTE_DCCINFO_OUTPUT
2131 {
2132     UINT_32 size;                 ///< Size of this structure in bytes
2133     UINT_64 dccRamBaseAlign;      ///< Base alignment of dcc key
2134     UINT_64 dccRamSize;           ///< Size of dcc key
2135     UINT_64 dccFastClearSize;     ///< Size of dcc key portion that can be fast cleared
2136     BOOL_32 subLvlCompressible;   ///< Whether sub resource is compressiable
2137     BOOL_32 dccRamSizeAligned;    ///< Whether the dcc key size is aligned
2138 } ADDR_COMPUTE_DCCINFO_OUTPUT;
2139
2140 /**
2141 ***************************************************************************************************
2142 *   AddrComputeDccInfo
2143 *
2144 *   @brief
2145 *       Compute DCC key size, base alignment
2146 *       info
2147 ***************************************************************************************************
2148 */
2149 ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
2150     ADDR_HANDLE                             hLib,
2151     const ADDR_COMPUTE_DCCINFO_INPUT*       pIn,
2152     ADDR_COMPUTE_DCCINFO_OUTPUT*            pOut);
2153
2154 /**
2155 ***************************************************************************************************
2156 *   ADDR_GET_MAX_ALINGMENTS_OUTPUT
2157 *
2158 *   @brief
2159 *       Output structure of AddrGetMaxAlignments
2160 ***************************************************************************************************
2161 */
2162 typedef struct _ADDR_GET_MAX_ALINGMENTS_OUTPUT
2163 {
2164     UINT_32 size;                   ///< Size of this structure in bytes
2165     UINT_64 baseAlign;              ///< Maximum base alignment in bytes
2166 } ADDR_GET_MAX_ALINGMENTS_OUTPUT;
2167
2168 /**
2169 ***************************************************************************************************
2170 *   AddrGetMaxAlignments
2171 *
2172 *   @brief
2173 *       Gets maximnum alignments
2174 ***************************************************************************************************
2175 */
2176 ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
2177     ADDR_HANDLE                     hLib,
2178     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut);
2179
2180 #if defined(__cplusplus)
2181 }
2182 #endif
2183
2184 #endif // __ADDR_INTERFACE_H__
2185
2186