2 * Copyright © 2007-2018 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"
39 #include "util/macros.h"
43 ////////////////////////////////////////////////////////////////////////////////////////////////////
44 // Create/Destroy/Config functions
45 ////////////////////////////////////////////////////////////////////////////////////////////////////
48 ****************************************************************************************************
52 * Create address lib object
55 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
56 ****************************************************************************************************
58 ADDR_E_RETURNCODE ADDR_API
AddrCreate(
59 const ADDR_CREATE_INPUT
* pAddrCreateIn
, ///< [in] infomation for creating address lib object
60 ADDR_CREATE_OUTPUT
* pAddrCreateOut
) ///< [out] address lib handle
62 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
65 returnCode
= Lib::Create(pAddrCreateIn
, pAddrCreateOut
);
72 ****************************************************************************************************
76 * Destroy address lib object
79 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
80 ****************************************************************************************************
82 ADDR_E_RETURNCODE ADDR_API
AddrDestroy(
83 ADDR_HANDLE hLib
) ///< address lib handle
85 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
89 Lib
* pLib
= Lib::GetLib(hLib
);
94 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
;
137 ****************************************************************************************************
138 * AddrComputeSurfaceAddrFromCoord
141 * Compute surface address according to coordinates
144 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
145 ****************************************************************************************************
147 ADDR_E_RETURNCODE ADDR_API
AddrComputeSurfaceAddrFromCoord(
148 ADDR_HANDLE hLib
, ///< address lib handle
149 const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] surface info and coordinates
150 ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] surface address
152 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
154 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
158 returnCode
= pLib
->ComputeSurfaceAddrFromCoord(pIn
, pOut
);
162 returnCode
= ADDR_ERROR
;
169 ****************************************************************************************************
170 * AddrComputeSurfaceCoordFromAddr
173 * Compute coordinates according to surface address
176 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
177 ****************************************************************************************************
179 ADDR_E_RETURNCODE ADDR_API
AddrComputeSurfaceCoordFromAddr(
180 ADDR_HANDLE hLib
, ///< address lib handle
181 const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
* pIn
, ///< [in] surface info and address
182 ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] coordinates
184 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
186 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
190 returnCode
= pLib
->ComputeSurfaceCoordFromAddr(pIn
, pOut
);
194 returnCode
= ADDR_ERROR
;
200 ////////////////////////////////////////////////////////////////////////////////////////////////////
202 ////////////////////////////////////////////////////////////////////////////////////////////////////
205 ****************************************************************************************************
206 * AddrComputeHtileInfo
209 * Compute Htile pitch, height, base alignment and size in bytes
212 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
213 ****************************************************************************************************
215 ADDR_E_RETURNCODE ADDR_API
AddrComputeHtileInfo(
216 ADDR_HANDLE hLib
, ///< address lib handle
217 const ADDR_COMPUTE_HTILE_INFO_INPUT
* pIn
, ///< [in] Htile information
218 ADDR_COMPUTE_HTILE_INFO_OUTPUT
* pOut
) ///< [out] Htile pitch, height and size in bytes
220 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
222 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
226 returnCode
= pLib
->ComputeHtileInfo(pIn
, pOut
);
230 returnCode
= ADDR_ERROR
;
237 ****************************************************************************************************
238 * AddrComputeHtileAddrFromCoord
241 * Compute Htile address according to coordinates (of depth buffer)
244 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
245 ****************************************************************************************************
247 ADDR_E_RETURNCODE ADDR_API
AddrComputeHtileAddrFromCoord(
248 ADDR_HANDLE hLib
, ///< address lib handle
249 const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Htile info and coordinates
250 ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Htile address
252 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
254 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
258 returnCode
= pLib
->ComputeHtileAddrFromCoord(pIn
, pOut
);
262 returnCode
= ADDR_ERROR
;
269 ****************************************************************************************************
270 * AddrComputeHtileCoordFromAddr
273 * Compute coordinates within depth buffer (1st pixel of a micro tile) according to
277 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
278 ****************************************************************************************************
280 ADDR_E_RETURNCODE ADDR_API
AddrComputeHtileCoordFromAddr(
281 ADDR_HANDLE hLib
, ///< address lib handle
282 const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
* pIn
, ///< [in] Htile info and address
283 ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Htile coordinates
285 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
287 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
291 returnCode
= pLib
->ComputeHtileCoordFromAddr(pIn
, pOut
);
295 returnCode
= ADDR_ERROR
;
301 ////////////////////////////////////////////////////////////////////////////////////////////////////
303 ////////////////////////////////////////////////////////////////////////////////////////////////////
306 ****************************************************************************************************
307 * AddrComputeCmaskInfo
310 * Compute Cmask pitch, height, base alignment and size in bytes from color buffer
314 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
315 ****************************************************************************************************
317 ADDR_E_RETURNCODE ADDR_API
AddrComputeCmaskInfo(
318 ADDR_HANDLE hLib
, ///< address lib handle
319 const ADDR_COMPUTE_CMASK_INFO_INPUT
* pIn
, ///< [in] Cmask pitch and height
320 ADDR_COMPUTE_CMASK_INFO_OUTPUT
* pOut
) ///< [out] Cmask pitch, height and size in bytes
322 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
324 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
328 returnCode
= pLib
->ComputeCmaskInfo(pIn
, pOut
);
332 returnCode
= ADDR_ERROR
;
339 ****************************************************************************************************
340 * AddrComputeCmaskAddrFromCoord
343 * Compute Cmask address according to coordinates (of MSAA color buffer)
346 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
347 ****************************************************************************************************
349 ADDR_E_RETURNCODE ADDR_API
AddrComputeCmaskAddrFromCoord(
350 ADDR_HANDLE hLib
, ///< address lib handle
351 const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Cmask info and coordinates
352 ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Cmask address
354 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
356 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
360 returnCode
= pLib
->ComputeCmaskAddrFromCoord(pIn
, pOut
);
364 returnCode
= ADDR_ERROR
;
371 ****************************************************************************************************
372 * AddrComputeCmaskCoordFromAddr
375 * Compute coordinates within color buffer (1st pixel of a micro tile) according to
379 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
380 ****************************************************************************************************
382 ADDR_E_RETURNCODE ADDR_API
AddrComputeCmaskCoordFromAddr(
383 ADDR_HANDLE hLib
, ///< address lib handle
384 const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
* pIn
, ///< [in] Cmask info and address
385 ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Cmask coordinates
387 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
389 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
393 returnCode
= pLib
->ComputeCmaskCoordFromAddr(pIn
, pOut
);
397 returnCode
= ADDR_ERROR
;
403 ////////////////////////////////////////////////////////////////////////////////////////////////////
405 ////////////////////////////////////////////////////////////////////////////////////////////////////
408 ****************************************************************************************************
409 * AddrComputeFmaskInfo
412 * Compute Fmask pitch/height/depth/alignments and size in bytes
415 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
416 ****************************************************************************************************
418 ADDR_E_RETURNCODE ADDR_API
AddrComputeFmaskInfo(
419 ADDR_HANDLE hLib
, ///< address lib handle
420 const ADDR_COMPUTE_FMASK_INFO_INPUT
* pIn
, ///< [in] Fmask information
421 ADDR_COMPUTE_FMASK_INFO_OUTPUT
* pOut
) ///< [out] Fmask pitch and height
423 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
425 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
429 returnCode
= pLib
->ComputeFmaskInfo(pIn
, pOut
);
433 returnCode
= ADDR_ERROR
;
440 ****************************************************************************************************
441 * AddrComputeFmaskAddrFromCoord
444 * Compute Fmask address according to coordinates (x,y,slice,sample,plane)
447 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
448 ****************************************************************************************************
450 ADDR_E_RETURNCODE ADDR_API
AddrComputeFmaskAddrFromCoord(
451 ADDR_HANDLE hLib
, ///< address lib handle
452 const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Fmask info and coordinates
453 ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Fmask address
455 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
457 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
461 returnCode
= pLib
->ComputeFmaskAddrFromCoord(pIn
, pOut
);
465 returnCode
= ADDR_ERROR
;
472 ****************************************************************************************************
473 * AddrComputeFmaskCoordFromAddr
476 * Compute coordinates (x,y,slice,sample,plane) according to Fmask address
479 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
480 ****************************************************************************************************
482 ADDR_E_RETURNCODE ADDR_API
AddrComputeFmaskCoordFromAddr(
483 ADDR_HANDLE hLib
, ///< address lib handle
484 const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
* pIn
, ///< [in] Fmask info and address
485 ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Fmask coordinates
487 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
489 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
493 returnCode
= pLib
->ComputeFmaskCoordFromAddr(pIn
, pOut
);
497 returnCode
= ADDR_ERROR
;
503 ////////////////////////////////////////////////////////////////////////////////////////////////////
505 ////////////////////////////////////////////////////////////////////////////////////////////////////
508 ****************************************************************************************************
512 * Compute DCC key size, base alignment based on color surface size, tile info or tile index
514 ****************************************************************************************************
516 ADDR_E_RETURNCODE ADDR_API
AddrComputeDccInfo(
517 ADDR_HANDLE hLib
, ///< handle of addrlib
518 const ADDR_COMPUTE_DCCINFO_INPUT
* pIn
, ///< [in] input
519 ADDR_COMPUTE_DCCINFO_OUTPUT
* pOut
) ///< [out] output
521 ADDR_E_RETURNCODE returnCode
;
523 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
527 returnCode
= pLib
->ComputeDccInfo(pIn
, pOut
);
531 returnCode
= ADDR_ERROR
;
537 ///////////////////////////////////////////////////////////////////////////////
538 // Below functions are element related or helper functions
539 ///////////////////////////////////////////////////////////////////////////////
542 ****************************************************************************************************
546 * Get AddrLib version number. Client may check this return value against ADDRLIB_VERSION
547 * defined in addrinterface.h to see if there is a mismatch.
548 ****************************************************************************************************
550 UINT_32 ADDR_API
AddrGetVersion(ADDR_HANDLE hLib
)
554 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
556 ADDR_ASSERT(pLib
!= NULL
);
560 version
= pLib
->GetVersion();
567 ****************************************************************************************************
571 * Return TRUE if tileIndex is enabled in this address library
572 ****************************************************************************************************
574 BOOL_32 ADDR_API
AddrUseTileIndex(ADDR_HANDLE hLib
)
576 BOOL_32 useTileIndex
= FALSE
;
578 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
580 ADDR_ASSERT(pLib
!= NULL
);
584 useTileIndex
= pLib
->UseTileIndex(0);
591 ****************************************************************************************************
592 * AddrUseCombinedSwizzle
595 * Return TRUE if combined swizzle is enabled in this address library
596 ****************************************************************************************************
598 BOOL_32 ADDR_API
AddrUseCombinedSwizzle(ADDR_HANDLE hLib
)
600 BOOL_32 useCombinedSwizzle
= FALSE
;
602 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
604 ADDR_ASSERT(pLib
!= NULL
);
608 useCombinedSwizzle
= pLib
->UseCombinedSwizzle();
611 return useCombinedSwizzle
;
615 ****************************************************************************************************
616 * AddrExtractBankPipeSwizzle
619 * Extract Bank and Pipe swizzle from base256b
621 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
622 ****************************************************************************************************
624 ADDR_E_RETURNCODE ADDR_API
AddrExtractBankPipeSwizzle(
625 ADDR_HANDLE hLib
, ///< addrlib handle
626 const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
* pIn
, ///< [in] input structure
627 ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
* pOut
) ///< [out] output structure
629 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
631 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
635 returnCode
= pLib
->ExtractBankPipeSwizzle(pIn
, pOut
);
639 returnCode
= ADDR_ERROR
;
646 ****************************************************************************************************
647 * AddrCombineBankPipeSwizzle
650 * Combine Bank and Pipe swizzle
653 ****************************************************************************************************
655 ADDR_E_RETURNCODE ADDR_API
AddrCombineBankPipeSwizzle(
657 const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
* pIn
,
658 ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
* pOut
)
660 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
662 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
666 returnCode
= pLib
->CombineBankPipeSwizzle(pIn
, pOut
);
670 returnCode
= ADDR_ERROR
;
677 ****************************************************************************************************
678 * AddrComputeSliceSwizzle
681 * Compute a swizzle for slice from a base swizzle
683 * ADDR_OK if no error
684 ****************************************************************************************************
686 ADDR_E_RETURNCODE ADDR_API
AddrComputeSliceSwizzle(
688 const ADDR_COMPUTE_SLICESWIZZLE_INPUT
* pIn
,
689 ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
* pOut
)
691 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
693 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
697 returnCode
= pLib
->ComputeSliceTileSwizzle(pIn
, pOut
);
701 returnCode
= ADDR_ERROR
;
708 ****************************************************************************************************
709 * AddrComputeBaseSwizzle
712 * Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
714 * ADDR_OK if no error
715 ****************************************************************************************************
717 ADDR_E_RETURNCODE ADDR_API
AddrComputeBaseSwizzle(
719 const ADDR_COMPUTE_BASE_SWIZZLE_INPUT
* pIn
,
720 ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
* pOut
)
722 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
724 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
728 returnCode
= pLib
->ComputeBaseSwizzle(pIn
, pOut
);
732 returnCode
= ADDR_ERROR
;
739 ****************************************************************************************************
740 * ElemFlt32ToDepthPixel
743 * Convert a FLT_32 value to a depth/stencil pixel value
746 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
748 ****************************************************************************************************
750 ADDR_E_RETURNCODE ADDR_API
ElemFlt32ToDepthPixel(
751 ADDR_HANDLE hLib
, ///< addrlib handle
752 const ELEM_FLT32TODEPTHPIXEL_INPUT
* pIn
, ///< [in] per-component value
753 ELEM_FLT32TODEPTHPIXEL_OUTPUT
* pOut
) ///< [out] final pixel value
755 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
757 Lib
* pLib
= Lib::GetLib(hLib
);
761 pLib
->Flt32ToDepthPixel(pIn
, pOut
);
765 returnCode
= ADDR_ERROR
;
772 ****************************************************************************************************
773 * ElemFlt32ToColorPixel
776 * Convert a FLT_32 value to a red/green/blue/alpha pixel value
779 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
781 ****************************************************************************************************
783 ADDR_E_RETURNCODE ADDR_API
ElemFlt32ToColorPixel(
784 ADDR_HANDLE hLib
, ///< addrlib handle
785 const ELEM_FLT32TOCOLORPIXEL_INPUT
* pIn
, ///< [in] format, surface number and swap value
786 ELEM_FLT32TOCOLORPIXEL_OUTPUT
* pOut
) ///< [out] final pixel value
788 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
790 Lib
* pLib
= Lib::GetLib(hLib
);
794 pLib
->Flt32ToColorPixel(pIn
, pOut
);
798 returnCode
= ADDR_ERROR
;
805 ****************************************************************************************************
809 * Helper function to check one format can be EXPORT_NUM,
810 * which is a register CB_COLOR_INFO.SURFACE_FORMAT.
811 * FP16 can be reported as EXPORT_NORM for rv770 in r600
814 ****************************************************************************************************
816 BOOL_32 ADDR_API
ElemGetExportNorm(
817 ADDR_HANDLE hLib
, ///< addrlib handle
818 const ELEM_GETEXPORTNORM_INPUT
* pIn
) ///< [in] input structure
820 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
821 BOOL_32 enabled
= FALSE
;
823 MAYBE_UNUSED ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
827 enabled
= pLib
->GetExportNorm(pIn
);
831 returnCode
= ADDR_ERROR
;
834 ADDR_ASSERT(returnCode
== ADDR_OK
);
840 ****************************************************************************************************
844 * Get bits-per-element for specified format
847 * Bits-per-element of specified format
849 ****************************************************************************************************
851 UINT_32 ADDR_API
ElemSize(
857 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
861 bpe
= pLib
->GetBpe(format
);
868 ****************************************************************************************************
869 * AddrConvertTileInfoToHW
872 * Convert tile info from real value to hardware register value
875 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
876 ****************************************************************************************************
878 ADDR_E_RETURNCODE ADDR_API
AddrConvertTileInfoToHW(
879 ADDR_HANDLE hLib
, ///< address lib handle
880 const ADDR_CONVERT_TILEINFOTOHW_INPUT
* pIn
, ///< [in] tile info with real value
881 ADDR_CONVERT_TILEINFOTOHW_OUTPUT
* pOut
) ///< [out] tile info with HW register value
883 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
885 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
889 returnCode
= pLib
->ConvertTileInfoToHW(pIn
, pOut
);
893 returnCode
= ADDR_ERROR
;
900 ****************************************************************************************************
901 * AddrConvertTileIndex
904 * Convert tile index to tile mode/type/info
907 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
908 ****************************************************************************************************
910 ADDR_E_RETURNCODE ADDR_API
AddrConvertTileIndex(
911 ADDR_HANDLE hLib
, ///< address lib handle
912 const ADDR_CONVERT_TILEINDEX_INPUT
* pIn
, ///< [in] input - tile index
913 ADDR_CONVERT_TILEINDEX_OUTPUT
* pOut
) ///< [out] tile mode/type/info
915 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
917 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
921 returnCode
= pLib
->ConvertTileIndex(pIn
, pOut
);
925 returnCode
= ADDR_ERROR
;
932 ****************************************************************************************************
933 * AddrGetMacroModeIndex
936 * Get macro mode index based on input parameters
939 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
940 ****************************************************************************************************
942 ADDR_E_RETURNCODE ADDR_API
AddrGetMacroModeIndex(
943 ADDR_HANDLE hLib
, ///< address lib handle
944 const ADDR_GET_MACROMODEINDEX_INPUT
* pIn
, ///< [in] input
945 ADDR_GET_MACROMODEINDEX_OUTPUT
* pOut
) ///< [out] macro mode index
947 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
949 ADDR_E_RETURNCODE returnCode
;
953 returnCode
= pLib
->GetMacroModeIndex(pIn
, pOut
);
957 returnCode
= ADDR_ERROR
;
964 ****************************************************************************************************
965 * AddrConvertTileIndex1
968 * Convert tile index to tile mode/type/info
971 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
972 ****************************************************************************************************
974 ADDR_E_RETURNCODE ADDR_API
AddrConvertTileIndex1(
975 ADDR_HANDLE hLib
, ///< address lib handle
976 const ADDR_CONVERT_TILEINDEX1_INPUT
* pIn
, ///< [in] input - tile index
977 ADDR_CONVERT_TILEINDEX_OUTPUT
* pOut
) ///< [out] tile mode/type/info
979 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
981 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
985 returnCode
= pLib
->ConvertTileIndex1(pIn
, pOut
);
989 returnCode
= ADDR_ERROR
;
996 ****************************************************************************************************
1000 * Get tile index from tile mode/type/info
1003 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1006 * Only meaningful for SI (and above)
1007 ****************************************************************************************************
1009 ADDR_E_RETURNCODE ADDR_API
AddrGetTileIndex(
1011 const ADDR_GET_TILEINDEX_INPUT
* pIn
,
1012 ADDR_GET_TILEINDEX_OUTPUT
* pOut
)
1014 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
1016 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1020 returnCode
= pLib
->GetTileIndex(pIn
, pOut
);
1024 returnCode
= ADDR_ERROR
;
1031 ****************************************************************************************************
1032 * AddrComputePrtInfo
1035 * Interface function for ComputePrtInfo
1037 ****************************************************************************************************
1039 ADDR_E_RETURNCODE ADDR_API
AddrComputePrtInfo(
1041 const ADDR_PRT_INFO_INPUT
* pIn
,
1042 ADDR_PRT_INFO_OUTPUT
* pOut
)
1044 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1046 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
1050 returnCode
= pLib
->ComputePrtInfo(pIn
, pOut
);
1054 returnCode
= ADDR_ERROR
;
1061 ****************************************************************************************************
1062 * AddrGetMaxAlignments
1065 * Convert maximum alignments
1068 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1069 ****************************************************************************************************
1071 ADDR_E_RETURNCODE ADDR_API
AddrGetMaxAlignments(
1072 ADDR_HANDLE hLib
, ///< address lib handle
1073 ADDR_GET_MAX_ALINGMENTS_OUTPUT
* pOut
) ///< [out] output structure
1075 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
1077 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1081 returnCode
= pLib
->GetMaxAlignments(pOut
);
1085 returnCode
= ADDR_ERROR
;
1092 ****************************************************************************************************
1093 * AddrGetMaxMetaAlignments
1096 * Convert maximum alignments for metadata
1099 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1100 ****************************************************************************************************
1102 ADDR_E_RETURNCODE ADDR_API
AddrGetMaxMetaAlignments(
1103 ADDR_HANDLE hLib
, ///< address lib handle
1104 ADDR_GET_MAX_ALINGMENTS_OUTPUT
* pOut
) ///< [out] output structure
1106 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
1108 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1112 returnCode
= pLib
->GetMaxMetaAlignments(pOut
);
1116 returnCode
= ADDR_ERROR
;
1122 ////////////////////////////////////////////////////////////////////////////////////////////////////
1123 // Surface functions for Addr2
1124 ////////////////////////////////////////////////////////////////////////////////////////////////////
1127 ****************************************************************************************************
1128 * Addr2ComputeSurfaceInfo
1131 * Calculate surface width/height/depth/alignments and suitable tiling mode
1134 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1135 ****************************************************************************************************
1137 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSurfaceInfo(
1138 ADDR_HANDLE hLib
, ///< address lib handle
1139 const ADDR2_COMPUTE_SURFACE_INFO_INPUT
* pIn
, ///< [in] surface information
1140 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT
* pOut
) ///< [out] surface parameters and alignments
1142 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1144 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1148 returnCode
= pLib
->ComputeSurfaceInfo(pIn
, pOut
);
1152 returnCode
= ADDR_ERROR
;
1159 ****************************************************************************************************
1160 * Addr2ComputeSurfaceAddrFromCoord
1163 * Compute surface address according to coordinates
1166 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1167 ****************************************************************************************************
1169 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSurfaceAddrFromCoord(
1170 ADDR_HANDLE hLib
, ///< address lib handle
1171 const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] surface info and coordinates
1172 ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] surface address
1174 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1176 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1180 returnCode
= pLib
->ComputeSurfaceAddrFromCoord(pIn
, pOut
);
1184 returnCode
= ADDR_ERROR
;
1191 ****************************************************************************************************
1192 * Addr2ComputeSurfaceCoordFromAddr
1195 * Compute coordinates according to surface address
1198 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1199 ****************************************************************************************************
1201 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSurfaceCoordFromAddr(
1202 ADDR_HANDLE hLib
, ///< address lib handle
1203 const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT
* pIn
, ///< [in] surface info and address
1204 ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] coordinates
1206 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1208 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1212 returnCode
= pLib
->ComputeSurfaceCoordFromAddr(pIn
, pOut
);
1216 returnCode
= ADDR_ERROR
;
1222 ////////////////////////////////////////////////////////////////////////////////////////////////////
1223 // HTile functions for Addr2
1224 ////////////////////////////////////////////////////////////////////////////////////////////////////
1227 ****************************************************************************************************
1228 * Addr2ComputeHtileInfo
1231 * Compute Htile pitch, height, base alignment and size in bytes
1234 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1235 ****************************************************************************************************
1237 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeHtileInfo(
1238 ADDR_HANDLE hLib
, ///< address lib handle
1239 const ADDR2_COMPUTE_HTILE_INFO_INPUT
* pIn
, ///< [in] Htile information
1240 ADDR2_COMPUTE_HTILE_INFO_OUTPUT
* pOut
) ///< [out] Htile pitch, height and size in bytes
1242 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1244 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1248 returnCode
= pLib
->ComputeHtileInfo(pIn
, pOut
);
1252 returnCode
= ADDR_ERROR
;
1259 ****************************************************************************************************
1260 * Addr2ComputeHtileAddrFromCoord
1263 * Compute Htile address according to coordinates (of depth buffer)
1266 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1267 ****************************************************************************************************
1269 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeHtileAddrFromCoord(
1270 ADDR_HANDLE hLib
, ///< address lib handle
1271 const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Htile info and coordinates
1272 ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Htile address
1274 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1276 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1280 returnCode
= pLib
->ComputeHtileAddrFromCoord(pIn
, pOut
);
1284 returnCode
= ADDR_ERROR
;
1291 ****************************************************************************************************
1292 * Addr2ComputeHtileCoordFromAddr
1295 * Compute coordinates within depth buffer (1st pixel of a micro tile) according to
1299 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1300 ****************************************************************************************************
1302 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeHtileCoordFromAddr(
1303 ADDR_HANDLE hLib
, ///< address lib handle
1304 const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT
* pIn
, ///< [in] Htile info and address
1305 ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Htile coordinates
1307 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1309 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1313 returnCode
= pLib
->ComputeHtileCoordFromAddr(pIn
, pOut
);
1317 returnCode
= ADDR_ERROR
;
1323 ////////////////////////////////////////////////////////////////////////////////////////////////////
1324 // C-mask functions for Addr2
1325 ////////////////////////////////////////////////////////////////////////////////////////////////////
1328 ****************************************************************************************************
1329 * Addr2ComputeCmaskInfo
1332 * Compute Cmask pitch, height, base alignment and size in bytes from color buffer
1336 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1337 ****************************************************************************************************
1339 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeCmaskInfo(
1340 ADDR_HANDLE hLib
, ///< address lib handle
1341 const ADDR2_COMPUTE_CMASK_INFO_INPUT
* pIn
, ///< [in] Cmask pitch and height
1342 ADDR2_COMPUTE_CMASK_INFO_OUTPUT
* pOut
) ///< [out] Cmask pitch, height and size in bytes
1344 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1346 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1350 returnCode
= pLib
->ComputeCmaskInfo(pIn
, pOut
);
1354 returnCode
= ADDR_ERROR
;
1361 ****************************************************************************************************
1362 * Addr2ComputeCmaskAddrFromCoord
1365 * Compute Cmask address according to coordinates (of MSAA color buffer)
1368 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1369 ****************************************************************************************************
1371 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeCmaskAddrFromCoord(
1372 ADDR_HANDLE hLib
, ///< address lib handle
1373 const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Cmask info and coordinates
1374 ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Cmask address
1376 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1378 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1382 returnCode
= pLib
->ComputeCmaskAddrFromCoord(pIn
, pOut
);
1386 returnCode
= ADDR_ERROR
;
1393 ****************************************************************************************************
1394 * Addr2ComputeCmaskCoordFromAddr
1397 * Compute coordinates within color buffer (1st pixel of a micro tile) according to
1401 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1402 ****************************************************************************************************
1404 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeCmaskCoordFromAddr(
1405 ADDR_HANDLE hLib
, ///< address lib handle
1406 const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT
* pIn
, ///< [in] Cmask info and address
1407 ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Cmask coordinates
1409 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1411 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1415 returnCode
= pLib
->ComputeCmaskCoordFromAddr(pIn
, pOut
);
1419 returnCode
= ADDR_ERROR
;
1425 ////////////////////////////////////////////////////////////////////////////////////////////////////
1426 // F-mask functions for Addr2
1427 ////////////////////////////////////////////////////////////////////////////////////////////////////
1430 ****************************************************************************************************
1431 * Addr2ComputeFmaskInfo
1434 * Compute Fmask pitch/height/depth/alignments and size in bytes
1437 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1438 ****************************************************************************************************
1440 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeFmaskInfo(
1441 ADDR_HANDLE hLib
, ///< address lib handle
1442 const ADDR2_COMPUTE_FMASK_INFO_INPUT
* pIn
, ///< [in] Fmask information
1443 ADDR2_COMPUTE_FMASK_INFO_OUTPUT
* pOut
) ///< [out] Fmask pitch and height
1445 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1447 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1451 returnCode
= pLib
->ComputeFmaskInfo(pIn
, pOut
);
1455 returnCode
= ADDR_ERROR
;
1462 ****************************************************************************************************
1463 * Addr2ComputeFmaskAddrFromCoord
1466 * Compute Fmask address according to coordinates (x,y,slice,sample,plane)
1469 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1470 ****************************************************************************************************
1472 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeFmaskAddrFromCoord(
1473 ADDR_HANDLE hLib
, ///< address lib handle
1474 const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Fmask info and coordinates
1475 ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Fmask address
1477 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1479 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1483 returnCode
= pLib
->ComputeFmaskAddrFromCoord(pIn
, pOut
);
1487 returnCode
= ADDR_ERROR
;
1494 ****************************************************************************************************
1495 * Addr2ComputeFmaskCoordFromAddr
1498 * Compute coordinates (x,y,slice,sample,plane) according to Fmask address
1501 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1502 ****************************************************************************************************
1504 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeFmaskCoordFromAddr(
1505 ADDR_HANDLE hLib
, ///< address lib handle
1506 const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT
* pIn
, ///< [in] Fmask info and address
1507 ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Fmask coordinates
1509 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1511 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1515 returnCode
= pLib
->ComputeFmaskCoordFromAddr(pIn
, pOut
);
1519 returnCode
= ADDR_ERROR
;
1525 ////////////////////////////////////////////////////////////////////////////////////////////////////
1526 // DCC key functions for Addr2
1527 ////////////////////////////////////////////////////////////////////////////////////////////////////
1530 ****************************************************************************************************
1531 * Addr2ComputeDccInfo
1534 * Compute DCC key size, base alignment based on color surface size, tile info or tile index
1536 ****************************************************************************************************
1538 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeDccInfo(
1539 ADDR_HANDLE hLib
, ///< handle of addrlib
1540 const ADDR2_COMPUTE_DCCINFO_INPUT
* pIn
, ///< [in] input
1541 ADDR2_COMPUTE_DCCINFO_OUTPUT
* pOut
) ///< [out] output
1543 ADDR_E_RETURNCODE returnCode
;
1545 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1549 returnCode
= pLib
->ComputeDccInfo(pIn
, pOut
);
1553 returnCode
= ADDR_ERROR
;
1560 ****************************************************************************************************
1561 * Addr2ComputeDccAddrFromCoord
1564 * Compute DCC key address according to coordinates
1567 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1568 ****************************************************************************************************
1570 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeDccAddrFromCoord(
1571 ADDR_HANDLE hLib
, ///< address lib handle
1572 const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Dcc info and coordinates
1573 ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Dcc address
1575 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1577 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1581 returnCode
= pLib
->ComputeDccAddrFromCoord(pIn
, pOut
);
1585 returnCode
= ADDR_ERROR
;
1592 ****************************************************************************************************
1593 * Addr2ComputePipeBankXor
1596 * Calculate a valid bank pipe xor value for client to use.
1597 ****************************************************************************************************
1599 ADDR_E_RETURNCODE ADDR_API
Addr2ComputePipeBankXor(
1600 ADDR_HANDLE hLib
, ///< handle of addrlib
1601 const ADDR2_COMPUTE_PIPEBANKXOR_INPUT
* pIn
, ///< [in] input
1602 ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT
* pOut
) ///< [out] output
1604 ADDR_E_RETURNCODE returnCode
;
1606 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1610 returnCode
= pLib
->ComputePipeBankXor(pIn
, pOut
);
1614 returnCode
= ADDR_ERROR
;
1621 ****************************************************************************************************
1622 * Addr2ComputeSlicePipeBankXor
1625 * Calculate slice pipe bank xor value based on base pipe bank xor and slice id.
1626 ****************************************************************************************************
1628 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSlicePipeBankXor(
1629 ADDR_HANDLE hLib
, ///< handle of addrlib
1630 const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT
* pIn
, ///< [in] input
1631 ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT
* pOut
) ///< [out] output
1633 ADDR_E_RETURNCODE returnCode
;
1635 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1639 returnCode
= pLib
->ComputeSlicePipeBankXor(pIn
, pOut
);
1643 returnCode
= ADDR_ERROR
;
1650 ****************************************************************************************************
1651 * Addr2ComputeSubResourceOffsetForSwizzlePattern
1654 * Calculate sub resource offset for swizzle pattern.
1655 ****************************************************************************************************
1657 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSubResourceOffsetForSwizzlePattern(
1658 ADDR_HANDLE hLib
, ///< handle of addrlib
1659 const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT
* pIn
, ///< [in] input
1660 ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT
* pOut
) ///< [out] output
1662 ADDR_E_RETURNCODE returnCode
;
1664 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1668 returnCode
= pLib
->ComputeSubResourceOffsetForSwizzlePattern(pIn
, pOut
);
1672 returnCode
= ADDR_ERROR
;
1679 ****************************************************************************************************
1680 * Addr2GetPreferredSurfaceSetting
1683 * Suggest a preferred setting for client driver to program HW register
1684 ****************************************************************************************************
1686 ADDR_E_RETURNCODE ADDR_API
Addr2GetPreferredSurfaceSetting(
1687 ADDR_HANDLE hLib
, ///< handle of addrlib
1688 const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT
* pIn
, ///< [in] input
1689 ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT
* pOut
) ///< [out] output
1691 ADDR_E_RETURNCODE returnCode
;
1693 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1697 returnCode
= pLib
->Addr2GetPreferredSurfaceSetting(pIn
, pOut
);
1701 returnCode
= ADDR_ERROR
;
1708 ****************************************************************************************************
1709 * Addr2IsValidDisplaySwizzleMode
1712 * Return whether the swizzle mode is supported by DCE / DCN.
1713 ****************************************************************************************************
1715 ADDR_E_RETURNCODE ADDR_API
Addr2IsValidDisplaySwizzleMode(
1717 AddrSwizzleMode swizzleMode
,
1721 ADDR_E_RETURNCODE returnCode
;
1723 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1727 ADDR2_COMPUTE_SURFACE_INFO_INPUT in
;
1728 in
.swizzleMode
= swizzleMode
;
1731 *result
= pLib
->IsValidDisplaySwizzleMode(&in
);
1732 returnCode
= ADDR_OK
;
1736 returnCode
= ADDR_ERROR
;