src/amd/addrlib/src/core/addrlib.cpp

   1 /*
   2  * Copyright © 2007-2019 Advanced Micro Devices, Inc.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sub license, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  14  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  15  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  16  * NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
  17  * AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  20  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * The above copyright notice and this permission notice (including the
  23  * next paragraph) shall be included in all copies or substantial portions
  24  * of the Software.
  25  */
  26
  27 /**
  28 ****************************************************************************************************
  29 * @file  addrlib.cpp
  30 * @brief Contains the implementation for the Addr::Lib class.
  31 ****************************************************************************************************
  32 */
  33
  34 #include "addrinterface.h"
  35 #include "addrlib.h"
  36 #include "addrcommon.h"
  37
  38 #if defined(__APPLE__)
  39
  40 UINT_32 div64_32(UINT_64 n, UINT_32 base)
  41 {
  42     UINT_64 rem = n;
  43     UINT_64 b = base;
  44     UINT_64 res, d = 1;
  45     UINT_32 high = rem >> 32;
  46
  47     res = 0;
  48     if (high >= base)
  49     {
  50         high /= base;
  51         res = (UINT_64) high << 32;
  52         rem -= (UINT_64) (high * base) << 32;
  53     }
  54
  55     while (((INT_64)b > 0) && (b < rem))
  56     {
  57         b = b + b;
  58         d = d + d;
  59     }
  60
  61     do
  62     {
  63         if (rem >= b)
  64         {
  65             rem -= b;
  66             res += d;
  67         }
  68         b >>= 1;
  69         d >>= 1;
  70     } while (d);
  71
  72     n = res;
  73     return rem;
  74 }
  75
  76 extern "C"
  77 UINT_32 __umoddi3(UINT_64 n, UINT_32 base)
  78 {
  79     return div64_32(n, base);
  80 }
  81
  82 #endif // __APPLE__
  83
  84 namespace Addr
  85 {
  86
  87 ////////////////////////////////////////////////////////////////////////////////////////////////////
  88 //                               Constructor/Destructor
  89 ////////////////////////////////////////////////////////////////////////////////////////////////////
  90
  91 /**
  92 ****************************************************************************************************
  93 *   Lib::Lib
  94 *
  95 *   @brief
  96 *       Constructor for the AddrLib class
  97 *
  98 ****************************************************************************************************
  99 */
 100 Lib::Lib() :
 101     m_class(BASE_ADDRLIB),
 102     m_chipFamily(ADDR_CHIP_FAMILY_IVLD),
 103     m_chipRevision(0),
 104     m_version(ADDRLIB_VERSION),
 105     m_pipes(0),
 106     m_banks(0),
 107     m_pipeInterleaveBytes(0),
 108     m_rowSize(0),
 109     m_minPitchAlignPixels(1),
 110     m_maxSamples(8),
 111     m_pElemLib(NULL)
 112 {
 113     m_configFlags.value = 0;
 114 }
 115
 116 /**
 117 ****************************************************************************************************
 118 *   Lib::Lib
 119 *
 120 *   @brief
 121 *       Constructor for the AddrLib class with hClient as parameter
 122 *
 123 ****************************************************************************************************
 124 */
 125 Lib::Lib(const Client* pClient) :
 126     Object(pClient),
 127     m_class(BASE_ADDRLIB),
 128     m_chipFamily(ADDR_CHIP_FAMILY_IVLD),
 129     m_chipRevision(0),
 130     m_version(ADDRLIB_VERSION),
 131     m_pipes(0),
 132     m_banks(0),
 133     m_pipeInterleaveBytes(0),
 134     m_rowSize(0),
 135     m_minPitchAlignPixels(1),
 136     m_maxSamples(8),
 137     m_pElemLib(NULL)
 138 {
 139     m_configFlags.value = 0;
 140 }
 141
 142 /**
 143 ****************************************************************************************************
 144 *   Lib::~AddrLib
 145 *
 146 *   @brief
 147 *       Destructor for the AddrLib class
 148 *
 149 ****************************************************************************************************
 150 */
 151 Lib::~Lib()
 152 {
 153     if (m_pElemLib)
 154     {
 155         delete m_pElemLib;
 156         m_pElemLib = NULL;
 157     }
 158 }
 159
 160 ////////////////////////////////////////////////////////////////////////////////////////////////////
 161 //                               Initialization/Helper
 162 ////////////////////////////////////////////////////////////////////////////////////////////////////
 163
 164 /**
 165 ****************************************************************************************************
 166 *   Lib::Create
 167 *
 168 *   @brief
 169 *       Creates and initializes AddrLib object.
 170 *
 171 *   @return
 172 *       ADDR_E_RETURNCODE
 173 ****************************************************************************************************
 174 */
 175 ADDR_E_RETURNCODE Lib::Create(
 176     const ADDR_CREATE_INPUT* pCreateIn,     ///< [in] pointer to ADDR_CREATE_INPUT
 177     ADDR_CREATE_OUTPUT*      pCreateOut)    ///< [out] pointer to ADDR_CREATE_OUTPUT
 178 {
 179     Lib* pLib = NULL;
 180     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 181
 182     if (pCreateIn->createFlags.fillSizeFields == TRUE)
 183     {
 184         if ((pCreateIn->size != sizeof(ADDR_CREATE_INPUT)) ||
 185             (pCreateOut->size != sizeof(ADDR_CREATE_OUTPUT)))
 186         {
 187             returnCode = ADDR_PARAMSIZEMISMATCH;
 188         }
 189     }
 190
 191     if ((returnCode == ADDR_OK)                    &&
 192         (pCreateIn->callbacks.allocSysMem != NULL) &&
 193         (pCreateIn->callbacks.freeSysMem != NULL))
 194     {
 195         Client client = {
 196             pCreateIn->hClient,
 197             pCreateIn->callbacks
 198         };
 199
 200         switch (pCreateIn->chipEngine)
 201         {
 202             case CIASICIDGFXENGINE_SOUTHERNISLAND:
 203                 switch (pCreateIn->chipFamily)
 204                 {
 205                     case FAMILY_SI:
 206                         pLib = SiHwlInit(&client);
 207                         break;
 208                     case FAMILY_VI:
 209                     case FAMILY_CZ:
 210                     case FAMILY_CI:
 211                     case FAMILY_KV: // CI based fusion
 212                         pLib = CiHwlInit(&client);
 213                         break;
 214                     default:
 215                         ADDR_ASSERT_ALWAYS();
 216                         break;
 217                 }
 218                 break;
 219             case CIASICIDGFXENGINE_ARCTICISLAND:
 220                 switch (pCreateIn->chipFamily)
 221                 {
 222                     case FAMILY_AI:
 223                     case FAMILY_RV:
 224                         pLib = Gfx9HwlInit(&client);
 225                         break;
 226                     default:
 227                         ADDR_ASSERT_ALWAYS();
 228                         break;
 229                 }
 230                 break;
 231             default:
 232                 ADDR_ASSERT_ALWAYS();
 233                 break;
 234         }
 235     }
 236
 237     if (pLib != NULL)
 238     {
 239         BOOL_32 initValid;
 240
 241         // Pass createFlags to configFlags first since these flags may be overwritten
 242         pLib->m_configFlags.noCubeMipSlicesPad  = pCreateIn->createFlags.noCubeMipSlicesPad;
 243         pLib->m_configFlags.fillSizeFields      = pCreateIn->createFlags.fillSizeFields;
 244         pLib->m_configFlags.useTileIndex        = pCreateIn->createFlags.useTileIndex;
 245         pLib->m_configFlags.useCombinedSwizzle  = pCreateIn->createFlags.useCombinedSwizzle;
 246         pLib->m_configFlags.checkLast2DLevel    = pCreateIn->createFlags.checkLast2DLevel;
 247         pLib->m_configFlags.useHtileSliceAlign  = pCreateIn->createFlags.useHtileSliceAlign;
 248         pLib->m_configFlags.allowLargeThickTile = pCreateIn->createFlags.allowLargeThickTile;
 249         pLib->m_configFlags.forceDccAndTcCompat = pCreateIn->createFlags.forceDccAndTcCompat;
 250         pLib->m_configFlags.disableLinearOpt    = FALSE;
 251
 252         pLib->SetChipFamily(pCreateIn->chipFamily, pCreateIn->chipRevision);
 253
 254         pLib->SetMinPitchAlignPixels(pCreateIn->minPitchAlignPixels);
 255
 256         // Global parameters initialized and remaining configFlags bits are set as well
 257         initValid = pLib->HwlInitGlobalParams(pCreateIn);
 258
 259         if (initValid)
 260         {
 261             pLib->m_pElemLib = ElemLib::Create(pLib);
 262         }
 263         else
 264         {
 265             pLib->m_pElemLib = NULL; // Don't go on allocating element lib
 266             returnCode = ADDR_INVALIDGBREGVALUES;
 267         }
 268
 269         if (pLib->m_pElemLib == NULL)
 270         {
 271             delete pLib;
 272             pLib = NULL;
 273             ADDR_ASSERT_ALWAYS();
 274         }
 275         else
 276         {
 277             pLib->m_pElemLib->SetConfigFlags(pLib->m_configFlags);
 278         }
 279     }
 280
 281     pCreateOut->hLib = pLib;
 282
 283     if ((pLib != NULL) &&
 284         (returnCode == ADDR_OK))
 285     {
 286         pCreateOut->numEquations =
 287             pLib->HwlGetEquationTableInfo(&pCreateOut->pEquationTable);
 288
 289         pLib->SetMaxAlignments();
 290
 291     }
 292     else if ((pLib == NULL) &&
 293              (returnCode == ADDR_OK))
 294     {
 295         // Unknown failures, we return the general error code
 296         returnCode = ADDR_ERROR;
 297     }
 298
 299     return returnCode;
 300 }
 301
 302 /**
 303 ****************************************************************************************************
 304 *   Lib::SetChipFamily
 305 *
 306 *   @brief
 307 *       Convert familyID defined in atiid.h to ChipFamily and set m_chipFamily/m_chipRevision
 308 *   @return
 309 *      N/A
 310 ****************************************************************************************************
 311 */
 312 VOID Lib::SetChipFamily(
 313     UINT_32 uChipFamily,        ///< [in] chip family defined in atiih.h
 314     UINT_32 uChipRevision)      ///< [in] chip revision defined in "asic_family"_id.h
 315 {
 316     ChipFamily family = HwlConvertChipFamily(uChipFamily, uChipRevision);
 317
 318     ADDR_ASSERT(family != ADDR_CHIP_FAMILY_IVLD);
 319
 320     m_chipFamily   = family;
 321     m_chipRevision = uChipRevision;
 322 }
 323
 324 /**
 325 ****************************************************************************************************
 326 *   Lib::SetMinPitchAlignPixels
 327 *
 328 *   @brief
 329 *       Set m_minPitchAlignPixels with input param
 330 *
 331 *   @return
 332 *      N/A
 333 ****************************************************************************************************
 334 */
 335 VOID Lib::SetMinPitchAlignPixels(
 336     UINT_32 minPitchAlignPixels)    ///< [in] minmum pitch alignment in pixels
 337 {
 338     m_minPitchAlignPixels = (minPitchAlignPixels == 0) ? 1 : minPitchAlignPixels;
 339 }
 340
 341 /**
 342 ****************************************************************************************************
 343 *   Lib::SetMaxAlignments
 344 *
 345 *   @brief
 346 *       Set max alignments
 347 *
 348 *   @return
 349 *      N/A
 350 ****************************************************************************************************
 351 */
 352 VOID Lib::SetMaxAlignments()
 353 {
 354     m_maxBaseAlign     = HwlComputeMaxBaseAlignments();
 355     m_maxMetaBaseAlign = HwlComputeMaxMetaBaseAlignments();
 356 }
 357
 358 /**
 359 ****************************************************************************************************
 360 *   Lib::GetLib
 361 *
 362 *   @brief
 363 *       Get AddrLib pointer
 364 *
 365 *   @return
 366 *      An AddrLib class pointer
 367 ****************************************************************************************************
 368 */
 369 Lib* Lib::GetLib(
 370     ADDR_HANDLE hLib)   ///< [in] handle of ADDR_HANDLE
 371 {
 372     return static_cast<Addr::Lib*>(hLib);
 373 }
 374
 375 /**
 376 ****************************************************************************************************
 377 *   Lib::GetMaxAlignments
 378 *
 379 *   @brief
 380 *       Gets maximum alignments for data surface (include FMask)
 381 *
 382 *   @return
 383 *       ADDR_E_RETURNCODE
 384 ****************************************************************************************************
 385 */
 386 ADDR_E_RETURNCODE Lib::GetMaxAlignments(
 387     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut    ///< [out] output structure
 388     ) const
 389 {
 390     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 391
 392     if (GetFillSizeFieldsFlags() == TRUE)
 393     {
 394         if (pOut->size != sizeof(ADDR_GET_MAX_ALINGMENTS_OUTPUT))
 395         {
 396             returnCode = ADDR_PARAMSIZEMISMATCH;
 397         }
 398     }
 399
 400     if (returnCode == ADDR_OK)
 401     {
 402         if (m_maxBaseAlign != 0)
 403         {
 404             pOut->baseAlign = m_maxBaseAlign;
 405         }
 406         else
 407         {
 408             returnCode = ADDR_NOTIMPLEMENTED;
 409         }
 410     }
 411
 412     return returnCode;
 413 }
 414
 415 /**
 416 ****************************************************************************************************
 417 *   Lib::GetMaxMetaAlignments
 418 *
 419 *   @brief
 420 *       Gets maximum alignments for metadata (CMask, DCC and HTile)
 421 *
 422 *   @return
 423 *       ADDR_E_RETURNCODE
 424 ****************************************************************************************************
 425 */
 426 ADDR_E_RETURNCODE Lib::GetMaxMetaAlignments(
 427     ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut    ///< [out] output structure
 428     ) const
 429 {
 430     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 431
 432     if (GetFillSizeFieldsFlags() == TRUE)
 433     {
 434         if (pOut->size != sizeof(ADDR_GET_MAX_ALINGMENTS_OUTPUT))
 435         {
 436             returnCode = ADDR_PARAMSIZEMISMATCH;
 437         }
 438     }
 439
 440     if (returnCode == ADDR_OK)
 441     {
 442         if (m_maxMetaBaseAlign != 0)
 443         {
 444             pOut->baseAlign = m_maxMetaBaseAlign;
 445         }
 446         else
 447         {
 448             returnCode = ADDR_NOTIMPLEMENTED;
 449         }
 450     }
 451
 452     return returnCode;
 453 }
 454
 455 /**
 456 ****************************************************************************************************
 457 *   Lib::Bits2Number
 458 *
 459 *   @brief
 460 *       Cat a array of binary bit to a number
 461 *
 462 *   @return
 463 *       The number combined with the array of bits
 464 ****************************************************************************************************
 465 */
 466 UINT_32 Lib::Bits2Number(
 467     UINT_32 bitNum,     ///< [in] how many bits
 468     ...)                ///< [in] varaible bits value starting from MSB
 469 {
 470     UINT_32 number = 0;
 471     UINT_32 i;
 472     va_list bits_ptr;
 473
 474     va_start(bits_ptr, bitNum);
 475
 476     for(i = 0; i < bitNum; i++)
 477     {
 478         number |= va_arg(bits_ptr, UINT_32);
 479         number <<= 1;
 480     }
 481
 482     number >>= 1;
 483
 484     va_end(bits_ptr);
 485
 486     return number;
 487 }
 488
 489 ////////////////////////////////////////////////////////////////////////////////////////////////////
 490 //                               Element lib
 491 ////////////////////////////////////////////////////////////////////////////////////////////////////
 492
 493 /**
 494 ****************************************************************************************************
 495 *   Lib::Flt32ToColorPixel
 496 *
 497 *   @brief
 498 *       Convert a FLT_32 value to a depth/stencil pixel value
 499 *   @return
 500 *       ADDR_E_RETURNCODE
 501 ****************************************************************************************************
 502 */
 503 ADDR_E_RETURNCODE Lib::Flt32ToDepthPixel(
 504     const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,
 505     ELEM_FLT32TODEPTHPIXEL_OUTPUT* pOut) const
 506 {
 507     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 508
 509     if (GetFillSizeFieldsFlags() == TRUE)
 510     {
 511         if ((pIn->size != sizeof(ELEM_FLT32TODEPTHPIXEL_INPUT)) ||
 512             (pOut->size != sizeof(ELEM_FLT32TODEPTHPIXEL_OUTPUT)))
 513         {
 514             returnCode = ADDR_PARAMSIZEMISMATCH;
 515         }
 516     }
 517
 518     if (returnCode == ADDR_OK)
 519     {
 520         GetElemLib()->Flt32ToDepthPixel(pIn->format, pIn->comps, pOut->pPixel);
 521
 522         UINT_32 depthBase = 0;
 523         UINT_32 stencilBase = 0;
 524         UINT_32 depthBits = 0;
 525         UINT_32 stencilBits = 0;
 526
 527         switch (pIn->format)
 528         {
 529             case ADDR_DEPTH_16:
 530                 depthBits = 16;
 531                 break;
 532             case ADDR_DEPTH_X8_24:
 533             case ADDR_DEPTH_8_24:
 534             case ADDR_DEPTH_X8_24_FLOAT:
 535             case ADDR_DEPTH_8_24_FLOAT:
 536                 depthBase = 8;
 537                 depthBits = 24;
 538                 stencilBits = 8;
 539                 break;
 540             case ADDR_DEPTH_32_FLOAT:
 541                 depthBits = 32;
 542                 break;
 543             case ADDR_DEPTH_X24_8_32_FLOAT:
 544                 depthBase = 8;
 545                 depthBits = 32;
 546                 stencilBits = 8;
 547                 break;
 548             default:
 549                 break;
 550         }
 551
 552         // Overwrite base since R800 has no "tileBase"
 553         if (GetElemLib()->IsDepthStencilTilePlanar() == FALSE)
 554         {
 555             depthBase = 0;
 556             stencilBase = 0;
 557         }
 558
 559         depthBase *= 64;
 560         stencilBase *= 64;
 561
 562         pOut->stencilBase = stencilBase;
 563         pOut->depthBase = depthBase;
 564         pOut->depthBits = depthBits;
 565         pOut->stencilBits = stencilBits;
 566     }
 567
 568     return returnCode;
 569 }
 570
 571 /**
 572 ****************************************************************************************************
 573 *   Lib::Flt32ToColorPixel
 574 *
 575 *   @brief
 576 *       Convert a FLT_32 value to a red/green/blue/alpha pixel value
 577 *   @return
 578 *       ADDR_E_RETURNCODE
 579 ****************************************************************************************************
 580 */
 581 ADDR_E_RETURNCODE Lib::Flt32ToColorPixel(
 582     const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,
 583     ELEM_FLT32TOCOLORPIXEL_OUTPUT* pOut) const
 584 {
 585     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 586
 587     if (GetFillSizeFieldsFlags() == TRUE)
 588     {
 589         if ((pIn->size != sizeof(ELEM_FLT32TOCOLORPIXEL_INPUT)) ||
 590             (pOut->size != sizeof(ELEM_FLT32TOCOLORPIXEL_OUTPUT)))
 591         {
 592             returnCode = ADDR_PARAMSIZEMISMATCH;
 593         }
 594     }
 595
 596     if (returnCode == ADDR_OK)
 597     {
 598         GetElemLib()->Flt32ToColorPixel(pIn->format,
 599                                         pIn->surfNum,
 600                                         pIn->surfSwap,
 601                                         pIn->comps,
 602                                         pOut->pPixel);
 603     }
 604
 605     return returnCode;
 606 }
 607
 608 /**
 609 ****************************************************************************************************
 610 *   Lib::GetExportNorm
 611 *
 612 *   @brief
 613 *       Check one format can be EXPORT_NUM
 614 *   @return
 615 *       TRUE if EXPORT_NORM can be used
 616 ****************************************************************************************************
 617 */
 618 BOOL_32 Lib::GetExportNorm(
 619     const ELEM_GETEXPORTNORM_INPUT* pIn) const
 620 {
 621     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 622
 623     BOOL_32 enabled = FALSE;
 624
 625     if (GetFillSizeFieldsFlags() == TRUE)
 626     {
 627         if (pIn->size != sizeof(ELEM_GETEXPORTNORM_INPUT))
 628         {
 629             returnCode = ADDR_PARAMSIZEMISMATCH;
 630         }
 631     }
 632
 633     if (returnCode == ADDR_OK)
 634     {
 635         enabled = GetElemLib()->PixGetExportNorm(pIn->format, pIn->num, pIn->swap);
 636     }
 637
 638     return enabled;
 639 }
 640
 641 /**
 642 ****************************************************************************************************
 643 *   Lib::GetBpe
 644 *
 645 *   @brief
 646 *       Get bits-per-element for specified format
 647 *   @return
 648 *       bits-per-element of specified format
 649 ****************************************************************************************************
 650 */
 651 UINT_32 Lib::GetBpe(AddrFormat format) const
 652 {
 653     return GetElemLib()->GetBitsPerPixel(format);
 654 }
 655
 656 } // Addr