1 #define NVOC_MPS_API_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_mps_api_nvoc.h"
9 
10 #ifdef DEBUG
11 char __nvoc_class_id_uniqueness_check_0x22ce42 = 1;
12 #endif
13 
14 extern const struct NVOC_CLASS_DEF __nvoc_class_def_MpsApi;
15 
16 extern const struct NVOC_CLASS_DEF __nvoc_class_def_Object;
17 
18 extern const struct NVOC_CLASS_DEF __nvoc_class_def_RsResource;
19 
20 extern const struct NVOC_CLASS_DEF __nvoc_class_def_RmResourceCommon;
21 
22 extern const struct NVOC_CLASS_DEF __nvoc_class_def_RmResource;
23 
24 void __nvoc_init_MpsApi(MpsApi*);
25 void __nvoc_init_funcTable_MpsApi(MpsApi*);
26 NV_STATUS __nvoc_ctor_MpsApi(MpsApi*, CALL_CONTEXT * arg_pCallContext, struct RS_RES_ALLOC_PARAMS_INTERNAL * arg_pParams);
27 void __nvoc_init_dataField_MpsApi(MpsApi*);
28 void __nvoc_dtor_MpsApi(MpsApi*);
29 extern const struct NVOC_EXPORT_INFO __nvoc_export_info_MpsApi;
30 
31 static const struct NVOC_RTTI __nvoc_rtti_MpsApi_MpsApi = {
32     /*pClassDef=*/          &__nvoc_class_def_MpsApi,
33     /*dtor=*/               (NVOC_DYNAMIC_DTOR) &__nvoc_dtor_MpsApi,
34     /*offset=*/             0,
35 };
36 
37 static const struct NVOC_RTTI __nvoc_rtti_MpsApi_Object = {
38     /*pClassDef=*/          &__nvoc_class_def_Object,
39     /*dtor=*/               &__nvoc_destructFromBase,
40     /*offset=*/             NV_OFFSETOF(MpsApi, __nvoc_base_RmResource.__nvoc_base_RsResource.__nvoc_base_Object),
41 };
42 
43 static const struct NVOC_RTTI __nvoc_rtti_MpsApi_RsResource = {
44     /*pClassDef=*/          &__nvoc_class_def_RsResource,
45     /*dtor=*/               &__nvoc_destructFromBase,
46     /*offset=*/             NV_OFFSETOF(MpsApi, __nvoc_base_RmResource.__nvoc_base_RsResource),
47 };
48 
49 static const struct NVOC_RTTI __nvoc_rtti_MpsApi_RmResourceCommon = {
50     /*pClassDef=*/          &__nvoc_class_def_RmResourceCommon,
51     /*dtor=*/               &__nvoc_destructFromBase,
52     /*offset=*/             NV_OFFSETOF(MpsApi, __nvoc_base_RmResource.__nvoc_base_RmResourceCommon),
53 };
54 
55 static const struct NVOC_RTTI __nvoc_rtti_MpsApi_RmResource = {
56     /*pClassDef=*/          &__nvoc_class_def_RmResource,
57     /*dtor=*/               &__nvoc_destructFromBase,
58     /*offset=*/             NV_OFFSETOF(MpsApi, __nvoc_base_RmResource),
59 };
60 
61 static const struct NVOC_CASTINFO __nvoc_castinfo_MpsApi = {
62     /*numRelatives=*/       5,
63     /*relatives=*/ {
64         &__nvoc_rtti_MpsApi_MpsApi,
65         &__nvoc_rtti_MpsApi_RmResource,
66         &__nvoc_rtti_MpsApi_RmResourceCommon,
67         &__nvoc_rtti_MpsApi_RsResource,
68         &__nvoc_rtti_MpsApi_Object,
69     },
70 };
71 
72 const struct NVOC_CLASS_DEF __nvoc_class_def_MpsApi =
73 {
74     /*classInfo=*/ {
75         /*size=*/               sizeof(MpsApi),
76         /*classId=*/            classId(MpsApi),
77         /*providerId=*/         &__nvoc_rtti_provider,
78 #if NV_PRINTF_STRINGS_ALLOWED
79         /*name=*/               "MpsApi",
80 #endif
81     },
82     /*objCreatefn=*/        (NVOC_DYNAMIC_OBJ_CREATE) &__nvoc_objCreateDynamic_MpsApi,
83     /*pCastInfo=*/          &__nvoc_castinfo_MpsApi,
84     /*pExportInfo=*/        &__nvoc_export_info_MpsApi
85 };
86 
87 static NvBool __nvoc_thunk_RmResource_mpsApiShareCallback(struct MpsApi *pResource, struct RsClient *pInvokingClient, struct RsResourceRef *pParentRef, RS_SHARE_POLICY *pSharePolicy) {
88     return rmresShareCallback((struct RmResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RmResource.offset), pInvokingClient, pParentRef, pSharePolicy);
89 }
90 
91 static NV_STATUS __nvoc_thunk_RmResource_mpsApiCheckMemInterUnmap(struct MpsApi *pRmResource, NvBool bSubdeviceHandleProvided) {
92     return rmresCheckMemInterUnmap((struct RmResource *)(((unsigned char *)pRmResource) + __nvoc_rtti_MpsApi_RmResource.offset), bSubdeviceHandleProvided);
93 }
94 
95 static NV_STATUS __nvoc_thunk_RsResource_mpsApiControl(struct MpsApi *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) {
96     return resControl((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RsResource.offset), pCallContext, pParams);
97 }
98 
99 static NV_STATUS __nvoc_thunk_RmResource_mpsApiGetMemInterMapParams(struct MpsApi *pRmResource, RMRES_MEM_INTER_MAP_PARAMS *pParams) {
100     return rmresGetMemInterMapParams((struct RmResource *)(((unsigned char *)pRmResource) + __nvoc_rtti_MpsApi_RmResource.offset), pParams);
101 }
102 
103 static NV_STATUS __nvoc_thunk_RmResource_mpsApiGetMemoryMappingDescriptor(struct MpsApi *pRmResource, struct MEMORY_DESCRIPTOR **ppMemDesc) {
104     return rmresGetMemoryMappingDescriptor((struct RmResource *)(((unsigned char *)pRmResource) + __nvoc_rtti_MpsApi_RmResource.offset), ppMemDesc);
105 }
106 
107 static NvU32 __nvoc_thunk_RsResource_mpsApiGetRefCount(struct MpsApi *pResource) {
108     return resGetRefCount((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RsResource.offset));
109 }
110 
111 static NV_STATUS __nvoc_thunk_RsResource_mpsApiControlFilter(struct MpsApi *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) {
112     return resControlFilter((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RsResource.offset), pCallContext, pParams);
113 }
114 
115 static void __nvoc_thunk_RsResource_mpsApiAddAdditionalDependants(struct RsClient *pClient, struct MpsApi *pResource, RsResourceRef *pReference) {
116     resAddAdditionalDependants(pClient, (struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RsResource.offset), pReference);
117 }
118 
119 static NV_STATUS __nvoc_thunk_RsResource_mpsApiUnmapFrom(struct MpsApi *pResource, RS_RES_UNMAP_FROM_PARAMS *pParams) {
120     return resUnmapFrom((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RsResource.offset), pParams);
121 }
122 
123 static NV_STATUS __nvoc_thunk_RmResource_mpsApiControlSerialization_Prologue(struct MpsApi *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) {
124     return rmresControlSerialization_Prologue((struct RmResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RmResource.offset), pCallContext, pParams);
125 }
126 
127 static NV_STATUS __nvoc_thunk_RmResource_mpsApiControl_Prologue(struct MpsApi *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) {
128     return rmresControl_Prologue((struct RmResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RmResource.offset), pCallContext, pParams);
129 }
130 
131 static NvBool __nvoc_thunk_RsResource_mpsApiCanCopy(struct MpsApi *pResource) {
132     return resCanCopy((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RsResource.offset));
133 }
134 
135 static NV_STATUS __nvoc_thunk_RsResource_mpsApiUnmap(struct MpsApi *pResource, struct CALL_CONTEXT *pCallContext, RsCpuMapping *pCpuMapping) {
136     return resUnmap((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RsResource.offset), pCallContext, pCpuMapping);
137 }
138 
139 static void __nvoc_thunk_RsResource_mpsApiPreDestruct(struct MpsApi *pResource) {
140     resPreDestruct((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RsResource.offset));
141 }
142 
143 static NV_STATUS __nvoc_thunk_RsResource_mpsApiMapTo(struct MpsApi *pResource, RS_RES_MAP_TO_PARAMS *pParams) {
144     return resMapTo((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RsResource.offset), pParams);
145 }
146 
147 static NV_STATUS __nvoc_thunk_RsResource_mpsApiIsDuplicate(struct MpsApi *pResource, NvHandle hMemory, NvBool *pDuplicate) {
148     return resIsDuplicate((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RsResource.offset), hMemory, pDuplicate);
149 }
150 
151 static void __nvoc_thunk_RmResource_mpsApiControlSerialization_Epilogue(struct MpsApi *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) {
152     rmresControlSerialization_Epilogue((struct RmResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RmResource.offset), pCallContext, pParams);
153 }
154 
155 static void __nvoc_thunk_RmResource_mpsApiControl_Epilogue(struct MpsApi *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) {
156     rmresControl_Epilogue((struct RmResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RmResource.offset), pCallContext, pParams);
157 }
158 
159 static NV_STATUS __nvoc_thunk_RsResource_mpsApiControlLookup(struct MpsApi *pResource, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams, const struct NVOC_EXPORTED_METHOD_DEF **ppEntry) {
160     return resControlLookup((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RsResource.offset), pParams, ppEntry);
161 }
162 
163 static NV_STATUS __nvoc_thunk_RsResource_mpsApiMap(struct MpsApi *pResource, struct CALL_CONTEXT *pCallContext, RS_CPU_MAP_PARAMS *pParams, RsCpuMapping *pCpuMapping) {
164     return resMap((struct RsResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RsResource.offset), pCallContext, pParams, pCpuMapping);
165 }
166 
167 static NvBool __nvoc_thunk_RmResource_mpsApiAccessCallback(struct MpsApi *pResource, struct RsClient *pInvokingClient, void *pAllocParams, RsAccessRight accessRight) {
168     return rmresAccessCallback((struct RmResource *)(((unsigned char *)pResource) + __nvoc_rtti_MpsApi_RmResource.offset), pInvokingClient, pAllocParams, accessRight);
169 }
170 
171 const struct NVOC_EXPORT_INFO __nvoc_export_info_MpsApi =
172 {
173     /*numEntries=*/     0,
174     /*pExportEntries=*/  0
175 };
176 
177 void __nvoc_dtor_RmResource(RmResource*);
178 void __nvoc_dtor_MpsApi(MpsApi *pThis) {
179     __nvoc_mpsApiDestruct(pThis);
180     __nvoc_dtor_RmResource(&pThis->__nvoc_base_RmResource);
181     PORT_UNREFERENCED_VARIABLE(pThis);
182 }
183 
184 void __nvoc_init_dataField_MpsApi(MpsApi *pThis) {
185     PORT_UNREFERENCED_VARIABLE(pThis);
186 }
187 
188 NV_STATUS __nvoc_ctor_RmResource(RmResource* , CALL_CONTEXT *, struct RS_RES_ALLOC_PARAMS_INTERNAL *);
189 NV_STATUS __nvoc_ctor_MpsApi(MpsApi *pThis, CALL_CONTEXT * arg_pCallContext, struct RS_RES_ALLOC_PARAMS_INTERNAL * arg_pParams) {
190     NV_STATUS status = NV_OK;
191     status = __nvoc_ctor_RmResource(&pThis->__nvoc_base_RmResource, arg_pCallContext, arg_pParams);
192     if (status != NV_OK) goto __nvoc_ctor_MpsApi_fail_RmResource;
193     __nvoc_init_dataField_MpsApi(pThis);
194 
195     status = __nvoc_mpsApiConstruct(pThis, arg_pCallContext, arg_pParams);
196     if (status != NV_OK) goto __nvoc_ctor_MpsApi_fail__init;
197     goto __nvoc_ctor_MpsApi_exit; // Success
198 
199 __nvoc_ctor_MpsApi_fail__init:
200     __nvoc_dtor_RmResource(&pThis->__nvoc_base_RmResource);
201 __nvoc_ctor_MpsApi_fail_RmResource:
202 __nvoc_ctor_MpsApi_exit:
203 
204     return status;
205 }
206 
207 static void __nvoc_init_funcTable_MpsApi_1(MpsApi *pThis) {
208     PORT_UNREFERENCED_VARIABLE(pThis);
209 
210     pThis->__mpsApiShareCallback__ = &__nvoc_thunk_RmResource_mpsApiShareCallback;
211 
212     pThis->__mpsApiCheckMemInterUnmap__ = &__nvoc_thunk_RmResource_mpsApiCheckMemInterUnmap;
213 
214     pThis->__mpsApiControl__ = &__nvoc_thunk_RsResource_mpsApiControl;
215 
216     pThis->__mpsApiGetMemInterMapParams__ = &__nvoc_thunk_RmResource_mpsApiGetMemInterMapParams;
217 
218     pThis->__mpsApiGetMemoryMappingDescriptor__ = &__nvoc_thunk_RmResource_mpsApiGetMemoryMappingDescriptor;
219 
220     pThis->__mpsApiGetRefCount__ = &__nvoc_thunk_RsResource_mpsApiGetRefCount;
221 
222     pThis->__mpsApiControlFilter__ = &__nvoc_thunk_RsResource_mpsApiControlFilter;
223 
224     pThis->__mpsApiAddAdditionalDependants__ = &__nvoc_thunk_RsResource_mpsApiAddAdditionalDependants;
225 
226     pThis->__mpsApiUnmapFrom__ = &__nvoc_thunk_RsResource_mpsApiUnmapFrom;
227 
228     pThis->__mpsApiControlSerialization_Prologue__ = &__nvoc_thunk_RmResource_mpsApiControlSerialization_Prologue;
229 
230     pThis->__mpsApiControl_Prologue__ = &__nvoc_thunk_RmResource_mpsApiControl_Prologue;
231 
232     pThis->__mpsApiCanCopy__ = &__nvoc_thunk_RsResource_mpsApiCanCopy;
233 
234     pThis->__mpsApiUnmap__ = &__nvoc_thunk_RsResource_mpsApiUnmap;
235 
236     pThis->__mpsApiPreDestruct__ = &__nvoc_thunk_RsResource_mpsApiPreDestruct;
237 
238     pThis->__mpsApiMapTo__ = &__nvoc_thunk_RsResource_mpsApiMapTo;
239 
240     pThis->__mpsApiIsDuplicate__ = &__nvoc_thunk_RsResource_mpsApiIsDuplicate;
241 
242     pThis->__mpsApiControlSerialization_Epilogue__ = &__nvoc_thunk_RmResource_mpsApiControlSerialization_Epilogue;
243 
244     pThis->__mpsApiControl_Epilogue__ = &__nvoc_thunk_RmResource_mpsApiControl_Epilogue;
245 
246     pThis->__mpsApiControlLookup__ = &__nvoc_thunk_RsResource_mpsApiControlLookup;
247 
248     pThis->__mpsApiMap__ = &__nvoc_thunk_RsResource_mpsApiMap;
249 
250     pThis->__mpsApiAccessCallback__ = &__nvoc_thunk_RmResource_mpsApiAccessCallback;
251 }
252 
253 void __nvoc_init_funcTable_MpsApi(MpsApi *pThis) {
254     __nvoc_init_funcTable_MpsApi_1(pThis);
255 }
256 
257 void __nvoc_init_RmResource(RmResource*);
258 void __nvoc_init_MpsApi(MpsApi *pThis) {
259     pThis->__nvoc_pbase_MpsApi = pThis;
260     pThis->__nvoc_pbase_Object = &pThis->__nvoc_base_RmResource.__nvoc_base_RsResource.__nvoc_base_Object;
261     pThis->__nvoc_pbase_RsResource = &pThis->__nvoc_base_RmResource.__nvoc_base_RsResource;
262     pThis->__nvoc_pbase_RmResourceCommon = &pThis->__nvoc_base_RmResource.__nvoc_base_RmResourceCommon;
263     pThis->__nvoc_pbase_RmResource = &pThis->__nvoc_base_RmResource;
264     __nvoc_init_RmResource(&pThis->__nvoc_base_RmResource);
265     __nvoc_init_funcTable_MpsApi(pThis);
266 }
267 
268 NV_STATUS __nvoc_objCreate_MpsApi(MpsApi **ppThis, Dynamic *pParent, NvU32 createFlags, CALL_CONTEXT * arg_pCallContext, struct RS_RES_ALLOC_PARAMS_INTERNAL * arg_pParams) {
269     NV_STATUS status;
270     Object *pParentObj;
271     MpsApi *pThis;
272 
273     status = __nvoc_handleObjCreateMemAlloc(createFlags, sizeof(MpsApi), (void**)&pThis, (void**)ppThis);
274     if (status != NV_OK)
275         return status;
276 
277     portMemSet(pThis, 0, sizeof(MpsApi));
278 
279     __nvoc_initRtti(staticCast(pThis, Dynamic), &__nvoc_class_def_MpsApi);
280 
281     pThis->__nvoc_base_RmResource.__nvoc_base_RsResource.__nvoc_base_Object.createFlags = createFlags;
282 
283     if (pParent != NULL && !(createFlags & NVOC_OBJ_CREATE_FLAGS_PARENT_HALSPEC_ONLY))
284     {
285         pParentObj = dynamicCast(pParent, Object);
286         objAddChild(pParentObj, &pThis->__nvoc_base_RmResource.__nvoc_base_RsResource.__nvoc_base_Object);
287     }
288     else
289     {
290         pThis->__nvoc_base_RmResource.__nvoc_base_RsResource.__nvoc_base_Object.pParent = NULL;
291     }
292 
293     __nvoc_init_MpsApi(pThis);
294     status = __nvoc_ctor_MpsApi(pThis, arg_pCallContext, arg_pParams);
295     if (status != NV_OK) goto __nvoc_objCreate_MpsApi_cleanup;
296 
297     *ppThis = pThis;
298 
299     return NV_OK;
300 
301 __nvoc_objCreate_MpsApi_cleanup:
302     // do not call destructors here since the constructor already called them
303     if (createFlags & NVOC_OBJ_CREATE_FLAGS_IN_PLACE_CONSTRUCT)
304         portMemSet(pThis, 0, sizeof(MpsApi));
305     else
306         portMemFree(pThis);
307 
308     // coverity[leaked_storage:FALSE]
309     return status;
310 }
311 
312 NV_STATUS __nvoc_objCreateDynamic_MpsApi(MpsApi **ppThis, Dynamic *pParent, NvU32 createFlags, va_list args) {
313     NV_STATUS status;
314     CALL_CONTEXT * arg_pCallContext = va_arg(args, CALL_CONTEXT *);
315     struct RS_RES_ALLOC_PARAMS_INTERNAL * arg_pParams = va_arg(args, struct RS_RES_ALLOC_PARAMS_INTERNAL *);
316 
317     status = __nvoc_objCreate_MpsApi(ppThis, pParent, createFlags, arg_pCallContext, arg_pParams);
318 
319     return status;
320 }
321 
322