src/amd/addrlib/addrinterface.cpp

   1 /*
   2  * Copyright © 2014 Advanced Micro Devices, Inc.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sub license, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  14  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  15  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  16  * NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
  17  * AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  20  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * The above copyright notice and this permission notice (including the
  23  * next paragraph) shall be included in all copies or substantial portions
  24  * of the Software.
  25  */
  26
  27 /**
  28 ****************************************************************************************************
  29 * @file  addrinterface.cpp
  30 * @brief Contains the addrlib interface functions
  31 ****************************************************************************************************
  32 */
  33 #include "addrinterface.h"
  34 #include "addrlib1.h"
  35
  36 #include "addrcommon.h"
  37
  38 using namespace Addr;
  39
  40 ////////////////////////////////////////////////////////////////////////////////////////////////////
  41 //                               Create/Destroy/Config functions
  42 ////////////////////////////////////////////////////////////////////////////////////////////////////
  43
  44 /**
  45 ****************************************************************************************************
  46 *   AddrCreate
  47 *
  48 *   @brief
  49 *       Create address lib object
  50 *
  51 *   @return
  52 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
  53 ****************************************************************************************************
  54 */
  55 ADDR_E_RETURNCODE ADDR_API AddrCreate(
  56     const ADDR_CREATE_INPUT*    pAddrCreateIn,  ///< [in] infomation for creating address lib object
  57     ADDR_CREATE_OUTPUT*         pAddrCreateOut) ///< [out] address lib handle
  58 {
  59     ADDR_E_RETURNCODE returnCode = ADDR_OK;
  60
  61     returnCode = Lib::Create(pAddrCreateIn, pAddrCreateOut);
  62
  63     return returnCode;
  64 }
  65
  66
  67
  68 /**
  69 ****************************************************************************************************
  70 *   AddrDestroy
  71 *
  72 *   @brief
  73 *       Destroy address lib object
  74 *
  75 *   @return
  76 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
  77 ****************************************************************************************************
  78 */
  79 ADDR_E_RETURNCODE ADDR_API AddrDestroy(
  80     ADDR_HANDLE hLib) ///< address lib handle
  81 {
  82     ADDR_E_RETURNCODE returnCode = ADDR_OK;
  83
  84     if (hLib)
  85     {
  86         Lib* pLib = Lib::GetLib(hLib);
  87         pLib->Destroy();
  88     }
  89     else
  90     {
  91         returnCode = ADDR_ERROR;
  92     }
  93
  94     return returnCode;
  95 }
  96
  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 /**
 138 ****************************************************************************************************
 139 *   AddrComputeSurfaceAddrFromCoord
 140 *
 141 *   @brief
 142 *       Compute surface address according to coordinates
 143 *
 144 *   @return
 145 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 146 ****************************************************************************************************
 147 */
 148 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
 149     ADDR_HANDLE                                     hLib, ///< address lib handle
 150     const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,  ///< [in] surface info and coordinates
 151     ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT*      pOut) ///< [out] surface address
 152 {
 153     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 154
 155     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 156
 157     if (pLib != NULL)
 158     {
 159         returnCode = pLib->ComputeSurfaceAddrFromCoord(pIn, pOut);
 160     }
 161     else
 162     {
 163         returnCode = ADDR_ERROR;
 164     }
 165
 166     return returnCode;
 167 }
 168
 169 /**
 170 ****************************************************************************************************
 171 *   AddrComputeSurfaceCoordFromAddr
 172 *
 173 *   @brief
 174 *       Compute coordinates according to surface address
 175 *
 176 *   @return
 177 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 178 ****************************************************************************************************
 179 */
 180 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
 181     ADDR_HANDLE                                     hLib, ///< address lib handle
 182     const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,  ///< [in] surface info and address
 183     ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT*      pOut) ///< [out] coordinates
 184 {
 185     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 186
 187     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 188
 189     if (pLib != NULL)
 190     {
 191         returnCode = pLib->ComputeSurfaceCoordFromAddr(pIn, pOut);
 192     }
 193     else
 194     {
 195         returnCode = ADDR_ERROR;
 196     }
 197
 198     return returnCode;
 199 }
 200
 201
 202
 203 ////////////////////////////////////////////////////////////////////////////////////////////////////
 204 //                                   HTile functions
 205 ////////////////////////////////////////////////////////////////////////////////////////////////////
 206
 207 /**
 208 ****************************************************************************************************
 209 *   AddrComputeHtileInfo
 210 *
 211 *   @brief
 212 *       Compute Htile pitch, height, base alignment and size in bytes
 213 *
 214 *   @return
 215 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 216 ****************************************************************************************************
 217 */
 218 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
 219     ADDR_HANDLE                             hLib, ///< address lib handle
 220     const ADDR_COMPUTE_HTILE_INFO_INPUT*    pIn,  ///< [in] Htile information
 221     ADDR_COMPUTE_HTILE_INFO_OUTPUT*         pOut) ///< [out] Htile pitch, height and size in bytes
 222 {
 223     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 224
 225     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 226
 227     if (pLib != NULL)
 228     {
 229         returnCode = pLib->ComputeHtileInfo(pIn, pOut);
 230     }
 231     else
 232     {
 233         returnCode = ADDR_ERROR;
 234     }
 235
 236     return returnCode;
 237 }
 238
 239 /**
 240 ****************************************************************************************************
 241 *   AddrComputeHtileAddrFromCoord
 242 *
 243 *   @brief
 244 *       Compute Htile address according to coordinates (of depth buffer)
 245 *
 246 *   @return
 247 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 248 ****************************************************************************************************
 249 */
 250 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
 251     ADDR_HANDLE                                     hLib, ///< address lib handle
 252     const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Htile info and coordinates
 253     ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Htile address
 254 {
 255     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 256
 257     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 258
 259     if (pLib != NULL)
 260     {
 261         returnCode = pLib->ComputeHtileAddrFromCoord(pIn, pOut);
 262     }
 263     else
 264     {
 265         returnCode = ADDR_ERROR;
 266     }
 267
 268     return returnCode;
 269 }
 270
 271 /**
 272 ****************************************************************************************************
 273 *   AddrComputeHtileCoordFromAddr
 274 *
 275 *   @brief
 276 *       Compute coordinates within depth buffer (1st pixel of a micro tile) according to
 277 *       Htile address
 278 *
 279 *   @return
 280 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 281 ****************************************************************************************************
 282 */
 283 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
 284     ADDR_HANDLE                                     hLib, ///< address lib handle
 285     const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT*   pIn,  ///< [in] Htile info and address
 286     ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Htile coordinates
 287 {
 288     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 289
 290     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 291
 292     if (pLib != NULL)
 293     {
 294         returnCode = pLib->ComputeHtileCoordFromAddr(pIn, pOut);
 295     }
 296     else
 297     {
 298         returnCode = ADDR_ERROR;
 299     }
 300
 301     return returnCode;
 302 }
 303
 304
 305
 306 ////////////////////////////////////////////////////////////////////////////////////////////////////
 307 //                                     C-mask functions
 308 ////////////////////////////////////////////////////////////////////////////////////////////////////
 309
 310 /**
 311 ****************************************************************************************************
 312 *   AddrComputeCmaskInfo
 313 *
 314 *   @brief
 315 *       Compute Cmask pitch, height, base alignment and size in bytes from color buffer
 316 *       info
 317 *
 318 *   @return
 319 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 320 ****************************************************************************************************
 321 */
 322 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
 323     ADDR_HANDLE                             hLib, ///< address lib handle
 324     const ADDR_COMPUTE_CMASK_INFO_INPUT*    pIn,  ///< [in] Cmask pitch and height
 325     ADDR_COMPUTE_CMASK_INFO_OUTPUT*         pOut) ///< [out] Cmask pitch, height and size in bytes
 326 {
 327     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 328
 329     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 330
 331     if (pLib != NULL)
 332     {
 333         returnCode = pLib->ComputeCmaskInfo(pIn, pOut);
 334     }
 335     else
 336     {
 337         returnCode = ADDR_ERROR;
 338     }
 339
 340     return returnCode;
 341 }
 342
 343 /**
 344 ****************************************************************************************************
 345 *   AddrComputeCmaskAddrFromCoord
 346 *
 347 *   @brief
 348 *       Compute Cmask address according to coordinates (of MSAA color buffer)
 349 *
 350 *   @return
 351 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 352 ****************************************************************************************************
 353 */
 354 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
 355     ADDR_HANDLE                                     hLib, ///< address lib handle
 356     const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Cmask info and coordinates
 357     ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Cmask address
 358 {
 359     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 360
 361     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 362
 363     if (pLib != NULL)
 364     {
 365         returnCode = pLib->ComputeCmaskAddrFromCoord(pIn, pOut);
 366     }
 367     else
 368     {
 369         returnCode = ADDR_ERROR;
 370     }
 371
 372     return returnCode;
 373 }
 374
 375 /**
 376 ****************************************************************************************************
 377 *   AddrComputeCmaskCoordFromAddr
 378 *
 379 *   @brief
 380 *       Compute coordinates within color buffer (1st pixel of a micro tile) according to
 381 *       Cmask address
 382 *
 383 *   @return
 384 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 385 ****************************************************************************************************
 386 */
 387 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
 388     ADDR_HANDLE                                     hLib, ///< address lib handle
 389     const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT*   pIn,  ///< [in] Cmask info and address
 390     ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Cmask coordinates
 391 {
 392     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 393
 394     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 395
 396     if (pLib != NULL)
 397     {
 398         returnCode = pLib->ComputeCmaskCoordFromAddr(pIn, pOut);
 399     }
 400     else
 401     {
 402         returnCode = ADDR_ERROR;
 403     }
 404
 405     return returnCode;
 406 }
 407
 408
 409
 410 ////////////////////////////////////////////////////////////////////////////////////////////////////
 411 //                                     F-mask functions
 412 ////////////////////////////////////////////////////////////////////////////////////////////////////
 413
 414 /**
 415 ****************************************************************************************************
 416 *   AddrComputeFmaskInfo
 417 *
 418 *   @brief
 419 *       Compute Fmask pitch/height/depth/alignments and size in bytes
 420 *
 421 *   @return
 422 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 423 ****************************************************************************************************
 424 */
 425 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
 426     ADDR_HANDLE                             hLib, ///< address lib handle
 427     const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,  ///< [in] Fmask information
 428     ADDR_COMPUTE_FMASK_INFO_OUTPUT*         pOut) ///< [out] Fmask pitch and height
 429 {
 430     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 431
 432     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 433
 434     if (pLib != NULL)
 435     {
 436         returnCode = pLib->ComputeFmaskInfo(pIn, pOut);
 437     }
 438     else
 439     {
 440         returnCode = ADDR_ERROR;
 441     }
 442
 443     return returnCode;
 444 }
 445
 446 /**
 447 ****************************************************************************************************
 448 *   AddrComputeFmaskAddrFromCoord
 449 *
 450 *   @brief
 451 *       Compute Fmask address according to coordinates (x,y,slice,sample,plane)
 452 *
 453 *   @return
 454 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 455 ****************************************************************************************************
 456 */
 457 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
 458     ADDR_HANDLE                                     hLib, ///< address lib handle
 459     const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Fmask info and coordinates
 460     ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Fmask address
 461 {
 462     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 463
 464     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 465
 466     if (pLib != NULL)
 467     {
 468         returnCode = pLib->ComputeFmaskAddrFromCoord(pIn, pOut);
 469     }
 470     else
 471     {
 472         returnCode = ADDR_ERROR;
 473     }
 474
 475     return returnCode;
 476 }
 477
 478 /**
 479 ****************************************************************************************************
 480 *   AddrComputeFmaskCoordFromAddr
 481 *
 482 *   @brief
 483 *       Compute coordinates (x,y,slice,sample,plane) according to Fmask address
 484 *
 485 *   @return
 486 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 487 ****************************************************************************************************
 488 */
 489 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
 490     ADDR_HANDLE                                     hLib, ///< address lib handle
 491     const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*   pIn,  ///< [in] Fmask info and address
 492     ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Fmask coordinates
 493 {
 494     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 495
 496     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 497
 498     if (pLib != NULL)
 499     {
 500         returnCode = pLib->ComputeFmaskCoordFromAddr(pIn, pOut);
 501     }
 502     else
 503     {
 504         returnCode = ADDR_ERROR;
 505     }
 506
 507     return returnCode;
 508 }
 509
 510
 511
 512 ////////////////////////////////////////////////////////////////////////////////////////////////////
 513 //                                     DCC key functions
 514 ////////////////////////////////////////////////////////////////////////////////////////////////////
 515
 516 /**
 517 ****************************************************************************************************
 518 *   AddrComputeDccInfo
 519 *
 520 *   @brief
 521 *       Compute DCC key size, base alignment based on color surface size, tile info or tile index
 522 *
 523 ****************************************************************************************************
 524 */
 525 ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
 526     ADDR_HANDLE                             hLib,   ///< handle of addrlib
 527     const ADDR_COMPUTE_DCCINFO_INPUT*       pIn,    ///< [in] input
 528     ADDR_COMPUTE_DCCINFO_OUTPUT*            pOut)   ///< [out] output
 529 {
 530     ADDR_E_RETURNCODE returnCode;
 531
 532     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 533
 534     if (pLib != NULL)
 535     {
 536        returnCode = pLib->ComputeDccInfo(pIn, pOut);
 537     }
 538     else
 539     {
 540        returnCode = ADDR_ERROR;
 541     }
 542
 543     return returnCode;
 544 }
 545
 546
 547
 548 ///////////////////////////////////////////////////////////////////////////////
 549 // Below functions are element related or helper functions
 550 ///////////////////////////////////////////////////////////////////////////////
 551
 552 /**
 553 ****************************************************************************************************
 554 *   AddrGetVersion
 555 *
 556 *   @brief
 557 *       Get AddrLib version number. Client may check this return value against ADDRLIB_VERSION
 558 *       defined in addrinterface.h to see if there is a mismatch.
 559 ****************************************************************************************************
 560 */
 561 UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib)
 562 {
 563     UINT_32 version = 0;
 564
 565     Addr::Lib* pLib = Lib::GetLib(hLib);
 566
 567     ADDR_ASSERT(pLib != NULL);
 568
 569     if (pLib)
 570     {
 571         version = pLib->GetVersion();
 572     }
 573
 574     return version;
 575 }
 576
 577 /**
 578 ****************************************************************************************************
 579 *   AddrUseTileIndex
 580 *
 581 *   @brief
 582 *       Return TRUE if tileIndex is enabled in this address library
 583 ****************************************************************************************************
 584 */
 585 BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib)
 586 {
 587     BOOL_32 useTileIndex = FALSE;
 588
 589     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 590
 591     ADDR_ASSERT(pLib != NULL);
 592
 593     if (pLib)
 594     {
 595         useTileIndex = pLib->UseTileIndex(0);
 596     }
 597
 598     return useTileIndex;
 599 }
 600
 601 /**
 602 ****************************************************************************************************
 603 *   AddrUseCombinedSwizzle
 604 *
 605 *   @brief
 606 *       Return TRUE if combined swizzle is enabled in this address library
 607 ****************************************************************************************************
 608 */
 609 BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib)
 610 {
 611     BOOL_32 useCombinedSwizzle = FALSE;
 612
 613     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 614
 615     ADDR_ASSERT(pLib != NULL);
 616
 617     if (pLib)
 618     {
 619         useCombinedSwizzle = pLib->UseCombinedSwizzle();
 620     }
 621
 622     return useCombinedSwizzle;
 623 }
 624
 625 /**
 626 ****************************************************************************************************
 627 *   AddrExtractBankPipeSwizzle
 628 *
 629 *   @brief
 630 *       Extract Bank and Pipe swizzle from base256b
 631 *   @return
 632 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 633 ****************************************************************************************************
 634 */
 635 ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
 636     ADDR_HANDLE                                 hLib,     ///< addrlib handle
 637     const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT*  pIn,      ///< [in] input structure
 638     ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT*       pOut)     ///< [out] output structure
 639 {
 640     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 641
 642     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 643
 644     if (pLib != NULL)
 645     {
 646         returnCode = pLib->ExtractBankPipeSwizzle(pIn, pOut);
 647     }
 648     else
 649     {
 650         returnCode = ADDR_ERROR;
 651     }
 652
 653     return returnCode;
 654 }
 655
 656 /**
 657 ****************************************************************************************************
 658 *   AddrCombineBankPipeSwizzle
 659 *
 660 *   @brief
 661 *       Combine Bank and Pipe swizzle
 662 *   @return
 663 *       ADDR_E_RETURNCODE
 664 ****************************************************************************************************
 665 */
 666 ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
 667     ADDR_HANDLE                                 hLib,
 668     const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT*  pIn,
 669     ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT*       pOut)
 670 {
 671     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 672
 673     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 674
 675     if (pLib != NULL)
 676     {
 677         returnCode = pLib->CombineBankPipeSwizzle(pIn, pOut);
 678     }
 679     else
 680     {
 681         returnCode = ADDR_ERROR;
 682     }
 683
 684     return returnCode;
 685 }
 686
 687 /**
 688 ****************************************************************************************************
 689 *   AddrComputeSliceSwizzle
 690 *
 691 *   @brief
 692 *       Compute a swizzle for slice from a base swizzle
 693 *   @return
 694 *       ADDR_OK if no error
 695 ****************************************************************************************************
 696 */
 697 ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
 698     ADDR_HANDLE                                 hLib,
 699     const ADDR_COMPUTE_SLICESWIZZLE_INPUT*      pIn,
 700     ADDR_COMPUTE_SLICESWIZZLE_OUTPUT*           pOut)
 701 {
 702     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 703
 704     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 705
 706     if (pLib != NULL)
 707     {
 708         returnCode = pLib->ComputeSliceTileSwizzle(pIn, pOut);
 709     }
 710     else
 711     {
 712         returnCode = ADDR_ERROR;
 713     }
 714
 715     return returnCode;
 716 }
 717
 718 /**
 719 ****************************************************************************************************
 720 *   AddrComputeBaseSwizzle
 721 *
 722 *   @brief
 723 *       Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
 724 *   @return
 725 *       ADDR_OK if no error
 726 ****************************************************************************************************
 727 */
 728 ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
 729     ADDR_HANDLE                             hLib,
 730     const ADDR_COMPUTE_BASE_SWIZZLE_INPUT*  pIn,
 731     ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT*       pOut)
 732 {
 733     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 734
 735     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 736
 737     if (pLib != NULL)
 738     {
 739         returnCode = pLib->ComputeBaseSwizzle(pIn, pOut);
 740     }
 741     else
 742     {
 743         returnCode = ADDR_ERROR;
 744     }
 745
 746     return returnCode;
 747 }
 748
 749 /**
 750 ****************************************************************************************************
 751 *   ElemFlt32ToDepthPixel
 752 *
 753 *   @brief
 754 *       Convert a FLT_32 value to a depth/stencil pixel value
 755 *
 756 *   @return
 757 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 758 *
 759 ****************************************************************************************************
 760 */
 761 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
 762     ADDR_HANDLE                         hLib,    ///< addrlib handle
 763     const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,     ///< [in] per-component value
 764     ELEM_FLT32TODEPTHPIXEL_OUTPUT*      pOut)    ///< [out] final pixel value
 765 {
 766     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 767
 768     Lib* pLib = Lib::GetLib(hLib);
 769
 770     if (pLib != NULL)
 771     {
 772         pLib->Flt32ToDepthPixel(pIn, pOut);
 773     }
 774     else
 775     {
 776         returnCode = ADDR_ERROR;
 777     }
 778
 779     return returnCode;
 780 }
 781
 782 /**
 783 ****************************************************************************************************
 784 *   ElemFlt32ToColorPixel
 785 *
 786 *   @brief
 787 *       Convert a FLT_32 value to a red/green/blue/alpha pixel value
 788 *
 789 *   @return
 790 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 791 *
 792 ****************************************************************************************************
 793 */
 794 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
 795     ADDR_HANDLE                         hLib,    ///< addrlib handle
 796     const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,     ///< [in] format, surface number and swap value
 797     ELEM_FLT32TOCOLORPIXEL_OUTPUT*      pOut)    ///< [out] final pixel value
 798 {
 799     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 800
 801     Lib* pLib = Lib::GetLib(hLib);
 802
 803     if (pLib != NULL)
 804     {
 805         pLib->Flt32ToColorPixel(pIn, pOut);
 806     }
 807     else
 808     {
 809         returnCode = ADDR_ERROR;
 810     }
 811
 812     return returnCode;
 813 }
 814
 815 /**
 816 ****************************************************************************************************
 817 *   ElemGetExportNorm
 818 *
 819 *   @brief
 820 *       Helper function to check one format can be EXPORT_NUM,
 821 *       which is a register CB_COLOR_INFO.SURFACE_FORMAT.
 822 *       FP16 can be reported as EXPORT_NORM for rv770 in r600
 823 *       family
 824 *
 825 ****************************************************************************************************
 826 */
 827 BOOL_32 ADDR_API ElemGetExportNorm(
 828     ADDR_HANDLE                     hLib, ///< addrlib handle
 829     const ELEM_GETEXPORTNORM_INPUT* pIn)  ///< [in] input structure
 830 {
 831     Addr::Lib* pLib = Lib::GetLib(hLib);
 832     BOOL_32 enabled = FALSE;
 833
 834     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 835
 836     if (pLib != NULL)
 837     {
 838         enabled = pLib->GetExportNorm(pIn);
 839     }
 840     else
 841     {
 842         returnCode = ADDR_ERROR;
 843     }
 844
 845     ADDR_ASSERT(returnCode == ADDR_OK);
 846
 847     return enabled;
 848 }
 849
 850 /**
 851 ****************************************************************************************************
 852 *   AddrConvertTileInfoToHW
 853 *
 854 *   @brief
 855 *       Convert tile info from real value to hardware register value
 856 *
 857 *   @return
 858 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 859 ****************************************************************************************************
 860 */
 861 ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
 862     ADDR_HANDLE                             hLib, ///< address lib handle
 863     const ADDR_CONVERT_TILEINFOTOHW_INPUT*  pIn,  ///< [in] tile info with real value
 864     ADDR_CONVERT_TILEINFOTOHW_OUTPUT*       pOut) ///< [out] tile info with HW register value
 865 {
 866     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 867
 868     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 869
 870     if (pLib != NULL)
 871     {
 872         returnCode = pLib->ConvertTileInfoToHW(pIn, pOut);
 873     }
 874     else
 875     {
 876         returnCode = ADDR_ERROR;
 877     }
 878
 879     return returnCode;
 880 }
 881
 882 /**
 883 ****************************************************************************************************
 884 *   AddrConvertTileIndex
 885 *
 886 *   @brief
 887 *       Convert tile index to tile mode/type/info
 888 *
 889 *   @return
 890 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 891 ****************************************************************************************************
 892 */
 893 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
 894     ADDR_HANDLE                          hLib, ///< address lib handle
 895     const ADDR_CONVERT_TILEINDEX_INPUT*  pIn,  ///< [in] input - tile index
 896     ADDR_CONVERT_TILEINDEX_OUTPUT*       pOut) ///< [out] tile mode/type/info
 897 {
 898     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 899
 900     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 901
 902     if (pLib != NULL)
 903     {
 904         returnCode = pLib->ConvertTileIndex(pIn, pOut);
 905     }
 906     else
 907     {
 908         returnCode = ADDR_ERROR;
 909     }
 910
 911     return returnCode;
 912 }
 913
 914 /**
 915 ****************************************************************************************************
 916 *   AddrGetMacroModeIndex
 917 *
 918 *   @brief
 919 *       Get macro mode index based on input parameters
 920 *
 921 *   @return
 922 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 923 ****************************************************************************************************
 924 */
 925 ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
 926     ADDR_HANDLE                          hLib, ///< address lib handle
 927     const ADDR_GET_MACROMODEINDEX_INPUT* pIn,  ///< [in] input
 928     ADDR_GET_MACROMODEINDEX_OUTPUT*      pOut) ///< [out] macro mode index
 929 {
 930     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 931
 932     ADDR_E_RETURNCODE returnCode;
 933
 934     if (pLib != NULL)
 935     {
 936         returnCode = pLib->GetMacroModeIndex(pIn, pOut);
 937     }
 938     else
 939     {
 940         returnCode = ADDR_ERROR;
 941     }
 942
 943     return returnCode;
 944 }
 945
 946 /**
 947 ****************************************************************************************************
 948 *   AddrConvertTileIndex1
 949 *
 950 *   @brief
 951 *       Convert tile index to tile mode/type/info
 952 *
 953 *   @return
 954 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 955 ****************************************************************************************************
 956 */
 957 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
 958     ADDR_HANDLE                          hLib, ///< address lib handle
 959     const ADDR_CONVERT_TILEINDEX1_INPUT* pIn,  ///< [in] input - tile index
 960     ADDR_CONVERT_TILEINDEX_OUTPUT*       pOut) ///< [out] tile mode/type/info
 961 {
 962     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 963
 964     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 965
 966     if (pLib != NULL)
 967     {
 968         returnCode = pLib->ConvertTileIndex1(pIn, pOut);
 969     }
 970     else
 971     {
 972         returnCode = ADDR_ERROR;
 973     }
 974
 975     return returnCode;
 976 }
 977
 978 /**
 979 ****************************************************************************************************
 980 *   AddrGetTileIndex
 981 *
 982 *   @brief
 983 *       Get tile index from tile mode/type/info
 984 *
 985 *   @return
 986 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
 987 *
 988 *   @note
 989 *       Only meaningful for SI (and above)
 990 ****************************************************************************************************
 991 */
 992 ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
 993     ADDR_HANDLE                     hLib,
 994     const ADDR_GET_TILEINDEX_INPUT* pIn,
 995     ADDR_GET_TILEINDEX_OUTPUT*      pOut)
 996 {
 997     V1::Lib* pLib = V1::Lib::GetLib(hLib);
 998
 999     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1000
1001     if (pLib != NULL)
1002     {
1003         returnCode = pLib->GetTileIndex(pIn, pOut);
1004     }
1005     else
1006     {
1007         returnCode = ADDR_ERROR;
1008     }
1009
1010     return returnCode;
1011 }
1012
1013 /**
1014 ****************************************************************************************************
1015 *   AddrComputePrtInfo
1016 *
1017 *   @brief
1018 *       Interface function for ComputePrtInfo
1019 *
1020 ****************************************************************************************************
1021 */
1022 ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
1023     ADDR_HANDLE                 hLib,
1024     const ADDR_PRT_INFO_INPUT*  pIn,
1025     ADDR_PRT_INFO_OUTPUT*       pOut)
1026 {
1027     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1028
1029     V1::Lib* pLib = V1::Lib::GetLib(hLib);
1030
1031     if (pLib != NULL)
1032     {
1033         returnCode = pLib->ComputePrtInfo(pIn, pOut);
1034     }
1035     else
1036     {
1037         returnCode = ADDR_ERROR;
1038     }
1039
1040     return returnCode;
1041 }
1042
1043 /**
1044 ****************************************************************************************************
1045 *   AddrGetMaxAlignments
1046 *
1047 *   @brief
1048 *       Convert maximum alignments
1049 *
1050 *   @return
1051 *       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1052 ****************************************************************************************************
1053 */
1054 ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
1055     ADDR_HANDLE                     hLib, ///< address lib handle
1056     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut) ///< [out] output structure
1057 {
1058     Addr::Lib* pLib = Lib::GetLib(hLib);
1059
1060     ADDR_E_RETURNCODE returnCode = ADDR_OK;
1061
1062     if (pLib != NULL)
1063     {
1064         returnCode = pLib->GetMaxAlignments(pOut);
1065     }
1066     else
1067     {
1068         returnCode = ADDR_ERROR;
1069     }
1070
1071     return returnCode;
1072 }