src/amd/addrlib/src/addrinterface.cpp

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