projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
amd/addrlib: update to latest version
[mesa.git] / src / amd / addrlib / gfx9 / gfx9addrlib.cpp
1 /*
2 * Copyright © 2017 Advanced Micro Devices, Inc.
3 * All Rights Reserved.
4 *
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:
12 *
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.
21 *
22 * The above copyright notice and this permission notice (including the
23 * next paragraph) shall be included in all copies or substantial portions
24 * of the Software.
25 */
26
27 /**
28 ************************************************************************************************************************
29 * @file gfx9addrlib.cpp
30 * @brief Contgfx9ns the implementation for the Gfx9Lib class.
31 ************************************************************************************************************************
32 */
33
34 #include "gfx9addrlib.h"
35
36 #include "gfx9_gb_reg.h"
37
38 #include "amdgpu_asic_addr.h"
39
40 ////////////////////////////////////////////////////////////////////////////////////////////////////
41 ////////////////////////////////////////////////////////////////////////////////////////////////////
42
43 namespace Addr
44 {
45
46 /**
47 ************************************************************************************************************************
48 * Gfx9HwlInit
49 *
50 * @brief
51 * Creates an Gfx9Lib object.
52 *
53 * @return
54 * Returns an Gfx9Lib object pointer.
55 ************************************************************************************************************************
56 */
57 Addr::Lib* Gfx9HwlInit(const Client* pClient)
58 {
59 return V2::Gfx9Lib::CreateObj(pClient);
60 }
61
62 namespace V2
63 {
64
65 ////////////////////////////////////////////////////////////////////////////////////////////////////
66 // Static Const Member
67 ////////////////////////////////////////////////////////////////////////////////////////////////////
68
69 const SwizzleModeFlags Gfx9Lib::SwizzleModeTable[ADDR_SW_MAX_TYPE] =
70 {//Linear 256B 4KB 64KB Var Z Std Disp Rot XOR T RtOpt
71 {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // ADDR_SW_LINEAR
72 {0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0}, // ADDR_SW_256B_S
73 {0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0}, // ADDR_SW_256B_D
74 {0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0}, // ADDR_SW_256B_R
75
76 {0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0}, // ADDR_SW_4KB_Z
77 {0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0}, // ADDR_SW_4KB_S
78 {0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0}, // ADDR_SW_4KB_D
79 {0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0}, // ADDR_SW_4KB_R
80
81 {0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0}, // ADDR_SW_64KB_Z
82 {0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0}, // ADDR_SW_64KB_S
83 {0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0}, // ADDR_SW_64KB_D
84 {0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0}, // ADDR_SW_64KB_R
85
86 {0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0}, // ADDR_SW_VAR_Z
87 {0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0}, // ADDR_SW_VAR_S
88 {0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0}, // ADDR_SW_VAR_D
89 {0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0}, // ADDR_SW_VAR_R
90
91 {0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0}, // ADDR_SW_64KB_Z_T
92 {0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0}, // ADDR_SW_64KB_S_T
93 {0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0}, // ADDR_SW_64KB_D_T
94 {0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0}, // ADDR_SW_64KB_R_T
95
96 {0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0}, // ADDR_SW_4KB_Z_x
97 {0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0}, // ADDR_SW_4KB_S_x
98 {0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0}, // ADDR_SW_4KB_D_x
99 {0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0}, // ADDR_SW_4KB_R_x
100
101 {0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0}, // ADDR_SW_64KB_Z_X
102 {0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0}, // ADDR_SW_64KB_S_X
103 {0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0}, // ADDR_SW_64KB_D_X
104 {0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0}, // ADDR_SW_64KB_R_X
105
106 {0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0}, // ADDR_SW_VAR_Z_X
107 {0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0}, // ADDR_SW_VAR_S_X
108 {0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0}, // ADDR_SW_VAR_D_X
109 {0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0}, // ADDR_SW_VAR_R_X
110 {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // ADDR_SW_LINEAR_GENERAL
111 };
112
113 const UINT_32 Gfx9Lib::MipTailOffset256B[] = {2048, 1024, 512, 256, 128, 64, 32, 16,
114 8, 6, 5, 4, 3, 2, 1, 0};
115
116 const Dim3d Gfx9Lib::Block256_3dS[] = {{16, 4, 4}, {8, 4, 4}, {4, 4, 4}, {2, 4, 4}, {1, 4, 4}};
117
118 const Dim3d Gfx9Lib::Block256_3dZ[] = {{8, 4, 8}, {4, 4, 8}, {4, 4, 4}, {4, 2, 4}, {2, 2, 4}};
119
120 /**
121 ************************************************************************************************************************
122 * Gfx9Lib::Gfx9Lib
123 *
124 * @brief
125 * Constructor
126 *
127 ************************************************************************************************************************
128 */
129 Gfx9Lib::Gfx9Lib(const Client* pClient)
130 :
131 Lib(pClient),
132 m_numEquations(0)
133 {
134 m_class = AI_ADDRLIB;
135 memset(&m_settings, 0, sizeof(m_settings));
136 memcpy(m_swizzleModeTable, SwizzleModeTable, sizeof(SwizzleModeTable));
137 }
138
139 /**
140 ************************************************************************************************************************
141 * Gfx9Lib::~Gfx9Lib
142 *
143 * @brief
144 * Destructor
145 ************************************************************************************************************************
146 */
147 Gfx9Lib::~Gfx9Lib()
148 {
149 }
150
151 /**
152 ************************************************************************************************************************
153 * Gfx9Lib::HwlComputeHtileInfo
154 *
155 * @brief
156 * Interface function stub of AddrComputeHtilenfo
157 *
158 * @return
159 * ADDR_E_RETURNCODE
160 ************************************************************************************************************************
161 */
162 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeHtileInfo(
163 const ADDR2_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] input structure
164 ADDR2_COMPUTE_HTILE_INFO_OUTPUT* pOut ///< [out] output structure
165 ) const
166 {
167 UINT_32 numPipeTotal = GetPipeNumForMetaAddressing(pIn->hTileFlags.pipeAligned,
168 pIn->swizzleMode);
169
170 UINT_32 numRbTotal = pIn->hTileFlags.rbAligned ? m_se * m_rbPerSe : 1;
171
172 UINT_32 numCompressBlkPerMetaBlk, numCompressBlkPerMetaBlkLog2;
173
174 if ((numPipeTotal == 1) && (numRbTotal == 1))
175 {
176 numCompressBlkPerMetaBlkLog2 = 10;
177 }
178 else
179 {
180 if (m_settings.applyAliasFix)
181 {
182 numCompressBlkPerMetaBlkLog2 = m_seLog2 + m_rbPerSeLog2 + Max(10u, m_pipeInterleaveLog2);
183 }
184 else
185 {
186 numCompressBlkPerMetaBlkLog2 = m_seLog2 + m_rbPerSeLog2 + 10;
187 }
188 }
189
190 numCompressBlkPerMetaBlk = 1 << numCompressBlkPerMetaBlkLog2;
191
192 Dim3d metaBlkDim = {8, 8, 1};
193 UINT_32 totalAmpBits = numCompressBlkPerMetaBlkLog2;
194 UINT_32 widthAmp = (pIn->numMipLevels > 1) ? (totalAmpBits >> 1) : RoundHalf(totalAmpBits);
195 UINT_32 heightAmp = totalAmpBits - widthAmp;
196 metaBlkDim.w <<= widthAmp;
197 metaBlkDim.h <<= heightAmp;
198
199 #if DEBUG
200 Dim3d metaBlkDimDbg = {8, 8, 1};
201 for (UINT_32 index = 0; index < numCompressBlkPerMetaBlkLog2; index++)
202 {
203 if ((metaBlkDimDbg.h < metaBlkDimDbg.w) ||
204 ((pIn->numMipLevels > 1) && (metaBlkDimDbg.h == metaBlkDimDbg.w)))
205 {
206 metaBlkDimDbg.h <<= 1;
207 }
208 else
209 {
210 metaBlkDimDbg.w <<= 1;
211 }
212 }
213 ADDR_ASSERT((metaBlkDimDbg.w == metaBlkDim.w) && (metaBlkDimDbg.h == metaBlkDim.h));
214 #endif
215
216 UINT_32 numMetaBlkX;
217 UINT_32 numMetaBlkY;
218 UINT_32 numMetaBlkZ;
219
220 GetMetaMipInfo(pIn->numMipLevels, &metaBlkDim, FALSE, pOut->pMipInfo,
221 pIn->unalignedWidth, pIn->unalignedHeight, pIn->numSlices,
222 &numMetaBlkX, &numMetaBlkY, &numMetaBlkZ);
223
224 UINT_32 sizeAlign = numPipeTotal * numRbTotal * m_pipeInterleaveBytes;
225
226 if (m_settings.htileAlignFix)
227 {
228 sizeAlign <<= 1;
229 }
230
231 pOut->pitch = numMetaBlkX * metaBlkDim.w;
232 pOut->height = numMetaBlkY * metaBlkDim.h;
233 pOut->sliceSize = numMetaBlkX * numMetaBlkY * numCompressBlkPerMetaBlk * 4;
234
235 pOut->metaBlkWidth = metaBlkDim.w;
236 pOut->metaBlkHeight = metaBlkDim.h;
237 pOut->metaBlkNumPerSlice = numMetaBlkX * numMetaBlkY;
238
239 pOut->baseAlign = Max(numCompressBlkPerMetaBlk * 4, sizeAlign);
240
241 if (m_settings.metaBaseAlignFix)
242 {
243 pOut->baseAlign = Max(pOut->baseAlign, GetBlockSize(pIn->swizzleMode));
244 }
245
246 if ((IsXor(pIn->swizzleMode) == FALSE) && (numPipeTotal > 2))
247 {
248 UINT_32 additionalAlign = numPipeTotal * numCompressBlkPerMetaBlk * 2;
249
250 if (additionalAlign > sizeAlign)
251 {
252 sizeAlign = additionalAlign;
253 }
254 }
255
256 pOut->htileBytes = PowTwoAlign(pOut->sliceSize * numMetaBlkZ, sizeAlign);
257
258 return ADDR_OK;
259 }
260
261 /**
262 ************************************************************************************************************************
263 * Gfx9Lib::HwlComputeCmaskInfo
264 *
265 * @brief
266 * Interface function stub of AddrComputeCmaskInfo
267 *
268 * @return
269 * ADDR_E_RETURNCODE
270 ************************************************************************************************************************
271 */
272 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeCmaskInfo(
273 const ADDR2_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] input structure
274 ADDR2_COMPUTE_CMASK_INFO_OUTPUT* pOut ///< [out] output structure
275 ) const
276 {
277 // TODO: Clarify with AddrLib team
278 // ADDR_ASSERT(pIn->resourceType == ADDR_RSRC_TEX_2D);
279
280 UINT_32 numPipeTotal = GetPipeNumForMetaAddressing(pIn->cMaskFlags.pipeAligned,
281 pIn->swizzleMode);
282
283 UINT_32 numRbTotal = pIn->cMaskFlags.rbAligned ? m_se * m_rbPerSe : 1;
284
285 UINT_32 numCompressBlkPerMetaBlkLog2, numCompressBlkPerMetaBlk;
286
287 if ((numPipeTotal == 1) && (numRbTotal == 1))
288 {
289 numCompressBlkPerMetaBlkLog2 = 13;
290 }
291 else
292 {
293 if (m_settings.applyAliasFix)
294 {
295 numCompressBlkPerMetaBlkLog2 = m_seLog2 + m_rbPerSeLog2 + Max(10u, m_pipeInterleaveLog2);
296 }
297 else
298 {
299 numCompressBlkPerMetaBlkLog2 = m_seLog2 + m_rbPerSeLog2 + 10;
300 }
301
302 numCompressBlkPerMetaBlkLog2 = Max(numCompressBlkPerMetaBlkLog2, 13u);
303 }
304
305 numCompressBlkPerMetaBlk = 1 << numCompressBlkPerMetaBlkLog2;
306
307 Dim2d metaBlkDim = {8, 8};
308 UINT_32 totalAmpBits = numCompressBlkPerMetaBlkLog2;
309 UINT_32 heightAmp = totalAmpBits >> 1;
310 UINT_32 widthAmp = totalAmpBits - heightAmp;
311 metaBlkDim.w <<= widthAmp;
312 metaBlkDim.h <<= heightAmp;
313
314 #if DEBUG
315 Dim2d metaBlkDimDbg = {8, 8};
316 for (UINT_32 index = 0; index < numCompressBlkPerMetaBlkLog2; index++)
317 {
318 if (metaBlkDimDbg.h < metaBlkDimDbg.w)
319 {
320 metaBlkDimDbg.h <<= 1;
321 }
322 else
323 {
324 metaBlkDimDbg.w <<= 1;
325 }
326 }
327 ADDR_ASSERT((metaBlkDimDbg.w == metaBlkDim.w) && (metaBlkDimDbg.h == metaBlkDim.h));
328 #endif
329
330 UINT_32 numMetaBlkX = (pIn->unalignedWidth + metaBlkDim.w - 1) / metaBlkDim.w;
331 UINT_32 numMetaBlkY = (pIn->unalignedHeight + metaBlkDim.h - 1) / metaBlkDim.h;
332 UINT_32 numMetaBlkZ = Max(pIn->numSlices, 1u);
333
334 UINT_32 sizeAlign = numPipeTotal * numRbTotal * m_pipeInterleaveBytes;
335
336 pOut->pitch = numMetaBlkX * metaBlkDim.w;
337 pOut->height = numMetaBlkY * metaBlkDim.h;
338 pOut->sliceSize = (numMetaBlkX * numMetaBlkY * numCompressBlkPerMetaBlk) >> 1;
339 pOut->cmaskBytes = PowTwoAlign(pOut->sliceSize * numMetaBlkZ, sizeAlign);
340 pOut->baseAlign = Max(numCompressBlkPerMetaBlk >> 1, sizeAlign);
341
342 if (m_settings.metaBaseAlignFix)
343 {
344 pOut->baseAlign = Max(pOut->baseAlign, GetBlockSize(pIn->swizzleMode));
345 }
346
347 pOut->metaBlkWidth = metaBlkDim.w;
348 pOut->metaBlkHeight = metaBlkDim.h;
349
350 pOut->metaBlkNumPerSlice = numMetaBlkX * numMetaBlkY;
351
352 return ADDR_OK;
353 }
354
355 /**
356 ************************************************************************************************************************
357 * Gfx9Lib::GetMetaMipInfo
358 *
359 * @brief
360 * Get meta mip info
361 *
362 * @return
363 * N/A
364 ************************************************************************************************************************
365 */
366 VOID Gfx9Lib::GetMetaMipInfo(
367 UINT_32 numMipLevels, ///< [in] number of mip levels
368 Dim3d* pMetaBlkDim, ///< [in] meta block dimension
369 BOOL_32 dataThick, ///< [in] data surface is thick
370 ADDR2_META_MIP_INFO* pInfo, ///< [out] meta mip info
371 UINT_32 mip0Width, ///< [in] mip0 width
372 UINT_32 mip0Height, ///< [in] mip0 height
373 UINT_32 mip0Depth, ///< [in] mip0 depth
374 UINT_32* pNumMetaBlkX, ///< [out] number of metablock X in mipchain
375 UINT_32* pNumMetaBlkY, ///< [out] number of metablock Y in mipchain
376 UINT_32* pNumMetaBlkZ) ///< [out] number of metablock Z in mipchain
377 const
378 {
379 UINT_32 numMetaBlkX = (mip0Width + pMetaBlkDim->w - 1) / pMetaBlkDim->w;
380 UINT_32 numMetaBlkY = (mip0Height + pMetaBlkDim->h - 1) / pMetaBlkDim->h;
381 UINT_32 numMetaBlkZ = (mip0Depth + pMetaBlkDim->d - 1) / pMetaBlkDim->d;
382 UINT_32 tailWidth = pMetaBlkDim->w;
383 UINT_32 tailHeight = pMetaBlkDim->h >> 1;
384 UINT_32 tailDepth = pMetaBlkDim->d;
385 BOOL_32 inTail = FALSE;
386 AddrMajorMode major = ADDR_MAJOR_MAX_TYPE;
387
388 if (numMipLevels > 1)
389 {
390 if (dataThick && (numMetaBlkZ > numMetaBlkX) && (numMetaBlkZ > numMetaBlkY))
391 {
392 // Z major
393 major = ADDR_MAJOR_Z;
394 }
395 else if (numMetaBlkX >= numMetaBlkY)
396 {
397 // X major
398 major = ADDR_MAJOR_X;
399 }
400 else
401 {
402 // Y major
403 major = ADDR_MAJOR_Y;
404 }
405
406 inTail = ((mip0Width <= tailWidth) &&
407 (mip0Height <= tailHeight) &&
408 ((dataThick == FALSE) || (mip0Depth <= tailDepth)));
409
410 if (inTail == FALSE)
411 {
412 UINT_32 orderLimit;
413 UINT_32 *pMipDim;
414 UINT_32 *pOrderDim;
415
416 if (major == ADDR_MAJOR_Z)
417 {
418 // Z major
419 pMipDim = &numMetaBlkY;
420 pOrderDim = &numMetaBlkZ;
421 orderLimit = 4;
422 }
423 else if (major == ADDR_MAJOR_X)
424 {
425 // X major
426 pMipDim = &numMetaBlkY;
427 pOrderDim = &numMetaBlkX;
428 orderLimit = 4;
429 }
430 else
431 {
432 // Y major
433 pMipDim = &numMetaBlkX;
434 pOrderDim = &numMetaBlkY;
435 orderLimit = 2;
436 }
437
438 if ((*pMipDim < 3) && (*pOrderDim > orderLimit) && (numMipLevels > 3))
439 {
440 *pMipDim += 2;
441 }
442 else
443 {
444 *pMipDim += ((*pMipDim / 2) + (*pMipDim & 1));
445 }
446 }
447 }
448
449 if (pInfo != NULL)
450 {
451 UINT_32 mipWidth = mip0Width;
452 UINT_32 mipHeight = mip0Height;
453 UINT_32 mipDepth = mip0Depth;
454 Dim3d mipCoord = {0};
455
456 for (UINT_32 mip = 0; mip < numMipLevels; mip++)
457 {
458 if (inTail)
459 {
460 GetMetaMiptailInfo(&pInfo[mip], mipCoord, numMipLevels - mip,
461 pMetaBlkDim);
462 break;
463 }
464 else
465 {
466 mipWidth = PowTwoAlign(mipWidth, pMetaBlkDim->w);
467 mipHeight = PowTwoAlign(mipHeight, pMetaBlkDim->h);
468 mipDepth = PowTwoAlign(mipDepth, pMetaBlkDim->d);
469
470 pInfo[mip].inMiptail = FALSE;
471 pInfo[mip].startX = mipCoord.w;
472 pInfo[mip].startY = mipCoord.h;
473 pInfo[mip].startZ = mipCoord.d;
474 pInfo[mip].width = mipWidth;
475 pInfo[mip].height = mipHeight;
476 pInfo[mip].depth = dataThick ? mipDepth : 1;
477
478 if ((mip >= 3) || (mip & 1))
479 {
480 switch (major)
481 {
482 case ADDR_MAJOR_X:
483 mipCoord.w += mipWidth;
484 break;
485 case ADDR_MAJOR_Y:
486 mipCoord.h += mipHeight;
487 break;
488 case ADDR_MAJOR_Z:
489 mipCoord.d += mipDepth;
490 break;
491 default:
492 break;
493 }
494 }
495 else
496 {
497 switch (major)
498 {
499 case ADDR_MAJOR_X:
500 mipCoord.h += mipHeight;
501 break;
502 case ADDR_MAJOR_Y:
503 mipCoord.w += mipWidth;
504 break;
505 case ADDR_MAJOR_Z:
506 mipCoord.h += mipHeight;
507 break;
508 default:
509 break;
510 }
511 }
512
513 mipWidth = Max(mipWidth >> 1, 1u);
514 mipHeight = Max(mipHeight >> 1, 1u);
515 mipDepth = Max(mipDepth >> 1, 1u);
516
517 inTail = ((mipWidth <= tailWidth) &&
518 (mipHeight <= tailHeight) &&
519 ((dataThick == FALSE) || (mipDepth <= tailDepth)));
520 }
521 }
522 }
523
524 *pNumMetaBlkX = numMetaBlkX;
525 *pNumMetaBlkY = numMetaBlkY;
526 *pNumMetaBlkZ = numMetaBlkZ;
527 }
528
529 /**
530 ************************************************************************************************************************
531 * Gfx9Lib::HwlComputeDccInfo
532 *
533 * @brief
534 * Interface function to compute DCC key info
535 *
536 * @return
537 * ADDR_E_RETURNCODE
538 ************************************************************************************************************************
539 */
540 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeDccInfo(
541 const ADDR2_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input structure
542 ADDR2_COMPUTE_DCCINFO_OUTPUT* pOut ///< [out] output structure
543 ) const
544 {
545 BOOL_32 dataLinear = IsLinear(pIn->swizzleMode);
546 BOOL_32 metaLinear = pIn->dccKeyFlags.linear;
547 BOOL_32 pipeAligned = pIn->dccKeyFlags.pipeAligned;
548
549 if (dataLinear)
550 {
551 metaLinear = TRUE;
552 }
553 else if (metaLinear == TRUE)
554 {
555 pipeAligned = FALSE;
556 }
557
558 UINT_32 numPipeTotal = GetPipeNumForMetaAddressing(pipeAligned, pIn->swizzleMode);
559
560 if (metaLinear)
561 {
562 // Linear metadata supporting was removed for GFX9! No one can use this feature on GFX9.
563 ADDR_ASSERT_ALWAYS();
564
565 pOut->dccRamBaseAlign = numPipeTotal * m_pipeInterleaveBytes;
566 pOut->dccRamSize = PowTwoAlign((pIn->dataSurfaceSize / 256), pOut->dccRamBaseAlign);
567 }
568 else
569 {
570 BOOL_32 dataThick = IsThick(pIn->resourceType, pIn->swizzleMode);
571
572 UINT_32 minMetaBlkSize = dataThick ? 65536 : 4096;
573
574 UINT_32 numFrags = Max(pIn->numFrags, 1u);
575 UINT_32 numSlices = Max(pIn->numSlices, 1u);
576
577 minMetaBlkSize /= numFrags;
578
579 UINT_32 numCompressBlkPerMetaBlk = minMetaBlkSize;
580
581 UINT_32 numRbTotal = pIn->dccKeyFlags.rbAligned ? m_se * m_rbPerSe : 1;
582
583 if ((numPipeTotal > 1) || (numRbTotal > 1))
584 {
585 const UINT_32 thinBlkSize = 1 << (m_settings.applyAliasFix ? Max(10u, m_pipeInterleaveLog2) : 10);
586
587 numCompressBlkPerMetaBlk =
588 Max(numCompressBlkPerMetaBlk, m_se * m_rbPerSe * (dataThick ? 262144 : thinBlkSize));
589
590 if (numCompressBlkPerMetaBlk > 65536 * pIn->bpp)
591 {
592 numCompressBlkPerMetaBlk = 65536 * pIn->bpp;
593 }
594 }
595
596 Dim3d compressBlkDim = GetDccCompressBlk(pIn->resourceType, pIn->swizzleMode, pIn->bpp);
597 Dim3d metaBlkDim = compressBlkDim;
598
599 for (UINT_32 index = 1; index < numCompressBlkPerMetaBlk; index <<= 1)
600 {
601 if ((metaBlkDim.h < metaBlkDim.w) ||
602 ((pIn->numMipLevels > 1) && (metaBlkDim.h == metaBlkDim.w)))
603 {
604 if ((dataThick == FALSE) || (metaBlkDim.h <= metaBlkDim.d))
605 {
606 metaBlkDim.h <<= 1;
607 }
608 else
609 {
610 metaBlkDim.d <<= 1;
611 }
612 }
613 else
614 {
615 if ((dataThick == FALSE) || (metaBlkDim.w <= metaBlkDim.d))
616 {
617 metaBlkDim.w <<= 1;
618 }
619 else
620 {
621 metaBlkDim.d <<= 1;
622 }
623 }
624 }
625
626 UINT_32 numMetaBlkX;
627 UINT_32 numMetaBlkY;
628 UINT_32 numMetaBlkZ;
629
630 GetMetaMipInfo(pIn->numMipLevels, &metaBlkDim, dataThick, pOut->pMipInfo,
631 pIn->unalignedWidth, pIn->unalignedHeight, numSlices,
632 &numMetaBlkX, &numMetaBlkY, &numMetaBlkZ);
633
634 UINT_32 sizeAlign = numPipeTotal * numRbTotal * m_pipeInterleaveBytes;
635
636 if (numFrags > m_maxCompFrag)
637 {
638 sizeAlign *= (numFrags / m_maxCompFrag);
639 }
640
641 pOut->dccRamSize = numMetaBlkX * numMetaBlkY * numMetaBlkZ *
642 numCompressBlkPerMetaBlk * numFrags;
643 pOut->dccRamSize = PowTwoAlign(pOut->dccRamSize, sizeAlign);
644 pOut->dccRamBaseAlign = Max(numCompressBlkPerMetaBlk, sizeAlign);
645
646 if (m_settings.metaBaseAlignFix)
647 {
648 pOut->dccRamBaseAlign = Max(pOut->dccRamBaseAlign, GetBlockSize(pIn->swizzleMode));
649 }
650
651 pOut->pitch = numMetaBlkX * metaBlkDim.w;
652 pOut->height = numMetaBlkY * metaBlkDim.h;
653 pOut->depth = numMetaBlkZ * metaBlkDim.d;
654
655 pOut->compressBlkWidth = compressBlkDim.w;
656 pOut->compressBlkHeight = compressBlkDim.h;
657 pOut->compressBlkDepth = compressBlkDim.d;
658
659 pOut->metaBlkWidth = metaBlkDim.w;
660 pOut->metaBlkHeight = metaBlkDim.h;
661 pOut->metaBlkDepth = metaBlkDim.d;
662
663 pOut->metaBlkNumPerSlice = numMetaBlkX * numMetaBlkY;
664 pOut->fastClearSizePerSlice =
665 pOut->metaBlkNumPerSlice * numCompressBlkPerMetaBlk * Min(numFrags, m_maxCompFrag);
666 }
667
668 return ADDR_OK;
669 }
670
671 /**
672 ************************************************************************************************************************
673 * Gfx9Lib::HwlGetMaxAlignments
674 *
675 * @brief
676 * Gets maximum alignments
677 * @return
678 * ADDR_E_RETURNCODE
679 ************************************************************************************************************************
680 */
681 ADDR_E_RETURNCODE Gfx9Lib::HwlGetMaxAlignments(
682 ADDR_GET_MAX_ALIGNMENTS_OUTPUT* pOut ///< [out] output structure
683 ) const
684 {
685 pOut->baseAlign = HwlComputeSurfaceBaseAlign(ADDR_SW_64KB);
686
687 return ADDR_OK;
688 }
689
690 /**
691 ************************************************************************************************************************
692 * Gfx9Lib::HwlComputeCmaskAddrFromCoord
693 *
694 * @brief
695 * Interface function stub of AddrComputeCmaskAddrFromCoord
696 *
697 * @return
698 * ADDR_E_RETURNCODE
699 ************************************************************************************************************************
700 */
701 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeCmaskAddrFromCoord(
702 const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
703 ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] output structure
704 {
705 ADDR2_COMPUTE_CMASK_INFO_INPUT input = {0};
706 input.size = sizeof(input);
707 input.cMaskFlags = pIn->cMaskFlags;
708 input.colorFlags = pIn->colorFlags;
709 input.unalignedWidth = Max(pIn->unalignedWidth, 1u);
710 input.unalignedHeight = Max(pIn->unalignedHeight, 1u);
711 input.numSlices = Max(pIn->numSlices, 1u);
712 input.swizzleMode = pIn->swizzleMode;
713 input.resourceType = pIn->resourceType;
714
715 ADDR2_COMPUTE_CMASK_INFO_OUTPUT output = {0};
716 output.size = sizeof(output);
717
718 ADDR_E_RETURNCODE returnCode = ComputeCmaskInfo(&input, &output);
719
720 if (returnCode == ADDR_OK)
721 {
722 UINT_32 fmaskBpp = GetFmaskBpp(pIn->numSamples, pIn->numFrags);
723 UINT_32 fmaskElementBytesLog2 = Log2(fmaskBpp >> 3);
724 UINT_32 metaBlkWidthLog2 = Log2(output.metaBlkWidth);
725 UINT_32 metaBlkHeightLog2 = Log2(output.metaBlkHeight);
726
727 const CoordEq* pMetaEq = GetMetaEquation({0, fmaskElementBytesLog2, 0, pIn->cMaskFlags,
728 Gfx9DataFmask, pIn->swizzleMode, pIn->resourceType,
729 metaBlkWidthLog2, metaBlkHeightLog2, 0, 3, 3, 0});
730
731 UINT_32 xb = pIn->x / output.metaBlkWidth;
732 UINT_32 yb = pIn->y / output.metaBlkHeight;
733 UINT_32 zb = pIn->slice;
734
735 UINT_32 pitchInBlock = output.pitch / output.metaBlkWidth;
736 UINT_32 sliceSizeInBlock = (output.height / output.metaBlkHeight) * pitchInBlock;
737 UINT_32 blockIndex = zb * sliceSizeInBlock + yb * pitchInBlock + xb;
738
739 UINT_64 address = pMetaEq->solve(pIn->x, pIn->y, pIn->slice, 0, blockIndex);
740
741 pOut->addr = address >> 1;
742 pOut->bitPosition = static_cast<UINT_32>((address & 1) << 2);
743
744
745 UINT_32 numPipeBits = GetPipeLog2ForMetaAddressing(pIn->cMaskFlags.pipeAligned,
746 pIn->swizzleMode);
747
748 UINT_64 pipeXor = static_cast<UINT_64>(pIn->pipeXor & ((1 << numPipeBits) - 1));
749
750 pOut->addr ^= (pipeXor << m_pipeInterleaveLog2);
751 }
752
753 return returnCode;
754 }
755
756 /**
757 ************************************************************************************************************************
758 * Gfx9Lib::HwlComputeHtileAddrFromCoord
759 *
760 * @brief
761 * Interface function stub of AddrComputeHtileAddrFromCoord
762 *
763 * @return
764 * ADDR_E_RETURNCODE
765 ************************************************************************************************************************
766 */
767 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeHtileAddrFromCoord(
768 const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
769 ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] output structure
770 {
771 ADDR_E_RETURNCODE returnCode = ADDR_OK;
772
773 if (pIn->numMipLevels > 1)
774 {
775 returnCode = ADDR_NOTIMPLEMENTED;
776 }
777 else
778 {
779 ADDR2_COMPUTE_HTILE_INFO_INPUT input = {0};
780 input.size = sizeof(input);
781 input.hTileFlags = pIn->hTileFlags;
782 input.depthFlags = pIn->depthflags;
783 input.swizzleMode = pIn->swizzleMode;
784 input.unalignedWidth = Max(pIn->unalignedWidth, 1u);
785 input.unalignedHeight = Max(pIn->unalignedHeight, 1u);
786 input.numSlices = Max(pIn->numSlices, 1u);
787 input.numMipLevels = Max(pIn->numMipLevels, 1u);
788
789 ADDR2_COMPUTE_HTILE_INFO_OUTPUT output = {0};
790 output.size = sizeof(output);
791
792 returnCode = ComputeHtileInfo(&input, &output);
793
794 if (returnCode == ADDR_OK)
795 {
796 UINT_32 elementBytesLog2 = Log2(pIn->bpp >> 3);
797 UINT_32 metaBlkWidthLog2 = Log2(output.metaBlkWidth);
798 UINT_32 metaBlkHeightLog2 = Log2(output.metaBlkHeight);
799 UINT_32 numSamplesLog2 = Log2(pIn->numSamples);
800
801 const CoordEq* pMetaEq = GetMetaEquation({0, elementBytesLog2, numSamplesLog2, pIn->hTileFlags,
802 Gfx9DataDepthStencil, pIn->swizzleMode, ADDR_RSRC_TEX_2D,
803 metaBlkWidthLog2, metaBlkHeightLog2, 0, 3, 3, 0});
804
805 UINT_32 xb = pIn->x / output.metaBlkWidth;
806 UINT_32 yb = pIn->y / output.metaBlkHeight;
807 UINT_32 zb = pIn->slice;
808
809 UINT_32 pitchInBlock = output.pitch / output.metaBlkWidth;
810 UINT_32 sliceSizeInBlock = (output.height / output.metaBlkHeight) * pitchInBlock;
811 UINT_32 blockIndex = zb * sliceSizeInBlock + yb * pitchInBlock + xb;
812
813 UINT_64 address = pMetaEq->solve(pIn->x, pIn->y, pIn->slice, 0, blockIndex);
814
815 pOut->addr = address >> 1;
816
817 UINT_32 numPipeBits = GetPipeLog2ForMetaAddressing(pIn->hTileFlags.pipeAligned,
818 pIn->swizzleMode);
819
820 UINT_64 pipeXor = static_cast<UINT_64>(pIn->pipeXor & ((1 << numPipeBits) - 1));
821
822 pOut->addr ^= (pipeXor << m_pipeInterleaveLog2);
823 }
824 }
825
826 return returnCode;
827 }
828
829 /**
830 ************************************************************************************************************************
831 * Gfx9Lib::HwlComputeHtileCoordFromAddr
832 *
833 * @brief
834 * Interface function stub of AddrComputeHtileCoordFromAddr
835 *
836 * @return
837 * ADDR_E_RETURNCODE
838 ************************************************************************************************************************
839 */
840 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeHtileCoordFromAddr(
841 const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
842 ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) ///< [out] output structure
843 {
844 ADDR_E_RETURNCODE returnCode = ADDR_OK;
845
846 if (pIn->numMipLevels > 1)
847 {
848 returnCode = ADDR_NOTIMPLEMENTED;
849 }
850 else
851 {
852 ADDR2_COMPUTE_HTILE_INFO_INPUT input = {0};
853 input.size = sizeof(input);
854 input.hTileFlags = pIn->hTileFlags;
855 input.swizzleMode = pIn->swizzleMode;
856 input.unalignedWidth = Max(pIn->unalignedWidth, 1u);
857 input.unalignedHeight = Max(pIn->unalignedHeight, 1u);
858 input.numSlices = Max(pIn->numSlices, 1u);
859 input.numMipLevels = Max(pIn->numMipLevels, 1u);
860
861 ADDR2_COMPUTE_HTILE_INFO_OUTPUT output = {0};
862 output.size = sizeof(output);
863
864 returnCode = ComputeHtileInfo(&input, &output);
865
866 if (returnCode == ADDR_OK)
867 {
868 UINT_32 elementBytesLog2 = Log2(pIn->bpp >> 3);
869 UINT_32 metaBlkWidthLog2 = Log2(output.metaBlkWidth);
870 UINT_32 metaBlkHeightLog2 = Log2(output.metaBlkHeight);
871 UINT_32 numSamplesLog2 = Log2(pIn->numSamples);
872
873 const CoordEq* pMetaEq = GetMetaEquation({0, elementBytesLog2, numSamplesLog2, pIn->hTileFlags,
874 Gfx9DataDepthStencil, pIn->swizzleMode, ADDR_RSRC_TEX_2D,
875 metaBlkWidthLog2, metaBlkHeightLog2, 0, 3, 3, 0});
876
877 UINT_32 numPipeBits = GetPipeLog2ForMetaAddressing(pIn->hTileFlags.pipeAligned,
878 pIn->swizzleMode);
879
880 UINT_64 pipeXor = static_cast<UINT_64>(pIn->pipeXor & ((1 << numPipeBits) - 1));
881
882 UINT_64 nibbleAddress = (pIn->addr ^ (pipeXor << m_pipeInterleaveLog2)) << 1;
883
884 UINT_32 pitchInBlock = output.pitch / output.metaBlkWidth;
885 UINT_32 sliceSizeInBlock = (output.height / output.metaBlkHeight) * pitchInBlock;
886
887 UINT_32 x, y, z, s, m;
888 pMetaEq->solveAddr(nibbleAddress, sliceSizeInBlock, x, y, z, s, m);
889
890 pOut->slice = m / sliceSizeInBlock;
891 pOut->y = ((m % sliceSizeInBlock) / pitchInBlock) * output.metaBlkHeight + y;
892 pOut->x = (m % pitchInBlock) * output.metaBlkWidth + x;
893 }
894 }
895
896 return returnCode;
897 }
898
899 /**
900 ************************************************************************************************************************
901 * Gfx9Lib::HwlComputeDccAddrFromCoord
902 *
903 * @brief
904 * Interface function stub of AddrComputeDccAddrFromCoord
905 *
906 * @return
907 * ADDR_E_RETURNCODE
908 ************************************************************************************************************************
909 */
910 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeDccAddrFromCoord(
911 const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT* pIn,
912 ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT* pOut)
913 {
914 ADDR_E_RETURNCODE returnCode = ADDR_OK;
915
916 if ((pIn->numMipLevels > 1) || (pIn->mipId > 1) || pIn->dccKeyFlags.linear)
917 {
918 returnCode = ADDR_NOTIMPLEMENTED;
919 }
920 else
921 {
922 ADDR2_COMPUTE_DCCINFO_INPUT input = {0};
923 input.size = sizeof(input);
924 input.dccKeyFlags = pIn->dccKeyFlags;
925 input.colorFlags = pIn->colorFlags;
926 input.swizzleMode = pIn->swizzleMode;
927 input.resourceType = pIn->resourceType;
928 input.bpp = pIn->bpp;
929 input.unalignedWidth = Max(pIn->unalignedWidth, 1u);
930 input.unalignedHeight = Max(pIn->unalignedHeight, 1u);
931 input.numSlices = Max(pIn->numSlices, 1u);
932 input.numFrags = Max(pIn->numFrags, 1u);
933 input.numMipLevels = Max(pIn->numMipLevels, 1u);
934
935 ADDR2_COMPUTE_DCCINFO_OUTPUT output = {0};
936 output.size = sizeof(output);
937
938 returnCode = ComputeDccInfo(&input, &output);
939
940 if (returnCode == ADDR_OK)
941 {
942 UINT_32 elementBytesLog2 = Log2(pIn->bpp >> 3);
943 UINT_32 numSamplesLog2 = Log2(pIn->numFrags);
944 UINT_32 metaBlkWidthLog2 = Log2(output.metaBlkWidth);
945 UINT_32 metaBlkHeightLog2 = Log2(output.metaBlkHeight);
946 UINT_32 metaBlkDepthLog2 = Log2(output.metaBlkDepth);
947 UINT_32 compBlkWidthLog2 = Log2(output.compressBlkWidth);
948 UINT_32 compBlkHeightLog2 = Log2(output.compressBlkHeight);
949 UINT_32 compBlkDepthLog2 = Log2(output.compressBlkDepth);
950
951 const CoordEq* pMetaEq = GetMetaEquation({pIn->mipId, elementBytesLog2, numSamplesLog2, pIn->dccKeyFlags,
952 Gfx9DataColor, pIn->swizzleMode, pIn->resourceType,
953 metaBlkWidthLog2, metaBlkHeightLog2, metaBlkDepthLog2,
954 compBlkWidthLog2, compBlkHeightLog2, compBlkDepthLog2});
955
956 UINT_32 xb = pIn->x / output.metaBlkWidth;
957 UINT_32 yb = pIn->y / output.metaBlkHeight;
958 UINT_32 zb = pIn->slice / output.metaBlkDepth;
959
960 UINT_32 pitchInBlock = output.pitch / output.metaBlkWidth;
961 UINT_32 sliceSizeInBlock = (output.height / output.metaBlkHeight) * pitchInBlock;
962 UINT_32 blockIndex = zb * sliceSizeInBlock + yb * pitchInBlock + xb;
963
964 UINT_64 address = pMetaEq->solve(pIn->x, pIn->y, pIn->slice, pIn->sample, blockIndex);
965
966 pOut->addr = address >> 1;
967
968 UINT_32 numPipeBits = GetPipeLog2ForMetaAddressing(pIn->dccKeyFlags.pipeAligned,
969 pIn->swizzleMode);
970
971 UINT_64 pipeXor = static_cast<UINT_64>(pIn->pipeXor & ((1 << numPipeBits) - 1));
972
973 pOut->addr ^= (pipeXor << m_pipeInterleaveLog2);
974 }
975 }
976
977 return returnCode;
978 }
979
980 /**
981 ************************************************************************************************************************
982 * Gfx9Lib::HwlInitGlobalParams
983 *
984 * @brief
985 * Initializes global parameters
986 *
987 * @return
988 * TRUE if all settings are valid
989 *
990 ************************************************************************************************************************
991 */
992 BOOL_32 Gfx9Lib::HwlInitGlobalParams(
993 const ADDR_CREATE_INPUT* pCreateIn) ///< [in] create input
994 {
995 BOOL_32 valid = TRUE;
996
997 if (m_settings.isArcticIsland)
998 {
999 GB_ADDR_CONFIG gbAddrConfig;
1000
1001 gbAddrConfig.u32All = pCreateIn->regValue.gbAddrConfig;
1002
1003 // These values are copied from CModel code
1004 switch (gbAddrConfig.bits.NUM_PIPES)
1005 {
1006 case ADDR_CONFIG_1_PIPE:
1007 m_pipes = 1;
1008 m_pipesLog2 = 0;
1009 break;
1010 case ADDR_CONFIG_2_PIPE:
1011 m_pipes = 2;
1012 m_pipesLog2 = 1;
1013 break;
1014 case ADDR_CONFIG_4_PIPE:
1015 m_pipes = 4;
1016 m_pipesLog2 = 2;
1017 break;
1018 case ADDR_CONFIG_8_PIPE:
1019 m_pipes = 8;
1020 m_pipesLog2 = 3;
1021 break;
1022 case ADDR_CONFIG_16_PIPE:
1023 m_pipes = 16;
1024 m_pipesLog2 = 4;
1025 break;
1026 case ADDR_CONFIG_32_PIPE:
1027 m_pipes = 32;
1028 m_pipesLog2 = 5;
1029 break;
1030 default:
1031 ADDR_ASSERT_ALWAYS();
1032 break;
1033 }
1034
1035 switch (gbAddrConfig.bits.PIPE_INTERLEAVE_SIZE)
1036 {
1037 case ADDR_CONFIG_PIPE_INTERLEAVE_256B:
1038 m_pipeInterleaveBytes = ADDR_PIPEINTERLEAVE_256B;
1039 m_pipeInterleaveLog2 = 8;
1040 break;
1041 case ADDR_CONFIG_PIPE_INTERLEAVE_512B:
1042 m_pipeInterleaveBytes = ADDR_PIPEINTERLEAVE_512B;
1043 m_pipeInterleaveLog2 = 9;
1044 break;
1045 case ADDR_CONFIG_PIPE_INTERLEAVE_1KB:
1046 m_pipeInterleaveBytes = ADDR_PIPEINTERLEAVE_1KB;
1047 m_pipeInterleaveLog2 = 10;
1048 break;
1049 case ADDR_CONFIG_PIPE_INTERLEAVE_2KB:
1050 m_pipeInterleaveBytes = ADDR_PIPEINTERLEAVE_2KB;
1051 m_pipeInterleaveLog2 = 11;
1052 break;
1053 default:
1054 ADDR_ASSERT_ALWAYS();
1055 break;
1056 }
1057
1058 switch (gbAddrConfig.bits.NUM_BANKS)
1059 {
1060 case ADDR_CONFIG_1_BANK:
1061 m_banks = 1;
1062 m_banksLog2 = 0;
1063 break;
1064 case ADDR_CONFIG_2_BANK:
1065 m_banks = 2;
1066 m_banksLog2 = 1;
1067 break;
1068 case ADDR_CONFIG_4_BANK:
1069 m_banks = 4;
1070 m_banksLog2 = 2;
1071 break;
1072 case ADDR_CONFIG_8_BANK:
1073 m_banks = 8;
1074 m_banksLog2 = 3;
1075 break;
1076 case ADDR_CONFIG_16_BANK:
1077 m_banks = 16;
1078 m_banksLog2 = 4;
1079 break;
1080 default:
1081 ADDR_ASSERT_ALWAYS();
1082 break;
1083 }
1084
1085 switch (gbAddrConfig.bits.NUM_SHADER_ENGINES)
1086 {
1087 case ADDR_CONFIG_1_SHADER_ENGINE:
1088 m_se = 1;
1089 m_seLog2 = 0;
1090 break;
1091 case ADDR_CONFIG_2_SHADER_ENGINE:
1092 m_se = 2;
1093 m_seLog2 = 1;
1094 break;
1095 case ADDR_CONFIG_4_SHADER_ENGINE:
1096 m_se = 4;
1097 m_seLog2 = 2;
1098 break;
1099 case ADDR_CONFIG_8_SHADER_ENGINE:
1100 m_se = 8;
1101 m_seLog2 = 3;
1102 break;
1103 default:
1104 ADDR_ASSERT_ALWAYS();
1105 break;
1106 }
1107
1108 switch (gbAddrConfig.bits.NUM_RB_PER_SE)
1109 {
1110 case ADDR_CONFIG_1_RB_PER_SHADER_ENGINE:
1111 m_rbPerSe = 1;
1112 m_rbPerSeLog2 = 0;
1113 break;
1114 case ADDR_CONFIG_2_RB_PER_SHADER_ENGINE:
1115 m_rbPerSe = 2;
1116 m_rbPerSeLog2 = 1;
1117 break;
1118 case ADDR_CONFIG_4_RB_PER_SHADER_ENGINE:
1119 m_rbPerSe = 4;
1120 m_rbPerSeLog2 = 2;
1121 break;
1122 default:
1123 ADDR_ASSERT_ALWAYS();
1124 break;
1125 }
1126
1127 switch (gbAddrConfig.bits.MAX_COMPRESSED_FRAGS)
1128 {
1129 case ADDR_CONFIG_1_MAX_COMPRESSED_FRAGMENTS:
1130 m_maxCompFrag = 1;
1131 m_maxCompFragLog2 = 0;
1132 break;
1133 case ADDR_CONFIG_2_MAX_COMPRESSED_FRAGMENTS:
1134 m_maxCompFrag = 2;
1135 m_maxCompFragLog2 = 1;
1136 break;
1137 case ADDR_CONFIG_4_MAX_COMPRESSED_FRAGMENTS:
1138 m_maxCompFrag = 4;
1139 m_maxCompFragLog2 = 2;
1140 break;
1141 case ADDR_CONFIG_8_MAX_COMPRESSED_FRAGMENTS:
1142 m_maxCompFrag = 8;
1143 m_maxCompFragLog2 = 3;
1144 break;
1145 default:
1146 ADDR_ASSERT_ALWAYS();
1147 break;
1148 }
1149
1150 m_blockVarSizeLog2 = pCreateIn->regValue.blockVarSizeLog2;
1151 ADDR_ASSERT((m_blockVarSizeLog2 == 0) ||
1152 ((m_blockVarSizeLog2 >= 17u) && (m_blockVarSizeLog2 <= 20u)));
1153 m_blockVarSizeLog2 = Min(Max(17u, m_blockVarSizeLog2), 20u);
1154 }
1155 else
1156 {
1157 valid = FALSE;
1158 ADDR_NOT_IMPLEMENTED();
1159 }
1160
1161 if (valid)
1162 {
1163 InitEquationTable();
1164 }
1165
1166 return valid;
1167 }
1168
1169 /**
1170 ************************************************************************************************************************
1171 * Gfx9Lib::HwlConvertChipFamily
1172 *
1173 * @brief
1174 * Convert familyID defined in atiid.h to ChipFamily and set m_chipFamily/m_chipRevision
1175 * @return
1176 * ChipFamily
1177 ************************************************************************************************************************
1178 */
1179 ChipFamily Gfx9Lib::HwlConvertChipFamily(
1180 UINT_32 uChipFamily, ///< [in] chip family defined in atiih.h
1181 UINT_32 uChipRevision) ///< [in] chip revision defined in "asic_family"_id.h
1182 {
1183 ChipFamily family = ADDR_CHIP_FAMILY_AI;
1184
1185 switch (uChipFamily)
1186 {
1187 case FAMILY_AI:
1188 m_settings.isArcticIsland = 1;
1189 m_settings.isVega10 = ASICREV_IS_VEGA10_P(uChipRevision);
1190
1191 m_settings.isDce12 = 1;
1192
1193 if (m_settings.isVega10 == 0)
1194 {
1195 m_settings.htileAlignFix = 1;
1196 m_settings.applyAliasFix = 1;
1197 }
1198
1199 m_settings.metaBaseAlignFix = 1;
1200
1201 m_settings.depthPipeXorDisable = 1;
1202 break;
1203 case FAMILY_RV:
1204 m_settings.isArcticIsland = 1;
1205 m_settings.isRaven = ASICREV_IS_RAVEN(uChipRevision);
1206
1207 if (m_settings.isRaven)
1208 {
1209 m_settings.isDcn1 = 1;
1210 }
1211
1212 m_settings.metaBaseAlignFix = 1;
1213
1214 if (ASICREV_IS_RAVEN(uChipRevision))
1215 {
1216 m_settings.depthPipeXorDisable = 1;
1217 }
1218 break;
1219
1220 default:
1221 ADDR_ASSERT(!"This should be a Fusion");
1222 break;
1223 }
1224
1225 return family;
1226 }
1227
1228 /**
1229 ************************************************************************************************************************
1230 * Gfx9Lib::InitRbEquation
1231 *
1232 * @brief
1233 * Init RB equation
1234 * @return
1235 * N/A
1236 ************************************************************************************************************************
1237 */
1238 VOID Gfx9Lib::GetRbEquation(
1239 CoordEq* pRbEq, ///< [out] rb equation
1240 UINT_32 numRbPerSeLog2, ///< [in] number of rb per shader engine
1241 UINT_32 numSeLog2) ///< [in] number of shader engine
1242 const
1243 {
1244 // RB's are distributed on 16x16, except when we have 1 rb per se, in which case its 32x32
1245 UINT_32 rbRegion = (numRbPerSeLog2 == 0) ? 5 : 4;
1246 Coordinate cx('x', rbRegion);
1247 Coordinate cy('y', rbRegion);
1248
1249 UINT_32 start = 0;
1250 UINT_32 numRbTotalLog2 = numRbPerSeLog2 + numSeLog2;
1251
1252 // Clear the rb equation
1253 pRbEq->resize(0);
1254 pRbEq->resize(numRbTotalLog2);
1255
1256 if ((numSeLog2 > 0) && (numRbPerSeLog2 == 1))
1257 {
1258 // Special case when more than 1 SE, and 2 RB per SE
1259 (*pRbEq)[0].add(cx);
1260 (*pRbEq)[0].add(cy);
1261 cx++;
1262 cy++;
1263
1264 if (m_settings.applyAliasFix == false)
1265 {
1266 (*pRbEq)[0].add(cy);
1267 }
1268
1269 (*pRbEq)[0].add(cy);
1270 start++;
1271 }
1272
1273 UINT_32 numBits = 2 * (numRbTotalLog2 - start);
1274
1275 for (UINT_32 i = 0; i < numBits; i++)
1276 {
1277 UINT_32 idx =
1278 start + (((start + i) >= numRbTotalLog2) ? (2 * (numRbTotalLog2 - start) - i - 1) : i);
1279
1280 if ((i % 2) == 1)
1281 {
1282 (*pRbEq)[idx].add(cx);
1283 cx++;
1284 }
1285 else
1286 {
1287 (*pRbEq)[idx].add(cy);
1288 cy++;
1289 }
1290 }
1291 }
1292
1293 /**
1294 ************************************************************************************************************************
1295 * Gfx9Lib::GetDataEquation
1296 *
1297 * @brief
1298 * Get data equation for fmask and Z
1299 * @return
1300 * N/A
1301 ************************************************************************************************************************
1302 */
1303 VOID Gfx9Lib::GetDataEquation(
1304 CoordEq* pDataEq, ///< [out] data surface equation
1305 Gfx9DataType dataSurfaceType, ///< [in] data surface type
1306 AddrSwizzleMode swizzleMode, ///< [in] data surface swizzle mode
1307 AddrResourceType resourceType, ///< [in] data surface resource type
1308 UINT_32 elementBytesLog2, ///< [in] data surface element bytes
1309 UINT_32 numSamplesLog2) ///< [in] data surface sample count
1310 const
1311 {
1312 Coordinate cx('x', 0);
1313 Coordinate cy('y', 0);
1314 Coordinate cz('z', 0);
1315 Coordinate cs('s', 0);
1316
1317 // Clear the equation
1318 pDataEq->resize(0);
1319 pDataEq->resize(27);
1320
1321 if (dataSurfaceType == Gfx9DataColor)
1322 {
1323 if (IsLinear(swizzleMode))
1324 {
1325 Coordinate cm('m', 0);
1326
1327 pDataEq->resize(49);
1328
1329 for (UINT_32 i = 0; i < 49; i++)
1330 {
1331 (*pDataEq)[i].add(cm);
1332 cm++;
1333 }
1334 }
1335 else if (IsThick(resourceType, swizzleMode))
1336 {
1337 // Color 3d_S and 3d_Z modes, 3d_D is same as color 2d
1338 UINT_32 i;
1339 if (IsStandardSwizzle(resourceType, swizzleMode))
1340 {
1341 // Standard 3d swizzle
1342 // Fill in bottom x bits
1343 for (i = elementBytesLog2; i < 4; i++)
1344 {
1345 (*pDataEq)[i].add(cx);
1346 cx++;
1347 }
1348 // Fill in 2 bits of y and then z
1349 for (i = 4; i < 6; i++)
1350 {
1351 (*pDataEq)[i].add(cy);
1352 cy++;
1353 }
1354 for (i = 6; i < 8; i++)
1355 {
1356 (*pDataEq)[i].add(cz);
1357 cz++;
1358 }
1359 if (elementBytesLog2 < 2)
1360 {
1361 // fill in z & y bit
1362 (*pDataEq)[8].add(cz);
1363 (*pDataEq)[9].add(cy);
1364 cz++;
1365 cy++;
1366 }
1367 else if (elementBytesLog2 == 2)
1368 {
1369 // fill in y and x bit
1370 (*pDataEq)[8].add(cy);
1371 (*pDataEq)[9].add(cx);
1372 cy++;
1373 cx++;
1374 }
1375 else
1376 {
1377 // fill in 2 x bits
1378 (*pDataEq)[8].add(cx);
1379 cx++;
1380 (*pDataEq)[9].add(cx);
1381 cx++;
1382 }
1383 }
1384 else
1385 {
1386 // Z 3d swizzle
1387 UINT_32 m2dEnd = (elementBytesLog2 ==0) ? 3 : ((elementBytesLog2 < 4) ? 4 : 5);
1388 UINT_32 numZs = (elementBytesLog2 == 0 || elementBytesLog2 == 4) ?
1389 2 : ((elementBytesLog2 == 1) ? 3 : 1);
1390 pDataEq->mort2d(cx, cy, elementBytesLog2, m2dEnd);
1391 for (i = m2dEnd + 1; i <= m2dEnd + numZs; i++)
1392 {
1393 (*pDataEq)[i].add(cz);
1394 cz++;
1395 }
1396 if ((elementBytesLog2 == 0) || (elementBytesLog2 == 3))
1397 {
1398 // add an x and z
1399 (*pDataEq)[6].add(cx);
1400 (*pDataEq)[7].add(cz);
1401 cx++;
1402 cz++;
1403 }
1404 else if (elementBytesLog2 == 2)
1405 {
1406 // add a y and z
1407 (*pDataEq)[6].add(cy);
1408 (*pDataEq)[7].add(cz);
1409 cy++;
1410 cz++;
1411 }
1412 // add y and x
1413 (*pDataEq)[8].add(cy);
1414 (*pDataEq)[9].add(cx);
1415 cy++;
1416 cx++;
1417 }
1418 // Fill in bit 10 and up
1419 pDataEq->mort3d( cz, cy, cx, 10 );
1420 }
1421 else if (IsThin(resourceType, swizzleMode))
1422 {
1423 UINT_32 blockSizeLog2 = GetBlockSizeLog2(swizzleMode);
1424 // Color 2D
1425 UINT_32 microYBits = (8 - elementBytesLog2) / 2;
1426 UINT_32 tileSplitStart = blockSizeLog2 - numSamplesLog2;
1427 UINT_32 i;
1428 // Fill in bottom x bits
1429 for (i = elementBytesLog2; i < 4; i++)
1430 {
1431 (*pDataEq)[i].add(cx);
1432 cx++;
1433 }
1434 // Fill in bottom y bits
1435 for (i = 4; i < 4 + microYBits; i++)
1436 {
1437 (*pDataEq)[i].add(cy);
1438 cy++;
1439 }
1440 // Fill in last of the micro_x bits
1441 for (i = 4 + microYBits; i < 8; i++)
1442 {
1443 (*pDataEq)[i].add(cx);
1444 cx++;
1445 }
1446 // Fill in x/y bits below sample split
1447 pDataEq->mort2d(cy, cx, 8, tileSplitStart - 1);
1448 // Fill in sample bits
1449 for (i = 0; i < numSamplesLog2; i++)
1450 {
1451 cs.set('s', i);
1452 (*pDataEq)[tileSplitStart + i].add(cs);
1453 }
1454 // Fill in x/y bits above sample split
1455 if ((numSamplesLog2 & 1) ^ (blockSizeLog2 & 1))
1456 {
1457 pDataEq->mort2d(cx, cy, blockSizeLog2);
1458 }
1459 else
1460 {
1461 pDataEq->mort2d(cy, cx, blockSizeLog2);
1462 }
1463 }
1464 else
1465 {
1466 ADDR_ASSERT_ALWAYS();
1467 }
1468 }
1469 else
1470 {
1471 // Fmask or depth
1472 UINT_32 sampleStart = elementBytesLog2;
1473 UINT_32 pixelStart = elementBytesLog2 + numSamplesLog2;
1474 UINT_32 ymajStart = 6 + numSamplesLog2;
1475
1476 for (UINT_32 s = 0; s < numSamplesLog2; s++)
1477 {
1478 cs.set('s', s);
1479 (*pDataEq)[sampleStart + s].add(cs);
1480 }
1481
1482 // Put in the x-major order pixel bits
1483 pDataEq->mort2d(cx, cy, pixelStart, ymajStart - 1);
1484 // Put in the y-major order pixel bits
1485 pDataEq->mort2d(cy, cx, ymajStart);
1486 }
1487 }
1488
1489 /**
1490 ************************************************************************************************************************
1491 * Gfx9Lib::GetPipeEquation
1492 *
1493 * @brief
1494 * Get pipe equation
1495 * @return
1496 * N/A
1497 ************************************************************************************************************************
1498 */
1499 VOID Gfx9Lib::GetPipeEquation(
1500 CoordEq* pPipeEq, ///< [out] pipe equation
1501 CoordEq* pDataEq, ///< [in] data equation
1502 UINT_32 pipeInterleaveLog2, ///< [in] pipe interleave
1503 UINT_32 numPipeLog2, ///< [in] number of pipes
1504 UINT_32 numSamplesLog2, ///< [in] data surface sample count
1505 Gfx9DataType dataSurfaceType, ///< [in] data surface type
1506 AddrSwizzleMode swizzleMode, ///< [in] data surface swizzle mode
1507 AddrResourceType resourceType ///< [in] data surface resource type
1508 ) const
1509 {
1510 UINT_32 blockSizeLog2 = GetBlockSizeLog2(swizzleMode);
1511 CoordEq dataEq;
1512
1513 pDataEq->copy(dataEq);
1514
1515 if (dataSurfaceType == Gfx9DataColor)
1516 {
1517 INT_32 shift = static_cast<INT_32>(numSamplesLog2);
1518 dataEq.shift(-shift, blockSizeLog2 - numSamplesLog2);
1519 }
1520
1521 dataEq.copy(*pPipeEq, pipeInterleaveLog2, numPipeLog2);
1522
1523 // This section should only apply to z/stencil, maybe fmask
1524 // If the pipe bit is below the comp block size,
1525 // then keep moving up the address until we find a bit that is above
1526 UINT_32 pipeStart = 0;
1527
1528 if (dataSurfaceType != Gfx9DataColor)
1529 {
1530 Coordinate tileMin('x', 3);
1531
1532 while (dataEq[pipeInterleaveLog2 + pipeStart][0] < tileMin)
1533 {
1534 pipeStart++;
1535 }
1536
1537 // if pipe is 0, then the first pipe bit is above the comp block size,
1538 // so we don't need to do anything
1539 // Note, this if condition is not necessary, since if we execute the loop when pipe==0,
1540 // we will get the same pipe equation
1541 if (pipeStart != 0)
1542 {
1543 for (UINT_32 i = 0; i < numPipeLog2; i++)
1544 {
1545 // Copy the jth bit above pipe interleave to the current pipe equation bit
1546 dataEq[pipeInterleaveLog2 + pipeStart + i].copyto((*pPipeEq)[i]);
1547 }
1548 }
1549 }
1550
1551 if (IsPrt(swizzleMode))
1552 {
1553 // Clear out bits above the block size if prt's are enabled
1554 dataEq.resize(blockSizeLog2);
1555 dataEq.resize(48);
1556 }
1557
1558 if (IsXor(swizzleMode))
1559 {
1560 CoordEq xorMask;
1561
1562 if (IsThick(resourceType, swizzleMode))
1563 {
1564 CoordEq xorMask2;
1565
1566 dataEq.copy(xorMask2, pipeInterleaveLog2 + numPipeLog2, 2 * numPipeLog2);
1567
1568 xorMask.resize(numPipeLog2);
1569
1570 for (UINT_32 pipeIdx = 0; pipeIdx < numPipeLog2; pipeIdx++)
1571 {
1572 xorMask[pipeIdx].add(xorMask2[2 * pipeIdx]);
1573 xorMask[pipeIdx].add(xorMask2[2 * pipeIdx + 1]);
1574 }
1575 }
1576 else
1577 {
1578 // Xor in the bits above the pipe+gpu bits
1579 dataEq.copy(xorMask, pipeInterleaveLog2 + pipeStart + numPipeLog2, numPipeLog2);
1580
1581 if ((numSamplesLog2 == 0) && (IsPrt(swizzleMode) == FALSE))
1582 {
1583 Coordinate co;
1584 CoordEq xorMask2;
1585 // if 1xaa and not prt, then xor in the z bits
1586 xorMask2.resize(0);
1587 xorMask2.resize(numPipeLog2);
1588 for (UINT_32 pipeIdx = 0; pipeIdx < numPipeLog2; pipeIdx++)
1589 {
1590 co.set('z', numPipeLog2 - 1 - pipeIdx);
1591 xorMask2[pipeIdx].add(co);
1592 }
1593
1594 pPipeEq->xorin(xorMask2);
1595 }
1596 }
1597
1598 xorMask.reverse();
1599 pPipeEq->xorin(xorMask);
1600 }
1601 }
1602 /**
1603 ************************************************************************************************************************
1604 * Gfx9Lib::GetMetaEquation
1605 *
1606 * @brief
1607 * Get meta equation for cmask/htile/DCC
1608 * @return
1609 * Pointer to a calculated meta equation
1610 ************************************************************************************************************************
1611 */
1612 const CoordEq* Gfx9Lib::GetMetaEquation(
1613 const MetaEqParams& metaEqParams)
1614 {
1615 UINT_32 cachedMetaEqIndex;
1616
1617 for (cachedMetaEqIndex = 0; cachedMetaEqIndex < MaxCachedMetaEq; cachedMetaEqIndex++)
1618 {
1619 if (memcmp(&metaEqParams,
1620 &m_cachedMetaEqKey[cachedMetaEqIndex],
1621 static_cast<UINT_32>(sizeof(metaEqParams))) == 0)
1622 {
1623 break;
1624 }
1625 }
1626
1627 CoordEq* pMetaEq = NULL;
1628
1629 if (cachedMetaEqIndex < MaxCachedMetaEq)
1630 {
1631 pMetaEq = &m_cachedMetaEq[cachedMetaEqIndex];
1632 }
1633 else
1634 {
1635 m_cachedMetaEqKey[m_metaEqOverrideIndex] = metaEqParams;
1636
1637 pMetaEq = &m_cachedMetaEq[m_metaEqOverrideIndex++];
1638
1639 m_metaEqOverrideIndex %= MaxCachedMetaEq;
1640
1641 GenMetaEquation(pMetaEq,
1642 metaEqParams.maxMip,
1643 metaEqParams.elementBytesLog2,
1644 metaEqParams.numSamplesLog2,
1645 metaEqParams.metaFlag,
1646 metaEqParams.dataSurfaceType,
1647 metaEqParams.swizzleMode,
1648 metaEqParams.resourceType,
1649 metaEqParams.metaBlkWidthLog2,
1650 metaEqParams.metaBlkHeightLog2,
1651 metaEqParams.metaBlkDepthLog2,
1652 metaEqParams.compBlkWidthLog2,
1653 metaEqParams.compBlkHeightLog2,
1654 metaEqParams.compBlkDepthLog2);
1655 }
1656
1657 return pMetaEq;
1658 }
1659
1660 /**
1661 ************************************************************************************************************************
1662 * Gfx9Lib::GenMetaEquation
1663 *
1664 * @brief
1665 * Get meta equation for cmask/htile/DCC
1666 * @return
1667 * N/A
1668 ************************************************************************************************************************
1669 */
1670 VOID Gfx9Lib::GenMetaEquation(
1671 CoordEq* pMetaEq, ///< [out] meta equation
1672 UINT_32 maxMip, ///< [in] max mip Id
1673 UINT_32 elementBytesLog2, ///< [in] data surface element bytes
1674 UINT_32 numSamplesLog2, ///< [in] data surface sample count
1675 ADDR2_META_FLAGS metaFlag, ///< [in] meta falg
1676 Gfx9DataType dataSurfaceType, ///< [in] data surface type
1677 AddrSwizzleMode swizzleMode, ///< [in] data surface swizzle mode
1678 AddrResourceType resourceType, ///< [in] data surface resource type
1679 UINT_32 metaBlkWidthLog2, ///< [in] meta block width
1680 UINT_32 metaBlkHeightLog2, ///< [in] meta block height
1681 UINT_32 metaBlkDepthLog2, ///< [in] meta block depth
1682 UINT_32 compBlkWidthLog2, ///< [in] compress block width
1683 UINT_32 compBlkHeightLog2, ///< [in] compress block height
1684 UINT_32 compBlkDepthLog2) ///< [in] compress block depth
1685 const
1686 {
1687 UINT_32 numPipeTotalLog2 = GetPipeLog2ForMetaAddressing(metaFlag.pipeAligned, swizzleMode);
1688 UINT_32 pipeInterleaveLog2 = m_pipeInterleaveLog2;
1689
1690 // Get the correct data address and rb equation
1691 CoordEq dataEq;
1692 GetDataEquation(&dataEq, dataSurfaceType, swizzleMode, resourceType,
1693 elementBytesLog2, numSamplesLog2);
1694
1695 // Get pipe and rb equations
1696 CoordEq pipeEquation;
1697 GetPipeEquation(&pipeEquation, &dataEq, pipeInterleaveLog2, numPipeTotalLog2,
1698 numSamplesLog2, dataSurfaceType, swizzleMode, resourceType);
1699 numPipeTotalLog2 = pipeEquation.getsize();
1700
1701 if (metaFlag.linear)
1702 {
1703 // Linear metadata supporting was removed for GFX9! No one can use this feature.
1704 ADDR_ASSERT_ALWAYS();
1705
1706 ADDR_ASSERT(dataSurfaceType == Gfx9DataColor);
1707
1708 dataEq.copy(*pMetaEq);
1709
1710 if (IsLinear(swizzleMode))
1711 {
1712 if (metaFlag.pipeAligned)
1713 {
1714 // Remove the pipe bits
1715 INT_32 shift = static_cast<INT_32>(numPipeTotalLog2);
1716 pMetaEq->shift(-shift, pipeInterleaveLog2);
1717 }
1718 // Divide by comp block size, which for linear (which is always color) is 256 B
1719 pMetaEq->shift(-8);
1720
1721 if (metaFlag.pipeAligned)
1722 {
1723 // Put pipe bits back in
1724 pMetaEq->shift(numPipeTotalLog2, pipeInterleaveLog2);
1725
1726 for (UINT_32 i = 0; i < numPipeTotalLog2; i++)
1727 {
1728 pipeEquation[i].copyto((*pMetaEq)[pipeInterleaveLog2 + i]);
1729 }
1730 }
1731 }
1732
1733 pMetaEq->shift(1);
1734 }
1735 else
1736 {
1737 UINT_32 maxCompFragLog2 = static_cast<INT_32>(m_maxCompFragLog2);
1738 UINT_32 compFragLog2 =
1739 ((dataSurfaceType == Gfx9DataColor) && (numSamplesLog2 > maxCompFragLog2)) ?
1740 maxCompFragLog2 : numSamplesLog2;
1741
1742 UINT_32 uncompFragLog2 = numSamplesLog2 - compFragLog2;
1743
1744 // Make sure the metaaddr is cleared
1745 pMetaEq->resize(0);
1746 pMetaEq->resize(27);
1747
1748 if (IsThick(resourceType, swizzleMode))
1749 {
1750 Coordinate cx('x', 0);
1751 Coordinate cy('y', 0);
1752 Coordinate cz('z', 0);
1753
1754 if (maxMip > 0)
1755 {
1756 pMetaEq->mort3d(cy, cx, cz);
1757 }
1758 else
1759 {
1760 pMetaEq->mort3d(cx, cy, cz);
1761 }
1762 }
1763 else
1764 {
1765 Coordinate cx('x', 0);
1766 Coordinate cy('y', 0);
1767 Coordinate cs;
1768
1769 if (maxMip > 0)
1770 {
1771 pMetaEq->mort2d(cy, cx, compFragLog2);
1772 }
1773 else
1774 {
1775 pMetaEq->mort2d(cx, cy, compFragLog2);
1776 }
1777
1778 //------------------------------------------------------------------------------------------------------------------------
1779 // Put the compressible fragments at the lsb
1780 // the uncompressible frags will be at the msb of the micro address
1781 //------------------------------------------------------------------------------------------------------------------------
1782 for (UINT_32 s = 0; s < compFragLog2; s++)
1783 {
1784 cs.set('s', s);
1785 (*pMetaEq)[s].add(cs);
1786 }
1787 }
1788
1789 // Keep a copy of the pipe equations
1790 CoordEq origPipeEquation;
1791 pipeEquation.copy(origPipeEquation);
1792
1793 Coordinate co;
1794 // filter out everything under the compressed block size
1795 co.set('x', compBlkWidthLog2);
1796 pMetaEq->Filter('<', co, 0, 'x');
1797 co.set('y', compBlkHeightLog2);
1798 pMetaEq->Filter('<', co, 0, 'y');
1799 co.set('z', compBlkDepthLog2);
1800 pMetaEq->Filter('<', co, 0, 'z');
1801
1802 // For non-color, filter out sample bits
1803 if (dataSurfaceType != Gfx9DataColor)
1804 {
1805 co.set('x', 0);
1806 pMetaEq->Filter('<', co, 0, 's');
1807 }
1808
1809 // filter out everything above the metablock size
1810 co.set('x', metaBlkWidthLog2 - 1);
1811 pMetaEq->Filter('>', co, 0, 'x');
1812 co.set('y', metaBlkHeightLog2 - 1);
1813 pMetaEq->Filter('>', co, 0, 'y');
1814 co.set('z', metaBlkDepthLog2 - 1);
1815 pMetaEq->Filter('>', co, 0, 'z');
1816
1817 // filter out everything above the metablock size for the channel bits
1818 co.set('x', metaBlkWidthLog2 - 1);
1819 pipeEquation.Filter('>', co, 0, 'x');
1820 co.set('y', metaBlkHeightLog2 - 1);
1821 pipeEquation.Filter('>', co, 0, 'y');
1822 co.set('z', metaBlkDepthLog2 - 1);
1823 pipeEquation.Filter('>', co, 0, 'z');
1824
1825 // Make sure we still have the same number of channel bits
1826 if (pipeEquation.getsize() != numPipeTotalLog2)
1827 {
1828 ADDR_ASSERT_ALWAYS();
1829 }
1830
1831 // Loop through all channel and rb bits,
1832 // and make sure these components exist in the metadata address
1833 for (UINT_32 i = 0; i < numPipeTotalLog2; i++)
1834 {
1835 for (UINT_32 j = pipeEquation[i].getsize(); j > 0; j--)
1836 {
1837 if (pMetaEq->Exists(pipeEquation[i][j - 1]) == FALSE)
1838 {
1839 ADDR_ASSERT_ALWAYS();
1840 }
1841 }
1842 }
1843
1844 const UINT_32 numSeLog2 = metaFlag.rbAligned ? m_seLog2 : 0;
1845 const UINT_32 numRbPeSeLog2 = metaFlag.rbAligned ? m_rbPerSeLog2 : 0;
1846 const UINT_32 numRbTotalLog2 = numRbPeSeLog2 + numSeLog2;
1847 CoordEq origRbEquation;
1848
1849 GetRbEquation(&origRbEquation, numRbPeSeLog2, numSeLog2);
1850
1851 CoordEq rbEquation = origRbEquation;
1852
1853 for (UINT_32 i = 0; i < numRbTotalLog2; i++)
1854 {
1855 for (UINT_32 j = rbEquation[i].getsize(); j > 0; j--)
1856 {
1857 if (pMetaEq->Exists(rbEquation[i][j - 1]) == FALSE)
1858 {
1859 ADDR_ASSERT_ALWAYS();
1860 }
1861 }
1862 }
1863
1864 if (m_settings.applyAliasFix)
1865 {
1866 co.set('z', -1);
1867 }
1868
1869 // Loop through each rb id bit; if it is equal to any of the filtered channel bits, clear it
1870 for (UINT_32 i = 0; i < numRbTotalLog2; i++)
1871 {
1872 for (UINT_32 j = 0; j < numPipeTotalLog2; j++)
1873 {
1874 BOOL_32 isRbEquationInPipeEquation = FALSE;
1875
1876 if (m_settings.applyAliasFix)
1877 {
1878 CoordTerm filteredPipeEq;
1879 filteredPipeEq = pipeEquation[j];
1880
1881 filteredPipeEq.Filter('>', co, 0, 'z');
1882
1883 isRbEquationInPipeEquation = (rbEquation[i] == filteredPipeEq);
1884 }
1885 else
1886 {
1887 isRbEquationInPipeEquation = (rbEquation[i] == pipeEquation[j]);
1888 }
1889
1890 if (isRbEquationInPipeEquation)
1891 {
1892 rbEquation[i].Clear();
1893 }
1894 }
1895 }
1896
1897 bool rbAppendedWithPipeBits[1 << (MaxSeLog2 + MaxRbPerSeLog2)] = {};
1898
1899 // Loop through each bit of the channel, get the smallest coordinate,
1900 // and remove it from the metaaddr, and rb_equation
1901 for (UINT_32 i = 0; i < numPipeTotalLog2; i++)
1902 {
1903 pipeEquation[i].getsmallest(co);
1904
1905 UINT_32 old_size = pMetaEq->getsize();
1906 pMetaEq->Filter('=', co);
1907 UINT_32 new_size = pMetaEq->getsize();
1908 if (new_size != old_size-1)
1909 {
1910 ADDR_ASSERT_ALWAYS();
1911 }
1912 pipeEquation.remove(co);
1913 for (UINT_32 j = 0; j < numRbTotalLog2; j++)
1914 {
1915 if (rbEquation[j].remove(co))
1916 {
1917 // if we actually removed something from this bit, then add the remaining
1918 // channel bits, as these can be removed for this bit
1919 for (UINT_32 k = 0; k < pipeEquation[i].getsize(); k++)
1920 {
1921 if (pipeEquation[i][k] != co)
1922 {
1923 rbEquation[j].add(pipeEquation[i][k]);
1924 rbAppendedWithPipeBits[j] = true;
1925 }
1926 }
1927 }
1928 }
1929 }
1930
1931 // Loop through the rb bits and see what remain;
1932 // filter out the smallest coordinate if it remains
1933 UINT_32 rbBitsLeft = 0;
1934 for (UINT_32 i = 0; i < numRbTotalLog2; i++)
1935 {
1936 BOOL_32 isRbEqAppended = FALSE;
1937
1938 if (m_settings.applyAliasFix)
1939 {
1940 isRbEqAppended = (rbEquation[i].getsize() > (rbAppendedWithPipeBits[i] ? 1 : 0));
1941 }
1942 else
1943 {
1944 isRbEqAppended = (rbEquation[i].getsize() > 0);
1945 }
1946
1947 if (isRbEqAppended)
1948 {
1949 rbBitsLeft++;
1950 rbEquation[i].getsmallest(co);
1951 UINT_32 old_size = pMetaEq->getsize();
1952 pMetaEq->Filter('=', co);
1953 UINT_32 new_size = pMetaEq->getsize();
1954 if (new_size != old_size - 1)
1955 {
1956 // assert warning
1957 }
1958 for (UINT_32 j = i + 1; j < numRbTotalLog2; j++)
1959 {
1960 if (rbEquation[j].remove(co))
1961 {
1962 // if we actually removed something from this bit, then add the remaining
1963 // rb bits, as these can be removed for this bit
1964 for (UINT_32 k = 0; k < rbEquation[i].getsize(); k++)
1965 {
1966 if (rbEquation[i][k] != co)
1967 {
1968 rbEquation[j].add(rbEquation[i][k]);
1969 rbAppendedWithPipeBits[j] |= rbAppendedWithPipeBits[i];
1970 }
1971 }
1972 }
1973 }
1974 }
1975 }
1976
1977 // capture the size of the metaaddr
1978 UINT_32 metaSize = pMetaEq->getsize();
1979 // resize to 49 bits...make this a nibble address
1980 pMetaEq->resize(49);
1981 // Concatenate the macro address above the current address
1982 for (UINT_32 i = metaSize, j = 0; i < 49; i++, j++)
1983 {
1984 co.set('m', j);
1985 (*pMetaEq)[i].add(co);
1986 }
1987
1988 // Multiply by meta element size (in nibbles)
1989 if (dataSurfaceType == Gfx9DataColor)
1990 {
1991 pMetaEq->shift(1);
1992 }
1993 else if (dataSurfaceType == Gfx9DataDepthStencil)
1994 {
1995 pMetaEq->shift(3);
1996 }
1997
1998 //------------------------------------------------------------------------------------------
1999 // Note the pipeInterleaveLog2+1 is because address is a nibble address
2000 // Shift up from pipe interleave number of channel
2001 // and rb bits left, and uncompressed fragments
2002 //------------------------------------------------------------------------------------------
2003
2004 pMetaEq->shift(numPipeTotalLog2 + rbBitsLeft + uncompFragLog2, pipeInterleaveLog2 + 1);
2005
2006 // Put in the channel bits
2007 for (UINT_32 i = 0; i < numPipeTotalLog2; i++)
2008 {
2009 origPipeEquation[i].copyto((*pMetaEq)[pipeInterleaveLog2+1 + i]);
2010 }
2011
2012 // Put in remaining rb bits
2013 for (UINT_32 i = 0, j = 0; j < rbBitsLeft; i = (i + 1) % numRbTotalLog2)
2014 {
2015 BOOL_32 isRbEqAppended = FALSE;
2016
2017 if (m_settings.applyAliasFix)
2018 {
2019 isRbEqAppended = (rbEquation[i].getsize() > (rbAppendedWithPipeBits[i] ? 1 : 0));
2020 }
2021 else
2022 {
2023 isRbEqAppended = (rbEquation[i].getsize() > 0);
2024 }
2025
2026 if (isRbEqAppended)
2027 {
2028 origRbEquation[i].copyto((*pMetaEq)[pipeInterleaveLog2 + 1 + numPipeTotalLog2 + j]);
2029 // Mark any rb bit we add in to the rb mask
2030 j++;
2031 }
2032 }
2033
2034 //------------------------------------------------------------------------------------------
2035 // Put in the uncompressed fragment bits
2036 //------------------------------------------------------------------------------------------
2037 for (UINT_32 i = 0; i < uncompFragLog2; i++)
2038 {
2039 co.set('s', compFragLog2 + i);
2040 (*pMetaEq)[pipeInterleaveLog2 + 1 + numPipeTotalLog2 + rbBitsLeft + i].add(co);
2041 }
2042 }
2043 }
2044
2045 /**
2046 ************************************************************************************************************************
2047 * Gfx9Lib::IsEquationSupported
2048 *
2049 * @brief
2050 * Check if equation is supported for given swizzle mode and resource type.
2051 *
2052 * @return
2053 * TRUE if supported
2054 ************************************************************************************************************************
2055 */
2056 BOOL_32 Gfx9Lib::IsEquationSupported(
2057 AddrResourceType rsrcType,
2058 AddrSwizzleMode swMode,
2059 UINT_32 elementBytesLog2) const
2060 {
2061 BOOL_32 supported = (elementBytesLog2 < MaxElementBytesLog2) &&
2062 (IsLinear(swMode) == FALSE) &&
2063 (((IsTex2d(rsrcType) == TRUE) &&
2064 ((elementBytesLog2 < 4) ||
2065 ((IsRotateSwizzle(swMode) == FALSE) &&
2066 (IsZOrderSwizzle(swMode) == FALSE)))) ||
2067 ((IsTex3d(rsrcType) == TRUE) &&
2068 (IsRotateSwizzle(swMode) == FALSE) &&
2069 (IsBlock256b(swMode) == FALSE)));
2070
2071 return supported;
2072 }
2073
2074 /**
2075 ************************************************************************************************************************
2076 * Gfx9Lib::InitEquationTable
2077 *
2078 * @brief
2079 * Initialize Equation table.
2080 *
2081 * @return
2082 * N/A
2083 ************************************************************************************************************************
2084 */
2085 VOID Gfx9Lib::InitEquationTable()
2086 {
2087 memset(m_equationTable, 0, sizeof(m_equationTable));
2088
2089 // Loop all possible resource type (2D/3D)
2090 for (UINT_32 rsrcTypeIdx = 0; rsrcTypeIdx < MaxRsrcType; rsrcTypeIdx++)
2091 {
2092 AddrResourceType rsrcType = static_cast<AddrResourceType>(rsrcTypeIdx + ADDR_RSRC_TEX_2D);
2093
2094 // Loop all possible swizzle mode
2095 for (UINT_32 swModeIdx = 0; swModeIdx < MaxSwMode; swModeIdx++)
2096 {
2097 AddrSwizzleMode swMode = static_cast<AddrSwizzleMode>(swModeIdx);
2098
2099 // Loop all possible bpp
2100 for (UINT_32 bppIdx = 0; bppIdx < MaxElementBytesLog2; bppIdx++)
2101 {
2102 UINT_32 equationIndex = ADDR_INVALID_EQUATION_INDEX;
2103
2104 // Check if the input is supported
2105 if (IsEquationSupported(rsrcType, swMode, bppIdx))
2106 {
2107 ADDR_EQUATION equation;
2108 ADDR_E_RETURNCODE retCode;
2109
2110 memset(&equation, 0, sizeof(ADDR_EQUATION));
2111
2112 // Generate the equation
2113 if (IsBlock256b(swMode) && IsTex2d(rsrcType))
2114 {
2115 retCode = ComputeBlock256Equation(rsrcType, swMode, bppIdx, &equation);
2116 }
2117 else if (IsThin(rsrcType, swMode))
2118 {
2119 retCode = ComputeThinEquation(rsrcType, swMode, bppIdx, &equation);
2120 }
2121 else
2122 {
2123 retCode = ComputeThickEquation(rsrcType, swMode, bppIdx, &equation);
2124 }
2125
2126 // Only fill the equation into the table if the return code is ADDR_OK,
2127 // otherwise if the return code is not ADDR_OK, it indicates this is not
2128 // a valid input, we do nothing but just fill invalid equation index
2129 // into the lookup table.
2130 if (retCode == ADDR_OK)
2131 {
2132 equationIndex = m_numEquations;
2133 ADDR_ASSERT(equationIndex < EquationTableSize);
2134
2135 m_equationTable[equationIndex] = equation;
2136
2137 m_numEquations++;
2138 }
2139 else
2140 {
2141 ADDR_ASSERT_ALWAYS();
2142 }
2143 }
2144
2145 // Fill the index into the lookup table, if the combination is not supported
2146 // fill the invalid equation index
2147 m_equationLookupTable[rsrcTypeIdx][swModeIdx][bppIdx] = equationIndex;
2148 }
2149 }
2150 }
2151 }
2152
2153 /**
2154 ************************************************************************************************************************
2155 * Gfx9Lib::HwlGetEquationIndex
2156 *
2157 * @brief
2158 * Interface function stub of GetEquationIndex
2159 *
2160 * @return
2161 * ADDR_E_RETURNCODE
2162 ************************************************************************************************************************
2163 */
2164 UINT_32 Gfx9Lib::HwlGetEquationIndex(
2165 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
2166 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut
2167 ) const
2168 {
2169 AddrResourceType rsrcType = pIn->resourceType;
2170 AddrSwizzleMode swMode = pIn->swizzleMode;
2171 UINT_32 elementBytesLog2 = Log2(pIn->bpp >> 3);
2172 UINT_32 index = ADDR_INVALID_EQUATION_INDEX;
2173
2174 if (IsEquationSupported(rsrcType, swMode, elementBytesLog2))
2175 {
2176 UINT_32 rsrcTypeIdx = static_cast<UINT_32>(rsrcType) - 1;
2177 UINT_32 swModeIdx = static_cast<UINT_32>(swMode);
2178
2179 index = m_equationLookupTable[rsrcTypeIdx][swModeIdx][elementBytesLog2];
2180 }
2181
2182 if (pOut->pMipInfo != NULL)
2183 {
2184 for (UINT_32 i = 0; i < pIn->numMipLevels; i++)
2185 {
2186 pOut->pMipInfo[i].equationIndex = index;
2187 }
2188 }
2189
2190 return index;
2191 }
2192
2193 /**
2194 ************************************************************************************************************************
2195 * Gfx9Lib::HwlComputeBlock256Equation
2196 *
2197 * @brief
2198 * Interface function stub of ComputeBlock256Equation
2199 *
2200 * @return
2201 * ADDR_E_RETURNCODE
2202 ************************************************************************************************************************
2203 */
2204 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeBlock256Equation(
2205 AddrResourceType rsrcType,
2206 AddrSwizzleMode swMode,
2207 UINT_32 elementBytesLog2,
2208 ADDR_EQUATION* pEquation) const
2209 {
2210 ADDR_E_RETURNCODE ret = ADDR_OK;
2211
2212 pEquation->numBits = 8;
2213
2214 UINT_32 i = 0;
2215 for (; i < elementBytesLog2; i++)
2216 {
2217 InitChannel(1, 0 , i, &pEquation->addr[i]);
2218 }
2219
2220 ADDR_CHANNEL_SETTING* pixelBit = &pEquation->addr[elementBytesLog2];
2221
2222 const UINT_32 maxBitsUsed = 4;
2223 ADDR_CHANNEL_SETTING x[maxBitsUsed] = {};
2224 ADDR_CHANNEL_SETTING y[maxBitsUsed] = {};
2225
2226 for (i = 0; i < maxBitsUsed; i++)
2227 {
2228 InitChannel(1, 0, elementBytesLog2 + i, &x[i]);
2229 InitChannel(1, 1, i, &y[i]);
2230 }
2231
2232 if (IsStandardSwizzle(rsrcType, swMode))
2233 {
2234 switch (elementBytesLog2)
2235 {
2236 case 0:
2237 pixelBit[0] = x[0];
2238 pixelBit[1] = x[1];
2239 pixelBit[2] = x[2];
2240 pixelBit[3] = x[3];
2241 pixelBit[4] = y[0];
2242 pixelBit[5] = y[1];
2243 pixelBit[6] = y[2];
2244 pixelBit[7] = y[3];
2245 break;
2246 case 1:
2247 pixelBit[0] = x[0];
2248 pixelBit[1] = x[1];
2249 pixelBit[2] = x[2];
2250 pixelBit[3] = y[0];
2251 pixelBit[4] = y[1];
2252 pixelBit[5] = y[2];
2253 pixelBit[6] = x[3];
2254 break;
2255 case 2:
2256 pixelBit[0] = x[0];
2257 pixelBit[1] = x[1];
2258 pixelBit[2] = y[0];
2259 pixelBit[3] = y[1];
2260 pixelBit[4] = y[2];
2261 pixelBit[5] = x[2];
2262 break;
2263 case 3:
2264 pixelBit[0] = x[0];
2265 pixelBit[1] = y[0];
2266 pixelBit[2] = y[1];
2267 pixelBit[3] = x[1];
2268 pixelBit[4] = x[2];
2269 break;
2270 case 4:
2271 pixelBit[0] = y[0];
2272 pixelBit[1] = y[1];
2273 pixelBit[2] = x[0];
2274 pixelBit[3] = x[1];
2275 break;
2276 default:
2277 ADDR_ASSERT_ALWAYS();
2278 ret = ADDR_INVALIDPARAMS;
2279 break;
2280 }
2281 }
2282 else if (IsDisplaySwizzle(rsrcType, swMode))
2283 {
2284 switch (elementBytesLog2)
2285 {
2286 case 0:
2287 pixelBit[0] = x[0];
2288 pixelBit[1] = x[1];
2289 pixelBit[2] = x[2];
2290 pixelBit[3] = y[1];
2291 pixelBit[4] = y[0];
2292 pixelBit[5] = y[2];
2293 pixelBit[6] = x[3];
2294 pixelBit[7] = y[3];
2295 break;
2296 case 1:
2297 pixelBit[0] = x[0];
2298 pixelBit[1] = x[1];
2299 pixelBit[2] = x[2];
2300 pixelBit[3] = y[0];
2301 pixelBit[4] = y[1];
2302 pixelBit[5] = y[2];
2303 pixelBit[6] = x[3];
2304 break;
2305 case 2:
2306 pixelBit[0] = x[0];
2307 pixelBit[1] = x[1];
2308 pixelBit[2] = y[0];
2309 pixelBit[3] = x[2];
2310 pixelBit[4] = y[1];
2311 pixelBit[5] = y[2];
2312 break;
2313 case 3:
2314 pixelBit[0] = x[0];
2315 pixelBit[1] = y[0];
2316 pixelBit[2] = x[1];
2317 pixelBit[3] = x[2];
2318 pixelBit[4] = y[1];
2319 break;
2320 case 4:
2321 pixelBit[0] = x[0];
2322 pixelBit[1] = y[0];
2323 pixelBit[2] = x[1];
2324 pixelBit[3] = y[1];
2325 break;
2326 default:
2327 ADDR_ASSERT_ALWAYS();
2328 ret = ADDR_INVALIDPARAMS;
2329 break;
2330 }
2331 }
2332 else if (IsRotateSwizzle(swMode))
2333 {
2334 switch (elementBytesLog2)
2335 {
2336 case 0:
2337 pixelBit[0] = y[0];
2338 pixelBit[1] = y[1];
2339 pixelBit[2] = y[2];
2340 pixelBit[3] = x[1];
2341 pixelBit[4] = x[0];
2342 pixelBit[5] = x[2];
2343 pixelBit[6] = x[3];
2344 pixelBit[7] = y[3];
2345 break;
2346 case 1:
2347 pixelBit[0] = y[0];
2348 pixelBit[1] = y[1];
2349 pixelBit[2] = y[2];
2350 pixelBit[3] = x[0];
2351 pixelBit[4] = x[1];
2352 pixelBit[5] = x[2];
2353 pixelBit[6] = x[3];
2354 break;
2355 case 2:
2356 pixelBit[0] = y[0];
2357 pixelBit[1] = y[1];
2358 pixelBit[2] = x[0];
2359 pixelBit[3] = y[2];
2360 pixelBit[4] = x[1];
2361 pixelBit[5] = x[2];
2362 break;
2363 case 3:
2364 pixelBit[0] = y[0];
2365 pixelBit[1] = x[0];
2366 pixelBit[2] = y[1];
2367 pixelBit[3] = x[1];
2368 pixelBit[4] = x[2];
2369 break;
2370 default:
2371 ADDR_ASSERT_ALWAYS();
2372 case 4:
2373 ret = ADDR_INVALIDPARAMS;
2374 break;
2375 }
2376 }
2377 else
2378 {
2379 ADDR_ASSERT_ALWAYS();
2380 ret = ADDR_INVALIDPARAMS;
2381 }
2382
2383 // Post validation
2384 if (ret == ADDR_OK)
2385 {
2386 Dim2d microBlockDim = Block256_2d[elementBytesLog2];
2387 ADDR_ASSERT((2u << GetMaxValidChannelIndex(pEquation->addr, 8, 0)) ==
2388 (microBlockDim.w * (1 << elementBytesLog2)));
2389 ADDR_ASSERT((2u << GetMaxValidChannelIndex(pEquation->addr, 8, 1)) == microBlockDim.h);
2390 }
2391
2392 return ret;
2393 }
2394
2395 /**
2396 ************************************************************************************************************************
2397 * Gfx9Lib::HwlComputeThinEquation
2398 *
2399 * @brief
2400 * Interface function stub of ComputeThinEquation
2401 *
2402 * @return
2403 * ADDR_E_RETURNCODE
2404 ************************************************************************************************************************
2405 */
2406 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeThinEquation(
2407 AddrResourceType rsrcType,
2408 AddrSwizzleMode swMode,
2409 UINT_32 elementBytesLog2,
2410 ADDR_EQUATION* pEquation) const
2411 {
2412 ADDR_E_RETURNCODE ret = ADDR_OK;
2413
2414 UINT_32 blockSizeLog2 = GetBlockSizeLog2(swMode);
2415
2416 UINT_32 maxXorBits = blockSizeLog2;
2417 if (IsNonPrtXor(swMode))
2418 {
2419 // For non-prt-xor, maybe need to initialize some more bits for xor
2420 // The highest xor bit used in equation will be max the following 3 items:
2421 // 1. m_pipeInterleaveLog2 + 2 * pipeXorBits
2422 // 2. m_pipeInterleaveLog2 + pipeXorBits + 2 * bankXorBits
2423 // 3. blockSizeLog2
2424
2425 maxXorBits = Max(maxXorBits, m_pipeInterleaveLog2 + 2 * GetPipeXorBits(blockSizeLog2));
2426 maxXorBits = Max(maxXorBits, m_pipeInterleaveLog2 +
2427 GetPipeXorBits(blockSizeLog2) +
2428 2 * GetBankXorBits(blockSizeLog2));
2429 }
2430
2431 const UINT_32 maxBitsUsed = 14;
2432 ADDR_ASSERT((2 * maxBitsUsed) >= maxXorBits);
2433 ADDR_CHANNEL_SETTING x[maxBitsUsed] = {};
2434 ADDR_CHANNEL_SETTING y[maxBitsUsed] = {};
2435
2436 const UINT_32 extraXorBits = 16;
2437 ADDR_ASSERT(extraXorBits >= maxXorBits - blockSizeLog2);
2438 ADDR_CHANNEL_SETTING xorExtra[extraXorBits] = {};
2439
2440 for (UINT_32 i = 0; i < maxBitsUsed; i++)
2441 {
2442 InitChannel(1, 0, elementBytesLog2 + i, &x[i]);
2443 InitChannel(1, 1, i, &y[i]);
2444 }
2445
2446 ADDR_CHANNEL_SETTING* pixelBit = pEquation->addr;
2447
2448 for (UINT_32 i = 0; i < elementBytesLog2; i++)
2449 {
2450 InitChannel(1, 0 , i, &pixelBit[i]);
2451 }
2452
2453 UINT_32 xIdx = 0;
2454 UINT_32 yIdx = 0;
2455 UINT_32 lowBits = 0;
2456
2457 if (IsZOrderSwizzle(swMode))
2458 {
2459 if (elementBytesLog2 <= 3)
2460 {
2461 for (UINT_32 i = elementBytesLog2; i < 6; i++)
2462 {
2463 pixelBit[i] = (((i - elementBytesLog2) & 1) == 0) ? x[xIdx++] : y[yIdx++];
2464 }
2465
2466 lowBits = 6;
2467 }
2468 else
2469 {
2470 ret = ADDR_INVALIDPARAMS;
2471 }
2472 }
2473 else
2474 {
2475 ret = HwlComputeBlock256Equation(rsrcType, swMode, elementBytesLog2, pEquation);
2476
2477 if (ret == ADDR_OK)
2478 {
2479 Dim2d microBlockDim = Block256_2d[elementBytesLog2];
2480 xIdx = Log2(microBlockDim.w);
2481 yIdx = Log2(microBlockDim.h);
2482 lowBits = 8;
2483 }
2484 }
2485
2486 if (ret == ADDR_OK)
2487 {
2488 for (UINT_32 i = lowBits; i < blockSizeLog2; i++)
2489 {
2490 pixelBit[i] = ((i & 1) == 0) ? y[yIdx++] : x[xIdx++];
2491 }
2492
2493 for (UINT_32 i = blockSizeLog2; i < maxXorBits; i++)
2494 {
2495 xorExtra[i - blockSizeLog2] = ((i & 1) == 0) ? y[yIdx++] : x[xIdx++];
2496 }
2497
2498 if (IsXor(swMode))
2499 {
2500 // Fill XOR bits
2501 UINT_32 pipeStart = m_pipeInterleaveLog2;
2502 UINT_32 pipeXorBits = GetPipeXorBits(blockSizeLog2);
2503
2504 UINT_32 bankStart = pipeStart + pipeXorBits;
2505 UINT_32 bankXorBits = GetBankXorBits(blockSizeLog2);
2506
2507 for (UINT_32 i = 0; i < pipeXorBits; i++)
2508 {
2509 UINT_32 xor1BitPos = pipeStart + 2 * pipeXorBits - 1 - i;
2510 ADDR_CHANNEL_SETTING* pXor1Src = (xor1BitPos < blockSizeLog2) ?
2511 &pEquation->addr[xor1BitPos] : &xorExtra[xor1BitPos - blockSizeLog2];
2512
2513 InitChannel(&pEquation->xor1[pipeStart + i], pXor1Src);
2514 }
2515
2516 for (UINT_32 i = 0; i < bankXorBits; i++)
2517 {
2518 UINT_32 xor1BitPos = bankStart + 2 * bankXorBits - 1 - i;
2519 ADDR_CHANNEL_SETTING* pXor1Src = (xor1BitPos < blockSizeLog2) ?
2520 &pEquation->addr[xor1BitPos] : &xorExtra[xor1BitPos - blockSizeLog2];
2521
2522 InitChannel(&pEquation->xor1[bankStart + i], pXor1Src);
2523 }
2524
2525 if (IsPrt(swMode) == FALSE)
2526 {
2527 for (UINT_32 i = 0; i < pipeXorBits; i++)
2528 {
2529 InitChannel(1, 2, pipeXorBits - i - 1, &pEquation->xor2[pipeStart + i]);
2530 }
2531
2532 for (UINT_32 i = 0; i < bankXorBits; i++)
2533 {
2534 InitChannel(1, 2, bankXorBits - i - 1 + pipeXorBits, &pEquation->xor2[bankStart + i]);
2535 }
2536 }
2537 }
2538
2539 pEquation->numBits = blockSizeLog2;
2540 }
2541
2542 return ret;
2543 }
2544
2545 /**
2546 ************************************************************************************************************************
2547 * Gfx9Lib::HwlComputeThickEquation
2548 *
2549 * @brief
2550 * Interface function stub of ComputeThickEquation
2551 *
2552 * @return
2553 * ADDR_E_RETURNCODE
2554 ************************************************************************************************************************
2555 */
2556 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeThickEquation(
2557 AddrResourceType rsrcType,
2558 AddrSwizzleMode swMode,
2559 UINT_32 elementBytesLog2,
2560 ADDR_EQUATION* pEquation) const
2561 {
2562 ADDR_E_RETURNCODE ret = ADDR_OK;
2563
2564 ADDR_ASSERT(IsTex3d(rsrcType));
2565
2566 UINT_32 blockSizeLog2 = GetBlockSizeLog2(swMode);
2567
2568 UINT_32 maxXorBits = blockSizeLog2;
2569 if (IsNonPrtXor(swMode))
2570 {
2571 // For non-prt-xor, maybe need to initialize some more bits for xor
2572 // The highest xor bit used in equation will be max the following 3:
2573 // 1. m_pipeInterleaveLog2 + 3 * pipeXorBits
2574 // 2. m_pipeInterleaveLog2 + pipeXorBits + 3 * bankXorBits
2575 // 3. blockSizeLog2
2576
2577 maxXorBits = Max(maxXorBits, m_pipeInterleaveLog2 + 3 * GetPipeXorBits(blockSizeLog2));
2578 maxXorBits = Max(maxXorBits, m_pipeInterleaveLog2 +
2579 GetPipeXorBits(blockSizeLog2) +
2580 3 * GetBankXorBits(blockSizeLog2));
2581 }
2582
2583 for (UINT_32 i = 0; i < elementBytesLog2; i++)
2584 {
2585 InitChannel(1, 0 , i, &pEquation->addr[i]);
2586 }
2587
2588 ADDR_CHANNEL_SETTING* pixelBit = &pEquation->addr[elementBytesLog2];
2589
2590 const UINT_32 maxBitsUsed = 12;
2591 ADDR_ASSERT((3 * maxBitsUsed) >= maxXorBits);
2592 ADDR_CHANNEL_SETTING x[maxBitsUsed] = {};
2593 ADDR_CHANNEL_SETTING y[maxBitsUsed] = {};
2594 ADDR_CHANNEL_SETTING z[maxBitsUsed] = {};
2595
2596 const UINT_32 extraXorBits = 24;
2597 ADDR_ASSERT(extraXorBits >= maxXorBits - blockSizeLog2);
2598 ADDR_CHANNEL_SETTING xorExtra[extraXorBits] = {};
2599
2600 for (UINT_32 i = 0; i < maxBitsUsed; i++)
2601 {
2602 InitChannel(1, 0, elementBytesLog2 + i, &x[i]);
2603 InitChannel(1, 1, i, &y[i]);
2604 InitChannel(1, 2, i, &z[i]);
2605 }
2606
2607 if (IsZOrderSwizzle(swMode))
2608 {
2609 switch (elementBytesLog2)
2610 {
2611 case 0:
2612 pixelBit[0] = x[0];
2613 pixelBit[1] = y[0];
2614 pixelBit[2] = x[1];
2615 pixelBit[3] = y[1];
2616 pixelBit[4] = z[0];
2617 pixelBit[5] = z[1];
2618 pixelBit[6] = x[2];
2619 pixelBit[7] = z[2];
2620 pixelBit[8] = y[2];
2621 pixelBit[9] = x[3];
2622 break;
2623 case 1:
2624 pixelBit[0] = x[0];
2625 pixelBit[1] = y[0];
2626 pixelBit[2] = x[1];
2627 pixelBit[3] = y[1];
2628 pixelBit[4] = z[0];
2629 pixelBit[5] = z[1];
2630 pixelBit[6] = z[2];
2631 pixelBit[7] = y[2];
2632 pixelBit[8] = x[2];
2633 break;
2634 case 2:
2635 pixelBit[0] = x[0];
2636 pixelBit[1] = y[0];
2637 pixelBit[2] = x[1];
2638 pixelBit[3] = z[0];
2639 pixelBit[4] = y[1];
2640 pixelBit[5] = z[1];
2641 pixelBit[6] = y[2];
2642 pixelBit[7] = x[2];
2643 break;
2644 case 3:
2645 pixelBit[0] = x[0];
2646 pixelBit[1] = y[0];
2647 pixelBit[2] = z[0];
2648 pixelBit[3] = x[1];
2649 pixelBit[4] = z[1];
2650 pixelBit[5] = y[1];
2651 pixelBit[6] = x[2];
2652 break;
2653 case 4:
2654 pixelBit[0] = x[0];
2655 pixelBit[1] = y[0];
2656 pixelBit[2] = z[0];
2657 pixelBit[3] = z[1];
2658 pixelBit[4] = y[1];
2659 pixelBit[5] = x[1];
2660 break;
2661 default:
2662 ADDR_ASSERT_ALWAYS();
2663 ret = ADDR_INVALIDPARAMS;
2664 break;
2665 }
2666 }
2667 else if (IsStandardSwizzle(rsrcType, swMode))
2668 {
2669 switch (elementBytesLog2)
2670 {
2671 case 0:
2672 pixelBit[0] = x[0];
2673 pixelBit[1] = x[1];
2674 pixelBit[2] = x[2];
2675 pixelBit[3] = x[3];
2676 pixelBit[4] = y[0];
2677 pixelBit[5] = y[1];
2678 pixelBit[6] = z[0];
2679 pixelBit[7] = z[1];
2680 pixelBit[8] = z[2];
2681 pixelBit[9] = y[2];
2682 break;
2683 case 1:
2684 pixelBit[0] = x[0];
2685 pixelBit[1] = x[1];
2686 pixelBit[2] = x[2];
2687 pixelBit[3] = y[0];
2688 pixelBit[4] = y[1];
2689 pixelBit[5] = z[0];
2690 pixelBit[6] = z[1];
2691 pixelBit[7] = z[2];
2692 pixelBit[8] = y[2];
2693 break;
2694 case 2:
2695 pixelBit[0] = x[0];
2696 pixelBit[1] = x[1];
2697 pixelBit[2] = y[0];
2698 pixelBit[3] = y[1];
2699 pixelBit[4] = z[0];
2700 pixelBit[5] = z[1];
2701 pixelBit[6] = y[2];
2702 pixelBit[7] = x[2];
2703 break;
2704 case 3:
2705 pixelBit[0] = x[0];
2706 pixelBit[1] = y[0];
2707 pixelBit[2] = y[1];
2708 pixelBit[3] = z[0];
2709 pixelBit[4] = z[1];
2710 pixelBit[5] = x[1];
2711 pixelBit[6] = x[2];
2712 break;
2713 case 4:
2714 pixelBit[0] = y[0];
2715 pixelBit[1] = y[1];
2716 pixelBit[2] = z[0];
2717 pixelBit[3] = z[1];
2718 pixelBit[4] = x[0];
2719 pixelBit[5] = x[1];
2720 break;
2721 default:
2722 ADDR_ASSERT_ALWAYS();
2723 ret = ADDR_INVALIDPARAMS;
2724 break;
2725 }
2726 }
2727 else
2728 {
2729 ADDR_ASSERT_ALWAYS();
2730 ret = ADDR_INVALIDPARAMS;
2731 }
2732
2733 if (ret == ADDR_OK)
2734 {
2735 Dim3d microBlockDim = Block1K_3d[elementBytesLog2];
2736 UINT_32 xIdx = Log2(microBlockDim.w);
2737 UINT_32 yIdx = Log2(microBlockDim.h);
2738 UINT_32 zIdx = Log2(microBlockDim.d);
2739
2740 pixelBit = pEquation->addr;
2741
2742 const UINT_32 lowBits = 10;
2743 ADDR_ASSERT(pEquation->addr[lowBits - 1].valid == 1);
2744 ADDR_ASSERT(pEquation->addr[lowBits].valid == 0);
2745
2746 for (UINT_32 i = lowBits; i < blockSizeLog2; i++)
2747 {
2748 if ((i % 3) == 0)
2749 {
2750 pixelBit[i] = x[xIdx++];
2751 }
2752 else if ((i % 3) == 1)
2753 {
2754 pixelBit[i] = z[zIdx++];
2755 }
2756 else
2757 {
2758 pixelBit[i] = y[yIdx++];
2759 }
2760 }
2761
2762 for (UINT_32 i = blockSizeLog2; i < maxXorBits; i++)
2763 {
2764 if ((i % 3) == 0)
2765 {
2766 xorExtra[i - blockSizeLog2] = x[xIdx++];
2767 }
2768 else if ((i % 3) == 1)
2769 {
2770 xorExtra[i - blockSizeLog2] = z[zIdx++];
2771 }
2772 else
2773 {
2774 xorExtra[i - blockSizeLog2] = y[yIdx++];
2775 }
2776 }
2777
2778 if (IsXor(swMode))
2779 {
2780 // Fill XOR bits
2781 UINT_32 pipeStart = m_pipeInterleaveLog2;
2782 UINT_32 pipeXorBits = GetPipeXorBits(blockSizeLog2);
2783 for (UINT_32 i = 0; i < pipeXorBits; i++)
2784 {
2785 UINT_32 xor1BitPos = pipeStart + (3 * pipeXorBits) - 1 - (2 * i);
2786 ADDR_CHANNEL_SETTING* pXor1Src = (xor1BitPos < blockSizeLog2) ?
2787 &pEquation->addr[xor1BitPos] : &xorExtra[xor1BitPos - blockSizeLog2];
2788
2789 InitChannel(&pEquation->xor1[pipeStart + i], pXor1Src);
2790
2791 UINT_32 xor2BitPos = pipeStart + (3 * pipeXorBits) - 2 - (2 * i);
2792 ADDR_CHANNEL_SETTING* pXor2Src = (xor2BitPos < blockSizeLog2) ?
2793 &pEquation->addr[xor2BitPos] : &xorExtra[xor2BitPos - blockSizeLog2];
2794
2795 InitChannel(&pEquation->xor2[pipeStart + i], pXor2Src);
2796 }
2797
2798 UINT_32 bankStart = pipeStart + pipeXorBits;
2799 UINT_32 bankXorBits = GetBankXorBits(blockSizeLog2);
2800 for (UINT_32 i = 0; i < bankXorBits; i++)
2801 {
2802 UINT_32 xor1BitPos = bankStart + (3 * bankXorBits) - 1 - (2 * i);
2803 ADDR_CHANNEL_SETTING* pXor1Src = (xor1BitPos < blockSizeLog2) ?
2804 &pEquation->addr[xor1BitPos] : &xorExtra[xor1BitPos - blockSizeLog2];
2805
2806 InitChannel(&pEquation->xor1[bankStart + i], pXor1Src);
2807
2808 UINT_32 xor2BitPos = bankStart + (3 * bankXorBits) - 2 - (2 * i);
2809 ADDR_CHANNEL_SETTING* pXor2Src = (xor2BitPos < blockSizeLog2) ?
2810 &pEquation->addr[xor2BitPos] : &xorExtra[xor2BitPos - blockSizeLog2];
2811
2812 InitChannel(&pEquation->xor2[bankStart + i], pXor2Src);
2813 }
2814 }
2815
2816 pEquation->numBits = blockSizeLog2;
2817 }
2818
2819 return ret;
2820 }
2821
2822 /**
2823 ************************************************************************************************************************
2824 * Gfx9Lib::IsValidDisplaySwizzleMode
2825 *
2826 * @brief
2827 * Check if a swizzle mode is supported by display engine
2828 *
2829 * @return
2830 * TRUE is swizzle mode is supported by display engine
2831 ************************************************************************************************************************
2832 */
2833 BOOL_32 Gfx9Lib::IsValidDisplaySwizzleMode(
2834 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn) const
2835 {
2836 BOOL_32 support = FALSE;
2837
2838 const AddrResourceType resourceType = pIn->resourceType;
2839 (void)resourceType;
2840 const AddrSwizzleMode swizzleMode = pIn->swizzleMode;
2841
2842 if (m_settings.isDce12)
2843 {
2844 switch (swizzleMode)
2845 {
2846 case ADDR_SW_256B_D:
2847 case ADDR_SW_256B_R:
2848 support = (pIn->bpp == 32);
2849 break;
2850
2851 case ADDR_SW_LINEAR:
2852 case ADDR_SW_4KB_D:
2853 case ADDR_SW_4KB_R:
2854 case ADDR_SW_64KB_D:
2855 case ADDR_SW_64KB_R:
2856 case ADDR_SW_VAR_D:
2857 case ADDR_SW_VAR_R:
2858 case ADDR_SW_4KB_D_X:
2859 case ADDR_SW_4KB_R_X:
2860 case ADDR_SW_64KB_D_X:
2861 case ADDR_SW_64KB_R_X:
2862 case ADDR_SW_VAR_D_X:
2863 case ADDR_SW_VAR_R_X:
2864 support = (pIn->bpp <= 64);
2865 break;
2866
2867 default:
2868 break;
2869 }
2870 }
2871 else if (m_settings.isDcn1)
2872 {
2873 switch (swizzleMode)
2874 {
2875 case ADDR_SW_4KB_D:
2876 case ADDR_SW_64KB_D:
2877 case ADDR_SW_VAR_D:
2878 case ADDR_SW_64KB_D_T:
2879 case ADDR_SW_4KB_D_X:
2880 case ADDR_SW_64KB_D_X:
2881 case ADDR_SW_VAR_D_X:
2882 support = (pIn->bpp == 64);
2883 break;
2884
2885 case ADDR_SW_LINEAR:
2886 case ADDR_SW_4KB_S:
2887 case ADDR_SW_64KB_S:
2888 case ADDR_SW_VAR_S:
2889 case ADDR_SW_64KB_S_T:
2890 case ADDR_SW_4KB_S_X:
2891 case ADDR_SW_64KB_S_X:
2892 case ADDR_SW_VAR_S_X:
2893 support = (pIn->bpp <= 64);
2894 break;
2895
2896 default:
2897 break;
2898 }
2899 }
2900 else
2901 {
2902 ADDR_NOT_IMPLEMENTED();
2903 }
2904
2905 return support;
2906 }
2907
2908 /**
2909 ************************************************************************************************************************
2910 * Gfx9Lib::HwlComputePipeBankXor
2911 *
2912 * @brief
2913 * Generate a PipeBankXor value to be ORed into bits above pipeInterleaveBits of address
2914 *
2915 * @return
2916 * PipeBankXor value
2917 ************************************************************************************************************************
2918 */
2919 ADDR_E_RETURNCODE Gfx9Lib::HwlComputePipeBankXor(
2920 const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn,
2921 ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut) const
2922 {
2923 UINT_32 macroBlockBits = GetBlockSizeLog2(pIn->swizzleMode);
2924 UINT_32 pipeBits = GetPipeXorBits(macroBlockBits);
2925 UINT_32 bankBits = GetBankXorBits(macroBlockBits);
2926
2927 UINT_32 pipeXor = 0;
2928 UINT_32 bankXor = 0;
2929
2930 const UINT_32 bankMask = (1 << bankBits) - 1;
2931 const UINT_32 index = pIn->surfIndex & bankMask;
2932
2933 const UINT_32 bpp = pIn->flags.fmask ?
2934 GetFmaskBpp(pIn->numSamples, pIn->numFrags) : GetElemLib()->GetBitsPerPixel(pIn->format);
2935 if (bankBits == 4)
2936 {
2937 static const UINT_32 BankXorSmallBpp[] = {0, 7, 4, 3, 8, 15, 12, 11, 1, 6, 5, 2, 9, 14, 13, 10};
2938 static const UINT_32 BankXorLargeBpp[] = {0, 7, 8, 15, 4, 3, 12, 11, 1, 6, 9, 14, 5, 2, 13, 10};
2939
2940 bankXor = (bpp <= 32) ? BankXorSmallBpp[index] : BankXorLargeBpp[index];
2941 }
2942 else if (bankBits > 0)
2943 {
2944 UINT_32 bankIncrease = (1 << (bankBits - 1)) - 1;
2945 bankIncrease = (bankIncrease == 0) ? 1 : bankIncrease;
2946 bankXor = (index * bankIncrease) & bankMask;
2947 }
2948
2949 pOut->pipeBankXor = (bankXor << pipeBits) | pipeXor;
2950
2951 return ADDR_OK;
2952 }
2953
2954 /**
2955 ************************************************************************************************************************
2956 * Gfx9Lib::HwlComputeSlicePipeBankXor
2957 *
2958 * @brief
2959 * Generate slice PipeBankXor value based on base PipeBankXor value and slice id
2960 *
2961 * @return
2962 * PipeBankXor value
2963 ************************************************************************************************************************
2964 */
2965 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeSlicePipeBankXor(
2966 const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn,
2967 ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut) const
2968 {
2969 UINT_32 macroBlockBits = GetBlockSizeLog2(pIn->swizzleMode);
2970 UINT_32 pipeBits = GetPipeXorBits(macroBlockBits);
2971 UINT_32 bankBits = GetBankXorBits(macroBlockBits);
2972
2973 UINT_32 pipeXor = ReverseBitVector(pIn->slice, pipeBits);
2974 UINT_32 bankXor = ReverseBitVector(pIn->slice >> pipeBits, bankBits);
2975
2976 pOut->pipeBankXor = pIn->basePipeBankXor ^ (pipeXor | (bankXor << pipeBits));
2977
2978 return ADDR_OK;
2979 }
2980
2981 /**
2982 ************************************************************************************************************************
2983 * Gfx9Lib::HwlComputeSubResourceOffsetForSwizzlePattern
2984 *
2985 * @brief
2986 * Compute sub resource offset to support swizzle pattern
2987 *
2988 * @return
2989 * Offset
2990 ************************************************************************************************************************
2991 */
2992 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeSubResourceOffsetForSwizzlePattern(
2993 const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn,
2994 ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut) const
2995 {
2996 ADDR_ASSERT(IsThin(pIn->resourceType, pIn->swizzleMode));
2997
2998 UINT_32 macroBlockBits = GetBlockSizeLog2(pIn->swizzleMode);
2999 UINT_32 pipeBits = GetPipeXorBits(macroBlockBits);
3000 UINT_32 bankBits = GetBankXorBits(macroBlockBits);
3001 UINT_32 pipeXor = ReverseBitVector(pIn->slice, pipeBits);
3002 UINT_32 bankXor = ReverseBitVector(pIn->slice >> pipeBits, bankBits);
3003 UINT_32 pipeBankXor = ((pipeXor | (bankXor << pipeBits)) ^ (pIn->pipeBankXor)) << m_pipeInterleaveLog2;
3004
3005 pOut->offset = pIn->slice * pIn->sliceSize +
3006 pIn->macroBlockOffset +
3007 (pIn->mipTailOffset ^ pipeBankXor) -
3008 static_cast<UINT_64>(pipeBankXor);
3009 return ADDR_OK;
3010 }
3011
3012 /**
3013 ************************************************************************************************************************
3014 * Gfx9Lib::HwlComputeSurfaceInfoSanityCheck
3015 *
3016 * @brief
3017 * Compute surface info sanity check
3018 *
3019 * @return
3020 * Offset
3021 ************************************************************************************************************************
3022 */
3023 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeSurfaceInfoSanityCheck(
3024 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn) const
3025 {
3026 BOOL_32 invalid = FALSE;
3027
3028 if ((pIn->bpp > 128) || (pIn->width == 0) || (pIn->numFrags > 8) || (pIn->numSamples > 16))
3029 {
3030 invalid = TRUE;
3031 }
3032 else if ((pIn->swizzleMode >= ADDR_SW_MAX_TYPE) ||
3033 (pIn->resourceType >= ADDR_RSRC_MAX_TYPE))
3034 {
3035 invalid = TRUE;
3036 }
3037
3038 BOOL_32 mipmap = (pIn->numMipLevels > 1);
3039 BOOL_32 msaa = (pIn->numFrags > 1);
3040
3041 ADDR2_SURFACE_FLAGS flags = pIn->flags;
3042 BOOL_32 zbuffer = (flags.depth || flags.stencil);
3043 BOOL_32 color = flags.color;
3044 BOOL_32 display = flags.display || flags.rotated;
3045
3046 AddrResourceType rsrcType = pIn->resourceType;
3047 BOOL_32 tex3d = IsTex3d(rsrcType);
3048 AddrSwizzleMode swizzle = pIn->swizzleMode;
3049 BOOL_32 linear = IsLinear(swizzle);
3050 BOOL_32 blk256B = IsBlock256b(swizzle);
3051 BOOL_32 blkVar = IsBlockVariable(swizzle);
3052 BOOL_32 isNonPrtXor = IsNonPrtXor(swizzle);
3053 BOOL_32 prt = flags.prt;
3054 BOOL_32 stereo = flags.qbStereo;
3055
3056 if (invalid == FALSE)
3057 {
3058 if ((pIn->numFrags > 1) &&
3059 (GetBlockSize(swizzle) < (m_pipeInterleaveBytes * pIn->numFrags)))
3060 {
3061 // MSAA surface must have blk_bytes/pipe_interleave >= num_samples
3062 invalid = TRUE;
3063 }
3064 }
3065
3066 if (invalid == FALSE)
3067 {
3068 switch (rsrcType)
3069 {
3070 case ADDR_RSRC_TEX_1D:
3071 invalid = msaa || zbuffer || display || (linear == FALSE) || stereo;
3072 break;
3073 case ADDR_RSRC_TEX_2D:
3074 invalid = (msaa && mipmap) || (stereo && msaa) || (stereo && mipmap);
3075 break;
3076 case ADDR_RSRC_TEX_3D:
3077 invalid = msaa || zbuffer || display || stereo;
3078 break;
3079 default:
3080 invalid = TRUE;
3081 break;
3082 }
3083 }
3084
3085 if (invalid == FALSE)
3086 {
3087 if (display)
3088 {
3089 invalid = (IsValidDisplaySwizzleMode(pIn) == FALSE);
3090 }
3091 }
3092
3093 if (invalid == FALSE)
3094 {
3095 if (linear)
3096 {
3097 invalid = ((ADDR_RSRC_TEX_1D != rsrcType) && prt) ||
3098 zbuffer || msaa || (pIn->bpp == 0) || ((pIn->bpp % 8) != 0);
3099 }
3100 else
3101 {
3102 if (blk256B || blkVar || isNonPrtXor)
3103 {
3104 invalid = prt;
3105 if (blk256B)
3106 {
3107 invalid = invalid || zbuffer || tex3d || mipmap || msaa;
3108 }
3109 }
3110
3111 if (invalid == FALSE)
3112 {
3113 if (IsZOrderSwizzle(swizzle))
3114 {
3115 invalid = color && msaa;
3116 }
3117 else if (IsStandardSwizzle(rsrcType, swizzle))
3118 {
3119 invalid = zbuffer;
3120 }
3121 else if (IsDisplaySwizzle(rsrcType, swizzle))
3122 {
3123 invalid = zbuffer;
3124 }
3125 else if (IsRotateSwizzle(swizzle))
3126 {
3127 invalid = zbuffer || (pIn->bpp > 64) || tex3d;
3128 }
3129 else
3130 {
3131 ADDR_ASSERT(!"invalid swizzle mode");
3132 invalid = TRUE;
3133 }
3134 }
3135 }
3136 }
3137
3138 ADDR_ASSERT(invalid == FALSE);
3139
3140 return invalid ? ADDR_INVALIDPARAMS : ADDR_OK;
3141 }
3142
3143 /**
3144 ************************************************************************************************************************
3145 * Gfx9Lib::HwlGetPreferredSurfaceSetting
3146 *
3147 * @brief
3148 * Internal function to get suggested surface information for cliet to use
3149 *
3150 * @return
3151 * ADDR_E_RETURNCODE
3152 ************************************************************************************************************************
3153 */
3154 ADDR_E_RETURNCODE Gfx9Lib::HwlGetPreferredSurfaceSetting(
3155 const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn,
3156 ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) const
3157 {
3158 // Macro define resource block type
3159 enum AddrBlockType
3160 {
3161 AddrBlockMicro = 0, // Resource uses 256B block
3162 AddrBlock4KB = 1, // Resource uses 4KB block
3163 AddrBlock64KB = 2, // Resource uses 64KB block
3164 AddrBlockVar = 3, // Resource uses var blcok
3165 AddrBlockLinear = 4, // Resource uses linear swizzle mode
3166
3167 AddrBlockMaxTiledType = AddrBlock64KB + 1,
3168 };
3169
3170 enum AddrBlockSet
3171 {
3172 AddrBlockSetMicro = 1 << AddrBlockMicro,
3173 AddrBlockSetMacro4KB = 1 << AddrBlock4KB,
3174 AddrBlockSetMacro64KB = 1 << AddrBlock64KB,
3175 AddrBlockSetVar = 1 << AddrBlockVar,
3176 AddrBlockSetLinear = 1 << AddrBlockLinear,
3177
3178 AddrBlockSetMacro = AddrBlockSetMacro4KB | AddrBlockSetMacro64KB,
3179 };
3180
3181 enum AddrSwSet
3182 {
3183 AddrSwSetZ = 1 << ADDR_SW_Z,
3184 AddrSwSetS = 1 << ADDR_SW_S,
3185 AddrSwSetD = 1 << ADDR_SW_D,
3186 AddrSwSetR = 1 << ADDR_SW_R,
3187
3188 AddrSwSetAll = AddrSwSetZ | AddrSwSetS | AddrSwSetD | AddrSwSetR,
3189 };
3190
3191 ADDR_E_RETURNCODE returnCode = ADDR_OK;
3192 ElemLib* pElemLib = GetElemLib();
3193
3194 // Set format to INVALID will skip this conversion
3195 UINT_32 expandX = 1;
3196 UINT_32 expandY = 1;
3197 UINT_32 bpp = pIn->bpp;
3198 UINT_32 width = pIn->width;
3199 UINT_32 height = pIn->height;
3200
3201 if (pIn->format != ADDR_FMT_INVALID)
3202 {
3203 // Don't care for this case
3204 ElemMode elemMode = ADDR_UNCOMPRESSED;
3205
3206 // Get compression/expansion factors and element mode which indicates compression/expansion
3207 bpp = pElemLib->GetBitsPerPixel(pIn->format,
3208 &elemMode,
3209 &expandX,
3210 &expandY);
3211
3212 UINT_32 basePitch = 0;
3213 GetElemLib()->AdjustSurfaceInfo(elemMode,
3214 expandX,
3215 expandY,
3216 &bpp,
3217 &basePitch,
3218 &width,
3219 &height);
3220 }
3221
3222 UINT_32 numSamples = Max(pIn->numSamples, 1u);
3223 UINT_32 numFrags = (pIn->numFrags == 0) ? numSamples : pIn->numFrags;
3224 UINT_32 slice = Max(pIn->numSlices, 1u);
3225 UINT_32 numMipLevels = Max(pIn->numMipLevels, 1u);
3226 UINT_32 minSizeAlign = NextPow2(pIn->minSizeAlign);
3227
3228 if (pIn->flags.fmask)
3229 {
3230 bpp = GetFmaskBpp(numSamples, numFrags);
3231 numFrags = 1;
3232 numSamples = 1;
3233 pOut->resourceType = ADDR_RSRC_TEX_2D;
3234 }
3235 else
3236 {
3237 // The output may get changed for volume(3D) texture resource in future
3238 pOut->resourceType = pIn->resourceType;
3239 }
3240
3241 if (bpp < 8)
3242 {
3243 ADDR_ASSERT_ALWAYS();
3244
3245 returnCode = ADDR_INVALIDPARAMS;
3246 }
3247 else if (IsTex1d(pOut->resourceType))
3248 {
3249 pOut->swizzleMode = ADDR_SW_LINEAR;
3250 pOut->validBlockSet.value = AddrBlockSetLinear;
3251 pOut->canXor = FALSE;
3252 }
3253 else
3254 {
3255 ADDR2_BLOCK_SET blockSet;
3256 blockSet.value = 0;
3257
3258 ADDR2_SWTYPE_SET addrPreferredSwSet, addrValidSwSet, clientPreferredSwSet;
3259 addrPreferredSwSet.value = AddrSwSetS;
3260 addrValidSwSet = addrPreferredSwSet;
3261 clientPreferredSwSet = pIn->preferredSwSet;
3262
3263 if (clientPreferredSwSet.value == 0)
3264 {
3265 clientPreferredSwSet.value = AddrSwSetAll;
3266 }
3267
3268 // prt Xor and non-xor will have less height align requirement for stereo surface
3269 BOOL_32 prtXor = (pIn->flags.prt || pIn->flags.qbStereo) && (pIn->noXor == FALSE);
3270 BOOL_32 displayResource = FALSE;
3271
3272 pOut->canXor = (pIn->flags.prt == FALSE) && (pIn->noXor == FALSE);
3273
3274 // Filter out improper swType and blockSet by HW restriction
3275 if (pIn->flags.fmask || pIn->flags.depth || pIn->flags.stencil)
3276 {
3277 ADDR_ASSERT(IsTex2d(pOut->resourceType));
3278 blockSet.value = AddrBlockSetMacro;
3279 addrPreferredSwSet.value = AddrSwSetZ;
3280 addrValidSwSet.value = AddrSwSetZ;
3281
3282 if (pIn->flags.depth && pIn->flags.texture)
3283 {
3284 if (((bpp == 16) && (numFrags >= 4)) ||
3285 ((bpp == 32) && (numFrags >= 2)))
3286 {
3287 // When _X/_T swizzle mode was used for MSAA depth texture, TC will get zplane
3288 // equation from wrong address within memory range a tile covered and use the
3289 // garbage data for compressed Z reading which finally leads to corruption.
3290 pOut->canXor = FALSE;
3291 prtXor = FALSE;
3292 }
3293 }
3294 }
3295 else if (ElemLib::IsBlockCompressed(pIn->format))
3296 {
3297 // block compressed formats (BCx, ASTC, ETC2) must be either S or D modes.
3298 // Not sure under what circumstances "_D" would be appropriate as these formats
3299 // are not displayable.
3300 blockSet.value = AddrBlockSetMacro;
3301
3302 // This isn't to be used as texture and caller doesn't allow macro tiled.
3303 if ((pIn->flags.texture == FALSE) &&
3304 (pIn->forbiddenBlock.macro4KB && pIn->forbiddenBlock.macro64KB))
3305 {
3306 blockSet.value |= AddrBlockSetLinear;
3307 }
3308
3309 addrPreferredSwSet.value = AddrSwSetD;
3310 addrValidSwSet.value = AddrSwSetS | AddrSwSetD;
3311 }
3312 else if (ElemLib::IsMacroPixelPacked(pIn->format))
3313 {
3314 // macro pixel packed formats (BG_RG, GB_GR) does not support the Z modes.
3315 // Its notclear under what circumstances the D or R modes would be appropriate
3316 // since these formats are not displayable.
3317 blockSet.value = AddrBlockSetLinear | AddrBlockSetMacro;
3318
3319 addrPreferredSwSet.value = AddrSwSetS;
3320 addrValidSwSet.value = AddrSwSetS | AddrSwSetD | AddrSwSetR;
3321 }
3322 else if (IsTex3d(pOut->resourceType))
3323 {
3324 blockSet.value = AddrBlockSetLinear | AddrBlockSetMacro;
3325
3326 if (pIn->flags.prt)
3327 {
3328 // PRT cannot use SW_D which gives an unexpected block dimension
3329 addrPreferredSwSet.value = AddrSwSetZ;
3330 addrValidSwSet.value = AddrSwSetZ | AddrSwSetS;
3331 }
3332 else if ((numMipLevels > 1) && (slice >= width) && (slice >= height))
3333 {
3334 // When depth (Z) is the maximum dimension then must use one of the SW_*_S
3335 // or SW_*_Z modes if mipmapping is desired on a 3D surface
3336 addrPreferredSwSet.value = AddrSwSetZ;
3337 addrValidSwSet.value = AddrSwSetZ | AddrSwSetS;
3338 }
3339 else if (pIn->flags.color)
3340 {
3341 addrPreferredSwSet.value = AddrSwSetD;
3342 addrValidSwSet.value = AddrSwSetZ | AddrSwSetS | AddrSwSetD;
3343 }
3344 else
3345 {
3346 addrPreferredSwSet.value = AddrSwSetZ;
3347 addrValidSwSet.value = AddrSwSetZ | AddrSwSetD;
3348 if (bpp != 128)
3349 {
3350 addrValidSwSet.value |= AddrSwSetS;
3351 }
3352 }
3353 }
3354 else
3355 {
3356 addrPreferredSwSet.value = ((pIn->flags.display == TRUE) ||
3357 (pIn->flags.overlay == TRUE) ||
3358 (pIn->bpp == 128)) ? AddrSwSetD : AddrSwSetS;
3359
3360 addrValidSwSet.value = AddrSwSetS | AddrSwSetD | AddrSwSetR;
3361
3362 if (numMipLevels > 1)
3363 {
3364 ADDR_ASSERT(numFrags == 1);
3365 blockSet.value = AddrBlockSetLinear | AddrBlockSetMacro;
3366 }
3367 else if ((numFrags > 1) || (numSamples > 1))
3368 {
3369 ADDR_ASSERT(IsTex2d(pOut->resourceType));
3370 blockSet.value = AddrBlockSetMacro;
3371 }
3372 else
3373 {
3374 ADDR_ASSERT(IsTex2d(pOut->resourceType));
3375 blockSet.value = AddrBlockSetLinear | AddrBlockSetMicro | AddrBlockSetMacro;
3376
3377 displayResource = pIn->flags.rotated || pIn->flags.display;
3378
3379 if (displayResource)
3380 {
3381 addrPreferredSwSet.value = pIn->flags.rotated ? AddrSwSetR : AddrSwSetD;
3382
3383 if (pIn->bpp > 64)
3384 {
3385 blockSet.value = 0;
3386 }
3387 else if (m_settings.isDce12)
3388 {
3389 if (pIn->bpp != 32)
3390 {
3391 blockSet.micro = FALSE;
3392 }
3393
3394 // DCE12 does not support display surface to be _T swizzle mode
3395 prtXor = FALSE;
3396
3397 addrValidSwSet.value = AddrSwSetD | AddrSwSetR;
3398 }
3399 else if (m_settings.isDcn1)
3400 {
3401 // _R is not supported by Dcn1
3402 if (pIn->bpp == 64)
3403 {
3404 addrPreferredSwSet.value = AddrSwSetD;
3405 addrValidSwSet.value = AddrSwSetD;
3406 }
3407 else
3408 {
3409 addrPreferredSwSet.value = AddrSwSetS;
3410 addrValidSwSet.value = AddrSwSetS | AddrSwSetD;
3411 }
3412
3413 blockSet.micro = FALSE;
3414 }
3415 else
3416 {
3417 ADDR_NOT_IMPLEMENTED();
3418 returnCode = ADDR_NOTSUPPORTED;
3419 }
3420 }
3421 }
3422 }
3423
3424 ADDR_ASSERT((addrValidSwSet.value & addrPreferredSwSet.value) == addrPreferredSwSet.value);
3425
3426 pOut->clientPreferredSwSet = clientPreferredSwSet;
3427
3428 // Clamp client preferred set to valid set
3429 clientPreferredSwSet.value &= addrValidSwSet.value;
3430
3431 pOut->validSwTypeSet = addrValidSwSet;
3432
3433 if (clientPreferredSwSet.value == 0)
3434 {
3435 // Client asks for an invalid swizzle type...
3436 ADDR_ASSERT_ALWAYS();
3437 returnCode = ADDR_INVALIDPARAMS;
3438 }
3439 else
3440 {
3441 if (IsPow2(clientPreferredSwSet.value))
3442 {
3443 // Only one swizzle type left, use it directly
3444 addrPreferredSwSet.value = clientPreferredSwSet.value;
3445 }
3446 else if ((clientPreferredSwSet.value & addrPreferredSwSet.value) == 0)
3447 {
3448 // Client wants 2 or more a valid swizzle type but none of them is addrlib preferred
3449 if (clientPreferredSwSet.sw_D)
3450 {
3451 addrPreferredSwSet.value = AddrSwSetD;
3452 }
3453 else if (clientPreferredSwSet.sw_Z)
3454 {
3455 addrPreferredSwSet.value = AddrSwSetZ;
3456 }
3457 else if (clientPreferredSwSet.sw_R)
3458 {
3459 addrPreferredSwSet.value = AddrSwSetR;
3460 }
3461 else
3462 {
3463 ADDR_ASSERT(clientPreferredSwSet.sw_S);
3464 addrPreferredSwSet.value = AddrSwSetS;
3465 }
3466 }
3467
3468 if ((numFrags > 1) &&
3469 (GetBlockSize(ADDR_SW_4KB) < (m_pipeInterleaveBytes * numFrags)))
3470 {
3471 // MSAA surface must have blk_bytes/pipe_interleave >= num_samples
3472 blockSet.macro4KB = FALSE;
3473 }
3474
3475 if (pIn->flags.prt)
3476 {
3477 blockSet.value &= AddrBlockSetMacro64KB;
3478 }
3479
3480 // Apply customized forbidden setting
3481 blockSet.value &= ~pIn->forbiddenBlock.value;
3482
3483 if (pIn->maxAlign > 0)
3484 {
3485 if (pIn->maxAlign < GetBlockSize(ADDR_SW_64KB))
3486 {
3487 blockSet.macro64KB = FALSE;
3488 }
3489
3490 if (pIn->maxAlign < GetBlockSize(ADDR_SW_4KB))
3491 {
3492 blockSet.macro4KB = FALSE;
3493 }
3494
3495 if (pIn->maxAlign < GetBlockSize(ADDR_SW_256B))
3496 {
3497 blockSet.micro = FALSE;
3498 }
3499 }
3500
3501 Dim3d blkAlign[AddrBlockMaxTiledType] = {{0}, {0}, {0}};
3502 Dim3d paddedDim[AddrBlockMaxTiledType] = {{0}, {0}, {0}};
3503 UINT_64 padSize[AddrBlockMaxTiledType] = {0};
3504
3505 if (blockSet.micro)
3506 {
3507 returnCode = ComputeBlockDimensionForSurf(&blkAlign[AddrBlockMicro].w,
3508 &blkAlign[AddrBlockMicro].h,
3509 &blkAlign[AddrBlockMicro].d,
3510 bpp,
3511 numFrags,
3512 pOut->resourceType,
3513 ADDR_SW_256B);
3514
3515 if (returnCode == ADDR_OK)
3516 {
3517 if (displayResource)
3518 {
3519 blkAlign[AddrBlockMicro].w = PowTwoAlign(blkAlign[AddrBlockMicro].w, 32);
3520 }
3521 else if ((blkAlign[AddrBlockMicro].w >= width) && (blkAlign[AddrBlockMicro].h >= height) &&
3522 (minSizeAlign <= GetBlockSize(ADDR_SW_256B)))
3523 {
3524 // If one 256B block can contain the surface, don't bother bigger block type
3525 blockSet.macro4KB = FALSE;
3526 blockSet.macro64KB = FALSE;
3527 blockSet.var = FALSE;
3528 }
3529
3530 padSize[AddrBlockMicro] = ComputePadSize(&blkAlign[AddrBlockMicro], width, height,
3531 slice, &paddedDim[AddrBlockMicro]);
3532 }
3533 }
3534
3535 if ((returnCode == ADDR_OK) && blockSet.macro4KB)
3536 {
3537 returnCode = ComputeBlockDimensionForSurf(&blkAlign[AddrBlock4KB].w,
3538 &blkAlign[AddrBlock4KB].h,
3539 &blkAlign[AddrBlock4KB].d,
3540 bpp,
3541 numFrags,
3542 pOut->resourceType,
3543 ADDR_SW_4KB);
3544
3545 if (returnCode == ADDR_OK)
3546 {
3547 if (displayResource)
3548 {
3549 blkAlign[AddrBlock4KB].w = PowTwoAlign(blkAlign[AddrBlock4KB].w, 32);
3550 }
3551
3552 padSize[AddrBlock4KB] = ComputePadSize(&blkAlign[AddrBlock4KB], width, height,
3553 slice, &paddedDim[AddrBlock4KB]);
3554
3555 ADDR_ASSERT(padSize[AddrBlock4KB] >= padSize[AddrBlockMicro]);
3556 }
3557 }
3558
3559 if ((returnCode == ADDR_OK) && blockSet.macro64KB)
3560 {
3561 returnCode = ComputeBlockDimensionForSurf(&blkAlign[AddrBlock64KB].w,
3562 &blkAlign[AddrBlock64KB].h,
3563 &blkAlign[AddrBlock64KB].d,
3564 bpp,
3565 numFrags,
3566 pOut->resourceType,
3567 ADDR_SW_64KB);
3568
3569 if (returnCode == ADDR_OK)
3570 {
3571 if (displayResource)
3572 {
3573 blkAlign[AddrBlock64KB].w = PowTwoAlign(blkAlign[AddrBlock64KB].w, 32);
3574 }
3575
3576 padSize[AddrBlock64KB] = ComputePadSize(&blkAlign[AddrBlock64KB], width, height,
3577 slice, &paddedDim[AddrBlock64KB]);
3578
3579 ADDR_ASSERT(padSize[AddrBlock64KB] >= padSize[AddrBlock4KB]);
3580 ADDR_ASSERT(padSize[AddrBlock64KB] >= padSize[AddrBlockMicro]);
3581 }
3582 }
3583
3584 if (returnCode == ADDR_OK)
3585 {
3586 UINT_64 minSizeAlignInElement = Max(minSizeAlign / (bpp >> 3), 1u);
3587
3588 for (UINT_32 i = AddrBlockMicro; i < AddrBlockMaxTiledType; i++)
3589 {
3590 padSize[i] = PowTwoAlign(padSize[i], minSizeAlignInElement);
3591 }
3592
3593 // Use minimum block type which meets all conditions above if flag minimizeAlign was set
3594 if (pIn->flags.minimizeAlign)
3595 {
3596 // If padded size of 64KB block is larger than padded size of 256B block or 4KB
3597 // block, filter out 64KB block from candidate list
3598 if (blockSet.macro64KB &&
3599 ((blockSet.micro && (padSize[AddrBlockMicro] < padSize[AddrBlock64KB])) ||
3600 (blockSet.macro4KB && (padSize[AddrBlock4KB] < padSize[AddrBlock64KB]))))
3601 {
3602 blockSet.macro64KB = FALSE;
3603 }
3604
3605 // If padded size of 4KB block is larger than padded size of 256B block,
3606 // filter out 4KB block from candidate list
3607 if (blockSet.macro4KB &&
3608 blockSet.micro &&
3609 (padSize[AddrBlockMicro] < padSize[AddrBlock4KB]))
3610 {
3611 blockSet.macro4KB = FALSE;
3612 }
3613 }
3614 // Filter out 64KB/4KB block if a smaller block type has 2/3 or less memory footprint
3615 else if (pIn->flags.opt4space)
3616 {
3617 UINT_64 threshold = blockSet.micro ? padSize[AddrBlockMicro] :
3618 (blockSet.macro4KB ? padSize[AddrBlock4KB] : padSize[AddrBlock64KB]);
3619
3620 threshold += threshold >> 1;
3621
3622 if (blockSet.macro64KB && (padSize[AddrBlock64KB] > threshold))
3623 {
3624 blockSet.macro64KB = FALSE;
3625 }
3626
3627 if (blockSet.macro4KB && (padSize[AddrBlock4KB] > threshold))
3628 {
3629 blockSet.macro4KB = FALSE;
3630 }
3631 }
3632 else
3633 {
3634 if (blockSet.macro64KB &&
3635 (padSize[AddrBlock64KB] >= static_cast<UINT_64>(width) * height * slice * 2) &&
3636 ((blockSet.value & ~AddrBlockSetMacro64KB) != 0))
3637 {
3638 // If 64KB block waste more than half memory on padding, filter it out from
3639 // candidate list when it is not the only choice left
3640 blockSet.macro64KB = FALSE;
3641 }
3642 }
3643
3644 if (blockSet.value == 0)
3645 {
3646 // Bad things happen, client will not get any useful information from AddrLib.
3647 // Maybe we should fill in some output earlier instead of outputing nothing?
3648 ADDR_ASSERT_ALWAYS();
3649 returnCode = ADDR_INVALIDPARAMS;
3650 }
3651 else
3652 {
3653 pOut->validBlockSet = blockSet;
3654 pOut->canXor = pOut->canXor &&
3655 (blockSet.macro4KB || blockSet.macro64KB || blockSet.var);
3656
3657 if (blockSet.macro64KB || blockSet.macro4KB)
3658 {
3659 if (addrPreferredSwSet.value == AddrSwSetZ)
3660 {
3661 pOut->swizzleMode = blockSet.macro64KB ? ADDR_SW_64KB_Z : ADDR_SW_4KB_Z;
3662 }
3663 else if (addrPreferredSwSet.value == AddrSwSetS)
3664 {
3665 pOut->swizzleMode = blockSet.macro64KB ? ADDR_SW_64KB_S : ADDR_SW_4KB_S;
3666 }
3667 else if (addrPreferredSwSet.value == AddrSwSetD)
3668 {
3669 pOut->swizzleMode = blockSet.macro64KB ? ADDR_SW_64KB_D : ADDR_SW_4KB_D;
3670 }
3671 else
3672 {
3673 ADDR_ASSERT(addrPreferredSwSet.value == AddrSwSetR);
3674 pOut->swizzleMode = blockSet.macro64KB ? ADDR_SW_64KB_R : ADDR_SW_4KB_R;
3675 }
3676
3677 if (prtXor && blockSet.macro64KB)
3678 {
3679 // Client wants PRTXOR, give back _T swizzle mode if 64KB is available
3680 const UINT_32 prtGap = ADDR_SW_64KB_Z_T - ADDR_SW_64KB_Z;
3681 pOut->swizzleMode = static_cast<AddrSwizzleMode>(pOut->swizzleMode + prtGap);
3682 }
3683 else if (pOut->canXor)
3684 {
3685 // Client wants XOR and this is allowed, return XOR version swizzle mode
3686 const UINT_32 xorGap = ADDR_SW_4KB_Z_X - ADDR_SW_4KB_Z;
3687 pOut->swizzleMode = static_cast<AddrSwizzleMode>(pOut->swizzleMode + xorGap);
3688 }
3689 }
3690 else if (blockSet.micro)
3691 {
3692 if (addrPreferredSwSet.value == AddrSwSetS)
3693 {
3694 pOut->swizzleMode = ADDR_SW_256B_S;
3695 }
3696 else if (addrPreferredSwSet.value == AddrSwSetD)
3697 {
3698 pOut->swizzleMode = ADDR_SW_256B_D;
3699 }
3700 else
3701 {
3702 ADDR_ASSERT(addrPreferredSwSet.value == AddrSwSetR);
3703 pOut->swizzleMode = ADDR_SW_256B_R;
3704 }
3705 }
3706 else if (blockSet.linear)
3707 {
3708 // Fall into this branch doesn't mean linear is suitable, only no other choices!
3709 pOut->swizzleMode = ADDR_SW_LINEAR;
3710 }
3711 else
3712 {
3713 ADDR_ASSERT(blockSet.var);
3714
3715 // Designer consider VAR swizzle mode is usless for most cases
3716 ADDR_UNHANDLED_CASE();
3717
3718 returnCode = ADDR_NOTSUPPORTED;
3719 }
3720
3721 #if DEBUG
3722 // Post sanity check, at least AddrLib should accept the output generated by its own
3723 if (pOut->swizzleMode != ADDR_SW_LINEAR)
3724 {
3725 ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
3726 localIn.flags = pIn->flags;
3727 localIn.swizzleMode = pOut->swizzleMode;
3728 localIn.resourceType = pOut->resourceType;
3729 localIn.format = pIn->format;
3730 localIn.bpp = bpp;
3731 localIn.width = width;
3732 localIn.height = height;
3733 localIn.numSlices = slice;
3734 localIn.numMipLevels = numMipLevels;
3735 localIn.numSamples = numSamples;
3736 localIn.numFrags = numFrags;
3737
3738 HwlComputeSurfaceInfoSanityCheck(&localIn);
3739
3740 }
3741 #endif
3742 }
3743 }
3744 }
3745 }
3746
3747 return returnCode;
3748 }
3749
3750 /**
3751 ************************************************************************************************************************
3752 * Gfx9Lib::ComputeStereoInfo
3753 *
3754 * @brief
3755 * Compute height alignment and right eye pipeBankXor for stereo surface
3756 *
3757 * @return
3758 * Error code
3759 *
3760 ************************************************************************************************************************
3761 */
3762 ADDR_E_RETURNCODE Gfx9Lib::ComputeStereoInfo(
3763 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
3764 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut,
3765 UINT_32* pHeightAlign
3766 ) const
3767 {
3768 ADDR_E_RETURNCODE returnCode = ADDR_OK;
3769
3770 UINT_32 eqIndex = HwlGetEquationIndex(pIn, pOut);
3771
3772 if (eqIndex < m_numEquations)
3773 {
3774 if (IsXor(pIn->swizzleMode))
3775 {
3776 const UINT_32 blkSizeLog2 = GetBlockSizeLog2(pIn->swizzleMode);
3777 const UINT_32 numPipeBits = GetPipeXorBits(blkSizeLog2);
3778 const UINT_32 numBankBits = GetBankXorBits(blkSizeLog2);
3779 const UINT_32 bppLog2 = Log2(pIn->bpp >> 3);
3780 const UINT_32 maxYCoordBlock256 = Log2(Block256_2d[bppLog2].h) - 1;
3781 const ADDR_EQUATION *pEqToCheck = &m_equationTable[eqIndex];
3782
3783 ADDR_ASSERT(maxYCoordBlock256 ==
3784 GetMaxValidChannelIndex(&pEqToCheck->addr[0], GetBlockSizeLog2(ADDR_SW_256B), 1));
3785
3786 const UINT_32 maxYCoordInBaseEquation =
3787 (blkSizeLog2 - GetBlockSizeLog2(ADDR_SW_256B)) / 2 + maxYCoordBlock256;
3788
3789 ADDR_ASSERT(maxYCoordInBaseEquation ==
3790 GetMaxValidChannelIndex(&pEqToCheck->addr[0], blkSizeLog2, 1));
3791
3792 const UINT_32 maxYCoordInPipeXor = (numPipeBits == 0) ? 0 : maxYCoordBlock256 + numPipeBits;
3793
3794 ADDR_ASSERT(maxYCoordInPipeXor ==
3795 GetMaxValidChannelIndex(&pEqToCheck->xor1[m_pipeInterleaveLog2], numPipeBits, 1));
3796
3797 const UINT_32 maxYCoordInBankXor = (numBankBits == 0) ?
3798 0 : maxYCoordBlock256 + (numPipeBits + 1) / 2 + numBankBits;
3799
3800 ADDR_ASSERT(maxYCoordInBankXor ==
3801 GetMaxValidChannelIndex(&pEqToCheck->xor1[m_pipeInterleaveLog2 + numPipeBits], numBankBits, 1));
3802
3803 const UINT_32 maxYCoordInPipeBankXor = Max(maxYCoordInPipeXor, maxYCoordInBankXor);
3804
3805 if (maxYCoordInPipeBankXor > maxYCoordInBaseEquation)
3806 {
3807 *pHeightAlign = 1u << maxYCoordInPipeBankXor;
3808
3809 if (pOut->pStereoInfo != NULL)
3810 {
3811 pOut->pStereoInfo->rightSwizzle = 0;
3812
3813 if ((PowTwoAlign(pIn->height, *pHeightAlign) % (*pHeightAlign * 2)) != 0)
3814 {
3815 if (maxYCoordInPipeXor == maxYCoordInPipeBankXor)
3816 {
3817 pOut->pStereoInfo->rightSwizzle |= (1u << 1);
3818 }
3819
3820 if (maxYCoordInBankXor == maxYCoordInPipeBankXor)
3821 {
3822 pOut->pStereoInfo->rightSwizzle |=
3823 1u << ((numPipeBits % 2) ? numPipeBits : numPipeBits + 1);
3824 }
3825
3826 ADDR_ASSERT(pOut->pStereoInfo->rightSwizzle ==
3827 GetCoordActiveMask(&pEqToCheck->xor1[m_pipeInterleaveLog2],
3828 numPipeBits + numBankBits, 1, maxYCoordInPipeBankXor));
3829 }
3830 }
3831 }
3832 }
3833 }
3834 else
3835 {
3836 ADDR_ASSERT_ALWAYS();
3837 returnCode = ADDR_ERROR;
3838 }
3839
3840 return returnCode;
3841 }
3842
3843 /**
3844 ************************************************************************************************************************
3845 * Gfx9Lib::HwlComputeSurfaceInfoTiled
3846 *
3847 * @brief
3848 * Internal function to calculate alignment for tiled surface
3849 *
3850 * @return
3851 * ADDR_E_RETURNCODE
3852 ************************************************************************************************************************
3853 */
3854 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeSurfaceInfoTiled(
3855 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
3856 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
3857 ) const
3858 {
3859 ADDR_E_RETURNCODE returnCode = ComputeBlockDimensionForSurf(&pOut->blockWidth,
3860 &pOut->blockHeight,
3861 &pOut->blockSlices,
3862 pIn->bpp,
3863 pIn->numFrags,
3864 pIn->resourceType,
3865 pIn->swizzleMode);
3866
3867 if (returnCode == ADDR_OK)
3868 {
3869 UINT_32 pitchAlignInElement = pOut->blockWidth;
3870
3871 if ((IsTex2d(pIn->resourceType) == TRUE) &&
3872 (pIn->flags.display || pIn->flags.rotated) &&
3873 (pIn->numMipLevels <= 1) &&
3874 (pIn->numSamples <= 1) &&
3875 (pIn->numFrags <= 1))
3876 {
3877 // Display engine needs pitch align to be at least 32 pixels.
3878 pitchAlignInElement = PowTwoAlign(pitchAlignInElement, 32);
3879 }
3880
3881 pOut->pitch = PowTwoAlign(pIn->width, pitchAlignInElement);
3882
3883 if ((pIn->numMipLevels <= 1) && (pIn->pitchInElement > 0))
3884 {
3885 if ((pIn->pitchInElement % pitchAlignInElement) != 0)
3886 {
3887 returnCode = ADDR_INVALIDPARAMS;
3888 }
3889 else if (pIn->pitchInElement < pOut->pitch)
3890 {
3891 returnCode = ADDR_INVALIDPARAMS;
3892 }
3893 else
3894 {
3895 pOut->pitch = pIn->pitchInElement;
3896 }
3897 }
3898
3899 UINT_32 heightAlign = 0;
3900
3901 if (pIn->flags.qbStereo)
3902 {
3903 returnCode = ComputeStereoInfo(pIn, pOut, &heightAlign);
3904 }
3905
3906 if (returnCode == ADDR_OK)
3907 {
3908 pOut->height = PowTwoAlign(pIn->height, pOut->blockHeight);
3909
3910 if (heightAlign > 1)
3911 {
3912 pOut->height = PowTwoAlign(pOut->height, heightAlign);
3913 }
3914
3915 pOut->numSlices = PowTwoAlign(pIn->numSlices, pOut->blockSlices);
3916
3917 pOut->epitchIsHeight = FALSE;
3918 pOut->mipChainInTail = FALSE;
3919 pOut->firstMipIdInTail = pIn->numMipLevels;
3920
3921 pOut->mipChainPitch = pOut->pitch;
3922 pOut->mipChainHeight = pOut->height;
3923 pOut->mipChainSlice = pOut->numSlices;
3924
3925 if (pIn->numMipLevels > 1)
3926 {
3927 pOut->firstMipIdInTail = GetMipChainInfo(pIn->resourceType,
3928 pIn->swizzleMode,
3929 pIn->bpp,
3930 pIn->width,
3931 pIn->height,
3932 pIn->numSlices,
3933 pOut->blockWidth,
3934 pOut->blockHeight,
3935 pOut->blockSlices,
3936 pIn->numMipLevels,
3937 pOut->pMipInfo);
3938
3939 const UINT_32 endingMipId = Min(pOut->firstMipIdInTail, pIn->numMipLevels - 1);
3940
3941 if (endingMipId == 0)
3942 {
3943 const Dim3d tailMaxDim = GetMipTailDim(pIn->resourceType,
3944 pIn->swizzleMode,
3945 pOut->blockWidth,
3946 pOut->blockHeight,
3947 pOut->blockSlices);
3948
3949 pOut->epitchIsHeight = TRUE;
3950 pOut->pitch = tailMaxDim.w;
3951 pOut->height = tailMaxDim.h;
3952 pOut->numSlices = IsThick(pIn->resourceType, pIn->swizzleMode) ?
3953 tailMaxDim.d : pIn->numSlices;
3954 pOut->mipChainInTail = TRUE;
3955 }
3956 else
3957 {
3958 UINT_32 mip0WidthInBlk = pOut->pitch / pOut->blockWidth;
3959 UINT_32 mip0HeightInBlk = pOut->height / pOut->blockHeight;
3960
3961 AddrMajorMode majorMode = GetMajorMode(pIn->resourceType,
3962 pIn->swizzleMode,
3963 mip0WidthInBlk,
3964 mip0HeightInBlk,
3965 pOut->numSlices / pOut->blockSlices);
3966 if (majorMode == ADDR_MAJOR_Y)
3967 {
3968 UINT_32 mip1WidthInBlk = RoundHalf(mip0WidthInBlk);
3969
3970 if ((mip1WidthInBlk == 1) && (endingMipId > 2))
3971 {
3972 mip1WidthInBlk++;
3973 }
3974
3975 pOut->mipChainPitch += (mip1WidthInBlk * pOut->blockWidth);
3976
3977 pOut->epitchIsHeight = FALSE;
3978 }
3979 else
3980 {
3981 UINT_32 mip1HeightInBlk = RoundHalf(mip0HeightInBlk);
3982
3983 if ((mip1HeightInBlk == 1) && (endingMipId > 2))
3984 {
3985 mip1HeightInBlk++;
3986 }
3987
3988 pOut->mipChainHeight += (mip1HeightInBlk * pOut->blockHeight);
3989
3990 pOut->epitchIsHeight = TRUE;
3991 }
3992 }
3993
3994 if (pOut->pMipInfo != NULL)
3995 {
3996 UINT_32 elementBytesLog2 = Log2(pIn->bpp >> 3);
3997
3998 for (UINT_32 i = 0; i < pIn->numMipLevels; i++)
3999 {
4000 Dim3d mipStartPos = {0};
4001 UINT_32 mipTailOffsetInBytes = 0;
4002
4003 mipStartPos = GetMipStartPos(pIn->resourceType,
4004 pIn->swizzleMode,
4005 pOut->pitch,
4006 pOut->height,
4007 pOut->numSlices,
4008 pOut->blockWidth,
4009 pOut->blockHeight,
4010 pOut->blockSlices,
4011 i,
4012 elementBytesLog2,
4013 &mipTailOffsetInBytes);
4014
4015 UINT_32 pitchInBlock =
4016 pOut->mipChainPitch / pOut->blockWidth;
4017 UINT_32 sliceInBlock =
4018 (pOut->mipChainHeight / pOut->blockHeight) * pitchInBlock;
4019 UINT_64 blockIndex =
4020 mipStartPos.d * sliceInBlock + mipStartPos.h * pitchInBlock + mipStartPos.w;
4021 UINT_64 macroBlockOffset =
4022 blockIndex << GetBlockSizeLog2(pIn->swizzleMode);
4023
4024 pOut->pMipInfo[i].macroBlockOffset = macroBlockOffset;
4025 pOut->pMipInfo[i].mipTailOffset = mipTailOffsetInBytes;
4026 }
4027 }
4028 }
4029 else if (pOut->pMipInfo != NULL)
4030 {
4031 pOut->pMipInfo[0].pitch = pOut->pitch;
4032 pOut->pMipInfo[0].height = pOut->height;
4033 pOut->pMipInfo[0].depth = IsTex3d(pIn->resourceType)? pOut->numSlices : 1;
4034 pOut->pMipInfo[0].offset = 0;
4035 }
4036
4037 pOut->sliceSize = static_cast<UINT_64>(pOut->mipChainPitch) * pOut->mipChainHeight *
4038 (pIn->bpp >> 3) * pIn->numFrags;
4039 pOut->surfSize = pOut->sliceSize * pOut->mipChainSlice;
4040 pOut->baseAlign = HwlComputeSurfaceBaseAlign(pIn->swizzleMode);
4041
4042 if (pIn->flags.prt)
4043 {
4044 pOut->baseAlign = Max(pOut->baseAlign, PrtAlignment);
4045 }
4046 }
4047 }
4048
4049 return returnCode;
4050 }
4051
4052 /**
4053 ************************************************************************************************************************
4054 * Gfx9Lib::HwlComputeSurfaceInfoLinear
4055 *
4056 * @brief
4057 * Internal function to calculate alignment for linear surface
4058 *
4059 * @return
4060 * ADDR_E_RETURNCODE
4061 ************************************************************************************************************************
4062 */
4063 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeSurfaceInfoLinear(
4064 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
4065 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
4066 ) const
4067 {
4068 ADDR_E_RETURNCODE returnCode = ADDR_OK;
4069 UINT_32 pitch = 0;
4070 UINT_32 actualHeight = 0;
4071 UINT_32 elementBytes = pIn->bpp >> 3;
4072 const UINT_32 alignment = pIn->flags.prt ? PrtAlignment : 256;
4073
4074 if (IsTex1d(pIn->resourceType))
4075 {
4076 if (pIn->height > 1)
4077 {
4078 returnCode = ADDR_INVALIDPARAMS;
4079 }
4080 else
4081 {
4082 const UINT_32 pitchAlignInElement = alignment / elementBytes;
4083
4084 pitch = PowTwoAlign(pIn->width, pitchAlignInElement);
4085 actualHeight = pIn->numMipLevels;
4086
4087 if (pIn->flags.prt == FALSE)
4088 {
4089 returnCode = ApplyCustomizedPitchHeight(pIn, elementBytes, pitchAlignInElement,
4090 &pitch, &actualHeight);
4091 }
4092
4093 if (returnCode == ADDR_OK)
4094 {
4095 if (pOut->pMipInfo != NULL)
4096 {
4097 for (UINT_32 i = 0; i < pIn->numMipLevels; i++)
4098 {
4099 pOut->pMipInfo[i].offset = pitch * elementBytes * i;
4100 pOut->pMipInfo[i].pitch = pitch;
4101 pOut->pMipInfo[i].height = 1;
4102 pOut->pMipInfo[i].depth = 1;
4103 }
4104 }
4105 }
4106 }
4107 }
4108 else
4109 {
4110 returnCode = ComputeSurfaceLinearPadding(pIn, &pitch, &actualHeight, pOut->pMipInfo);
4111 }
4112
4113 if ((pitch == 0) || (actualHeight == 0))
4114 {
4115 returnCode = ADDR_INVALIDPARAMS;
4116 }
4117
4118 if (returnCode == ADDR_OK)
4119 {
4120 pOut->pitch = pitch;
4121 pOut->height = pIn->height;
4122 pOut->numSlices = pIn->numSlices;
4123 pOut->mipChainPitch = pitch;
4124 pOut->mipChainHeight = actualHeight;
4125 pOut->mipChainSlice = pOut->numSlices;
4126 pOut->epitchIsHeight = (pIn->numMipLevels > 1) ? TRUE : FALSE;
4127 pOut->sliceSize = static_cast<UINT_64>(pOut->pitch) * actualHeight * elementBytes;
4128 pOut->surfSize = pOut->sliceSize * pOut->numSlices;
4129 pOut->baseAlign = (pIn->swizzleMode == ADDR_SW_LINEAR_GENERAL) ? (pIn->bpp / 8) : alignment;
4130 pOut->blockWidth = (pIn->swizzleMode == ADDR_SW_LINEAR_GENERAL) ? 1 : (256 / elementBytes);
4131 pOut->blockHeight = 1;
4132 pOut->blockSlices = 1;
4133 }
4134
4135 // Post calculation validate
4136 ADDR_ASSERT(pOut->sliceSize > 0);
4137
4138 return returnCode;
4139 }
4140
4141 /**
4142 ************************************************************************************************************************
4143 * Gfx9Lib::GetMipChainInfo
4144 *
4145 * @brief
4146 * Internal function to get out information about mip chain
4147 *
4148 * @return
4149 * Smaller value between Id of first mip fitted in mip tail and max Id of mip being created
4150 ************************************************************************************************************************
4151 */
4152 UINT_32 Gfx9Lib::GetMipChainInfo(
4153 AddrResourceType resourceType,
4154 AddrSwizzleMode swizzleMode,
4155 UINT_32 bpp,
4156 UINT_32 mip0Width,
4157 UINT_32 mip0Height,
4158 UINT_32 mip0Depth,
4159 UINT_32 blockWidth,
4160 UINT_32 blockHeight,
4161 UINT_32 blockDepth,
4162 UINT_32 numMipLevel,
4163 ADDR2_MIP_INFO* pMipInfo) const
4164 {
4165 const Dim3d tailMaxDim =
4166 GetMipTailDim(resourceType, swizzleMode, blockWidth, blockHeight, blockDepth);
4167
4168 UINT_32 mipPitch = mip0Width;
4169 UINT_32 mipHeight = mip0Height;
4170 UINT_32 mipDepth = IsTex3d(resourceType) ? mip0Depth : 1;
4171 UINT_32 offset = 0;
4172 UINT_32 firstMipIdInTail = numMipLevel;
4173 BOOL_32 inTail = FALSE;
4174 BOOL_32 finalDim = FALSE;
4175 BOOL_32 is3dThick = IsThick(resourceType, swizzleMode);
4176 BOOL_32 is3dThin = IsTex3d(resourceType) && (is3dThick == FALSE);
4177
4178 for (UINT_32 mipId = 0; mipId < numMipLevel; mipId++)
4179 {
4180 if (inTail)
4181 {
4182 if (finalDim == FALSE)
4183 {
4184 UINT_32 mipSize;
4185
4186 if (is3dThick)
4187 {
4188 mipSize = mipPitch * mipHeight * mipDepth * (bpp >> 3);
4189 }
4190 else
4191 {
4192 mipSize = mipPitch * mipHeight * (bpp >> 3);
4193 }
4194
4195 if (mipSize <= 256)
4196 {
4197 UINT_32 index = Log2(bpp >> 3);
4198
4199 if (is3dThick)
4200 {
4201 mipPitch = Block256_3dZ[index].w;
4202 mipHeight = Block256_3dZ[index].h;
4203 mipDepth = Block256_3dZ[index].d;
4204 }
4205 else
4206 {
4207 mipPitch = Block256_2d[index].w;
4208 mipHeight = Block256_2d[index].h;
4209 }
4210
4211 finalDim = TRUE;
4212 }
4213 }
4214 }
4215 else
4216 {
4217 inTail = IsInMipTail(resourceType, swizzleMode, tailMaxDim,
4218 mipPitch, mipHeight, mipDepth);
4219
4220 if (inTail)
4221 {
4222 firstMipIdInTail = mipId;
4223 mipPitch = tailMaxDim.w;
4224 mipHeight = tailMaxDim.h;
4225
4226 if (is3dThick)
4227 {
4228 mipDepth = tailMaxDim.d;
4229 }
4230 }
4231 else
4232 {
4233 mipPitch = PowTwoAlign(mipPitch, blockWidth);
4234 mipHeight = PowTwoAlign(mipHeight, blockHeight);
4235
4236 if (is3dThick)
4237 {
4238 mipDepth = PowTwoAlign(mipDepth, blockDepth);
4239 }
4240 }
4241 }
4242
4243 if (pMipInfo != NULL)
4244 {
4245 pMipInfo[mipId].pitch = mipPitch;
4246 pMipInfo[mipId].height = mipHeight;
4247 pMipInfo[mipId].depth = mipDepth;
4248 pMipInfo[mipId].offset = offset;
4249 }
4250
4251 offset += (mipPitch * mipHeight * mipDepth * (bpp >> 3));
4252
4253 if (finalDim)
4254 {
4255 if (is3dThin)
4256 {
4257 mipDepth = Max(mipDepth >> 1, 1u);
4258 }
4259 }
4260 else
4261 {
4262 mipPitch = Max(mipPitch >> 1, 1u);
4263 mipHeight = Max(mipHeight >> 1, 1u);
4264
4265 if (is3dThick || is3dThin)
4266 {
4267 mipDepth = Max(mipDepth >> 1, 1u);
4268 }
4269 }
4270 }
4271
4272 return firstMipIdInTail;
4273 }
4274
4275 /**
4276 ************************************************************************************************************************
4277 * Gfx9Lib::GetMetaMiptailInfo
4278 *
4279 * @brief
4280 * Get mip tail coordinate information.
4281 *
4282 * @return
4283 * N/A
4284 ************************************************************************************************************************
4285 */
4286 VOID Gfx9Lib::GetMetaMiptailInfo(
4287 ADDR2_META_MIP_INFO* pInfo, ///< [out] output structure to store per mip coord
4288 Dim3d mipCoord, ///< [in] mip tail base coord
4289 UINT_32 numMipInTail, ///< [in] number of mips in tail
4290 Dim3d* pMetaBlkDim ///< [in] meta block width/height/depth
4291 ) const
4292 {
4293 BOOL_32 isThick = (pMetaBlkDim->d > 1);
4294 UINT_32 mipWidth = pMetaBlkDim->w;
4295 UINT_32 mipHeight = pMetaBlkDim->h >> 1;
4296 UINT_32 mipDepth = pMetaBlkDim->d;
4297 UINT_32 minInc;
4298
4299 if (isThick)
4300 {
4301 minInc = (pMetaBlkDim->h >= 512) ? 128 : ((pMetaBlkDim->h == 256) ? 64 : 32);
4302 }
4303 else if (pMetaBlkDim->h >= 1024)
4304 {
4305 minInc = 256;
4306 }
4307 else if (pMetaBlkDim->h == 512)
4308 {
4309 minInc = 128;
4310 }
4311 else
4312 {
4313 minInc = 64;
4314 }
4315
4316 UINT_32 blk32MipId = 0xFFFFFFFF;
4317
4318 for (UINT_32 mip = 0; mip < numMipInTail; mip++)
4319 {
4320 pInfo[mip].inMiptail = TRUE;
4321 pInfo[mip].startX = mipCoord.w;
4322 pInfo[mip].startY = mipCoord.h;
4323 pInfo[mip].startZ = mipCoord.d;
4324 pInfo[mip].width = mipWidth;
4325 pInfo[mip].height = mipHeight;
4326 pInfo[mip].depth = mipDepth;
4327
4328 if (mipWidth <= 32)
4329 {
4330 if (blk32MipId == 0xFFFFFFFF)
4331 {
4332 blk32MipId = mip;
4333 }
4334
4335 mipCoord.w = pInfo[blk32MipId].startX;
4336 mipCoord.h = pInfo[blk32MipId].startY;
4337 mipCoord.d = pInfo[blk32MipId].startZ;
4338
4339 switch (mip - blk32MipId)
4340 {
4341 case 0:
4342 mipCoord.w += 32; // 16x16
4343 break;
4344 case 1:
4345 mipCoord.h += 32; // 8x8
4346 break;
4347 case 2:
4348 mipCoord.h += 32; // 4x4
4349 mipCoord.w += 16;
4350 break;
4351 case 3:
4352 mipCoord.h += 32; // 2x2
4353 mipCoord.w += 32;
4354 break;
4355 case 4:
4356 mipCoord.h += 32; // 1x1
4357 mipCoord.w += 48;
4358 break;
4359 // The following are for BC/ASTC formats
4360 case 5:
4361 mipCoord.h += 48; // 1/2 x 1/2
4362 break;
4363 case 6:
4364 mipCoord.h += 48; // 1/4 x 1/4
4365 mipCoord.w += 16;
4366 break;
4367 case 7:
4368 mipCoord.h += 48; // 1/8 x 1/8
4369 mipCoord.w += 32;
4370 break;
4371 case 8:
4372 mipCoord.h += 48; // 1/16 x 1/16
4373 mipCoord.w += 48;
4374 break;
4375 default:
4376 ADDR_ASSERT_ALWAYS();
4377 break;
4378 }
4379
4380 mipWidth = ((mip - blk32MipId) == 0) ? 16 : 8;
4381 mipHeight = mipWidth;
4382
4383 if (isThick)
4384 {
4385 mipDepth = mipWidth;
4386 }
4387 }
4388 else
4389 {
4390 if (mipWidth <= minInc)
4391 {
4392 // if we're below the minimal increment...
4393 if (isThick)
4394 {
4395 // For 3d, just go in z direction
4396 mipCoord.d += mipDepth;
4397 }
4398 else
4399 {
4400 // For 2d, first go across, then down
4401 if ((mipWidth * 2) == minInc)
4402 {
4403 // if we're 2 mips below, that's when we go back in x, and down in y
4404 mipCoord.w -= minInc;
4405 mipCoord.h += minInc;
4406 }
4407 else
4408 {
4409 // otherwise, just go across in x
4410 mipCoord.w += minInc;
4411 }
4412 }
4413 }
4414 else
4415 {
4416 // On even mip, go down, otherwise, go across
4417 if (mip & 1)
4418 {
4419 mipCoord.w += mipWidth;
4420 }
4421 else
4422 {
4423 mipCoord.h += mipHeight;
4424 }
4425 }
4426 // Divide the width by 2
4427 mipWidth >>= 1;
4428 // After the first mip in tail, the mip is always a square
4429 mipHeight = mipWidth;
4430 // ...or for 3d, a cube
4431 if (isThick)
4432 {
4433 mipDepth = mipWidth;
4434 }
4435 }
4436 }
4437 }
4438
4439 /**
4440 ************************************************************************************************************************
4441 * Gfx9Lib::GetMipStartPos
4442 *
4443 * @brief
4444 * Internal function to get out information about mip logical start position
4445 *
4446 * @return
4447 * logical start position in macro block width/heith/depth of one mip level within one slice
4448 ************************************************************************************************************************
4449 */
4450 Dim3d Gfx9Lib::GetMipStartPos(
4451 AddrResourceType resourceType,
4452 AddrSwizzleMode swizzleMode,
4453 UINT_32 width,
4454 UINT_32 height,
4455 UINT_32 depth,
4456 UINT_32 blockWidth,
4457 UINT_32 blockHeight,
4458 UINT_32 blockDepth,
4459 UINT_32 mipId,
4460 UINT_32 log2ElementBytes,
4461 UINT_32* pMipTailBytesOffset) const
4462 {
4463 Dim3d mipStartPos = {0};
4464 const Dim3d tailMaxDim = GetMipTailDim(resourceType, swizzleMode, blockWidth, blockHeight, blockDepth);
4465
4466 // Report mip in tail if Mip0 is already in mip tail
4467 BOOL_32 inMipTail = IsInMipTail(resourceType, swizzleMode, tailMaxDim, width, height, depth);
4468 UINT_32 log2blkSize = GetBlockSizeLog2(swizzleMode);
4469 UINT_32 mipIndexInTail = mipId;
4470
4471 if (inMipTail == FALSE)
4472 {
4473 // Mip 0 dimension, unit in block
4474 UINT_32 mipWidthInBlk = width / blockWidth;
4475 UINT_32 mipHeightInBlk = height / blockHeight;
4476 UINT_32 mipDepthInBlk = depth / blockDepth;
4477 AddrMajorMode majorMode = GetMajorMode(resourceType,
4478 swizzleMode,
4479 mipWidthInBlk,
4480 mipHeightInBlk,
4481 mipDepthInBlk);
4482
4483 UINT_32 endingMip = mipId + 1;
4484
4485 for (UINT_32 i = 1; i <= mipId; i++)
4486 {
4487 if ((i == 1) || (i == 3))
4488 {
4489 if (majorMode == ADDR_MAJOR_Y)
4490 {
4491 mipStartPos.w += mipWidthInBlk;
4492 }
4493 else
4494 {
4495 mipStartPos.h += mipHeightInBlk;
4496 }
4497 }
4498 else
4499 {
4500 if (majorMode == ADDR_MAJOR_X)
4501 {
4502 mipStartPos.w += mipWidthInBlk;
4503 }
4504 else if (majorMode == ADDR_MAJOR_Y)
4505 {
4506 mipStartPos.h += mipHeightInBlk;
4507 }
4508 else
4509 {
4510 mipStartPos.d += mipDepthInBlk;
4511 }
4512 }
4513
4514 BOOL_32 inTail = FALSE;
4515
4516 if (IsThick(resourceType, swizzleMode))
4517 {
4518 UINT_32 dim = log2blkSize % 3;
4519
4520 if (dim == 0)
4521 {
4522 inTail =
4523 (mipWidthInBlk <= 2) && (mipHeightInBlk == 1) && (mipDepthInBlk <= 2);
4524 }
4525 else if (dim == 1)
4526 {
4527 inTail =
4528 (mipWidthInBlk == 1) && (mipHeightInBlk <= 2) && (mipDepthInBlk <= 2);
4529 }
4530 else
4531 {
4532 inTail =
4533 (mipWidthInBlk <= 2) && (mipHeightInBlk <= 2) && (mipDepthInBlk == 1);
4534 }
4535 }
4536 else
4537 {
4538 if (log2blkSize & 1)
4539 {
4540 inTail = (mipWidthInBlk <= 2) && (mipHeightInBlk == 1);
4541 }
4542 else
4543 {
4544 inTail = (mipWidthInBlk == 1) && (mipHeightInBlk <= 2);
4545 }
4546 }
4547
4548 if (inTail)
4549 {
4550 endingMip = i;
4551 break;
4552 }
4553
4554 mipWidthInBlk = RoundHalf(mipWidthInBlk);
4555 mipHeightInBlk = RoundHalf(mipHeightInBlk);
4556 mipDepthInBlk = RoundHalf(mipDepthInBlk);
4557 }
4558
4559 if (mipId >= endingMip)
4560 {
4561 inMipTail = TRUE;
4562 mipIndexInTail = mipId - endingMip;
4563 }
4564 }
4565
4566 if (inMipTail)
4567 {
4568 UINT_32 index = mipIndexInTail + MaxMacroBits - log2blkSize;
4569 ADDR_ASSERT(index < sizeof(MipTailOffset256B) / sizeof(UINT_32));
4570 *pMipTailBytesOffset = MipTailOffset256B[index] << 8;
4571 }
4572
4573 return mipStartPos;
4574 }
4575
4576 /**
4577 ************************************************************************************************************************
4578 * Gfx9Lib::HwlComputeSurfaceAddrFromCoordTiled
4579 *
4580 * @brief
4581 * Internal function to calculate address from coord for tiled swizzle surface
4582 *
4583 * @return
4584 * ADDR_E_RETURNCODE
4585 ************************************************************************************************************************
4586 */
4587 ADDR_E_RETURNCODE Gfx9Lib::HwlComputeSurfaceAddrFromCoordTiled(
4588 const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
4589 ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
4590 ) const
4591 {
4592 ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
4593 localIn.swizzleMode = pIn->swizzleMode;
4594 localIn.flags = pIn->flags;
4595 localIn.resourceType = pIn->resourceType;
4596 localIn.bpp = pIn->bpp;
4597 localIn.width = Max(pIn->unalignedWidth, 1u);
4598 localIn.height = Max(pIn->unalignedHeight, 1u);
4599 localIn.numSlices = Max(pIn->numSlices, 1u);
4600 localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
4601 localIn.numSamples = Max(pIn->numSamples, 1u);
4602 localIn.numFrags = Max(pIn->numFrags, 1u);
4603 if (localIn.numMipLevels <= 1)
4604 {
4605 localIn.pitchInElement = pIn->pitchInElement;
4606 }
4607
4608 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT localOut = {0};
4609 ADDR_E_RETURNCODE returnCode = ComputeSurfaceInfoTiled(&localIn, &localOut);
4610
4611 BOOL_32 valid = (returnCode == ADDR_OK) &&
4612 (IsThin(pIn->resourceType, pIn->swizzleMode) ||
4613 IsThick(pIn->resourceType, pIn->swizzleMode)) &&
4614 ((pIn->pipeBankXor == 0) || (IsXor(pIn->swizzleMode)));
4615
4616 if (valid)
4617 {
4618 UINT_32 log2ElementBytes = Log2(pIn->bpp >> 3);
4619 Dim3d mipStartPos = {0};
4620 UINT_32 mipTailBytesOffset = 0;
4621
4622 if (pIn->numMipLevels > 1)
4623 {
4624 // Mip-map chain cannot be MSAA surface
4625 ADDR_ASSERT((pIn->numSamples <= 1) && (pIn->numFrags<= 1));
4626
4627 mipStartPos = GetMipStartPos(pIn->resourceType,
4628 pIn->swizzleMode,
4629 localOut.pitch,
4630 localOut.height,
4631 localOut.numSlices,
4632 localOut.blockWidth,
4633 localOut.blockHeight,
4634 localOut.blockSlices,
4635 pIn->mipId,
4636 log2ElementBytes,
4637 &mipTailBytesOffset);
4638 }
4639
4640 UINT_32 interleaveOffset = 0;
4641 UINT_32 pipeBits = 0;
4642 UINT_32 pipeXor = 0;
4643 UINT_32 bankBits = 0;
4644 UINT_32 bankXor = 0;
4645
4646 if (IsThin(pIn->resourceType, pIn->swizzleMode))
4647 {
4648 UINT_32 blockOffset = 0;
4649 UINT_32 log2blkSize = GetBlockSizeLog2(pIn->swizzleMode);
4650
4651 if (IsZOrderSwizzle(pIn->swizzleMode))
4652 {
4653 // Morton generation
4654 if ((log2ElementBytes == 0) || (log2ElementBytes == 2))
4655 {
4656 UINT_32 totalLowBits = 6 - log2ElementBytes;
4657 UINT_32 mortBits = totalLowBits / 2;
4658 UINT_32 lowBitsValue = MortonGen2d(pIn->y, pIn->x, mortBits);
4659 // Are 9 bits enough?
4660 UINT_32 highBitsValue =
4661 MortonGen2d(pIn->x >> mortBits, pIn->y >> mortBits, 9) << totalLowBits;
4662 blockOffset = lowBitsValue | highBitsValue;
4663 ADDR_ASSERT(blockOffset == lowBitsValue + highBitsValue);
4664 }
4665 else
4666 {
4667 blockOffset = MortonGen2d(pIn->y, pIn->x, 13);
4668 }
4669
4670 // Fill LSBs with sample bits
4671 if (pIn->numSamples > 1)
4672 {
4673 blockOffset *= pIn->numSamples;
4674 blockOffset |= pIn->sample;
4675 }
4676
4677 // Shift according to BytesPP
4678 blockOffset <<= log2ElementBytes;
4679 }
4680 else
4681 {
4682 // Micro block offset
4683 UINT_32 microBlockOffset = ComputeSurface2DMicroBlockOffset(pIn);
4684 blockOffset = microBlockOffset;
4685
4686 // Micro block dimension
4687 ADDR_ASSERT(log2ElementBytes < MaxNumOfBpp);
4688 Dim2d microBlockDim = Block256_2d[log2ElementBytes];
4689 // Morton generation, does 12 bit enough?
4690 blockOffset |=
4691 MortonGen2d((pIn->x / microBlockDim.w), (pIn->y / microBlockDim.h), 12) << 8;
4692
4693 // Sample bits start location
4694 UINT_32 sampleStart = log2blkSize - Log2(pIn->numSamples);
4695 // Join sample bits information to the highest Macro block bits
4696 if (IsNonPrtXor(pIn->swizzleMode))
4697 {
4698 // Non-prt-Xor : xor highest Macro block bits with sample bits
4699 blockOffset = blockOffset ^ (pIn->sample << sampleStart);
4700 }
4701 else
4702 {
4703 // Non-Xor or prt-Xor: replace highest Macro block bits with sample bits
4704 // after this op, the blockOffset only contains log2 Macro block size bits
4705 blockOffset %= (1 << sampleStart);
4706 blockOffset |= (pIn->sample << sampleStart);
4707 ADDR_ASSERT((blockOffset >> log2blkSize) == 0);
4708 }
4709 }
4710
4711 if (IsXor(pIn->swizzleMode))
4712 {
4713 // Mask off bits above Macro block bits to keep page synonyms working for prt
4714 if (IsPrt(pIn->swizzleMode))
4715 {
4716 blockOffset &= ((1 << log2blkSize) - 1);
4717 }
4718
4719 // Preserve offset inside pipe interleave
4720 interleaveOffset = blockOffset & ((1 << m_pipeInterleaveLog2) - 1);
4721 blockOffset >>= m_pipeInterleaveLog2;
4722
4723 // Pipe/Se xor bits
4724 pipeBits = GetPipeXorBits(log2blkSize);
4725 // Pipe xor
4726 pipeXor = FoldXor2d(blockOffset, pipeBits);
4727 blockOffset >>= pipeBits;
4728
4729 // Bank xor bits
4730 bankBits = GetBankXorBits(log2blkSize);
4731 // Bank Xor
4732 bankXor = FoldXor2d(blockOffset, bankBits);
4733 blockOffset >>= bankBits;
4734
4735 // Put all the part back together
4736 blockOffset <<= bankBits;
4737 blockOffset |= bankXor;
4738 blockOffset <<= pipeBits;
4739 blockOffset |= pipeXor;
4740 blockOffset <<= m_pipeInterleaveLog2;
4741 blockOffset |= interleaveOffset;
4742 }
4743
4744 ADDR_ASSERT((blockOffset | mipTailBytesOffset) == (blockOffset + mipTailBytesOffset));
4745 ADDR_ASSERT((mipTailBytesOffset == 0u) || (blockOffset < (1u << log2blkSize)));
4746
4747 blockOffset |= mipTailBytesOffset;
4748
4749 if (IsNonPrtXor(pIn->swizzleMode) && (pIn->numSamples <= 1))
4750 {
4751 // Apply slice xor if not MSAA/PRT
4752 blockOffset ^= (ReverseBitVector(pIn->slice, pipeBits) << m_pipeInterleaveLog2);
4753 blockOffset ^= (ReverseBitVector(pIn->slice >> pipeBits, bankBits) <<
4754 (m_pipeInterleaveLog2 + pipeBits));
4755 }
4756
4757 returnCode = ApplyCustomerPipeBankXor(pIn->swizzleMode, pIn->pipeBankXor,
4758 bankBits, pipeBits, &blockOffset);
4759
4760 blockOffset %= (1 << log2blkSize);
4761
4762 UINT_32 pitchInMacroBlock = localOut.mipChainPitch / localOut.blockWidth;
4763 UINT_32 paddedHeightInMacroBlock = localOut.mipChainHeight / localOut.blockHeight;
4764 UINT_32 sliceSizeInMacroBlock = pitchInMacroBlock * paddedHeightInMacroBlock;
4765 UINT_32 macroBlockIndex =
4766 (pIn->slice + mipStartPos.d) * sliceSizeInMacroBlock +
4767 ((pIn->y / localOut.blockHeight) + mipStartPos.h) * pitchInMacroBlock +
4768 ((pIn->x / localOut.blockWidth) + mipStartPos.w);
4769
4770 UINT_64 macroBlockOffset = (static_cast<UINT_64>(macroBlockIndex) <<
4771 GetBlockSizeLog2(pIn->swizzleMode));
4772
4773 pOut->addr = blockOffset | macroBlockOffset;
4774 }
4775 else
4776 {
4777 UINT_32 log2blkSize = GetBlockSizeLog2(pIn->swizzleMode);
4778
4779 Dim3d microBlockDim = Block1K_3d[log2ElementBytes];
4780
4781 UINT_32 blockOffset = MortonGen3d((pIn->x / microBlockDim.w),
4782 (pIn->y / microBlockDim.h),
4783 (pIn->slice / microBlockDim.d),
4784 8);
4785
4786 blockOffset <<= 10;
4787 blockOffset |= ComputeSurface3DMicroBlockOffset(pIn);
4788
4789 if (IsXor(pIn->swizzleMode))
4790 {
4791 // Mask off bits above Macro block bits to keep page synonyms working for prt
4792 if (IsPrt(pIn->swizzleMode))
4793 {
4794 blockOffset &= ((1 << log2blkSize) - 1);
4795 }
4796
4797 // Preserve offset inside pipe interleave
4798 interleaveOffset = blockOffset & ((1 << m_pipeInterleaveLog2) - 1);
4799 blockOffset >>= m_pipeInterleaveLog2;
4800
4801 // Pipe/Se xor bits
4802 pipeBits = GetPipeXorBits(log2blkSize);
4803 // Pipe xor
4804 pipeXor = FoldXor3d(blockOffset, pipeBits);
4805 blockOffset >>= pipeBits;
4806
4807 // Bank xor bits
4808 bankBits = GetBankXorBits(log2blkSize);
4809 // Bank Xor
4810 bankXor = FoldXor3d(blockOffset, bankBits);
4811 blockOffset >>= bankBits;
4812
4813 // Put all the part back together
4814 blockOffset <<= bankBits;
4815 blockOffset |= bankXor;
4816 blockOffset <<= pipeBits;
4817 blockOffset |= pipeXor;
4818 blockOffset <<= m_pipeInterleaveLog2;
4819 blockOffset |= interleaveOffset;
4820 }
4821
4822 ADDR_ASSERT((blockOffset | mipTailBytesOffset) == (blockOffset + mipTailBytesOffset));
4823 ADDR_ASSERT((mipTailBytesOffset == 0u) || (blockOffset < (1u << log2blkSize)));
4824 blockOffset |= mipTailBytesOffset;
4825
4826 returnCode = ApplyCustomerPipeBankXor(pIn->swizzleMode, pIn->pipeBankXor,
4827 bankBits, pipeBits, &blockOffset);
4828
4829 blockOffset %= (1 << log2blkSize);
4830
4831 UINT_32 xb = pIn->x / localOut.blockWidth + mipStartPos.w;
4832 UINT_32 yb = pIn->y / localOut.blockHeight + mipStartPos.h;
4833 UINT_32 zb = pIn->slice / localOut.blockSlices + + mipStartPos.d;
4834
4835 UINT_32 pitchInBlock = localOut.mipChainPitch / localOut.blockWidth;
4836 UINT_32 sliceSizeInBlock =
4837 (localOut.mipChainHeight / localOut.blockHeight) * pitchInBlock;
4838 UINT_32 blockIndex = zb * sliceSizeInBlock + yb * pitchInBlock + xb;
4839
4840 pOut->addr = blockOffset | (blockIndex << log2blkSize);
4841 }
4842 }
4843 else
4844 {
4845 returnCode = ADDR_INVALIDPARAMS;
4846 }
4847
4848 return returnCode;
4849 }
4850
4851 /**
4852 ************************************************************************************************************************
4853 * Gfx9Lib::ComputeSurfaceInfoLinear
4854 *
4855 * @brief
4856 * Internal function to calculate padding for linear swizzle 2D/3D surface
4857 *
4858 * @return
4859 * N/A
4860 ************************************************************************************************************************
4861 */
4862 ADDR_E_RETURNCODE Gfx9Lib::ComputeSurfaceLinearPadding(
4863 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input srtucture
4864 UINT_32* pMipmap0PaddedWidth, ///< [out] padded width in element
4865 UINT_32* pSlice0PaddedHeight, ///< [out] padded height for HW
4866 ADDR2_MIP_INFO* pMipInfo ///< [out] per mip information
4867 ) const
4868 {
4869 ADDR_E_RETURNCODE returnCode = ADDR_OK;
4870
4871 UINT_32 elementBytes = pIn->bpp >> 3;
4872 UINT_32 pitchAlignInElement = 0;
4873
4874 if (pIn->swizzleMode == ADDR_SW_LINEAR_GENERAL)
4875 {
4876 ADDR_ASSERT(pIn->numMipLevels <= 1);
4877 ADDR_ASSERT(pIn->numSlices <= 1);
4878 pitchAlignInElement = 1;
4879 }
4880 else
4881 {
4882 pitchAlignInElement = (256 / elementBytes);
4883 }
4884
4885 UINT_32 mipChainWidth = PowTwoAlign(pIn->width, pitchAlignInElement);
4886 UINT_32 slice0PaddedHeight = pIn->height;
4887
4888 returnCode = ApplyCustomizedPitchHeight(pIn, elementBytes, pitchAlignInElement,
4889 &mipChainWidth, &slice0PaddedHeight);
4890
4891 if (returnCode == ADDR_OK)
4892 {
4893 UINT_32 mipChainHeight = 0;
4894 UINT_32 mipHeight = pIn->height;
4895
4896 for (UINT_32 i = 0; i < pIn->numMipLevels; i++)
4897 {
4898 if (pMipInfo != NULL)
4899 {
4900 pMipInfo[i].offset = mipChainWidth * mipChainHeight * elementBytes;
4901 pMipInfo[i].pitch = mipChainWidth;
4902 pMipInfo[i].height = mipHeight;
4903 pMipInfo[i].depth = 1;
4904 }
4905
4906 mipChainHeight += mipHeight;
4907 mipHeight = RoundHalf(mipHeight);
4908 mipHeight = Max(mipHeight, 1u);
4909 }
4910
4911 *pMipmap0PaddedWidth = mipChainWidth;
4912 *pSlice0PaddedHeight = (pIn->numMipLevels > 1) ? mipChainHeight : slice0PaddedHeight;
4913 }
4914
4915 return returnCode;
4916 }
4917
4918 } // V2
4919 } // Addr