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 #include <stdlib.h>
  40 #include <string.h>
  41 #include <assert.h>
  42
  43 #if !defined(DEBUG)
  44 #ifdef NDEBUG
  45 #define DEBUG 0
  46 #else
  47 #define DEBUG 1
  48 #endif
  49 #endif
  50
  51 ////////////////////////////////////////////////////////////////////////////////////////////////////
  52 // Platform specific debug break defines
  53 ////////////////////////////////////////////////////////////////////////////////////////////////////
  54 #if DEBUG
  55     #if defined(__GNUC__)
  56         #define ADDR_DBG_BREAK()    assert(false)
  57     #elif defined(__APPLE__)
  58         #define ADDR_DBG_BREAK()    { IOPanic("");}
  59     #else
  60         #define ADDR_DBG_BREAK()    { __debugbreak(); }
  61     #endif
  62 #else
  63     #define ADDR_DBG_BREAK()
  64 #endif
  65 ////////////////////////////////////////////////////////////////////////////////////////////////////
  66
  67 ////////////////////////////////////////////////////////////////////////////////////////////////////
  68 // Debug assertions used in AddrLib
  69 ////////////////////////////////////////////////////////////////////////////////////////////////////
  70 #if defined(_WIN32) && (_MSC_VER >= 1400)
  71     #define ADDR_ANALYSIS_ASSUME(expr) __analysis_assume(expr)
  72 #else
  73     #define ADDR_ANALYSIS_ASSUME(expr) do { (void)(expr); } while (0)
  74 #endif
  75
  76 #define ADDR_ASSERT(__e) assert(__e)
  77 #define ADDR_ASSERT_ALWAYS() ADDR_DBG_BREAK()
  78 #define ADDR_UNHANDLED_CASE() ADDR_ASSERT(!"Unhandled case")
  79 #define ADDR_NOT_IMPLEMENTED() ADDR_ASSERT(!"Not implemented");
  80 ////////////////////////////////////////////////////////////////////////////////////////////////////
  81
  82 ////////////////////////////////////////////////////////////////////////////////////////////////////
  83 // Debug print macro from legacy address library
  84 ////////////////////////////////////////////////////////////////////////////////////////////////////
  85 #if DEBUG
  86
  87 #define ADDR_PRNT(a)    Object::DebugPrint a
  88
  89 /// @brief Macro for reporting informational messages
  90 /// @ingroup util
  91 ///
  92 /// This macro optionally prints an informational message to stdout.
  93 /// The first parameter is a condition -- if it is true, nothing is done.
  94 /// The second pararmeter MUST be a parenthesis-enclosed list of arguments,
  95 /// starting with a string. This is passed to printf() or an equivalent
  96 /// in order to format the informational message. For example,
  97 /// ADDR_INFO(0, ("test %d",3) ); prints out "test 3".
  98 ///
  99 #define ADDR_INFO(cond, a)         \
 100 { if (!(cond)) { ADDR_PRNT(a); } }
 101
 102
 103 /// @brief Macro for reporting error warning messages
 104 /// @ingroup util
 105 ///
 106 /// This macro optionally prints an error warning message to stdout,
 107 /// followed by the file name and line number where the macro was called.
 108 /// The first parameter is a condition -- if it is true, nothing is done.
 109 /// The second pararmeter MUST be a parenthesis-enclosed list of arguments,
 110 /// starting with a string. This is passed to printf() or an equivalent
 111 /// in order to format the informational message. For example,
 112 /// ADDR_WARN(0, ("test %d",3) ); prints out "test 3" followed by
 113 /// a second line with the file name and line number.
 114 ///
 115 #define ADDR_WARN(cond, a)         \
 116 { if (!(cond))                     \
 117   { ADDR_PRNT(a);                  \
 118     ADDR_PRNT(("  WARNING in file %s, line %d\n", __FILE__, __LINE__)); \
 119 } }
 120
 121
 122 /// @brief Macro for reporting fatal error conditions
 123 /// @ingroup util
 124 ///
 125 /// This macro optionally stops execution of the current routine
 126 /// after printing an error warning message to stdout,
 127 /// followed by the file name and line number where the macro was called.
 128 /// The first parameter is a condition -- if it is true, nothing is done.
 129 /// The second pararmeter MUST be a parenthesis-enclosed list of arguments,
 130 /// starting with a string. This is passed to printf() or an equivalent
 131 /// in order to format the informational message. For example,
 132 /// ADDR_EXIT(0, ("test %d",3) ); prints out "test 3" followed by
 133 /// a second line with the file name and line number, then stops execution.
 134 ///
 135 #define ADDR_EXIT(cond, a)         \
 136 { if (!(cond))                     \
 137   { ADDR_PRNT(a); ADDR_DBG_BREAK();\
 138 } }
 139
 140 #else // DEBUG
 141
 142 #define ADDRDPF 1 ? (void)0 : (void)
 143
 144 #define ADDR_PRNT(a)
 145
 146 #define ADDR_DBG_BREAK()
 147
 148 #define ADDR_INFO(cond, a)
 149
 150 #define ADDR_WARN(cond, a)
 151
 152 #define ADDR_EXIT(cond, a)
 153
 154 #endif // DEBUG
 155 ////////////////////////////////////////////////////////////////////////////////////////////////////
 156
 157 #define ADDR_C_ASSERT(__e) typedef char __ADDR_C_ASSERT__[(__e) ? 1 : -1]
 158
 159 namespace Addr
 160 {
 161
 162 namespace V1
 163 {
 164 ////////////////////////////////////////////////////////////////////////////////////////////////////
 165 // Common constants
 166 ////////////////////////////////////////////////////////////////////////////////////////////////////
 167 static const UINT_32 MicroTileWidth      = 8;       ///< Micro tile width, for 1D and 2D tiling
 168 static const UINT_32 MicroTileHeight     = 8;       ///< Micro tile height, for 1D and 2D tiling
 169 static const UINT_32 ThickTileThickness  = 4;       ///< Micro tile thickness, for THICK modes
 170 static const UINT_32 XThickTileThickness = 8;       ///< Extra thick tiling thickness
 171 static const UINT_32 PowerSaveTileBytes  = 64;      ///< Nuber of bytes per tile for power save 64
 172 static const UINT_32 CmaskCacheBits      = 1024;    ///< Number of bits for CMASK cache
 173 static const UINT_32 CmaskElemBits       = 4;       ///< Number of bits for CMASK element
 174 static const UINT_32 HtileCacheBits      = 16384;   ///< Number of bits for HTILE cache 512*32
 175
 176 static const UINT_32 MicroTilePixels     = MicroTileWidth * MicroTileHeight;
 177
 178 static const INT_32 TileIndexInvalid        = TILEINDEX_INVALID;
 179 static const INT_32 TileIndexLinearGeneral  = TILEINDEX_LINEAR_GENERAL;
 180 static const INT_32 TileIndexNoMacroIndex   = -3;
 181
 182 } // V1
 183
 184 namespace V2
 185 {
 186 ////////////////////////////////////////////////////////////////////////////////////////////////////
 187 // Common constants
 188 ////////////////////////////////////////////////////////////////////////////////////////////////////
 189 static const UINT_32 MaxSurfaceHeight = 16384;
 190
 191 } // V2
 192
 193 ////////////////////////////////////////////////////////////////////////////////////////////////////
 194 // Common macros
 195 ////////////////////////////////////////////////////////////////////////////////////////////////////
 196 #define BITS_PER_BYTE 8
 197 #define BITS_TO_BYTES(x) ( ((x) + (BITS_PER_BYTE-1)) / BITS_PER_BYTE )
 198 #define BYTES_TO_BITS(x) ( (x) * BITS_PER_BYTE )
 199
 200 /// Helper macros to select a single bit from an int (undefined later in section)
 201 #define _BIT(v,b)      (((v) >> (b) ) & 1)
 202
 203 /**
 204 ****************************************************************************************************
 205 * @brief Enums to identify AddrLib type
 206 ****************************************************************************************************
 207 */
 208 enum LibClass
 209 {
 210     BASE_ADDRLIB = 0x0,
 211     R600_ADDRLIB = 0x6,
 212     R800_ADDRLIB = 0x8,
 213     SI_ADDRLIB   = 0xa,
 214     CI_ADDRLIB   = 0xb,
 215     AI_ADDRLIB   = 0xd,
 216 };
 217
 218 /**
 219 ****************************************************************************************************
 220 * ChipFamily
 221 *
 222 *   @brief
 223 *       Neutral enums that specifies chip family.
 224 *
 225 ****************************************************************************************************
 226 */
 227 enum ChipFamily
 228 {
 229     ADDR_CHIP_FAMILY_IVLD,    ///< Invalid family
 230     ADDR_CHIP_FAMILY_R6XX,
 231     ADDR_CHIP_FAMILY_R7XX,
 232     ADDR_CHIP_FAMILY_R8XX,
 233     ADDR_CHIP_FAMILY_NI,
 234     ADDR_CHIP_FAMILY_SI,
 235     ADDR_CHIP_FAMILY_CI,
 236     ADDR_CHIP_FAMILY_VI,
 237     ADDR_CHIP_FAMILY_AI,
 238 };
 239
 240 /**
 241 ****************************************************************************************************
 242 * ConfigFlags
 243 *
 244 *   @brief
 245 *       This structure is used to set configuration flags.
 246 ****************************************************************************************************
 247 */
 248 union ConfigFlags
 249 {
 250     struct
 251     {
 252         /// These flags are set up internally thru AddrLib::Create() based on ADDR_CREATE_FLAGS
 253         UINT_32 optimalBankSwap        : 1;    ///< New bank tiling for RV770 only
 254         UINT_32 noCubeMipSlicesPad     : 1;    ///< Disables faces padding for cubemap mipmaps
 255         UINT_32 fillSizeFields         : 1;    ///< If clients fill size fields in all input and
 256                                                ///  output structure
 257         UINT_32 ignoreTileInfo         : 1;    ///< Don't use tile info structure
 258         UINT_32 useTileIndex           : 1;    ///< Make tileIndex field in input valid
 259         UINT_32 useCombinedSwizzle     : 1;    ///< Use combined swizzle
 260         UINT_32 checkLast2DLevel       : 1;    ///< Check the last 2D mip sub level
 261         UINT_32 useHtileSliceAlign     : 1;    ///< Do htile single slice alignment
 262         UINT_32 allowLargeThickTile    : 1;    ///< Allow 64*thickness*bytesPerPixel > rowSize
 263         UINT_32 disableLinearOpt       : 1;    ///< Disallow tile modes to be optimized to linear
 264         UINT_32 reserved               : 22;   ///< Reserved bits for future use
 265     };
 266
 267     UINT_32 value;
 268 };
 269
 270 ////////////////////////////////////////////////////////////////////////////////////////////////////
 271 // Misc helper functions
 272 ////////////////////////////////////////////////////////////////////////////////////////////////////
 273
 274 /**
 275 ****************************************************************************************************
 276 *   AddrXorReduce
 277 *
 278 *   @brief
 279 *       Xor the right-side numberOfBits bits of x.
 280 ****************************************************************************************************
 281 */
 282 static inline UINT_32 XorReduce(
 283     UINT_32 x,
 284     UINT_32 numberOfBits)
 285 {
 286     UINT_32 i;
 287     UINT_32 result = x & 1;
 288
 289     for (i=1; i<numberOfBits; i++)
 290     {
 291         result ^= ((x>>i) & 1);
 292     }
 293
 294     return result;
 295 }
 296
 297 /**
 298 ****************************************************************************************************
 299 *   IsPow2
 300 *
 301 *   @brief
 302 *       Check if the size (UINT_32) is pow 2
 303 ****************************************************************************************************
 304 */
 305 static inline UINT_32 IsPow2(
 306     UINT_32 dim)        ///< [in] dimension of miplevel
 307 {
 308     ADDR_ASSERT(dim > 0);
 309     return !(dim & (dim - 1));
 310 }
 311
 312 /**
 313 ****************************************************************************************************
 314 *   IsPow2
 315 *
 316 *   @brief
 317 *       Check if the size (UINT_64) is pow 2
 318 ****************************************************************************************************
 319 */
 320 static inline UINT_64 IsPow2(
 321     UINT_64 dim)        ///< [in] dimension of miplevel
 322 {
 323     ADDR_ASSERT(dim > 0);
 324     return !(dim & (dim - 1));
 325 }
 326
 327 /**
 328 ****************************************************************************************************
 329 *   ByteAlign
 330 *
 331 *   @brief
 332 *       Align UINT_32 "x" to "align" alignment, "align" should be power of 2
 333 ****************************************************************************************************
 334 */
 335 static inline UINT_32 PowTwoAlign(
 336     UINT_32 x,
 337     UINT_32 align)
 338 {
 339     //
 340     // Assert that x is a power of two.
 341     //
 342     ADDR_ASSERT(IsPow2(align));
 343     return (x + (align - 1)) & (~(align - 1));
 344 }
 345
 346 /**
 347 ****************************************************************************************************
 348 *   ByteAlign
 349 *
 350 *   @brief
 351 *       Align UINT_64 "x" to "align" alignment, "align" should be power of 2
 352 ****************************************************************************************************
 353 */
 354 static inline UINT_64 PowTwoAlign(
 355     UINT_64 x,
 356     UINT_64 align)
 357 {
 358     //
 359     // Assert that x is a power of two.
 360     //
 361     ADDR_ASSERT(IsPow2(align));
 362     return (x + (align - 1)) & (~(align - 1));
 363 }
 364
 365 /**
 366 ****************************************************************************************************
 367 *   Min
 368 *
 369 *   @brief
 370 *       Get the min value between two unsigned values
 371 ****************************************************************************************************
 372 */
 373 static inline UINT_32 Min(
 374     UINT_32 value1,
 375     UINT_32 value2)
 376 {
 377     return ((value1 < (value2)) ? (value1) : value2);
 378 }
 379
 380 /**
 381 ****************************************************************************************************
 382 *   Min
 383 *
 384 *   @brief
 385 *       Get the min value between two signed values
 386 ****************************************************************************************************
 387 */
 388 static inline INT_32 Min(
 389     INT_32 value1,
 390     INT_32 value2)
 391 {
 392     return ((value1 < (value2)) ? (value1) : value2);
 393 }
 394
 395 /**
 396 ****************************************************************************************************
 397 *   Max
 398 *
 399 *   @brief
 400 *       Get the max value between two unsigned values
 401 ****************************************************************************************************
 402 */
 403 static inline UINT_32 Max(
 404     UINT_32 value1,
 405     UINT_32 value2)
 406 {
 407     return ((value1 > (value2)) ? (value1) : value2);
 408 }
 409
 410 /**
 411 ****************************************************************************************************
 412 *   Max
 413 *
 414 *   @brief
 415 *       Get the max value between two signed values
 416 ****************************************************************************************************
 417 */
 418 static inline INT_32 Max(
 419     INT_32 value1,
 420     INT_32 value2)
 421 {
 422     return ((value1 > (value2)) ? (value1) : value2);
 423 }
 424
 425 /**
 426 ****************************************************************************************************
 427 *   NextPow2
 428 *
 429 *   @brief
 430 *       Compute the mipmap's next level dim size
 431 ****************************************************************************************************
 432 */
 433 static inline UINT_32 NextPow2(
 434     UINT_32 dim)        ///< [in] dimension of miplevel
 435 {
 436     UINT_32 newDim = 1;
 437
 438     if (dim > 0x7fffffff)
 439     {
 440         ADDR_ASSERT_ALWAYS();
 441         newDim = 0x80000000;
 442     }
 443     else
 444     {
 445         while (newDim < dim)
 446         {
 447             newDim <<= 1;
 448         }
 449     }
 450
 451     return newDim;
 452 }
 453
 454 /**
 455 ****************************************************************************************************
 456 *   Log2NonPow2
 457 *
 458 *   @brief
 459 *       Compute log of base 2 no matter the target is power of 2 or not
 460 ****************************************************************************************************
 461 */
 462 static inline UINT_32 Log2NonPow2(
 463     UINT_32 x)      ///< [in] the value should calculate log based 2
 464 {
 465     UINT_32 y;
 466
 467     y = 0;
 468     while (x > 1)
 469     {
 470         x >>= 1;
 471         y++;
 472     }
 473
 474     return y;
 475 }
 476
 477 /**
 478 ****************************************************************************************************
 479 *   Log2
 480 *
 481 *   @brief
 482 *       Compute log of base 2
 483 ****************************************************************************************************
 484 */
 485 static inline UINT_32 Log2(
 486     UINT_32 x)      ///< [in] the value should calculate log based 2
 487 {
 488     // Assert that x is a power of two.
 489     ADDR_ASSERT(IsPow2(x));
 490
 491     return Log2NonPow2(x);
 492 }
 493
 494 /**
 495 ****************************************************************************************************
 496 *   QLog2
 497 *
 498 *   @brief
 499 *       Compute log of base 2 quickly (<= 16)
 500 ****************************************************************************************************
 501 */
 502 static inline UINT_32 QLog2(
 503     UINT_32 x)      ///< [in] the value should calculate log based 2
 504 {
 505     ADDR_ASSERT(x <= 16);
 506
 507     UINT_32 y = 0;
 508
 509     switch (x)
 510     {
 511         case 1:
 512             y = 0;
 513             break;
 514         case 2:
 515             y = 1;
 516             break;
 517         case 4:
 518             y = 2;
 519             break;
 520         case 8:
 521             y = 3;
 522             break;
 523         case 16:
 524             y = 4;
 525             break;
 526         default:
 527             ADDR_ASSERT_ALWAYS();
 528     }
 529
 530     return y;
 531 }
 532
 533 /**
 534 ****************************************************************************************************
 535 *   SafeAssign
 536 *
 537 *   @brief
 538 *       NULL pointer safe assignment
 539 ****************************************************************************************************
 540 */
 541 static inline VOID SafeAssign(
 542     UINT_32*    pLVal,  ///< [in] Pointer to left val
 543     UINT_32     rVal)   ///< [in] Right value
 544 {
 545     if (pLVal)
 546     {
 547         *pLVal = rVal;
 548     }
 549 }
 550
 551 /**
 552 ****************************************************************************************************
 553 *   SafeAssign
 554 *
 555 *   @brief
 556 *       NULL pointer safe assignment for 64bit values
 557 ****************************************************************************************************
 558 */
 559 static inline VOID SafeAssign(
 560     UINT_64*    pLVal,  ///< [in] Pointer to left val
 561     UINT_64     rVal)   ///< [in] Right value
 562 {
 563     if (pLVal)
 564     {
 565         *pLVal = rVal;
 566     }
 567 }
 568
 569 /**
 570 ****************************************************************************************************
 571 *   SafeAssign
 572 *
 573 *   @brief
 574 *       NULL pointer safe assignment for AddrTileMode
 575 ****************************************************************************************************
 576 */
 577 static inline VOID SafeAssign(
 578     AddrTileMode*    pLVal, ///< [in] Pointer to left val
 579     AddrTileMode     rVal)  ///< [in] Right value
 580 {
 581     if (pLVal)
 582     {
 583         *pLVal = rVal;
 584     }
 585 }
 586
 587 /**
 588 ****************************************************************************************************
 589 *   RoundHalf
 590 *
 591 *   @brief
 592 *       return (x + 1) / 2
 593 ****************************************************************************************************
 594 */
 595 static inline UINT_32 RoundHalf(
 596     UINT_32     x)     ///< [in] input value
 597 {
 598     ADDR_ASSERT(x != 0);
 599
 600 #if 1
 601     return (x >> 1) + (x & 1);
 602 #else
 603     return (x + 1) >> 1;
 604 #endif
 605 }
 606
 607 /**
 608 ****************************************************************************************************
 609 *   SumGeo
 610 *
 611 *   @brief
 612 *       Calculate sum of a geometric progression whose ratio is 1/2
 613 ****************************************************************************************************
 614 */
 615 static inline UINT_32 SumGeo(
 616     UINT_32     base,   ///< [in] First term in the geometric progression
 617     UINT_32     num)    ///< [in] Number of terms to be added into sum
 618 {
 619     ADDR_ASSERT(base > 0);
 620
 621     UINT_32 sum = 0;
 622     UINT_32 i = 0;
 623     for (; (i < num) && (base > 1); i++)
 624     {
 625         sum += base;
 626         base = RoundHalf(base);
 627     }
 628     sum += num - i;
 629
 630     return sum;
 631 }
 632
 633 /**
 634 ****************************************************************************************************
 635 *   GetBit
 636 *
 637 *   @brief
 638 *       Extract bit N value (0 or 1) of a UINT32 value.
 639 ****************************************************************************************************
 640 */
 641 static inline UINT_32 GetBit(
 642     UINT_32     u32,   ///< [in] UINT32 value
 643     UINT_32     pos)   ///< [in] bit position from LSB, valid range is [0..31]
 644 {
 645     ADDR_ASSERT(pos <= 31);
 646
 647     return (u32 >> pos) & 0x1;
 648 }
 649
 650 /**
 651 ****************************************************************************************************
 652 *   GetBits
 653 *
 654 *   @brief
 655 *       Copy 'bitsNum' bits from src start from srcStartPos into destination from dstStartPos
 656 *       srcStartPos: 0~31 for UINT_32
 657 *       bitsNum    : 1~32 for UINT_32
 658 *       srcStartPos: 0~31 for UINT_32
 659 *                                                                 src start position
 660 *                                                                          |
 661 *       src : b[31] b[30] b[29] ... ... ... ... ... ... ... ... b[end]..b[beg] ... b[1] b[0]
 662 *                                   || Bits num || copy length  || Bits num ||
 663 *       dst : b[31] b[30] b[29] ... b[end]..b[beg] ... ... ... ... ... ... ... ... b[1] b[0]
 664 *                                              |
 665 *                                     dst start position
 666 ****************************************************************************************************
 667 */
 668 static inline UINT_32 GetBits(
 669     UINT_32 src,
 670     UINT_32 srcStartPos,
 671     UINT_32 bitsNum,
 672     UINT_32 dstStartPos)
 673 {
 674     ADDR_ASSERT((srcStartPos < 32) && (dstStartPos < 32) && (bitsNum > 0));
 675     ADDR_ASSERT((bitsNum + dstStartPos <= 32) && (bitsNum + srcStartPos <= 32));
 676
 677     return ((src >> srcStartPos) << (32 - bitsNum)) >> (32 - bitsNum - dstStartPos);
 678 }
 679
 680 /**
 681 ****************************************************************************************************
 682 *   MortonGen2d
 683 *
 684 *   @brief
 685 *       Generate 2D Morton interleave code with num lowest bits in each channel
 686 ****************************************************************************************************
 687 */
 688 static inline UINT_32 MortonGen2d(
 689     UINT_32     x,     ///< [in] First channel
 690     UINT_32     y,     ///< [in] Second channel
 691     UINT_32     num)   ///< [in] Number of bits extracted from each channel
 692 {
 693     UINT_32 mort = 0;
 694
 695     for (UINT_32 i = 0; i < num; i++)
 696     {
 697         mort |= (GetBit(y, i) << (2 * i));
 698         mort |= (GetBit(x, i) << (2 * i + 1));
 699     }
 700
 701     return mort;
 702 }
 703
 704 /**
 705 ****************************************************************************************************
 706 *   MortonGen3d
 707 *
 708 *   @brief
 709 *       Generate 3D Morton interleave code with num lowest bits in each channel
 710 ****************************************************************************************************
 711 */
 712 static inline UINT_32 MortonGen3d(
 713     UINT_32     x,     ///< [in] First channel
 714     UINT_32     y,     ///< [in] Second channel
 715     UINT_32     z,     ///< [in] Third channel
 716     UINT_32     num)   ///< [in] Number of bits extracted from each channel
 717 {
 718     UINT_32 mort = 0;
 719
 720     for (UINT_32 i = 0; i < num; i++)
 721     {
 722         mort |= (GetBit(z, i) << (3 * i));
 723         mort |= (GetBit(y, i) << (3 * i + 1));
 724         mort |= (GetBit(x, i) << (3 * i + 2));
 725     }
 726
 727     return mort;
 728 }
 729
 730 /**
 731 ****************************************************************************************************
 732 *   ReverseBitVector
 733 *
 734 *   @brief
 735 *       Return reversed lowest num bits of v: v[0]v[1]...v[num-2]v[num-1]
 736 ****************************************************************************************************
 737 */
 738 static inline UINT_32 ReverseBitVector(
 739     UINT_32     v,     ///< [in] Reverse operation base value
 740     UINT_32     num)   ///< [in] Number of bits used in reverse operation
 741 {
 742     UINT_32 reverse = 0;
 743
 744     for (UINT_32 i = 0; i < num; i++)
 745     {
 746         reverse |= (GetBit(v, num - 1 - i) << i);
 747     }
 748
 749     return reverse;
 750 }
 751
 752 /**
 753 ****************************************************************************************************
 754 *   FoldXor2d
 755 *
 756 *   @brief
 757 *       Xor bit vector v[num-1]v[num-2]...v[1]v[0] with v[num]v[num+1]...v[2*num-2]v[2*num-1]
 758 ****************************************************************************************************
 759 */
 760 static inline UINT_32 FoldXor2d(
 761     UINT_32     v,     ///< [in] Xor operation base value
 762     UINT_32     num)   ///< [in] Number of bits used in fold xor operation
 763 {
 764     return (v & ((1 << num) - 1)) ^ ReverseBitVector(v >> num, num);
 765 }
 766
 767 /**
 768 ****************************************************************************************************
 769 *   DeMort
 770 *
 771 *   @brief
 772 *       Return v[0] | v[2] | v[4] | v[6]... | v[2*num - 2]
 773 ****************************************************************************************************
 774 */
 775 static inline UINT_32 DeMort(
 776     UINT_32     v,     ///< [in] DeMort operation base value
 777     UINT_32     num)   ///< [in] Number of bits used in fold DeMort operation
 778 {
 779     UINT_32 d = 0;
 780
 781     for (UINT_32 i = 0; i < num; i++)
 782     {
 783         d |= ((v & (1 << (i << 1))) >> i);
 784     }
 785
 786     return d;
 787 }
 788
 789 /**
 790 ****************************************************************************************************
 791 *   FoldXor3d
 792 *
 793 *   @brief
 794 *       v[0]...v[num-1] ^ v[3*num-1]v[3*num-3]...v[num+2]v[num] ^ v[3*num-2]...v[num+1]v[num-1]
 795 ****************************************************************************************************
 796 */
 797 static inline UINT_32 FoldXor3d(
 798     UINT_32     v,     ///< [in] Xor operation base value
 799     UINT_32     num)   ///< [in] Number of bits used in fold xor operation
 800 {
 801     UINT_32 t = v & ((1 << num) - 1);
 802     t ^= ReverseBitVector(DeMort(v >> num, num), num);
 803     t ^= ReverseBitVector(DeMort(v >> (num + 1), num), num);
 804
 805     return t;
 806 }
 807
 808 /**
 809 ****************************************************************************************************
 810 *   InitChannel
 811 *
 812 *   @brief
 813 *       Set channel initialization value via a return value
 814 ****************************************************************************************************
 815 */
 816 static inline ADDR_CHANNEL_SETTING InitChannel(
 817     UINT_32     valid,     ///< [in] valid setting
 818     UINT_32     channel,   ///< [in] channel setting
 819     UINT_32     index)     ///< [in] index setting
 820 {
 821     ADDR_CHANNEL_SETTING t;
 822     t.valid = valid;
 823     t.channel = channel;
 824     t.index = index;
 825
 826     return t;
 827 }
 828
 829 /**
 830 ****************************************************************************************************
 831 *   InitChannel
 832 *
 833 *   @brief
 834 *       Set channel initialization value via channel pointer
 835 ****************************************************************************************************
 836 */
 837 static inline VOID InitChannel(
 838     UINT_32     valid,              ///< [in] valid setting
 839     UINT_32     channel,            ///< [in] channel setting
 840     UINT_32     index,              ///< [in] index setting
 841     ADDR_CHANNEL_SETTING *pChanSet) ///< [out] channel setting to be initialized
 842 {
 843     pChanSet->valid = valid;
 844     pChanSet->channel = channel;
 845     pChanSet->index = index;
 846 }
 847
 848
 849 /**
 850 ****************************************************************************************************
 851 *   InitChannel
 852 *
 853 *   @brief
 854 *       Set channel initialization value via another channel
 855 ****************************************************************************************************
 856 */
 857 static inline VOID InitChannel(
 858     ADDR_CHANNEL_SETTING *pChanDst, ///< [in] channel setting to be copied from
 859     ADDR_CHANNEL_SETTING *pChanSrc) ///< [out] channel setting to be initialized
 860 {
 861     pChanDst->valid = pChanSrc->valid;
 862     pChanDst->channel = pChanSrc->channel;
 863     pChanDst->index = pChanSrc->index;
 864 }
 865
 866 /**
 867 ****************************************************************************************************
 868 *   GetMaxValidChannelIndex
 869 *
 870 *   @brief
 871 *       Get max valid index for a specific channel
 872 ****************************************************************************************************
 873 */
 874 static inline UINT_32 GetMaxValidChannelIndex(
 875     const ADDR_CHANNEL_SETTING *pChanSet,   ///< [in] channel setting to be initialized
 876     UINT_32                     searchCount,///< [in] number of channel setting to be searched
 877     UINT_32                     channel)    ///< [in] channel to be searched
 878 {
 879     UINT_32 index = 0;
 880
 881     for (UINT_32 i = 0; i < searchCount; i++)
 882     {
 883         if (pChanSet[i].valid && (pChanSet[i].channel == channel))
 884         {
 885             index = Max(index, static_cast<UINT_32>(pChanSet[i].index));
 886         }
 887     }
 888
 889     return index;
 890 }
 891
 892 /**
 893 ****************************************************************************************************
 894 *   GetCoordActiveMask
 895 *
 896 *   @brief
 897 *       Get bit mask which indicates which positions in the equation match the target coord
 898 ****************************************************************************************************
 899 */
 900 static inline UINT_32 GetCoordActiveMask(
 901     const ADDR_CHANNEL_SETTING *pChanSet,   ///< [in] channel setting to be initialized
 902     UINT_32                     searchCount,///< [in] number of channel setting to be searched
 903     UINT_32                     channel,    ///< [in] channel to be searched
 904     UINT_32                     index)      ///< [in] index to be searched
 905 {
 906     UINT_32 mask = 0;
 907
 908     for (UINT_32 i = 0; i < searchCount; i++)
 909     {
 910         if ((pChanSet[i].valid   == TRUE)    &&
 911             (pChanSet[i].channel == channel) &&
 912             (pChanSet[i].index   == index))
 913         {
 914             mask |= (1 << i);
 915         }
 916     }
 917
 918     return mask;
 919 }
 920
 921 } // Addr
 922
 923 #endif // __ADDR_COMMON_H__
 924