amd: remove always-true BRAHMA_BUILD define
[mesa.git] / 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