1 #ifndef _G_DISP_CHANNEL_NVOC_H_ 2 #define _G_DISP_CHANNEL_NVOC_H_ 3 #include "nvoc/runtime.h" 4 5 #ifdef __cplusplus 6 extern "C" { 7 #endif 8 9 /* 10 * SPDX-FileCopyrightText: Copyright (c) 1993-2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 11 * SPDX-License-Identifier: MIT 12 * 13 * Permission is hereby granted, free of charge, to any person obtaining a 14 * copy of this software and associated documentation files (the "Software"), 15 * to deal in the Software without restriction, including without limitation 16 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 17 * and/or sell copies of the Software, and to permit persons to whom the 18 * Software is furnished to do so, subject to the following conditions: 19 * 20 * The above copyright notice and this permission notice shall be included in 21 * all copies or substantial portions of the Software. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 24 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 25 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 26 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 27 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 28 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 29 * DEALINGS IN THE SOFTWARE. 30 */ 31 32 /****************************************************************************** 33 * 34 * Description: 35 * This file contains functions managing DispChannel and its derived classes. 36 * 37 ******************************************************************************/ 38 39 #include "g_disp_channel_nvoc.h" 40 41 #ifndef DISP_CHANNEL_H 42 #define DISP_CHANNEL_H 43 44 #include "gpu/gpu_resource.h" 45 #include "rmapi/event.h" 46 47 struct ContextDma; 48 49 #ifndef __NVOC_CLASS_ContextDma_TYPEDEF__ 50 #define __NVOC_CLASS_ContextDma_TYPEDEF__ 51 typedef struct ContextDma ContextDma; 52 #endif /* __NVOC_CLASS_ContextDma_TYPEDEF__ */ 53 54 #ifndef __nvoc_class_id_ContextDma 55 #define __nvoc_class_id_ContextDma 0x88441b 56 #endif /* __nvoc_class_id_ContextDma */ 57 58 59 struct DispObject; 60 61 #ifndef __NVOC_CLASS_DispObject_TYPEDEF__ 62 #define __NVOC_CLASS_DispObject_TYPEDEF__ 63 typedef struct DispObject DispObject; 64 #endif /* __NVOC_CLASS_DispObject_TYPEDEF__ */ 65 66 #ifndef __nvoc_class_id_DispObject 67 #define __nvoc_class_id_DispObject 0x999839 68 #endif /* __nvoc_class_id_DispObject */ 69 70 71 72 /*! 73 * Base class for display channels 74 */ 75 #ifdef NVOC_DISP_CHANNEL_H_PRIVATE_ACCESS_ALLOWED 76 #define PRIVATE_FIELD(x) x 77 #else 78 #define PRIVATE_FIELD(x) NVOC_PRIVATE_FIELD(x) 79 #endif 80 struct DispChannel { 81 const struct NVOC_RTTI *__nvoc_rtti; 82 struct GpuResource __nvoc_base_GpuResource; 83 struct Notifier __nvoc_base_Notifier; 84 struct Object *__nvoc_pbase_Object; 85 struct RsResource *__nvoc_pbase_RsResource; 86 struct RmResourceCommon *__nvoc_pbase_RmResourceCommon; 87 struct RmResource *__nvoc_pbase_RmResource; 88 struct GpuResource *__nvoc_pbase_GpuResource; 89 struct INotifier *__nvoc_pbase_INotifier; 90 struct Notifier *__nvoc_pbase_Notifier; 91 struct DispChannel *__nvoc_pbase_DispChannel; 92 NV_STATUS (*__dispchnGetRegBaseOffsetAndSize__)(struct DispChannel *, struct OBJGPU *, NvU32 *, NvU32 *); 93 NvBool (*__dispchnShareCallback__)(struct DispChannel *, struct RsClient *, struct RsResourceRef *, RS_SHARE_POLICY *); 94 NV_STATUS (*__dispchnCheckMemInterUnmap__)(struct DispChannel *, NvBool); 95 NV_STATUS (*__dispchnGetOrAllocNotifShare__)(struct DispChannel *, NvHandle, NvHandle, struct NotifShare **); 96 NV_STATUS (*__dispchnMapTo__)(struct DispChannel *, RS_RES_MAP_TO_PARAMS *); 97 NV_STATUS (*__dispchnGetMapAddrSpace__)(struct DispChannel *, struct CALL_CONTEXT *, NvU32, NV_ADDRESS_SPACE *); 98 void (*__dispchnSetNotificationShare__)(struct DispChannel *, struct NotifShare *); 99 NvU32 (*__dispchnGetRefCount__)(struct DispChannel *); 100 void (*__dispchnAddAdditionalDependants__)(struct RsClient *, struct DispChannel *, RsResourceRef *); 101 NV_STATUS (*__dispchnControl_Prologue__)(struct DispChannel *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 102 NV_STATUS (*__dispchnInternalControlForward__)(struct DispChannel *, NvU32, void *, NvU32); 103 NV_STATUS (*__dispchnUnmapFrom__)(struct DispChannel *, RS_RES_UNMAP_FROM_PARAMS *); 104 void (*__dispchnControl_Epilogue__)(struct DispChannel *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 105 NV_STATUS (*__dispchnControlLookup__)(struct DispChannel *, struct RS_RES_CONTROL_PARAMS_INTERNAL *, const struct NVOC_EXPORTED_METHOD_DEF **); 106 NvHandle (*__dispchnGetInternalObjectHandle__)(struct DispChannel *); 107 NV_STATUS (*__dispchnControl__)(struct DispChannel *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 108 NV_STATUS (*__dispchnUnmap__)(struct DispChannel *, struct CALL_CONTEXT *, struct RsCpuMapping *); 109 NV_STATUS (*__dispchnGetMemInterMapParams__)(struct DispChannel *, RMRES_MEM_INTER_MAP_PARAMS *); 110 NV_STATUS (*__dispchnGetMemoryMappingDescriptor__)(struct DispChannel *, struct MEMORY_DESCRIPTOR **); 111 NV_STATUS (*__dispchnControlFilter__)(struct DispChannel *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 112 NV_STATUS (*__dispchnUnregisterEvent__)(struct DispChannel *, NvHandle, NvHandle, NvHandle, NvHandle); 113 NV_STATUS (*__dispchnControlSerialization_Prologue__)(struct DispChannel *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 114 NvBool (*__dispchnCanCopy__)(struct DispChannel *); 115 void (*__dispchnPreDestruct__)(struct DispChannel *); 116 NV_STATUS (*__dispchnIsDuplicate__)(struct DispChannel *, NvHandle, NvBool *); 117 void (*__dispchnControlSerialization_Epilogue__)(struct DispChannel *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 118 PEVENTNOTIFICATION *(*__dispchnGetNotificationListPtr__)(struct DispChannel *); 119 struct NotifShare *(*__dispchnGetNotificationShare__)(struct DispChannel *); 120 NV_STATUS (*__dispchnMap__)(struct DispChannel *, struct CALL_CONTEXT *, struct RS_CPU_MAP_PARAMS *, struct RsCpuMapping *); 121 NvBool (*__dispchnAccessCallback__)(struct DispChannel *, struct RsClient *, void *, RsAccessRight); 122 struct DispObject *pDispObject; 123 NvU32 DispClass; 124 NvU32 InstanceNumber; 125 NvP64 pControl; 126 NvP64 pPriv; 127 NvU32 ControlOffset; 128 NvU32 ControlLength; 129 NvBool bIsDma; 130 }; 131 132 #ifndef __NVOC_CLASS_DispChannel_TYPEDEF__ 133 #define __NVOC_CLASS_DispChannel_TYPEDEF__ 134 typedef struct DispChannel DispChannel; 135 #endif /* __NVOC_CLASS_DispChannel_TYPEDEF__ */ 136 137 #ifndef __nvoc_class_id_DispChannel 138 #define __nvoc_class_id_DispChannel 0xbd2ff3 139 #endif /* __nvoc_class_id_DispChannel */ 140 141 extern const struct NVOC_CLASS_DEF __nvoc_class_def_DispChannel; 142 143 #define __staticCast_DispChannel(pThis) \ 144 ((pThis)->__nvoc_pbase_DispChannel) 145 146 #ifdef __nvoc_disp_channel_h_disabled 147 #define __dynamicCast_DispChannel(pThis) ((DispChannel*)NULL) 148 #else //__nvoc_disp_channel_h_disabled 149 #define __dynamicCast_DispChannel(pThis) \ 150 ((DispChannel*)__nvoc_dynamicCast(staticCast((pThis), Dynamic), classInfo(DispChannel))) 151 #endif //__nvoc_disp_channel_h_disabled 152 153 154 NV_STATUS __nvoc_objCreateDynamic_DispChannel(DispChannel**, Dynamic*, NvU32, va_list); 155 156 NV_STATUS __nvoc_objCreate_DispChannel(DispChannel**, Dynamic*, NvU32, struct CALL_CONTEXT * arg_pCallContext, struct RS_RES_ALLOC_PARAMS_INTERNAL * arg_pParams, NvU32 arg_isDma); 157 #define __objCreate_DispChannel(ppNewObj, pParent, createFlags, arg_pCallContext, arg_pParams, arg_isDma) \ 158 __nvoc_objCreate_DispChannel((ppNewObj), staticCast((pParent), Dynamic), (createFlags), arg_pCallContext, arg_pParams, arg_isDma) 159 160 #define dispchnGetRegBaseOffsetAndSize(pDispChannel, pGpu, pOffset, pSize) dispchnGetRegBaseOffsetAndSize_DISPATCH(pDispChannel, pGpu, pOffset, pSize) 161 #define dispchnShareCallback(pGpuResource, pInvokingClient, pParentRef, pSharePolicy) dispchnShareCallback_DISPATCH(pGpuResource, pInvokingClient, pParentRef, pSharePolicy) 162 #define dispchnCheckMemInterUnmap(pRmResource, bSubdeviceHandleProvided) dispchnCheckMemInterUnmap_DISPATCH(pRmResource, bSubdeviceHandleProvided) 163 #define dispchnGetOrAllocNotifShare(pNotifier, hNotifierClient, hNotifierResource, ppNotifShare) dispchnGetOrAllocNotifShare_DISPATCH(pNotifier, hNotifierClient, hNotifierResource, ppNotifShare) 164 #define dispchnMapTo(pResource, pParams) dispchnMapTo_DISPATCH(pResource, pParams) 165 #define dispchnGetMapAddrSpace(pGpuResource, pCallContext, mapFlags, pAddrSpace) dispchnGetMapAddrSpace_DISPATCH(pGpuResource, pCallContext, mapFlags, pAddrSpace) 166 #define dispchnSetNotificationShare(pNotifier, pNotifShare) dispchnSetNotificationShare_DISPATCH(pNotifier, pNotifShare) 167 #define dispchnGetRefCount(pResource) dispchnGetRefCount_DISPATCH(pResource) 168 #define dispchnAddAdditionalDependants(pClient, pResource, pReference) dispchnAddAdditionalDependants_DISPATCH(pClient, pResource, pReference) 169 #define dispchnControl_Prologue(pResource, pCallContext, pParams) dispchnControl_Prologue_DISPATCH(pResource, pCallContext, pParams) 170 #define dispchnInternalControlForward(pGpuResource, command, pParams, size) dispchnInternalControlForward_DISPATCH(pGpuResource, command, pParams, size) 171 #define dispchnUnmapFrom(pResource, pParams) dispchnUnmapFrom_DISPATCH(pResource, pParams) 172 #define dispchnControl_Epilogue(pResource, pCallContext, pParams) dispchnControl_Epilogue_DISPATCH(pResource, pCallContext, pParams) 173 #define dispchnControlLookup(pResource, pParams, ppEntry) dispchnControlLookup_DISPATCH(pResource, pParams, ppEntry) 174 #define dispchnGetInternalObjectHandle(pGpuResource) dispchnGetInternalObjectHandle_DISPATCH(pGpuResource) 175 #define dispchnControl(pGpuResource, pCallContext, pParams) dispchnControl_DISPATCH(pGpuResource, pCallContext, pParams) 176 #define dispchnUnmap(pGpuResource, pCallContext, pCpuMapping) dispchnUnmap_DISPATCH(pGpuResource, pCallContext, pCpuMapping) 177 #define dispchnGetMemInterMapParams(pRmResource, pParams) dispchnGetMemInterMapParams_DISPATCH(pRmResource, pParams) 178 #define dispchnGetMemoryMappingDescriptor(pRmResource, ppMemDesc) dispchnGetMemoryMappingDescriptor_DISPATCH(pRmResource, ppMemDesc) 179 #define dispchnControlFilter(pResource, pCallContext, pParams) dispchnControlFilter_DISPATCH(pResource, pCallContext, pParams) 180 #define dispchnUnregisterEvent(pNotifier, hNotifierClient, hNotifierResource, hEventClient, hEvent) dispchnUnregisterEvent_DISPATCH(pNotifier, hNotifierClient, hNotifierResource, hEventClient, hEvent) 181 #define dispchnControlSerialization_Prologue(pResource, pCallContext, pParams) dispchnControlSerialization_Prologue_DISPATCH(pResource, pCallContext, pParams) 182 #define dispchnCanCopy(pResource) dispchnCanCopy_DISPATCH(pResource) 183 #define dispchnPreDestruct(pResource) dispchnPreDestruct_DISPATCH(pResource) 184 #define dispchnIsDuplicate(pResource, hMemory, pDuplicate) dispchnIsDuplicate_DISPATCH(pResource, hMemory, pDuplicate) 185 #define dispchnControlSerialization_Epilogue(pResource, pCallContext, pParams) dispchnControlSerialization_Epilogue_DISPATCH(pResource, pCallContext, pParams) 186 #define dispchnGetNotificationListPtr(pNotifier) dispchnGetNotificationListPtr_DISPATCH(pNotifier) 187 #define dispchnGetNotificationShare(pNotifier) dispchnGetNotificationShare_DISPATCH(pNotifier) 188 #define dispchnMap(pGpuResource, pCallContext, pParams, pCpuMapping) dispchnMap_DISPATCH(pGpuResource, pCallContext, pParams, pCpuMapping) 189 #define dispchnAccessCallback(pResource, pInvokingClient, pAllocParams, accessRight) dispchnAccessCallback_DISPATCH(pResource, pInvokingClient, pAllocParams, accessRight) 190 NV_STATUS dispchnGetRegBaseOffsetAndSize_IMPL(struct DispChannel *pDispChannel, struct OBJGPU *pGpu, NvU32 *pOffset, NvU32 *pSize); 191 192 static inline NV_STATUS dispchnGetRegBaseOffsetAndSize_DISPATCH(struct DispChannel *pDispChannel, struct OBJGPU *pGpu, NvU32 *pOffset, NvU32 *pSize) { 193 return pDispChannel->__dispchnGetRegBaseOffsetAndSize__(pDispChannel, pGpu, pOffset, pSize); 194 } 195 196 static inline NvBool dispchnShareCallback_DISPATCH(struct DispChannel *pGpuResource, struct RsClient *pInvokingClient, struct RsResourceRef *pParentRef, RS_SHARE_POLICY *pSharePolicy) { 197 return pGpuResource->__dispchnShareCallback__(pGpuResource, pInvokingClient, pParentRef, pSharePolicy); 198 } 199 200 static inline NV_STATUS dispchnCheckMemInterUnmap_DISPATCH(struct DispChannel *pRmResource, NvBool bSubdeviceHandleProvided) { 201 return pRmResource->__dispchnCheckMemInterUnmap__(pRmResource, bSubdeviceHandleProvided); 202 } 203 204 static inline NV_STATUS dispchnGetOrAllocNotifShare_DISPATCH(struct DispChannel *pNotifier, NvHandle hNotifierClient, NvHandle hNotifierResource, struct NotifShare **ppNotifShare) { 205 return pNotifier->__dispchnGetOrAllocNotifShare__(pNotifier, hNotifierClient, hNotifierResource, ppNotifShare); 206 } 207 208 static inline NV_STATUS dispchnMapTo_DISPATCH(struct DispChannel *pResource, RS_RES_MAP_TO_PARAMS *pParams) { 209 return pResource->__dispchnMapTo__(pResource, pParams); 210 } 211 212 static inline NV_STATUS dispchnGetMapAddrSpace_DISPATCH(struct DispChannel *pGpuResource, struct CALL_CONTEXT *pCallContext, NvU32 mapFlags, NV_ADDRESS_SPACE *pAddrSpace) { 213 return pGpuResource->__dispchnGetMapAddrSpace__(pGpuResource, pCallContext, mapFlags, pAddrSpace); 214 } 215 216 static inline void dispchnSetNotificationShare_DISPATCH(struct DispChannel *pNotifier, struct NotifShare *pNotifShare) { 217 pNotifier->__dispchnSetNotificationShare__(pNotifier, pNotifShare); 218 } 219 220 static inline NvU32 dispchnGetRefCount_DISPATCH(struct DispChannel *pResource) { 221 return pResource->__dispchnGetRefCount__(pResource); 222 } 223 224 static inline void dispchnAddAdditionalDependants_DISPATCH(struct RsClient *pClient, struct DispChannel *pResource, RsResourceRef *pReference) { 225 pResource->__dispchnAddAdditionalDependants__(pClient, pResource, pReference); 226 } 227 228 static inline NV_STATUS dispchnControl_Prologue_DISPATCH(struct DispChannel *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 229 return pResource->__dispchnControl_Prologue__(pResource, pCallContext, pParams); 230 } 231 232 static inline NV_STATUS dispchnInternalControlForward_DISPATCH(struct DispChannel *pGpuResource, NvU32 command, void *pParams, NvU32 size) { 233 return pGpuResource->__dispchnInternalControlForward__(pGpuResource, command, pParams, size); 234 } 235 236 static inline NV_STATUS dispchnUnmapFrom_DISPATCH(struct DispChannel *pResource, RS_RES_UNMAP_FROM_PARAMS *pParams) { 237 return pResource->__dispchnUnmapFrom__(pResource, pParams); 238 } 239 240 static inline void dispchnControl_Epilogue_DISPATCH(struct DispChannel *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 241 pResource->__dispchnControl_Epilogue__(pResource, pCallContext, pParams); 242 } 243 244 static inline NV_STATUS dispchnControlLookup_DISPATCH(struct DispChannel *pResource, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams, const struct NVOC_EXPORTED_METHOD_DEF **ppEntry) { 245 return pResource->__dispchnControlLookup__(pResource, pParams, ppEntry); 246 } 247 248 static inline NvHandle dispchnGetInternalObjectHandle_DISPATCH(struct DispChannel *pGpuResource) { 249 return pGpuResource->__dispchnGetInternalObjectHandle__(pGpuResource); 250 } 251 252 static inline NV_STATUS dispchnControl_DISPATCH(struct DispChannel *pGpuResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 253 return pGpuResource->__dispchnControl__(pGpuResource, pCallContext, pParams); 254 } 255 256 static inline NV_STATUS dispchnUnmap_DISPATCH(struct DispChannel *pGpuResource, struct CALL_CONTEXT *pCallContext, struct RsCpuMapping *pCpuMapping) { 257 return pGpuResource->__dispchnUnmap__(pGpuResource, pCallContext, pCpuMapping); 258 } 259 260 static inline NV_STATUS dispchnGetMemInterMapParams_DISPATCH(struct DispChannel *pRmResource, RMRES_MEM_INTER_MAP_PARAMS *pParams) { 261 return pRmResource->__dispchnGetMemInterMapParams__(pRmResource, pParams); 262 } 263 264 static inline NV_STATUS dispchnGetMemoryMappingDescriptor_DISPATCH(struct DispChannel *pRmResource, struct MEMORY_DESCRIPTOR **ppMemDesc) { 265 return pRmResource->__dispchnGetMemoryMappingDescriptor__(pRmResource, ppMemDesc); 266 } 267 268 static inline NV_STATUS dispchnControlFilter_DISPATCH(struct DispChannel *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 269 return pResource->__dispchnControlFilter__(pResource, pCallContext, pParams); 270 } 271 272 static inline NV_STATUS dispchnUnregisterEvent_DISPATCH(struct DispChannel *pNotifier, NvHandle hNotifierClient, NvHandle hNotifierResource, NvHandle hEventClient, NvHandle hEvent) { 273 return pNotifier->__dispchnUnregisterEvent__(pNotifier, hNotifierClient, hNotifierResource, hEventClient, hEvent); 274 } 275 276 static inline NV_STATUS dispchnControlSerialization_Prologue_DISPATCH(struct DispChannel *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 277 return pResource->__dispchnControlSerialization_Prologue__(pResource, pCallContext, pParams); 278 } 279 280 static inline NvBool dispchnCanCopy_DISPATCH(struct DispChannel *pResource) { 281 return pResource->__dispchnCanCopy__(pResource); 282 } 283 284 static inline void dispchnPreDestruct_DISPATCH(struct DispChannel *pResource) { 285 pResource->__dispchnPreDestruct__(pResource); 286 } 287 288 static inline NV_STATUS dispchnIsDuplicate_DISPATCH(struct DispChannel *pResource, NvHandle hMemory, NvBool *pDuplicate) { 289 return pResource->__dispchnIsDuplicate__(pResource, hMemory, pDuplicate); 290 } 291 292 static inline void dispchnControlSerialization_Epilogue_DISPATCH(struct DispChannel *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 293 pResource->__dispchnControlSerialization_Epilogue__(pResource, pCallContext, pParams); 294 } 295 296 static inline PEVENTNOTIFICATION *dispchnGetNotificationListPtr_DISPATCH(struct DispChannel *pNotifier) { 297 return pNotifier->__dispchnGetNotificationListPtr__(pNotifier); 298 } 299 300 static inline struct NotifShare *dispchnGetNotificationShare_DISPATCH(struct DispChannel *pNotifier) { 301 return pNotifier->__dispchnGetNotificationShare__(pNotifier); 302 } 303 304 static inline NV_STATUS dispchnMap_DISPATCH(struct DispChannel *pGpuResource, struct CALL_CONTEXT *pCallContext, struct RS_CPU_MAP_PARAMS *pParams, struct RsCpuMapping *pCpuMapping) { 305 return pGpuResource->__dispchnMap__(pGpuResource, pCallContext, pParams, pCpuMapping); 306 } 307 308 static inline NvBool dispchnAccessCallback_DISPATCH(struct DispChannel *pResource, struct RsClient *pInvokingClient, void *pAllocParams, RsAccessRight accessRight) { 309 return pResource->__dispchnAccessCallback__(pResource, pInvokingClient, pAllocParams, accessRight); 310 } 311 312 NV_STATUS dispchnConstruct_IMPL(struct DispChannel *arg_pDispChannel, struct CALL_CONTEXT *arg_pCallContext, struct RS_RES_ALLOC_PARAMS_INTERNAL *arg_pParams, NvU32 arg_isDma); 313 314 #define __nvoc_dispchnConstruct(arg_pDispChannel, arg_pCallContext, arg_pParams, arg_isDma) dispchnConstruct_IMPL(arg_pDispChannel, arg_pCallContext, arg_pParams, arg_isDma) 315 void dispchnDestruct_IMPL(struct DispChannel *pDispChannel); 316 317 #define __nvoc_dispchnDestruct(pDispChannel) dispchnDestruct_IMPL(pDispChannel) 318 void dispchnSetRegBaseOffsetAndSize_IMPL(struct DispChannel *pDispChannel, struct OBJGPU *pGpu); 319 320 #ifdef __nvoc_disp_channel_h_disabled 321 static inline void dispchnSetRegBaseOffsetAndSize(struct DispChannel *pDispChannel, struct OBJGPU *pGpu) { 322 NV_ASSERT_FAILED_PRECOMP("DispChannel was disabled!"); 323 } 324 #else //__nvoc_disp_channel_h_disabled 325 #define dispchnSetRegBaseOffsetAndSize(pDispChannel, pGpu) dispchnSetRegBaseOffsetAndSize_IMPL(pDispChannel, pGpu) 326 #endif //__nvoc_disp_channel_h_disabled 327 328 NV_STATUS dispchnGrabChannel_IMPL(struct DispChannel *pDispChannel, NvHandle hClient, NvHandle hParent, NvHandle hChannel, NvU32 hClass, void *pAllocParms); 329 330 #ifdef __nvoc_disp_channel_h_disabled 331 static inline NV_STATUS dispchnGrabChannel(struct DispChannel *pDispChannel, NvHandle hClient, NvHandle hParent, NvHandle hChannel, NvU32 hClass, void *pAllocParms) { 332 NV_ASSERT_FAILED_PRECOMP("DispChannel was disabled!"); 333 return NV_ERR_NOT_SUPPORTED; 334 } 335 #else //__nvoc_disp_channel_h_disabled 336 #define dispchnGrabChannel(pDispChannel, hClient, hParent, hChannel, hClass, pAllocParms) dispchnGrabChannel_IMPL(pDispChannel, hClient, hParent, hChannel, hClass, pAllocParms) 337 #endif //__nvoc_disp_channel_h_disabled 338 339 NV_STATUS dispchnBindCtx_IMPL(struct OBJGPU *pGpu, struct ContextDma *pContextDma, NvHandle hDispChannel); 340 341 #define dispchnBindCtx(pGpu, pContextDma, hDispChannel) dispchnBindCtx_IMPL(pGpu, pContextDma, hDispChannel) 342 NV_STATUS dispchnUnbindCtx_IMPL(struct OBJGPU *pGpu, struct ContextDma *pContextDma, NvHandle hDispChannel); 343 344 #define dispchnUnbindCtx(pGpu, pContextDma, hDispChannel) dispchnUnbindCtx_IMPL(pGpu, pContextDma, hDispChannel) 345 void dispchnUnbindCtxFromAllChannels_IMPL(struct OBJGPU *pGpu, struct ContextDma *pContextDma); 346 347 #define dispchnUnbindCtxFromAllChannels(pGpu, pContextDma) dispchnUnbindCtxFromAllChannels_IMPL(pGpu, pContextDma) 348 void dispchnUnbindAllCtx_IMPL(struct OBJGPU *pGpu, struct DispChannel *pDispChannel); 349 350 #ifdef __nvoc_disp_channel_h_disabled 351 static inline void dispchnUnbindAllCtx(struct OBJGPU *pGpu, struct DispChannel *pDispChannel) { 352 NV_ASSERT_FAILED_PRECOMP("DispChannel was disabled!"); 353 } 354 #else //__nvoc_disp_channel_h_disabled 355 #define dispchnUnbindAllCtx(pGpu, pDispChannel) dispchnUnbindAllCtx_IMPL(pGpu, pDispChannel) 356 #endif //__nvoc_disp_channel_h_disabled 357 358 NV_STATUS dispchnGetByHandle_IMPL(struct RsClient *pClient, NvHandle hDisplayChannel, struct DispChannel **ppDispChannel); 359 360 #define dispchnGetByHandle(pClient, hDisplayChannel, ppDispChannel) dispchnGetByHandle_IMPL(pClient, hDisplayChannel, ppDispChannel) 361 #undef PRIVATE_FIELD 362 363 364 /*! 365 * RM internal class representing XXX_XXX_CHANNEL_PIO 366 */ 367 #ifdef NVOC_DISP_CHANNEL_H_PRIVATE_ACCESS_ALLOWED 368 #define PRIVATE_FIELD(x) x 369 #else 370 #define PRIVATE_FIELD(x) NVOC_PRIVATE_FIELD(x) 371 #endif 372 struct DispChannelPio { 373 const struct NVOC_RTTI *__nvoc_rtti; 374 struct DispChannel __nvoc_base_DispChannel; 375 struct Object *__nvoc_pbase_Object; 376 struct RsResource *__nvoc_pbase_RsResource; 377 struct RmResourceCommon *__nvoc_pbase_RmResourceCommon; 378 struct RmResource *__nvoc_pbase_RmResource; 379 struct GpuResource *__nvoc_pbase_GpuResource; 380 struct INotifier *__nvoc_pbase_INotifier; 381 struct Notifier *__nvoc_pbase_Notifier; 382 struct DispChannel *__nvoc_pbase_DispChannel; 383 struct DispChannelPio *__nvoc_pbase_DispChannelPio; 384 NvBool (*__dispchnpioShareCallback__)(struct DispChannelPio *, struct RsClient *, struct RsResourceRef *, RS_SHARE_POLICY *); 385 NV_STATUS (*__dispchnpioCheckMemInterUnmap__)(struct DispChannelPio *, NvBool); 386 NV_STATUS (*__dispchnpioGetOrAllocNotifShare__)(struct DispChannelPio *, NvHandle, NvHandle, struct NotifShare **); 387 NV_STATUS (*__dispchnpioMapTo__)(struct DispChannelPio *, RS_RES_MAP_TO_PARAMS *); 388 NV_STATUS (*__dispchnpioGetMapAddrSpace__)(struct DispChannelPio *, struct CALL_CONTEXT *, NvU32, NV_ADDRESS_SPACE *); 389 void (*__dispchnpioSetNotificationShare__)(struct DispChannelPio *, struct NotifShare *); 390 NvU32 (*__dispchnpioGetRefCount__)(struct DispChannelPio *); 391 void (*__dispchnpioAddAdditionalDependants__)(struct RsClient *, struct DispChannelPio *, RsResourceRef *); 392 NV_STATUS (*__dispchnpioControl_Prologue__)(struct DispChannelPio *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 393 NV_STATUS (*__dispchnpioGetRegBaseOffsetAndSize__)(struct DispChannelPio *, struct OBJGPU *, NvU32 *, NvU32 *); 394 NV_STATUS (*__dispchnpioInternalControlForward__)(struct DispChannelPio *, NvU32, void *, NvU32); 395 NV_STATUS (*__dispchnpioUnmapFrom__)(struct DispChannelPio *, RS_RES_UNMAP_FROM_PARAMS *); 396 void (*__dispchnpioControl_Epilogue__)(struct DispChannelPio *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 397 NV_STATUS (*__dispchnpioControlLookup__)(struct DispChannelPio *, struct RS_RES_CONTROL_PARAMS_INTERNAL *, const struct NVOC_EXPORTED_METHOD_DEF **); 398 NvHandle (*__dispchnpioGetInternalObjectHandle__)(struct DispChannelPio *); 399 NV_STATUS (*__dispchnpioControl__)(struct DispChannelPio *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 400 NV_STATUS (*__dispchnpioUnmap__)(struct DispChannelPio *, struct CALL_CONTEXT *, struct RsCpuMapping *); 401 NV_STATUS (*__dispchnpioGetMemInterMapParams__)(struct DispChannelPio *, RMRES_MEM_INTER_MAP_PARAMS *); 402 NV_STATUS (*__dispchnpioGetMemoryMappingDescriptor__)(struct DispChannelPio *, struct MEMORY_DESCRIPTOR **); 403 NV_STATUS (*__dispchnpioControlFilter__)(struct DispChannelPio *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 404 NV_STATUS (*__dispchnpioUnregisterEvent__)(struct DispChannelPio *, NvHandle, NvHandle, NvHandle, NvHandle); 405 NV_STATUS (*__dispchnpioControlSerialization_Prologue__)(struct DispChannelPio *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 406 NvBool (*__dispchnpioCanCopy__)(struct DispChannelPio *); 407 void (*__dispchnpioPreDestruct__)(struct DispChannelPio *); 408 NV_STATUS (*__dispchnpioIsDuplicate__)(struct DispChannelPio *, NvHandle, NvBool *); 409 void (*__dispchnpioControlSerialization_Epilogue__)(struct DispChannelPio *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 410 PEVENTNOTIFICATION *(*__dispchnpioGetNotificationListPtr__)(struct DispChannelPio *); 411 struct NotifShare *(*__dispchnpioGetNotificationShare__)(struct DispChannelPio *); 412 NV_STATUS (*__dispchnpioMap__)(struct DispChannelPio *, struct CALL_CONTEXT *, struct RS_CPU_MAP_PARAMS *, struct RsCpuMapping *); 413 NvBool (*__dispchnpioAccessCallback__)(struct DispChannelPio *, struct RsClient *, void *, RsAccessRight); 414 }; 415 416 #ifndef __NVOC_CLASS_DispChannelPio_TYPEDEF__ 417 #define __NVOC_CLASS_DispChannelPio_TYPEDEF__ 418 typedef struct DispChannelPio DispChannelPio; 419 #endif /* __NVOC_CLASS_DispChannelPio_TYPEDEF__ */ 420 421 #ifndef __nvoc_class_id_DispChannelPio 422 #define __nvoc_class_id_DispChannelPio 0x10dec3 423 #endif /* __nvoc_class_id_DispChannelPio */ 424 425 extern const struct NVOC_CLASS_DEF __nvoc_class_def_DispChannelPio; 426 427 #define __staticCast_DispChannelPio(pThis) \ 428 ((pThis)->__nvoc_pbase_DispChannelPio) 429 430 #ifdef __nvoc_disp_channel_h_disabled 431 #define __dynamicCast_DispChannelPio(pThis) ((DispChannelPio*)NULL) 432 #else //__nvoc_disp_channel_h_disabled 433 #define __dynamicCast_DispChannelPio(pThis) \ 434 ((DispChannelPio*)__nvoc_dynamicCast(staticCast((pThis), Dynamic), classInfo(DispChannelPio))) 435 #endif //__nvoc_disp_channel_h_disabled 436 437 438 NV_STATUS __nvoc_objCreateDynamic_DispChannelPio(DispChannelPio**, Dynamic*, NvU32, va_list); 439 440 NV_STATUS __nvoc_objCreate_DispChannelPio(DispChannelPio**, Dynamic*, NvU32, struct CALL_CONTEXT * arg_pCallContext, struct RS_RES_ALLOC_PARAMS_INTERNAL * arg_pParams); 441 #define __objCreate_DispChannelPio(ppNewObj, pParent, createFlags, arg_pCallContext, arg_pParams) \ 442 __nvoc_objCreate_DispChannelPio((ppNewObj), staticCast((pParent), Dynamic), (createFlags), arg_pCallContext, arg_pParams) 443 444 #define dispchnpioShareCallback(pGpuResource, pInvokingClient, pParentRef, pSharePolicy) dispchnpioShareCallback_DISPATCH(pGpuResource, pInvokingClient, pParentRef, pSharePolicy) 445 #define dispchnpioCheckMemInterUnmap(pRmResource, bSubdeviceHandleProvided) dispchnpioCheckMemInterUnmap_DISPATCH(pRmResource, bSubdeviceHandleProvided) 446 #define dispchnpioGetOrAllocNotifShare(pNotifier, hNotifierClient, hNotifierResource, ppNotifShare) dispchnpioGetOrAllocNotifShare_DISPATCH(pNotifier, hNotifierClient, hNotifierResource, ppNotifShare) 447 #define dispchnpioMapTo(pResource, pParams) dispchnpioMapTo_DISPATCH(pResource, pParams) 448 #define dispchnpioGetMapAddrSpace(pGpuResource, pCallContext, mapFlags, pAddrSpace) dispchnpioGetMapAddrSpace_DISPATCH(pGpuResource, pCallContext, mapFlags, pAddrSpace) 449 #define dispchnpioSetNotificationShare(pNotifier, pNotifShare) dispchnpioSetNotificationShare_DISPATCH(pNotifier, pNotifShare) 450 #define dispchnpioGetRefCount(pResource) dispchnpioGetRefCount_DISPATCH(pResource) 451 #define dispchnpioAddAdditionalDependants(pClient, pResource, pReference) dispchnpioAddAdditionalDependants_DISPATCH(pClient, pResource, pReference) 452 #define dispchnpioControl_Prologue(pResource, pCallContext, pParams) dispchnpioControl_Prologue_DISPATCH(pResource, pCallContext, pParams) 453 #define dispchnpioGetRegBaseOffsetAndSize(pDispChannel, pGpu, pOffset, pSize) dispchnpioGetRegBaseOffsetAndSize_DISPATCH(pDispChannel, pGpu, pOffset, pSize) 454 #define dispchnpioInternalControlForward(pGpuResource, command, pParams, size) dispchnpioInternalControlForward_DISPATCH(pGpuResource, command, pParams, size) 455 #define dispchnpioUnmapFrom(pResource, pParams) dispchnpioUnmapFrom_DISPATCH(pResource, pParams) 456 #define dispchnpioControl_Epilogue(pResource, pCallContext, pParams) dispchnpioControl_Epilogue_DISPATCH(pResource, pCallContext, pParams) 457 #define dispchnpioControlLookup(pResource, pParams, ppEntry) dispchnpioControlLookup_DISPATCH(pResource, pParams, ppEntry) 458 #define dispchnpioGetInternalObjectHandle(pGpuResource) dispchnpioGetInternalObjectHandle_DISPATCH(pGpuResource) 459 #define dispchnpioControl(pGpuResource, pCallContext, pParams) dispchnpioControl_DISPATCH(pGpuResource, pCallContext, pParams) 460 #define dispchnpioUnmap(pGpuResource, pCallContext, pCpuMapping) dispchnpioUnmap_DISPATCH(pGpuResource, pCallContext, pCpuMapping) 461 #define dispchnpioGetMemInterMapParams(pRmResource, pParams) dispchnpioGetMemInterMapParams_DISPATCH(pRmResource, pParams) 462 #define dispchnpioGetMemoryMappingDescriptor(pRmResource, ppMemDesc) dispchnpioGetMemoryMappingDescriptor_DISPATCH(pRmResource, ppMemDesc) 463 #define dispchnpioControlFilter(pResource, pCallContext, pParams) dispchnpioControlFilter_DISPATCH(pResource, pCallContext, pParams) 464 #define dispchnpioUnregisterEvent(pNotifier, hNotifierClient, hNotifierResource, hEventClient, hEvent) dispchnpioUnregisterEvent_DISPATCH(pNotifier, hNotifierClient, hNotifierResource, hEventClient, hEvent) 465 #define dispchnpioControlSerialization_Prologue(pResource, pCallContext, pParams) dispchnpioControlSerialization_Prologue_DISPATCH(pResource, pCallContext, pParams) 466 #define dispchnpioCanCopy(pResource) dispchnpioCanCopy_DISPATCH(pResource) 467 #define dispchnpioPreDestruct(pResource) dispchnpioPreDestruct_DISPATCH(pResource) 468 #define dispchnpioIsDuplicate(pResource, hMemory, pDuplicate) dispchnpioIsDuplicate_DISPATCH(pResource, hMemory, pDuplicate) 469 #define dispchnpioControlSerialization_Epilogue(pResource, pCallContext, pParams) dispchnpioControlSerialization_Epilogue_DISPATCH(pResource, pCallContext, pParams) 470 #define dispchnpioGetNotificationListPtr(pNotifier) dispchnpioGetNotificationListPtr_DISPATCH(pNotifier) 471 #define dispchnpioGetNotificationShare(pNotifier) dispchnpioGetNotificationShare_DISPATCH(pNotifier) 472 #define dispchnpioMap(pGpuResource, pCallContext, pParams, pCpuMapping) dispchnpioMap_DISPATCH(pGpuResource, pCallContext, pParams, pCpuMapping) 473 #define dispchnpioAccessCallback(pResource, pInvokingClient, pAllocParams, accessRight) dispchnpioAccessCallback_DISPATCH(pResource, pInvokingClient, pAllocParams, accessRight) 474 static inline NvBool dispchnpioShareCallback_DISPATCH(struct DispChannelPio *pGpuResource, struct RsClient *pInvokingClient, struct RsResourceRef *pParentRef, RS_SHARE_POLICY *pSharePolicy) { 475 return pGpuResource->__dispchnpioShareCallback__(pGpuResource, pInvokingClient, pParentRef, pSharePolicy); 476 } 477 478 static inline NV_STATUS dispchnpioCheckMemInterUnmap_DISPATCH(struct DispChannelPio *pRmResource, NvBool bSubdeviceHandleProvided) { 479 return pRmResource->__dispchnpioCheckMemInterUnmap__(pRmResource, bSubdeviceHandleProvided); 480 } 481 482 static inline NV_STATUS dispchnpioGetOrAllocNotifShare_DISPATCH(struct DispChannelPio *pNotifier, NvHandle hNotifierClient, NvHandle hNotifierResource, struct NotifShare **ppNotifShare) { 483 return pNotifier->__dispchnpioGetOrAllocNotifShare__(pNotifier, hNotifierClient, hNotifierResource, ppNotifShare); 484 } 485 486 static inline NV_STATUS dispchnpioMapTo_DISPATCH(struct DispChannelPio *pResource, RS_RES_MAP_TO_PARAMS *pParams) { 487 return pResource->__dispchnpioMapTo__(pResource, pParams); 488 } 489 490 static inline NV_STATUS dispchnpioGetMapAddrSpace_DISPATCH(struct DispChannelPio *pGpuResource, struct CALL_CONTEXT *pCallContext, NvU32 mapFlags, NV_ADDRESS_SPACE *pAddrSpace) { 491 return pGpuResource->__dispchnpioGetMapAddrSpace__(pGpuResource, pCallContext, mapFlags, pAddrSpace); 492 } 493 494 static inline void dispchnpioSetNotificationShare_DISPATCH(struct DispChannelPio *pNotifier, struct NotifShare *pNotifShare) { 495 pNotifier->__dispchnpioSetNotificationShare__(pNotifier, pNotifShare); 496 } 497 498 static inline NvU32 dispchnpioGetRefCount_DISPATCH(struct DispChannelPio *pResource) { 499 return pResource->__dispchnpioGetRefCount__(pResource); 500 } 501 502 static inline void dispchnpioAddAdditionalDependants_DISPATCH(struct RsClient *pClient, struct DispChannelPio *pResource, RsResourceRef *pReference) { 503 pResource->__dispchnpioAddAdditionalDependants__(pClient, pResource, pReference); 504 } 505 506 static inline NV_STATUS dispchnpioControl_Prologue_DISPATCH(struct DispChannelPio *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 507 return pResource->__dispchnpioControl_Prologue__(pResource, pCallContext, pParams); 508 } 509 510 static inline NV_STATUS dispchnpioGetRegBaseOffsetAndSize_DISPATCH(struct DispChannelPio *pDispChannel, struct OBJGPU *pGpu, NvU32 *pOffset, NvU32 *pSize) { 511 return pDispChannel->__dispchnpioGetRegBaseOffsetAndSize__(pDispChannel, pGpu, pOffset, pSize); 512 } 513 514 static inline NV_STATUS dispchnpioInternalControlForward_DISPATCH(struct DispChannelPio *pGpuResource, NvU32 command, void *pParams, NvU32 size) { 515 return pGpuResource->__dispchnpioInternalControlForward__(pGpuResource, command, pParams, size); 516 } 517 518 static inline NV_STATUS dispchnpioUnmapFrom_DISPATCH(struct DispChannelPio *pResource, RS_RES_UNMAP_FROM_PARAMS *pParams) { 519 return pResource->__dispchnpioUnmapFrom__(pResource, pParams); 520 } 521 522 static inline void dispchnpioControl_Epilogue_DISPATCH(struct DispChannelPio *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 523 pResource->__dispchnpioControl_Epilogue__(pResource, pCallContext, pParams); 524 } 525 526 static inline NV_STATUS dispchnpioControlLookup_DISPATCH(struct DispChannelPio *pResource, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams, const struct NVOC_EXPORTED_METHOD_DEF **ppEntry) { 527 return pResource->__dispchnpioControlLookup__(pResource, pParams, ppEntry); 528 } 529 530 static inline NvHandle dispchnpioGetInternalObjectHandle_DISPATCH(struct DispChannelPio *pGpuResource) { 531 return pGpuResource->__dispchnpioGetInternalObjectHandle__(pGpuResource); 532 } 533 534 static inline NV_STATUS dispchnpioControl_DISPATCH(struct DispChannelPio *pGpuResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 535 return pGpuResource->__dispchnpioControl__(pGpuResource, pCallContext, pParams); 536 } 537 538 static inline NV_STATUS dispchnpioUnmap_DISPATCH(struct DispChannelPio *pGpuResource, struct CALL_CONTEXT *pCallContext, struct RsCpuMapping *pCpuMapping) { 539 return pGpuResource->__dispchnpioUnmap__(pGpuResource, pCallContext, pCpuMapping); 540 } 541 542 static inline NV_STATUS dispchnpioGetMemInterMapParams_DISPATCH(struct DispChannelPio *pRmResource, RMRES_MEM_INTER_MAP_PARAMS *pParams) { 543 return pRmResource->__dispchnpioGetMemInterMapParams__(pRmResource, pParams); 544 } 545 546 static inline NV_STATUS dispchnpioGetMemoryMappingDescriptor_DISPATCH(struct DispChannelPio *pRmResource, struct MEMORY_DESCRIPTOR **ppMemDesc) { 547 return pRmResource->__dispchnpioGetMemoryMappingDescriptor__(pRmResource, ppMemDesc); 548 } 549 550 static inline NV_STATUS dispchnpioControlFilter_DISPATCH(struct DispChannelPio *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 551 return pResource->__dispchnpioControlFilter__(pResource, pCallContext, pParams); 552 } 553 554 static inline NV_STATUS dispchnpioUnregisterEvent_DISPATCH(struct DispChannelPio *pNotifier, NvHandle hNotifierClient, NvHandle hNotifierResource, NvHandle hEventClient, NvHandle hEvent) { 555 return pNotifier->__dispchnpioUnregisterEvent__(pNotifier, hNotifierClient, hNotifierResource, hEventClient, hEvent); 556 } 557 558 static inline NV_STATUS dispchnpioControlSerialization_Prologue_DISPATCH(struct DispChannelPio *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 559 return pResource->__dispchnpioControlSerialization_Prologue__(pResource, pCallContext, pParams); 560 } 561 562 static inline NvBool dispchnpioCanCopy_DISPATCH(struct DispChannelPio *pResource) { 563 return pResource->__dispchnpioCanCopy__(pResource); 564 } 565 566 static inline void dispchnpioPreDestruct_DISPATCH(struct DispChannelPio *pResource) { 567 pResource->__dispchnpioPreDestruct__(pResource); 568 } 569 570 static inline NV_STATUS dispchnpioIsDuplicate_DISPATCH(struct DispChannelPio *pResource, NvHandle hMemory, NvBool *pDuplicate) { 571 return pResource->__dispchnpioIsDuplicate__(pResource, hMemory, pDuplicate); 572 } 573 574 static inline void dispchnpioControlSerialization_Epilogue_DISPATCH(struct DispChannelPio *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 575 pResource->__dispchnpioControlSerialization_Epilogue__(pResource, pCallContext, pParams); 576 } 577 578 static inline PEVENTNOTIFICATION *dispchnpioGetNotificationListPtr_DISPATCH(struct DispChannelPio *pNotifier) { 579 return pNotifier->__dispchnpioGetNotificationListPtr__(pNotifier); 580 } 581 582 static inline struct NotifShare *dispchnpioGetNotificationShare_DISPATCH(struct DispChannelPio *pNotifier) { 583 return pNotifier->__dispchnpioGetNotificationShare__(pNotifier); 584 } 585 586 static inline NV_STATUS dispchnpioMap_DISPATCH(struct DispChannelPio *pGpuResource, struct CALL_CONTEXT *pCallContext, struct RS_CPU_MAP_PARAMS *pParams, struct RsCpuMapping *pCpuMapping) { 587 return pGpuResource->__dispchnpioMap__(pGpuResource, pCallContext, pParams, pCpuMapping); 588 } 589 590 static inline NvBool dispchnpioAccessCallback_DISPATCH(struct DispChannelPio *pResource, struct RsClient *pInvokingClient, void *pAllocParams, RsAccessRight accessRight) { 591 return pResource->__dispchnpioAccessCallback__(pResource, pInvokingClient, pAllocParams, accessRight); 592 } 593 594 NV_STATUS dispchnpioConstruct_IMPL(struct DispChannelPio *arg_pDispChannelPio, struct CALL_CONTEXT *arg_pCallContext, struct RS_RES_ALLOC_PARAMS_INTERNAL *arg_pParams); 595 596 #define __nvoc_dispchnpioConstruct(arg_pDispChannelPio, arg_pCallContext, arg_pParams) dispchnpioConstruct_IMPL(arg_pDispChannelPio, arg_pCallContext, arg_pParams) 597 #undef PRIVATE_FIELD 598 599 600 /*! 601 * RM internal class representing XXX_XXX_CHANNEL_DMA 602 */ 603 #ifdef NVOC_DISP_CHANNEL_H_PRIVATE_ACCESS_ALLOWED 604 #define PRIVATE_FIELD(x) x 605 #else 606 #define PRIVATE_FIELD(x) NVOC_PRIVATE_FIELD(x) 607 #endif 608 struct DispChannelDma { 609 const struct NVOC_RTTI *__nvoc_rtti; 610 struct DispChannel __nvoc_base_DispChannel; 611 struct Object *__nvoc_pbase_Object; 612 struct RsResource *__nvoc_pbase_RsResource; 613 struct RmResourceCommon *__nvoc_pbase_RmResourceCommon; 614 struct RmResource *__nvoc_pbase_RmResource; 615 struct GpuResource *__nvoc_pbase_GpuResource; 616 struct INotifier *__nvoc_pbase_INotifier; 617 struct Notifier *__nvoc_pbase_Notifier; 618 struct DispChannel *__nvoc_pbase_DispChannel; 619 struct DispChannelDma *__nvoc_pbase_DispChannelDma; 620 NvBool (*__dispchndmaShareCallback__)(struct DispChannelDma *, struct RsClient *, struct RsResourceRef *, RS_SHARE_POLICY *); 621 NV_STATUS (*__dispchndmaCheckMemInterUnmap__)(struct DispChannelDma *, NvBool); 622 NV_STATUS (*__dispchndmaGetOrAllocNotifShare__)(struct DispChannelDma *, NvHandle, NvHandle, struct NotifShare **); 623 NV_STATUS (*__dispchndmaMapTo__)(struct DispChannelDma *, RS_RES_MAP_TO_PARAMS *); 624 NV_STATUS (*__dispchndmaGetMapAddrSpace__)(struct DispChannelDma *, struct CALL_CONTEXT *, NvU32, NV_ADDRESS_SPACE *); 625 void (*__dispchndmaSetNotificationShare__)(struct DispChannelDma *, struct NotifShare *); 626 NvU32 (*__dispchndmaGetRefCount__)(struct DispChannelDma *); 627 void (*__dispchndmaAddAdditionalDependants__)(struct RsClient *, struct DispChannelDma *, RsResourceRef *); 628 NV_STATUS (*__dispchndmaControl_Prologue__)(struct DispChannelDma *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 629 NV_STATUS (*__dispchndmaGetRegBaseOffsetAndSize__)(struct DispChannelDma *, struct OBJGPU *, NvU32 *, NvU32 *); 630 NV_STATUS (*__dispchndmaInternalControlForward__)(struct DispChannelDma *, NvU32, void *, NvU32); 631 NV_STATUS (*__dispchndmaUnmapFrom__)(struct DispChannelDma *, RS_RES_UNMAP_FROM_PARAMS *); 632 void (*__dispchndmaControl_Epilogue__)(struct DispChannelDma *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 633 NV_STATUS (*__dispchndmaControlLookup__)(struct DispChannelDma *, struct RS_RES_CONTROL_PARAMS_INTERNAL *, const struct NVOC_EXPORTED_METHOD_DEF **); 634 NvHandle (*__dispchndmaGetInternalObjectHandle__)(struct DispChannelDma *); 635 NV_STATUS (*__dispchndmaControl__)(struct DispChannelDma *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 636 NV_STATUS (*__dispchndmaUnmap__)(struct DispChannelDma *, struct CALL_CONTEXT *, struct RsCpuMapping *); 637 NV_STATUS (*__dispchndmaGetMemInterMapParams__)(struct DispChannelDma *, RMRES_MEM_INTER_MAP_PARAMS *); 638 NV_STATUS (*__dispchndmaGetMemoryMappingDescriptor__)(struct DispChannelDma *, struct MEMORY_DESCRIPTOR **); 639 NV_STATUS (*__dispchndmaControlFilter__)(struct DispChannelDma *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 640 NV_STATUS (*__dispchndmaUnregisterEvent__)(struct DispChannelDma *, NvHandle, NvHandle, NvHandle, NvHandle); 641 NV_STATUS (*__dispchndmaControlSerialization_Prologue__)(struct DispChannelDma *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 642 NvBool (*__dispchndmaCanCopy__)(struct DispChannelDma *); 643 void (*__dispchndmaPreDestruct__)(struct DispChannelDma *); 644 NV_STATUS (*__dispchndmaIsDuplicate__)(struct DispChannelDma *, NvHandle, NvBool *); 645 void (*__dispchndmaControlSerialization_Epilogue__)(struct DispChannelDma *, struct CALL_CONTEXT *, struct RS_RES_CONTROL_PARAMS_INTERNAL *); 646 PEVENTNOTIFICATION *(*__dispchndmaGetNotificationListPtr__)(struct DispChannelDma *); 647 struct NotifShare *(*__dispchndmaGetNotificationShare__)(struct DispChannelDma *); 648 NV_STATUS (*__dispchndmaMap__)(struct DispChannelDma *, struct CALL_CONTEXT *, struct RS_CPU_MAP_PARAMS *, struct RsCpuMapping *); 649 NvBool (*__dispchndmaAccessCallback__)(struct DispChannelDma *, struct RsClient *, void *, RsAccessRight); 650 }; 651 652 #ifndef __NVOC_CLASS_DispChannelDma_TYPEDEF__ 653 #define __NVOC_CLASS_DispChannelDma_TYPEDEF__ 654 typedef struct DispChannelDma DispChannelDma; 655 #endif /* __NVOC_CLASS_DispChannelDma_TYPEDEF__ */ 656 657 #ifndef __nvoc_class_id_DispChannelDma 658 #define __nvoc_class_id_DispChannelDma 0xfe3d2e 659 #endif /* __nvoc_class_id_DispChannelDma */ 660 661 extern const struct NVOC_CLASS_DEF __nvoc_class_def_DispChannelDma; 662 663 #define __staticCast_DispChannelDma(pThis) \ 664 ((pThis)->__nvoc_pbase_DispChannelDma) 665 666 #ifdef __nvoc_disp_channel_h_disabled 667 #define __dynamicCast_DispChannelDma(pThis) ((DispChannelDma*)NULL) 668 #else //__nvoc_disp_channel_h_disabled 669 #define __dynamicCast_DispChannelDma(pThis) \ 670 ((DispChannelDma*)__nvoc_dynamicCast(staticCast((pThis), Dynamic), classInfo(DispChannelDma))) 671 #endif //__nvoc_disp_channel_h_disabled 672 673 674 NV_STATUS __nvoc_objCreateDynamic_DispChannelDma(DispChannelDma**, Dynamic*, NvU32, va_list); 675 676 NV_STATUS __nvoc_objCreate_DispChannelDma(DispChannelDma**, Dynamic*, NvU32, struct CALL_CONTEXT * arg_pCallContext, struct RS_RES_ALLOC_PARAMS_INTERNAL * arg_pParams); 677 #define __objCreate_DispChannelDma(ppNewObj, pParent, createFlags, arg_pCallContext, arg_pParams) \ 678 __nvoc_objCreate_DispChannelDma((ppNewObj), staticCast((pParent), Dynamic), (createFlags), arg_pCallContext, arg_pParams) 679 680 #define dispchndmaShareCallback(pGpuResource, pInvokingClient, pParentRef, pSharePolicy) dispchndmaShareCallback_DISPATCH(pGpuResource, pInvokingClient, pParentRef, pSharePolicy) 681 #define dispchndmaCheckMemInterUnmap(pRmResource, bSubdeviceHandleProvided) dispchndmaCheckMemInterUnmap_DISPATCH(pRmResource, bSubdeviceHandleProvided) 682 #define dispchndmaGetOrAllocNotifShare(pNotifier, hNotifierClient, hNotifierResource, ppNotifShare) dispchndmaGetOrAllocNotifShare_DISPATCH(pNotifier, hNotifierClient, hNotifierResource, ppNotifShare) 683 #define dispchndmaMapTo(pResource, pParams) dispchndmaMapTo_DISPATCH(pResource, pParams) 684 #define dispchndmaGetMapAddrSpace(pGpuResource, pCallContext, mapFlags, pAddrSpace) dispchndmaGetMapAddrSpace_DISPATCH(pGpuResource, pCallContext, mapFlags, pAddrSpace) 685 #define dispchndmaSetNotificationShare(pNotifier, pNotifShare) dispchndmaSetNotificationShare_DISPATCH(pNotifier, pNotifShare) 686 #define dispchndmaGetRefCount(pResource) dispchndmaGetRefCount_DISPATCH(pResource) 687 #define dispchndmaAddAdditionalDependants(pClient, pResource, pReference) dispchndmaAddAdditionalDependants_DISPATCH(pClient, pResource, pReference) 688 #define dispchndmaControl_Prologue(pResource, pCallContext, pParams) dispchndmaControl_Prologue_DISPATCH(pResource, pCallContext, pParams) 689 #define dispchndmaGetRegBaseOffsetAndSize(pDispChannel, pGpu, pOffset, pSize) dispchndmaGetRegBaseOffsetAndSize_DISPATCH(pDispChannel, pGpu, pOffset, pSize) 690 #define dispchndmaInternalControlForward(pGpuResource, command, pParams, size) dispchndmaInternalControlForward_DISPATCH(pGpuResource, command, pParams, size) 691 #define dispchndmaUnmapFrom(pResource, pParams) dispchndmaUnmapFrom_DISPATCH(pResource, pParams) 692 #define dispchndmaControl_Epilogue(pResource, pCallContext, pParams) dispchndmaControl_Epilogue_DISPATCH(pResource, pCallContext, pParams) 693 #define dispchndmaControlLookup(pResource, pParams, ppEntry) dispchndmaControlLookup_DISPATCH(pResource, pParams, ppEntry) 694 #define dispchndmaGetInternalObjectHandle(pGpuResource) dispchndmaGetInternalObjectHandle_DISPATCH(pGpuResource) 695 #define dispchndmaControl(pGpuResource, pCallContext, pParams) dispchndmaControl_DISPATCH(pGpuResource, pCallContext, pParams) 696 #define dispchndmaUnmap(pGpuResource, pCallContext, pCpuMapping) dispchndmaUnmap_DISPATCH(pGpuResource, pCallContext, pCpuMapping) 697 #define dispchndmaGetMemInterMapParams(pRmResource, pParams) dispchndmaGetMemInterMapParams_DISPATCH(pRmResource, pParams) 698 #define dispchndmaGetMemoryMappingDescriptor(pRmResource, ppMemDesc) dispchndmaGetMemoryMappingDescriptor_DISPATCH(pRmResource, ppMemDesc) 699 #define dispchndmaControlFilter(pResource, pCallContext, pParams) dispchndmaControlFilter_DISPATCH(pResource, pCallContext, pParams) 700 #define dispchndmaUnregisterEvent(pNotifier, hNotifierClient, hNotifierResource, hEventClient, hEvent) dispchndmaUnregisterEvent_DISPATCH(pNotifier, hNotifierClient, hNotifierResource, hEventClient, hEvent) 701 #define dispchndmaControlSerialization_Prologue(pResource, pCallContext, pParams) dispchndmaControlSerialization_Prologue_DISPATCH(pResource, pCallContext, pParams) 702 #define dispchndmaCanCopy(pResource) dispchndmaCanCopy_DISPATCH(pResource) 703 #define dispchndmaPreDestruct(pResource) dispchndmaPreDestruct_DISPATCH(pResource) 704 #define dispchndmaIsDuplicate(pResource, hMemory, pDuplicate) dispchndmaIsDuplicate_DISPATCH(pResource, hMemory, pDuplicate) 705 #define dispchndmaControlSerialization_Epilogue(pResource, pCallContext, pParams) dispchndmaControlSerialization_Epilogue_DISPATCH(pResource, pCallContext, pParams) 706 #define dispchndmaGetNotificationListPtr(pNotifier) dispchndmaGetNotificationListPtr_DISPATCH(pNotifier) 707 #define dispchndmaGetNotificationShare(pNotifier) dispchndmaGetNotificationShare_DISPATCH(pNotifier) 708 #define dispchndmaMap(pGpuResource, pCallContext, pParams, pCpuMapping) dispchndmaMap_DISPATCH(pGpuResource, pCallContext, pParams, pCpuMapping) 709 #define dispchndmaAccessCallback(pResource, pInvokingClient, pAllocParams, accessRight) dispchndmaAccessCallback_DISPATCH(pResource, pInvokingClient, pAllocParams, accessRight) 710 static inline NvBool dispchndmaShareCallback_DISPATCH(struct DispChannelDma *pGpuResource, struct RsClient *pInvokingClient, struct RsResourceRef *pParentRef, RS_SHARE_POLICY *pSharePolicy) { 711 return pGpuResource->__dispchndmaShareCallback__(pGpuResource, pInvokingClient, pParentRef, pSharePolicy); 712 } 713 714 static inline NV_STATUS dispchndmaCheckMemInterUnmap_DISPATCH(struct DispChannelDma *pRmResource, NvBool bSubdeviceHandleProvided) { 715 return pRmResource->__dispchndmaCheckMemInterUnmap__(pRmResource, bSubdeviceHandleProvided); 716 } 717 718 static inline NV_STATUS dispchndmaGetOrAllocNotifShare_DISPATCH(struct DispChannelDma *pNotifier, NvHandle hNotifierClient, NvHandle hNotifierResource, struct NotifShare **ppNotifShare) { 719 return pNotifier->__dispchndmaGetOrAllocNotifShare__(pNotifier, hNotifierClient, hNotifierResource, ppNotifShare); 720 } 721 722 static inline NV_STATUS dispchndmaMapTo_DISPATCH(struct DispChannelDma *pResource, RS_RES_MAP_TO_PARAMS *pParams) { 723 return pResource->__dispchndmaMapTo__(pResource, pParams); 724 } 725 726 static inline NV_STATUS dispchndmaGetMapAddrSpace_DISPATCH(struct DispChannelDma *pGpuResource, struct CALL_CONTEXT *pCallContext, NvU32 mapFlags, NV_ADDRESS_SPACE *pAddrSpace) { 727 return pGpuResource->__dispchndmaGetMapAddrSpace__(pGpuResource, pCallContext, mapFlags, pAddrSpace); 728 } 729 730 static inline void dispchndmaSetNotificationShare_DISPATCH(struct DispChannelDma *pNotifier, struct NotifShare *pNotifShare) { 731 pNotifier->__dispchndmaSetNotificationShare__(pNotifier, pNotifShare); 732 } 733 734 static inline NvU32 dispchndmaGetRefCount_DISPATCH(struct DispChannelDma *pResource) { 735 return pResource->__dispchndmaGetRefCount__(pResource); 736 } 737 738 static inline void dispchndmaAddAdditionalDependants_DISPATCH(struct RsClient *pClient, struct DispChannelDma *pResource, RsResourceRef *pReference) { 739 pResource->__dispchndmaAddAdditionalDependants__(pClient, pResource, pReference); 740 } 741 742 static inline NV_STATUS dispchndmaControl_Prologue_DISPATCH(struct DispChannelDma *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 743 return pResource->__dispchndmaControl_Prologue__(pResource, pCallContext, pParams); 744 } 745 746 static inline NV_STATUS dispchndmaGetRegBaseOffsetAndSize_DISPATCH(struct DispChannelDma *pDispChannel, struct OBJGPU *pGpu, NvU32 *pOffset, NvU32 *pSize) { 747 return pDispChannel->__dispchndmaGetRegBaseOffsetAndSize__(pDispChannel, pGpu, pOffset, pSize); 748 } 749 750 static inline NV_STATUS dispchndmaInternalControlForward_DISPATCH(struct DispChannelDma *pGpuResource, NvU32 command, void *pParams, NvU32 size) { 751 return pGpuResource->__dispchndmaInternalControlForward__(pGpuResource, command, pParams, size); 752 } 753 754 static inline NV_STATUS dispchndmaUnmapFrom_DISPATCH(struct DispChannelDma *pResource, RS_RES_UNMAP_FROM_PARAMS *pParams) { 755 return pResource->__dispchndmaUnmapFrom__(pResource, pParams); 756 } 757 758 static inline void dispchndmaControl_Epilogue_DISPATCH(struct DispChannelDma *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 759 pResource->__dispchndmaControl_Epilogue__(pResource, pCallContext, pParams); 760 } 761 762 static inline NV_STATUS dispchndmaControlLookup_DISPATCH(struct DispChannelDma *pResource, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams, const struct NVOC_EXPORTED_METHOD_DEF **ppEntry) { 763 return pResource->__dispchndmaControlLookup__(pResource, pParams, ppEntry); 764 } 765 766 static inline NvHandle dispchndmaGetInternalObjectHandle_DISPATCH(struct DispChannelDma *pGpuResource) { 767 return pGpuResource->__dispchndmaGetInternalObjectHandle__(pGpuResource); 768 } 769 770 static inline NV_STATUS dispchndmaControl_DISPATCH(struct DispChannelDma *pGpuResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 771 return pGpuResource->__dispchndmaControl__(pGpuResource, pCallContext, pParams); 772 } 773 774 static inline NV_STATUS dispchndmaUnmap_DISPATCH(struct DispChannelDma *pGpuResource, struct CALL_CONTEXT *pCallContext, struct RsCpuMapping *pCpuMapping) { 775 return pGpuResource->__dispchndmaUnmap__(pGpuResource, pCallContext, pCpuMapping); 776 } 777 778 static inline NV_STATUS dispchndmaGetMemInterMapParams_DISPATCH(struct DispChannelDma *pRmResource, RMRES_MEM_INTER_MAP_PARAMS *pParams) { 779 return pRmResource->__dispchndmaGetMemInterMapParams__(pRmResource, pParams); 780 } 781 782 static inline NV_STATUS dispchndmaGetMemoryMappingDescriptor_DISPATCH(struct DispChannelDma *pRmResource, struct MEMORY_DESCRIPTOR **ppMemDesc) { 783 return pRmResource->__dispchndmaGetMemoryMappingDescriptor__(pRmResource, ppMemDesc); 784 } 785 786 static inline NV_STATUS dispchndmaControlFilter_DISPATCH(struct DispChannelDma *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 787 return pResource->__dispchndmaControlFilter__(pResource, pCallContext, pParams); 788 } 789 790 static inline NV_STATUS dispchndmaUnregisterEvent_DISPATCH(struct DispChannelDma *pNotifier, NvHandle hNotifierClient, NvHandle hNotifierResource, NvHandle hEventClient, NvHandle hEvent) { 791 return pNotifier->__dispchndmaUnregisterEvent__(pNotifier, hNotifierClient, hNotifierResource, hEventClient, hEvent); 792 } 793 794 static inline NV_STATUS dispchndmaControlSerialization_Prologue_DISPATCH(struct DispChannelDma *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 795 return pResource->__dispchndmaControlSerialization_Prologue__(pResource, pCallContext, pParams); 796 } 797 798 static inline NvBool dispchndmaCanCopy_DISPATCH(struct DispChannelDma *pResource) { 799 return pResource->__dispchndmaCanCopy__(pResource); 800 } 801 802 static inline void dispchndmaPreDestruct_DISPATCH(struct DispChannelDma *pResource) { 803 pResource->__dispchndmaPreDestruct__(pResource); 804 } 805 806 static inline NV_STATUS dispchndmaIsDuplicate_DISPATCH(struct DispChannelDma *pResource, NvHandle hMemory, NvBool *pDuplicate) { 807 return pResource->__dispchndmaIsDuplicate__(pResource, hMemory, pDuplicate); 808 } 809 810 static inline void dispchndmaControlSerialization_Epilogue_DISPATCH(struct DispChannelDma *pResource, struct CALL_CONTEXT *pCallContext, struct RS_RES_CONTROL_PARAMS_INTERNAL *pParams) { 811 pResource->__dispchndmaControlSerialization_Epilogue__(pResource, pCallContext, pParams); 812 } 813 814 static inline PEVENTNOTIFICATION *dispchndmaGetNotificationListPtr_DISPATCH(struct DispChannelDma *pNotifier) { 815 return pNotifier->__dispchndmaGetNotificationListPtr__(pNotifier); 816 } 817 818 static inline struct NotifShare *dispchndmaGetNotificationShare_DISPATCH(struct DispChannelDma *pNotifier) { 819 return pNotifier->__dispchndmaGetNotificationShare__(pNotifier); 820 } 821 822 static inline NV_STATUS dispchndmaMap_DISPATCH(struct DispChannelDma *pGpuResource, struct CALL_CONTEXT *pCallContext, struct RS_CPU_MAP_PARAMS *pParams, struct RsCpuMapping *pCpuMapping) { 823 return pGpuResource->__dispchndmaMap__(pGpuResource, pCallContext, pParams, pCpuMapping); 824 } 825 826 static inline NvBool dispchndmaAccessCallback_DISPATCH(struct DispChannelDma *pResource, struct RsClient *pInvokingClient, void *pAllocParams, RsAccessRight accessRight) { 827 return pResource->__dispchndmaAccessCallback__(pResource, pInvokingClient, pAllocParams, accessRight); 828 } 829 830 NV_STATUS dispchndmaConstruct_IMPL(struct DispChannelDma *arg_pDispChannelDma, struct CALL_CONTEXT *arg_pCallContext, struct RS_RES_ALLOC_PARAMS_INTERNAL *arg_pParams); 831 832 #define __nvoc_dispchndmaConstruct(arg_pDispChannelDma, arg_pCallContext, arg_pParams) dispchndmaConstruct_IMPL(arg_pDispChannelDma, arg_pCallContext, arg_pParams) 833 #undef PRIVATE_FIELD 834 835 836 #endif // DISP_CHANNEL_H 837 838 #ifdef __cplusplus 839 } // extern "C" 840 #endif 841 #endif // _G_DISP_CHANNEL_NVOC_H_ 842