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 pLib
= Gfx9HwlInit(&client
);
224 ADDR_ASSERT_ALWAYS();
233 // Pass createFlags to configFlags first since these flags may be overwritten
234 pLib
->m_configFlags
.noCubeMipSlicesPad
= pCreateIn
->createFlags
.noCubeMipSlicesPad
;
235 pLib
->m_configFlags
.fillSizeFields
= pCreateIn
->createFlags
.fillSizeFields
;
236 pLib
->m_configFlags
.useTileIndex
= pCreateIn
->createFlags
.useTileIndex
;
237 pLib
->m_configFlags
.useCombinedSwizzle
= pCreateIn
->createFlags
.useCombinedSwizzle
;
238 pLib
->m_configFlags
.checkLast2DLevel
= pCreateIn
->createFlags
.checkLast2DLevel
;
239 pLib
->m_configFlags
.useHtileSliceAlign
= pCreateIn
->createFlags
.useHtileSliceAlign
;
240 pLib
->m_configFlags
.allowLargeThickTile
= pCreateIn
->createFlags
.allowLargeThickTile
;
241 pLib
->m_configFlags
.disableLinearOpt
= FALSE
;
243 pLib
->SetChipFamily(pCreateIn
->chipFamily
, pCreateIn
->chipRevision
);
245 pLib
->SetMinPitchAlignPixels(pCreateIn
->minPitchAlignPixels
);
247 // Global parameters initialized and remaining configFlags bits are set as well
248 initValid
= pLib
->HwlInitGlobalParams(pCreateIn
);
252 pLib
->m_pElemLib
= ElemLib::Create(pLib
);
256 pLib
->m_pElemLib
= NULL
; // Don't go on allocating element lib
257 returnCode
= ADDR_INVALIDGBREGVALUES
;
260 if (pLib
->m_pElemLib
== NULL
)
264 ADDR_ASSERT_ALWAYS();
268 pLib
->m_pElemLib
->SetConfigFlags(pLib
->m_configFlags
);
272 pCreateOut
->hLib
= pLib
;
274 if ((pLib
!= NULL
) &&
275 (returnCode
== ADDR_OK
))
277 pCreateOut
->numEquations
=
278 pLib
->HwlGetEquationTableInfo(&pCreateOut
->pEquationTable
);
281 if ((pLib
== NULL
) &&
282 (returnCode
== ADDR_OK
))
284 // Unknown failures, we return the general error code
285 returnCode
= ADDR_ERROR
;
292 ****************************************************************************************************
296 * Convert familyID defined in atiid.h to ChipFamily and set m_chipFamily/m_chipRevision
299 ****************************************************************************************************
301 VOID
Lib::SetChipFamily(
302 UINT_32 uChipFamily
, ///< [in] chip family defined in atiih.h
303 UINT_32 uChipRevision
) ///< [in] chip revision defined in "asic_family"_id.h
305 ChipFamily family
= HwlConvertChipFamily(uChipFamily
, uChipRevision
);
307 ADDR_ASSERT(family
!= ADDR_CHIP_FAMILY_IVLD
);
309 m_chipFamily
= family
;
310 m_chipRevision
= uChipRevision
;
314 ****************************************************************************************************
315 * Lib::SetMinPitchAlignPixels
318 * Set m_minPitchAlignPixels with input param
322 ****************************************************************************************************
324 VOID
Lib::SetMinPitchAlignPixels(
325 UINT_32 minPitchAlignPixels
) ///< [in] minmum pitch alignment in pixels
327 m_minPitchAlignPixels
= (minPitchAlignPixels
== 0) ? 1 : minPitchAlignPixels
;
331 ****************************************************************************************************
335 * Get AddrLib pointer
338 * An AddrLib class pointer
339 ****************************************************************************************************
342 ADDR_HANDLE hLib
) ///< [in] handle of ADDR_HANDLE
344 return static_cast<Addr::Lib
*>(hLib
);
348 ****************************************************************************************************
349 * Lib::GetMaxAlignments
352 * Gets maximum alignments
356 ****************************************************************************************************
358 ADDR_E_RETURNCODE
Lib::GetMaxAlignments(
359 ADDR_GET_MAX_ALINGMENTS_OUTPUT
* pOut
///< [out] output structure
362 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
364 if (GetFillSizeFieldsFlags() == TRUE
)
366 if (pOut
->size
!= sizeof(ADDR_GET_MAX_ALINGMENTS_OUTPUT
))
368 returnCode
= ADDR_PARAMSIZEMISMATCH
;
372 if (returnCode
== ADDR_OK
)
374 returnCode
= HwlGetMaxAlignments(pOut
);
381 ****************************************************************************************************
385 * Cat a array of binary bit to a number
388 * The number combined with the array of bits
389 ****************************************************************************************************
391 UINT_32
Lib::Bits2Number(
392 UINT_32 bitNum
, ///< [in] how many bits
393 ...) ///< [in] varaible bits value starting from MSB
399 va_start(bits_ptr
, bitNum
);
401 for(i
= 0; i
< bitNum
; i
++)
403 number
|= va_arg(bits_ptr
, UINT_32
);
415 ////////////////////////////////////////////////////////////////////////////////////////////////////
417 ////////////////////////////////////////////////////////////////////////////////////////////////////
421 ****************************************************************************************************
422 * Lib::Flt32ToColorPixel
425 * Convert a FLT_32 value to a depth/stencil pixel value
428 ****************************************************************************************************
430 ADDR_E_RETURNCODE
Lib::Flt32ToDepthPixel(
431 const ELEM_FLT32TODEPTHPIXEL_INPUT
* pIn
,
432 ELEM_FLT32TODEPTHPIXEL_OUTPUT
* pOut
) const
434 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
436 if (GetFillSizeFieldsFlags() == TRUE
)
438 if ((pIn
->size
!= sizeof(ELEM_FLT32TODEPTHPIXEL_INPUT
)) ||
439 (pOut
->size
!= sizeof(ELEM_FLT32TODEPTHPIXEL_OUTPUT
)))
441 returnCode
= ADDR_PARAMSIZEMISMATCH
;
445 if (returnCode
== ADDR_OK
)
447 GetElemLib()->Flt32ToDepthPixel(pIn
->format
, pIn
->comps
, pOut
->pPixel
);
449 UINT_32 depthBase
= 0;
450 UINT_32 stencilBase
= 0;
451 UINT_32 depthBits
= 0;
452 UINT_32 stencilBits
= 0;
459 case ADDR_DEPTH_X8_24
:
460 case ADDR_DEPTH_8_24
:
461 case ADDR_DEPTH_X8_24_FLOAT
:
462 case ADDR_DEPTH_8_24_FLOAT
:
467 case ADDR_DEPTH_32_FLOAT
:
470 case ADDR_DEPTH_X24_8_32_FLOAT
:
479 // Overwrite base since R800 has no "tileBase"
480 if (GetElemLib()->IsDepthStencilTilePlanar() == FALSE
)
489 pOut
->stencilBase
= stencilBase
;
490 pOut
->depthBase
= depthBase
;
491 pOut
->depthBits
= depthBits
;
492 pOut
->stencilBits
= stencilBits
;
499 ****************************************************************************************************
500 * Lib::Flt32ToColorPixel
503 * Convert a FLT_32 value to a red/green/blue/alpha pixel value
506 ****************************************************************************************************
508 ADDR_E_RETURNCODE
Lib::Flt32ToColorPixel(
509 const ELEM_FLT32TOCOLORPIXEL_INPUT
* pIn
,
510 ELEM_FLT32TOCOLORPIXEL_OUTPUT
* pOut
) const
512 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
514 if (GetFillSizeFieldsFlags() == TRUE
)
516 if ((pIn
->size
!= sizeof(ELEM_FLT32TOCOLORPIXEL_INPUT
)) ||
517 (pOut
->size
!= sizeof(ELEM_FLT32TOCOLORPIXEL_OUTPUT
)))
519 returnCode
= ADDR_PARAMSIZEMISMATCH
;
523 if (returnCode
== ADDR_OK
)
525 GetElemLib()->Flt32ToColorPixel(pIn
->format
,
537 ****************************************************************************************************
541 * Check one format can be EXPORT_NUM
543 * TRUE if EXPORT_NORM can be used
544 ****************************************************************************************************
546 BOOL_32
Lib::GetExportNorm(
547 const ELEM_GETEXPORTNORM_INPUT
* pIn
) const
549 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
551 BOOL_32 enabled
= FALSE
;
553 if (GetFillSizeFieldsFlags() == TRUE
)
555 if (pIn
->size
!= sizeof(ELEM_GETEXPORTNORM_INPUT
))
557 returnCode
= ADDR_PARAMSIZEMISMATCH
;
561 if (returnCode
== ADDR_OK
)
563 enabled
= GetElemLib()->PixGetExportNorm(pIn
->format
, pIn
->num
, pIn
->swap
);