1 #define NVOC_OBJTMR_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_objtmr_nvoc.h"
9 
10 #ifdef DEBUG
11 char __nvoc_class_id_uniqueness_check_0x9ddede = 1;
12 #endif
13 
14 extern const struct NVOC_CLASS_DEF __nvoc_class_def_OBJTMR;
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_OBJTMR(OBJTMR*, RmHalspecOwner* );
23 void __nvoc_init_funcTable_OBJTMR(OBJTMR*, RmHalspecOwner* );
24 NV_STATUS __nvoc_ctor_OBJTMR(OBJTMR*, RmHalspecOwner* );
25 void __nvoc_init_dataField_OBJTMR(OBJTMR*, RmHalspecOwner* );
26 void __nvoc_dtor_OBJTMR(OBJTMR*);
27 extern const struct NVOC_EXPORT_INFO __nvoc_export_info_OBJTMR;
28 
29 static const struct NVOC_RTTI __nvoc_rtti_OBJTMR_OBJTMR = {
30     /*pClassDef=*/          &__nvoc_class_def_OBJTMR,
31     /*dtor=*/               (NVOC_DYNAMIC_DTOR) &__nvoc_dtor_OBJTMR,
32     /*offset=*/             0,
33 };
34 
35 static const struct NVOC_RTTI __nvoc_rtti_OBJTMR_Object = {
36     /*pClassDef=*/          &__nvoc_class_def_Object,
37     /*dtor=*/               &__nvoc_destructFromBase,
38     /*offset=*/             NV_OFFSETOF(OBJTMR, __nvoc_base_OBJENGSTATE.__nvoc_base_Object),
39 };
40 
41 static const struct NVOC_RTTI __nvoc_rtti_OBJTMR_OBJENGSTATE = {
42     /*pClassDef=*/          &__nvoc_class_def_OBJENGSTATE,
43     /*dtor=*/               &__nvoc_destructFromBase,
44     /*offset=*/             NV_OFFSETOF(OBJTMR, __nvoc_base_OBJENGSTATE),
45 };
46 
47 static const struct NVOC_RTTI __nvoc_rtti_OBJTMR_IntrService = {
48     /*pClassDef=*/          &__nvoc_class_def_IntrService,
49     /*dtor=*/               &__nvoc_destructFromBase,
50     /*offset=*/             NV_OFFSETOF(OBJTMR, __nvoc_base_IntrService),
51 };
52 
53 static const struct NVOC_CASTINFO __nvoc_castinfo_OBJTMR = {
54     /*numRelatives=*/       4,
55     /*relatives=*/ {
56         &__nvoc_rtti_OBJTMR_OBJTMR,
57         &__nvoc_rtti_OBJTMR_IntrService,
58         &__nvoc_rtti_OBJTMR_OBJENGSTATE,
59         &__nvoc_rtti_OBJTMR_Object,
60     },
61 };
62 
63 const struct NVOC_CLASS_DEF __nvoc_class_def_OBJTMR =
64 {
65     /*classInfo=*/ {
66         /*size=*/               sizeof(OBJTMR),
67         /*classId=*/            classId(OBJTMR),
68         /*providerId=*/         &__nvoc_rtti_provider,
69 #if NV_PRINTF_STRINGS_ALLOWED
70         /*name=*/               "OBJTMR",
71 #endif
72     },
73     /*objCreatefn=*/        (NVOC_DYNAMIC_OBJ_CREATE) &__nvoc_objCreateDynamic_OBJTMR,
74     /*pCastInfo=*/          &__nvoc_castinfo_OBJTMR,
75     /*pExportInfo=*/        &__nvoc_export_info_OBJTMR
76 };
77 
78 static void __nvoc_thunk_OBJTMR_intrservRegisterIntrService(OBJGPU *pGpu, struct IntrService *pTmr, IntrServiceRecord pRecords[168]) {
79     tmrRegisterIntrService(pGpu, (struct OBJTMR *)(((unsigned char *)pTmr) - __nvoc_rtti_OBJTMR_IntrService.offset), pRecords);
80 }
81 
82 static NvBool __nvoc_thunk_OBJTMR_intrservClearInterrupt(OBJGPU *pGpu, struct IntrService *pTmr, IntrServiceClearInterruptArguments *pParams) {
83     return tmrClearInterrupt(pGpu, (struct OBJTMR *)(((unsigned char *)pTmr) - __nvoc_rtti_OBJTMR_IntrService.offset), pParams);
84 }
85 
86 static NvU32 __nvoc_thunk_OBJTMR_intrservServiceInterrupt(OBJGPU *pGpu, struct IntrService *pTmr, IntrServiceServiceInterruptArguments *pParams) {
87     return tmrServiceInterrupt(pGpu, (struct OBJTMR *)(((unsigned char *)pTmr) - __nvoc_rtti_OBJTMR_IntrService.offset), pParams);
88 }
89 
90 static NV_STATUS __nvoc_thunk_OBJTMR_engstateConstructEngine(OBJGPU *pGpu, struct OBJENGSTATE *pTmr, ENGDESCRIPTOR arg0) {
91     return tmrConstructEngine(pGpu, (struct OBJTMR *)(((unsigned char *)pTmr) - __nvoc_rtti_OBJTMR_OBJENGSTATE.offset), arg0);
92 }
93 
94 static NV_STATUS __nvoc_thunk_OBJTMR_engstateStateInitLocked(OBJGPU *pGpu, struct OBJENGSTATE *pTmr) {
95     return tmrStateInitLocked(pGpu, (struct OBJTMR *)(((unsigned char *)pTmr) - __nvoc_rtti_OBJTMR_OBJENGSTATE.offset));
96 }
97 
98 static NV_STATUS __nvoc_thunk_OBJTMR_engstateStateInitUnlocked(OBJGPU *pGpu, struct OBJENGSTATE *pTmr) {
99     return tmrStateInitUnlocked(pGpu, (struct OBJTMR *)(((unsigned char *)pTmr) - __nvoc_rtti_OBJTMR_OBJENGSTATE.offset));
100 }
101 
102 static NV_STATUS __nvoc_thunk_OBJTMR_engstateStateLoad(OBJGPU *pGpu, struct OBJENGSTATE *pTmr, NvU32 arg0) {
103     return tmrStateLoad(pGpu, (struct OBJTMR *)(((unsigned char *)pTmr) - __nvoc_rtti_OBJTMR_OBJENGSTATE.offset), arg0);
104 }
105 
106 static NV_STATUS __nvoc_thunk_OBJTMR_engstateStateUnload(OBJGPU *pGpu, struct OBJENGSTATE *pTmr, NvU32 arg0) {
107     return tmrStateUnload(pGpu, (struct OBJTMR *)(((unsigned char *)pTmr) - __nvoc_rtti_OBJTMR_OBJENGSTATE.offset), arg0);
108 }
109 
110 static void __nvoc_thunk_OBJTMR_engstateStateDestroy(OBJGPU *pGpu, struct OBJENGSTATE *pTmr) {
111     tmrStateDestroy(pGpu, (struct OBJTMR *)(((unsigned char *)pTmr) - __nvoc_rtti_OBJTMR_OBJENGSTATE.offset));
112 }
113 
114 static NV_STATUS __nvoc_thunk_IntrService_tmrServiceNotificationInterrupt(OBJGPU *pGpu, struct OBJTMR *pIntrService, IntrServiceServiceNotificationInterruptArguments *pParams) {
115     return intrservServiceNotificationInterrupt(pGpu, (struct IntrService *)(((unsigned char *)pIntrService) + __nvoc_rtti_OBJTMR_IntrService.offset), pParams);
116 }
117 
118 static NV_STATUS __nvoc_thunk_OBJENGSTATE_tmrStatePreLoad(POBJGPU pGpu, struct OBJTMR *pEngstate, NvU32 arg0) {
119     return engstateStatePreLoad(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_OBJTMR_OBJENGSTATE.offset), arg0);
120 }
121 
122 static NV_STATUS __nvoc_thunk_OBJENGSTATE_tmrStatePostUnload(POBJGPU pGpu, struct OBJTMR *pEngstate, NvU32 arg0) {
123     return engstateStatePostUnload(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_OBJTMR_OBJENGSTATE.offset), arg0);
124 }
125 
126 static NV_STATUS __nvoc_thunk_OBJENGSTATE_tmrStatePreUnload(POBJGPU pGpu, struct OBJTMR *pEngstate, NvU32 arg0) {
127     return engstateStatePreUnload(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_OBJTMR_OBJENGSTATE.offset), arg0);
128 }
129 
130 static void __nvoc_thunk_OBJENGSTATE_tmrInitMissing(POBJGPU pGpu, struct OBJTMR *pEngstate) {
131     engstateInitMissing(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_OBJTMR_OBJENGSTATE.offset));
132 }
133 
134 static NV_STATUS __nvoc_thunk_OBJENGSTATE_tmrStatePreInitLocked(POBJGPU pGpu, struct OBJTMR *pEngstate) {
135     return engstateStatePreInitLocked(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_OBJTMR_OBJENGSTATE.offset));
136 }
137 
138 static NV_STATUS __nvoc_thunk_OBJENGSTATE_tmrStatePreInitUnlocked(POBJGPU pGpu, struct OBJTMR *pEngstate) {
139     return engstateStatePreInitUnlocked(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_OBJTMR_OBJENGSTATE.offset));
140 }
141 
142 static NV_STATUS __nvoc_thunk_OBJENGSTATE_tmrStatePostLoad(POBJGPU pGpu, struct OBJTMR *pEngstate, NvU32 arg0) {
143     return engstateStatePostLoad(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_OBJTMR_OBJENGSTATE.offset), arg0);
144 }
145 
146 static NvBool __nvoc_thunk_OBJENGSTATE_tmrIsPresent(POBJGPU pGpu, struct OBJTMR *pEngstate) {
147     return engstateIsPresent(pGpu, (struct OBJENGSTATE *)(((unsigned char *)pEngstate) + __nvoc_rtti_OBJTMR_OBJENGSTATE.offset));
148 }
149 
150 const struct NVOC_EXPORT_INFO __nvoc_export_info_OBJTMR =
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_OBJTMR(OBJTMR *pThis) {
159     __nvoc_tmrDestruct(pThis);
160     __nvoc_dtor_OBJENGSTATE(&pThis->__nvoc_base_OBJENGSTATE);
161     __nvoc_dtor_IntrService(&pThis->__nvoc_base_IntrService);
162     PORT_UNREFERENCED_VARIABLE(pThis);
163 }
164 
165 void __nvoc_init_dataField_OBJTMR(OBJTMR *pThis, RmHalspecOwner *pRmhalspecowner) {
166     ChipHal *chipHal = &pRmhalspecowner->chipHal;
167     const unsigned long chipHal_HalVarIdx = (unsigned long)chipHal->__nvoc_HalVarIdx;
168     RmVariantHal *rmVariantHal = &pRmhalspecowner->rmVariantHal;
169     const unsigned long rmVariantHal_HalVarIdx = (unsigned long)rmVariantHal->__nvoc_HalVarIdx;
170     PORT_UNREFERENCED_VARIABLE(pThis);
171     PORT_UNREFERENCED_VARIABLE(pRmhalspecowner);
172     PORT_UNREFERENCED_VARIABLE(chipHal);
173     PORT_UNREFERENCED_VARIABLE(chipHal_HalVarIdx);
174     PORT_UNREFERENCED_VARIABLE(rmVariantHal);
175     PORT_UNREFERENCED_VARIABLE(rmVariantHal_HalVarIdx);
176 
177     // NVOC Property Hal field -- PDB_PROP_TMR_USE_COUNTDOWN_TIMER_FOR_RM_CALLBACKS
178     if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x11f0ffe0UL) )) /* ChipHal: TU102 | TU104 | TU106 | TU116 | TU117 | GA100 | GA102 | GA103 | GA104 | GA106 | GA107 | AD102 | AD103 | AD104 | AD106 | AD107 | GH100 */
179     {
180         pThis->setProperty(pThis, PDB_PROP_TMR_USE_COUNTDOWN_TIMER_FOR_RM_CALLBACKS, ((NvBool)(0 == 0)));
181     }
182 
183     // NVOC Property Hal field -- PDB_PROP_TMR_ALARM_INTR_REMOVED_FROM_PMC_TREE
184     if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x11f0fc00UL) )) /* ChipHal: GA100 | GA102 | GA103 | GA104 | GA106 | GA107 | AD102 | AD103 | AD104 | AD106 | AD107 | GH100 */
185     {
186         pThis->setProperty(pThis, PDB_PROP_TMR_ALARM_INTR_REMOVED_FROM_PMC_TREE, ((NvBool)(0 == 0)));
187     }
188     // default
189     else
190     {
191         pThis->setProperty(pThis, PDB_PROP_TMR_ALARM_INTR_REMOVED_FROM_PMC_TREE, ((NvBool)(0 != 0)));
192     }
193 
194     // NVOC Property Hal field -- PDB_PROP_TMR_USE_OS_TIMER_FOR_CALLBACKS
195     if (( ((rmVariantHal_HalVarIdx >> 5) == 0UL) && ((1UL << (rmVariantHal_HalVarIdx & 0x1f)) & 0x00000002UL) )) /* RmVariantHal: PF_KERNEL_ONLY */
196     {
197         pThis->setProperty(pThis, PDB_PROP_TMR_USE_OS_TIMER_FOR_CALLBACKS, ((NvBool)(0 == 0)));
198     }
199     pThis->setProperty(pThis, PDB_PROP_TMR_USE_PTIMER_FOR_OSTIMER_CALLBACKS, (0));
200     pThis->setProperty(pThis, PDB_PROP_TMR_USE_POLLING_FOR_CALLBACKS, (0));
201 
202     // NVOC Property Hal field -- PDB_PROP_TMR_USE_SECOND_COUNTDOWN_TIMER_FOR_SWRL
203     if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x10000000UL) )) /* ChipHal: GH100 */
204     {
205         pThis->setProperty(pThis, PDB_PROP_TMR_USE_SECOND_COUNTDOWN_TIMER_FOR_SWRL, ((NvBool)(0 == 0)));
206     }
207     // default
208     else
209     {
210         pThis->setProperty(pThis, PDB_PROP_TMR_USE_SECOND_COUNTDOWN_TIMER_FOR_SWRL, ((NvBool)(0 != 0)));
211     }
212 }
213 
214 NV_STATUS __nvoc_ctor_OBJENGSTATE(OBJENGSTATE* );
215 NV_STATUS __nvoc_ctor_IntrService(IntrService* );
216 NV_STATUS __nvoc_ctor_OBJTMR(OBJTMR *pThis, RmHalspecOwner *pRmhalspecowner) {
217     NV_STATUS status = NV_OK;
218     status = __nvoc_ctor_OBJENGSTATE(&pThis->__nvoc_base_OBJENGSTATE);
219     if (status != NV_OK) goto __nvoc_ctor_OBJTMR_fail_OBJENGSTATE;
220     status = __nvoc_ctor_IntrService(&pThis->__nvoc_base_IntrService);
221     if (status != NV_OK) goto __nvoc_ctor_OBJTMR_fail_IntrService;
222     __nvoc_init_dataField_OBJTMR(pThis, pRmhalspecowner);
223     goto __nvoc_ctor_OBJTMR_exit; // Success
224 
225 __nvoc_ctor_OBJTMR_fail_IntrService:
226     __nvoc_dtor_OBJENGSTATE(&pThis->__nvoc_base_OBJENGSTATE);
227 __nvoc_ctor_OBJTMR_fail_OBJENGSTATE:
228 __nvoc_ctor_OBJTMR_exit:
229 
230     return status;
231 }
232 
233 static void __nvoc_init_funcTable_OBJTMR_1(OBJTMR *pThis, RmHalspecOwner *pRmhalspecowner) {
234     ChipHal *chipHal = &pRmhalspecowner->chipHal;
235     const unsigned long chipHal_HalVarIdx = (unsigned long)chipHal->__nvoc_HalVarIdx;
236     RmVariantHal *rmVariantHal = &pRmhalspecowner->rmVariantHal;
237     const unsigned long rmVariantHal_HalVarIdx = (unsigned long)rmVariantHal->__nvoc_HalVarIdx;
238     PORT_UNREFERENCED_VARIABLE(pThis);
239     PORT_UNREFERENCED_VARIABLE(pRmhalspecowner);
240     PORT_UNREFERENCED_VARIABLE(chipHal);
241     PORT_UNREFERENCED_VARIABLE(chipHal_HalVarIdx);
242     PORT_UNREFERENCED_VARIABLE(rmVariantHal);
243     PORT_UNREFERENCED_VARIABLE(rmVariantHal_HalVarIdx);
244 
245     pThis->__tmrRegisterIntrService__ = &tmrRegisterIntrService_IMPL;
246 
247     pThis->__tmrClearInterrupt__ = &tmrClearInterrupt_IMPL;
248 
249     // Hal function -- tmrServiceInterrupt
250     pThis->__tmrServiceInterrupt__ = &tmrServiceInterrupt_56cd7a;
251 
252     pThis->__tmrConstructEngine__ = &tmrConstructEngine_IMPL;
253 
254     pThis->__tmrStateInitLocked__ = &tmrStateInitLocked_IMPL;
255 
256     pThis->__tmrStateInitUnlocked__ = &tmrStateInitUnlocked_IMPL;
257 
258     pThis->__tmrStateLoad__ = &tmrStateLoad_IMPL;
259 
260     pThis->__tmrStateUnload__ = &tmrStateUnload_IMPL;
261 
262     pThis->__tmrStateDestroy__ = &tmrStateDestroy_IMPL;
263 
264     // Hal function -- tmrSetCurrentTime
265     if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x10000000UL) )) /* ChipHal: GH100 */
266     {
267         pThis->__tmrSetCurrentTime__ = &tmrSetCurrentTime_GH100;
268     }
269     else
270     {
271         pThis->__tmrSetCurrentTime__ = &tmrSetCurrentTime_GV100;
272     }
273 
274     // Hal function -- tmrGetTimeEx
275     if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x10000000UL) )) /* ChipHal: GH100 */
276     {
277         pThis->__tmrGetTimeEx__ = &tmrGetTimeEx_GH100;
278     }
279     else
280     {
281         pThis->__tmrGetTimeEx__ = &tmrGetTimeEx_GM107;
282     }
283 
284     // Hal function -- tmrSetCountdownIntrDisable
285     if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x10000000UL) )) /* ChipHal: GH100 */
286     {
287         pThis->__tmrSetCountdownIntrDisable__ = &tmrSetCountdownIntrDisable_56cd7a;
288     }
289     else
290     {
291         pThis->__tmrSetCountdownIntrDisable__ = &tmrSetCountdownIntrDisable_GM200;
292     }
293 
294     // Hal function -- tmrSetCountdown
295     if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x10000000UL) )) /* ChipHal: GH100 */
296     {
297         pThis->__tmrSetCountdown__ = &tmrSetCountdown_GH100;
298     }
299     else
300     {
301         pThis->__tmrSetCountdown__ = &tmrSetCountdown_TU102;
302     }
303 
304     // Hal function -- tmrGrTickFreqChange
305     if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x10000000UL) )) /* ChipHal: GH100 */
306     {
307         pThis->__tmrGrTickFreqChange__ = &tmrGrTickFreqChange_46f6a7;
308     }
309     else
310     {
311         pThis->__tmrGrTickFreqChange__ = &tmrGrTickFreqChange_GM107;
312     }
313 
314     // Hal function -- tmrGetGpuPtimerOffset
315     if (( ((chipHal_HalVarIdx >> 5) == 1UL) && ((1UL << (chipHal_HalVarIdx & 0x1f)) & 0x000003e0UL) )) /* ChipHal: TU102 | TU104 | TU106 | TU116 | TU117 */
316     {
317         pThis->__tmrGetGpuPtimerOffset__ = &tmrGetGpuPtimerOffset_TU102;
318     }
319     else
320     {
321         pThis->__tmrGetGpuPtimerOffset__ = &tmrGetGpuPtimerOffset_GA100;
322     }
323 
324     pThis->__nvoc_base_IntrService.__intrservRegisterIntrService__ = &__nvoc_thunk_OBJTMR_intrservRegisterIntrService;
325 
326     pThis->__nvoc_base_IntrService.__intrservClearInterrupt__ = &__nvoc_thunk_OBJTMR_intrservClearInterrupt;
327 
328     pThis->__nvoc_base_IntrService.__intrservServiceInterrupt__ = &__nvoc_thunk_OBJTMR_intrservServiceInterrupt;
329 
330     pThis->__nvoc_base_OBJENGSTATE.__engstateConstructEngine__ = &__nvoc_thunk_OBJTMR_engstateConstructEngine;
331 
332     pThis->__nvoc_base_OBJENGSTATE.__engstateStateInitLocked__ = &__nvoc_thunk_OBJTMR_engstateStateInitLocked;
333 
334     pThis->__nvoc_base_OBJENGSTATE.__engstateStateInitUnlocked__ = &__nvoc_thunk_OBJTMR_engstateStateInitUnlocked;
335 
336     pThis->__nvoc_base_OBJENGSTATE.__engstateStateLoad__ = &__nvoc_thunk_OBJTMR_engstateStateLoad;
337 
338     pThis->__nvoc_base_OBJENGSTATE.__engstateStateUnload__ = &__nvoc_thunk_OBJTMR_engstateStateUnload;
339 
340     pThis->__nvoc_base_OBJENGSTATE.__engstateStateDestroy__ = &__nvoc_thunk_OBJTMR_engstateStateDestroy;
341 
342     pThis->__tmrServiceNotificationInterrupt__ = &__nvoc_thunk_IntrService_tmrServiceNotificationInterrupt;
343 
344     pThis->__tmrStatePreLoad__ = &__nvoc_thunk_OBJENGSTATE_tmrStatePreLoad;
345 
346     pThis->__tmrStatePostUnload__ = &__nvoc_thunk_OBJENGSTATE_tmrStatePostUnload;
347 
348     pThis->__tmrStatePreUnload__ = &__nvoc_thunk_OBJENGSTATE_tmrStatePreUnload;
349 
350     pThis->__tmrInitMissing__ = &__nvoc_thunk_OBJENGSTATE_tmrInitMissing;
351 
352     pThis->__tmrStatePreInitLocked__ = &__nvoc_thunk_OBJENGSTATE_tmrStatePreInitLocked;
353 
354     pThis->__tmrStatePreInitUnlocked__ = &__nvoc_thunk_OBJENGSTATE_tmrStatePreInitUnlocked;
355 
356     pThis->__tmrStatePostLoad__ = &__nvoc_thunk_OBJENGSTATE_tmrStatePostLoad;
357 
358     pThis->__tmrIsPresent__ = &__nvoc_thunk_OBJENGSTATE_tmrIsPresent;
359 }
360 
361 void __nvoc_init_funcTable_OBJTMR(OBJTMR *pThis, RmHalspecOwner *pRmhalspecowner) {
362     __nvoc_init_funcTable_OBJTMR_1(pThis, pRmhalspecowner);
363 }
364 
365 void __nvoc_init_OBJENGSTATE(OBJENGSTATE*);
366 void __nvoc_init_IntrService(IntrService*);
367 void __nvoc_init_OBJTMR(OBJTMR *pThis, RmHalspecOwner *pRmhalspecowner) {
368     pThis->__nvoc_pbase_OBJTMR = pThis;
369     pThis->__nvoc_pbase_Object = &pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object;
370     pThis->__nvoc_pbase_OBJENGSTATE = &pThis->__nvoc_base_OBJENGSTATE;
371     pThis->__nvoc_pbase_IntrService = &pThis->__nvoc_base_IntrService;
372     __nvoc_init_OBJENGSTATE(&pThis->__nvoc_base_OBJENGSTATE);
373     __nvoc_init_IntrService(&pThis->__nvoc_base_IntrService);
374     __nvoc_init_funcTable_OBJTMR(pThis, pRmhalspecowner);
375 }
376 
377 NV_STATUS __nvoc_objCreate_OBJTMR(OBJTMR **ppThis, Dynamic *pParent, NvU32 createFlags) {
378     NV_STATUS status;
379     Object *pParentObj;
380     OBJTMR *pThis;
381     RmHalspecOwner *pRmhalspecowner;
382 
383     status = __nvoc_handleObjCreateMemAlloc(createFlags, sizeof(OBJTMR), (void**)&pThis, (void**)ppThis);
384     if (status != NV_OK)
385         return status;
386 
387     portMemSet(pThis, 0, sizeof(OBJTMR));
388 
389     __nvoc_initRtti(staticCast(pThis, Dynamic), &__nvoc_class_def_OBJTMR);
390 
391     pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object.createFlags = createFlags;
392 
393     if (pParent != NULL && !(createFlags & NVOC_OBJ_CREATE_FLAGS_PARENT_HALSPEC_ONLY))
394     {
395         pParentObj = dynamicCast(pParent, Object);
396         objAddChild(pParentObj, &pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object);
397     }
398     else
399     {
400         pThis->__nvoc_base_OBJENGSTATE.__nvoc_base_Object.pParent = NULL;
401     }
402 
403     if ((pRmhalspecowner = dynamicCast(pParent, RmHalspecOwner)) == NULL)
404         pRmhalspecowner = objFindAncestorOfType(RmHalspecOwner, pParent);
405     NV_ASSERT_OR_RETURN(pRmhalspecowner != NULL, NV_ERR_INVALID_ARGUMENT);
406 
407     __nvoc_init_OBJTMR(pThis, pRmhalspecowner);
408     status = __nvoc_ctor_OBJTMR(pThis, pRmhalspecowner);
409     if (status != NV_OK) goto __nvoc_objCreate_OBJTMR_cleanup;
410 
411     *ppThis = pThis;
412 
413     return NV_OK;
414 
415 __nvoc_objCreate_OBJTMR_cleanup:
416     // do not call destructors here since the constructor already called them
417     if (createFlags & NVOC_OBJ_CREATE_FLAGS_IN_PLACE_CONSTRUCT)
418         portMemSet(pThis, 0, sizeof(OBJTMR));
419     else
420         portMemFree(pThis);
421 
422     // coverity[leaked_storage:FALSE]
423     return status;
424 }
425 
426 NV_STATUS __nvoc_objCreateDynamic_OBJTMR(OBJTMR **ppThis, Dynamic *pParent, NvU32 createFlags, va_list args) {
427     NV_STATUS status;
428 
429     status = __nvoc_objCreate_OBJTMR(ppThis, pParent, createFlags);
430 
431     return status;
432 }
433 
434