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