1 #define NVOC_KERNEL_MIG_MANAGER_H_PRIVATE_ACCESS_ALLOWED
2 #include "nvoc/runtime.h"
3 #include "nvoc/rtti.h"
4 #include "nvtypes.h"
5 #include "nvport/nvport.h"
6 #include "nvport/inline/util_valist.h"
7 #include "utils/nvassert.h"
8 #include "g_kernel_mig_manager_nvoc.h"
9
10 #ifdef DEBUG
11 char __nvoc_class_id_uniqueness_check_0x01c1bf = 1;
12 #endif
13
14 extern const struct NVOC_CLASS_DEF __nvoc_class_def_KernelMIGManager;
15
16 extern const struct NVOC_CLASS_DEF __nvoc_class_def_Object;
17
18 extern const struct NVOC_CLASS_DEF __nvoc_class_def_OBJENGSTATE;
19
20 void __nvoc_init_KernelMIGManager(KernelMIGManager*, RmHalspecOwner* );
21 void __nvoc_init_funcTable_KernelMIGManager(KernelMIGManager*, RmHalspecOwner* );
22 NV_STATUS __nvoc_ctor_KernelMIGManager(KernelMIGManager*, RmHalspecOwner* );
23 void __nvoc_init_dataField_KernelMIGManager(KernelMIGManager*, RmHalspecOwner* );
24 void __nvoc_dtor_KernelMIGManager(KernelMIGManager*);
25 extern const struct NVOC_EXPORT_INFO __nvoc_export_info_KernelMIGManager;
26
27 static const struct NVOC_RTTI __nvoc_rtti_KernelMIGManager_KernelMIGManager = {
28 /*pClassDef=*/ &__nvoc_class_def_KernelMIGManager,
29 /*dtor=*/ (NVOC_DYNAMIC_DTOR) &__nvoc_dtor_KernelMIGManager,
30 /*offset=*/ 0,
31 };
32
33 static const struct NVOC_RTTI __nvoc_rtti_KernelMIGManager_Object = {
34 /*pClassDef=*/ &__nvoc_class_def_Object,
35 /*dtor=*/ &__nvoc_destructFromBase,
36 /*offset=*/ NV_OFFSETOF(KernelMIGManager, __nvoc_base_OBJENGSTATE.__nvoc_base_Object),
37 };
38
39 static const struct NVOC_RTTI __nvoc_rtti_KernelMIGManager_OBJENGSTATE = {
40 /*pClassDef=*/ &__nvoc_class_def_OBJENGSTATE,
41 /*dtor=*/ &__nvoc_destructFromBase,
42 /*offset=*/ NV_OFFSETOF(KernelMIGManager, __nvoc_base_OBJENGSTATE),
43 };
44
45 static const struct NVOC_CASTINFO __nvoc_castinfo_KernelMIGManager = {
46 /*numRelatives=*/ 3,
47 /*relatives=*/ {
48 &__nvoc_rtti_KernelMIGManager_KernelMIGManager,
49 &__nvoc_rtti_KernelMIGManager_OBJENGSTATE,
50 &__nvoc_rtti_KernelMIGManager_Object,
51 },
52 };
53
54 const struct NVOC_CLASS_DEF __nvoc_class_def_KernelMIGManager =
55 {
56 /*classInfo=*/ {
57 /*size=*/ sizeof(KernelMIGManager),
58 /*classId=*/ classId(KernelMIGManager),
59 /*providerId=*/ &__nvoc_rtti_provider,
60 #if NV_PRINTF_STRINGS_ALLOWED
61 /*name=*/ "KernelMIGManager",
62 #endif
63 },
64 /*objCreatefn=*/ (NVOC_DYNAMIC_OBJ_CREATE) &__nvoc_objCreateDynamic_KernelMIGManager,
65 /*pCastInfo=*/ &__nvoc_castinfo_KernelMIGManager,
66 /*pExportInfo=*/ &__nvoc_export_info_KernelMIGManager
67 };
68
__nvoc_thunk_KernelMIGManager_engstateConstructEngine(OBJGPU * arg0,struct OBJENGSTATE * arg1,ENGDESCRIPTOR arg2)69 static NV_STATUS __nvoc_thunk_KernelMIGManager_engstateConstructEngine(OBJGPU *arg0, struct OBJENGSTATE *arg1, ENGDESCRIPTOR arg2) {
70 return kmigmgrConstructEngine(arg0, (struct KernelMIGManager *)(((unsigned char *)arg1) - __nvoc_rtti_KernelMIGManager_OBJENGSTATE.offset), arg2);
71 }
72
__nvoc_thunk_KernelMIGManager_engstateStateInitLocked(OBJGPU * arg0,struct OBJENGSTATE * arg1)73 static NV_STATUS __nvoc_thunk_KernelMIGManager_engstateStateInitLocked(OBJGPU *arg0, struct OBJENGSTATE *arg1) {
74 return kmigmgrStateInitLocked(arg0, (struct KernelMIGManager *)(((unsigned char *)arg1) - __nvoc_rtti_KernelMIGManager_OBJENGSTATE.offset));
75 }
76
__nvoc_thunk_KernelMIGManager_engstateStateUnload(OBJGPU * arg0,struct OBJENGSTATE * arg1,NvU32 flags)77 static NV_STATUS __nvoc_thunk_KernelMIGManager_engstateStateUnload(OBJGPU *arg0, struct OBJENGSTATE *arg1, NvU32 flags) {
78 return kmigmgrStateUnload(arg0, (struct KernelMIGManager *)(((unsigned char *)arg1) - __nvoc_rtti_KernelMIGManager_OBJENGSTATE.offset), flags);
79 }
80
__nvoc_thunk_OBJENGSTATE_kmigmgrStateLoad(POBJGPU pGpu,struct KernelMIGManager * pEngstate,NvU32 arg0)81 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kmigmgrStateLoad(POBJGPU pGpu, struct KernelMIGManager *pEngstate, NvU32 arg0) {
82 return engstateStateLoad(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelMIGManager_OBJENGSTATE.offset), arg0);
83 }
84
__nvoc_thunk_OBJENGSTATE_kmigmgrStatePreLoad(POBJGPU pGpu,struct KernelMIGManager * pEngstate,NvU32 arg0)85 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kmigmgrStatePreLoad(POBJGPU pGpu, struct KernelMIGManager *pEngstate, NvU32 arg0) {
86 return engstateStatePreLoad(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelMIGManager_OBJENGSTATE.offset), arg0);
87 }
88
__nvoc_thunk_OBJENGSTATE_kmigmgrStatePostUnload(POBJGPU pGpu,struct KernelMIGManager * pEngstate,NvU32 arg0)89 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kmigmgrStatePostUnload(POBJGPU pGpu, struct KernelMIGManager *pEngstate, NvU32 arg0) {
90 return engstateStatePostUnload(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelMIGManager_OBJENGSTATE.offset), arg0);
91 }
92
__nvoc_thunk_OBJENGSTATE_kmigmgrStateDestroy(POBJGPU pGpu,struct KernelMIGManager * pEngstate)93 static void __nvoc_thunk_OBJENGSTATE_kmigmgrStateDestroy(POBJGPU pGpu, struct KernelMIGManager *pEngstate) {
94 engstateStateDestroy(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelMIGManager_OBJENGSTATE.offset));
95 }
96
__nvoc_thunk_OBJENGSTATE_kmigmgrStatePreUnload(POBJGPU pGpu,struct KernelMIGManager * pEngstate,NvU32 arg0)97 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kmigmgrStatePreUnload(POBJGPU pGpu, struct KernelMIGManager *pEngstate, NvU32 arg0) {
98 return engstateStatePreUnload(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelMIGManager_OBJENGSTATE.offset), arg0);
99 }
100
__nvoc_thunk_OBJENGSTATE_kmigmgrStateInitUnlocked(POBJGPU pGpu,struct KernelMIGManager * pEngstate)101 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kmigmgrStateInitUnlocked(POBJGPU pGpu, struct KernelMIGManager *pEngstate) {
102 return engstateStateInitUnlocked(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelMIGManager_OBJENGSTATE.offset));
103 }
104
__nvoc_thunk_OBJENGSTATE_kmigmgrInitMissing(POBJGPU pGpu,struct KernelMIGManager * pEngstate)105 static void __nvoc_thunk_OBJENGSTATE_kmigmgrInitMissing(POBJGPU pGpu, struct KernelMIGManager *pEngstate) {
106 engstateInitMissing(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelMIGManager_OBJENGSTATE.offset));
107 }
108
__nvoc_thunk_OBJENGSTATE_kmigmgrStatePreInitLocked(POBJGPU pGpu,struct KernelMIGManager * pEngstate)109 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kmigmgrStatePreInitLocked(POBJGPU pGpu, struct KernelMIGManager *pEngstate) {
110 return engstateStatePreInitLocked(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelMIGManager_OBJENGSTATE.offset));
111 }
112
__nvoc_thunk_OBJENGSTATE_kmigmgrStatePreInitUnlocked(POBJGPU pGpu,struct KernelMIGManager * pEngstate)113 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kmigmgrStatePreInitUnlocked(POBJGPU pGpu, struct KernelMIGManager *pEngstate) {
114 return engstateStatePreInitUnlocked(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelMIGManager_OBJENGSTATE.offset));
115 }
116
__nvoc_thunk_OBJENGSTATE_kmigmgrStatePostLoad(POBJGPU pGpu,struct KernelMIGManager * pEngstate,NvU32 arg0)117 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kmigmgrStatePostLoad(POBJGPU pGpu, struct KernelMIGManager *pEngstate, NvU32 arg0) {
118 return engstateStatePostLoad(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelMIGManager_OBJENGSTATE.offset), arg0);
119 }
120
__nvoc_thunk_OBJENGSTATE_kmigmgrIsPresent(POBJGPU pGpu,struct KernelMIGManager * pEngstate)121 static NvBool __nvoc_thunk_OBJENGSTATE_kmigmgrIsPresent(POBJGPU pGpu, struct KernelMIGManager *pEngstate) {
122 return engstateIsPresent(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelMIGManager_OBJENGSTATE.offset));
123 }
124
125 const struct NVOC_EXPORT_INFO __nvoc_export_info_KernelMIGManager =
126 {
127 /*numEntries=*/ 0,
128 /*pExportEntries=*/ 0
129 };
130
131 void __nvoc_dtor_OBJENGSTATE(OBJENGSTATE*);
__nvoc_dtor_KernelMIGManager(KernelMIGManager * pThis)132 void __nvoc_dtor_KernelMIGManager(KernelMIGManager *pThis) {
133 __nvoc_kmigmgrDestruct(pThis);
134 __nvoc_dtor_OBJENGSTATE(&pThis->__nvoc_base_OBJENGSTATE);
135 PORT_UNREFERENCED_VARIABLE(pThis);
136 }
137
__nvoc_init_dataField_KernelMIGManager(KernelMIGManager * pThis,RmHalspecOwner * pRmhalspecowner)138 void __nvoc_init_dataField_KernelMIGManager(KernelMIGManager *pThis, RmHalspecOwner *pRmhalspecowner) {
139 RmVariantHal *rmVariantHal = &pRmhalspecowner->rmVariantHal;
140 const unsigned long rmVariantHal_HalVarIdx = (unsigned long)rmVariantHal->__nvoc_HalVarIdx;
141 ChipHal *chipHal = &pRmhalspecowner->chipHal;
142 const unsigned long chipHal_HalVarIdx = (unsigned long)chipHal->__nvoc_HalVarIdx;
143 PORT_UNREFERENCED_VARIABLE(pThis);
144 PORT_UNREFERENCED_VARIABLE(pRmhalspecowner);
145 PORT_UNREFERENCED_VARIABLE(rmVariantHal);
146 PORT_UNREFERENCED_VARIABLE(rmVariantHal_HalVarIdx);
147 PORT_UNREFERENCED_VARIABLE(chipHal);
148 PORT_UNREFERENCED_VARIABLE(chipHal_HalVarIdx);
149 }
150
151 NV_STATUS __nvoc_ctor_OBJENGSTATE(OBJENGSTATE* );
__nvoc_ctor_KernelMIGManager(KernelMIGManager * pThis,RmHalspecOwner * pRmhalspecowner)152 NV_STATUS __nvoc_ctor_KernelMIGManager(KernelMIGManager *pThis, RmHalspecOwner *pRmhalspecowner) {
153 NV_STATUS status = NV_OK;
154 status = __nvoc_ctor_OBJENGSTATE(&pThis->__nvoc_base_OBJENGSTATE);
155 if (status != NV_OK) goto __nvoc_ctor_KernelMIGManager_fail_OBJENGSTATE;
156 __nvoc_init_dataField_KernelMIGManager(pThis, pRmhalspecowner);
157 goto __nvoc_ctor_KernelMIGManager_exit; // Success
158
159 __nvoc_ctor_KernelMIGManager_fail_OBJENGSTATE:
160 __nvoc_ctor_KernelMIGManager_exit:
161
162 return status;
163 }
164
__nvoc_init_funcTable_KernelMIGManager_1(KernelMIGManager * pThis,RmHalspecOwner * pRmhalspecowner)165 static void __nvoc_init_funcTable_KernelMIGManager_1(KernelMIGManager *pThis, RmHalspecOwner *pRmhalspecowner) {
166 RmVariantHal *rmVariantHal = &pRmhalspecowner->rmVariantHal;
167 const unsigned long rmVariantHal_HalVarIdx = (unsigned long)rmVariantHal->__nvoc_HalVarIdx;
168 ChipHal *chipHal = &pRmhalspecowner->chipHal;
169 const unsigned long chipHal_HalVarIdx = (unsigned long)chipHal->__nvoc_HalVarIdx;
170 PORT_UNREFERENCED_VARIABLE(pThis);
171 PORT_UNREFERENCED_VARIABLE(pRmhalspecowner);
172 PORT_UNREFERENCED_VARIABLE(rmVariantHal);
173 PORT_UNREFERENCED_VARIABLE(rmVariantHal_HalVarIdx);
174 PORT_UNREFERENCED_VARIABLE(chipHal);
175 PORT_UNREFERENCED_VARIABLE(chipHal_HalVarIdx);
176
177 pThis->__kmigmgrConstructEngine__ = &kmigmgrConstructEngine_IMPL;
178
179 pThis->__kmigmgrStateInitLocked__ = &kmigmgrStateInitLocked_IMPL;
180
181 pThis->__kmigmgrStateUnload__ = &kmigmgrStateUnload_IMPL;
182
183 // Hal function -- kmigmgrLoadStaticInfo
184 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
185 {
186 pThis->__kmigmgrLoadStaticInfo__ = &kmigmgrLoadStaticInfo_VF;
187 }
188 else
189 {
190 pThis->__kmigmgrLoadStaticInfo__ = &kmigmgrLoadStaticInfo_KERNEL;
191 }
192
193 // Hal function -- kmigmgrSetStaticInfo
194 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
195 {
196 pThis->__kmigmgrSetStaticInfo__ = &kmigmgrSetStaticInfo_VF;
197 }
198 else
199 {
200 pThis->__kmigmgrSetStaticInfo__ = &kmigmgrSetStaticInfo_46f6a7;
201 }
202
203 // Hal function -- kmigmgrClearStaticInfo
204 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
205 {
206 pThis->__kmigmgrClearStaticInfo__ = &kmigmgrClearStaticInfo_VF;
207 }
208 else
209 {
210 pThis->__kmigmgrClearStaticInfo__ = &kmigmgrClearStaticInfo_b3696a;
211 }
212
213 // Hal function -- kmigmgrSaveToPersistenceFromVgpuStaticInfo
214 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
215 {
216 pThis->__kmigmgrSaveToPersistenceFromVgpuStaticInfo__ = &kmigmgrSaveToPersistenceFromVgpuStaticInfo_VF;
217 }
218 else
219 {
220 pThis->__kmigmgrSaveToPersistenceFromVgpuStaticInfo__ = &kmigmgrSaveToPersistenceFromVgpuStaticInfo_46f6a7;
221 }
222
223 // Hal function -- kmigmgrDeleteGPUInstanceRunlists
224 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
225 {
226 pThis->__kmigmgrDeleteGPUInstanceRunlists__ = &kmigmgrDeleteGPUInstanceRunlists_56cd7a;
227 }
228 else
229 {
230 pThis->__kmigmgrDeleteGPUInstanceRunlists__ = &kmigmgrDeleteGPUInstanceRunlists_FWCLIENT;
231 }
232
233 // Hal function -- kmigmgrCreateGPUInstanceRunlists
234 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
235 {
236 pThis->__kmigmgrCreateGPUInstanceRunlists__ = &kmigmgrCreateGPUInstanceRunlists_56cd7a;
237 }
238 else
239 {
240 pThis->__kmigmgrCreateGPUInstanceRunlists__ = &kmigmgrCreateGPUInstanceRunlists_FWCLIENT;
241 }
242
243 // Hal function -- kmigmgrRestoreFromPersistence
244 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
245 {
246 pThis->__kmigmgrRestoreFromPersistence__ = &kmigmgrRestoreFromPersistence_VF;
247 }
248 else
249 {
250 pThis->__kmigmgrRestoreFromPersistence__ = &kmigmgrRestoreFromPersistence_PF;
251 }
252
253 // Hal function -- kmigmgrCreateGPUInstanceCheck
254 if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x10000400UL) )) /* ChipHal: GA100 | GH100 */
255 {
256 pThis->__kmigmgrCreateGPUInstanceCheck__ = &kmigmgrCreateGPUInstanceCheck_GA100;
257 }
258 else
259 {
260 pThis->__kmigmgrCreateGPUInstanceCheck__ = &kmigmgrCreateGPUInstanceCheck_46f6a7;
261 }
262
263 // Hal function -- kmigmgrIsDevinitMIGBitSet
264 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
265 {
266 pThis->__kmigmgrIsDevinitMIGBitSet__ = &kmigmgrIsDevinitMIGBitSet_VF;
267 }
268 else
269 {
270 if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x00000400UL) )) /* ChipHal: GA100 */
271 {
272 pThis->__kmigmgrIsDevinitMIGBitSet__ = &kmigmgrIsDevinitMIGBitSet_GA100;
273 }
274 // default
275 else
276 {
277 pThis->__kmigmgrIsDevinitMIGBitSet__ = &kmigmgrIsDevinitMIGBitSet_491d52;
278 }
279 }
280
281 // Hal function -- kmigmgrIsGPUInstanceCombinationValid
282 if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x00000400UL) )) /* ChipHal: GA100 */
283 {
284 pThis->__kmigmgrIsGPUInstanceCombinationValid__ = &kmigmgrIsGPUInstanceCombinationValid_GA100;
285 }
286 else if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x10000000UL) )) /* ChipHal: GH100 */
287 {
288 pThis->__kmigmgrIsGPUInstanceCombinationValid__ = &kmigmgrIsGPUInstanceCombinationValid_GH100;
289 }
290 // default
291 else
292 {
293 pThis->__kmigmgrIsGPUInstanceCombinationValid__ = &kmigmgrIsGPUInstanceCombinationValid_491d52;
294 }
295
296 // Hal function -- kmigmgrIsGPUInstanceFlagValid
297 if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x00000400UL) )) /* ChipHal: GA100 */
298 {
299 pThis->__kmigmgrIsGPUInstanceFlagValid__ = &kmigmgrIsGPUInstanceFlagValid_GA100;
300 }
301 else if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x10000000UL) )) /* ChipHal: GH100 */
302 {
303 pThis->__kmigmgrIsGPUInstanceFlagValid__ = &kmigmgrIsGPUInstanceFlagValid_GH100;
304 }
305 // default
306 else
307 {
308 pThis->__kmigmgrIsGPUInstanceFlagValid__ = &kmigmgrIsGPUInstanceFlagValid_491d52;
309 }
310
311 // Hal function -- kmigmgrGenerateComputeInstanceUuid
312 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
313 {
314 pThis->__kmigmgrGenerateComputeInstanceUuid__ = &kmigmgrGenerateComputeInstanceUuid_VF;
315 }
316 // default
317 else
318 {
319 pThis->__kmigmgrGenerateComputeInstanceUuid__ = &kmigmgrGenerateComputeInstanceUuid_5baef9;
320 }
321
322 // Hal function -- kmigmgrGenerateGPUInstanceUuid
323 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
324 {
325 pThis->__kmigmgrGenerateGPUInstanceUuid__ = &kmigmgrGenerateGPUInstanceUuid_VF;
326 }
327 // default
328 else
329 {
330 pThis->__kmigmgrGenerateGPUInstanceUuid__ = &kmigmgrGenerateGPUInstanceUuid_5baef9;
331 }
332
333 // Hal function -- kmigmgrCreateComputeInstances
334 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
335 {
336 pThis->__kmigmgrCreateComputeInstances__ = &kmigmgrCreateComputeInstances_VF;
337 }
338 else
339 {
340 pThis->__kmigmgrCreateComputeInstances__ = &kmigmgrCreateComputeInstances_FWCLIENT;
341 }
342
343 // Hal function -- kmigmgrIsMemoryPartitioningRequested
344 if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x10000400UL) )) /* ChipHal: GA100 | GH100 */
345 {
346 pThis->__kmigmgrIsMemoryPartitioningRequested__ = &kmigmgrIsMemoryPartitioningRequested_GA100;
347 }
348 else
349 {
350 pThis->__kmigmgrIsMemoryPartitioningRequested__ = &kmigmgrIsMemoryPartitioningRequested_491d52;
351 }
352
353 // Hal function -- kmigmgrIsMemoryPartitioningNeeded
354 if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x10000400UL) )) /* ChipHal: GA100 | GH100 */
355 {
356 pThis->__kmigmgrIsMemoryPartitioningNeeded__ = &kmigmgrIsMemoryPartitioningNeeded_GA100;
357 }
358 else
359 {
360 pThis->__kmigmgrIsMemoryPartitioningNeeded__ = &kmigmgrIsMemoryPartitioningNeeded_491d52;
361 }
362
363 // Hal function -- kmigmgrMemSizeFlagToSwizzIdRange
364 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
365 {
366 pThis->__kmigmgrMemSizeFlagToSwizzIdRange__ = &kmigmgrMemSizeFlagToSwizzIdRange_d64cd6;
367 }
368 else
369 {
370 if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x10000400UL) )) /* ChipHal: GA100 | GH100 */
371 {
372 pThis->__kmigmgrMemSizeFlagToSwizzIdRange__ = &kmigmgrMemSizeFlagToSwizzIdRange_GA100;
373 }
374 else
375 {
376 pThis->__kmigmgrMemSizeFlagToSwizzIdRange__ = &kmigmgrMemSizeFlagToSwizzIdRange_d64cd6;
377 }
378 }
379
380 // Hal function -- kmigmgrSwizzIdToSpan
381 if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x10000400UL) )) /* ChipHal: GA100 | GH100 */
382 {
383 pThis->__kmigmgrSwizzIdToSpan__ = &kmigmgrSwizzIdToSpan_GA100;
384 }
385 else
386 {
387 pThis->__kmigmgrSwizzIdToSpan__ = &kmigmgrSwizzIdToSpan_d64cd6;
388 }
389
390 // Hal function -- kmigmgrSetMIGState
391 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
392 {
393 pThis->__kmigmgrSetMIGState__ = &kmigmgrSetMIGState_VF;
394 }
395 else
396 {
397 pThis->__kmigmgrSetMIGState__ = &kmigmgrSetMIGState_FWCLIENT;
398 }
399
400 // Hal function -- kmigmgrIsCTSAlignmentRequired
401 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
402 {
403 pThis->__kmigmgrIsCTSAlignmentRequired__ = &kmigmgrIsCTSAlignmentRequired_VF;
404 }
405 else
406 {
407 pThis->__kmigmgrIsCTSAlignmentRequired__ = &kmigmgrIsCTSAlignmentRequired_PF;
408 }
409
410 // Hal function -- kmigmgrRestoreFromBootConfig
411 if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000001UL) )) /* RmVariantHal: VF */
412 {
413 pThis->__kmigmgrRestoreFromBootConfig__ = &kmigmgrRestoreFromBootConfig_56cd7a;
414 }
415 else
416 {
417 pThis->__kmigmgrRestoreFromBootConfig__ = &kmigmgrRestoreFromBootConfig_PF;
418 }
419
420 pThis->__nvoc_base_OBJENGSTATE.__engstateConstructEngine__ = &__nvoc_thunk_KernelMIGManager_engstateConstructEngine;
421
422 pThis->__nvoc_base_OBJENGSTATE.__engstateStateInitLocked__ = &__nvoc_thunk_KernelMIGManager_engstateStateInitLocked;
423
424 pThis->__nvoc_base_OBJENGSTATE.__engstateStateUnload__ = &__nvoc_thunk_KernelMIGManager_engstateStateUnload;
425
426 pThis->__kmigmgrStateLoad__ = &__nvoc_thunk_OBJENGSTATE_kmigmgrStateLoad;
427
428 pThis->__kmigmgrStatePreLoad__ = &__nvoc_thunk_OBJENGSTATE_kmigmgrStatePreLoad;
429
430 pThis->__kmigmgrStatePostUnload__ = &__nvoc_thunk_OBJENGSTATE_kmigmgrStatePostUnload;
431
432 pThis->__kmigmgrStateDestroy__ = &__nvoc_thunk_OBJENGSTATE_kmigmgrStateDestroy;
433
434 pThis->__kmigmgrStatePreUnload__ = &__nvoc_thunk_OBJENGSTATE_kmigmgrStatePreUnload;
435
436 pThis->__kmigmgrStateInitUnlocked__ = &__nvoc_thunk_OBJENGSTATE_kmigmgrStateInitUnlocked;
437
438 pThis->__kmigmgrInitMissing__ = &__nvoc_thunk_OBJENGSTATE_kmigmgrInitMissing;
439
440 pThis->__kmigmgrStatePreInitLocked__ = &__nvoc_thunk_OBJENGSTATE_kmigmgrStatePreInitLocked;
441
442 pThis->__kmigmgrStatePreInitUnlocked__ = &__nvoc_thunk_OBJENGSTATE_kmigmgrStatePreInitUnlocked;
443
444 pThis->__kmigmgrStatePostLoad__ = &__nvoc_thunk_OBJENGSTATE_kmigmgrStatePostLoad;
445
446 pThis->__kmigmgrIsPresent__ = &__nvoc_thunk_OBJENGSTATE_kmigmgrIsPresent;
447 }
448
__nvoc_init_funcTable_KernelMIGManager(KernelMIGManager * pThis,RmHalspecOwner * pRmhalspecowner)449 void __nvoc_init_funcTable_KernelMIGManager(KernelMIGManager *pThis, RmHalspecOwner *pRmhalspecowner) {
450 __nvoc_init_funcTable_KernelMIGManager_1(pThis, pRmhalspecowner);
451 }
452
453 void __nvoc_init_OBJENGSTATE(OBJENGSTATE*);
__nvoc_init_KernelMIGManager(KernelMIGManager * pThis,RmHalspecOwner * pRmhalspecowner)454 void __nvoc_init_KernelMIGManager(KernelMIGManager *pThis, RmHalspecOwner *pRmhalspecowner) {
455 pThis->__nvoc_pbase_KernelMIGManager = pThis;
456 pThis->__nvoc_pbase_Object = &pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object;
457 pThis->__nvoc_pbase_OBJENGSTATE = &pThis->__nvoc_base_OBJENGSTATE;
458 __nvoc_init_OBJENGSTATE(&pThis->__nvoc_base_OBJENGSTATE);
459 __nvoc_init_funcTable_KernelMIGManager(pThis, pRmhalspecowner);
460 }
461
__nvoc_objCreate_KernelMIGManager(KernelMIGManager ** ppThis,Dynamic * pParent,NvU32 createFlags)462 NV_STATUS __nvoc_objCreate_KernelMIGManager(KernelMIGManager **ppThis, Dynamic *pParent, NvU32 createFlags)
463 {
464 NV_STATUS status;
465 Object *pParentObj = NULL;
466 KernelMIGManager *pThis;
467 RmHalspecOwner *pRmhalspecowner;
468
469 // Assign `pThis`, allocating memory unless suppressed by flag.
470 status = __nvoc_handleObjCreateMemAlloc(createFlags, sizeof(KernelMIGManager), (void**)&pThis, (void**)ppThis);
471 if (status != NV_OK)
472 return status;
473
474 // Zero is the initial value for everything.
475 portMemSet(pThis, 0, sizeof(KernelMIGManager));
476
477 // Initialize runtime type information.
478 __nvoc_initRtti(staticCast(pThis, Dynamic), &__nvoc_class_def_KernelMIGManager);
479
480 pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object.createFlags = createFlags;
481
482 // pParent must be a valid object that derives from a halspec owner class.
483 NV_ASSERT_OR_RETURN(pParent != NULL, NV_ERR_INVALID_ARGUMENT);
484
485 // Link the child into the parent unless flagged not to do so.
486 if (!(createFlags & NVOC_OBJ_CREATE_FLAGS_PARENT_HALSPEC_ONLY))
487 {
488 pParentObj = dynamicCast(pParent, Object);
489 objAddChild(pParentObj, &pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object);
490 }
491 else
492 {
493 pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object.pParent = NULL;
494 }
495
496 if ((pRmhalspecowner = dynamicCast(pParent, RmHalspecOwner)) == NULL)
497 pRmhalspecowner = objFindAncestorOfType(RmHalspecOwner, pParent);
498 NV_ASSERT_OR_RETURN(pRmhalspecowner != NULL, NV_ERR_INVALID_ARGUMENT);
499
500 __nvoc_init_KernelMIGManager(pThis, pRmhalspecowner);
501 status = __nvoc_ctor_KernelMIGManager(pThis, pRmhalspecowner);
502 if (status != NV_OK) goto __nvoc_objCreate_KernelMIGManager_cleanup;
503
504 // Assignment has no effect if NVOC_OBJ_CREATE_FLAGS_IN_PLACE_CONSTRUCT is set.
505 *ppThis = pThis;
506
507 return NV_OK;
508
509 __nvoc_objCreate_KernelMIGManager_cleanup:
510
511 // Unlink the child from the parent if it was linked above.
512 if (pParentObj != NULL)
513 objRemoveChild(pParentObj, &pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object);
514
515 // Do not call destructors here since the constructor already called them.
516 if (createFlags & NVOC_OBJ_CREATE_FLAGS_IN_PLACE_CONSTRUCT)
517 portMemSet(pThis, 0, sizeof(KernelMIGManager));
518 else
519 {
520 portMemFree(pThis);
521 *ppThis = NULL;
522 }
523
524 // coverity[leaked_storage:FALSE]
525 return status;
526 }
527
__nvoc_objCreateDynamic_KernelMIGManager(KernelMIGManager ** ppThis,Dynamic * pParent,NvU32 createFlags,va_list args)528 NV_STATUS __nvoc_objCreateDynamic_KernelMIGManager(KernelMIGManager **ppThis, Dynamic *pParent, NvU32 createFlags, va_list args) {
529 NV_STATUS status;
530
531 status = __nvoc_objCreate_KernelMIGManager(ppThis, pParent, createFlags);
532
533 return status;
534 }
535
536