src/amd/addrlib/addrinterface.cpp

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