src/amd/addrlib/addrinterface.cpp

   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.cpp
  30 * @brief Contains the addrlib interface functions
  31 ****************************************************************************************************
  32 */
  33 #include "addrinterface.h"
  34 #include "addrlib1.h"
  35 #include "addrlib2.h"
  36
  37 #include "addrcommon.h"
  38
  39 #include "util/macros.h"
  40
  41 using namespace Addr;
  42
  43 ////////////////////////////////////////////////////////////////////////////////////////////////////
  44 //                               Create/Destroy/Config functions
  45 ////////////////////////////////////////////////////////////////////////////////////////////////////
  46
  47 /**
  48 ****************************************************************************************************
  49 *   AddrCreate
  50 *
  51 *   @brief
  52 *       Create address lib object
  53 *
  54 *   @return
  55 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
  56 ****************************************************************************************************
  57 */
  58 ADDR_E_RETURNCODE ADDR_API AddrCreate(
  59     const ADDR_CREATE_INPUT*    pAddrCreateIn,  ///< [in] infomation for creating address lib object
  60     ADDR_CREATE_OUTPUT*         pAddrCreateOut) ///< [out] address lib handle
  61 {
  62     ADDR_E_RETURNCODE returnCode = ADDR_OK;
  63
  64     returnCode = Lib::Create(pAddrCreateIn, pAddrCreateOut);
  65
  66     return returnCode;
  67 }
  68
  69
  70
  71 /**
  72 ****************************************************************************************************
  73 *   AddrDestroy
  74 *
  75 *   @brief
  76 *       Destroy address lib object
  77 *
  78 *   @return
  79 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
  80 ****************************************************************************************************
  81 */
  82 ADDR_E_RETURNCODE ADDR_API AddrDestroy(
  83     ADDR_HANDLE hLib) ///< address lib handle
  84 {
  85     ADDR_E_RETURNCODE returnCode = ADDR_OK;
  86
  87     if (hLib)
  88     {
  89         Lib* pLib = Lib::GetLib(hLib);
  90         pLib->Destroy();
  91     }
  92     else
  93     {
  94         returnCode = ADDR_ERROR;
  95     }
  96
  97     return returnCode;
  98 }
  99
 100
 101
 102 ////////////////////////////////////////////////////////////////////////////////////////////////////
 103 //                                    Surface functions
 104 ////////////////////////////////////////////////////////////////////////////////////////////////////
 105
 106 /**
 107 ****************************************************************************************************
 108 *   AddrComputeSurfaceInfo
 109 *
 110 *   @brief
 111 *       Calculate surface width/height/depth/alignments and suitable tiling mode
 112 *
 113 *   @return
 114 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 115 ****************************************************************************************************
 116 */
 117 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
 118     ADDR_HANDLE                             hLib, ///< address lib handle
 119     const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,  ///< [in] surface information
 120     ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut) ///< [out] surface parameters and alignments
 121 {
 122     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 123
 124     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 125
 126     if (pLib != NULL)
 127     {
 128         returnCode = pLib->ComputeSurfaceInfo(pIn, pOut);
 129     }
 130     else
 131     {
 132         returnCode = ADDR_ERROR;
 133     }
 134
 135     return returnCode;
 136 }
 137
 138
 139
 140 /**
 141 ****************************************************************************************************
 142 *   AddrComputeSurfaceAddrFromCoord
 143 *
 144 *   @brief
 145 *       Compute surface address according to coordinates
 146 *
 147 *   @return
 148 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 149 ****************************************************************************************************
 150 */
 151 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
 152     ADDR_HANDLE                                     hLib, ///< address lib handle
 153     const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,  ///< [in] surface info and coordinates
 154     ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT*      pOut) ///< [out] surface address
 155 {
 156     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 157
 158     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 159
 160     if (pLib != NULL)
 161     {
 162         returnCode = pLib->ComputeSurfaceAddrFromCoord(pIn, pOut);
 163     }
 164     else
 165     {
 166         returnCode = ADDR_ERROR;
 167     }
 168
 169     return returnCode;
 170 }
 171
 172 /**
 173 ****************************************************************************************************
 174 *   AddrComputeSurfaceCoordFromAddr
 175 *
 176 *   @brief
 177 *       Compute coordinates according to surface address
 178 *
 179 *   @return
 180 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 181 ****************************************************************************************************
 182 */
 183 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
 184     ADDR_HANDLE                                     hLib, ///< address lib handle
 185     const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,  ///< [in] surface info and address
 186     ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT*      pOut) ///< [out] coordinates
 187 {
 188     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 189
 190     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 191
 192     if (pLib != NULL)
 193     {
 194         returnCode = pLib->ComputeSurfaceCoordFromAddr(pIn, pOut);
 195     }
 196     else
 197     {
 198         returnCode = ADDR_ERROR;
 199     }
 200
 201     return returnCode;
 202 }
 203
 204
 205
 206 ////////////////////////////////////////////////////////////////////////////////////////////////////
 207 //                                   HTile functions
 208 ////////////////////////////////////////////////////////////////////////////////////////////////////
 209
 210 /**
 211 ****************************************************************************************************
 212 *   AddrComputeHtileInfo
 213 *
 214 *   @brief
 215 *       Compute Htile pitch, height, base alignment and size in bytes
 216 *
 217 *   @return
 218 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 219 ****************************************************************************************************
 220 */
 221 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
 222     ADDR_HANDLE                             hLib, ///< address lib handle
 223     const ADDR_COMPUTE_HTILE_INFO_INPUT*    pIn,  ///< [in] Htile information
 224     ADDR_COMPUTE_HTILE_INFO_OUTPUT*         pOut) ///< [out] Htile pitch, height and size in bytes
 225 {
 226     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 227
 228     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 229
 230     if (pLib != NULL)
 231     {
 232         returnCode = pLib->ComputeHtileInfo(pIn, pOut);
 233     }
 234     else
 235     {
 236         returnCode = ADDR_ERROR;
 237     }
 238
 239     return returnCode;
 240 }
 241
 242 /**
 243 ****************************************************************************************************
 244 *   AddrComputeHtileAddrFromCoord
 245 *
 246 *   @brief
 247 *       Compute Htile address according to coordinates (of depth buffer)
 248 *
 249 *   @return
 250 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 251 ****************************************************************************************************
 252 */
 253 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
 254     ADDR_HANDLE                                     hLib, ///< address lib handle
 255     const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Htile info and coordinates
 256     ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Htile address
 257 {
 258     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 259
 260     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 261
 262     if (pLib != NULL)
 263     {
 264         returnCode = pLib->ComputeHtileAddrFromCoord(pIn, pOut);
 265     }
 266     else
 267     {
 268         returnCode = ADDR_ERROR;
 269     }
 270
 271     return returnCode;
 272 }
 273
 274 /**
 275 ****************************************************************************************************
 276 *   AddrComputeHtileCoordFromAddr
 277 *
 278 *   @brief
 279 *       Compute coordinates within depth buffer (1st pixel of a micro tile) according to
 280 *       Htile address
 281 *
 282 *   @return
 283 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 284 ****************************************************************************************************
 285 */
 286 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
 287     ADDR_HANDLE                                     hLib, ///< address lib handle
 288     const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT*   pIn,  ///< [in] Htile info and address
 289     ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Htile coordinates
 290 {
 291     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 292
 293     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 294
 295     if (pLib != NULL)
 296     {
 297         returnCode = pLib->ComputeHtileCoordFromAddr(pIn, pOut);
 298     }
 299     else
 300     {
 301         returnCode = ADDR_ERROR;
 302     }
 303
 304     return returnCode;
 305 }
 306
 307
 308
 309 ////////////////////////////////////////////////////////////////////////////////////////////////////
 310 //                                     C-mask functions
 311 ////////////////////////////////////////////////////////////////////////////////////////////////////
 312
 313 /**
 314 ****************************************************************************************************
 315 *   AddrComputeCmaskInfo
 316 *
 317 *   @brief
 318 *       Compute Cmask pitch, height, base alignment and size in bytes from color buffer
 319 *       info
 320 *
 321 *   @return
 322 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 323 ****************************************************************************************************
 324 */
 325 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
 326     ADDR_HANDLE                             hLib, ///< address lib handle
 327     const ADDR_COMPUTE_CMASK_INFO_INPUT*    pIn,  ///< [in] Cmask pitch and height
 328     ADDR_COMPUTE_CMASK_INFO_OUTPUT*         pOut) ///< [out] Cmask pitch, height and size in bytes
 329 {
 330     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 331
 332     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 333
 334     if (pLib != NULL)
 335     {
 336         returnCode = pLib->ComputeCmaskInfo(pIn, pOut);
 337     }
 338     else
 339     {
 340         returnCode = ADDR_ERROR;
 341     }
 342
 343     return returnCode;
 344 }
 345
 346 /**
 347 ****************************************************************************************************
 348 *   AddrComputeCmaskAddrFromCoord
 349 *
 350 *   @brief
 351 *       Compute Cmask address according to coordinates (of MSAA color buffer)
 352 *
 353 *   @return
 354 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 355 ****************************************************************************************************
 356 */
 357 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
 358     ADDR_HANDLE                                     hLib, ///< address lib handle
 359     const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Cmask info and coordinates
 360     ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Cmask address
 361 {
 362     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 363
 364     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 365
 366     if (pLib != NULL)
 367     {
 368         returnCode = pLib->ComputeCmaskAddrFromCoord(pIn, pOut);
 369     }
 370     else
 371     {
 372         returnCode = ADDR_ERROR;
 373     }
 374
 375     return returnCode;
 376 }
 377
 378 /**
 379 ****************************************************************************************************
 380 *   AddrComputeCmaskCoordFromAddr
 381 *
 382 *   @brief
 383 *       Compute coordinates within color buffer (1st pixel of a micro tile) according to
 384 *       Cmask address
 385 *
 386 *   @return
 387 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 388 ****************************************************************************************************
 389 */
 390 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
 391     ADDR_HANDLE                                     hLib, ///< address lib handle
 392     const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT*   pIn,  ///< [in] Cmask info and address
 393     ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Cmask coordinates
 394 {
 395     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 396
 397     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 398
 399     if (pLib != NULL)
 400     {
 401         returnCode = pLib->ComputeCmaskCoordFromAddr(pIn, pOut);
 402     }
 403     else
 404     {
 405         returnCode = ADDR_ERROR;
 406     }
 407
 408     return returnCode;
 409 }
 410
 411
 412
 413 ////////////////////////////////////////////////////////////////////////////////////////////////////
 414 //                                     F-mask functions
 415 ////////////////////////////////////////////////////////////////////////////////////////////////////
 416
 417 /**
 418 ****************************************************************************************************
 419 *   AddrComputeFmaskInfo
 420 *
 421 *   @brief
 422 *       Compute Fmask pitch/height/depth/alignments and size in bytes
 423 *
 424 *   @return
 425 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 426 ****************************************************************************************************
 427 */
 428 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
 429     ADDR_HANDLE                             hLib, ///< address lib handle
 430     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,  ///< [in] Fmask information
 431     ADDR_COMPUTE_FMASK_INFO_OUTPUT*         pOut) ///< [out] Fmask pitch and height
 432 {
 433     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 434
 435     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 436
 437     if (pLib != NULL)
 438     {
 439         returnCode = pLib->ComputeFmaskInfo(pIn, pOut);
 440     }
 441     else
 442     {
 443         returnCode = ADDR_ERROR;
 444     }
 445
 446     return returnCode;
 447 }
 448
 449 /**
 450 ****************************************************************************************************
 451 *   AddrComputeFmaskAddrFromCoord
 452 *
 453 *   @brief
 454 *       Compute Fmask address according to coordinates (x,y,slice,sample,plane)
 455 *
 456 *   @return
 457 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 458 ****************************************************************************************************
 459 */
 460 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
 461     ADDR_HANDLE                                     hLib, ///< address lib handle
 462     const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Fmask info and coordinates
 463     ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Fmask address
 464 {
 465     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 466
 467     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 468
 469     if (pLib != NULL)
 470     {
 471         returnCode = pLib->ComputeFmaskAddrFromCoord(pIn, pOut);
 472     }
 473     else
 474     {
 475         returnCode = ADDR_ERROR;
 476     }
 477
 478     return returnCode;
 479 }
 480
 481 /**
 482 ****************************************************************************************************
 483 *   AddrComputeFmaskCoordFromAddr
 484 *
 485 *   @brief
 486 *       Compute coordinates (x,y,slice,sample,plane) according to Fmask address
 487 *
 488 *   @return
 489 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 490 ****************************************************************************************************
 491 */
 492 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
 493     ADDR_HANDLE                                     hLib, ///< address lib handle
 494     const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*   pIn,  ///< [in] Fmask info and address
 495     ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Fmask coordinates
 496 {
 497     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 498
 499     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 500
 501     if (pLib != NULL)
 502     {
 503         returnCode = pLib->ComputeFmaskCoordFromAddr(pIn, pOut);
 504     }
 505     else
 506     {
 507         returnCode = ADDR_ERROR;
 508     }
 509
 510     return returnCode;
 511 }
 512
 513
 514
 515 ////////////////////////////////////////////////////////////////////////////////////////////////////
 516 //                                     DCC key functions
 517 ////////////////////////////////////////////////////////////////////////////////////////////////////
 518
 519 /**
 520 ****************************************************************************************************
 521 *   AddrComputeDccInfo
 522 *
 523 *   @brief
 524 *       Compute DCC key size, base alignment based on color surface size, tile info or tile index
 525 *
 526 ****************************************************************************************************
 527 */
 528 ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
 529     ADDR_HANDLE                             hLib,   ///< handle of addrlib
 530     const ADDR_COMPUTE_DCCINFO_INPUT*       pIn,    ///< [in] input
 531     ADDR_COMPUTE_DCCINFO_OUTPUT*            pOut)   ///< [out] output
 532 {
 533     ADDR_E_RETURNCODE returnCode;
 534
 535     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 536
 537     if (pLib != NULL)
 538     {
 539         returnCode = pLib->ComputeDccInfo(pIn, pOut);
 540     }
 541     else
 542     {
 543         returnCode = ADDR_ERROR;
 544     }
 545
 546     return returnCode;
 547 }
 548
 549
 550
 551 ///////////////////////////////////////////////////////////////////////////////
 552 // Below functions are element related or helper functions
 553 ///////////////////////////////////////////////////////////////////////////////
 554
 555 /**
 556 ****************************************************************************************************
 557 *   AddrGetVersion
 558 *
 559 *   @brief
 560 *       Get AddrLib version number. Client may check this return value against ADDRLIB_VERSION
 561 *       defined in addrinterface.h to see if there is a mismatch.
 562 ****************************************************************************************************
 563 */
 564 UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib)
 565 {
 566     UINT_32 version = 0;
 567
 568     Addr::Lib* pLib = Lib::GetLib(hLib);
 569
 570     ADDR_ASSERT(pLib != NULL);
 571
 572     if (pLib)
 573     {
 574         version = pLib->GetVersion();
 575     }
 576
 577     return version;
 578 }
 579
 580 /**
 581 ****************************************************************************************************
 582 *   AddrUseTileIndex
 583 *
 584 *   @brief
 585 *       Return TRUE if tileIndex is enabled in this address library
 586 ****************************************************************************************************
 587 */
 588 BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib)
 589 {
 590     BOOL_32 useTileIndex = FALSE;
 591
 592     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 593
 594     ADDR_ASSERT(pLib != NULL);
 595
 596     if (pLib)
 597     {
 598         useTileIndex = pLib->UseTileIndex(0);
 599     }
 600
 601     return useTileIndex;
 602 }
 603
 604 /**
 605 ****************************************************************************************************
 606 *   AddrUseCombinedSwizzle
 607 *
 608 *   @brief
 609 *       Return TRUE if combined swizzle is enabled in this address library
 610 ****************************************************************************************************
 611 */
 612 BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib)
 613 {
 614     BOOL_32 useCombinedSwizzle = FALSE;
 615
 616     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 617
 618     ADDR_ASSERT(pLib != NULL);
 619
 620     if (pLib)
 621     {
 622         useCombinedSwizzle = pLib->UseCombinedSwizzle();
 623     }
 624
 625     return useCombinedSwizzle;
 626 }
 627
 628 /**
 629 ****************************************************************************************************
 630 *   AddrExtractBankPipeSwizzle
 631 *
 632 *   @brief
 633 *       Extract Bank and Pipe swizzle from base256b
 634 *   @return
 635 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 636 ****************************************************************************************************
 637 */
 638 ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
 639     ADDR_HANDLE                                 hLib,     ///< addrlib handle
 640     const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT*  pIn,      ///< [in] input structure
 641     ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT*       pOut)     ///< [out] output structure
 642 {
 643     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 644
 645     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 646
 647     if (pLib != NULL)
 648     {
 649         returnCode = pLib->ExtractBankPipeSwizzle(pIn, pOut);
 650     }
 651     else
 652     {
 653         returnCode = ADDR_ERROR;
 654     }
 655
 656     return returnCode;
 657 }
 658
 659 /**
 660 ****************************************************************************************************
 661 *   AddrCombineBankPipeSwizzle
 662 *
 663 *   @brief
 664 *       Combine Bank and Pipe swizzle
 665 *   @return
 666 *       ADDR_E_RETURNCODE
 667 ****************************************************************************************************
 668 */
 669 ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
 670     ADDR_HANDLE                                 hLib,
 671     const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT*  pIn,
 672     ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT*       pOut)
 673 {
 674     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 675
 676     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 677
 678     if (pLib != NULL)
 679     {
 680         returnCode = pLib->CombineBankPipeSwizzle(pIn, pOut);
 681     }
 682     else
 683     {
 684         returnCode = ADDR_ERROR;
 685     }
 686
 687     return returnCode;
 688 }
 689
 690 /**
 691 ****************************************************************************************************
 692 *   AddrComputeSliceSwizzle
 693 *
 694 *   @brief
 695 *       Compute a swizzle for slice from a base swizzle
 696 *   @return
 697 *       ADDR_OK if no error
 698 ****************************************************************************************************
 699 */
 700 ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
 701     ADDR_HANDLE                                 hLib,
 702     const ADDR_COMPUTE_SLICESWIZZLE_INPUT*      pIn,
 703     ADDR_COMPUTE_SLICESWIZZLE_OUTPUT*           pOut)
 704 {
 705     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 706
 707     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 708
 709     if (pLib != NULL)
 710     {
 711         returnCode = pLib->ComputeSliceTileSwizzle(pIn, pOut);
 712     }
 713     else
 714     {
 715         returnCode = ADDR_ERROR;
 716     }
 717
 718     return returnCode;
 719 }
 720
 721 /**
 722 ****************************************************************************************************
 723 *   AddrComputeBaseSwizzle
 724 *
 725 *   @brief
 726 *       Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
 727 *   @return
 728 *       ADDR_OK if no error
 729 ****************************************************************************************************
 730 */
 731 ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
 732     ADDR_HANDLE                             hLib,
 733     const ADDR_COMPUTE_BASE_SWIZZLE_INPUT*  pIn,
 734     ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT*       pOut)
 735 {
 736     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 737
 738     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 739
 740     if (pLib != NULL)
 741     {
 742         returnCode = pLib->ComputeBaseSwizzle(pIn, pOut);
 743     }
 744     else
 745     {
 746         returnCode = ADDR_ERROR;
 747     }
 748
 749     return returnCode;
 750 }
 751
 752 /**
 753 ****************************************************************************************************
 754 *   ElemFlt32ToDepthPixel
 755 *
 756 *   @brief
 757 *       Convert a FLT_32 value to a depth/stencil pixel value
 758 *
 759 *   @return
 760 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 761 *
 762 ****************************************************************************************************
 763 */
 764 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
 765     ADDR_HANDLE                         hLib,    ///< addrlib handle
 766     const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,     ///< [in] per-component value
 767     ELEM_FLT32TODEPTHPIXEL_OUTPUT*      pOut)    ///< [out] final pixel value
 768 {
 769     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 770
 771     Lib* pLib = Lib::GetLib(hLib);
 772
 773     if (pLib != NULL)
 774     {
 775         pLib->Flt32ToDepthPixel(pIn, pOut);
 776     }
 777     else
 778     {
 779         returnCode = ADDR_ERROR;
 780     }
 781
 782     return returnCode;
 783 }
 784
 785 /**
 786 ****************************************************************************************************
 787 *   ElemFlt32ToColorPixel
 788 *
 789 *   @brief
 790 *       Convert a FLT_32 value to a red/green/blue/alpha pixel value
 791 *
 792 *   @return
 793 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 794 *
 795 ****************************************************************************************************
 796 */
 797 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
 798     ADDR_HANDLE                         hLib,    ///< addrlib handle
 799     const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,     ///< [in] format, surface number and swap value
 800     ELEM_FLT32TOCOLORPIXEL_OUTPUT*      pOut)    ///< [out] final pixel value
 801 {
 802     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 803
 804     Lib* pLib = Lib::GetLib(hLib);
 805
 806     if (pLib != NULL)
 807     {
 808         pLib->Flt32ToColorPixel(pIn, pOut);
 809     }
 810     else
 811     {
 812         returnCode = ADDR_ERROR;
 813     }
 814
 815     return returnCode;
 816 }
 817
 818 /**
 819 ****************************************************************************************************
 820 *   ElemGetExportNorm
 821 *
 822 *   @brief
 823 *       Helper function to check one format can be EXPORT_NUM,
 824 *       which is a register CB_COLOR_INFO.SURFACE_FORMAT.
 825 *       FP16 can be reported as EXPORT_NORM for rv770 in r600
 826 *       family
 827 *
 828 ****************************************************************************************************
 829 */
 830 BOOL_32 ADDR_API ElemGetExportNorm(
 831     ADDR_HANDLE                     hLib, ///< addrlib handle
 832     const ELEM_GETEXPORTNORM_INPUT* pIn)  ///< [in] input structure
 833 {
 834     Addr::Lib* pLib = Lib::GetLib(hLib);
 835     BOOL_32 enabled = FALSE;
 836
 837     MAYBE_UNUSED ADDR_E_RETURNCODE returnCode = ADDR_OK;
 838
 839     if (pLib != NULL)
 840     {
 841         enabled = pLib->GetExportNorm(pIn);
 842     }
 843     else
 844     {
 845         returnCode = ADDR_ERROR;
 846     }
 847
 848     ADDR_ASSERT(returnCode == ADDR_OK);
 849
 850     return enabled;
 851 }
 852
 853 /**
 854 ****************************************************************************************************
 855 *   AddrConvertTileInfoToHW
 856 *
 857 *   @brief
 858 *       Convert tile info from real value to hardware register value
 859 *
 860 *   @return
 861 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 862 ****************************************************************************************************
 863 */
 864 ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
 865     ADDR_HANDLE                             hLib, ///< address lib handle
 866     const ADDR_CONVERT_TILEINFOTOHW_INPUT*  pIn,  ///< [in] tile info with real value
 867     ADDR_CONVERT_TILEINFOTOHW_OUTPUT*       pOut) ///< [out] tile info with HW register value
 868 {
 869     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 870
 871     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 872
 873     if (pLib != NULL)
 874     {
 875         returnCode = pLib->ConvertTileInfoToHW(pIn, pOut);
 876     }
 877     else
 878     {
 879         returnCode = ADDR_ERROR;
 880     }
 881
 882     return returnCode;
 883 }
 884
 885 /**
 886 ****************************************************************************************************
 887 *   AddrConvertTileIndex
 888 *
 889 *   @brief
 890 *       Convert tile index to tile mode/type/info
 891 *
 892 *   @return
 893 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 894 ****************************************************************************************************
 895 */
 896 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
 897     ADDR_HANDLE                          hLib, ///< address lib handle
 898     const ADDR_CONVERT_TILEINDEX_INPUT*  pIn,  ///< [in] input - tile index
 899     ADDR_CONVERT_TILEINDEX_OUTPUT*       pOut) ///< [out] tile mode/type/info
 900 {
 901     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 902
 903     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 904
 905     if (pLib != NULL)
 906     {
 907         returnCode = pLib->ConvertTileIndex(pIn, pOut);
 908     }
 909     else
 910     {
 911         returnCode = ADDR_ERROR;
 912     }
 913
 914     return returnCode;
 915 }
 916
 917 /**
 918 ****************************************************************************************************
 919 *   AddrGetMacroModeIndex
 920 *
 921 *   @brief
 922 *       Get macro mode index based on input parameters
 923 *
 924 *   @return
 925 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 926 ****************************************************************************************************
 927 */
 928 ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
 929     ADDR_HANDLE                          hLib, ///< address lib handle
 930     const ADDR_GET_MACROMODEINDEX_INPUT* pIn,  ///< [in] input
 931     ADDR_GET_MACROMODEINDEX_OUTPUT*      pOut) ///< [out] macro mode index
 932 {
 933     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 934
 935     ADDR_E_RETURNCODE returnCode;
 936
 937     if (pLib != NULL)
 938     {
 939         returnCode = pLib->GetMacroModeIndex(pIn, pOut);
 940     }
 941     else
 942     {
 943         returnCode = ADDR_ERROR;
 944     }
 945
 946     return returnCode;
 947 }
 948
 949 /**
 950 ****************************************************************************************************
 951 *   AddrConvertTileIndex1
 952 *
 953 *   @brief
 954 *       Convert tile index to tile mode/type/info
 955 *
 956 *   @return
 957 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 958 ****************************************************************************************************
 959 */
 960 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
 961     ADDR_HANDLE                          hLib, ///< address lib handle
 962     const ADDR_CONVERT_TILEINDEX1_INPUT* pIn,  ///< [in] input - tile index
 963     ADDR_CONVERT_TILEINDEX_OUTPUT*       pOut) ///< [out] tile mode/type/info
 964 {
 965     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 966
 967     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 968
 969     if (pLib != NULL)
 970     {
 971         returnCode = pLib->ConvertTileIndex1(pIn, pOut);
 972     }
 973     else
 974     {
 975         returnCode = ADDR_ERROR;
 976     }
 977
 978     return returnCode;
 979 }
 980
 981 /**
 982 ****************************************************************************************************
 983 *   AddrGetTileIndex
 984 *
 985 *   @brief
 986 *       Get tile index from tile mode/type/info
 987 *
 988 *   @return
 989 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 990 *
 991 *   @note
 992 *       Only meaningful for SI (and above)
 993 ****************************************************************************************************
 994 */
 995 ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
 996     ADDR_HANDLE                     hLib,
 997     const ADDR_GET_TILEINDEX_INPUT* pIn,
 998     ADDR_GET_TILEINDEX_OUTPUT*      pOut)
 999 {
1000     V1::Lib* pLib = V1::Lib::GetLib(hLib);
1001
1002     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1003
1004     if (pLib != NULL)
1005     {
1006         returnCode = pLib->GetTileIndex(pIn, pOut);
1007     }
1008     else
1009     {
1010         returnCode = ADDR_ERROR;
1011     }
1012
1013     return returnCode;
1014 }
1015
1016 /**
1017 ****************************************************************************************************
1018 *   AddrComputePrtInfo
1019 *
1020 *   @brief
1021 *       Interface function for ComputePrtInfo
1022 *
1023 ****************************************************************************************************
1024 */
1025 ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
1026     ADDR_HANDLE                 hLib,
1027     const ADDR_PRT_INFO_INPUT*  pIn,
1028     ADDR_PRT_INFO_OUTPUT*       pOut)
1029 {
1030     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1031
1032     V1::Lib* pLib = V1::Lib::GetLib(hLib);
1033
1034     if (pLib != NULL)
1035     {
1036         returnCode = pLib->ComputePrtInfo(pIn, pOut);
1037     }
1038     else
1039     {
1040         returnCode = ADDR_ERROR;
1041     }
1042
1043     return returnCode;
1044 }
1045
1046 /**
1047 ****************************************************************************************************
1048 *   AddrGetMaxAlignments
1049 *
1050 *   @brief
1051 *       Convert maximum alignments
1052 *
1053 *   @return
1054 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1055 ****************************************************************************************************
1056 */
1057 ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
1058     ADDR_HANDLE                     hLib, ///< address lib handle
1059     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut) ///< [out] output structure
1060 {
1061     Addr::Lib* pLib = Lib::GetLib(hLib);
1062
1063     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1064
1065     if (pLib != NULL)
1066     {
1067         returnCode = pLib->GetMaxAlignments(pOut);
1068     }
1069     else
1070     {
1071         returnCode = ADDR_ERROR;
1072     }
1073
1074     return returnCode;
1075 }
1076
1077 /**
1078 ****************************************************************************************************
1079 *   AddrGetMaxMetaAlignments
1080 *
1081 *   @brief
1082 *       Convert maximum alignments for metadata
1083 *
1084 *   @return
1085 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1086 ****************************************************************************************************
1087 */
1088 ADDR_E_RETURNCODE ADDR_API AddrGetMaxMetaAlignments(
1089     ADDR_HANDLE                     hLib, ///< address lib handle
1090     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut) ///< [out] output structure
1091 {
1092     Addr::Lib* pLib = Lib::GetLib(hLib);
1093
1094     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1095
1096     if (pLib != NULL)
1097     {
1098         returnCode = pLib->GetMaxMetaAlignments(pOut);
1099     }
1100     else
1101     {
1102         returnCode = ADDR_ERROR;
1103     }
1104
1105     return returnCode;
1106 }
1107
1108
1109 ////////////////////////////////////////////////////////////////////////////////////////////////////
1110 //                                    Surface functions for Addr2
1111 ////////////////////////////////////////////////////////////////////////////////////////////////////
1112
1113 /**
1114 ****************************************************************************************************
1115 *   Addr2ComputeSurfaceInfo
1116 *
1117 *   @brief
1118 *       Calculate surface width/height/depth/alignments and suitable tiling mode
1119 *
1120 *   @return
1121 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1122 ****************************************************************************************************
1123 */
1124 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceInfo(
1125     ADDR_HANDLE                                hLib, ///< address lib handle
1126     const ADDR2_COMPUTE_SURFACE_INFO_INPUT*    pIn,  ///< [in] surface information
1127     ADDR2_COMPUTE_SURFACE_INFO_OUTPUT*         pOut) ///< [out] surface parameters and alignments
1128 {
1129     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1130
1131     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1132
1133     if (pLib != NULL)
1134     {
1135         returnCode = pLib->ComputeSurfaceInfo(pIn, pOut);
1136     }
1137     else
1138     {
1139         returnCode = ADDR_ERROR;
1140     }
1141
1142     return returnCode;
1143 }
1144
1145
1146 /**
1147 ****************************************************************************************************
1148 *   Addr2ComputeSurfaceAddrFromCoord
1149 *
1150 *   @brief
1151 *       Compute surface address according to coordinates
1152 *
1153 *   @return
1154 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1155 ****************************************************************************************************
1156 */
1157 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceAddrFromCoord(
1158     ADDR_HANDLE                                         hLib, ///< address lib handle
1159     const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT*    pIn,  ///< [in] surface info and coordinates
1160     ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT*         pOut) ///< [out] surface address
1161 {
1162     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1163
1164     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1165
1166     if (pLib != NULL)
1167     {
1168         returnCode = pLib->ComputeSurfaceAddrFromCoord(pIn, pOut);
1169     }
1170     else
1171     {
1172         returnCode = ADDR_ERROR;
1173     }
1174
1175     return returnCode;
1176 }
1177
1178
1179 /**
1180 ****************************************************************************************************
1181 *   Addr2ComputeSurfaceCoordFromAddr
1182 *
1183 *   @brief
1184 *       Compute coordinates according to surface address
1185 *
1186 *   @return
1187 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1188 ****************************************************************************************************
1189 */
1190 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceCoordFromAddr(
1191     ADDR_HANDLE                                         hLib, ///< address lib handle
1192     const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT*    pIn,  ///< [in] surface info and address
1193     ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT*         pOut) ///< [out] coordinates
1194 {
1195     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1196
1197     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1198
1199     if (pLib != NULL)
1200     {
1201         returnCode = pLib->ComputeSurfaceCoordFromAddr(pIn, pOut);
1202     }
1203     else
1204     {
1205         returnCode = ADDR_ERROR;
1206     }
1207
1208     return returnCode;
1209 }
1210
1211
1212
1213 ////////////////////////////////////////////////////////////////////////////////////////////////////
1214 //                                   HTile functions for Addr2
1215 ////////////////////////////////////////////////////////////////////////////////////////////////////
1216
1217 /**
1218 ****************************************************************************************************
1219 *   Addr2ComputeHtileInfo
1220 *
1221 *   @brief
1222 *       Compute Htile pitch, height, base alignment and size in bytes
1223 *
1224 *   @return
1225 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1226 ****************************************************************************************************
1227 */
1228 ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileInfo(
1229     ADDR_HANDLE                              hLib, ///< address lib handle
1230     const ADDR2_COMPUTE_HTILE_INFO_INPUT*    pIn,  ///< [in] Htile information
1231     ADDR2_COMPUTE_HTILE_INFO_OUTPUT*         pOut) ///< [out] Htile pitch, height and size in bytes
1232 {
1233     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1234
1235     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1236
1237     if (pLib != NULL)
1238     {
1239         returnCode = pLib->ComputeHtileInfo(pIn, pOut);
1240     }
1241     else
1242     {
1243         returnCode = ADDR_ERROR;
1244     }
1245
1246     return returnCode;
1247 }
1248
1249
1250 /**
1251 ****************************************************************************************************
1252 *   Addr2ComputeHtileAddrFromCoord
1253 *
1254 *   @brief
1255 *       Compute Htile address according to coordinates (of depth buffer)
1256 *
1257 *   @return
1258 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1259 ****************************************************************************************************
1260 */
1261 ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileAddrFromCoord(
1262     ADDR_HANDLE                                       hLib, ///< address lib handle
1263     const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*    pIn,  ///< [in] Htile info and coordinates
1264     ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT*         pOut) ///< [out] Htile address
1265 {
1266     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1267
1268     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1269
1270     if (pLib != NULL)
1271     {
1272         returnCode = pLib->ComputeHtileAddrFromCoord(pIn, pOut);
1273     }
1274     else
1275     {
1276         returnCode = ADDR_ERROR;
1277     }
1278
1279     return returnCode;
1280 }
1281
1282
1283 /**
1284 ****************************************************************************************************
1285 *   Addr2ComputeHtileCoordFromAddr
1286 *
1287 *   @brief
1288 *       Compute coordinates within depth buffer (1st pixel of a micro tile) according to
1289 *       Htile address
1290 *
1291 *   @return
1292 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1293 ****************************************************************************************************
1294 */
1295 ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileCoordFromAddr(
1296     ADDR_HANDLE                                       hLib, ///< address lib handle
1297     const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT*    pIn,  ///< [in] Htile info and address
1298     ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT*         pOut) ///< [out] Htile coordinates
1299 {
1300     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1301
1302     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1303
1304     if (pLib != NULL)
1305     {
1306         returnCode = pLib->ComputeHtileCoordFromAddr(pIn, pOut);
1307     }
1308     else
1309     {
1310         returnCode = ADDR_ERROR;
1311     }
1312
1313     return returnCode;
1314 }
1315
1316
1317
1318 ////////////////////////////////////////////////////////////////////////////////////////////////////
1319 //                                     C-mask functions for Addr2
1320 ////////////////////////////////////////////////////////////////////////////////////////////////////
1321
1322 /**
1323 ****************************************************************************************************
1324 *   Addr2ComputeCmaskInfo
1325 *
1326 *   @brief
1327 *       Compute Cmask pitch, height, base alignment and size in bytes from color buffer
1328 *       info
1329 *
1330 *   @return
1331 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1332 ****************************************************************************************************
1333 */
1334 ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskInfo(
1335     ADDR_HANDLE                              hLib, ///< address lib handle
1336     const ADDR2_COMPUTE_CMASK_INFO_INPUT*    pIn,  ///< [in] Cmask pitch and height
1337     ADDR2_COMPUTE_CMASK_INFO_OUTPUT*         pOut) ///< [out] Cmask pitch, height and size in bytes
1338 {
1339     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1340
1341     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1342
1343     if (pLib != NULL)
1344     {
1345         returnCode = pLib->ComputeCmaskInfo(pIn, pOut);
1346     }
1347     else
1348     {
1349         returnCode = ADDR_ERROR;
1350     }
1351
1352     return returnCode;
1353 }
1354
1355
1356 /**
1357 ****************************************************************************************************
1358 *   Addr2ComputeCmaskAddrFromCoord
1359 *
1360 *   @brief
1361 *       Compute Cmask address according to coordinates (of MSAA color buffer)
1362 *
1363 *   @return
1364 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1365 ****************************************************************************************************
1366 */
1367 ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskAddrFromCoord(
1368     ADDR_HANDLE                                       hLib, ///< address lib handle
1369     const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*    pIn,  ///< [in] Cmask info and coordinates
1370     ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT*         pOut) ///< [out] Cmask address
1371 {
1372     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1373
1374     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1375
1376     if (pLib != NULL)
1377     {
1378         returnCode = pLib->ComputeCmaskAddrFromCoord(pIn, pOut);
1379     }
1380     else
1381     {
1382         returnCode = ADDR_ERROR;
1383     }
1384
1385     return returnCode;
1386 }
1387
1388
1389 /**
1390 ****************************************************************************************************
1391 *   Addr2ComputeCmaskCoordFromAddr
1392 *
1393 *   @brief
1394 *       Compute coordinates within color buffer (1st pixel of a micro tile) according to
1395 *       Cmask address
1396 *
1397 *   @return
1398 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1399 ****************************************************************************************************
1400 */
1401 ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskCoordFromAddr(
1402     ADDR_HANDLE                                       hLib, ///< address lib handle
1403     const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT*    pIn,  ///< [in] Cmask info and address
1404     ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT*         pOut) ///< [out] Cmask coordinates
1405 {
1406     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1407
1408     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1409
1410     if (pLib != NULL)
1411     {
1412         returnCode = pLib->ComputeCmaskCoordFromAddr(pIn, pOut);
1413     }
1414     else
1415     {
1416         returnCode = ADDR_ERROR;
1417     }
1418
1419     return returnCode;
1420 }
1421
1422
1423
1424 ////////////////////////////////////////////////////////////////////////////////////////////////////
1425 //                                     F-mask functions for Addr2
1426 ////////////////////////////////////////////////////////////////////////////////////////////////////
1427
1428 /**
1429 ****************************************************************************************************
1430 *   Addr2ComputeFmaskInfo
1431 *
1432 *   @brief
1433 *       Compute Fmask pitch/height/depth/alignments and size in bytes
1434 *
1435 *   @return
1436 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1437 ****************************************************************************************************
1438 */
1439 ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskInfo(
1440     ADDR_HANDLE                              hLib, ///< address lib handle
1441     const ADDR2_COMPUTE_FMASK_INFO_INPUT*    pIn,  ///< [in] Fmask information
1442     ADDR2_COMPUTE_FMASK_INFO_OUTPUT*         pOut) ///< [out] Fmask pitch and height
1443 {
1444     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1445
1446     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1447
1448     if (pLib != NULL)
1449     {
1450         returnCode = pLib->ComputeFmaskInfo(pIn, pOut);
1451     }
1452     else
1453     {
1454         returnCode = ADDR_ERROR;
1455     }
1456
1457     return returnCode;
1458 }
1459
1460
1461 /**
1462 ****************************************************************************************************
1463 *   Addr2ComputeFmaskAddrFromCoord
1464 *
1465 *   @brief
1466 *       Compute Fmask address according to coordinates (x,y,slice,sample,plane)
1467 *
1468 *   @return
1469 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1470 ****************************************************************************************************
1471 */
1472 ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskAddrFromCoord(
1473     ADDR_HANDLE                                       hLib, ///< address lib handle
1474     const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*    pIn,  ///< [in] Fmask info and coordinates
1475     ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*         pOut) ///< [out] Fmask address
1476 {
1477     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1478
1479     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1480
1481     if (pLib != NULL)
1482     {
1483         returnCode = pLib->ComputeFmaskAddrFromCoord(pIn, pOut);
1484     }
1485     else
1486     {
1487         returnCode = ADDR_ERROR;
1488     }
1489
1490     return returnCode;
1491 }
1492
1493
1494 /**
1495 ****************************************************************************************************
1496 *   Addr2ComputeFmaskCoordFromAddr
1497 *
1498 *   @brief
1499 *       Compute coordinates (x,y,slice,sample,plane) according to Fmask address
1500 *
1501 *   @return
1502 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1503 ****************************************************************************************************
1504 */
1505 ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskCoordFromAddr(
1506     ADDR_HANDLE                                       hLib, ///< address lib handle
1507     const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT*    pIn,  ///< [in] Fmask info and address
1508     ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT*         pOut) ///< [out] Fmask coordinates
1509 {
1510     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1511
1512     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1513
1514     if (pLib != NULL)
1515     {
1516         returnCode = pLib->ComputeFmaskCoordFromAddr(pIn, pOut);
1517     }
1518     else
1519     {
1520         returnCode = ADDR_ERROR;
1521     }
1522
1523     return returnCode;
1524 }
1525
1526
1527
1528 ////////////////////////////////////////////////////////////////////////////////////////////////////
1529 //                                     DCC key functions for Addr2
1530 ////////////////////////////////////////////////////////////////////////////////////////////////////
1531
1532 /**
1533 ****************************************************************************************************
1534 *   Addr2ComputeDccInfo
1535 *
1536 *   @brief
1537 *       Compute DCC key size, base alignment based on color surface size, tile info or tile index
1538 *
1539 ****************************************************************************************************
1540 */
1541 ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccInfo(
1542     ADDR_HANDLE                           hLib,   ///< handle of addrlib
1543     const ADDR2_COMPUTE_DCCINFO_INPUT*    pIn,    ///< [in] input
1544     ADDR2_COMPUTE_DCCINFO_OUTPUT*         pOut)   ///< [out] output
1545 {
1546     ADDR_E_RETURNCODE returnCode;
1547
1548     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1549
1550     if (pLib != NULL)
1551     {
1552         returnCode = pLib->ComputeDccInfo(pIn, pOut);
1553     }
1554     else
1555     {
1556         returnCode = ADDR_ERROR;
1557     }
1558
1559     return returnCode;
1560 }
1561
1562 /**
1563 ****************************************************************************************************
1564 *   Addr2ComputeDccAddrFromCoord
1565 *
1566 *   @brief
1567 *       Compute DCC key address according to coordinates
1568 *
1569 *   @return
1570 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1571 ****************************************************************************************************
1572 */
1573 ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccAddrFromCoord(
1574     ADDR_HANDLE                                     hLib, ///< address lib handle
1575     const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT*    pIn,  ///< [in] Dcc info and coordinates
1576     ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT*         pOut) ///< [out] Dcc address
1577 {
1578     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1579
1580     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1581
1582     if (pLib != NULL)
1583     {
1584         returnCode = pLib->ComputeDccAddrFromCoord(pIn, pOut);
1585     }
1586     else
1587     {
1588         returnCode = ADDR_ERROR;
1589     }
1590
1591     return returnCode;
1592 }
1593
1594 /**
1595 ****************************************************************************************************
1596 *   Addr2ComputePipeBankXor
1597 *
1598 *   @brief
1599 *       Calculate a valid bank pipe xor value for client to use.
1600 ****************************************************************************************************
1601 */
1602 ADDR_E_RETURNCODE ADDR_API Addr2ComputePipeBankXor(
1603     ADDR_HANDLE                            hLib, ///< handle of addrlib
1604     const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn,  ///< [in] input
1605     ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT*      pOut) ///< [out] output
1606 {
1607     ADDR_E_RETURNCODE returnCode;
1608
1609     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1610
1611     if (pLib != NULL)
1612     {
1613         returnCode = pLib->ComputePipeBankXor(pIn, pOut);
1614     }
1615     else
1616     {
1617         returnCode = ADDR_ERROR;
1618     }
1619
1620     return returnCode;
1621 }
1622
1623 /**
1624 ****************************************************************************************************
1625 *   Addr2ComputeSlicePipeBankXor
1626 *
1627 *   @brief
1628 *       Calculate slice pipe bank xor value based on base pipe bank xor and slice id.
1629 ****************************************************************************************************
1630 */
1631 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSlicePipeBankXor(
1632     ADDR_HANDLE                                  hLib, ///< handle of addrlib
1633     const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn,  ///< [in] input
1634     ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT*      pOut) ///< [out] output
1635 {
1636     ADDR_E_RETURNCODE returnCode;
1637
1638     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1639
1640     if (pLib != NULL)
1641     {
1642         returnCode = pLib->ComputeSlicePipeBankXor(pIn, pOut);
1643     }
1644     else
1645     {
1646         returnCode = ADDR_ERROR;
1647     }
1648
1649     return returnCode;
1650 }
1651
1652 /**
1653 ****************************************************************************************************
1654 *   Addr2ComputeSubResourceOffsetForSwizzlePattern
1655 *
1656 *   @brief
1657 *       Calculate sub resource offset for swizzle pattern.
1658 ****************************************************************************************************
1659 */
1660 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSubResourceOffsetForSwizzlePattern(
1661     ADDR_HANDLE                                                     hLib, ///< handle of addrlib
1662     const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn,  ///< [in] input
1663     ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT*      pOut) ///< [out] output
1664 {
1665     ADDR_E_RETURNCODE returnCode;
1666
1667     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1668
1669     if (pLib != NULL)
1670     {
1671         returnCode = pLib->ComputeSubResourceOffsetForSwizzlePattern(pIn, pOut);
1672     }
1673     else
1674     {
1675         returnCode = ADDR_ERROR;
1676     }
1677
1678     return returnCode;
1679 }
1680
1681 /**
1682 ****************************************************************************************************
1683 *   Addr2GetPreferredSurfaceSetting
1684 *
1685 *   @brief
1686 *       Suggest a preferred setting for client driver to program HW register
1687 ****************************************************************************************************
1688 */
1689 ADDR_E_RETURNCODE ADDR_API Addr2GetPreferredSurfaceSetting(
1690     ADDR_HANDLE                                   hLib, ///< handle of addrlib
1691     const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn,  ///< [in] input
1692     ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT*      pOut) ///< [out] output
1693 {
1694     ADDR_E_RETURNCODE returnCode;
1695
1696     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1697
1698     if (pLib != NULL)
1699     {
1700         returnCode = pLib->Addr2GetPreferredSurfaceSetting(pIn, pOut);
1701     }
1702     else
1703     {
1704         returnCode = ADDR_ERROR;
1705     }
1706
1707     return returnCode;
1708 }
1709
1710 /**
1711 ****************************************************************************************************
1712 *   Addr2IsValidDisplaySwizzleMode
1713 *
1714 *   @brief
1715 *       Return whether the swizzle mode is supported by DCE / DCN.
1716 ****************************************************************************************************
1717 */
1718 ADDR_E_RETURNCODE ADDR_API Addr2IsValidDisplaySwizzleMode(
1719     ADDR_HANDLE     hLib,
1720     AddrSwizzleMode swizzleMode,
1721     UINT_32         bpp,
1722     bool            *result)
1723 {
1724     ADDR_E_RETURNCODE returnCode;
1725
1726     V2::Lib* pLib = V2::Lib::GetLib(hLib);
1727
1728     if (pLib != NULL)
1729     {
1730         ADDR2_COMPUTE_SURFACE_INFO_INPUT in;
1731         in.swizzleMode = swizzleMode;
1732         in.bpp = bpp;
1733
1734         *result = pLib->IsValidDisplaySwizzleMode(&in);
1735         returnCode = ADDR_OK;
1736     }
1737     else
1738     {
1739         returnCode = ADDR_ERROR;
1740     }
1741
1742     return returnCode;
1743 }