1 /*
2 ************************************************************************************************************************
3 *
4 * Copyright (C) 2007-2022 Advanced Micro Devices, Inc. All rights reserved.
5 * SPDX-License-Identifier: MIT
6 *
7 ***********************************************************************************************************************/
8
9 /**
10 ****************************************************************************************************
11 * @file addrinterface.cpp
12 * @brief Contains the addrlib interface functions
13 ****************************************************************************************************
14 */
15 #include "addrinterface.h"
16 #include "addrlib1.h"
17 #include "addrlib2.h"
18
19 #include "addrcommon.h"
20
21 using namespace Addr;
22
23 ////////////////////////////////////////////////////////////////////////////////////////////////////
24 // Create/Destroy/Config functions
25 ////////////////////////////////////////////////////////////////////////////////////////////////////
26
27 /**
28 ****************************************************************************************************
29 * AddrCreate
30 *
31 * @brief
32 * Create address lib object
33 *
34 * @return
35 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
36 ****************************************************************************************************
37 */
AddrCreate(const ADDR_CREATE_INPUT * pAddrCreateIn,ADDR_CREATE_OUTPUT * pAddrCreateOut)38 ADDR_E_RETURNCODE ADDR_API AddrCreate(
39 const ADDR_CREATE_INPUT* pAddrCreateIn, ///< [in] infomation for creating address lib object
40 ADDR_CREATE_OUTPUT* pAddrCreateOut) ///< [out] address lib handle
41 {
42 ADDR_E_RETURNCODE returnCode = ADDR_OK;
43 {
44 returnCode = Lib::Create(pAddrCreateIn, pAddrCreateOut);
45 }
46
47 return returnCode;
48 }
49
50
51
52 /**
53 ****************************************************************************************************
54 * AddrDestroy
55 *
56 * @brief
57 * Destroy address lib object
58 *
59 * @return
60 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
61 ****************************************************************************************************
62 */
AddrDestroy(ADDR_HANDLE hLib)63 ADDR_E_RETURNCODE ADDR_API AddrDestroy(
64 ADDR_HANDLE hLib) ///< address lib handle
65 {
66 ADDR_E_RETURNCODE returnCode = ADDR_OK;
67
68 if (hLib)
69 {
70 Lib* pLib = Lib::GetLib(hLib);
71 pLib->Destroy();
72 }
73 else
74 {
75 returnCode = ADDR_ERROR;
76 }
77
78 return returnCode;
79 }
80
81
82
83 ////////////////////////////////////////////////////////////////////////////////////////////////////
84 // Surface functions
85 ////////////////////////////////////////////////////////////////////////////////////////////////////
86
87 /**
88 ****************************************************************************************************
89 * AddrComputeSurfaceInfo
90 *
91 * @brief
92 * Calculate surface width/height/depth/alignments and suitable tiling mode
93 *
94 * @return
95 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
96 ****************************************************************************************************
97 */
AddrComputeSurfaceInfo(ADDR_HANDLE hLib,const ADDR_COMPUTE_SURFACE_INFO_INPUT * pIn,ADDR_COMPUTE_SURFACE_INFO_OUTPUT * pOut)98 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
99 ADDR_HANDLE hLib, ///< address lib handle
100 const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] surface information
101 ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) ///< [out] surface parameters and alignments
102 {
103 V1::Lib* pLib = V1::Lib::GetLib(hLib);
104
105 ADDR_E_RETURNCODE returnCode = ADDR_OK;
106
107 if (pLib != NULL)
108 {
109 returnCode = pLib->ComputeSurfaceInfo(pIn, pOut);
110 }
111 else
112 {
113 returnCode = ADDR_ERROR;
114 }
115
116 return returnCode;
117 }
118
119
120
121 /**
122 ****************************************************************************************************
123 * AddrComputeSurfaceAddrFromCoord
124 *
125 * @brief
126 * Compute surface address according to coordinates
127 *
128 * @return
129 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
130 ****************************************************************************************************
131 */
AddrComputeSurfaceAddrFromCoord(ADDR_HANDLE hLib,const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT * pIn,ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT * pOut)132 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
133 ADDR_HANDLE hLib, ///< address lib handle
134 const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] surface info and coordinates
135 ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] surface address
136 {
137 V1::Lib* pLib = V1::Lib::GetLib(hLib);
138
139 ADDR_E_RETURNCODE returnCode = ADDR_OK;
140
141 if (pLib != NULL)
142 {
143 returnCode = pLib->ComputeSurfaceAddrFromCoord(pIn, pOut);
144 }
145 else
146 {
147 returnCode = ADDR_ERROR;
148 }
149
150 return returnCode;
151 }
152
153 /**
154 ****************************************************************************************************
155 * AddrComputeSurfaceCoordFromAddr
156 *
157 * @brief
158 * Compute coordinates according to surface address
159 *
160 * @return
161 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
162 ****************************************************************************************************
163 */
AddrComputeSurfaceCoordFromAddr(ADDR_HANDLE hLib,const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT * pIn,ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT * pOut)164 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
165 ADDR_HANDLE hLib, ///< address lib handle
166 const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] surface info and address
167 ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) ///< [out] coordinates
168 {
169 V1::Lib* pLib = V1::Lib::GetLib(hLib);
170
171 ADDR_E_RETURNCODE returnCode = ADDR_OK;
172
173 if (pLib != NULL)
174 {
175 returnCode = pLib->ComputeSurfaceCoordFromAddr(pIn, pOut);
176 }
177 else
178 {
179 returnCode = ADDR_ERROR;
180 }
181
182 return returnCode;
183 }
184
185
186
187 ////////////////////////////////////////////////////////////////////////////////////////////////////
188 // HTile functions
189 ////////////////////////////////////////////////////////////////////////////////////////////////////
190
191 /**
192 ****************************************************************************************************
193 * AddrComputeHtileInfo
194 *
195 * @brief
196 * Compute Htile pitch, height, base alignment and size in bytes
197 *
198 * @return
199 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
200 ****************************************************************************************************
201 */
AddrComputeHtileInfo(ADDR_HANDLE hLib,const ADDR_COMPUTE_HTILE_INFO_INPUT * pIn,ADDR_COMPUTE_HTILE_INFO_OUTPUT * pOut)202 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
203 ADDR_HANDLE hLib, ///< address lib handle
204 const ADDR_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] Htile information
205 ADDR_COMPUTE_HTILE_INFO_OUTPUT* pOut) ///< [out] Htile pitch, height and size in bytes
206 {
207 V1::Lib* pLib = V1::Lib::GetLib(hLib);
208
209 ADDR_E_RETURNCODE returnCode = ADDR_OK;
210
211 if (pLib != NULL)
212 {
213 returnCode = pLib->ComputeHtileInfo(pIn, pOut);
214 }
215 else
216 {
217 returnCode = ADDR_ERROR;
218 }
219
220 return returnCode;
221 }
222
223 /**
224 ****************************************************************************************************
225 * AddrComputeHtileAddrFromCoord
226 *
227 * @brief
228 * Compute Htile address according to coordinates (of depth buffer)
229 *
230 * @return
231 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
232 ****************************************************************************************************
233 */
AddrComputeHtileAddrFromCoord(ADDR_HANDLE hLib,const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT * pIn,ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT * pOut)234 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
235 ADDR_HANDLE hLib, ///< address lib handle
236 const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] Htile info and coordinates
237 ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Htile address
238 {
239 V1::Lib* pLib = V1::Lib::GetLib(hLib);
240
241 ADDR_E_RETURNCODE returnCode = ADDR_OK;
242
243 if (pLib != NULL)
244 {
245 returnCode = pLib->ComputeHtileAddrFromCoord(pIn, pOut);
246 }
247 else
248 {
249 returnCode = ADDR_ERROR;
250 }
251
252 return returnCode;
253 }
254
255 /**
256 ****************************************************************************************************
257 * AddrComputeHtileCoordFromAddr
258 *
259 * @brief
260 * Compute coordinates within depth buffer (1st pixel of a micro tile) according to
261 * Htile address
262 *
263 * @return
264 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
265 ****************************************************************************************************
266 */
AddrComputeHtileCoordFromAddr(ADDR_HANDLE hLib,const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT * pIn,ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT * pOut)267 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
268 ADDR_HANDLE hLib, ///< address lib handle
269 const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] Htile info and address
270 ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) ///< [out] Htile coordinates
271 {
272 V1::Lib* pLib = V1::Lib::GetLib(hLib);
273
274 ADDR_E_RETURNCODE returnCode = ADDR_OK;
275
276 if (pLib != NULL)
277 {
278 returnCode = pLib->ComputeHtileCoordFromAddr(pIn, pOut);
279 }
280 else
281 {
282 returnCode = ADDR_ERROR;
283 }
284
285 return returnCode;
286 }
287
288
289
290 ////////////////////////////////////////////////////////////////////////////////////////////////////
291 // C-mask functions
292 ////////////////////////////////////////////////////////////////////////////////////////////////////
293
294 /**
295 ****************************************************************************************************
296 * AddrComputeCmaskInfo
297 *
298 * @brief
299 * Compute Cmask pitch, height, base alignment and size in bytes from color buffer
300 * info
301 *
302 * @return
303 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
304 ****************************************************************************************************
305 */
AddrComputeCmaskInfo(ADDR_HANDLE hLib,const ADDR_COMPUTE_CMASK_INFO_INPUT * pIn,ADDR_COMPUTE_CMASK_INFO_OUTPUT * pOut)306 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
307 ADDR_HANDLE hLib, ///< address lib handle
308 const ADDR_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] Cmask pitch and height
309 ADDR_COMPUTE_CMASK_INFO_OUTPUT* pOut) ///< [out] Cmask pitch, height and size in bytes
310 {
311 V1::Lib* pLib = V1::Lib::GetLib(hLib);
312
313 ADDR_E_RETURNCODE returnCode = ADDR_OK;
314
315 if (pLib != NULL)
316 {
317 returnCode = pLib->ComputeCmaskInfo(pIn, pOut);
318 }
319 else
320 {
321 returnCode = ADDR_ERROR;
322 }
323
324 return returnCode;
325 }
326
327 /**
328 ****************************************************************************************************
329 * AddrComputeCmaskAddrFromCoord
330 *
331 * @brief
332 * Compute Cmask address according to coordinates (of MSAA color buffer)
333 *
334 * @return
335 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
336 ****************************************************************************************************
337 */
AddrComputeCmaskAddrFromCoord(ADDR_HANDLE hLib,const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT * pIn,ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT * pOut)338 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
339 ADDR_HANDLE hLib, ///< address lib handle
340 const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Cmask info and coordinates
341 ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Cmask address
342 {
343 V1::Lib* pLib = V1::Lib::GetLib(hLib);
344
345 ADDR_E_RETURNCODE returnCode = ADDR_OK;
346
347 if (pLib != NULL)
348 {
349 returnCode = pLib->ComputeCmaskAddrFromCoord(pIn, pOut);
350 }
351 else
352 {
353 returnCode = ADDR_ERROR;
354 }
355
356 return returnCode;
357 }
358
359 /**
360 ****************************************************************************************************
361 * AddrComputeCmaskCoordFromAddr
362 *
363 * @brief
364 * Compute coordinates within color buffer (1st pixel of a micro tile) according to
365 * Cmask address
366 *
367 * @return
368 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
369 ****************************************************************************************************
370 */
AddrComputeCmaskCoordFromAddr(ADDR_HANDLE hLib,const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT * pIn,ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT * pOut)371 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
372 ADDR_HANDLE hLib, ///< address lib handle
373 const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Cmask info and address
374 ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Cmask coordinates
375 {
376 V1::Lib* pLib = V1::Lib::GetLib(hLib);
377
378 ADDR_E_RETURNCODE returnCode = ADDR_OK;
379
380 if (pLib != NULL)
381 {
382 returnCode = pLib->ComputeCmaskCoordFromAddr(pIn, pOut);
383 }
384 else
385 {
386 returnCode = ADDR_ERROR;
387 }
388
389 return returnCode;
390 }
391
392
393
394 ////////////////////////////////////////////////////////////////////////////////////////////////////
395 // F-mask functions
396 ////////////////////////////////////////////////////////////////////////////////////////////////////
397
398 /**
399 ****************************************************************************************************
400 * AddrComputeFmaskInfo
401 *
402 * @brief
403 * Compute Fmask pitch/height/depth/alignments and size in bytes
404 *
405 * @return
406 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
407 ****************************************************************************************************
408 */
AddrComputeFmaskInfo(ADDR_HANDLE hLib,const ADDR_COMPUTE_FMASK_INFO_INPUT * pIn,ADDR_COMPUTE_FMASK_INFO_OUTPUT * pOut)409 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
410 ADDR_HANDLE hLib, ///< address lib handle
411 const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] Fmask information
412 ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut) ///< [out] Fmask pitch and height
413 {
414 V1::Lib* pLib = V1::Lib::GetLib(hLib);
415
416 ADDR_E_RETURNCODE returnCode = ADDR_OK;
417
418 if (pLib != NULL)
419 {
420 returnCode = pLib->ComputeFmaskInfo(pIn, pOut);
421 }
422 else
423 {
424 returnCode = ADDR_ERROR;
425 }
426
427 return returnCode;
428 }
429
430 /**
431 ****************************************************************************************************
432 * AddrComputeFmaskAddrFromCoord
433 *
434 * @brief
435 * Compute Fmask address according to coordinates (x,y,slice,sample,plane)
436 *
437 * @return
438 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
439 ****************************************************************************************************
440 */
AddrComputeFmaskAddrFromCoord(ADDR_HANDLE hLib,const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT * pIn,ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT * pOut)441 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
442 ADDR_HANDLE hLib, ///< address lib handle
443 const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Fmask info and coordinates
444 ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Fmask address
445 {
446 V1::Lib* pLib = V1::Lib::GetLib(hLib);
447
448 ADDR_E_RETURNCODE returnCode = ADDR_OK;
449
450 if (pLib != NULL)
451 {
452 returnCode = pLib->ComputeFmaskAddrFromCoord(pIn, pOut);
453 }
454 else
455 {
456 returnCode = ADDR_ERROR;
457 }
458
459 return returnCode;
460 }
461
462 /**
463 ****************************************************************************************************
464 * AddrComputeFmaskCoordFromAddr
465 *
466 * @brief
467 * Compute coordinates (x,y,slice,sample,plane) according to Fmask address
468 *
469 * @return
470 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
471 ****************************************************************************************************
472 */
AddrComputeFmaskCoordFromAddr(ADDR_HANDLE hLib,const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT * pIn,ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT * pOut)473 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
474 ADDR_HANDLE hLib, ///< address lib handle
475 const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Fmask info and address
476 ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Fmask coordinates
477 {
478 V1::Lib* pLib = V1::Lib::GetLib(hLib);
479
480 ADDR_E_RETURNCODE returnCode = ADDR_OK;
481
482 if (pLib != NULL)
483 {
484 returnCode = pLib->ComputeFmaskCoordFromAddr(pIn, pOut);
485 }
486 else
487 {
488 returnCode = ADDR_ERROR;
489 }
490
491 return returnCode;
492 }
493
494
495
496 ////////////////////////////////////////////////////////////////////////////////////////////////////
497 // DCC key functions
498 ////////////////////////////////////////////////////////////////////////////////////////////////////
499
500 /**
501 ****************************************************************************************************
502 * AddrComputeDccInfo
503 *
504 * @brief
505 * Compute DCC key size, base alignment based on color surface size, tile info or tile index
506 *
507 ****************************************************************************************************
508 */
AddrComputeDccInfo(ADDR_HANDLE hLib,const ADDR_COMPUTE_DCCINFO_INPUT * pIn,ADDR_COMPUTE_DCCINFO_OUTPUT * pOut)509 ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
510 ADDR_HANDLE hLib, ///< handle of addrlib
511 const ADDR_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input
512 ADDR_COMPUTE_DCCINFO_OUTPUT* pOut) ///< [out] output
513 {
514 ADDR_E_RETURNCODE returnCode;
515
516 V1::Lib* pLib = V1::Lib::GetLib(hLib);
517
518 if (pLib != NULL)
519 {
520 returnCode = pLib->ComputeDccInfo(pIn, pOut);
521 }
522 else
523 {
524 returnCode = ADDR_ERROR;
525 }
526
527 return returnCode;
528 }
529
530
531
532 ///////////////////////////////////////////////////////////////////////////////
533 // Below functions are element related or helper functions
534 ///////////////////////////////////////////////////////////////////////////////
535
536 /**
537 ****************************************************************************************************
538 * AddrGetVersion
539 *
540 * @brief
541 * Get AddrLib version number. Client may check this return value against ADDRLIB_VERSION
542 * defined in addrinterface.h to see if there is a mismatch.
543 ****************************************************************************************************
544 */
AddrGetVersion(ADDR_HANDLE hLib)545 UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib)
546 {
547 UINT_32 version = 0;
548
549 Addr::Lib* pLib = Lib::GetLib(hLib);
550
551 ADDR_ASSERT(pLib != NULL);
552
553 if (pLib)
554 {
555 version = pLib->GetVersion();
556 }
557
558 return version;
559 }
560
561 /**
562 ****************************************************************************************************
563 * AddrUseTileIndex
564 *
565 * @brief
566 * Return TRUE if tileIndex is enabled in this address library
567 ****************************************************************************************************
568 */
AddrUseTileIndex(ADDR_HANDLE hLib)569 BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib)
570 {
571 BOOL_32 useTileIndex = FALSE;
572
573 V1::Lib* pLib = V1::Lib::GetLib(hLib);
574
575 ADDR_ASSERT(pLib != NULL);
576
577 if (pLib)
578 {
579 useTileIndex = pLib->UseTileIndex(0);
580 }
581
582 return useTileIndex;
583 }
584
585 /**
586 ****************************************************************************************************
587 * AddrUseCombinedSwizzle
588 *
589 * @brief
590 * Return TRUE if combined swizzle is enabled in this address library
591 ****************************************************************************************************
592 */
AddrUseCombinedSwizzle(ADDR_HANDLE hLib)593 BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib)
594 {
595 BOOL_32 useCombinedSwizzle = FALSE;
596
597 V1::Lib* pLib = V1::Lib::GetLib(hLib);
598
599 ADDR_ASSERT(pLib != NULL);
600
601 if (pLib)
602 {
603 useCombinedSwizzle = pLib->UseCombinedSwizzle();
604 }
605
606 return useCombinedSwizzle;
607 }
608
609 /**
610 ****************************************************************************************************
611 * AddrExtractBankPipeSwizzle
612 *
613 * @brief
614 * Extract Bank and Pipe swizzle from base256b
615 * @return
616 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
617 ****************************************************************************************************
618 */
AddrExtractBankPipeSwizzle(ADDR_HANDLE hLib,const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT * pIn,ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT * pOut)619 ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
620 ADDR_HANDLE hLib, ///< addrlib handle
621 const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn, ///< [in] input structure
622 ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT* pOut) ///< [out] output structure
623 {
624 ADDR_E_RETURNCODE returnCode = ADDR_OK;
625
626 V1::Lib* pLib = V1::Lib::GetLib(hLib);
627
628 if (pLib != NULL)
629 {
630 returnCode = pLib->ExtractBankPipeSwizzle(pIn, pOut);
631 }
632 else
633 {
634 returnCode = ADDR_ERROR;
635 }
636
637 return returnCode;
638 }
639
640 /**
641 ****************************************************************************************************
642 * AddrCombineBankPipeSwizzle
643 *
644 * @brief
645 * Combine Bank and Pipe swizzle
646 * @return
647 * ADDR_E_RETURNCODE
648 ****************************************************************************************************
649 */
AddrCombineBankPipeSwizzle(ADDR_HANDLE hLib,const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT * pIn,ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT * pOut)650 ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
651 ADDR_HANDLE hLib,
652 const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT* pIn,
653 ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT* pOut)
654 {
655 ADDR_E_RETURNCODE returnCode = ADDR_OK;
656
657 V1::Lib* pLib = V1::Lib::GetLib(hLib);
658
659 if (pLib != NULL)
660 {
661 returnCode = pLib->CombineBankPipeSwizzle(pIn, pOut);
662 }
663 else
664 {
665 returnCode = ADDR_ERROR;
666 }
667
668 return returnCode;
669 }
670
671 /**
672 ****************************************************************************************************
673 * AddrComputeSliceSwizzle
674 *
675 * @brief
676 * Compute a swizzle for slice from a base swizzle
677 * @return
678 * ADDR_OK if no error
679 ****************************************************************************************************
680 */
AddrComputeSliceSwizzle(ADDR_HANDLE hLib,const ADDR_COMPUTE_SLICESWIZZLE_INPUT * pIn,ADDR_COMPUTE_SLICESWIZZLE_OUTPUT * pOut)681 ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
682 ADDR_HANDLE hLib,
683 const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn,
684 ADDR_COMPUTE_SLICESWIZZLE_OUTPUT* pOut)
685 {
686 ADDR_E_RETURNCODE returnCode = ADDR_OK;
687
688 V1::Lib* pLib = V1::Lib::GetLib(hLib);
689
690 if (pLib != NULL)
691 {
692 returnCode = pLib->ComputeSliceTileSwizzle(pIn, pOut);
693 }
694 else
695 {
696 returnCode = ADDR_ERROR;
697 }
698
699 return returnCode;
700 }
701
702 /**
703 ****************************************************************************************************
704 * AddrComputeBaseSwizzle
705 *
706 * @brief
707 * Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
708 * @return
709 * ADDR_OK if no error
710 ****************************************************************************************************
711 */
AddrComputeBaseSwizzle(ADDR_HANDLE hLib,const ADDR_COMPUTE_BASE_SWIZZLE_INPUT * pIn,ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT * pOut)712 ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
713 ADDR_HANDLE hLib,
714 const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn,
715 ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT* pOut)
716 {
717 ADDR_E_RETURNCODE returnCode = ADDR_OK;
718
719 V1::Lib* pLib = V1::Lib::GetLib(hLib);
720
721 if (pLib != NULL)
722 {
723 returnCode = pLib->ComputeBaseSwizzle(pIn, pOut);
724 }
725 else
726 {
727 returnCode = ADDR_ERROR;
728 }
729
730 return returnCode;
731 }
732
733 /**
734 ****************************************************************************************************
735 * ElemFlt32ToDepthPixel
736 *
737 * @brief
738 * Convert a FLT_32 value to a depth/stencil pixel value
739 *
740 * @return
741 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
742 *
743 ****************************************************************************************************
744 */
ElemFlt32ToDepthPixel(ADDR_HANDLE hLib,const ELEM_FLT32TODEPTHPIXEL_INPUT * pIn,ELEM_FLT32TODEPTHPIXEL_OUTPUT * pOut)745 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
746 ADDR_HANDLE hLib, ///< addrlib handle
747 const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn, ///< [in] per-component value
748 ELEM_FLT32TODEPTHPIXEL_OUTPUT* pOut) ///< [out] final pixel value
749 {
750 ADDR_E_RETURNCODE returnCode = ADDR_OK;
751
752 Lib* pLib = Lib::GetLib(hLib);
753
754 if (pLib != NULL)
755 {
756 pLib->Flt32ToDepthPixel(pIn, pOut);
757 }
758 else
759 {
760 returnCode = ADDR_ERROR;
761 }
762
763 return returnCode;
764 }
765
766 /**
767 ****************************************************************************************************
768 * ElemFlt32ToColorPixel
769 *
770 * @brief
771 * Convert a FLT_32 value to a red/green/blue/alpha pixel value
772 *
773 * @return
774 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
775 *
776 ****************************************************************************************************
777 */
ElemFlt32ToColorPixel(ADDR_HANDLE hLib,const ELEM_FLT32TOCOLORPIXEL_INPUT * pIn,ELEM_FLT32TOCOLORPIXEL_OUTPUT * pOut)778 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
779 ADDR_HANDLE hLib, ///< addrlib handle
780 const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn, ///< [in] format, surface number and swap value
781 ELEM_FLT32TOCOLORPIXEL_OUTPUT* pOut) ///< [out] final pixel value
782 {
783 ADDR_E_RETURNCODE returnCode = ADDR_OK;
784
785 Lib* pLib = Lib::GetLib(hLib);
786
787 if (pLib != NULL)
788 {
789 pLib->Flt32ToColorPixel(pIn, pOut);
790 }
791 else
792 {
793 returnCode = ADDR_ERROR;
794 }
795
796 return returnCode;
797 }
798
799 /**
800 ****************************************************************************************************
801 * ElemGetExportNorm
802 *
803 * @brief
804 * Helper function to check one format can be EXPORT_NUM,
805 * which is a register CB_COLOR_INFO.SURFACE_FORMAT.
806 * FP16 can be reported as EXPORT_NORM for rv770 in r600
807 * family
808 *
809 ****************************************************************************************************
810 */
ElemGetExportNorm(ADDR_HANDLE hLib,const ELEM_GETEXPORTNORM_INPUT * pIn)811 BOOL_32 ADDR_API ElemGetExportNorm(
812 ADDR_HANDLE hLib, ///< addrlib handle
813 const ELEM_GETEXPORTNORM_INPUT* pIn) ///< [in] input structure
814 {
815 Addr::Lib* pLib = Lib::GetLib(hLib);
816 BOOL_32 enabled = FALSE;
817
818 ADDR_E_RETURNCODE returnCode = ADDR_OK;
819
820 if (pLib != NULL)
821 {
822 enabled = pLib->GetExportNorm(pIn);
823 }
824 else
825 {
826 returnCode = ADDR_ERROR;
827 }
828
829 ADDR_ASSERT(returnCode == ADDR_OK);
830
831 return enabled;
832 }
833
834 /**
835 ****************************************************************************************************
836 * ElemSize
837 *
838 * @brief
839 * Get bits-per-element for specified format
840 *
841 * @return
842 * Bits-per-element of specified format
843 *
844 ****************************************************************************************************
845 */
ElemSize(ADDR_HANDLE hLib,AddrFormat format)846 UINT_32 ADDR_API ElemSize(
847 ADDR_HANDLE hLib,
848 AddrFormat format)
849 {
850 UINT_32 bpe = 0;
851
852 Addr::Lib* pLib = Lib::GetLib(hLib);
853
854 if (pLib != NULL)
855 {
856 bpe = pLib->GetBpe(format);
857 }
858
859 return bpe;
860 }
861
862 /**
863 ****************************************************************************************************
864 * AddrConvertTileInfoToHW
865 *
866 * @brief
867 * Convert tile info from real value to hardware register value
868 *
869 * @return
870 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
871 ****************************************************************************************************
872 */
AddrConvertTileInfoToHW(ADDR_HANDLE hLib,const ADDR_CONVERT_TILEINFOTOHW_INPUT * pIn,ADDR_CONVERT_TILEINFOTOHW_OUTPUT * pOut)873 ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
874 ADDR_HANDLE hLib, ///< address lib handle
875 const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] tile info with real value
876 ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut) ///< [out] tile info with HW register value
877 {
878 V1::Lib* pLib = V1::Lib::GetLib(hLib);
879
880 ADDR_E_RETURNCODE returnCode = ADDR_OK;
881
882 if (pLib != NULL)
883 {
884 returnCode = pLib->ConvertTileInfoToHW(pIn, pOut);
885 }
886 else
887 {
888 returnCode = ADDR_ERROR;
889 }
890
891 return returnCode;
892 }
893
894 /**
895 ****************************************************************************************************
896 * AddrConvertTileIndex
897 *
898 * @brief
899 * Convert tile index to tile mode/type/info
900 *
901 * @return
902 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
903 ****************************************************************************************************
904 */
AddrConvertTileIndex(ADDR_HANDLE hLib,const ADDR_CONVERT_TILEINDEX_INPUT * pIn,ADDR_CONVERT_TILEINDEX_OUTPUT * pOut)905 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
906 ADDR_HANDLE hLib, ///< address lib handle
907 const ADDR_CONVERT_TILEINDEX_INPUT* pIn, ///< [in] input - tile index
908 ADDR_CONVERT_TILEINDEX_OUTPUT* pOut) ///< [out] tile mode/type/info
909 {
910 V1::Lib* pLib = V1::Lib::GetLib(hLib);
911
912 ADDR_E_RETURNCODE returnCode = ADDR_OK;
913
914 if (pLib != NULL)
915 {
916 returnCode = pLib->ConvertTileIndex(pIn, pOut);
917 }
918 else
919 {
920 returnCode = ADDR_ERROR;
921 }
922
923 return returnCode;
924 }
925
926 /**
927 ****************************************************************************************************
928 * AddrGetMacroModeIndex
929 *
930 * @brief
931 * Get macro mode index based on input parameters
932 *
933 * @return
934 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
935 ****************************************************************************************************
936 */
AddrGetMacroModeIndex(ADDR_HANDLE hLib,const ADDR_GET_MACROMODEINDEX_INPUT * pIn,ADDR_GET_MACROMODEINDEX_OUTPUT * pOut)937 ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
938 ADDR_HANDLE hLib, ///< address lib handle
939 const ADDR_GET_MACROMODEINDEX_INPUT* pIn, ///< [in] input
940 ADDR_GET_MACROMODEINDEX_OUTPUT* pOut) ///< [out] macro mode index
941 {
942 V1::Lib* pLib = V1::Lib::GetLib(hLib);
943
944 ADDR_E_RETURNCODE returnCode;
945
946 if (pLib != NULL)
947 {
948 returnCode = pLib->GetMacroModeIndex(pIn, pOut);
949 }
950 else
951 {
952 returnCode = ADDR_ERROR;
953 }
954
955 return returnCode;
956 }
957
958 /**
959 ****************************************************************************************************
960 * AddrConvertTileIndex1
961 *
962 * @brief
963 * Convert tile index to tile mode/type/info
964 *
965 * @return
966 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
967 ****************************************************************************************************
968 */
AddrConvertTileIndex1(ADDR_HANDLE hLib,const ADDR_CONVERT_TILEINDEX1_INPUT * pIn,ADDR_CONVERT_TILEINDEX_OUTPUT * pOut)969 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
970 ADDR_HANDLE hLib, ///< address lib handle
971 const ADDR_CONVERT_TILEINDEX1_INPUT* pIn, ///< [in] input - tile index
972 ADDR_CONVERT_TILEINDEX_OUTPUT* pOut) ///< [out] tile mode/type/info
973 {
974 V1::Lib* pLib = V1::Lib::GetLib(hLib);
975
976 ADDR_E_RETURNCODE returnCode = ADDR_OK;
977
978 if (pLib != NULL)
979 {
980 returnCode = pLib->ConvertTileIndex1(pIn, pOut);
981 }
982 else
983 {
984 returnCode = ADDR_ERROR;
985 }
986
987 return returnCode;
988 }
989
990 /**
991 ****************************************************************************************************
992 * AddrGetTileIndex
993 *
994 * @brief
995 * Get tile index from tile mode/type/info
996 *
997 * @return
998 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
999 *
1000 * @note
1001 * Only meaningful for SI (and above)
1002 ****************************************************************************************************
1003 */
AddrGetTileIndex(ADDR_HANDLE hLib,const ADDR_GET_TILEINDEX_INPUT * pIn,ADDR_GET_TILEINDEX_OUTPUT * pOut)1004 ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
1005 ADDR_HANDLE hLib,
1006 const ADDR_GET_TILEINDEX_INPUT* pIn,
1007 ADDR_GET_TILEINDEX_OUTPUT* pOut)
1008 {
1009 V1::Lib* pLib = V1::Lib::GetLib(hLib);
1010
1011 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1012
1013 if (pLib != NULL)
1014 {
1015 returnCode = pLib->GetTileIndex(pIn, pOut);
1016 }
1017 else
1018 {
1019 returnCode = ADDR_ERROR;
1020 }
1021
1022 return returnCode;
1023 }
1024
1025 /**
1026 ****************************************************************************************************
1027 * AddrComputePrtInfo
1028 *
1029 * @brief
1030 * Interface function for ComputePrtInfo
1031 *
1032 ****************************************************************************************************
1033 */
AddrComputePrtInfo(ADDR_HANDLE hLib,const ADDR_PRT_INFO_INPUT * pIn,ADDR_PRT_INFO_OUTPUT * pOut)1034 ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
1035 ADDR_HANDLE hLib,
1036 const ADDR_PRT_INFO_INPUT* pIn,
1037 ADDR_PRT_INFO_OUTPUT* pOut)
1038 {
1039 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1040
1041 V1::Lib* pLib = V1::Lib::GetLib(hLib);
1042
1043 if (pLib != NULL)
1044 {
1045 returnCode = pLib->ComputePrtInfo(pIn, pOut);
1046 }
1047 else
1048 {
1049 returnCode = ADDR_ERROR;
1050 }
1051
1052 return returnCode;
1053 }
1054
1055 /**
1056 ****************************************************************************************************
1057 * AddrGetMaxAlignments
1058 *
1059 * @brief
1060 * Convert maximum alignments
1061 *
1062 * @return
1063 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1064 ****************************************************************************************************
1065 */
AddrGetMaxAlignments(ADDR_HANDLE hLib,ADDR_GET_MAX_ALIGNMENTS_OUTPUT * pOut)1066 ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
1067 ADDR_HANDLE hLib, ///< address lib handle
1068 ADDR_GET_MAX_ALIGNMENTS_OUTPUT* pOut) ///< [out] output structure
1069 {
1070 Addr::Lib* pLib = Lib::GetLib(hLib);
1071
1072 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1073
1074 if (pLib != NULL)
1075 {
1076 returnCode = pLib->GetMaxAlignments(pOut);
1077 }
1078 else
1079 {
1080 returnCode = ADDR_ERROR;
1081 }
1082
1083 return returnCode;
1084 }
1085
1086 /**
1087 ****************************************************************************************************
1088 * AddrGetMaxMetaAlignments
1089 *
1090 * @brief
1091 * Convert maximum alignments for metadata
1092 *
1093 * @return
1094 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1095 ****************************************************************************************************
1096 */
AddrGetMaxMetaAlignments(ADDR_HANDLE hLib,ADDR_GET_MAX_ALIGNMENTS_OUTPUT * pOut)1097 ADDR_E_RETURNCODE ADDR_API AddrGetMaxMetaAlignments(
1098 ADDR_HANDLE hLib, ///< address lib handle
1099 ADDR_GET_MAX_ALIGNMENTS_OUTPUT* pOut) ///< [out] output structure
1100 {
1101 Addr::Lib* pLib = Lib::GetLib(hLib);
1102
1103 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1104
1105 if (pLib != NULL)
1106 {
1107 returnCode = pLib->GetMaxMetaAlignments(pOut);
1108 }
1109 else
1110 {
1111 returnCode = ADDR_ERROR;
1112 }
1113
1114 return returnCode;
1115 }
1116
1117
1118 ////////////////////////////////////////////////////////////////////////////////////////////////////
1119 // Surface functions for Addr2
1120 ////////////////////////////////////////////////////////////////////////////////////////////////////
1121
1122 /**
1123 ****************************************************************************************************
1124 * Addr2ComputeSurfaceInfo
1125 *
1126 * @brief
1127 * Calculate surface width/height/depth/alignments and suitable tiling mode
1128 *
1129 * @return
1130 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1131 ****************************************************************************************************
1132 */
Addr2ComputeSurfaceInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SURFACE_INFO_INPUT * pIn,ADDR2_COMPUTE_SURFACE_INFO_OUTPUT * pOut)1133 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceInfo(
1134 ADDR_HANDLE hLib, ///< address lib handle
1135 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] surface information
1136 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut) ///< [out] surface parameters and alignments
1137 {
1138 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1139
1140 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1141
1142 if (pLib != NULL)
1143 {
1144 returnCode = pLib->ComputeSurfaceInfo(pIn, pOut);
1145 }
1146 else
1147 {
1148 returnCode = ADDR_ERROR;
1149 }
1150
1151 return returnCode;
1152 }
1153
1154
1155 /**
1156 ****************************************************************************************************
1157 * Addr2ComputeSurfaceAddrFromCoord
1158 *
1159 * @brief
1160 * Compute surface address according to coordinates
1161 *
1162 * @return
1163 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1164 ****************************************************************************************************
1165 */
Addr2ComputeSurfaceAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT * pOut)1166 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceAddrFromCoord(
1167 ADDR_HANDLE hLib, ///< address lib handle
1168 const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] surface info and coordinates
1169 ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] surface address
1170 {
1171 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1172
1173 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1174
1175 if (pLib != NULL)
1176 {
1177 returnCode = pLib->ComputeSurfaceAddrFromCoord(pIn, pOut);
1178 }
1179 else
1180 {
1181 returnCode = ADDR_ERROR;
1182 }
1183
1184 return returnCode;
1185 }
1186
1187
1188 /**
1189 ****************************************************************************************************
1190 * Addr2ComputeSurfaceCoordFromAddr
1191 *
1192 * @brief
1193 * Compute coordinates according to surface address
1194 *
1195 * @return
1196 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1197 ****************************************************************************************************
1198 */
Addr2ComputeSurfaceCoordFromAddr(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT * pOut)1199 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceCoordFromAddr(
1200 ADDR_HANDLE hLib, ///< address lib handle
1201 const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] surface info and address
1202 ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) ///< [out] coordinates
1203 {
1204 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1205
1206 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1207
1208 if (pLib != NULL)
1209 {
1210 returnCode = pLib->ComputeSurfaceCoordFromAddr(pIn, pOut);
1211 }
1212 else
1213 {
1214 returnCode = ADDR_ERROR;
1215 }
1216
1217 return returnCode;
1218 }
1219
1220
1221
1222 ////////////////////////////////////////////////////////////////////////////////////////////////////
1223 // HTile functions for Addr2
1224 ////////////////////////////////////////////////////////////////////////////////////////////////////
1225
1226 /**
1227 ****************************************************************************************************
1228 * Addr2ComputeHtileInfo
1229 *
1230 * @brief
1231 * Compute Htile pitch, height, base alignment and size in bytes
1232 *
1233 * @return
1234 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1235 ****************************************************************************************************
1236 */
Addr2ComputeHtileInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_HTILE_INFO_INPUT * pIn,ADDR2_COMPUTE_HTILE_INFO_OUTPUT * pOut)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
1241 {
1242 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1243
1244 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1245
1246 if (pLib != NULL)
1247 {
1248 returnCode = pLib->ComputeHtileInfo(pIn, pOut);
1249 }
1250 else
1251 {
1252 returnCode = ADDR_ERROR;
1253 }
1254
1255 return returnCode;
1256 }
1257
1258
1259 /**
1260 ****************************************************************************************************
1261 * Addr2ComputeHtileAddrFromCoord
1262 *
1263 * @brief
1264 * Compute Htile address according to coordinates (of depth buffer)
1265 *
1266 * @return
1267 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1268 ****************************************************************************************************
1269 */
Addr2ComputeHtileAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT * pOut)1270 ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileAddrFromCoord(
1271 ADDR_HANDLE hLib, ///< address lib handle
1272 const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] Htile info and coordinates
1273 ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Htile address
1274 {
1275 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1276
1277 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1278
1279 if (pLib != NULL)
1280 {
1281 returnCode = pLib->ComputeHtileAddrFromCoord(pIn, pOut);
1282 }
1283 else
1284 {
1285 returnCode = ADDR_ERROR;
1286 }
1287
1288 return returnCode;
1289 }
1290
1291
1292 /**
1293 ****************************************************************************************************
1294 * Addr2ComputeHtileCoordFromAddr
1295 *
1296 * @brief
1297 * Compute coordinates within depth buffer (1st pixel of a micro tile) according to
1298 * Htile address
1299 *
1300 * @return
1301 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1302 ****************************************************************************************************
1303 */
Addr2ComputeHtileCoordFromAddr(ADDR_HANDLE hLib,const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT * pOut)1304 ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileCoordFromAddr(
1305 ADDR_HANDLE hLib, ///< address lib handle
1306 const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] Htile info and address
1307 ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) ///< [out] Htile coordinates
1308 {
1309 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1310
1311 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1312
1313 if (pLib != NULL)
1314 {
1315 returnCode = pLib->ComputeHtileCoordFromAddr(pIn, pOut);
1316 }
1317 else
1318 {
1319 returnCode = ADDR_ERROR;
1320 }
1321
1322 return returnCode;
1323 }
1324
1325
1326
1327 ////////////////////////////////////////////////////////////////////////////////////////////////////
1328 // C-mask functions for Addr2
1329 ////////////////////////////////////////////////////////////////////////////////////////////////////
1330
1331 /**
1332 ****************************************************************************************************
1333 * Addr2ComputeCmaskInfo
1334 *
1335 * @brief
1336 * Compute Cmask pitch, height, base alignment and size in bytes from color buffer
1337 * info
1338 *
1339 * @return
1340 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1341 ****************************************************************************************************
1342 */
Addr2ComputeCmaskInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_CMASK_INFO_INPUT * pIn,ADDR2_COMPUTE_CMASK_INFO_OUTPUT * pOut)1343 ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskInfo(
1344 ADDR_HANDLE hLib, ///< address lib handle
1345 const ADDR2_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] Cmask pitch and height
1346 ADDR2_COMPUTE_CMASK_INFO_OUTPUT* pOut) ///< [out] Cmask pitch, height and size in bytes
1347 {
1348 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1349
1350 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1351
1352 if (pLib != NULL)
1353 {
1354 returnCode = pLib->ComputeCmaskInfo(pIn, pOut);
1355 }
1356 else
1357 {
1358 returnCode = ADDR_ERROR;
1359 }
1360
1361 return returnCode;
1362 }
1363
1364
1365 /**
1366 ****************************************************************************************************
1367 * Addr2ComputeCmaskAddrFromCoord
1368 *
1369 * @brief
1370 * Compute Cmask address according to coordinates (of MSAA color buffer)
1371 *
1372 * @return
1373 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1374 ****************************************************************************************************
1375 */
Addr2ComputeCmaskAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT * pOut)1376 ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskAddrFromCoord(
1377 ADDR_HANDLE hLib, ///< address lib handle
1378 const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Cmask info and coordinates
1379 ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Cmask address
1380 {
1381 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1382
1383 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1384
1385 if (pLib != NULL)
1386 {
1387 returnCode = pLib->ComputeCmaskAddrFromCoord(pIn, pOut);
1388 }
1389 else
1390 {
1391 returnCode = ADDR_ERROR;
1392 }
1393
1394 return returnCode;
1395 }
1396
1397
1398 /**
1399 ****************************************************************************************************
1400 * Addr2ComputeCmaskCoordFromAddr
1401 *
1402 * @brief
1403 * Compute coordinates within color buffer (1st pixel of a micro tile) according to
1404 * Cmask address
1405 *
1406 * @return
1407 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1408 ****************************************************************************************************
1409 */
Addr2ComputeCmaskCoordFromAddr(ADDR_HANDLE hLib,const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT * pOut)1410 ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskCoordFromAddr(
1411 ADDR_HANDLE hLib, ///< address lib handle
1412 const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Cmask info and address
1413 ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Cmask coordinates
1414 {
1415 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1416
1417 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1418
1419 if (pLib != NULL)
1420 {
1421 returnCode = pLib->ComputeCmaskCoordFromAddr(pIn, pOut);
1422 }
1423 else
1424 {
1425 returnCode = ADDR_ERROR;
1426 }
1427
1428 return returnCode;
1429 }
1430
1431
1432
1433 ////////////////////////////////////////////////////////////////////////////////////////////////////
1434 // F-mask functions for Addr2
1435 ////////////////////////////////////////////////////////////////////////////////////////////////////
1436
1437 /**
1438 ****************************************************************************************************
1439 * Addr2ComputeFmaskInfo
1440 *
1441 * @brief
1442 * Compute Fmask pitch/height/depth/alignments and size in bytes
1443 *
1444 * @return
1445 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1446 ****************************************************************************************************
1447 */
Addr2ComputeFmaskInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_FMASK_INFO_INPUT * pIn,ADDR2_COMPUTE_FMASK_INFO_OUTPUT * pOut)1448 ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskInfo(
1449 ADDR_HANDLE hLib, ///< address lib handle
1450 const ADDR2_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] Fmask information
1451 ADDR2_COMPUTE_FMASK_INFO_OUTPUT* pOut) ///< [out] Fmask pitch and height
1452 {
1453 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1454
1455 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1456
1457 if (pLib != NULL)
1458 {
1459 returnCode = pLib->ComputeFmaskInfo(pIn, pOut);
1460 }
1461 else
1462 {
1463 returnCode = ADDR_ERROR;
1464 }
1465
1466 return returnCode;
1467 }
1468
1469
1470 /**
1471 ****************************************************************************************************
1472 * Addr2ComputeFmaskAddrFromCoord
1473 *
1474 * @brief
1475 * Compute Fmask address according to coordinates (x,y,slice,sample,plane)
1476 *
1477 * @return
1478 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1479 ****************************************************************************************************
1480 */
Addr2ComputeFmaskAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT * pOut)1481 ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskAddrFromCoord(
1482 ADDR_HANDLE hLib, ///< address lib handle
1483 const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Fmask info and coordinates
1484 ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Fmask address
1485 {
1486 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1487
1488 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1489
1490 if (pLib != NULL)
1491 {
1492 returnCode = pLib->ComputeFmaskAddrFromCoord(pIn, pOut);
1493 }
1494 else
1495 {
1496 returnCode = ADDR_ERROR;
1497 }
1498
1499 return returnCode;
1500 }
1501
1502
1503 /**
1504 ****************************************************************************************************
1505 * Addr2ComputeFmaskCoordFromAddr
1506 *
1507 * @brief
1508 * Compute coordinates (x,y,slice,sample,plane) according to Fmask address
1509 *
1510 * @return
1511 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1512 ****************************************************************************************************
1513 */
Addr2ComputeFmaskCoordFromAddr(ADDR_HANDLE hLib,const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT * pOut)1514 ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskCoordFromAddr(
1515 ADDR_HANDLE hLib, ///< address lib handle
1516 const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Fmask info and address
1517 ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Fmask coordinates
1518 {
1519 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1520
1521 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1522
1523 if (pLib != NULL)
1524 {
1525 returnCode = pLib->ComputeFmaskCoordFromAddr(pIn, pOut);
1526 }
1527 else
1528 {
1529 returnCode = ADDR_ERROR;
1530 }
1531
1532 return returnCode;
1533 }
1534
1535
1536
1537 ////////////////////////////////////////////////////////////////////////////////////////////////////
1538 // DCC key functions for Addr2
1539 ////////////////////////////////////////////////////////////////////////////////////////////////////
1540
1541 /**
1542 ****************************************************************************************************
1543 * Addr2ComputeDccInfo
1544 *
1545 * @brief
1546 * Compute DCC key size, base alignment based on color surface size, tile info or tile index
1547 *
1548 ****************************************************************************************************
1549 */
Addr2ComputeDccInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_DCCINFO_INPUT * pIn,ADDR2_COMPUTE_DCCINFO_OUTPUT * pOut)1550 ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccInfo(
1551 ADDR_HANDLE hLib, ///< handle of addrlib
1552 const ADDR2_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input
1553 ADDR2_COMPUTE_DCCINFO_OUTPUT* pOut) ///< [out] output
1554 {
1555 ADDR_E_RETURNCODE returnCode;
1556
1557 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1558
1559 if (pLib != NULL)
1560 {
1561 returnCode = pLib->ComputeDccInfo(pIn, pOut);
1562 }
1563 else
1564 {
1565 returnCode = ADDR_ERROR;
1566 }
1567
1568 return returnCode;
1569 }
1570
1571 /**
1572 ****************************************************************************************************
1573 * Addr2ComputeDccAddrFromCoord
1574 *
1575 * @brief
1576 * Compute DCC key address according to coordinates
1577 *
1578 * @return
1579 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1580 ****************************************************************************************************
1581 */
Addr2ComputeDccAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT * pOut)1582 ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccAddrFromCoord(
1583 ADDR_HANDLE hLib, ///< address lib handle
1584 const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT* pIn, ///< [in] Dcc info and coordinates
1585 ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Dcc address
1586 {
1587 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1588
1589 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1590
1591 if (pLib != NULL)
1592 {
1593 returnCode = pLib->ComputeDccAddrFromCoord(pIn, pOut);
1594 }
1595 else
1596 {
1597 returnCode = ADDR_ERROR;
1598 }
1599
1600 return returnCode;
1601 }
1602
1603 /**
1604 ****************************************************************************************************
1605 * Addr2ComputePipeBankXor
1606 *
1607 * @brief
1608 * Calculate a valid bank pipe xor value for client to use.
1609 ****************************************************************************************************
1610 */
Addr2ComputePipeBankXor(ADDR_HANDLE hLib,const ADDR2_COMPUTE_PIPEBANKXOR_INPUT * pIn,ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT * pOut)1611 ADDR_E_RETURNCODE ADDR_API Addr2ComputePipeBankXor(
1612 ADDR_HANDLE hLib, ///< handle of addrlib
1613 const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn, ///< [in] input
1614 ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut) ///< [out] output
1615 {
1616 ADDR_E_RETURNCODE returnCode;
1617
1618 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1619
1620 if (pLib != NULL)
1621 {
1622 returnCode = pLib->ComputePipeBankXor(pIn, pOut);
1623 }
1624 else
1625 {
1626 returnCode = ADDR_ERROR;
1627 }
1628
1629 return returnCode;
1630 }
1631
1632 /**
1633 ****************************************************************************************************
1634 * Addr2ComputeSlicePipeBankXor
1635 *
1636 * @brief
1637 * Calculate slice pipe bank xor value based on base pipe bank xor and slice id.
1638 ****************************************************************************************************
1639 */
Addr2ComputeSlicePipeBankXor(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT * pIn,ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT * pOut)1640 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSlicePipeBankXor(
1641 ADDR_HANDLE hLib, ///< handle of addrlib
1642 const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn, ///< [in] input
1643 ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut) ///< [out] output
1644 {
1645 ADDR_E_RETURNCODE returnCode;
1646
1647 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1648
1649 if (pLib != NULL)
1650 {
1651 returnCode = pLib->ComputeSlicePipeBankXor(pIn, pOut);
1652 }
1653 else
1654 {
1655 returnCode = ADDR_ERROR;
1656 }
1657
1658 return returnCode;
1659 }
1660
1661 /**
1662 ****************************************************************************************************
1663 * Addr2ComputeSubResourceOffsetForSwizzlePattern
1664 *
1665 * @brief
1666 * Calculate sub resource offset for swizzle pattern.
1667 ****************************************************************************************************
1668 */
Addr2ComputeSubResourceOffsetForSwizzlePattern(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT * pIn,ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT * pOut)1669 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSubResourceOffsetForSwizzlePattern(
1670 ADDR_HANDLE hLib, ///< handle of addrlib
1671 const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn, ///< [in] input
1672 ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut) ///< [out] output
1673 {
1674 ADDR_E_RETURNCODE returnCode;
1675
1676 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1677
1678 if (pLib != NULL)
1679 {
1680 returnCode = pLib->ComputeSubResourceOffsetForSwizzlePattern(pIn, pOut);
1681 }
1682 else
1683 {
1684 returnCode = ADDR_ERROR;
1685 }
1686
1687 return returnCode;
1688 }
1689
1690 /**
1691 ****************************************************************************************************
1692 * Addr2ComputeNonBlockCompressedView
1693 *
1694 * @brief
1695 * Compute non-block-compressed view for a given mipmap level/slice.
1696 ****************************************************************************************************
1697 */
Addr2ComputeNonBlockCompressedView(ADDR_HANDLE hLib,const ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT * pIn,ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT * pOut)1698 ADDR_E_RETURNCODE ADDR_API Addr2ComputeNonBlockCompressedView(
1699 ADDR_HANDLE hLib, ///< handle of addrlib
1700 const ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT* pIn, ///< [in] input
1701 ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT* pOut) ///< [out] output
1702 {
1703 ADDR_E_RETURNCODE returnCode;
1704
1705 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1706
1707 if (pLib != NULL)
1708 {
1709 returnCode = pLib->ComputeNonBlockCompressedView(pIn, pOut);
1710 }
1711 else
1712 {
1713 returnCode = ADDR_ERROR;
1714 }
1715
1716 return returnCode;
1717 }
1718
1719 /**
1720 ****************************************************************************************************
1721 * Addr2GetPreferredSurfaceSetting
1722 *
1723 * @brief
1724 * Suggest a preferred setting for client driver to program HW register
1725 ****************************************************************************************************
1726 */
Addr2GetPreferredSurfaceSetting(ADDR_HANDLE hLib,const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT * pIn,ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT * pOut)1727 ADDR_E_RETURNCODE ADDR_API Addr2GetPreferredSurfaceSetting(
1728 ADDR_HANDLE hLib, ///< handle of addrlib
1729 const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn, ///< [in] input
1730 ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) ///< [out] output
1731 {
1732 ADDR_E_RETURNCODE returnCode;
1733
1734 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1735
1736 if (pLib != NULL)
1737 {
1738 returnCode = pLib->Addr2GetPreferredSurfaceSetting(pIn, pOut);
1739 }
1740 else
1741 {
1742 returnCode = ADDR_ERROR;
1743 }
1744
1745 return returnCode;
1746 }
1747
1748 /**
1749 ****************************************************************************************************
1750 * Addr2IsValidDisplaySwizzleMode
1751 *
1752 * @brief
1753 * Return whether the swizzle mode is supported by display engine
1754 ****************************************************************************************************
1755 */
Addr2IsValidDisplaySwizzleMode(ADDR_HANDLE hLib,AddrSwizzleMode swizzleMode,UINT_32 bpp,BOOL_32 * pResult)1756 ADDR_E_RETURNCODE ADDR_API Addr2IsValidDisplaySwizzleMode(
1757 ADDR_HANDLE hLib,
1758 AddrSwizzleMode swizzleMode,
1759 UINT_32 bpp,
1760 BOOL_32 *pResult)
1761 {
1762 ADDR_E_RETURNCODE returnCode;
1763
1764 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1765
1766 if (pLib != NULL)
1767 {
1768 ADDR2_COMPUTE_SURFACE_INFO_INPUT in = {};
1769 in.resourceType = ADDR_RSRC_TEX_2D;
1770 in.swizzleMode = swizzleMode;
1771 in.bpp = bpp;
1772
1773 *pResult = pLib->IsValidDisplaySwizzleMode(&in);
1774 returnCode = ADDR_OK;
1775 }
1776 else
1777 {
1778 returnCode = ADDR_ERROR;
1779 }
1780
1781 return returnCode;
1782 }
1783
1784 /**
1785 ****************************************************************************************************
1786 * Addr2GetPossibleSwizzleModes
1787 *
1788 * @brief
1789 * Returns a list of swizzle modes that are valid from the hardware's perspective for the
1790 * client to choose from
1791 ****************************************************************************************************
1792 */
Addr2GetPossibleSwizzleModes(ADDR_HANDLE hLib,const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT * pIn,ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT * pOut)1793 ADDR_E_RETURNCODE ADDR_API Addr2GetPossibleSwizzleModes(
1794 ADDR_HANDLE hLib, ///< handle of addrlib
1795 const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn, ///< [in] input
1796 ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) ///< [out] output
1797 {
1798 ADDR_E_RETURNCODE returnCode;
1799
1800 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1801
1802 if (pLib != NULL)
1803 {
1804 returnCode = pLib->GetPossibleSwizzleModes(pIn, pOut);
1805 }
1806 else
1807 {
1808 returnCode = ADDR_ERROR;
1809 }
1810
1811 return returnCode;
1812 }
1813 /**
1814 ****************************************************************************************************
1815 * Addr2GetAllowedBlockSet
1816 *
1817 * @brief
1818 * Returns the set of allowed block sizes given the allowed swizzle modes and resource type
1819 ****************************************************************************************************
1820 */
Addr2GetAllowedBlockSet(ADDR_HANDLE hLib,ADDR2_SWMODE_SET allowedSwModeSet,AddrResourceType rsrcType,ADDR2_BLOCK_SET * pAllowedBlockSet)1821 ADDR_E_RETURNCODE ADDR_API Addr2GetAllowedBlockSet(
1822 ADDR_HANDLE hLib, ///< handle of addrlib
1823 ADDR2_SWMODE_SET allowedSwModeSet, ///< [in] allowed swizzle modes
1824 AddrResourceType rsrcType, ///< [in] resource type
1825 ADDR2_BLOCK_SET* pAllowedBlockSet) ///< [out] allowed block sizes
1826 {
1827 ADDR_E_RETURNCODE returnCode;
1828
1829 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1830
1831 if (pLib != NULL)
1832 {
1833 returnCode = pLib->GetAllowedBlockSet(allowedSwModeSet, rsrcType, pAllowedBlockSet);
1834 }
1835 else
1836 {
1837 returnCode = ADDR_ERROR;
1838 }
1839
1840 return returnCode;
1841 }
1842
1843 /**
1844 ****************************************************************************************************
1845 * Addr2GetAllowedSwSet
1846 *
1847 * @brief
1848 * Returns the set of allowed swizzle types given the allowed swizzle modes
1849 ****************************************************************************************************
1850 */
Addr2GetAllowedSwSet(ADDR_HANDLE hLib,ADDR2_SWMODE_SET allowedSwModeSet,ADDR2_SWTYPE_SET * pAllowedSwSet)1851 ADDR_E_RETURNCODE ADDR_API Addr2GetAllowedSwSet(
1852 ADDR_HANDLE hLib, ///< handle of addrlib
1853 ADDR2_SWMODE_SET allowedSwModeSet, ///< [in] allowed swizzle modes
1854 ADDR2_SWTYPE_SET* pAllowedSwSet) ///< [out] allowed swizzle types
1855 {
1856 ADDR_E_RETURNCODE returnCode;
1857
1858 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1859
1860 if (pLib != NULL)
1861 {
1862 returnCode = pLib->GetAllowedSwSet(allowedSwModeSet, pAllowedSwSet);
1863 }
1864 else
1865 {
1866 returnCode = ADDR_ERROR;
1867 }
1868
1869 return returnCode;
1870 }
1871
1872 /**
1873 ****************************************************************************************************
1874 * Addr2IsBlockTypeAvailable
1875 *
1876 * @brief
1877 * Determine whether a block type is allowed in a given blockSet
1878 ****************************************************************************************************
1879 */
Addr2IsBlockTypeAvailable(ADDR2_BLOCK_SET blockSet,AddrBlockType blockType)1880 BOOL_32 Addr2IsBlockTypeAvailable(
1881 ADDR2_BLOCK_SET blockSet,
1882 AddrBlockType blockType)
1883 {
1884 BOOL_32 avail;
1885
1886 if (blockType == AddrBlockLinear)
1887 {
1888 avail = blockSet.linear ? TRUE : FALSE;
1889 }
1890 else
1891 {
1892 avail = blockSet.value & (1 << (static_cast<UINT_32>(blockType) - 1)) ? TRUE : FALSE;
1893 }
1894
1895 return avail;
1896 }
1897
1898 /**
1899 ****************************************************************************************************
1900 * Addr2BlockTypeWithinMemoryBudget
1901 *
1902 * @brief
1903 * Determine whether a new block type is acceptable based on memory waste ratio. Will favor
1904 * larger block types.
1905 ****************************************************************************************************
1906 */
Addr2BlockTypeWithinMemoryBudget(UINT_64 minSize,UINT_64 newBlockTypeSize,UINT_32 ratioLow,UINT_32 ratioHi,DOUBLE memoryBudget,BOOL_32 newBlockTypeBigger)1907 BOOL_32 Addr2BlockTypeWithinMemoryBudget(
1908 UINT_64 minSize,
1909 UINT_64 newBlockTypeSize,
1910 UINT_32 ratioLow,
1911 UINT_32 ratioHi,
1912 DOUBLE memoryBudget,
1913 BOOL_32 newBlockTypeBigger)
1914 {
1915 BOOL_32 accept = FALSE;
1916
1917 if (memoryBudget >= 1.0)
1918 {
1919 if (newBlockTypeBigger)
1920 {
1921 if ((static_cast<DOUBLE>(newBlockTypeSize) / minSize) <= memoryBudget)
1922 {
1923 accept = TRUE;
1924 }
1925 }
1926 else
1927 {
1928 if ((static_cast<DOUBLE>(minSize) / newBlockTypeSize) > memoryBudget)
1929 {
1930 accept = TRUE;
1931 }
1932 }
1933 }
1934 else
1935 {
1936 if (newBlockTypeBigger)
1937 {
1938 if ((newBlockTypeSize * ratioHi) <= (minSize * ratioLow))
1939 {
1940 accept = TRUE;
1941 }
1942 }
1943 else
1944 {
1945 if ((newBlockTypeSize * ratioLow) < (minSize * ratioHi))
1946 {
1947 accept = TRUE;
1948 }
1949 }
1950 }
1951
1952 return accept;
1953 }
1954