src/amd/addrlib/core/addrlib.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  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 ////////////////////////////////////////////////////////////////////////////////////////////////////
 162 //                               Initialization/Helper
 163 ////////////////////////////////////////////////////////////////////////////////////////////////////
 164
 165 /**
 166 ****************************************************************************************************
 167 *   Lib::Create
 168 *
 169 *   @brief
 170 *       Creates and initializes AddrLib object.
 171 *
 172 *   @return
 173 *       ADDR_E_RETURNCODE
 174 ****************************************************************************************************
 175 */
 176 ADDR_E_RETURNCODE Lib::Create(
 177     const ADDR_CREATE_INPUT* pCreateIn,     ///< [in] pointer to ADDR_CREATE_INPUT
 178     ADDR_CREATE_OUTPUT*      pCreateOut)    ///< [out] pointer to ADDR_CREATE_OUTPUT
 179 {
 180     Lib* pLib = NULL;
 181     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 182
 183     if (pCreateIn->createFlags.fillSizeFields == TRUE)
 184     {
 185         if ((pCreateIn->size != sizeof(ADDR_CREATE_INPUT)) ||
 186             (pCreateOut->size != sizeof(ADDR_CREATE_OUTPUT)))
 187         {
 188             returnCode = ADDR_PARAMSIZEMISMATCH;
 189         }
 190     }
 191
 192     if ((returnCode == ADDR_OK)                    &&
 193         (pCreateIn->callbacks.allocSysMem != NULL) &&
 194         (pCreateIn->callbacks.freeSysMem != NULL))
 195     {
 196         Client client = {
 197             pCreateIn->hClient,
 198             pCreateIn->callbacks
 199         };
 200
 201         switch (pCreateIn->chipEngine)
 202         {
 203             case CIASICIDGFXENGINE_SOUTHERNISLAND:
 204                 switch (pCreateIn->chipFamily)
 205                 {
 206                     case FAMILY_SI:
 207                         pLib = SiHwlInit(&client);
 208                         break;
 209                     case FAMILY_VI:
 210                     case FAMILY_CZ: // VI based fusion(carrizo)
 211                     case FAMILY_CI:
 212                     case FAMILY_KV: // CI based fusion
 213                         pLib = CiHwlInit(&client);
 214                         break;
 215                     default:
 216                         ADDR_ASSERT_ALWAYS();
 217                         break;
 218                 }
 219                 break;
 220             case CIASICIDGFXENGINE_ARCTICISLAND:
 221                 switch (pCreateIn->chipFamily)
 222                 {
 223                     case FAMILY_AI:
 224                     case FAMILY_RV:
 225                         pLib = Gfx9HwlInit(&client);
 226                         break;
 227                     default:
 228                         ADDR_ASSERT_ALWAYS();
 229                         break;
 230                 }
 231                 break;
 232             default:
 233                 ADDR_ASSERT_ALWAYS();
 234                 break;
 235         }
 236     }
 237
 238     if (pLib != NULL)
 239     {
 240         BOOL_32 initValid;
 241
 242         // Pass createFlags to configFlags first since these flags may be overwritten
 243         pLib->m_configFlags.noCubeMipSlicesPad  = pCreateIn->createFlags.noCubeMipSlicesPad;
 244         pLib->m_configFlags.fillSizeFields      = pCreateIn->createFlags.fillSizeFields;
 245         pLib->m_configFlags.useTileIndex        = pCreateIn->createFlags.useTileIndex;
 246         pLib->m_configFlags.useCombinedSwizzle  = pCreateIn->createFlags.useCombinedSwizzle;
 247         pLib->m_configFlags.checkLast2DLevel    = pCreateIn->createFlags.checkLast2DLevel;
 248         pLib->m_configFlags.useHtileSliceAlign  = pCreateIn->createFlags.useHtileSliceAlign;
 249         pLib->m_configFlags.allowLargeThickTile = pCreateIn->createFlags.allowLargeThickTile;
 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 ////////////////////////////////////////////////////////////////////////////////////////////////////
 491 //                               Element lib
 492 ////////////////////////////////////////////////////////////////////////////////////////////////////
 493
 494
 495 /**
 496 ****************************************************************************************************
 497 *   Lib::Flt32ToColorPixel
 498 *
 499 *   @brief
 500 *       Convert a FLT_32 value to a depth/stencil pixel value
 501 *   @return
 502 *       ADDR_E_RETURNCODE
 503 ****************************************************************************************************
 504 */
 505 ADDR_E_RETURNCODE Lib::Flt32ToDepthPixel(
 506     const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,
 507     ELEM_FLT32TODEPTHPIXEL_OUTPUT* pOut) const
 508 {
 509     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 510
 511     if (GetFillSizeFieldsFlags() == TRUE)
 512     {
 513         if ((pIn->size != sizeof(ELEM_FLT32TODEPTHPIXEL_INPUT)) ||
 514             (pOut->size != sizeof(ELEM_FLT32TODEPTHPIXEL_OUTPUT)))
 515         {
 516             returnCode = ADDR_PARAMSIZEMISMATCH;
 517         }
 518     }
 519
 520     if (returnCode == ADDR_OK)
 521     {
 522         GetElemLib()->Flt32ToDepthPixel(pIn->format, pIn->comps, pOut->pPixel);
 523
 524         UINT_32 depthBase = 0;
 525         UINT_32 stencilBase = 0;
 526         UINT_32 depthBits = 0;
 527         UINT_32 stencilBits = 0;
 528
 529         switch (pIn->format)
 530         {
 531             case ADDR_DEPTH_16:
 532                 depthBits = 16;
 533                 break;
 534             case ADDR_DEPTH_X8_24:
 535             case ADDR_DEPTH_8_24:
 536             case ADDR_DEPTH_X8_24_FLOAT:
 537             case ADDR_DEPTH_8_24_FLOAT:
 538                 depthBase = 8;
 539                 depthBits = 24;
 540                 stencilBits = 8;
 541                 break;
 542             case ADDR_DEPTH_32_FLOAT:
 543                 depthBits = 32;
 544                 break;
 545             case ADDR_DEPTH_X24_8_32_FLOAT:
 546                 depthBase = 8;
 547                 depthBits = 32;
 548                 stencilBits = 8;
 549                 break;
 550             default:
 551                 break;
 552         }
 553
 554         // Overwrite base since R800 has no "tileBase"
 555         if (GetElemLib()->IsDepthStencilTilePlanar() == FALSE)
 556         {
 557             depthBase = 0;
 558             stencilBase = 0;
 559         }
 560
 561         depthBase *= 64;
 562         stencilBase *= 64;
 563
 564         pOut->stencilBase = stencilBase;
 565         pOut->depthBase = depthBase;
 566         pOut->depthBits = depthBits;
 567         pOut->stencilBits = stencilBits;
 568     }
 569
 570     return returnCode;
 571 }
 572
 573 /**
 574 ****************************************************************************************************
 575 *   Lib::Flt32ToColorPixel
 576 *
 577 *   @brief
 578 *       Convert a FLT_32 value to a red/green/blue/alpha pixel value
 579 *   @return
 580 *       ADDR_E_RETURNCODE
 581 ****************************************************************************************************
 582 */
 583 ADDR_E_RETURNCODE Lib::Flt32ToColorPixel(
 584     const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,
 585     ELEM_FLT32TOCOLORPIXEL_OUTPUT* pOut) const
 586 {
 587     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 588
 589     if (GetFillSizeFieldsFlags() == TRUE)
 590     {
 591         if ((pIn->size != sizeof(ELEM_FLT32TOCOLORPIXEL_INPUT)) ||
 592             (pOut->size != sizeof(ELEM_FLT32TOCOLORPIXEL_OUTPUT)))
 593         {
 594             returnCode = ADDR_PARAMSIZEMISMATCH;
 595         }
 596     }
 597
 598     if (returnCode == ADDR_OK)
 599     {
 600         GetElemLib()->Flt32ToColorPixel(pIn->format,
 601                                         pIn->surfNum,
 602                                         pIn->surfSwap,
 603                                         pIn->comps,
 604                                         pOut->pPixel);
 605     }
 606
 607     return returnCode;
 608 }
 609
 610
 611 /**
 612 ****************************************************************************************************
 613 *   Lib::GetExportNorm
 614 *
 615 *   @brief
 616 *       Check one format can be EXPORT_NUM
 617 *   @return
 618 *       TRUE if EXPORT_NORM can be used
 619 ****************************************************************************************************
 620 */
 621 BOOL_32 Lib::GetExportNorm(
 622     const ELEM_GETEXPORTNORM_INPUT* pIn) const
 623 {
 624     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 625
 626     BOOL_32 enabled = FALSE;
 627
 628     if (GetFillSizeFieldsFlags() == TRUE)
 629     {
 630         if (pIn->size != sizeof(ELEM_GETEXPORTNORM_INPUT))
 631         {
 632             returnCode = ADDR_PARAMSIZEMISMATCH;
 633         }
 634     }
 635
 636     if (returnCode == ADDR_OK)
 637     {
 638         enabled = GetElemLib()->PixGetExportNorm(pIn->format, pIn->num, pIn->swap);
 639     }
 640
 641     return enabled;
 642 }
 643
 644 } // Addr