1 /*==============================================================================
2 Copyright(c) 2020 Intel Corporation
3
4 Permission is hereby granted, free of charge, to any person obtaining a
5 copy of this software and associated documentation files(the "Software"),
6 to deal in the Software without restriction, including without limitation
7 the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 and / or sell copies of the Software, and to permit persons to whom the
9 Software is furnished to do so, subject to the following conditions:
10
11 The above copyright notice and this permission notice shall be included
12 in all copies or substantial portions of the Software.
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 OTHER DEALINGS IN THE SOFTWARE.
21 ============================================================================*/
22
23
24 #include "Internal/Common/GmmLibInc.h"
25 #include "External/Common/GmmCachePolicy.h"
26 #include "External/Common/CachePolicy/GmmCachePolicyGen10.h"
27 #include "External/Common/CachePolicy/GmmCachePolicyGen11.h"
28 #include "External/Common/CachePolicy/GmmCachePolicyGen12.h"
29 #include "External/Common/CachePolicy/GmmCachePolicyGen12dGPU.h"
30
31 //=============================================================================
32 //
33 // Function: IsSpecialMOCSUsage
34 //
35 // Desc: This function returns special(hw-reserved) MocsIdx based on usage
36 //
37 // Parameters: usage -> Resource usage type
38 // UpdateMOCS -> True if MOCS Table must be updated, ow false
39 //
40 // Return: int32_t
41 //
42 //-----------------------------------------------------------------------------
IsSpecialMOCSUsage(GMM_RESOURCE_USAGE_TYPE Usage,bool & UpdateMOCS)43 int32_t GmmLib::GmmGen12dGPUCachePolicy::IsSpecialMOCSUsage(GMM_RESOURCE_USAGE_TYPE Usage, bool &UpdateMOCS)
44 {
45 int32_t MocsIdx = -1;
46 UpdateMOCS = true;
47
48 switch(Usage)
49 {
50 case GMM_RESOURCE_USAGE_CCS:
51 __GMM_ASSERT(pCachePolicy[Usage].L3 == 0 && //Architecturally, CCS isn't L3-cacheable.
52 pCachePolicy[Usage].UcLookup == 0); // On DG1/XE_HP_SDV/DG2, CCS Resource is never cached in L3, so LookUp is N/A
53 MocsIdx = 60;
54 break;
55 case GMM_RESOURCE_USAGE_MOCS_62:
56 __GMM_ASSERT(pCachePolicy[Usage].L3 == 0 &&
57 pCachePolicy[Usage].UcLookup == 0); //Architecturally, TR/Aux-TT node isn't L3-cacheable.
58 MocsIdx = 62;
59 break;
60 case GMM_RESOURCE_USAGE_L3_EVICTION:
61 MocsIdx = 63;
62 break;
63 case GMM_RESOURCE_USAGE_L3_EVICTION_SPECIAL:
64 case GMM_RESOURCE_USAGE_CCS_MEDIA_WRITABLE:
65 MocsIdx = 61;
66 break;
67 default:
68 UpdateMOCS = false;
69 break;
70 }
71
72 return MocsIdx;
73 }
74
75 //=============================================================================
76 //
77 // Function: __GmmGen12dGPUInitCachePolicy
78 //
79 // Desc: This function initializes the cache policy
80 //
81 // Parameters: pCachePolicy -> Ptr to array to be populated with the
82 // mapping of usages -> cache settings.
83 //
84 // Return: GMM_STATUS
85 //
86 //-----------------------------------------------------------------------------
InitCachePolicy()87 GMM_STATUS GmmLib::GmmGen12dGPUCachePolicy::InitCachePolicy()
88 {
89
90 __GMM_ASSERTPTR(pCachePolicy, GMM_ERROR);
91
92 #define DEFINE_CACHE_ELEMENT(usage, l3, l3_scc, hdcl1, go, uclookup, l1cc) DEFINE_CP_ELEMENT(usage, 0, 0, l3, 0, 0, 0, 0, l3_scc, 0, 0, 0, hdcl1, 0, 0, go, uclookup, l1cc, 0, 0, 0, 0, 0, 0)
93
94 #include "GmmGen12dGPUCachePolicy.h"
95
96 #define L3_UNCACHEABLE (0x1)
97 #define L3_WB_CACHEABLE (0x3)
98 #define L3_PAT_UNCACHEABLE (0x0)
99
100 #define DISABLE_SKIP_CACHING_CONTROL (0x0)
101 #define ENABLE_SKIP_CACHING_CONTROL (0x1)
102
103 #define DISABLE_SELF_SNOOP_OVERRIDE (0x0)
104 #define CLASS_SERVICE_ZERO (0x0)
105 #define GMM_GEN12_MAX_NUMBER_MOCS_INDEXES (60) // On TGL last four (#60-#63) are reserved by h/w, few? are sw configurable though (#60)
106 {
107 SetUpMOCSTable();
108 }
109
110 if(GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform) == IGFX_PVC)
111 {
112 SetupPAT();
113 }
114
115 {
116 // Define index of cache element
117 uint32_t Usage = 0;
118
119 #if(_WIN32 && (_DEBUG || _RELEASE_INTERNAL))
120 void *pKmdGmmContext = NULL;
121
122 OverrideCachePolicy(pKmdGmmContext);
123 #endif
124
125 // Process the cache policy and fill in the look up table
126 for(; Usage < GMM_RESOURCE_USAGE_MAX; Usage++)
127 {
128 bool CachePolicyError = false;
129 bool SpecialMOCS = false;
130 int32_t CPTblIdx = -1, PATIdx = -1;
131 uint32_t j = 0, i = 0;
132 uint64_t PTEValue = 0;
133 GMM_CACHE_POLICY_TBL_ELEMENT UsageEle = {0};
134 uint32_t StartMocsIdx = 0;
135 GMM_PRIVATE_PAT UsagePATElement = {0};
136
137
138 switch(GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform))
139 {
140 case IGFX_DG1:
141 case IGFX_XE_HP_SDV:
142 case IGFX_PVC:
143 StartMocsIdx = 1; // Index 0 is reserved for Error
144 break;
145 case IGFX_DG2:
146 // DG2 provides 2 wires for MOCS Registers, gives 4(2^2) indexes to program.
147 StartMocsIdx = 0;
148 break;
149 default:
150 StartMocsIdx = 1;
151 break;
152 }
153
154 // No Special MOCS handling for next platform
155 if(GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform) < IGFX_DG2)
156 {
157 CPTblIdx = IsSpecialMOCSUsage((GMM_RESOURCE_USAGE_TYPE)Usage, SpecialMOCS);
158 }
159
160 // Applicable upto Xe_HP only
161 if(pCachePolicy[Usage].HDCL1 &&
162 (GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform) <= IGFX_XE_HP_SDV))
163 {
164 UsageEle.HDCL1 = 1;
165 }
166
167 UsageEle.L3.Reserved = 0; // Reserved bits zeroe'd, this is so we
168 // we can compare the unioned L3.UshortValue.
169 UsageEle.L3.ESC = DISABLE_SKIP_CACHING_CONTROL;
170 UsageEle.L3.SCC = 0;
171 UsageEle.L3.Cacheability = pCachePolicy[Usage].L3 ? L3_WB_CACHEABLE : L3_UNCACHEABLE;
172
173 if(pCachePolicy[Usage].L3_SCC)
174 {
175 UsageEle.L3.ESC = ENABLE_SKIP_CACHING_CONTROL;
176 UsageEle.L3.SCC = (uint16_t)pCachePolicy[Usage].L3_SCC;
177 }
178
179 if(GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform) == IGFX_PVC)
180 {
181 pCachePolicy[Usage].GlbGo = 0;
182 pCachePolicy[Usage].UcLookup = 0;
183 }
184 // Go/Lookup
185 // N/A for SpecialMOCS
186 // N/A for DG1, RKL, PVC
187 // Applicable for IGFX_XE_HP_SDV and DG2 only
188 if(!SpecialMOCS &&
189 (FROMPRODUCT(XE_HP_SDV)) &&
190 (GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform) != IGFX_PVC))
191 {
192 if(pCachePolicy[Usage].L3 == 0)
193 {
194 UsageEle.L3.GlobalGo = pCachePolicy[Usage].GlbGo;
195 }
196 UsageEle.L3.UCLookup = pCachePolicy[Usage].UcLookup;
197 __GMM_ASSERT((pCachePolicy[Usage].UcLookup) || (pCachePolicy[Usage].L3 == 0 && pCachePolicy[Usage].UcLookup == 0));
198 }
199
200
201 //Special-case MOCS handling for MOCS Table Index 60-63
202 if(CPTblIdx >= GMM_GEN12_MAX_NUMBER_MOCS_INDEXES)
203 {
204 GMM_CACHE_POLICY_TBL_ELEMENT *TblEle = &pGmmLibContext->GetCachePolicyTlbElement()[CPTblIdx];
205
206 if(SpecialMOCS &&
207 !(TblEle->L3.UshortValue == UsageEle.L3.UshortValue))
208 {
209 //Assert if being overwritten!
210 __GMM_ASSERT(TblEle->L3.UshortValue == 0);
211
212 }
213 }
214 //For HDC L1 caching, MOCS Table index 48-59 should be used
215 else if(UsageEle.HDCL1)
216 {
217 for(j = GMM_GEN10_HDCL1_MOCS_INDEX_START; j <= CurrentMaxL1HdcMocsIndex; j++)
218 {
219 GMM_CACHE_POLICY_TBL_ELEMENT *TblEle = &pGmmLibContext->GetCachePolicyTlbElement()[j];
220 if(TblEle->L3.UshortValue == UsageEle.L3.UshortValue &&
221 TblEle->HDCL1 == UsageEle.HDCL1)
222 {
223 CPTblIdx = j;
224 break;
225 }
226 }
227 }
228 else
229 {
230 for(j = StartMocsIdx; j <= CurrentMaxMocsIndex; j++)
231 {
232 if(pCachePolicy[Usage].L3 == 0 &&
233 pCachePolicy[Usage].GlbGo == 0 &&
234 pCachePolicy[Usage].UcLookup == 0)
235 {
236 CPTblIdx = StartMocsIdx;
237 break;
238 }
239 else
240 {
241 GMM_CACHE_POLICY_TBL_ELEMENT *TblEle = &pGmmLibContext->GetCachePolicyTlbElement()[j];
242
243 if(TblEle->L3.UshortValue == UsageEle.L3.UshortValue)
244 {
245 CPTblIdx = j;
246 break;
247 }
248 }
249 }
250 }
251
252 // Didn't find the caching settings in one of the already programmed lookup table entries.
253 // Need to add a new lookup table entry.
254 if(CPTblIdx == -1)
255 {
256
257 {
258 GMM_ASSERTDPF(false, "CRITICAL ERROR: Cache Policy Usage value specified by Client is not defined in Fixed MOCS Table!");
259
260 CachePolicyError = true;
261 GMM_ASSERTDPF(
262 "Cache Policy Init Error: Invalid Cache Programming, too many unique caching combinations"
263 "(we only support GMM_GEN_MAX_NUMBER_MOCS_INDEXES = %d)",
264 CurrentMaxMocsIndex);
265
266 // Set cache policy index to uncached.
267 CPTblIdx = StartMocsIdx;
268 }
269 }
270
271 // PTE entries do not control caching on SKL+ (for legacy context)
272 if(!GetUsagePTEValue(pCachePolicy[Usage], Usage, &PTEValue))
273 {
274 CachePolicyError = true;
275 }
276
277 pCachePolicy[Usage].PTE.DwordValue = PTEValue & 0xFFFFFFFF;
278 pCachePolicy[Usage].PTE.HighDwordValue = 0;
279
280 pCachePolicy[Usage].MemoryObjectOverride.Gen12.Index = CPTblIdx;
281
282 pCachePolicy[Usage].Override = ALWAYS_OVERRIDE;
283
284 if(CachePolicyError)
285 {
286 GMM_ASSERTDPF("Cache Policy Init Error: Invalid Cache Programming - Element %d", Usage);
287 }
288
289 if(GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform) == IGFX_PVC)
290 {
291 // PAT data
292 {
293 UsagePATElement.Xe_HPC.Reserved = 0;
294
295 UsagePATElement.Xe_HPC.MemoryType = pCachePolicy[Usage].L3 ? L3_WB_CACHEABLE : L3_PAT_UNCACHEABLE;
296
297 // try to find a match in static PAT table
298 for(i = 0; i <= CurrentMaxPATIndex; i++)
299 {
300 GMM_PRIVATE_PAT PAT = GetPrivatePATEntry(i);
301 if(UsagePATElement.Xe_HPC.MemoryType == PAT.Xe_HPC.MemoryType)
302 {
303 PATIdx = i;
304 break;
305 }
306 }
307
308 if(PATIdx == -1)
309 {
310 GMM_ASSERTDPF(
311 "Cache Policy Init Error: Invalid Cache Programming, too many unique caching combinations"
312 "(we only support NumPATRegisters = %d)",
313 CurrentMaxPATIndex);
314 CachePolicyError = true;
315 // add rterror here <ToDo>
316 PATIdx = PAT0; // default to uncached PAT index 0: GMM_CP_NON_COHERENT_UC
317 // Log Error using regkey to indicate the above error
318
319 }
320 }
321
322 pCachePolicy[Usage].PATIndex = PATIdx;
323 pCachePolicy[Usage].PTE.DwordValue = GMM_GET_PTE_BITS_FROM_PAT_IDX(PATIdx) & 0xFFFFFFFF;
324 pCachePolicy[Usage].PTE.HighDwordValue = GMM_GET_PTE_BITS_FROM_PAT_IDX(PATIdx) >> 32;
325 }
326 }
327 }
328
329 return GMM_SUCCESS;
330 }
331
332 #pragma optimize("", on)
333 //=============================================================================
334 //
335 // Function: SetUpMOCSTable
336 //
337 // Desc: For Gen12dGPU, Define new Fixed MOCS table
338 //
339 // Parameters:
340 //
341 // Return: GMM_STATUS
342 //
343 //-----------------------------------------------------------------------------
SetUpMOCSTable()344 void GmmLib::GmmGen12dGPUCachePolicy::SetUpMOCSTable()
345 {
346 GMM_CACHE_POLICY_TBL_ELEMENT *pCachePolicyTlbElement = &(pGmmLibContext->GetCachePolicyTlbElement()[0]);
347 CurrentMaxL1HdcMocsIndex = 0;
348 CurrentMaxSpecialMocsIndex = 0;
349
350 #define GMM_DEFINE_MOCS(Index, L3_ESC, L3_SCC, L3_CC, L3_Go, L3_LookUp, _HDCL1) \
351 { \
352 pCachePolicyTlbElement[Index].L3.ESC = L3_ESC; \
353 pCachePolicyTlbElement[Index].L3.SCC = L3_SCC; \
354 pCachePolicyTlbElement[Index].L3.Cacheability = L3_CC; \
355 pCachePolicyTlbElement[Index].L3.GlobalGo = L3_Go; \
356 pCachePolicyTlbElement[Index].L3.UCLookup = L3_LookUp; \
357 pCachePolicyTlbElement[Index].LeCC.Cacheability = 1; \
358 pCachePolicyTlbElement[Index].LeCC.TargetCache = 0; \
359 pCachePolicyTlbElement[Index].LeCC.LRUM = 0; \
360 pCachePolicyTlbElement[Index].LeCC.AOM = 0; \
361 pCachePolicyTlbElement[Index].LeCC.ESC = 0; \
362 pCachePolicyTlbElement[Index].LeCC.SCC = 0; \
363 pCachePolicyTlbElement[Index].LeCC.PFM = 0; \
364 pCachePolicyTlbElement[Index].LeCC.SCF = 0; \
365 pCachePolicyTlbElement[Index].LeCC.CoS = CLASS_SERVICE_ZERO; \
366 pCachePolicyTlbElement[Index].LeCC.SelfSnoop = DISABLE_SELF_SNOOP_OVERRIDE; \
367 pCachePolicyTlbElement[Index].HDCL1 = _HDCL1; \
368 }
369
370 // clang-format off
371
372 if (GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform) == IGFX_DG1)
373 {
374 //Default MOCS Table
375 for(int index = 0; index < GMM_MAX_NUMBER_MOCS_INDEXES; index++)
376 { // Index ESC SCC L3CC Go LookUp HDCL1
377 GMM_DEFINE_MOCS( index , 0 , 0 , 3 , 0 , 0 , 0 )
378 }
379 // Fixed MOCS Table
380 // Index ESC SCC L3CC Go LookUp HDCL1
381 GMM_DEFINE_MOCS( 0 , 0 , 0 , 1 , 0 , 0 , 0 )
382 GMM_DEFINE_MOCS( 1 , 0 , 0 , 1 , 0 , 0 , 0 )
383 GMM_DEFINE_MOCS( 2 , 0 , 0 , 0 , 0 , 0 , 0 )
384 GMM_DEFINE_MOCS( 3 , 0 , 0 , 0 , 0 , 0 , 0 )
385 GMM_DEFINE_MOCS( 4 , 0 , 0 , 0 , 0 , 0 , 0 )
386 GMM_DEFINE_MOCS( 5 , 0 , 0 , 3 , 0 , 0 , 0 )
387 GMM_DEFINE_MOCS( 6 , 1 , 1 , 3 , 0 , 0 , 0 )
388 GMM_DEFINE_MOCS( 7 , 1 , 3 , 3 , 0 , 0 , 0 )
389 GMM_DEFINE_MOCS( 8 , 1 , 7 , 3 , 0 , 0 , 0 )
390 GMM_DEFINE_MOCS( 48 , 0 , 0 , 3 , 0 , 0 , 1 )
391 GMM_DEFINE_MOCS( 49 , 0 , 0 , 1 , 0 , 0 , 1 )
392 GMM_DEFINE_MOCS( 60 , 0 , 0 , 1 , 0 , 0 , 0 )
393 GMM_DEFINE_MOCS( 61 , 0 , 0 , 1 , 0 , 0 , 0 )
394 GMM_DEFINE_MOCS( 62 , 0 , 0 , 1 , 0 , 0 , 0 )
395 GMM_DEFINE_MOCS( 63 , 0 , 0 , 1 , 0 , 0 , 0 )
396
397 CurrentMaxMocsIndex = 8;
398 CurrentMaxL1HdcMocsIndex = 49;
399 CurrentMaxSpecialMocsIndex = 63;
400
401 }
402 else if (GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform) == IGFX_XE_HP_SDV)
403 {
404 //Default MOCS Table
405 for(int index = 0; index < GMM_MAX_NUMBER_MOCS_INDEXES; index++)
406 { // Index ESC SCC L3CC Go LookUp HDCL1
407 GMM_DEFINE_MOCS( index , 0 , 0 , 3 , 0 , 1 , 0 )
408 }
409 // Fixed MOCS Table
410 // Index ESC SCC L3CC Go LookUp HDCL1
411 GMM_DEFINE_MOCS( 1 , 0 , 0 , 1 , 0 , 1 , 0 )
412 GMM_DEFINE_MOCS( 2 , 0 , 0 , 1 , 1 , 1 , 0 )
413 GMM_DEFINE_MOCS( 3 , 0 , 0 , 1 , 1 , 0 , 0 )
414 GMM_DEFINE_MOCS( 4 , 0 , 0 , 1 , 0 , 0 , 0 )
415 GMM_DEFINE_MOCS( 5 , 0 , 0 , 3 , 0 , 1 , 0 )
416 GMM_DEFINE_MOCS( 48 , 0 , 0 , 3 , 0 , 1 , 1 )
417 GMM_DEFINE_MOCS( 49 , 0 , 0 , 1 , 0 , 1 , 1 )
418 GMM_DEFINE_MOCS( 60 , 0 , 0 , 1 , 0 , 0 , 0 )
419 GMM_DEFINE_MOCS( 61 , 0 , 0 , 1 , 0 , 0 , 0 )
420 GMM_DEFINE_MOCS( 62 , 0 , 0 , 1 , 0 , 0 , 0 )
421 GMM_DEFINE_MOCS( 63 , 0 , 0 , 1 , 0 , 0 , 0 )
422
423 CurrentMaxMocsIndex = 5;
424 CurrentMaxL1HdcMocsIndex = 49;
425 CurrentMaxSpecialMocsIndex = 63;
426
427 }
428 else if ((GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform) == IGFX_DG2))
429 {
430 //Default MOCS Table
431 for(int index = 0; index < GMM_MAX_NUMBER_MOCS_INDEXES; index++)
432 { // Index ESC SCC L3CC Go LookUp HDCL1
433 GMM_DEFINE_MOCS( index , 0 , 0 , 3 , 0 , 1 , 0 )
434 }
435 // Fixed MOCS Table
436 // Index ESC SCC L3CC Go LookUp HDCL1
437 GMM_DEFINE_MOCS( 0 , 0 , 0 , 1 , 0 , 1 , 0 )
438 GMM_DEFINE_MOCS( 1 , 0 , 0 , 1 , 1 , 1 , 0 )
439 GMM_DEFINE_MOCS( 2 , 0 , 0 , 1 , 1 , 0 , 0 )
440 GMM_DEFINE_MOCS( 3 , 0 , 0 , 3 , 0 , 1 , 0 )
441
442 CurrentMaxMocsIndex = 3;
443 }
444 else if (GFX_GET_CURRENT_PRODUCT(pGmmLibContext->GetPlatformInfo().Platform) == IGFX_PVC)
445 {
446 //Default MOCS Table
447 for(int index = 0; index < GMM_MAX_NUMBER_MOCS_INDEXES; index++)
448 { // Index ESC SCC L3CC Go LookUp HDCL1
449 GMM_DEFINE_MOCS( index , 0 , 0 , 3 , 0 , 0 , 0 )
450 }
451 // Fixed MOCS Table
452 // Index ESC SCC L3CC Go LookUp HDCL1
453 GMM_DEFINE_MOCS( 1 , 0 , 0 , 1 , 0 , 0 , 0 )
454 GMM_DEFINE_MOCS( 2 , 0 , 0 , 3 , 0 , 0 , 0 )
455
456 CurrentMaxMocsIndex = 2;
457 }
458 // clang-format on
459
460
461 #undef GMM_DEFINE_MOCS
462 }
463
464 //=============================================================================
465 //
466 // Function: SetupPAT
467 //
468 // Desc:
469 //
470 // Parameters:
471 //
472 // Return: GMM_STATUS
473 //
474 //-----------------------------------------------------------------------------
SetupPAT()475 GMM_STATUS GmmLib::GmmGen12dGPUCachePolicy::SetupPAT()
476 {
477 GMM_PRIVATE_PAT *pPATTlbElement = &(pGmmLibContext->GetPrivatePATTable()[0]);
478
479 #define L3_UC (0x0)
480 #define L3_WC (0x1)
481 #define L3_WT (0x2)
482 #define L3_WB (0x3)
483
484 #define GMM_DEFINE_PAT_ELEMENT(indx, CLOS, L3Caching) \
485 { \
486 pPATTlbElement[indx].Xe_HPC.MemoryType = L3Caching; \
487 pPATTlbElement[indx].Xe_HPC.L3CLOS = CLOS; \
488 pPATTlbElement[indx].Xe_HPC.Reserved = 0; \
489 }
490
491 // clang-format off
492
493 // Default PAT Table
494 for (uint32_t i = 0; i < NumPATRegisters; i++)
495 { // Index CLOS CachingPolicy
496 GMM_DEFINE_PAT_ELEMENT( i, 0 , L3_UC );
497 }
498
499 // Fixed PAT Table
500 // Group: CLOS0
501 // Index CLOS CachingPolicy
502 GMM_DEFINE_PAT_ELEMENT( 0 , 0 , L3_UC ) // PATRegValue = 0x0
503 GMM_DEFINE_PAT_ELEMENT( 1 , 0 , L3_WC ) // PATRegValue = 0x1
504 GMM_DEFINE_PAT_ELEMENT( 2 , 0 , L3_WT ) // PATRegValue = 0x2
505 GMM_DEFINE_PAT_ELEMENT( 3 , 0 , L3_WB ) // PATRegValue = 0x3
506 //Group: CLOS1
507 GMM_DEFINE_PAT_ELEMENT( 4 , 1 , L3_WT ) // PATRegValue = 0x6
508 GMM_DEFINE_PAT_ELEMENT( 5 , 1 , L3_WB ) // PATRegValue = 0x7
509 //Group: CLOS2
510 GMM_DEFINE_PAT_ELEMENT( 6 , 2 , L3_WT ) // PATRegValue = 0xA
511 GMM_DEFINE_PAT_ELEMENT( 7 , 2 , L3_WB ) // PATRegValue = 0xB
512
513 CurrentMaxPATIndex = 7;
514
515 // clang-format on
516 #undef GMM_DEFINE_PAT_ELEMENT
517 #undef L3_UC
518 #undef L3_WC
519 #undef L3_WT
520 #undef L3_WB
521 return GMM_SUCCESS;
522 }
523
524 /////////////////////////////////////////////////////////////////////////////////////
525 /// A simple getter function returning the PAT (cache policy) for a given
526 /// use Usage of the named resource pResInfo.
527 /// Typically used to populate PPGTT/GGTT.
528 ///
529 /// @param[in] pResInfo: Resource info for resource, can be NULL.
530 /// @param[in] Usage: Current usage for resource.
531 ///
532 /// @return PATIndex
533 /////////////////////////////////////////////////////////////////////////////////////
CachePolicyGetPATIndex(GMM_RESOURCE_INFO * pResInfo,GMM_RESOURCE_USAGE_TYPE Usage,bool * pCompressionEnable,bool IsCpuCacheable)534 uint32_t GMM_STDCALL GmmLib::GmmGen12dGPUCachePolicy::CachePolicyGetPATIndex(GMM_RESOURCE_INFO *pResInfo, GMM_RESOURCE_USAGE_TYPE Usage, bool *pCompressionEnable, bool IsCpuCacheable)
535 {
536 __GMM_ASSERT(pGmmLibContext->GetCachePolicyElement(Usage).Initialized);
537 GMM_UNREFERENCED_PARAMETER(pCompressionEnable);
538 GMM_UNREFERENCED_PARAMETER(IsCpuCacheable);
539
540 // Prevent wrong Usage for XAdapter resources. UMD does not call GetMemoryObject on shader resources but,
541 // when they add it someone could call it without knowing the restriction.
542 if(pResInfo &&
543 pResInfo->GetResFlags().Info.XAdapter &&
544 Usage != GMM_RESOURCE_USAGE_XADAPTER_SHARED_RESOURCE)
545 {
546 __GMM_ASSERT(false);
547 }
548
549 return pGmmLibContext->GetCachePolicyElement(Usage).PATIndex;
550 }
551