1 #define NVOC_SWINTR_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_swintr_nvoc.h"
9 
10 #ifdef DEBUG
11 char __nvoc_class_id_uniqueness_check_0x5ca633 = 1;
12 #endif
13 
14 extern const struct NVOC_CLASS_DEF __nvoc_class_def_SwIntr;
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 extern const struct NVOC_CLASS_DEF __nvoc_class_def_IntrService;
21 
22 void __nvoc_init_SwIntr(SwIntr*);
23 void __nvoc_init_funcTable_SwIntr(SwIntr*);
24 NV_STATUS __nvoc_ctor_SwIntr(SwIntr*);
25 void __nvoc_init_dataField_SwIntr(SwIntr*);
26 void __nvoc_dtor_SwIntr(SwIntr*);
27 extern const struct NVOC_EXPORT_INFO __nvoc_export_info_SwIntr;
28 
29 static const struct NVOC_RTTI __nvoc_rtti_SwIntr_SwIntr = {
30     /*pClassDef=*/          &__nvoc_class_def_SwIntr,
31     /*dtor=*/               (NVOC_DYNAMIC_DTOR) &__nvoc_dtor_SwIntr,
32     /*offset=*/             0,
33 };
34 
35 static const struct NVOC_RTTI __nvoc_rtti_SwIntr_Object = {
36     /*pClassDef=*/          &__nvoc_class_def_Object,
37     /*dtor=*/               &__nvoc_destructFromBase,
38     /*offset=*/             NV_OFFSETOF(SwIntr, __nvoc_base_OBJENGSTATE.__nvoc_base_Object),
39 };
40 
41 static const struct NVOC_RTTI __nvoc_rtti_SwIntr_OBJENGSTATE = {
42     /*pClassDef=*/          &__nvoc_class_def_OBJENGSTATE,
43     /*dtor=*/               &__nvoc_destructFromBase,
44     /*offset=*/             NV_OFFSETOF(SwIntr, __nvoc_base_OBJENGSTATE),
45 };
46 
47 static const struct NVOC_RTTI __nvoc_rtti_SwIntr_IntrService = {
48     /*pClassDef=*/          &__nvoc_class_def_IntrService,
49     /*dtor=*/               &__nvoc_destructFromBase,
50     /*offset=*/             NV_OFFSETOF(SwIntr, __nvoc_base_IntrService),
51 };
52 
53 static const struct NVOC_CASTINFO __nvoc_castinfo_SwIntr = {
54     /*numRelatives=*/       4,
55     /*relatives=*/ {
56         &__nvoc_rtti_SwIntr_SwIntr,
57         &__nvoc_rtti_SwIntr_IntrService,
58         &__nvoc_rtti_SwIntr_OBJENGSTATE,
59         &__nvoc_rtti_SwIntr_Object,
60     },
61 };
62 
63 const struct NVOC_CLASS_DEF __nvoc_class_def_SwIntr =
64 {
65     /*classInfo=*/ {
66         /*size=*/               sizeof(SwIntr),
67         /*classId=*/            classId(SwIntr),
68         /*providerId=*/         &__nvoc_rtti_provider,
69 #if NV_PRINTF_STRINGS_ALLOWED
70         /*name=*/               "SwIntr",
71 #endif
72     },
73     /*objCreatefn=*/        (NVOC_DYNAMIC_OBJ_CREATE) &__nvoc_objCreateDynamic_SwIntr,
74     /*pCastInfo=*/          &__nvoc_castinfo_SwIntr,
75     /*pExportInfo=*/        &__nvoc_export_info_SwIntr
76 };
77 
78 static void __nvoc_thunk_SwIntr_intrservRegisterIntrService(OBJGPU *pGpu, struct IntrService *pSwIntr, IntrServiceRecord pRecords[166]) {
79     swintrRegisterIntrService(pGpu, (struct SwIntr *)(((unsigned char *)pSwIntr) - __nvoc_rtti_SwIntr_IntrService.offset), pRecords);
80 }
81 
82 static NvU32 __nvoc_thunk_SwIntr_intrservServiceInterrupt(OBJGPU *pGpu, struct IntrService *pSwIntr, IntrServiceServiceInterruptArguments *pParams) {
83     return swintrServiceInterrupt(pGpu, (struct SwIntr *)(((unsigned char *)pSwIntr) - __nvoc_rtti_SwIntr_IntrService.offset), pParams);
84 }
85 
86 static NV_STATUS __nvoc_thunk_OBJENGSTATE_swintrStateLoad(POBJGPU pGpu, struct SwIntr *pEngstate, NvU32 arg0) {
87     return engstateStateLoad(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_SwIntr_OBJENGSTATE.offset), arg0);
88 }
89 
90 static NV_STATUS __nvoc_thunk_OBJENGSTATE_swintrStateUnload(POBJGPU pGpu, struct SwIntr *pEngstate, NvU32 arg0) {
91     return engstateStateUnload(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_SwIntr_OBJENGSTATE.offset), arg0);
92 }
93 
94 static NV_STATUS __nvoc_thunk_IntrService_swintrServiceNotificationInterrupt(OBJGPU *pGpu, struct SwIntr *pIntrService, IntrServiceServiceNotificationInterruptArguments *pParams) {
95     return intrservServiceNotificationInterrupt(pGpu, (struct IntrService *)(((unsigned char *)pIntrService) + __nvoc_rtti_SwIntr_IntrService.offset), pParams);
96 }
97 
98 static NV_STATUS __nvoc_thunk_OBJENGSTATE_swintrStateInitLocked(POBJGPU pGpu, struct SwIntr *pEngstate) {
99     return engstateStateInitLocked(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_SwIntr_OBJENGSTATE.offset));
100 }
101 
102 static NV_STATUS __nvoc_thunk_OBJENGSTATE_swintrStatePreLoad(POBJGPU pGpu, struct SwIntr *pEngstate, NvU32 arg0) {
103     return engstateStatePreLoad(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_SwIntr_OBJENGSTATE.offset), arg0);
104 }
105 
106 static NV_STATUS __nvoc_thunk_OBJENGSTATE_swintrStatePostUnload(POBJGPU pGpu, struct SwIntr *pEngstate, NvU32 arg0) {
107     return engstateStatePostUnload(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_SwIntr_OBJENGSTATE.offset), arg0);
108 }
109 
110 static void __nvoc_thunk_OBJENGSTATE_swintrStateDestroy(POBJGPU pGpu, struct SwIntr *pEngstate) {
111     engstateStateDestroy(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_SwIntr_OBJENGSTATE.offset));
112 }
113 
114 static NV_STATUS __nvoc_thunk_OBJENGSTATE_swintrStatePreUnload(POBJGPU pGpu, struct SwIntr *pEngstate, NvU32 arg0) {
115     return engstateStatePreUnload(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_SwIntr_OBJENGSTATE.offset), arg0);
116 }
117 
118 static NV_STATUS __nvoc_thunk_OBJENGSTATE_swintrStateInitUnlocked(POBJGPU pGpu, struct SwIntr *pEngstate) {
119     return engstateStateInitUnlocked(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_SwIntr_OBJENGSTATE.offset));
120 }
121 
122 static void __nvoc_thunk_OBJENGSTATE_swintrInitMissing(POBJGPU pGpu, struct SwIntr *pEngstate) {
123     engstateInitMissing(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_SwIntr_OBJENGSTATE.offset));
124 }
125 
126 static NV_STATUS __nvoc_thunk_OBJENGSTATE_swintrStatePreInitLocked(POBJGPU pGpu, struct SwIntr *pEngstate) {
127     return engstateStatePreInitLocked(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_SwIntr_OBJENGSTATE.offset));
128 }
129 
130 static NV_STATUS __nvoc_thunk_OBJENGSTATE_swintrStatePreInitUnlocked(POBJGPU pGpu, struct SwIntr *pEngstate) {
131     return engstateStatePreInitUnlocked(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_SwIntr_OBJENGSTATE.offset));
132 }
133 
134 static NvBool __nvoc_thunk_IntrService_swintrClearInterrupt(OBJGPU *pGpu, struct SwIntr *pIntrService, IntrServiceClearInterruptArguments *pParams) {
135     return intrservClearInterrupt(pGpu, (struct IntrService *)(((unsigned char *)pIntrService) + __nvoc_rtti_SwIntr_IntrService.offset), pParams);
136 }
137 
138 static NV_STATUS __nvoc_thunk_OBJENGSTATE_swintrStatePostLoad(POBJGPU pGpu, struct SwIntr *pEngstate, NvU32 arg0) {
139     return engstateStatePostLoad(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_SwIntr_OBJENGSTATE.offset), arg0);
140 }
141 
142 static NV_STATUS __nvoc_thunk_OBJENGSTATE_swintrConstructEngine(POBJGPU pGpu, struct SwIntr *pEngstate, ENGDESCRIPTOR arg0) {
143     return engstateConstructEngine(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_SwIntr_OBJENGSTATE.offset), arg0);
144 }
145 
146 static NvBool __nvoc_thunk_OBJENGSTATE_swintrIsPresent(POBJGPU pGpu, struct SwIntr *pEngstate) {
147     return engstateIsPresent(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_SwIntr_OBJENGSTATE.offset));
148 }
149 
150 const struct NVOC_EXPORT_INFO __nvoc_export_info_SwIntr =
151 {
152     /*numEntries=*/     0,
153     /*pExportEntries=*/  0
154 };
155 
156 void __nvoc_dtor_OBJENGSTATE(OBJENGSTATE*);
157 void __nvoc_dtor_IntrService(IntrService*);
158 void __nvoc_dtor_SwIntr(SwIntr *pThis) {
159     __nvoc_dtor_OBJENGSTATE(&pThis->__nvoc_base_OBJENGSTATE);
160     __nvoc_dtor_IntrService(&pThis->__nvoc_base_IntrService);
161     PORT_UNREFERENCED_VARIABLE(pThis);
162 }
163 
164 void __nvoc_init_dataField_SwIntr(SwIntr *pThis) {
165     PORT_UNREFERENCED_VARIABLE(pThis);
166 }
167 
168 NV_STATUS __nvoc_ctor_OBJENGSTATE(OBJENGSTATE* );
169 NV_STATUS __nvoc_ctor_IntrService(IntrService* );
170 NV_STATUS __nvoc_ctor_SwIntr(SwIntr *pThis) {
171     NV_STATUS status = NV_OK;
172     status = __nvoc_ctor_OBJENGSTATE(&pThis->__nvoc_base_OBJENGSTATE);
173     if (status != NV_OK) goto __nvoc_ctor_SwIntr_fail_OBJENGSTATE;
174     status = __nvoc_ctor_IntrService(&pThis->__nvoc_base_IntrService);
175     if (status != NV_OK) goto __nvoc_ctor_SwIntr_fail_IntrService;
176     __nvoc_init_dataField_SwIntr(pThis);
177     goto __nvoc_ctor_SwIntr_exit; // Success
178 
179 __nvoc_ctor_SwIntr_fail_IntrService:
180     __nvoc_dtor_OBJENGSTATE(&pThis->__nvoc_base_OBJENGSTATE);
181 __nvoc_ctor_SwIntr_fail_OBJENGSTATE:
182 __nvoc_ctor_SwIntr_exit:
183 
184     return status;
185 }
186 
187 static void __nvoc_init_funcTable_SwIntr_1(SwIntr *pThis) {
188     PORT_UNREFERENCED_VARIABLE(pThis);
189 
190     pThis->__swintrRegisterIntrService__ = &swintrRegisterIntrService_IMPL;
191 
192     pThis->__swintrServiceInterrupt__ = &swintrServiceInterrupt_IMPL;
193 
194     pThis->__nvoc_base_IntrService.__intrservRegisterIntrService__ = &__nvoc_thunk_SwIntr_intrservRegisterIntrService;
195 
196     pThis->__nvoc_base_IntrService.__intrservServiceInterrupt__ = &__nvoc_thunk_SwIntr_intrservServiceInterrupt;
197 
198     pThis->__swintrStateLoad__ = &__nvoc_thunk_OBJENGSTATE_swintrStateLoad;
199 
200     pThis->__swintrStateUnload__ = &__nvoc_thunk_OBJENGSTATE_swintrStateUnload;
201 
202     pThis->__swintrServiceNotificationInterrupt__ = &__nvoc_thunk_IntrService_swintrServiceNotificationInterrupt;
203 
204     pThis->__swintrStateInitLocked__ = &__nvoc_thunk_OBJENGSTATE_swintrStateInitLocked;
205 
206     pThis->__swintrStatePreLoad__ = &__nvoc_thunk_OBJENGSTATE_swintrStatePreLoad;
207 
208     pThis->__swintrStatePostUnload__ = &__nvoc_thunk_OBJENGSTATE_swintrStatePostUnload;
209 
210     pThis->__swintrStateDestroy__ = &__nvoc_thunk_OBJENGSTATE_swintrStateDestroy;
211 
212     pThis->__swintrStatePreUnload__ = &__nvoc_thunk_OBJENGSTATE_swintrStatePreUnload;
213 
214     pThis->__swintrStateInitUnlocked__ = &__nvoc_thunk_OBJENGSTATE_swintrStateInitUnlocked;
215 
216     pThis->__swintrInitMissing__ = &__nvoc_thunk_OBJENGSTATE_swintrInitMissing;
217 
218     pThis->__swintrStatePreInitLocked__ = &__nvoc_thunk_OBJENGSTATE_swintrStatePreInitLocked;
219 
220     pThis->__swintrStatePreInitUnlocked__ = &__nvoc_thunk_OBJENGSTATE_swintrStatePreInitUnlocked;
221 
222     pThis->__swintrClearInterrupt__ = &__nvoc_thunk_IntrService_swintrClearInterrupt;
223 
224     pThis->__swintrStatePostLoad__ = &__nvoc_thunk_OBJENGSTATE_swintrStatePostLoad;
225 
226     pThis->__swintrConstructEngine__ = &__nvoc_thunk_OBJENGSTATE_swintrConstructEngine;
227 
228     pThis->__swintrIsPresent__ = &__nvoc_thunk_OBJENGSTATE_swintrIsPresent;
229 }
230 
231 void __nvoc_init_funcTable_SwIntr(SwIntr *pThis) {
232     __nvoc_init_funcTable_SwIntr_1(pThis);
233 }
234 
235 void __nvoc_init_OBJENGSTATE(OBJENGSTATE*);
236 void __nvoc_init_IntrService(IntrService*);
237 void __nvoc_init_SwIntr(SwIntr *pThis) {
238     pThis->__nvoc_pbase_SwIntr = pThis;
239     pThis->__nvoc_pbase_Object = &pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object;
240     pThis->__nvoc_pbase_OBJENGSTATE = &pThis->__nvoc_base_OBJENGSTATE;
241     pThis->__nvoc_pbase_IntrService = &pThis->__nvoc_base_IntrService;
242     __nvoc_init_OBJENGSTATE(&pThis->__nvoc_base_OBJENGSTATE);
243     __nvoc_init_IntrService(&pThis->__nvoc_base_IntrService);
244     __nvoc_init_funcTable_SwIntr(pThis);
245 }
246 
247 NV_STATUS __nvoc_objCreate_SwIntr(SwIntr **ppThis, Dynamic *pParent, NvU32 createFlags) {
248     NV_STATUS status;
249     Object *pParentObj;
250     SwIntr *pThis;
251 
252     status = __nvoc_handleObjCreateMemAlloc(createFlags, sizeof(SwIntr), (void**)&pThis, (void**)ppThis);
253     if (status != NV_OK)
254         return status;
255 
256     portMemSet(pThis, 0, sizeof(SwIntr));
257 
258     __nvoc_initRtti(staticCast(pThis, Dynamic), &__nvoc_class_def_SwIntr);
259 
260     pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object.createFlags = createFlags;
261 
262     if (pParent != NULL && !(createFlags & NVOC_OBJ_CREATE_FLAGS_PARENT_HALSPEC_ONLY))
263     {
264         pParentObj = dynamicCast(pParent, Object);
265         objAddChild(pParentObj, &pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object);
266     }
267     else
268     {
269         pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object.pParent = NULL;
270     }
271 
272     __nvoc_init_SwIntr(pThis);
273     status = __nvoc_ctor_SwIntr(pThis);
274     if (status != NV_OK) goto __nvoc_objCreate_SwIntr_cleanup;
275 
276     *ppThis = pThis;
277 
278     return NV_OK;
279 
280 __nvoc_objCreate_SwIntr_cleanup:
281     // do not call destructors here since the constructor already called them
282     if (createFlags & NVOC_OBJ_CREATE_FLAGS_IN_PLACE_CONSTRUCT)
283         portMemSet(pThis, 0, sizeof(SwIntr));
284     else
285         portMemFree(pThis);
286 
287     // coverity[leaked_storage:FALSE]
288     return status;
289 }
290 
291 NV_STATUS __nvoc_objCreateDynamic_SwIntr(SwIntr **ppThis, Dynamic *pParent, NvU32 createFlags, va_list args) {
292     NV_STATUS status;
293 
294     status = __nvoc_objCreate_SwIntr(ppThis, pParent, createFlags);
295 
296     return status;
297 }
298 
299