1 #define NVOC_KERNEL_CCU_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_ccu_nvoc.h"
9 
10 #ifdef DEBUG
11 char __nvoc_class_id_uniqueness_check_0x5d5b68 = 1;
12 #endif
13 
14 extern const struct NVOC_CLASS_DEF __nvoc_class_def_KernelCcu;
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_KernelCcu(KernelCcu*, RmHalspecOwner* );
21 void __nvoc_init_funcTable_KernelCcu(KernelCcu*, RmHalspecOwner* );
22 NV_STATUS __nvoc_ctor_KernelCcu(KernelCcu*, RmHalspecOwner* );
23 void __nvoc_init_dataField_KernelCcu(KernelCcu*, RmHalspecOwner* );
24 void __nvoc_dtor_KernelCcu(KernelCcu*);
25 extern const struct NVOC_EXPORT_INFO __nvoc_export_info_KernelCcu;
26 
27 static const struct NVOC_RTTI __nvoc_rtti_KernelCcu_KernelCcu = {
28     /*pClassDef=*/          &__nvoc_class_def_KernelCcu,
29     /*dtor=*/               (NVOC_DYNAMIC_DTOR) &__nvoc_dtor_KernelCcu,
30     /*offset=*/             0,
31 };
32 
33 static const struct NVOC_RTTI __nvoc_rtti_KernelCcu_Object = {
34     /*pClassDef=*/          &__nvoc_class_def_Object,
35     /*dtor=*/               &__nvoc_destructFromBase,
36     /*offset=*/             NV_OFFSETOF(KernelCcu, __nvoc_base_OBJENGSTATE.__nvoc_base_Object),
37 };
38 
39 static const struct NVOC_RTTI __nvoc_rtti_KernelCcu_OBJENGSTATE = {
40     /*pClassDef=*/          &__nvoc_class_def_OBJENGSTATE,
41     /*dtor=*/               &__nvoc_destructFromBase,
42     /*offset=*/             NV_OFFSETOF(KernelCcu, __nvoc_base_OBJENGSTATE),
43 };
44 
45 static const struct NVOC_CASTINFO __nvoc_castinfo_KernelCcu = {
46     /*numRelatives=*/       3,
47     /*relatives=*/ {
48         &__nvoc_rtti_KernelCcu_KernelCcu,
49         &__nvoc_rtti_KernelCcu_OBJENGSTATE,
50         &__nvoc_rtti_KernelCcu_Object,
51     },
52 };
53 
54 const struct NVOC_CLASS_DEF __nvoc_class_def_KernelCcu =
55 {
56     /*classInfo=*/ {
57         /*size=*/               sizeof(KernelCcu),
58         /*classId=*/            classId(KernelCcu),
59         /*providerId=*/         &__nvoc_rtti_provider,
60 #if NV_PRINTF_STRINGS_ALLOWED
61         /*name=*/               "KernelCcu",
62 #endif
63     },
64     /*objCreatefn=*/        (NVOC_DYNAMIC_OBJ_CREATE) &__nvoc_objCreateDynamic_KernelCcu,
65     /*pCastInfo=*/          &__nvoc_castinfo_KernelCcu,
66     /*pExportInfo=*/        &__nvoc_export_info_KernelCcu
67 };
68 
69 static NV_STATUS __nvoc_thunk_KernelCcu_engstateConstructEngine(OBJGPU *pGpu, struct OBJENGSTATE *pKernelCcu, ENGDESCRIPTOR engDesc) {
70     return kccuConstructEngine(pGpu, (struct KernelCcu *)(((unsigned char *)pKernelCcu) - __nvoc_rtti_KernelCcu_OBJENGSTATE.offset), engDesc);
71 }
72 
73 static NV_STATUS __nvoc_thunk_KernelCcu_engstateStateLoad(OBJGPU *arg0, struct OBJENGSTATE *arg1, NvU32 flags) {
74     return kccuStateLoad(arg0, (struct KernelCcu *)(((unsigned char *)arg1) - __nvoc_rtti_KernelCcu_OBJENGSTATE.offset), flags);
75 }
76 
77 static NV_STATUS __nvoc_thunk_KernelCcu_engstateStateUnload(OBJGPU *arg0, struct OBJENGSTATE *arg1, NvU32 flags) {
78     return kccuStateUnload(arg0, (struct KernelCcu *)(((unsigned char *)arg1) - __nvoc_rtti_KernelCcu_OBJENGSTATE.offset), flags);
79 }
80 
81 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kccuStateInitLocked(POBJGPU pGpu, struct KernelCcu *pEngstate) {
82     return engstateStateInitLocked(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelCcu_OBJENGSTATE.offset));
83 }
84 
85 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kccuStatePreLoad(POBJGPU pGpu, struct KernelCcu *pEngstate, NvU32 arg0) {
86     return engstateStatePreLoad(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelCcu_OBJENGSTATE.offset), arg0);
87 }
88 
89 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kccuStatePostUnload(POBJGPU pGpu, struct KernelCcu *pEngstate, NvU32 arg0) {
90     return engstateStatePostUnload(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelCcu_OBJENGSTATE.offset), arg0);
91 }
92 
93 static void __nvoc_thunk_OBJENGSTATE_kccuStateDestroy(POBJGPU pGpu, struct KernelCcu *pEngstate) {
94     engstateStateDestroy(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelCcu_OBJENGSTATE.offset));
95 }
96 
97 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kccuStatePreUnload(POBJGPU pGpu, struct KernelCcu *pEngstate, NvU32 arg0) {
98     return engstateStatePreUnload(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelCcu_OBJENGSTATE.offset), arg0);
99 }
100 
101 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kccuStateInitUnlocked(POBJGPU pGpu, struct KernelCcu *pEngstate) {
102     return engstateStateInitUnlocked(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelCcu_OBJENGSTATE.offset));
103 }
104 
105 static void __nvoc_thunk_OBJENGSTATE_kccuInitMissing(POBJGPU pGpu, struct KernelCcu *pEngstate) {
106     engstateInitMissing(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelCcu_OBJENGSTATE.offset));
107 }
108 
109 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kccuStatePreInitLocked(POBJGPU pGpu, struct KernelCcu *pEngstate) {
110     return engstateStatePreInitLocked(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelCcu_OBJENGSTATE.offset));
111 }
112 
113 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kccuStatePreInitUnlocked(POBJGPU pGpu, struct KernelCcu *pEngstate) {
114     return engstateStatePreInitUnlocked(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelCcu_OBJENGSTATE.offset));
115 }
116 
117 static NV_STATUS __nvoc_thunk_OBJENGSTATE_kccuStatePostLoad(POBJGPU pGpu, struct KernelCcu *pEngstate, NvU32 arg0) {
118     return engstateStatePostLoad(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelCcu_OBJENGSTATE.offset), arg0);
119 }
120 
121 static NvBool __nvoc_thunk_OBJENGSTATE_kccuIsPresent(POBJGPU pGpu, struct KernelCcu *pEngstate) {
122     return engstateIsPresent(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_KernelCcu_OBJENGSTATE.offset));
123 }
124 
125 const struct NVOC_EXPORT_INFO __nvoc_export_info_KernelCcu =
126 {
127     /*numEntries=*/     0,
128     /*pExportEntries=*/  0
129 };
130 
131 void __nvoc_dtor_OBJENGSTATE(OBJENGSTATE*);
132 void __nvoc_dtor_KernelCcu(KernelCcu *pThis) {
133     __nvoc_kccuDestruct(pThis);
134     __nvoc_dtor_OBJENGSTATE(&pThis->__nvoc_base_OBJENGSTATE);
135     PORT_UNREFERENCED_VARIABLE(pThis);
136 }
137 
138 void __nvoc_init_dataField_KernelCcu(KernelCcu *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* );
152 NV_STATUS __nvoc_ctor_KernelCcu(KernelCcu *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_KernelCcu_fail_OBJENGSTATE;
156     __nvoc_init_dataField_KernelCcu(pThis, pRmhalspecowner);
157     goto __nvoc_ctor_KernelCcu_exit; // Success
158 
159 __nvoc_ctor_KernelCcu_fail_OBJENGSTATE:
160 __nvoc_ctor_KernelCcu_exit:
161 
162     return status;
163 }
164 
165 static void __nvoc_init_funcTable_KernelCcu_1(KernelCcu *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     // Hal function -- kccuConstructEngine
178     pThis->__kccuConstructEngine__ = &kccuConstructEngine_IMPL;
179 
180     pThis->__kccuStateLoad__ = &kccuStateLoad_IMPL;
181 
182     pThis->__kccuStateUnload__ = &kccuStateUnload_IMPL;
183 
184     // Hal function -- kccuMigShrBufHandler
185     if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x10000000UL) )) /* ChipHal: GH100 */
186     {
187         pThis->__kccuMigShrBufHandler__ = &kccuMigShrBufHandler_GH100;
188     }
189     // default
190     else
191     {
192         pThis->__kccuMigShrBufHandler__ = &kccuMigShrBufHandler_46f6a7;
193     }
194 
195     pThis->__nvoc_base_OBJENGSTATE.__engstateConstructEngine__ = &__nvoc_thunk_KernelCcu_engstateConstructEngine;
196 
197     pThis->__nvoc_base_OBJENGSTATE.__engstateStateLoad__ = &__nvoc_thunk_KernelCcu_engstateStateLoad;
198 
199     pThis->__nvoc_base_OBJENGSTATE.__engstateStateUnload__ = &__nvoc_thunk_KernelCcu_engstateStateUnload;
200 
201     pThis->__kccuStateInitLocked__ = &__nvoc_thunk_OBJENGSTATE_kccuStateInitLocked;
202 
203     pThis->__kccuStatePreLoad__ = &__nvoc_thunk_OBJENGSTATE_kccuStatePreLoad;
204 
205     pThis->__kccuStatePostUnload__ = &__nvoc_thunk_OBJENGSTATE_kccuStatePostUnload;
206 
207     pThis->__kccuStateDestroy__ = &__nvoc_thunk_OBJENGSTATE_kccuStateDestroy;
208 
209     pThis->__kccuStatePreUnload__ = &__nvoc_thunk_OBJENGSTATE_kccuStatePreUnload;
210 
211     pThis->__kccuStateInitUnlocked__ = &__nvoc_thunk_OBJENGSTATE_kccuStateInitUnlocked;
212 
213     pThis->__kccuInitMissing__ = &__nvoc_thunk_OBJENGSTATE_kccuInitMissing;
214 
215     pThis->__kccuStatePreInitLocked__ = &__nvoc_thunk_OBJENGSTATE_kccuStatePreInitLocked;
216 
217     pThis->__kccuStatePreInitUnlocked__ = &__nvoc_thunk_OBJENGSTATE_kccuStatePreInitUnlocked;
218 
219     pThis->__kccuStatePostLoad__ = &__nvoc_thunk_OBJENGSTATE_kccuStatePostLoad;
220 
221     pThis->__kccuIsPresent__ = &__nvoc_thunk_OBJENGSTATE_kccuIsPresent;
222 }
223 
224 void __nvoc_init_funcTable_KernelCcu(KernelCcu *pThis, RmHalspecOwner *pRmhalspecowner) {
225     __nvoc_init_funcTable_KernelCcu_1(pThis, pRmhalspecowner);
226 }
227 
228 void __nvoc_init_OBJENGSTATE(OBJENGSTATE*);
229 void __nvoc_init_KernelCcu(KernelCcu *pThis, RmHalspecOwner *pRmhalspecowner) {
230     pThis->__nvoc_pbase_KernelCcu = pThis;
231     pThis->__nvoc_pbase_Object = &pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object;
232     pThis->__nvoc_pbase_OBJENGSTATE = &pThis->__nvoc_base_OBJENGSTATE;
233     __nvoc_init_OBJENGSTATE(&pThis->__nvoc_base_OBJENGSTATE);
234     __nvoc_init_funcTable_KernelCcu(pThis, pRmhalspecowner);
235 }
236 
237 NV_STATUS __nvoc_objCreate_KernelCcu(KernelCcu **ppThis, Dynamic *pParent, NvU32 createFlags) {
238     NV_STATUS status;
239     Object *pParentObj;
240     KernelCcu *pThis;
241     RmHalspecOwner *pRmhalspecowner;
242 
243     status = __nvoc_handleObjCreateMemAlloc(createFlags, sizeof(KernelCcu), (void**)&pThis, (void**)ppThis);
244     if (status != NV_OK)
245         return status;
246 
247     portMemSet(pThis, 0, sizeof(KernelCcu));
248 
249     __nvoc_initRtti(staticCast(pThis, Dynamic), &__nvoc_class_def_KernelCcu);
250 
251     pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object.createFlags = createFlags;
252 
253     if (pParent != NULL && !(createFlags & NVOC_OBJ_CREATE_FLAGS_PARENT_HALSPEC_ONLY))
254     {
255         pParentObj = dynamicCast(pParent, Object);
256         objAddChild(pParentObj, &pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object);
257     }
258     else
259     {
260         pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object.pParent = NULL;
261     }
262 
263     if ((pRmhalspecowner = dynamicCast(pParent, RmHalspecOwner)) == NULL)
264         pRmhalspecowner = objFindAncestorOfType(RmHalspecOwner, pParent);
265     NV_ASSERT_OR_RETURN(pRmhalspecowner != NULL, NV_ERR_INVALID_ARGUMENT);
266 
267     __nvoc_init_KernelCcu(pThis, pRmhalspecowner);
268     status = __nvoc_ctor_KernelCcu(pThis, pRmhalspecowner);
269     if (status != NV_OK) goto __nvoc_objCreate_KernelCcu_cleanup;
270 
271     *ppThis = pThis;
272 
273     return NV_OK;
274 
275 __nvoc_objCreate_KernelCcu_cleanup:
276     // do not call destructors here since the constructor already called them
277     if (createFlags & NVOC_OBJ_CREATE_FLAGS_IN_PLACE_CONSTRUCT)
278         portMemSet(pThis, 0, sizeof(KernelCcu));
279     else
280         portMemFree(pThis);
281 
282     // coverity[leaked_storage:FALSE]
283     return status;
284 }
285 
286 NV_STATUS __nvoc_objCreateDynamic_KernelCcu(KernelCcu **ppThis, Dynamic *pParent, NvU32 createFlags, va_list args) {
287     NV_STATUS status;
288 
289     status = __nvoc_objCreate_KernelCcu(ppThis, pParent, createFlags);
290 
291     return status;
292 }
293 
294