2 * Copyright © 2014 Advanced Micro Devices, Inc.
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:
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.
22 * The above copyright notice and this permission notice (including the
23 * next paragraph) shall be included in all copies or substantial portions
28 ****************************************************************************************************
29 * @file addrinterface.cpp
30 * @brief Contains the addrlib interface functions
31 ****************************************************************************************************
33 #include "addrinterface.h"
37 #include "addrcommon.h"
41 ////////////////////////////////////////////////////////////////////////////////////////////////////
42 // Create/Destroy/Config functions
43 ////////////////////////////////////////////////////////////////////////////////////////////////////
46 ****************************************************************************************************
50 * Create address lib object
53 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
54 ****************************************************************************************************
56 ADDR_E_RETURNCODE ADDR_API
AddrCreate(
57 const ADDR_CREATE_INPUT
* pAddrCreateIn
, ///< [in] infomation for creating address lib object
58 ADDR_CREATE_OUTPUT
* pAddrCreateOut
) ///< [out] address lib handle
60 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
62 returnCode
= Lib::Create(pAddrCreateIn
, pAddrCreateOut
);
70 ****************************************************************************************************
74 * Destroy address lib object
77 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
78 ****************************************************************************************************
80 ADDR_E_RETURNCODE ADDR_API
AddrDestroy(
81 ADDR_HANDLE hLib
) ///< address lib handle
83 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
87 Lib
* pLib
= Lib::GetLib(hLib
);
92 returnCode
= ADDR_ERROR
;
100 ////////////////////////////////////////////////////////////////////////////////////////////////////
102 ////////////////////////////////////////////////////////////////////////////////////////////////////
105 ****************************************************************************************************
106 * AddrComputeSurfaceInfo
109 * Calculate surface width/height/depth/alignments and suitable tiling mode
112 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
113 ****************************************************************************************************
115 ADDR_E_RETURNCODE ADDR_API
AddrComputeSurfaceInfo(
116 ADDR_HANDLE hLib
, ///< address lib handle
117 const ADDR_COMPUTE_SURFACE_INFO_INPUT
* pIn
, ///< [in] surface information
118 ADDR_COMPUTE_SURFACE_INFO_OUTPUT
* pOut
) ///< [out] surface parameters and alignments
120 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
122 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
126 returnCode
= pLib
->ComputeSurfaceInfo(pIn
, pOut
);
130 returnCode
= ADDR_ERROR
;
139 ****************************************************************************************************
140 * AddrComputeSurfaceAddrFromCoord
143 * Compute surface address according to coordinates
146 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
147 ****************************************************************************************************
149 ADDR_E_RETURNCODE ADDR_API
AddrComputeSurfaceAddrFromCoord(
150 ADDR_HANDLE hLib
, ///< address lib handle
151 const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] surface info and coordinates
152 ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] surface address
154 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
156 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
160 returnCode
= pLib
->ComputeSurfaceAddrFromCoord(pIn
, pOut
);
164 returnCode
= ADDR_ERROR
;
171 ****************************************************************************************************
172 * AddrComputeSurfaceCoordFromAddr
175 * Compute coordinates according to surface address
178 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
179 ****************************************************************************************************
181 ADDR_E_RETURNCODE ADDR_API
AddrComputeSurfaceCoordFromAddr(
182 ADDR_HANDLE hLib
, ///< address lib handle
183 const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
* pIn
, ///< [in] surface info and address
184 ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] coordinates
186 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
188 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
192 returnCode
= pLib
->ComputeSurfaceCoordFromAddr(pIn
, pOut
);
196 returnCode
= ADDR_ERROR
;
204 ////////////////////////////////////////////////////////////////////////////////////////////////////
206 ////////////////////////////////////////////////////////////////////////////////////////////////////
209 ****************************************************************************************************
210 * AddrComputeHtileInfo
213 * Compute Htile pitch, height, base alignment and size in bytes
216 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
217 ****************************************************************************************************
219 ADDR_E_RETURNCODE ADDR_API
AddrComputeHtileInfo(
220 ADDR_HANDLE hLib
, ///< address lib handle
221 const ADDR_COMPUTE_HTILE_INFO_INPUT
* pIn
, ///< [in] Htile information
222 ADDR_COMPUTE_HTILE_INFO_OUTPUT
* pOut
) ///< [out] Htile pitch, height and size in bytes
224 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
226 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
230 returnCode
= pLib
->ComputeHtileInfo(pIn
, pOut
);
234 returnCode
= ADDR_ERROR
;
241 ****************************************************************************************************
242 * AddrComputeHtileAddrFromCoord
245 * Compute Htile address according to coordinates (of depth buffer)
248 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
249 ****************************************************************************************************
251 ADDR_E_RETURNCODE ADDR_API
AddrComputeHtileAddrFromCoord(
252 ADDR_HANDLE hLib
, ///< address lib handle
253 const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Htile info and coordinates
254 ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Htile address
256 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
258 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
262 returnCode
= pLib
->ComputeHtileAddrFromCoord(pIn
, pOut
);
266 returnCode
= ADDR_ERROR
;
273 ****************************************************************************************************
274 * AddrComputeHtileCoordFromAddr
277 * Compute coordinates within depth buffer (1st pixel of a micro tile) according to
281 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
282 ****************************************************************************************************
284 ADDR_E_RETURNCODE ADDR_API
AddrComputeHtileCoordFromAddr(
285 ADDR_HANDLE hLib
, ///< address lib handle
286 const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
* pIn
, ///< [in] Htile info and address
287 ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Htile coordinates
289 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
291 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
295 returnCode
= pLib
->ComputeHtileCoordFromAddr(pIn
, pOut
);
299 returnCode
= ADDR_ERROR
;
307 ////////////////////////////////////////////////////////////////////////////////////////////////////
309 ////////////////////////////////////////////////////////////////////////////////////////////////////
312 ****************************************************************************************************
313 * AddrComputeCmaskInfo
316 * Compute Cmask pitch, height, base alignment and size in bytes from color buffer
320 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
321 ****************************************************************************************************
323 ADDR_E_RETURNCODE ADDR_API
AddrComputeCmaskInfo(
324 ADDR_HANDLE hLib
, ///< address lib handle
325 const ADDR_COMPUTE_CMASK_INFO_INPUT
* pIn
, ///< [in] Cmask pitch and height
326 ADDR_COMPUTE_CMASK_INFO_OUTPUT
* pOut
) ///< [out] Cmask pitch, height and size in bytes
328 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
330 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
334 returnCode
= pLib
->ComputeCmaskInfo(pIn
, pOut
);
338 returnCode
= ADDR_ERROR
;
345 ****************************************************************************************************
346 * AddrComputeCmaskAddrFromCoord
349 * Compute Cmask address according to coordinates (of MSAA color buffer)
352 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
353 ****************************************************************************************************
355 ADDR_E_RETURNCODE ADDR_API
AddrComputeCmaskAddrFromCoord(
356 ADDR_HANDLE hLib
, ///< address lib handle
357 const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Cmask info and coordinates
358 ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Cmask address
360 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
362 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
366 returnCode
= pLib
->ComputeCmaskAddrFromCoord(pIn
, pOut
);
370 returnCode
= ADDR_ERROR
;
377 ****************************************************************************************************
378 * AddrComputeCmaskCoordFromAddr
381 * Compute coordinates within color buffer (1st pixel of a micro tile) according to
385 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
386 ****************************************************************************************************
388 ADDR_E_RETURNCODE ADDR_API
AddrComputeCmaskCoordFromAddr(
389 ADDR_HANDLE hLib
, ///< address lib handle
390 const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
* pIn
, ///< [in] Cmask info and address
391 ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Cmask coordinates
393 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
395 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
399 returnCode
= pLib
->ComputeCmaskCoordFromAddr(pIn
, pOut
);
403 returnCode
= ADDR_ERROR
;
411 ////////////////////////////////////////////////////////////////////////////////////////////////////
413 ////////////////////////////////////////////////////////////////////////////////////////////////////
416 ****************************************************************************************************
417 * AddrComputeFmaskInfo
420 * Compute Fmask pitch/height/depth/alignments and size in bytes
423 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
424 ****************************************************************************************************
426 ADDR_E_RETURNCODE ADDR_API
AddrComputeFmaskInfo(
427 ADDR_HANDLE hLib
, ///< address lib handle
428 const ADDR_COMPUTE_FMASK_INFO_INPUT
* pIn
, ///< [in] Fmask information
429 ADDR_COMPUTE_FMASK_INFO_OUTPUT
* pOut
) ///< [out] Fmask pitch and height
431 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
433 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
437 returnCode
= pLib
->ComputeFmaskInfo(pIn
, pOut
);
441 returnCode
= ADDR_ERROR
;
448 ****************************************************************************************************
449 * AddrComputeFmaskAddrFromCoord
452 * Compute Fmask address according to coordinates (x,y,slice,sample,plane)
455 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
456 ****************************************************************************************************
458 ADDR_E_RETURNCODE ADDR_API
AddrComputeFmaskAddrFromCoord(
459 ADDR_HANDLE hLib
, ///< address lib handle
460 const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Fmask info and coordinates
461 ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Fmask address
463 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
465 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
469 returnCode
= pLib
->ComputeFmaskAddrFromCoord(pIn
, pOut
);
473 returnCode
= ADDR_ERROR
;
480 ****************************************************************************************************
481 * AddrComputeFmaskCoordFromAddr
484 * Compute coordinates (x,y,slice,sample,plane) according to Fmask address
487 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
488 ****************************************************************************************************
490 ADDR_E_RETURNCODE ADDR_API
AddrComputeFmaskCoordFromAddr(
491 ADDR_HANDLE hLib
, ///< address lib handle
492 const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
* pIn
, ///< [in] Fmask info and address
493 ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Fmask coordinates
495 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
497 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
501 returnCode
= pLib
->ComputeFmaskCoordFromAddr(pIn
, pOut
);
505 returnCode
= ADDR_ERROR
;
513 ////////////////////////////////////////////////////////////////////////////////////////////////////
515 ////////////////////////////////////////////////////////////////////////////////////////////////////
518 ****************************************************************************************************
522 * Compute DCC key size, base alignment based on color surface size, tile info or tile index
524 ****************************************************************************************************
526 ADDR_E_RETURNCODE ADDR_API
AddrComputeDccInfo(
527 ADDR_HANDLE hLib
, ///< handle of addrlib
528 const ADDR_COMPUTE_DCCINFO_INPUT
* pIn
, ///< [in] input
529 ADDR_COMPUTE_DCCINFO_OUTPUT
* pOut
) ///< [out] output
531 ADDR_E_RETURNCODE returnCode
;
533 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
537 returnCode
= pLib
->ComputeDccInfo(pIn
, pOut
);
541 returnCode
= ADDR_ERROR
;
549 ///////////////////////////////////////////////////////////////////////////////
550 // Below functions are element related or helper functions
551 ///////////////////////////////////////////////////////////////////////////////
554 ****************************************************************************************************
558 * Get AddrLib version number. Client may check this return value against ADDRLIB_VERSION
559 * defined in addrinterface.h to see if there is a mismatch.
560 ****************************************************************************************************
562 UINT_32 ADDR_API
AddrGetVersion(ADDR_HANDLE hLib
)
566 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
568 ADDR_ASSERT(pLib
!= NULL
);
572 version
= pLib
->GetVersion();
579 ****************************************************************************************************
583 * Return TRUE if tileIndex is enabled in this address library
584 ****************************************************************************************************
586 BOOL_32 ADDR_API
AddrUseTileIndex(ADDR_HANDLE hLib
)
588 BOOL_32 useTileIndex
= FALSE
;
590 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
592 ADDR_ASSERT(pLib
!= NULL
);
596 useTileIndex
= pLib
->UseTileIndex(0);
603 ****************************************************************************************************
604 * AddrUseCombinedSwizzle
607 * Return TRUE if combined swizzle is enabled in this address library
608 ****************************************************************************************************
610 BOOL_32 ADDR_API
AddrUseCombinedSwizzle(ADDR_HANDLE hLib
)
612 BOOL_32 useCombinedSwizzle
= FALSE
;
614 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
616 ADDR_ASSERT(pLib
!= NULL
);
620 useCombinedSwizzle
= pLib
->UseCombinedSwizzle();
623 return useCombinedSwizzle
;
627 ****************************************************************************************************
628 * AddrExtractBankPipeSwizzle
631 * Extract Bank and Pipe swizzle from base256b
633 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
634 ****************************************************************************************************
636 ADDR_E_RETURNCODE ADDR_API
AddrExtractBankPipeSwizzle(
637 ADDR_HANDLE hLib
, ///< addrlib handle
638 const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
* pIn
, ///< [in] input structure
639 ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
* pOut
) ///< [out] output structure
641 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
643 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
647 returnCode
= pLib
->ExtractBankPipeSwizzle(pIn
, pOut
);
651 returnCode
= ADDR_ERROR
;
658 ****************************************************************************************************
659 * AddrCombineBankPipeSwizzle
662 * Combine Bank and Pipe swizzle
665 ****************************************************************************************************
667 ADDR_E_RETURNCODE ADDR_API
AddrCombineBankPipeSwizzle(
669 const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
* pIn
,
670 ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
* pOut
)
672 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
674 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
678 returnCode
= pLib
->CombineBankPipeSwizzle(pIn
, pOut
);
682 returnCode
= ADDR_ERROR
;
689 ****************************************************************************************************
690 * AddrComputeSliceSwizzle
693 * Compute a swizzle for slice from a base swizzle
695 * ADDR_OK if no error
696 ****************************************************************************************************
698 ADDR_E_RETURNCODE ADDR_API
AddrComputeSliceSwizzle(
700 const ADDR_COMPUTE_SLICESWIZZLE_INPUT
* pIn
,
701 ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
* pOut
)
703 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
705 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
709 returnCode
= pLib
->ComputeSliceTileSwizzle(pIn
, pOut
);
713 returnCode
= ADDR_ERROR
;
720 ****************************************************************************************************
721 * AddrComputeBaseSwizzle
724 * Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
726 * ADDR_OK if no error
727 ****************************************************************************************************
729 ADDR_E_RETURNCODE ADDR_API
AddrComputeBaseSwizzle(
731 const ADDR_COMPUTE_BASE_SWIZZLE_INPUT
* pIn
,
732 ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
* pOut
)
734 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
736 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
740 returnCode
= pLib
->ComputeBaseSwizzle(pIn
, pOut
);
744 returnCode
= ADDR_ERROR
;
751 ****************************************************************************************************
752 * ElemFlt32ToDepthPixel
755 * Convert a FLT_32 value to a depth/stencil pixel value
758 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
760 ****************************************************************************************************
762 ADDR_E_RETURNCODE ADDR_API
ElemFlt32ToDepthPixel(
763 ADDR_HANDLE hLib
, ///< addrlib handle
764 const ELEM_FLT32TODEPTHPIXEL_INPUT
* pIn
, ///< [in] per-component value
765 ELEM_FLT32TODEPTHPIXEL_OUTPUT
* pOut
) ///< [out] final pixel value
767 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
769 Lib
* pLib
= Lib::GetLib(hLib
);
773 pLib
->Flt32ToDepthPixel(pIn
, pOut
);
777 returnCode
= ADDR_ERROR
;
784 ****************************************************************************************************
785 * ElemFlt32ToColorPixel
788 * Convert a FLT_32 value to a red/green/blue/alpha pixel value
791 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
793 ****************************************************************************************************
795 ADDR_E_RETURNCODE ADDR_API
ElemFlt32ToColorPixel(
796 ADDR_HANDLE hLib
, ///< addrlib handle
797 const ELEM_FLT32TOCOLORPIXEL_INPUT
* pIn
, ///< [in] format, surface number and swap value
798 ELEM_FLT32TOCOLORPIXEL_OUTPUT
* pOut
) ///< [out] final pixel value
800 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
802 Lib
* pLib
= Lib::GetLib(hLib
);
806 pLib
->Flt32ToColorPixel(pIn
, pOut
);
810 returnCode
= ADDR_ERROR
;
817 ****************************************************************************************************
821 * Helper function to check one format can be EXPORT_NUM,
822 * which is a register CB_COLOR_INFO.SURFACE_FORMAT.
823 * FP16 can be reported as EXPORT_NORM for rv770 in r600
826 ****************************************************************************************************
828 BOOL_32 ADDR_API
ElemGetExportNorm(
829 ADDR_HANDLE hLib
, ///< addrlib handle
830 const ELEM_GETEXPORTNORM_INPUT
* pIn
) ///< [in] input structure
832 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
833 BOOL_32 enabled
= FALSE
;
835 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
839 enabled
= pLib
->GetExportNorm(pIn
);
843 returnCode
= ADDR_ERROR
;
846 ADDR_ASSERT(returnCode
== ADDR_OK
);
852 ****************************************************************************************************
853 * AddrConvertTileInfoToHW
856 * Convert tile info from real value to hardware register value
859 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
860 ****************************************************************************************************
862 ADDR_E_RETURNCODE ADDR_API
AddrConvertTileInfoToHW(
863 ADDR_HANDLE hLib
, ///< address lib handle
864 const ADDR_CONVERT_TILEINFOTOHW_INPUT
* pIn
, ///< [in] tile info with real value
865 ADDR_CONVERT_TILEINFOTOHW_OUTPUT
* pOut
) ///< [out] tile info with HW register value
867 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
869 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
873 returnCode
= pLib
->ConvertTileInfoToHW(pIn
, pOut
);
877 returnCode
= ADDR_ERROR
;
884 ****************************************************************************************************
885 * AddrConvertTileIndex
888 * Convert tile index to tile mode/type/info
891 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
892 ****************************************************************************************************
894 ADDR_E_RETURNCODE ADDR_API
AddrConvertTileIndex(
895 ADDR_HANDLE hLib
, ///< address lib handle
896 const ADDR_CONVERT_TILEINDEX_INPUT
* pIn
, ///< [in] input - tile index
897 ADDR_CONVERT_TILEINDEX_OUTPUT
* pOut
) ///< [out] tile mode/type/info
899 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
901 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
905 returnCode
= pLib
->ConvertTileIndex(pIn
, pOut
);
909 returnCode
= ADDR_ERROR
;
916 ****************************************************************************************************
917 * AddrGetMacroModeIndex
920 * Get macro mode index based on input parameters
923 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
924 ****************************************************************************************************
926 ADDR_E_RETURNCODE ADDR_API
AddrGetMacroModeIndex(
927 ADDR_HANDLE hLib
, ///< address lib handle
928 const ADDR_GET_MACROMODEINDEX_INPUT
* pIn
, ///< [in] input
929 ADDR_GET_MACROMODEINDEX_OUTPUT
* pOut
) ///< [out] macro mode index
931 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
933 ADDR_E_RETURNCODE returnCode
;
937 returnCode
= pLib
->GetMacroModeIndex(pIn
, pOut
);
941 returnCode
= ADDR_ERROR
;
948 ****************************************************************************************************
949 * AddrConvertTileIndex1
952 * Convert tile index to tile mode/type/info
955 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
956 ****************************************************************************************************
958 ADDR_E_RETURNCODE ADDR_API
AddrConvertTileIndex1(
959 ADDR_HANDLE hLib
, ///< address lib handle
960 const ADDR_CONVERT_TILEINDEX1_INPUT
* pIn
, ///< [in] input - tile index
961 ADDR_CONVERT_TILEINDEX_OUTPUT
* pOut
) ///< [out] tile mode/type/info
963 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
965 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
969 returnCode
= pLib
->ConvertTileIndex1(pIn
, pOut
);
973 returnCode
= ADDR_ERROR
;
980 ****************************************************************************************************
984 * Get tile index from tile mode/type/info
987 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
990 * Only meaningful for SI (and above)
991 ****************************************************************************************************
993 ADDR_E_RETURNCODE ADDR_API
AddrGetTileIndex(
995 const ADDR_GET_TILEINDEX_INPUT
* pIn
,
996 ADDR_GET_TILEINDEX_OUTPUT
* pOut
)
998 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
1000 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1004 returnCode
= pLib
->GetTileIndex(pIn
, pOut
);
1008 returnCode
= ADDR_ERROR
;
1015 ****************************************************************************************************
1016 * AddrComputePrtInfo
1019 * Interface function for ComputePrtInfo
1021 ****************************************************************************************************
1023 ADDR_E_RETURNCODE ADDR_API
AddrComputePrtInfo(
1025 const ADDR_PRT_INFO_INPUT
* pIn
,
1026 ADDR_PRT_INFO_OUTPUT
* pOut
)
1028 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1030 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
1034 returnCode
= pLib
->ComputePrtInfo(pIn
, pOut
);
1038 returnCode
= ADDR_ERROR
;
1045 ****************************************************************************************************
1046 * AddrGetMaxAlignments
1049 * Convert maximum alignments
1052 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1053 ****************************************************************************************************
1055 ADDR_E_RETURNCODE ADDR_API
AddrGetMaxAlignments(
1056 ADDR_HANDLE hLib
, ///< address lib handle
1057 ADDR_GET_MAX_ALIGNMENTS_OUTPUT
* pOut
) ///< [out] output structure
1059 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
1061 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1065 returnCode
= pLib
->GetMaxAlignments(pOut
);
1069 returnCode
= ADDR_ERROR
;
1077 ////////////////////////////////////////////////////////////////////////////////////////////////////
1078 // Surface functions for Addr2
1079 ////////////////////////////////////////////////////////////////////////////////////////////////////
1082 ****************************************************************************************************
1083 * Addr2ComputeSurfaceInfo
1086 * Calculate surface width/height/depth/alignments and suitable tiling mode
1089 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1090 ****************************************************************************************************
1092 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSurfaceInfo(
1093 ADDR_HANDLE hLib
, ///< address lib handle
1094 const ADDR2_COMPUTE_SURFACE_INFO_INPUT
* pIn
, ///< [in] surface information
1095 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT
* pOut
) ///< [out] surface parameters and alignments
1097 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1099 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1103 returnCode
= pLib
->ComputeSurfaceInfo(pIn
, pOut
);
1107 returnCode
= ADDR_ERROR
;
1115 ****************************************************************************************************
1116 * Addr2ComputeSurfaceAddrFromCoord
1119 * Compute surface address according to coordinates
1122 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1123 ****************************************************************************************************
1125 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSurfaceAddrFromCoord(
1126 ADDR_HANDLE hLib
, ///< address lib handle
1127 const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] surface info and coordinates
1128 ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] surface address
1130 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1132 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1136 returnCode
= pLib
->ComputeSurfaceAddrFromCoord(pIn
, pOut
);
1140 returnCode
= ADDR_ERROR
;
1148 ****************************************************************************************************
1149 * Addr2ComputeSurfaceCoordFromAddr
1152 * Compute coordinates according to surface address
1155 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1156 ****************************************************************************************************
1158 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSurfaceCoordFromAddr(
1159 ADDR_HANDLE hLib
, ///< address lib handle
1160 const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT
* pIn
, ///< [in] surface info and address
1161 ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] coordinates
1163 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1165 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1169 returnCode
= pLib
->ComputeSurfaceCoordFromAddr(pIn
, pOut
);
1173 returnCode
= ADDR_ERROR
;
1181 ////////////////////////////////////////////////////////////////////////////////////////////////////
1182 // HTile functions for Addr2
1183 ////////////////////////////////////////////////////////////////////////////////////////////////////
1186 ****************************************************************************************************
1187 * Addr2ComputeHtileInfo
1190 * Compute Htile pitch, height, base alignment and size in bytes
1193 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1194 ****************************************************************************************************
1196 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeHtileInfo(
1197 ADDR_HANDLE hLib
, ///< address lib handle
1198 const ADDR2_COMPUTE_HTILE_INFO_INPUT
* pIn
, ///< [in] Htile information
1199 ADDR2_COMPUTE_HTILE_INFO_OUTPUT
* pOut
) ///< [out] Htile pitch, height and size in bytes
1201 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1203 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1207 returnCode
= pLib
->ComputeHtileInfo(pIn
, pOut
);
1211 returnCode
= ADDR_ERROR
;
1219 ****************************************************************************************************
1220 * Addr2ComputeHtileAddrFromCoord
1223 * Compute Htile address according to coordinates (of depth buffer)
1226 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1227 ****************************************************************************************************
1229 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeHtileAddrFromCoord(
1230 ADDR_HANDLE hLib
, ///< address lib handle
1231 const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Htile info and coordinates
1232 ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Htile address
1234 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1236 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1240 returnCode
= pLib
->ComputeHtileAddrFromCoord(pIn
, pOut
);
1244 returnCode
= ADDR_ERROR
;
1252 ****************************************************************************************************
1253 * Addr2ComputeHtileCoordFromAddr
1256 * Compute coordinates within depth buffer (1st pixel of a micro tile) according to
1260 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1261 ****************************************************************************************************
1263 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeHtileCoordFromAddr(
1264 ADDR_HANDLE hLib
, ///< address lib handle
1265 const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT
* pIn
, ///< [in] Htile info and address
1266 ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Htile coordinates
1268 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1270 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1274 returnCode
= pLib
->ComputeHtileCoordFromAddr(pIn
, pOut
);
1278 returnCode
= ADDR_ERROR
;
1286 ////////////////////////////////////////////////////////////////////////////////////////////////////
1287 // C-mask functions for Addr2
1288 ////////////////////////////////////////////////////////////////////////////////////////////////////
1291 ****************************************************************************************************
1292 * Addr2ComputeCmaskInfo
1295 * Compute Cmask pitch, height, base alignment and size in bytes from color buffer
1299 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1300 ****************************************************************************************************
1302 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeCmaskInfo(
1303 ADDR_HANDLE hLib
, ///< address lib handle
1304 const ADDR2_COMPUTE_CMASK_INFO_INPUT
* pIn
, ///< [in] Cmask pitch and height
1305 ADDR2_COMPUTE_CMASK_INFO_OUTPUT
* pOut
) ///< [out] Cmask pitch, height and size in bytes
1307 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1309 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1313 returnCode
= pLib
->ComputeCmaskInfo(pIn
, pOut
);
1317 returnCode
= ADDR_ERROR
;
1325 ****************************************************************************************************
1326 * Addr2ComputeCmaskAddrFromCoord
1329 * Compute Cmask address according to coordinates (of MSAA color buffer)
1332 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1333 ****************************************************************************************************
1335 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeCmaskAddrFromCoord(
1336 ADDR_HANDLE hLib
, ///< address lib handle
1337 const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Cmask info and coordinates
1338 ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Cmask address
1340 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1342 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1346 returnCode
= pLib
->ComputeCmaskAddrFromCoord(pIn
, pOut
);
1350 returnCode
= ADDR_ERROR
;
1358 ****************************************************************************************************
1359 * Addr2ComputeCmaskCoordFromAddr
1362 * Compute coordinates within color buffer (1st pixel of a micro tile) according to
1366 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1367 ****************************************************************************************************
1369 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeCmaskCoordFromAddr(
1370 ADDR_HANDLE hLib
, ///< address lib handle
1371 const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT
* pIn
, ///< [in] Cmask info and address
1372 ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Cmask coordinates
1374 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1376 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1380 returnCode
= pLib
->ComputeCmaskCoordFromAddr(pIn
, pOut
);
1384 returnCode
= ADDR_ERROR
;
1392 ////////////////////////////////////////////////////////////////////////////////////////////////////
1393 // F-mask functions for Addr2
1394 ////////////////////////////////////////////////////////////////////////////////////////////////////
1397 ****************************************************************************************************
1398 * Addr2ComputeFmaskInfo
1401 * Compute Fmask pitch/height/depth/alignments and size in bytes
1404 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1405 ****************************************************************************************************
1407 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeFmaskInfo(
1408 ADDR_HANDLE hLib
, ///< address lib handle
1409 const ADDR2_COMPUTE_FMASK_INFO_INPUT
* pIn
, ///< [in] Fmask information
1410 ADDR2_COMPUTE_FMASK_INFO_OUTPUT
* pOut
) ///< [out] Fmask pitch and height
1412 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1414 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1418 returnCode
= pLib
->ComputeFmaskInfo(pIn
, pOut
);
1422 returnCode
= ADDR_ERROR
;
1430 ****************************************************************************************************
1431 * Addr2ComputeFmaskAddrFromCoord
1434 * Compute Fmask address according to coordinates (x,y,slice,sample,plane)
1437 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1438 ****************************************************************************************************
1440 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeFmaskAddrFromCoord(
1441 ADDR_HANDLE hLib
, ///< address lib handle
1442 const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Fmask info and coordinates
1443 ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Fmask address
1445 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1447 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1451 returnCode
= pLib
->ComputeFmaskAddrFromCoord(pIn
, pOut
);
1455 returnCode
= ADDR_ERROR
;
1463 ****************************************************************************************************
1464 * Addr2ComputeFmaskCoordFromAddr
1467 * Compute coordinates (x,y,slice,sample,plane) according to Fmask address
1470 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1471 ****************************************************************************************************
1473 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeFmaskCoordFromAddr(
1474 ADDR_HANDLE hLib
, ///< address lib handle
1475 const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT
* pIn
, ///< [in] Fmask info and address
1476 ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Fmask coordinates
1478 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1480 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1484 returnCode
= pLib
->ComputeFmaskCoordFromAddr(pIn
, pOut
);
1488 returnCode
= ADDR_ERROR
;
1496 ////////////////////////////////////////////////////////////////////////////////////////////////////
1497 // DCC key functions for Addr2
1498 ////////////////////////////////////////////////////////////////////////////////////////////////////
1501 ****************************************************************************************************
1502 * Addr2ComputeDccInfo
1505 * Compute DCC key size, base alignment based on color surface size, tile info or tile index
1507 ****************************************************************************************************
1509 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeDccInfo(
1510 ADDR_HANDLE hLib
, ///< handle of addrlib
1511 const ADDR2_COMPUTE_DCCINFO_INPUT
* pIn
, ///< [in] input
1512 ADDR2_COMPUTE_DCCINFO_OUTPUT
* pOut
) ///< [out] output
1514 ADDR_E_RETURNCODE returnCode
;
1516 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1520 returnCode
= pLib
->ComputeDccInfo(pIn
, pOut
);
1524 returnCode
= ADDR_ERROR
;
1531 ****************************************************************************************************
1532 * Addr2ComputeDccAddrFromCoord
1535 * Compute DCC key address according to coordinates
1538 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1539 ****************************************************************************************************
1541 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeDccAddrFromCoord(
1542 ADDR_HANDLE hLib
, ///< address lib handle
1543 const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Dcc info and coordinates
1544 ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Dcc address
1546 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1548 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1552 returnCode
= pLib
->ComputeDccAddrFromCoord(pIn
, pOut
);
1556 returnCode
= ADDR_ERROR
;
1563 ****************************************************************************************************
1564 * Addr2ComputePipeBankXor
1567 * Calculate a valid bank pipe xor value for client to use.
1568 ****************************************************************************************************
1570 ADDR_E_RETURNCODE ADDR_API
Addr2ComputePipeBankXor(
1571 ADDR_HANDLE hLib
, ///< handle of addrlib
1572 const ADDR2_COMPUTE_PIPEBANKXOR_INPUT
* pIn
, ///< [in] input
1573 ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT
* pOut
) ///< [out] output
1575 ADDR_E_RETURNCODE returnCode
;
1577 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1581 returnCode
= pLib
->ComputePipeBankXor(pIn
, pOut
);
1585 returnCode
= ADDR_ERROR
;
1592 ****************************************************************************************************
1593 * Addr2ComputeSlicePipeBankXor
1596 * Calculate slice pipe bank xor value based on base pipe bank xor and slice id.
1597 ****************************************************************************************************
1599 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSlicePipeBankXor(
1600 ADDR_HANDLE hLib
, ///< handle of addrlib
1601 const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT
* pIn
, ///< [in] input
1602 ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT
* pOut
) ///< [out] output
1604 ADDR_E_RETURNCODE returnCode
;
1606 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1610 returnCode
= pLib
->ComputeSlicePipeBankXor(pIn
, pOut
);
1614 returnCode
= ADDR_ERROR
;
1621 ****************************************************************************************************
1622 * Addr2ComputeSubResourceOffsetForSwizzlePattern
1625 * Calculate sub resource offset for swizzle pattern.
1626 ****************************************************************************************************
1628 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSubResourceOffsetForSwizzlePattern(
1629 ADDR_HANDLE hLib
, ///< handle of addrlib
1630 const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT
* pIn
, ///< [in] input
1631 ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT
* pOut
) ///< [out] output
1633 ADDR_E_RETURNCODE returnCode
;
1635 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1639 returnCode
= pLib
->ComputeSubResourceOffsetForSwizzlePattern(pIn
, pOut
);
1643 returnCode
= ADDR_ERROR
;
1650 ****************************************************************************************************
1651 * Addr2GetPreferredSurfaceSetting
1654 * Suggest a preferred setting for client driver to program HW register
1655 ****************************************************************************************************
1657 ADDR_E_RETURNCODE ADDR_API
Addr2GetPreferredSurfaceSetting(
1658 ADDR_HANDLE hLib
, ///< handle of addrlib
1659 const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT
* pIn
, ///< [in] input
1660 ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT
* pOut
) ///< [out] output
1662 ADDR_E_RETURNCODE returnCode
;
1664 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1668 returnCode
= pLib
->Addr2GetPreferredSurfaceSetting(pIn
, pOut
);
1672 returnCode
= ADDR_ERROR
;