2 * Copyright © 2016 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 Addr::V1::Lib class definition.
31 ****************************************************************************************************
34 #ifndef __ADDR_LIB1_H__
35 #define __ADDR_LIB1_H__
45 ****************************************************************************************************
46 * @brief Neutral enums that define bank swap size
47 ****************************************************************************************************
51 ADDR_SAMPLESPLIT_1KB
= 1024,
52 ADDR_SAMPLESPLIT_2KB
= 2048,
53 ADDR_SAMPLESPLIT_4KB
= 4096,
54 ADDR_SAMPLESPLIT_8KB
= 8192,
58 ****************************************************************************************************
59 * @brief Flags for AddrTileMode
60 ****************************************************************************************************
64 UINT_32 thickness
: 4;
68 UINT_32 isMacro3d
: 1;
70 UINT_32 isPrtNoRotation
: 1;
71 UINT_32 isBankSwapped
: 1;
74 static const UINT_32 Block64K
= 0x10000;
75 static const UINT_32 PrtTileSize
= Block64K
;
78 ****************************************************************************************************
79 * @brief This class contains asic independent address lib functionalities
80 ****************************************************************************************************
82 class Lib
: public Addr::Lib
90 /// Returns tileIndex support
91 BOOL_32
UseTileIndex(INT_32 index
) const
93 return m_configFlags
.useTileIndex
&& (index
!= TileIndexInvalid
);
96 /// Returns combined swizzle support
97 BOOL_32
UseCombinedSwizzle() const
99 return m_configFlags
.useCombinedSwizzle
;
105 ADDR_E_RETURNCODE
ComputeSurfaceInfo(
106 const ADDR_COMPUTE_SURFACE_INFO_INPUT
* pIn
,
107 ADDR_COMPUTE_SURFACE_INFO_OUTPUT
* pOut
) const;
109 ADDR_E_RETURNCODE
ComputeSurfaceAddrFromCoord(
110 const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
* pIn
,
111 ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
* pOut
) const;
113 ADDR_E_RETURNCODE
ComputeSurfaceCoordFromAddr(
114 const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
* pIn
,
115 ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
* pOut
) const;
117 ADDR_E_RETURNCODE
ComputeSliceTileSwizzle(
118 const ADDR_COMPUTE_SLICESWIZZLE_INPUT
* pIn
,
119 ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
* pOut
) const;
121 ADDR_E_RETURNCODE
ExtractBankPipeSwizzle(
122 const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
* pIn
,
123 ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
* pOut
) const;
125 ADDR_E_RETURNCODE
CombineBankPipeSwizzle(
126 const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
* pIn
,
127 ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
* pOut
) const;
129 ADDR_E_RETURNCODE
ComputeBaseSwizzle(
130 const ADDR_COMPUTE_BASE_SWIZZLE_INPUT
* pIn
,
131 ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
* pOut
) const;
133 ADDR_E_RETURNCODE
ComputeFmaskInfo(
134 const ADDR_COMPUTE_FMASK_INFO_INPUT
* pIn
,
135 ADDR_COMPUTE_FMASK_INFO_OUTPUT
* pOut
);
137 ADDR_E_RETURNCODE
ComputeFmaskAddrFromCoord(
138 const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
* pIn
,
139 ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
* pOut
) const;
141 ADDR_E_RETURNCODE
ComputeFmaskCoordFromAddr(
142 const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
* pIn
,
143 ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
* pOut
) const;
145 ADDR_E_RETURNCODE
ConvertTileInfoToHW(
146 const ADDR_CONVERT_TILEINFOTOHW_INPUT
* pIn
,
147 ADDR_CONVERT_TILEINFOTOHW_OUTPUT
* pOut
) const;
149 ADDR_E_RETURNCODE
ConvertTileIndex(
150 const ADDR_CONVERT_TILEINDEX_INPUT
* pIn
,
151 ADDR_CONVERT_TILEINDEX_OUTPUT
* pOut
) const;
153 ADDR_E_RETURNCODE
GetMacroModeIndex(
154 const ADDR_GET_MACROMODEINDEX_INPUT
* pIn
,
155 ADDR_GET_MACROMODEINDEX_OUTPUT
* pOut
) const;
157 ADDR_E_RETURNCODE
ConvertTileIndex1(
158 const ADDR_CONVERT_TILEINDEX1_INPUT
* pIn
,
159 ADDR_CONVERT_TILEINDEX_OUTPUT
* pOut
) const;
161 ADDR_E_RETURNCODE
GetTileIndex(
162 const ADDR_GET_TILEINDEX_INPUT
* pIn
,
163 ADDR_GET_TILEINDEX_OUTPUT
* pOut
) const;
165 ADDR_E_RETURNCODE
ComputeHtileInfo(
166 const ADDR_COMPUTE_HTILE_INFO_INPUT
* pIn
,
167 ADDR_COMPUTE_HTILE_INFO_OUTPUT
* pOut
) const;
169 ADDR_E_RETURNCODE
ComputeCmaskInfo(
170 const ADDR_COMPUTE_CMASK_INFO_INPUT
* pIn
,
171 ADDR_COMPUTE_CMASK_INFO_OUTPUT
* pOut
) const;
173 ADDR_E_RETURNCODE
ComputeDccInfo(
174 const ADDR_COMPUTE_DCCINFO_INPUT
* pIn
,
175 ADDR_COMPUTE_DCCINFO_OUTPUT
* pOut
) const;
177 ADDR_E_RETURNCODE
ComputeHtileAddrFromCoord(
178 const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
* pIn
,
179 ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
* pOut
) const;
181 ADDR_E_RETURNCODE
ComputeCmaskAddrFromCoord(
182 const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
* pIn
,
183 ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
* pOut
) const;
185 ADDR_E_RETURNCODE
ComputeHtileCoordFromAddr(
186 const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
* pIn
,
187 ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
* pOut
) const;
189 ADDR_E_RETURNCODE
ComputeCmaskCoordFromAddr(
190 const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
* pIn
,
191 ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
* pOut
) const;
193 ADDR_E_RETURNCODE
ComputePrtInfo(
194 const ADDR_PRT_INFO_INPUT
* pIn
,
195 ADDR_PRT_INFO_OUTPUT
* pOut
) const;
197 Lib(); // Constructor is protected
198 Lib(const Client
* pClient
);
200 /// Pure Virtual function for Hwl computing surface info
201 virtual ADDR_E_RETURNCODE
HwlComputeSurfaceInfo(
202 const ADDR_COMPUTE_SURFACE_INFO_INPUT
* pIn
,
203 ADDR_COMPUTE_SURFACE_INFO_OUTPUT
* pOut
) const = 0;
205 /// Pure Virtual function for Hwl computing surface address from coord
206 virtual ADDR_E_RETURNCODE
HwlComputeSurfaceAddrFromCoord(
207 const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
* pIn
,
208 ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
* pOut
) const = 0;
210 /// Pure Virtual function for Hwl computing surface coord from address
211 virtual ADDR_E_RETURNCODE
HwlComputeSurfaceCoordFromAddr(
212 const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
* pIn
,
213 ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
* pOut
) const = 0;
215 /// Pure Virtual function for Hwl computing surface tile swizzle
216 virtual ADDR_E_RETURNCODE
HwlComputeSliceTileSwizzle(
217 const ADDR_COMPUTE_SLICESWIZZLE_INPUT
* pIn
,
218 ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
* pOut
) const = 0;
220 /// Pure Virtual function for Hwl extracting bank/pipe swizzle from base256b
221 virtual ADDR_E_RETURNCODE
HwlExtractBankPipeSwizzle(
222 const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
* pIn
,
223 ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
* pOut
) const = 0;
225 /// Pure Virtual function for Hwl combining bank/pipe swizzle
226 virtual ADDR_E_RETURNCODE
HwlCombineBankPipeSwizzle(
227 UINT_32 bankSwizzle
, UINT_32 pipeSwizzle
, ADDR_TILEINFO
* pTileInfo
,
228 UINT_64 baseAddr
, UINT_32
* pTileSwizzle
) const = 0;
230 /// Pure Virtual function for Hwl computing base swizzle
231 virtual ADDR_E_RETURNCODE
HwlComputeBaseSwizzle(
232 const ADDR_COMPUTE_BASE_SWIZZLE_INPUT
* pIn
,
233 ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
* pOut
) const = 0;
235 /// Pure Virtual function for Hwl computing HTILE base align
236 virtual UINT_32
HwlComputeHtileBaseAlign(
237 BOOL_32 isTcCompatible
, BOOL_32 isLinear
, ADDR_TILEINFO
* pTileInfo
) const = 0;
239 /// Pure Virtual function for Hwl computing HTILE bpp
240 virtual UINT_32
HwlComputeHtileBpp(
241 BOOL_32 isWidth8
, BOOL_32 isHeight8
) const = 0;
243 /// Pure Virtual function for Hwl computing HTILE bytes
244 virtual UINT_64
HwlComputeHtileBytes(
245 UINT_32 pitch
, UINT_32 height
, UINT_32 bpp
,
246 BOOL_32 isLinear
, UINT_32 numSlices
, UINT_64
* pSliceBytes
, UINT_32 baseAlign
) const = 0;
248 /// Pure Virtual function for Hwl computing FMASK info
249 virtual ADDR_E_RETURNCODE
HwlComputeFmaskInfo(
250 const ADDR_COMPUTE_FMASK_INFO_INPUT
* pIn
,
251 ADDR_COMPUTE_FMASK_INFO_OUTPUT
* pOut
) = 0;
253 /// Pure Virtual function for Hwl FMASK address from coord
254 virtual ADDR_E_RETURNCODE
HwlComputeFmaskAddrFromCoord(
255 const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
* pIn
,
256 ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
* pOut
) const = 0;
258 /// Pure Virtual function for Hwl FMASK coord from address
259 virtual ADDR_E_RETURNCODE
HwlComputeFmaskCoordFromAddr(
260 const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
* pIn
,
261 ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
* pOut
) const = 0;
263 /// Pure Virtual function for Hwl convert tile info from real value to HW value
264 virtual ADDR_E_RETURNCODE
HwlConvertTileInfoToHW(
265 const ADDR_CONVERT_TILEINFOTOHW_INPUT
* pIn
,
266 ADDR_CONVERT_TILEINFOTOHW_OUTPUT
* pOut
) const = 0;
268 /// Pure Virtual function for Hwl compute mipmap info
269 virtual BOOL_32
HwlComputeMipLevel(
270 ADDR_COMPUTE_SURFACE_INFO_INPUT
* pIn
) const = 0;
272 /// Pure Virtual function for Hwl compute max cmask blockMax value
273 virtual BOOL_32
HwlGetMaxCmaskBlockMax() const = 0;
275 /// Pure Virtual function for Hwl compute fmask bits
276 virtual UINT_32
HwlComputeFmaskBits(
277 const ADDR_COMPUTE_FMASK_INFO_INPUT
* pIn
,
278 UINT_32
* pNumSamples
) const = 0;
280 /// Virtual function to get index (not pure then no need to implement this in all hwls
281 virtual ADDR_E_RETURNCODE
HwlGetTileIndex(
282 const ADDR_GET_TILEINDEX_INPUT
* pIn
,
283 ADDR_GET_TILEINDEX_OUTPUT
* pOut
) const
285 return ADDR_NOTSUPPORTED
;
288 /// Virtual function for Hwl to compute Dcc info
289 virtual ADDR_E_RETURNCODE
HwlComputeDccInfo(
290 const ADDR_COMPUTE_DCCINFO_INPUT
* pIn
,
291 ADDR_COMPUTE_DCCINFO_OUTPUT
* pOut
) const
293 return ADDR_NOTSUPPORTED
;
296 /// Virtual function to get cmask address for tc compatible cmask
297 virtual ADDR_E_RETURNCODE
HwlComputeCmaskAddrFromCoord(
298 const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
* pIn
,
299 ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
* pOut
) const
301 return ADDR_NOTSUPPORTED
;
304 /// Virtual function to get htile address for tc compatible htile
305 virtual ADDR_E_RETURNCODE
HwlComputeHtileAddrFromCoord(
306 const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
* pIn
,
307 ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
* pOut
) const
309 return ADDR_NOTSUPPORTED
;
312 // Compute attributes
315 UINT_32
ComputeHtileInfo(
316 ADDR_HTILE_FLAGS flags
,
317 UINT_32 pitchIn
, UINT_32 heightIn
, UINT_32 numSlices
,
318 BOOL_32 isLinear
, BOOL_32 isWidth8
, BOOL_32 isHeight8
,
319 ADDR_TILEINFO
* pTileInfo
,
320 UINT_32
* pPitchOut
, UINT_32
* pHeightOut
, UINT_64
* pHtileBytes
,
321 UINT_32
* pMacroWidth
= NULL
, UINT_32
* pMacroHeight
= NULL
,
322 UINT_64
* pSliceSize
= NULL
, UINT_32
* pBaseAlign
= NULL
) const;
325 ADDR_E_RETURNCODE
ComputeCmaskInfo(
326 ADDR_CMASK_FLAGS flags
,
327 UINT_32 pitchIn
, UINT_32 heightIn
, UINT_32 numSlices
, BOOL_32 isLinear
,
328 ADDR_TILEINFO
* pTileInfo
, UINT_32
* pPitchOut
, UINT_32
* pHeightOut
, UINT_64
* pCmaskBytes
,
329 UINT_32
* pMacroWidth
, UINT_32
* pMacroHeight
, UINT_64
* pSliceSize
= NULL
,
330 UINT_32
* pBaseAlign
= NULL
, UINT_32
* pBlockMax
= NULL
) const;
332 virtual VOID
HwlComputeTileDataWidthAndHeightLinear(
333 UINT_32
* pMacroWidth
, UINT_32
* pMacroHeight
,
334 UINT_32 bpp
, ADDR_TILEINFO
* pTileInfo
) const;
336 // CMASK & HTILE addressing
337 virtual UINT_64
HwlComputeXmaskAddrFromCoord(
338 UINT_32 pitch
, UINT_32 height
, UINT_32 x
, UINT_32 y
, UINT_32 slice
,
339 UINT_32 numSlices
, UINT_32 factor
, BOOL_32 isLinear
, BOOL_32 isWidth8
,
340 BOOL_32 isHeight8
, ADDR_TILEINFO
* pTileInfo
,
341 UINT_32
* bitPosition
) const;
343 virtual VOID
HwlComputeXmaskCoordFromAddr(
344 UINT_64 addr
, UINT_32 bitPosition
, UINT_32 pitch
, UINT_32 height
, UINT_32 numSlices
,
345 UINT_32 factor
, BOOL_32 isLinear
, BOOL_32 isWidth8
, BOOL_32 isHeight8
,
346 ADDR_TILEINFO
* pTileInfo
, UINT_32
* pX
, UINT_32
* pY
, UINT_32
* pSlice
) const;
349 VOID
ComputeMipLevel(
350 ADDR_COMPUTE_SURFACE_INFO_INPUT
* pIn
) const;
352 /// Pure Virtual function for Hwl to get macro tiled alignment info
353 virtual BOOL_32
HwlGetAlignmentInfoMacroTiled(
354 const ADDR_COMPUTE_SURFACE_INFO_INPUT
* pIn
,
355 UINT_32
* pPitchAlign
, UINT_32
* pHeightAlign
, UINT_32
* pSizeAlign
) const = 0;
358 virtual VOID
HwlOverrideTileMode(ADDR_COMPUTE_SURFACE_INFO_INPUT
* pInOut
) const
360 // not supported in hwl layer
363 virtual VOID
HwlOptimizeTileMode(ADDR_COMPUTE_SURFACE_INFO_INPUT
* pInOut
) const
365 // not supported in hwl layer
368 virtual VOID
HwlSelectTileMode(ADDR_COMPUTE_SURFACE_INFO_INPUT
* pInOut
) const
370 // not supported in hwl layer
373 AddrTileMode
DegradeLargeThickTile(AddrTileMode tileMode
, UINT_32 bpp
) const;
376 AddrTileMode tileMode
, UINT_32 bpp
, ADDR_SURFACE_FLAGS flags
,
377 UINT_32 numSamples
, ADDR_TILEINFO
* pTileInfo
, UINT_32 padDims
, UINT_32 mipLevel
,
378 UINT_32
* pPitch
, UINT_32
* pPitchAlign
, UINT_32
* pHeight
, UINT_32 heightAlign
,
379 UINT_32
* pSlices
, UINT_32 sliceAlign
) const;
381 virtual VOID
HwlPadDimensions(
382 AddrTileMode tileMode
, UINT_32 bpp
, ADDR_SURFACE_FLAGS flags
,
383 UINT_32 numSamples
, ADDR_TILEINFO
* pTileInfo
, UINT_32 mipLevel
,
384 UINT_32
* pPitch
, UINT_32
* pPitchAlign
, UINT_32 height
, UINT_32 heightAlign
) const
389 // Addressing shared for linear/1D tiling
391 UINT_64
ComputeSurfaceAddrFromCoordLinear(
392 UINT_32 x
, UINT_32 y
, UINT_32 slice
, UINT_32 sample
,
393 UINT_32 bpp
, UINT_32 pitch
, UINT_32 height
, UINT_32 numSlices
,
394 UINT_32
* pBitPosition
) const;
396 VOID
ComputeSurfaceCoordFromAddrLinear(
397 UINT_64 addr
, UINT_32 bitPosition
, UINT_32 bpp
,
398 UINT_32 pitch
, UINT_32 height
, UINT_32 numSlices
,
399 UINT_32
* pX
, UINT_32
* pY
, UINT_32
* pSlice
, UINT_32
* pSample
) const;
401 VOID
ComputeSurfaceCoordFromAddrMicroTiled(
402 UINT_64 addr
, UINT_32 bitPosition
,
403 UINT_32 bpp
, UINT_32 pitch
, UINT_32 height
, UINT_32 numSamples
,
404 AddrTileMode tileMode
, UINT_32 tileBase
, UINT_32 compBits
,
405 UINT_32
* pX
, UINT_32
* pY
, UINT_32
* pSlice
, UINT_32
* pSample
,
406 AddrTileType microTileType
, BOOL_32 isDepthSampleOrder
) const;
408 ADDR_E_RETURNCODE
ComputeMicroTileEquation(
409 UINT_32 bpp
, AddrTileMode tileMode
,
410 AddrTileType microTileType
, ADDR_EQUATION
* pEquation
) const;
412 UINT_32
ComputePixelIndexWithinMicroTile(
413 UINT_32 x
, UINT_32 y
, UINT_32 z
,
414 UINT_32 bpp
, AddrTileMode tileMode
, AddrTileType microTileType
) const;
416 /// Pure Virtual function for Hwl computing coord from offset inside micro tile
417 virtual VOID
HwlComputePixelCoordFromOffset(
418 UINT_32 offset
, UINT_32 bpp
, UINT_32 numSamples
,
419 AddrTileMode tileMode
, UINT_32 tileBase
, UINT_32 compBits
,
420 UINT_32
* pX
, UINT_32
* pY
, UINT_32
* pSlice
, UINT_32
* pSample
,
421 AddrTileType microTileType
, BOOL_32 isDepthSampleOrder
) const = 0;
424 // Addressing shared by all
426 virtual UINT_32
HwlGetPipes(
427 const ADDR_TILEINFO
* pTileInfo
) const;
429 UINT_32
ComputePipeFromAddr(
430 UINT_64 addr
, UINT_32 numPipes
) const;
432 virtual ADDR_E_RETURNCODE
ComputePipeEquation(
433 UINT_32 log2BytesPP
, UINT_32 threshX
, UINT_32 threshY
, ADDR_TILEINFO
* pTileInfo
, ADDR_EQUATION
* pEquation
) const
435 return ADDR_NOTSUPPORTED
;
438 /// Pure Virtual function for Hwl computing pipe from coord
439 virtual UINT_32
ComputePipeFromCoord(
440 UINT_32 x
, UINT_32 y
, UINT_32 slice
, AddrTileMode tileMode
,
441 UINT_32 pipeSwizzle
, BOOL_32 flags
, ADDR_TILEINFO
* pTileInfo
) const = 0;
443 /// Pure Virtual function for Hwl computing coord Y for 8 pipe cmask/htile
444 virtual UINT_32
HwlComputeXmaskCoordYFrom8Pipe(
445 UINT_32 pipe
, UINT_32 x
) const = 0;
450 static const TileModeFlags ModeFlags
[ADDR_TM_COUNT
];
452 static UINT_32
Thickness(
453 AddrTileMode tileMode
);
455 // Checking tile mode
456 static BOOL_32
IsMacroTiled(AddrTileMode tileMode
);
457 static BOOL_32
IsMacro3dTiled(AddrTileMode tileMode
);
458 static BOOL_32
IsLinear(AddrTileMode tileMode
);
459 static BOOL_32
IsMicroTiled(AddrTileMode tileMode
);
460 static BOOL_32
IsPrtTileMode(AddrTileMode tileMode
);
461 static BOOL_32
IsPrtNoRotationTileMode(AddrTileMode tileMode
);
463 /// Return TRUE if tile info is needed
464 BOOL_32
UseTileInfo() const
466 return !m_configFlags
.ignoreTileInfo
;
469 /// Adjusts pitch alignment for flipping surface
470 VOID
AdjustPitchAlignment(
471 ADDR_SURFACE_FLAGS flags
, UINT_32
* pPitchAlign
) const;
473 /// Overwrite tile config according to tile index
474 virtual ADDR_E_RETURNCODE
HwlSetupTileCfg(
475 UINT_32 bpp
, INT_32 index
, INT_32 macroModeIndex
,
476 ADDR_TILEINFO
* pInfo
, AddrTileMode
* mode
= NULL
, AddrTileType
* type
= NULL
) const;
478 /// Overwrite macro tile config according to tile index
479 virtual INT_32
HwlComputeMacroModeIndex(
480 INT_32 index
, ADDR_SURFACE_FLAGS flags
, UINT_32 bpp
, UINT_32 numSamples
,
481 ADDR_TILEINFO
* pTileInfo
, AddrTileMode
*pTileMode
= NULL
, AddrTileType
*pTileType
= NULL
484 return TileIndexNoMacroIndex
;
487 /// Pre-handler of 3x pitch (96 bit) adjustment
488 virtual UINT_32
HwlPreHandleBaseLvl3xPitch(
489 const ADDR_COMPUTE_SURFACE_INFO_INPUT
* pIn
, UINT_32 expPitch
) const;
490 /// Post-handler of 3x pitch adjustment
491 virtual UINT_32
HwlPostHandleBaseLvl3xPitch(
492 const ADDR_COMPUTE_SURFACE_INFO_INPUT
* pIn
, UINT_32 expPitch
) const;
493 /// Check miplevel after surface adjustment
494 ADDR_E_RETURNCODE
PostComputeMipLevel(
495 ADDR_COMPUTE_SURFACE_INFO_INPUT
* pIn
,
496 ADDR_COMPUTE_SURFACE_INFO_OUTPUT
* pOut
) const;
498 /// Quad buffer stereo support, has its implementation in ind. layer
499 VOID
ComputeQbStereoInfo(
500 ADDR_COMPUTE_SURFACE_INFO_OUTPUT
* pOut
) const;
502 /// Pure virutual function to compute stereo bank swizzle for right eye
503 virtual UINT_32
HwlComputeQbStereoRightSwizzle(
504 ADDR_COMPUTE_SURFACE_INFO_OUTPUT
* pOut
) const = 0;
506 VOID
OptimizeTileMode(ADDR_COMPUTE_SURFACE_INFO_INPUT
* pInOut
) const;
508 /// Overwrite tile setting to PRT
509 virtual VOID
HwlSetPrtTileMode(ADDR_COMPUTE_SURFACE_INFO_INPUT
* pInOut
) const
513 static BOOL_32
DegradeTo1D(
514 UINT_32 width
, UINT_32 height
,
515 UINT_32 macroTilePitchAlign
, UINT_32 macroTileHeightAlign
);
518 // Disallow the copy constructor
521 // Disallow the assignment operator
522 Lib
& operator=(const Lib
& a
);
524 UINT_32
ComputeCmaskBaseAlign(
525 ADDR_CMASK_FLAGS flags
, ADDR_TILEINFO
* pTileInfo
) const;
527 UINT_64
ComputeCmaskBytes(
528 UINT_32 pitch
, UINT_32 height
, UINT_32 numSlices
) const;
531 // CMASK/HTILE shared methods
533 VOID
ComputeTileDataWidthAndHeight(
534 UINT_32 bpp
, UINT_32 cacheBits
, ADDR_TILEINFO
* pTileInfo
,
535 UINT_32
* pMacroWidth
, UINT_32
* pMacroHeight
) const;
537 UINT_32
ComputeXmaskCoordYFromPipe(
538 UINT_32 pipe
, UINT_32 x
) const;