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"
36 #include "addrcommon.h"
40 ////////////////////////////////////////////////////////////////////////////////////////////////////
41 // Create/Destroy/Config functions
42 ////////////////////////////////////////////////////////////////////////////////////////////////////
45 ****************************************************************************************************
49 * Create address lib object
52 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
53 ****************************************************************************************************
55 ADDR_E_RETURNCODE ADDR_API
AddrCreate(
56 const ADDR_CREATE_INPUT
* pAddrCreateIn
, ///< [in] infomation for creating address lib object
57 ADDR_CREATE_OUTPUT
* pAddrCreateOut
) ///< [out] address lib handle
59 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
61 returnCode
= Lib::Create(pAddrCreateIn
, pAddrCreateOut
);
69 ****************************************************************************************************
73 * Destroy address lib object
76 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
77 ****************************************************************************************************
79 ADDR_E_RETURNCODE ADDR_API
AddrDestroy(
80 ADDR_HANDLE hLib
) ///< address lib handle
82 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
86 Lib
* pLib
= Lib::GetLib(hLib
);
91 returnCode
= ADDR_ERROR
;
99 ////////////////////////////////////////////////////////////////////////////////////////////////////
101 ////////////////////////////////////////////////////////////////////////////////////////////////////
104 ****************************************************************************************************
105 * AddrComputeSurfaceInfo
108 * Calculate surface width/height/depth/alignments and suitable tiling mode
111 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
112 ****************************************************************************************************
114 ADDR_E_RETURNCODE ADDR_API
AddrComputeSurfaceInfo(
115 ADDR_HANDLE hLib
, ///< address lib handle
116 const ADDR_COMPUTE_SURFACE_INFO_INPUT
* pIn
, ///< [in] surface information
117 ADDR_COMPUTE_SURFACE_INFO_OUTPUT
* pOut
) ///< [out] surface parameters and alignments
119 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
121 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
125 returnCode
= pLib
->ComputeSurfaceInfo(pIn
, pOut
);
129 returnCode
= ADDR_ERROR
;
138 ****************************************************************************************************
139 * AddrComputeSurfaceAddrFromCoord
142 * Compute surface address according to coordinates
145 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
146 ****************************************************************************************************
148 ADDR_E_RETURNCODE ADDR_API
AddrComputeSurfaceAddrFromCoord(
149 ADDR_HANDLE hLib
, ///< address lib handle
150 const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] surface info and coordinates
151 ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] surface address
153 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
155 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
159 returnCode
= pLib
->ComputeSurfaceAddrFromCoord(pIn
, pOut
);
163 returnCode
= ADDR_ERROR
;
170 ****************************************************************************************************
171 * AddrComputeSurfaceCoordFromAddr
174 * Compute coordinates according to surface address
177 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
178 ****************************************************************************************************
180 ADDR_E_RETURNCODE ADDR_API
AddrComputeSurfaceCoordFromAddr(
181 ADDR_HANDLE hLib
, ///< address lib handle
182 const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
* pIn
, ///< [in] surface info and address
183 ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] coordinates
185 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
187 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
191 returnCode
= pLib
->ComputeSurfaceCoordFromAddr(pIn
, pOut
);
195 returnCode
= ADDR_ERROR
;
203 ////////////////////////////////////////////////////////////////////////////////////////////////////
205 ////////////////////////////////////////////////////////////////////////////////////////////////////
208 ****************************************************************************************************
209 * AddrComputeHtileInfo
212 * Compute Htile pitch, height, base alignment and size in bytes
215 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
216 ****************************************************************************************************
218 ADDR_E_RETURNCODE ADDR_API
AddrComputeHtileInfo(
219 ADDR_HANDLE hLib
, ///< address lib handle
220 const ADDR_COMPUTE_HTILE_INFO_INPUT
* pIn
, ///< [in] Htile information
221 ADDR_COMPUTE_HTILE_INFO_OUTPUT
* pOut
) ///< [out] Htile pitch, height and size in bytes
223 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
225 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
229 returnCode
= pLib
->ComputeHtileInfo(pIn
, pOut
);
233 returnCode
= ADDR_ERROR
;
240 ****************************************************************************************************
241 * AddrComputeHtileAddrFromCoord
244 * Compute Htile address according to coordinates (of depth buffer)
247 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
248 ****************************************************************************************************
250 ADDR_E_RETURNCODE ADDR_API
AddrComputeHtileAddrFromCoord(
251 ADDR_HANDLE hLib
, ///< address lib handle
252 const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Htile info and coordinates
253 ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Htile address
255 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
257 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
261 returnCode
= pLib
->ComputeHtileAddrFromCoord(pIn
, pOut
);
265 returnCode
= ADDR_ERROR
;
272 ****************************************************************************************************
273 * AddrComputeHtileCoordFromAddr
276 * Compute coordinates within depth buffer (1st pixel of a micro tile) according to
280 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
281 ****************************************************************************************************
283 ADDR_E_RETURNCODE ADDR_API
AddrComputeHtileCoordFromAddr(
284 ADDR_HANDLE hLib
, ///< address lib handle
285 const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
* pIn
, ///< [in] Htile info and address
286 ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Htile coordinates
288 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
290 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
294 returnCode
= pLib
->ComputeHtileCoordFromAddr(pIn
, pOut
);
298 returnCode
= ADDR_ERROR
;
306 ////////////////////////////////////////////////////////////////////////////////////////////////////
308 ////////////////////////////////////////////////////////////////////////////////////////////////////
311 ****************************************************************************************************
312 * AddrComputeCmaskInfo
315 * Compute Cmask pitch, height, base alignment and size in bytes from color buffer
319 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
320 ****************************************************************************************************
322 ADDR_E_RETURNCODE ADDR_API
AddrComputeCmaskInfo(
323 ADDR_HANDLE hLib
, ///< address lib handle
324 const ADDR_COMPUTE_CMASK_INFO_INPUT
* pIn
, ///< [in] Cmask pitch and height
325 ADDR_COMPUTE_CMASK_INFO_OUTPUT
* pOut
) ///< [out] Cmask pitch, height and size in bytes
327 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
329 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
333 returnCode
= pLib
->ComputeCmaskInfo(pIn
, pOut
);
337 returnCode
= ADDR_ERROR
;
344 ****************************************************************************************************
345 * AddrComputeCmaskAddrFromCoord
348 * Compute Cmask address according to coordinates (of MSAA color buffer)
351 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
352 ****************************************************************************************************
354 ADDR_E_RETURNCODE ADDR_API
AddrComputeCmaskAddrFromCoord(
355 ADDR_HANDLE hLib
, ///< address lib handle
356 const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Cmask info and coordinates
357 ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Cmask address
359 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
361 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
365 returnCode
= pLib
->ComputeCmaskAddrFromCoord(pIn
, pOut
);
369 returnCode
= ADDR_ERROR
;
376 ****************************************************************************************************
377 * AddrComputeCmaskCoordFromAddr
380 * Compute coordinates within color buffer (1st pixel of a micro tile) according to
384 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
385 ****************************************************************************************************
387 ADDR_E_RETURNCODE ADDR_API
AddrComputeCmaskCoordFromAddr(
388 ADDR_HANDLE hLib
, ///< address lib handle
389 const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
* pIn
, ///< [in] Cmask info and address
390 ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Cmask coordinates
392 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
394 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
398 returnCode
= pLib
->ComputeCmaskCoordFromAddr(pIn
, pOut
);
402 returnCode
= ADDR_ERROR
;
410 ////////////////////////////////////////////////////////////////////////////////////////////////////
412 ////////////////////////////////////////////////////////////////////////////////////////////////////
415 ****************************************************************************************************
416 * AddrComputeFmaskInfo
419 * Compute Fmask pitch/height/depth/alignments and size in bytes
422 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
423 ****************************************************************************************************
425 ADDR_E_RETURNCODE ADDR_API
AddrComputeFmaskInfo(
426 ADDR_HANDLE hLib
, ///< address lib handle
427 const ADDR_COMPUTE_FMASK_INFO_INPUT
* pIn
, ///< [in] Fmask information
428 ADDR_COMPUTE_FMASK_INFO_OUTPUT
* pOut
) ///< [out] Fmask pitch and height
430 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
432 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
436 returnCode
= pLib
->ComputeFmaskInfo(pIn
, pOut
);
440 returnCode
= ADDR_ERROR
;
447 ****************************************************************************************************
448 * AddrComputeFmaskAddrFromCoord
451 * Compute Fmask address according to coordinates (x,y,slice,sample,plane)
454 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
455 ****************************************************************************************************
457 ADDR_E_RETURNCODE ADDR_API
AddrComputeFmaskAddrFromCoord(
458 ADDR_HANDLE hLib
, ///< address lib handle
459 const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Fmask info and coordinates
460 ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Fmask address
462 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
464 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
468 returnCode
= pLib
->ComputeFmaskAddrFromCoord(pIn
, pOut
);
472 returnCode
= ADDR_ERROR
;
479 ****************************************************************************************************
480 * AddrComputeFmaskCoordFromAddr
483 * Compute coordinates (x,y,slice,sample,plane) according to Fmask address
486 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
487 ****************************************************************************************************
489 ADDR_E_RETURNCODE ADDR_API
AddrComputeFmaskCoordFromAddr(
490 ADDR_HANDLE hLib
, ///< address lib handle
491 const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
* pIn
, ///< [in] Fmask info and address
492 ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Fmask coordinates
494 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
496 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
500 returnCode
= pLib
->ComputeFmaskCoordFromAddr(pIn
, pOut
);
504 returnCode
= ADDR_ERROR
;
512 ////////////////////////////////////////////////////////////////////////////////////////////////////
514 ////////////////////////////////////////////////////////////////////////////////////////////////////
517 ****************************************************************************************************
521 * Compute DCC key size, base alignment based on color surface size, tile info or tile index
523 ****************************************************************************************************
525 ADDR_E_RETURNCODE ADDR_API
AddrComputeDccInfo(
526 ADDR_HANDLE hLib
, ///< handle of addrlib
527 const ADDR_COMPUTE_DCCINFO_INPUT
* pIn
, ///< [in] input
528 ADDR_COMPUTE_DCCINFO_OUTPUT
* pOut
) ///< [out] output
530 ADDR_E_RETURNCODE returnCode
;
532 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
536 returnCode
= pLib
->ComputeDccInfo(pIn
, pOut
);
540 returnCode
= ADDR_ERROR
;
548 ///////////////////////////////////////////////////////////////////////////////
549 // Below functions are element related or helper functions
550 ///////////////////////////////////////////////////////////////////////////////
553 ****************************************************************************************************
557 * Get AddrLib version number. Client may check this return value against ADDRLIB_VERSION
558 * defined in addrinterface.h to see if there is a mismatch.
559 ****************************************************************************************************
561 UINT_32 ADDR_API
AddrGetVersion(ADDR_HANDLE hLib
)
565 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
567 ADDR_ASSERT(pLib
!= NULL
);
571 version
= pLib
->GetVersion();
578 ****************************************************************************************************
582 * Return TRUE if tileIndex is enabled in this address library
583 ****************************************************************************************************
585 BOOL_32 ADDR_API
AddrUseTileIndex(ADDR_HANDLE hLib
)
587 BOOL_32 useTileIndex
= FALSE
;
589 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
591 ADDR_ASSERT(pLib
!= NULL
);
595 useTileIndex
= pLib
->UseTileIndex(0);
602 ****************************************************************************************************
603 * AddrUseCombinedSwizzle
606 * Return TRUE if combined swizzle is enabled in this address library
607 ****************************************************************************************************
609 BOOL_32 ADDR_API
AddrUseCombinedSwizzle(ADDR_HANDLE hLib
)
611 BOOL_32 useCombinedSwizzle
= FALSE
;
613 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
615 ADDR_ASSERT(pLib
!= NULL
);
619 useCombinedSwizzle
= pLib
->UseCombinedSwizzle();
622 return useCombinedSwizzle
;
626 ****************************************************************************************************
627 * AddrExtractBankPipeSwizzle
630 * Extract Bank and Pipe swizzle from base256b
632 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
633 ****************************************************************************************************
635 ADDR_E_RETURNCODE ADDR_API
AddrExtractBankPipeSwizzle(
636 ADDR_HANDLE hLib
, ///< addrlib handle
637 const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
* pIn
, ///< [in] input structure
638 ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
* pOut
) ///< [out] output structure
640 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
642 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
646 returnCode
= pLib
->ExtractBankPipeSwizzle(pIn
, pOut
);
650 returnCode
= ADDR_ERROR
;
657 ****************************************************************************************************
658 * AddrCombineBankPipeSwizzle
661 * Combine Bank and Pipe swizzle
664 ****************************************************************************************************
666 ADDR_E_RETURNCODE ADDR_API
AddrCombineBankPipeSwizzle(
668 const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
* pIn
,
669 ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
* pOut
)
671 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
673 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
677 returnCode
= pLib
->CombineBankPipeSwizzle(pIn
, pOut
);
681 returnCode
= ADDR_ERROR
;
688 ****************************************************************************************************
689 * AddrComputeSliceSwizzle
692 * Compute a swizzle for slice from a base swizzle
694 * ADDR_OK if no error
695 ****************************************************************************************************
697 ADDR_E_RETURNCODE ADDR_API
AddrComputeSliceSwizzle(
699 const ADDR_COMPUTE_SLICESWIZZLE_INPUT
* pIn
,
700 ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
* pOut
)
702 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
704 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
708 returnCode
= pLib
->ComputeSliceTileSwizzle(pIn
, pOut
);
712 returnCode
= ADDR_ERROR
;
719 ****************************************************************************************************
720 * AddrComputeBaseSwizzle
723 * Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
725 * ADDR_OK if no error
726 ****************************************************************************************************
728 ADDR_E_RETURNCODE ADDR_API
AddrComputeBaseSwizzle(
730 const ADDR_COMPUTE_BASE_SWIZZLE_INPUT
* pIn
,
731 ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
* pOut
)
733 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
735 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
739 returnCode
= pLib
->ComputeBaseSwizzle(pIn
, pOut
);
743 returnCode
= ADDR_ERROR
;
750 ****************************************************************************************************
751 * ElemFlt32ToDepthPixel
754 * Convert a FLT_32 value to a depth/stencil pixel value
757 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
759 ****************************************************************************************************
761 ADDR_E_RETURNCODE ADDR_API
ElemFlt32ToDepthPixel(
762 ADDR_HANDLE hLib
, ///< addrlib handle
763 const ELEM_FLT32TODEPTHPIXEL_INPUT
* pIn
, ///< [in] per-component value
764 ELEM_FLT32TODEPTHPIXEL_OUTPUT
* pOut
) ///< [out] final pixel value
766 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
768 Lib
* pLib
= Lib::GetLib(hLib
);
772 pLib
->Flt32ToDepthPixel(pIn
, pOut
);
776 returnCode
= ADDR_ERROR
;
783 ****************************************************************************************************
784 * ElemFlt32ToColorPixel
787 * Convert a FLT_32 value to a red/green/blue/alpha pixel value
790 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
792 ****************************************************************************************************
794 ADDR_E_RETURNCODE ADDR_API
ElemFlt32ToColorPixel(
795 ADDR_HANDLE hLib
, ///< addrlib handle
796 const ELEM_FLT32TOCOLORPIXEL_INPUT
* pIn
, ///< [in] format, surface number and swap value
797 ELEM_FLT32TOCOLORPIXEL_OUTPUT
* pOut
) ///< [out] final pixel value
799 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
801 Lib
* pLib
= Lib::GetLib(hLib
);
805 pLib
->Flt32ToColorPixel(pIn
, pOut
);
809 returnCode
= ADDR_ERROR
;
816 ****************************************************************************************************
820 * Helper function to check one format can be EXPORT_NUM,
821 * which is a register CB_COLOR_INFO.SURFACE_FORMAT.
822 * FP16 can be reported as EXPORT_NORM for rv770 in r600
825 ****************************************************************************************************
827 BOOL_32 ADDR_API
ElemGetExportNorm(
828 ADDR_HANDLE hLib
, ///< addrlib handle
829 const ELEM_GETEXPORTNORM_INPUT
* pIn
) ///< [in] input structure
831 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
832 BOOL_32 enabled
= FALSE
;
834 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
838 enabled
= pLib
->GetExportNorm(pIn
);
842 returnCode
= ADDR_ERROR
;
845 ADDR_ASSERT(returnCode
== ADDR_OK
);
851 ****************************************************************************************************
852 * AddrConvertTileInfoToHW
855 * Convert tile info from real value to hardware register value
858 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
859 ****************************************************************************************************
861 ADDR_E_RETURNCODE ADDR_API
AddrConvertTileInfoToHW(
862 ADDR_HANDLE hLib
, ///< address lib handle
863 const ADDR_CONVERT_TILEINFOTOHW_INPUT
* pIn
, ///< [in] tile info with real value
864 ADDR_CONVERT_TILEINFOTOHW_OUTPUT
* pOut
) ///< [out] tile info with HW register value
866 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
868 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
872 returnCode
= pLib
->ConvertTileInfoToHW(pIn
, pOut
);
876 returnCode
= ADDR_ERROR
;
883 ****************************************************************************************************
884 * AddrConvertTileIndex
887 * Convert tile index to tile mode/type/info
890 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
891 ****************************************************************************************************
893 ADDR_E_RETURNCODE ADDR_API
AddrConvertTileIndex(
894 ADDR_HANDLE hLib
, ///< address lib handle
895 const ADDR_CONVERT_TILEINDEX_INPUT
* pIn
, ///< [in] input - tile index
896 ADDR_CONVERT_TILEINDEX_OUTPUT
* pOut
) ///< [out] tile mode/type/info
898 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
900 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
904 returnCode
= pLib
->ConvertTileIndex(pIn
, pOut
);
908 returnCode
= ADDR_ERROR
;
915 ****************************************************************************************************
916 * AddrGetMacroModeIndex
919 * Get macro mode index based on input parameters
922 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
923 ****************************************************************************************************
925 ADDR_E_RETURNCODE ADDR_API
AddrGetMacroModeIndex(
926 ADDR_HANDLE hLib
, ///< address lib handle
927 const ADDR_GET_MACROMODEINDEX_INPUT
* pIn
, ///< [in] input
928 ADDR_GET_MACROMODEINDEX_OUTPUT
* pOut
) ///< [out] macro mode index
930 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
932 ADDR_E_RETURNCODE returnCode
;
936 returnCode
= pLib
->GetMacroModeIndex(pIn
, pOut
);
940 returnCode
= ADDR_ERROR
;
947 ****************************************************************************************************
948 * AddrConvertTileIndex1
951 * Convert tile index to tile mode/type/info
954 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
955 ****************************************************************************************************
957 ADDR_E_RETURNCODE ADDR_API
AddrConvertTileIndex1(
958 ADDR_HANDLE hLib
, ///< address lib handle
959 const ADDR_CONVERT_TILEINDEX1_INPUT
* pIn
, ///< [in] input - tile index
960 ADDR_CONVERT_TILEINDEX_OUTPUT
* pOut
) ///< [out] tile mode/type/info
962 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
964 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
968 returnCode
= pLib
->ConvertTileIndex1(pIn
, pOut
);
972 returnCode
= ADDR_ERROR
;
979 ****************************************************************************************************
983 * Get tile index from tile mode/type/info
986 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
989 * Only meaningful for SI (and above)
990 ****************************************************************************************************
992 ADDR_E_RETURNCODE ADDR_API
AddrGetTileIndex(
994 const ADDR_GET_TILEINDEX_INPUT
* pIn
,
995 ADDR_GET_TILEINDEX_OUTPUT
* pOut
)
997 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
999 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1003 returnCode
= pLib
->GetTileIndex(pIn
, pOut
);
1007 returnCode
= ADDR_ERROR
;
1014 ****************************************************************************************************
1015 * AddrComputePrtInfo
1018 * Interface function for ComputePrtInfo
1020 ****************************************************************************************************
1022 ADDR_E_RETURNCODE ADDR_API
AddrComputePrtInfo(
1024 const ADDR_PRT_INFO_INPUT
* pIn
,
1025 ADDR_PRT_INFO_OUTPUT
* pOut
)
1027 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1029 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
1033 returnCode
= pLib
->ComputePrtInfo(pIn
, pOut
);
1037 returnCode
= ADDR_ERROR
;
1044 ****************************************************************************************************
1045 * AddrGetMaxAlignments
1048 * Convert maximum alignments
1051 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1052 ****************************************************************************************************
1054 ADDR_E_RETURNCODE ADDR_API
AddrGetMaxAlignments(
1055 ADDR_HANDLE hLib
, ///< address lib handle
1056 ADDR_GET_MAX_ALINGMENTS_OUTPUT
* pOut
) ///< [out] output structure
1058 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
1060 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1064 returnCode
= pLib
->GetMaxAlignments(pOut
);
1068 returnCode
= ADDR_ERROR
;