2 * Copyright © 2014 Advanced Micro Devices, Inc.
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sub license, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
15 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16 * NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
17 * AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20 * USE OR OTHER DEALINGS IN THE SOFTWARE.
22 * The above copyright notice and this permission notice (including the
23 * next paragraph) shall be included in all copies or substantial portions
28 ****************************************************************************************************
30 * @brief Contains the implementation for the Addr::Lib class.
31 ****************************************************************************************************
34 #include "addrinterface.h"
36 #include "addrcommon.h"
38 #if defined(__APPLE__)
40 UINT_32
div64_32(UINT_64 n
, UINT_32 base
)
45 UINT_32 high
= rem
>> 32;
51 res
= (UINT_64
) high
<< 32;
52 rem
-= (UINT_64
) (high
* base
) << 32;
55 while (((INT_64
)b
> 0) && (b
< rem
))
77 UINT_32
__umoddi3(UINT_64 n
, UINT_32 base
)
79 return div64_32(n
, base
);
87 ////////////////////////////////////////////////////////////////////////////////////////////////////
88 // Constructor/Destructor
89 ////////////////////////////////////////////////////////////////////////////////////////////////////
92 ****************************************************************************************************
96 * Constructor for the AddrLib class
98 ****************************************************************************************************
101 m_class(BASE_ADDRLIB
),
102 m_chipFamily(ADDR_CHIP_FAMILY_IVLD
),
104 m_version(ADDRLIB_VERSION
),
107 m_pipeInterleaveBytes(0),
109 m_minPitchAlignPixels(1),
113 m_configFlags
.value
= 0;
117 ****************************************************************************************************
121 * Constructor for the AddrLib class with hClient as parameter
123 ****************************************************************************************************
125 Lib::Lib(const Client
* pClient
) :
127 m_class(BASE_ADDRLIB
),
128 m_chipFamily(ADDR_CHIP_FAMILY_IVLD
),
130 m_version(ADDRLIB_VERSION
),
133 m_pipeInterleaveBytes(0),
135 m_minPitchAlignPixels(1),
139 m_configFlags
.value
= 0;
143 ****************************************************************************************************
147 * Destructor for the AddrLib class
149 ****************************************************************************************************
161 ////////////////////////////////////////////////////////////////////////////////////////////////////
162 // Initialization/Helper
163 ////////////////////////////////////////////////////////////////////////////////////////////////////
166 ****************************************************************************************************
170 * Creates and initializes AddrLib object.
174 ****************************************************************************************************
176 ADDR_E_RETURNCODE
Lib::Create(
177 const ADDR_CREATE_INPUT
* pCreateIn
, ///< [in] pointer to ADDR_CREATE_INPUT
178 ADDR_CREATE_OUTPUT
* pCreateOut
) ///< [out] pointer to ADDR_CREATE_OUTPUT
181 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
183 if (pCreateIn
->createFlags
.fillSizeFields
== TRUE
)
185 if ((pCreateIn
->size
!= sizeof(ADDR_CREATE_INPUT
)) ||
186 (pCreateOut
->size
!= sizeof(ADDR_CREATE_OUTPUT
)))
188 returnCode
= ADDR_PARAMSIZEMISMATCH
;
192 if ((returnCode
== ADDR_OK
) &&
193 (pCreateIn
->callbacks
.allocSysMem
!= NULL
) &&
194 (pCreateIn
->callbacks
.freeSysMem
!= NULL
))
201 switch (pCreateIn
->chipEngine
)
203 case CIASICIDGFXENGINE_SOUTHERNISLAND
:
204 switch (pCreateIn
->chipFamily
)
207 pLib
= SiHwlInit(&client
);
210 case FAMILY_CZ
: // VI based fusion(carrizo)
212 case FAMILY_KV
: // CI based fusion
213 pLib
= CiHwlInit(&client
);
216 ADDR_ASSERT_ALWAYS();
220 case CIASICIDGFXENGINE_ARCTICISLAND
:
221 switch (pCreateIn
->chipFamily
)
225 pLib
= Gfx9HwlInit(&client
);
228 ADDR_ASSERT_ALWAYS();
233 ADDR_ASSERT_ALWAYS();
242 // Pass createFlags to configFlags first since these flags may be overwritten
243 pLib
->m_configFlags
.noCubeMipSlicesPad
= pCreateIn
->createFlags
.noCubeMipSlicesPad
;
244 pLib
->m_configFlags
.fillSizeFields
= pCreateIn
->createFlags
.fillSizeFields
;
245 pLib
->m_configFlags
.useTileIndex
= pCreateIn
->createFlags
.useTileIndex
;
246 pLib
->m_configFlags
.useCombinedSwizzle
= pCreateIn
->createFlags
.useCombinedSwizzle
;
247 pLib
->m_configFlags
.checkLast2DLevel
= pCreateIn
->createFlags
.checkLast2DLevel
;
248 pLib
->m_configFlags
.useHtileSliceAlign
= pCreateIn
->createFlags
.useHtileSliceAlign
;
249 pLib
->m_configFlags
.allowLargeThickTile
= pCreateIn
->createFlags
.allowLargeThickTile
;
250 pLib
->m_configFlags
.disableLinearOpt
= FALSE
;
252 pLib
->SetChipFamily(pCreateIn
->chipFamily
, pCreateIn
->chipRevision
);
254 pLib
->SetMinPitchAlignPixels(pCreateIn
->minPitchAlignPixels
);
256 // Global parameters initialized and remaining configFlags bits are set as well
257 initValid
= pLib
->HwlInitGlobalParams(pCreateIn
);
261 pLib
->m_pElemLib
= ElemLib::Create(pLib
);
265 pLib
->m_pElemLib
= NULL
; // Don't go on allocating element lib
266 returnCode
= ADDR_INVALIDGBREGVALUES
;
269 if (pLib
->m_pElemLib
== NULL
)
273 ADDR_ASSERT_ALWAYS();
277 pLib
->m_pElemLib
->SetConfigFlags(pLib
->m_configFlags
);
281 pCreateOut
->hLib
= pLib
;
283 if ((pLib
!= NULL
) &&
284 (returnCode
== ADDR_OK
))
286 pCreateOut
->numEquations
=
287 pLib
->HwlGetEquationTableInfo(&pCreateOut
->pEquationTable
);
289 pLib
->SetMaxAlignments();
292 else if ((pLib
== NULL
) &&
293 (returnCode
== ADDR_OK
))
295 // Unknown failures, we return the general error code
296 returnCode
= ADDR_ERROR
;
303 ****************************************************************************************************
307 * Convert familyID defined in atiid.h to ChipFamily and set m_chipFamily/m_chipRevision
310 ****************************************************************************************************
312 VOID
Lib::SetChipFamily(
313 UINT_32 uChipFamily
, ///< [in] chip family defined in atiih.h
314 UINT_32 uChipRevision
) ///< [in] chip revision defined in "asic_family"_id.h
316 ChipFamily family
= HwlConvertChipFamily(uChipFamily
, uChipRevision
);
318 ADDR_ASSERT(family
!= ADDR_CHIP_FAMILY_IVLD
);
320 m_chipFamily
= family
;
321 m_chipRevision
= uChipRevision
;
325 ****************************************************************************************************
326 * Lib::SetMinPitchAlignPixels
329 * Set m_minPitchAlignPixels with input param
333 ****************************************************************************************************
335 VOID
Lib::SetMinPitchAlignPixels(
336 UINT_32 minPitchAlignPixels
) ///< [in] minmum pitch alignment in pixels
338 m_minPitchAlignPixels
= (minPitchAlignPixels
== 0) ? 1 : minPitchAlignPixels
;
342 ****************************************************************************************************
343 * Lib::SetMaxAlignments
350 ****************************************************************************************************
352 VOID
Lib::SetMaxAlignments()
354 m_maxBaseAlign
= HwlComputeMaxBaseAlignments();
355 m_maxMetaBaseAlign
= HwlComputeMaxMetaBaseAlignments();
359 ****************************************************************************************************
363 * Get AddrLib pointer
366 * An AddrLib class pointer
367 ****************************************************************************************************
370 ADDR_HANDLE hLib
) ///< [in] handle of ADDR_HANDLE
372 return static_cast<Addr::Lib
*>(hLib
);
376 ****************************************************************************************************
377 * Lib::GetMaxAlignments
380 * Gets maximum alignments for data surface (include FMask)
384 ****************************************************************************************************
386 ADDR_E_RETURNCODE
Lib::GetMaxAlignments(
387 ADDR_GET_MAX_ALINGMENTS_OUTPUT
* pOut
///< [out] output structure
390 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
392 if (GetFillSizeFieldsFlags() == TRUE
)
394 if (pOut
->size
!= sizeof(ADDR_GET_MAX_ALINGMENTS_OUTPUT
))
396 returnCode
= ADDR_PARAMSIZEMISMATCH
;
400 if (returnCode
== ADDR_OK
)
402 if (m_maxBaseAlign
!= 0)
404 pOut
->baseAlign
= m_maxBaseAlign
;
408 returnCode
= ADDR_NOTIMPLEMENTED
;
416 ****************************************************************************************************
417 * Lib::GetMaxMetaAlignments
420 * Gets maximum alignments for metadata (CMask, DCC and HTile)
424 ****************************************************************************************************
426 ADDR_E_RETURNCODE
Lib::GetMaxMetaAlignments(
427 ADDR_GET_MAX_ALINGMENTS_OUTPUT
* pOut
///< [out] output structure
430 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
432 if (GetFillSizeFieldsFlags() == TRUE
)
434 if (pOut
->size
!= sizeof(ADDR_GET_MAX_ALINGMENTS_OUTPUT
))
436 returnCode
= ADDR_PARAMSIZEMISMATCH
;
440 if (returnCode
== ADDR_OK
)
442 if (m_maxMetaBaseAlign
!= 0)
444 pOut
->baseAlign
= m_maxMetaBaseAlign
;
448 returnCode
= ADDR_NOTIMPLEMENTED
;
456 ****************************************************************************************************
460 * Cat a array of binary bit to a number
463 * The number combined with the array of bits
464 ****************************************************************************************************
466 UINT_32
Lib::Bits2Number(
467 UINT_32 bitNum
, ///< [in] how many bits
468 ...) ///< [in] varaible bits value starting from MSB
474 va_start(bits_ptr
, bitNum
);
476 for(i
= 0; i
< bitNum
; i
++)
478 number
|= va_arg(bits_ptr
, UINT_32
);
490 ////////////////////////////////////////////////////////////////////////////////////////////////////
492 ////////////////////////////////////////////////////////////////////////////////////////////////////
496 ****************************************************************************************************
497 * Lib::Flt32ToColorPixel
500 * Convert a FLT_32 value to a depth/stencil pixel value
503 ****************************************************************************************************
505 ADDR_E_RETURNCODE
Lib::Flt32ToDepthPixel(
506 const ELEM_FLT32TODEPTHPIXEL_INPUT
* pIn
,
507 ELEM_FLT32TODEPTHPIXEL_OUTPUT
* pOut
) const
509 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
511 if (GetFillSizeFieldsFlags() == TRUE
)
513 if ((pIn
->size
!= sizeof(ELEM_FLT32TODEPTHPIXEL_INPUT
)) ||
514 (pOut
->size
!= sizeof(ELEM_FLT32TODEPTHPIXEL_OUTPUT
)))
516 returnCode
= ADDR_PARAMSIZEMISMATCH
;
520 if (returnCode
== ADDR_OK
)
522 GetElemLib()->Flt32ToDepthPixel(pIn
->format
, pIn
->comps
, pOut
->pPixel
);
524 UINT_32 depthBase
= 0;
525 UINT_32 stencilBase
= 0;
526 UINT_32 depthBits
= 0;
527 UINT_32 stencilBits
= 0;
534 case ADDR_DEPTH_X8_24
:
535 case ADDR_DEPTH_8_24
:
536 case ADDR_DEPTH_X8_24_FLOAT
:
537 case ADDR_DEPTH_8_24_FLOAT
:
542 case ADDR_DEPTH_32_FLOAT
:
545 case ADDR_DEPTH_X24_8_32_FLOAT
:
554 // Overwrite base since R800 has no "tileBase"
555 if (GetElemLib()->IsDepthStencilTilePlanar() == FALSE
)
564 pOut
->stencilBase
= stencilBase
;
565 pOut
->depthBase
= depthBase
;
566 pOut
->depthBits
= depthBits
;
567 pOut
->stencilBits
= stencilBits
;
574 ****************************************************************************************************
575 * Lib::Flt32ToColorPixel
578 * Convert a FLT_32 value to a red/green/blue/alpha pixel value
581 ****************************************************************************************************
583 ADDR_E_RETURNCODE
Lib::Flt32ToColorPixel(
584 const ELEM_FLT32TOCOLORPIXEL_INPUT
* pIn
,
585 ELEM_FLT32TOCOLORPIXEL_OUTPUT
* pOut
) const
587 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
589 if (GetFillSizeFieldsFlags() == TRUE
)
591 if ((pIn
->size
!= sizeof(ELEM_FLT32TOCOLORPIXEL_INPUT
)) ||
592 (pOut
->size
!= sizeof(ELEM_FLT32TOCOLORPIXEL_OUTPUT
)))
594 returnCode
= ADDR_PARAMSIZEMISMATCH
;
598 if (returnCode
== ADDR_OK
)
600 GetElemLib()->Flt32ToColorPixel(pIn
->format
,
612 ****************************************************************************************************
616 * Check one format can be EXPORT_NUM
618 * TRUE if EXPORT_NORM can be used
619 ****************************************************************************************************
621 BOOL_32
Lib::GetExportNorm(
622 const ELEM_GETEXPORTNORM_INPUT
* pIn
) const
624 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
626 BOOL_32 enabled
= FALSE
;
628 if (GetFillSizeFieldsFlags() == TRUE
)
630 if (pIn
->size
!= sizeof(ELEM_GETEXPORTNORM_INPUT
))
632 returnCode
= ADDR_PARAMSIZEMISMATCH
;
636 if (returnCode
== ADDR_OK
)
638 enabled
= GetElemLib()->PixGetExportNorm(pIn
->format
, pIn
->num
, pIn
->swap
);