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