src/amd/addrlib/core/addrcommon.h

   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  addrcommon.h
  30 * @brief Contains the helper function and constants
  31 ***************************************************************************************************
  32 */
  33
  34 #ifndef __ADDR_COMMON_H__
  35 #define __ADDR_COMMON_H__
  36
  37 #include "addrinterface.h"
  38
  39
  40 // ADDR_LNX_KERNEL_BUILD is for internal build
  41 // Moved from addrinterface.h so __KERNEL__ is not needed any more
  42 #if ADDR_LNX_KERNEL_BUILD // || (defined(__GNUC__) && defined(__KERNEL__))
  43     #include "lnx_common_defs.h" // ported from cmmqs
  44 #elif !defined(__APPLE__)
  45     #include <stdlib.h>
  46     #include <string.h>
  47 #endif
  48
  49 ///////////////////////////////////////////////////////////////////////////////////////////////////
  50 // Common constants
  51 ///////////////////////////////////////////////////////////////////////////////////////////////////
  52 static const UINT_32 MicroTileWidth      = 8;       ///< Micro tile width, for 1D and 2D tiling
  53 static const UINT_32 MicroTileHeight     = 8;       ///< Micro tile height, for 1D and 2D tiling
  54 static const UINT_32 ThickTileThickness  = 4;       ///< Micro tile thickness, for THICK modes
  55 static const UINT_32 XThickTileThickness = 8;       ///< Extra thick tiling thickness
  56 static const UINT_32 PowerSaveTileBytes  = 64;      ///< Nuber of bytes per tile for power save 64
  57 static const UINT_32 CmaskCacheBits      = 1024;    ///< Number of bits for CMASK cache
  58 static const UINT_32 CmaskElemBits       = 4;       ///< Number of bits for CMASK element
  59 static const UINT_32 HtileCacheBits      = 16384;   ///< Number of bits for HTILE cache 512*32
  60
  61 static const UINT_32 MicroTilePixels     = MicroTileWidth * MicroTileHeight;
  62
  63 static const INT_32 TileIndexInvalid        = TILEINDEX_INVALID;
  64 static const INT_32 TileIndexLinearGeneral  = TILEINDEX_LINEAR_GENERAL;
  65 static const INT_32 TileIndexNoMacroIndex   = -3;
  66
  67 ///////////////////////////////////////////////////////////////////////////////////////////////////
  68 // Common macros
  69 ///////////////////////////////////////////////////////////////////////////////////////////////////
  70 #define BITS_PER_BYTE 8
  71 #define BITS_TO_BYTES(x) ( ((x) + (BITS_PER_BYTE-1)) / BITS_PER_BYTE )
  72 #define BYTES_TO_BITS(x) ( (x) * BITS_PER_BYTE )
  73
  74 /// Helper macros to select a single bit from an int (undefined later in section)
  75 #define _BIT(v,b)      (((v) >> (b) ) & 1)
  76
  77 /**
  78 ***************************************************************************************************
  79 * @brief Enums to identify AddrLib type
  80 ***************************************************************************************************
  81 */
  82 enum AddrLibClass
  83 {
  84     BASE_ADDRLIB = 0x0,
  85     R600_ADDRLIB = 0x6,
  86     R800_ADDRLIB = 0x8,
  87     SI_ADDRLIB   = 0xa,
  88     CI_ADDRLIB   = 0xb,
  89 };
  90
  91 /**
  92 ***************************************************************************************************
  93 * AddrChipFamily
  94 *
  95 *   @brief
  96 *       Neutral enums that specifies chip family.
  97 *
  98 ***************************************************************************************************
  99 */
 100 enum AddrChipFamily
 101 {
 102     ADDR_CHIP_FAMILY_IVLD,    ///< Invalid family
 103     ADDR_CHIP_FAMILY_R6XX,
 104     ADDR_CHIP_FAMILY_R7XX,
 105     ADDR_CHIP_FAMILY_R8XX,
 106     ADDR_CHIP_FAMILY_NI,
 107     ADDR_CHIP_FAMILY_SI,
 108     ADDR_CHIP_FAMILY_CI,
 109     ADDR_CHIP_FAMILY_VI,
 110 };
 111
 112 /**
 113 ***************************************************************************************************
 114 * ADDR_CONFIG_FLAGS
 115 *
 116 *   @brief
 117 *       This structure is used to set addr configuration flags.
 118 ***************************************************************************************************
 119 */
 120 union ADDR_CONFIG_FLAGS
 121 {
 122     struct
 123     {
 124         /// Clients do not need to set these flags except forceLinearAligned.
 125         /// There flags are set up by AddrLib inside thru AddrInitGlobalParamsFromRegister
 126         UINT_32 optimalBankSwap        : 1;    ///< New bank tiling for RV770 only
 127         UINT_32 noCubeMipSlicesPad     : 1;    ///< Disables faces padding for cubemap mipmaps
 128         UINT_32 fillSizeFields         : 1;    ///< If clients fill size fields in all input and
 129                                                ///  output structure
 130         UINT_32 ignoreTileInfo         : 1;    ///< Don't use tile info structure
 131         UINT_32 useTileIndex           : 1;    ///< Make tileIndex field in input valid
 132         UINT_32 useCombinedSwizzle     : 1;    ///< Use combined swizzle
 133         UINT_32 checkLast2DLevel       : 1;    ///< Check the last 2D mip sub level
 134         UINT_32 useHtileSliceAlign     : 1;    ///< Do htile single slice alignment
 135         UINT_32 degradeBaseLevel       : 1;    ///< Degrade to 1D modes automatically for base level
 136         UINT_32 allowLargeThickTile    : 1;    ///< Allow 64*thickness*bytesPerPixel > rowSize
 137         UINT_32 reserved               : 22;   ///< Reserved bits for future use
 138     };
 139
 140     UINT_32 value;
 141 };
 142
 143 ///////////////////////////////////////////////////////////////////////////////////////////////////
 144 // Platform specific debug break defines
 145 ///////////////////////////////////////////////////////////////////////////////////////////////////
 146 #if DEBUG
 147     #if defined(__GNUC__)
 148         #define ADDR_DBG_BREAK()
 149     #elif defined(__APPLE__)
 150         #define ADDR_DBG_BREAK()    { IOPanic("");}
 151     #else
 152         #define ADDR_DBG_BREAK()    { __debugbreak(); }
 153     #endif
 154 #else
 155     #define ADDR_DBG_BREAK()
 156 #endif
 157 ///////////////////////////////////////////////////////////////////////////////////////////////////
 158
 159 ///////////////////////////////////////////////////////////////////////////////////////////////////
 160 // Debug assertions used in AddrLib
 161 ///////////////////////////////////////////////////////////////////////////////////////////////////
 162 #if DEBUG
 163 #define ADDR_ASSERT(__e) if ( !((__e) ? TRUE : FALSE)) { ADDR_DBG_BREAK(); }
 164 #define ADDR_ASSERT_ALWAYS() ADDR_DBG_BREAK()
 165 #define ADDR_UNHANDLED_CASE() ADDR_ASSERT(!"Unhandled case")
 166 #define ADDR_NOT_IMPLEMENTED() ADDR_ASSERT(!"Not implemented");
 167 #else //DEBUG
 168 #define ADDR_ASSERT(__e)
 169 #define ADDR_ASSERT_ALWAYS()
 170 #define ADDR_UNHANDLED_CASE()
 171 #define ADDR_NOT_IMPLEMENTED()
 172 #endif //DEBUG
 173 ///////////////////////////////////////////////////////////////////////////////////////////////////
 174
 175 ///////////////////////////////////////////////////////////////////////////////////////////////////
 176 // Debug print macro from legacy address library
 177 ///////////////////////////////////////////////////////////////////////////////////////////////////
 178 #if DEBUG
 179
 180 #define ADDR_PRNT(a)    AddrObject::DebugPrint a
 181
 182 /// @brief Macro for reporting informational messages
 183 /// @ingroup util
 184 ///
 185 /// This macro optionally prints an informational message to stdout.
 186 /// The first parameter is a condition -- if it is true, nothing is done.
 187 /// The second pararmeter MUST be a parenthesis-enclosed list of arguments,
 188 /// starting with a string. This is passed to printf() or an equivalent
 189 /// in order to format the informational message. For example,
 190 /// ADDR_INFO(0, ("test %d",3) ); prints out "test 3".
 191 ///
 192 #define ADDR_INFO(cond, a)         \
 193 { if (!(cond)) { ADDR_PRNT(a); } }
 194
 195
 196 /// @brief Macro for reporting error warning messages
 197 /// @ingroup util
 198 ///
 199 /// This macro optionally prints an error warning message to stdout,
 200 /// followed by the file name and line number where the macro was called.
 201 /// The first parameter is a condition -- if it is true, nothing is done.
 202 /// The second pararmeter MUST be a parenthesis-enclosed list of arguments,
 203 /// starting with a string. This is passed to printf() or an equivalent
 204 /// in order to format the informational message. For example,
 205 /// ADDR_WARN(0, ("test %d",3) ); prints out "test 3" followed by
 206 /// a second line with the file name and line number.
 207 ///
 208 #define ADDR_WARN(cond, a)         \
 209 { if (!(cond))                     \
 210   { ADDR_PRNT(a);                  \
 211     ADDR_PRNT(("  WARNING in file %s, line %d\n", __FILE__, __LINE__)); \
 212 } }
 213
 214
 215 /// @brief Macro for reporting fatal error conditions
 216 /// @ingroup util
 217 ///
 218 /// This macro optionally stops execution of the current routine
 219 /// after printing an error warning message to stdout,
 220 /// followed by the file name and line number where the macro was called.
 221 /// The first parameter is a condition -- if it is true, nothing is done.
 222 /// The second pararmeter MUST be a parenthesis-enclosed list of arguments,
 223 /// starting with a string. This is passed to printf() or an equivalent
 224 /// in order to format the informational message. For example,
 225 /// ADDR_EXIT(0, ("test %d",3) ); prints out "test 3" followed by
 226 /// a second line with the file name and line number, then stops execution.
 227 ///
 228 #define ADDR_EXIT(cond, a)         \
 229 { if (!(cond))                     \
 230   { ADDR_PRNT(a); ADDR_DBG_BREAK();\
 231 } }
 232
 233 #else // DEBUG
 234
 235 #define ADDRDPF 1 ? (void)0 : (void)
 236
 237 #define ADDR_PRNT(a)
 238
 239 #define ADDR_DBG_BREAK()
 240
 241 #define ADDR_INFO(cond, a)
 242
 243 #define ADDR_WARN(cond, a)
 244
 245 #define ADDR_EXIT(cond, a)
 246
 247 #endif // DEBUG
 248 ///////////////////////////////////////////////////////////////////////////////////////////////////
 249
 250 ///////////////////////////////////////////////////////////////////////////////////////////////////
 251 // Misc helper functions
 252 ////////////////////////////////////////////////////////////////////////////////////////////////////
 253
 254 /**
 255 ***************************************************************************************************
 256 *   AddrXorReduce
 257 *
 258 *   @brief
 259 *       Xor the right-side numberOfBits bits of x.
 260 ***************************************************************************************************
 261 */
 262 static inline UINT_32 XorReduce(
 263     UINT_32 x,
 264     UINT_32 numberOfBits)
 265 {
 266     UINT_32 i;
 267     UINT_32 result = x & 1;
 268
 269     for (i=1; i<numberOfBits; i++)
 270     {
 271         result ^= ((x>>i) & 1);
 272     }
 273
 274     return result;
 275 }
 276
 277 /**
 278 ***************************************************************************************************
 279 *   IsPow2
 280 *
 281 *   @brief
 282 *       Check if the size (UINT_32) is pow 2
 283 ***************************************************************************************************
 284 */
 285 static inline UINT_32 IsPow2(
 286     UINT_32 dim)        ///< [in] dimension of miplevel
 287 {
 288     ADDR_ASSERT(dim > 0);
 289     return !(dim & (dim - 1));
 290 }
 291
 292 /**
 293 ***************************************************************************************************
 294 *   IsPow2
 295 *
 296 *   @brief
 297 *       Check if the size (UINT_64) is pow 2
 298 ***************************************************************************************************
 299 */
 300 static inline UINT_64 IsPow2(
 301     UINT_64 dim)        ///< [in] dimension of miplevel
 302 {
 303     ADDR_ASSERT(dim > 0);
 304     return !(dim & (dim - 1));
 305 }
 306
 307 /**
 308 ***************************************************************************************************
 309 *   ByteAlign
 310 *
 311 *   @brief
 312 *       Align UINT_32 "x" to "align" alignment, "align" should be power of 2
 313 ***************************************************************************************************
 314 */
 315 static inline UINT_32 PowTwoAlign(
 316     UINT_32 x,
 317     UINT_32 align)
 318 {
 319     //
 320     // Assert that x is a power of two.
 321     //
 322     ADDR_ASSERT(IsPow2(align));
 323     return (x + (align - 1)) & (~(align - 1));
 324 }
 325
 326 /**
 327 ***************************************************************************************************
 328 *   ByteAlign
 329 *
 330 *   @brief
 331 *       Align UINT_64 "x" to "align" alignment, "align" should be power of 2
 332 ***************************************************************************************************
 333 */
 334 static inline UINT_64 PowTwoAlign(
 335     UINT_64 x,
 336     UINT_64 align)
 337 {
 338     //
 339     // Assert that x is a power of two.
 340     //
 341     ADDR_ASSERT(IsPow2(align));
 342     return (x + (align - 1)) & (~(align - 1));
 343 }
 344
 345 /**
 346 ***************************************************************************************************
 347 *   Min
 348 *
 349 *   @brief
 350 *       Get the min value between two unsigned values
 351 ***************************************************************************************************
 352 */
 353 static inline UINT_32 Min(
 354     UINT_32 value1,
 355     UINT_32 value2)
 356 {
 357     return ((value1 < (value2)) ? (value1) : value2);
 358 }
 359
 360 /**
 361 ***************************************************************************************************
 362 *   Min
 363 *
 364 *   @brief
 365 *       Get the min value between two signed values
 366 ***************************************************************************************************
 367 */
 368 static inline INT_32 Min(
 369     INT_32 value1,
 370     INT_32 value2)
 371 {
 372     return ((value1 < (value2)) ? (value1) : value2);
 373 }
 374
 375 /**
 376 ***************************************************************************************************
 377 *   Max
 378 *
 379 *   @brief
 380 *       Get the max value between two unsigned values
 381 ***************************************************************************************************
 382 */
 383 static inline UINT_32 Max(
 384     UINT_32 value1,
 385     UINT_32 value2)
 386 {
 387     return ((value1 > (value2)) ? (value1) : value2);
 388 }
 389
 390 /**
 391 ***************************************************************************************************
 392 *   Max
 393 *
 394 *   @brief
 395 *       Get the max value between two signed values
 396 ***************************************************************************************************
 397 */
 398 static inline INT_32 Max(
 399     INT_32 value1,
 400     INT_32 value2)
 401 {
 402     return ((value1 > (value2)) ? (value1) : value2);
 403 }
 404
 405 /**
 406 ***************************************************************************************************
 407 *   NextPow2
 408 *
 409 *   @brief
 410 *       Compute the mipmap's next level dim size
 411 ***************************************************************************************************
 412 */
 413 static inline UINT_32 NextPow2(
 414     UINT_32 dim)        ///< [in] dimension of miplevel
 415 {
 416     UINT_32 newDim;
 417
 418     newDim = 1;
 419
 420     if (dim > 0x7fffffff)
 421     {
 422         ADDR_ASSERT_ALWAYS();
 423         newDim = 0x80000000;
 424     }
 425     else
 426     {
 427         while (newDim < dim)
 428         {
 429             newDim <<= 1;
 430         }
 431     }
 432
 433     return newDim;
 434 }
 435
 436 /**
 437 ***************************************************************************************************
 438 *   Log2
 439 *
 440 *   @brief
 441 *       Compute log of base 2
 442 ***************************************************************************************************
 443 */
 444 static inline UINT_32 Log2(
 445     UINT_32 x)      ///< [in] the value should calculate log based 2
 446 {
 447     UINT_32 y;
 448
 449     //
 450     // Assert that x is a power of two.
 451     //
 452     ADDR_ASSERT(IsPow2(x));
 453
 454     y = 0;
 455     while (x > 1)
 456     {
 457         x >>= 1;
 458         y++;
 459     }
 460
 461     return y;
 462 }
 463
 464 /**
 465 ***************************************************************************************************
 466 *   QLog2
 467 *
 468 *   @brief
 469 *       Compute log of base 2 quickly (<= 16)
 470 ***************************************************************************************************
 471 */
 472 static inline UINT_32 QLog2(
 473     UINT_32 x)      ///< [in] the value should calculate log based 2
 474 {
 475     ADDR_ASSERT(x <= 16);
 476
 477     UINT_32 y = 0;
 478
 479     switch (x)
 480     {
 481         case 1:
 482             y = 0;
 483             break;
 484         case 2:
 485             y = 1;
 486             break;
 487         case 4:
 488             y = 2;
 489             break;
 490         case 8:
 491             y = 3;
 492             break;
 493         case 16:
 494             y = 4;
 495             break;
 496         default:
 497             ADDR_ASSERT_ALWAYS();
 498     }
 499
 500     return y;
 501 }
 502
 503 /**
 504 ***************************************************************************************************
 505 *   SafeAssign
 506 *
 507 *   @brief
 508 *       NULL pointer safe assignment
 509 ***************************************************************************************************
 510 */
 511 static inline VOID SafeAssign(
 512     UINT_32*    pLVal,  ///< [in] Pointer to left val
 513     UINT_32     rVal)   ///< [in] Right value
 514 {
 515     if (pLVal)
 516     {
 517         *pLVal = rVal;
 518     }
 519 }
 520
 521 /**
 522 ***************************************************************************************************
 523 *   SafeAssign
 524 *
 525 *   @brief
 526 *       NULL pointer safe assignment for 64bit values
 527 ***************************************************************************************************
 528 */
 529 static inline VOID SafeAssign(
 530     UINT_64*    pLVal,  ///< [in] Pointer to left val
 531     UINT_64     rVal)   ///< [in] Right value
 532 {
 533     if (pLVal)
 534     {
 535         *pLVal = rVal;
 536     }
 537 }
 538
 539 /**
 540 ***************************************************************************************************
 541 *   SafeAssign
 542 *
 543 *   @brief
 544 *       NULL pointer safe assignment for AddrTileMode
 545 ***************************************************************************************************
 546 */
 547 static inline VOID SafeAssign(
 548     AddrTileMode*    pLVal, ///< [in] Pointer to left val
 549     AddrTileMode     rVal)  ///< [in] Right value
 550 {
 551     if (pLVal)
 552     {
 553         *pLVal = rVal;
 554     }
 555 }
 556
 557 #endif // __ADDR_COMMON_H__
 558