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                 pLib = Gfx9HwlInit(&client);
 222                 break;
 223             default:
 224                 ADDR_ASSERT_ALWAYS();
 225                 break;
 226         }
 227     }
 228
 229     if (pLib != NULL)
 230     {
 231         BOOL_32 initValid;
 232
 233         // Pass createFlags to configFlags first since these flags may be overwritten
 234         pLib->m_configFlags.noCubeMipSlicesPad  = pCreateIn->createFlags.noCubeMipSlicesPad;
 235         pLib->m_configFlags.fillSizeFields      = pCreateIn->createFlags.fillSizeFields;
 236         pLib->m_configFlags.useTileIndex        = pCreateIn->createFlags.useTileIndex;
 237         pLib->m_configFlags.useCombinedSwizzle  = pCreateIn->createFlags.useCombinedSwizzle;
 238         pLib->m_configFlags.checkLast2DLevel    = pCreateIn->createFlags.checkLast2DLevel;
 239         pLib->m_configFlags.useHtileSliceAlign  = pCreateIn->createFlags.useHtileSliceAlign;
 240         pLib->m_configFlags.allowLargeThickTile = pCreateIn->createFlags.allowLargeThickTile;
 241         pLib->m_configFlags.disableLinearOpt    = FALSE;
 242
 243         pLib->SetChipFamily(pCreateIn->chipFamily, pCreateIn->chipRevision);
 244
 245         pLib->SetMinPitchAlignPixels(pCreateIn->minPitchAlignPixels);
 246
 247         // Global parameters initialized and remaining configFlags bits are set as well
 248         initValid = pLib->HwlInitGlobalParams(pCreateIn);
 249
 250         if (initValid)
 251         {
 252             pLib->m_pElemLib = ElemLib::Create(pLib);
 253         }
 254         else
 255         {
 256             pLib->m_pElemLib = NULL; // Don't go on allocating element lib
 257             returnCode = ADDR_INVALIDGBREGVALUES;
 258         }
 259
 260         if (pLib->m_pElemLib == NULL)
 261         {
 262             delete pLib;
 263             pLib = NULL;
 264             ADDR_ASSERT_ALWAYS();
 265         }
 266         else
 267         {
 268             pLib->m_pElemLib->SetConfigFlags(pLib->m_configFlags);
 269         }
 270     }
 271
 272     pCreateOut->hLib = pLib;
 273
 274     if ((pLib != NULL) &&
 275         (returnCode == ADDR_OK))
 276     {
 277         pCreateOut->numEquations =
 278             pLib->HwlGetEquationTableInfo(&pCreateOut->pEquationTable);
 279     }
 280
 281     if ((pLib == NULL) &&
 282         (returnCode == ADDR_OK))
 283     {
 284         // Unknown failures, we return the general error code
 285         returnCode = ADDR_ERROR;
 286     }
 287
 288     return returnCode;
 289 }
 290
 291 /**
 292 ****************************************************************************************************
 293 *   Lib::SetChipFamily
 294 *
 295 *   @brief
 296 *       Convert familyID defined in atiid.h to ChipFamily and set m_chipFamily/m_chipRevision
 297 *   @return
 298 *      N/A
 299 ****************************************************************************************************
 300 */
 301 VOID Lib::SetChipFamily(
 302     UINT_32 uChipFamily,        ///< [in] chip family defined in atiih.h
 303     UINT_32 uChipRevision)      ///< [in] chip revision defined in "asic_family"_id.h
 304 {
 305     ChipFamily family = HwlConvertChipFamily(uChipFamily, uChipRevision);
 306
 307     ADDR_ASSERT(family != ADDR_CHIP_FAMILY_IVLD);
 308
 309     m_chipFamily   = family;
 310     m_chipRevision = uChipRevision;
 311 }
 312
 313 /**
 314 ****************************************************************************************************
 315 *   Lib::SetMinPitchAlignPixels
 316 *
 317 *   @brief
 318 *       Set m_minPitchAlignPixels with input param
 319 *
 320 *   @return
 321 *      N/A
 322 ****************************************************************************************************
 323 */
 324 VOID Lib::SetMinPitchAlignPixels(
 325     UINT_32 minPitchAlignPixels)    ///< [in] minmum pitch alignment in pixels
 326 {
 327     m_minPitchAlignPixels = (minPitchAlignPixels == 0) ? 1 : minPitchAlignPixels;
 328 }
 329
 330 /**
 331 ****************************************************************************************************
 332 *   Lib::GetLib
 333 *
 334 *   @brief
 335 *       Get AddrLib pointer
 336 *
 337 *   @return
 338 *      An AddrLib class pointer
 339 ****************************************************************************************************
 340 */
 341 Lib* Lib::GetLib(
 342     ADDR_HANDLE hLib)   ///< [in] handle of ADDR_HANDLE
 343 {
 344     return static_cast<Addr::Lib*>(hLib);
 345 }
 346
 347 /**
 348 ****************************************************************************************************
 349 *   Lib::GetMaxAlignments
 350 *
 351 *   @brief
 352 *       Gets maximum alignments
 353 *
 354 *   @return
 355 *       ADDR_E_RETURNCODE
 356 ****************************************************************************************************
 357 */
 358 ADDR_E_RETURNCODE Lib::GetMaxAlignments(
 359     ADDR_GET_MAX_ALIGNMENTS_OUTPUT* pOut    ///< [out] output structure
 360     ) const
 361 {
 362     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 363
 364     if (GetFillSizeFieldsFlags() == TRUE)
 365     {
 366         if (pOut->size != sizeof(ADDR_GET_MAX_ALIGNMENTS_OUTPUT))
 367         {
 368             returnCode = ADDR_PARAMSIZEMISMATCH;
 369         }
 370     }
 371
 372     if (returnCode == ADDR_OK)
 373     {
 374         returnCode = HwlGetMaxAlignments(pOut);
 375     }
 376
 377     return returnCode;
 378 }
 379
 380 /**
 381 ****************************************************************************************************
 382 *   Lib::Bits2Number
 383 *
 384 *   @brief
 385 *       Cat a array of binary bit to a number
 386 *
 387 *   @return
 388 *       The number combined with the array of bits
 389 ****************************************************************************************************
 390 */
 391 UINT_32 Lib::Bits2Number(
 392     UINT_32 bitNum,     ///< [in] how many bits
 393     ...)                ///< [in] varaible bits value starting from MSB
 394 {
 395     UINT_32 number = 0;
 396     UINT_32 i;
 397     va_list bits_ptr;
 398
 399     va_start(bits_ptr, bitNum);
 400
 401     for(i = 0; i < bitNum; i++)
 402     {
 403         number |= va_arg(bits_ptr, UINT_32);
 404         number <<= 1;
 405     }
 406
 407     number >>= 1;
 408
 409     va_end(bits_ptr);
 410
 411     return number;
 412 }
 413
 414
 415 ////////////////////////////////////////////////////////////////////////////////////////////////////
 416 //                               Element lib
 417 ////////////////////////////////////////////////////////////////////////////////////////////////////
 418
 419
 420 /**
 421 ****************************************************************************************************
 422 *   Lib::Flt32ToColorPixel
 423 *
 424 *   @brief
 425 *       Convert a FLT_32 value to a depth/stencil pixel value
 426 *   @return
 427 *       ADDR_E_RETURNCODE
 428 ****************************************************************************************************
 429 */
 430 ADDR_E_RETURNCODE Lib::Flt32ToDepthPixel(
 431     const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,
 432     ELEM_FLT32TODEPTHPIXEL_OUTPUT* pOut) const
 433 {
 434     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 435
 436     if (GetFillSizeFieldsFlags() == TRUE)
 437     {
 438         if ((pIn->size != sizeof(ELEM_FLT32TODEPTHPIXEL_INPUT)) ||
 439             (pOut->size != sizeof(ELEM_FLT32TODEPTHPIXEL_OUTPUT)))
 440         {
 441             returnCode = ADDR_PARAMSIZEMISMATCH;
 442         }
 443     }
 444
 445     if (returnCode == ADDR_OK)
 446     {
 447         GetElemLib()->Flt32ToDepthPixel(pIn->format, pIn->comps, pOut->pPixel);
 448
 449         UINT_32 depthBase = 0;
 450         UINT_32 stencilBase = 0;
 451         UINT_32 depthBits = 0;
 452         UINT_32 stencilBits = 0;
 453
 454         switch (pIn->format)
 455         {
 456             case ADDR_DEPTH_16:
 457                 depthBits = 16;
 458                 break;
 459             case ADDR_DEPTH_X8_24:
 460             case ADDR_DEPTH_8_24:
 461             case ADDR_DEPTH_X8_24_FLOAT:
 462             case ADDR_DEPTH_8_24_FLOAT:
 463                 depthBase = 8;
 464                 depthBits = 24;
 465                 stencilBits = 8;
 466                 break;
 467             case ADDR_DEPTH_32_FLOAT:
 468                 depthBits = 32;
 469                 break;
 470             case ADDR_DEPTH_X24_8_32_FLOAT:
 471                 depthBase = 8;
 472                 depthBits = 32;
 473                 stencilBits = 8;
 474                 break;
 475             default:
 476                 break;
 477         }
 478
 479         // Overwrite base since R800 has no "tileBase"
 480         if (GetElemLib()->IsDepthStencilTilePlanar() == FALSE)
 481         {
 482             depthBase = 0;
 483             stencilBase = 0;
 484         }
 485
 486         depthBase *= 64;
 487         stencilBase *= 64;
 488
 489         pOut->stencilBase = stencilBase;
 490         pOut->depthBase = depthBase;
 491         pOut->depthBits = depthBits;
 492         pOut->stencilBits = stencilBits;
 493     }
 494
 495     return returnCode;
 496 }
 497
 498 /**
 499 ****************************************************************************************************
 500 *   Lib::Flt32ToColorPixel
 501 *
 502 *   @brief
 503 *       Convert a FLT_32 value to a red/green/blue/alpha pixel value
 504 *   @return
 505 *       ADDR_E_RETURNCODE
 506 ****************************************************************************************************
 507 */
 508 ADDR_E_RETURNCODE Lib::Flt32ToColorPixel(
 509     const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,
 510     ELEM_FLT32TOCOLORPIXEL_OUTPUT* pOut) const
 511 {
 512     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 513
 514     if (GetFillSizeFieldsFlags() == TRUE)
 515     {
 516         if ((pIn->size != sizeof(ELEM_FLT32TOCOLORPIXEL_INPUT)) ||
 517             (pOut->size != sizeof(ELEM_FLT32TOCOLORPIXEL_OUTPUT)))
 518         {
 519             returnCode = ADDR_PARAMSIZEMISMATCH;
 520         }
 521     }
 522
 523     if (returnCode == ADDR_OK)
 524     {
 525         GetElemLib()->Flt32ToColorPixel(pIn->format,
 526                                         pIn->surfNum,
 527                                         pIn->surfSwap,
 528                                         pIn->comps,
 529                                         pOut->pPixel);
 530     }
 531
 532     return returnCode;
 533 }
 534
 535
 536 /**
 537 ****************************************************************************************************
 538 *   Lib::GetExportNorm
 539 *
 540 *   @brief
 541 *       Check one format can be EXPORT_NUM
 542 *   @return
 543 *       TRUE if EXPORT_NORM can be used
 544 ****************************************************************************************************
 545 */
 546 BOOL_32 Lib::GetExportNorm(
 547     const ELEM_GETEXPORTNORM_INPUT* pIn) const
 548 {
 549     ADDR_E_RETURNCODE returnCode = ADDR_OK;
 550
 551     BOOL_32 enabled = FALSE;
 552
 553     if (GetFillSizeFieldsFlags() == TRUE)
 554     {
 555         if (pIn->size != sizeof(ELEM_GETEXPORTNORM_INPUT))
 556         {
 557             returnCode = ADDR_PARAMSIZEMISMATCH;
 558         }
 559     }
 560
 561     if (returnCode == ADDR_OK)
 562     {
 563         enabled = GetElemLib()->PixGetExportNorm(pIn->format, pIn->num, pIn->swap);
 564     }
 565
 566     return enabled;
 567 }
 568
 569 } // Addr