1 #ifndef _G_KERNEL_NVLINK_NVOC_H_ 2 #define _G_KERNEL_NVLINK_NVOC_H_ 3 #include "nvoc/runtime.h" 4 5 #ifdef __cplusplus 6 extern "C" { 7 #endif 8 9 /* 10 * SPDX-FileCopyrightText: Copyright (c) 2020-2023 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 #include "g_kernel_nvlink_nvoc.h" 33 34 #ifndef _KERNEL_NVLINK_H_ 35 #define _KERNEL_NVLINK_H_ 36 37 #include "core/core.h" 38 #include "core/locks.h" 39 #include "gpu/eng_state.h" 40 #include "lib/ref_count.h" 41 #include "objtmr.h" 42 #include "nvCpuUuid.h" 43 #include "gpu/bus/kern_bus.h" 44 45 #if defined(INCLUDE_NVLINK_LIB) 46 #include "nvlink.h" 47 #include "nvlink_export.h" 48 #include "nvlink_lib_ctrl.h" 49 #endif 50 51 #include "kernel/gpu/nvlink/kernel_ioctrl.h" 52 53 #include "ctrl/ctrl2080/ctrl2080nvlink.h" // rmcontrol params 54 #include "ctrl/ctrl2080/ctrl2080pmgr.h" 55 56 #include "nvlink_inband_drv_header.h" 57 #include "nvlink_inband_msg.h" 58 59 #if defined(INCLUDE_NVLINK_LIB) 60 61 typedef struct _def_knvlink_conn_info 62 { 63 NvU32 domain; 64 NvU16 bus; 65 NvU16 device; 66 NvU16 function; 67 NvU32 pciDeviceId; 68 NvU8 devUuid[NV_UUID_LEN]; 69 NvU64 deviceType; 70 NvU32 linkNumber; 71 NvU32 ipVerDlPl; 72 NvBool bConnected; 73 NvU64 chipSid; 74 } KNVLINK_CONN_INFO, *PKNVLINK_CONN_INFO; 75 76 #endif 77 78 // Known versions (taken from nvlinkip_discovery.h NV_NVLINKIP_DISCOVERY_COMMON_VERSION) 79 #define NVLINK_VERSION_10 0x00000001 80 #define NVLINK_VERSION_20 0x00000002 81 #define NVLINK_VERSION_22 0x00000004 82 #define NVLINK_VERSION_30 0x00000005 83 #define NVLINK_VERSION_31 0x00000006 84 #define NVLINK_VERSION_40 0x00000007 85 #define NVLINK_VERSION_50 0x00000008 86 87 // Maximum links the GPU NVLink SW can currently support 88 #define NVLINK_MAX_LINKS_SW 18 89 90 // Maximum IOCTRLs supported in SW 91 #define NVLINK_MAX_IOCTRLS_SW 3 92 93 // NvLink Phase Identifiers 94 #define NVLINK_PHASE_STATE_LOAD 0xFF000001 95 #define NVLINK_PHASE_STATE_POST_LOAD 0xFF000002 96 97 /******** NVLink associated timeouts and delays ***********/ 98 99 // INITOPTIMIZE timeout = 10s 100 #define NVLINK_INITOPTIMIZE_POLL_TIMEOUT 10000000 101 #define NVLINK_INITOPTIMIZE_POLL_TIMEOUT_EMU 20000000 102 #define NVLINK_INITOPTIMIZE_POLL_COUNT_DELAY_MS 1000 103 104 // Link Retrain after reset time = 10s 105 #define NVLINK_RETRAIN_TIME 10000000000 106 107 /**********************************************************/ 108 109 // NvGpu identifier in nvlink core library 110 #define NVLINK_NVIDIA_DRIVER "NVIDIA GPU DRIVER" 111 112 #define NVLINK_DRIVER_NAME_LENGTH 0x0000040 113 #define NVLINK_DEVICE_NAME_LENGTH 0x0000040 114 #define NVLINK_LINK_NAME_LENGTH 0x0000040 115 116 // 117 // Arch CONNECTION defines, replaces forceconfig. See Bugs 1665737, 118 // 1665734 and 1734252. 119 // This per link connection state is passed up from chiplib 120 // and can be controlled on the command line. 121 // The max number of connections is speced in __SIZE_1. 122 // 123 #define NV_NVLINK_ARCH_CONNECTION 31:0 124 #define NV_NVLINK_ARCH_CONNECTION__SIZE_1 32 125 #define NV_NVLINK_ARCH_CONNECTION_DISABLED 0x00000000 126 #define NV_NVLINK_ARCH_CONNECTION_PEER_MASK 7:0 127 #define NV_NVLINK_ARCH_CONNECTION_ENABLED 8:8 128 #define NV_NVLINK_ARCH_CONNECTION_PHYSICAL_LINK 20:16 129 #define NV_NVLINK_ARCH_CONNECTION_RESERVED 29:21 130 #define NV_NVLINK_ARCH_CONNECTION_PEERS_COMPUTE_ONLY 30:30 131 #define NV_NVLINK_ARCH_CONNECTION_CPU 31:31 132 133 // Invalid fabric address 134 #define NVLINK_INVALID_FABRIC_ADDR NV_U64_MAX 135 136 #define NVLINK_MAX_PEERS_SW 8 137 138 // PCI Device IDs and types used for ForceConfig 139 140 // FORCED_SYSMEM uses the ebridge device from NVLink1 141 #define FORCED_SYSMEM_PCI_BUS 0xe 142 #define FORCED_SYSMEM_DEVICE_ID 0x10ec 143 #define FORCED_SYSMEM_DEVICE_TYPE NV2080_CTRL_NVLINK_DEVICE_INFO_DEVICE_TYPE_EBRIDGE 144 145 // 146 // FORCED_SWITCH uses the first Switch device (Willow) 147 // Willow device ID is 0x10F5 or 0x1AC0..0x1ACF 148 // 149 #define FORCED_SWITCH_PCI_BUS 0xe 150 #define FORCED_SWITCH_DEVICE_ID 0x10F5 151 #define FORCED_SWITCH_DEVICE_TYPE NV2080_CTRL_NVLINK_DEVICE_INFO_DEVICE_TYPE_SWITCH 152 153 // 154 // Structure representing per link information 155 // 156 typedef struct _def_knvlink_link 157 { 158 #if defined(INCLUDE_NVLINK_LIB) 159 160 // Reference to link object registered with core lib 161 nvlink_link *core_link; 162 163 // Nvlink connection information 164 KNVLINK_CONN_INFO remoteEndInfo; 165 166 // OS-specific data associated with the link 167 void *pOsInfo; 168 169 #endif 170 171 struct OBJGPU *pGpu; 172 NvU8 linkId; 173 NvBool bValid; 174 175 // IOCTRL id that this link is associated with 176 NvU32 ioctrlId; 177 178 // DLPL IP version for the link 179 NvU32 ipVerDlPl; 180 181 // PLL sharing information 182 NvU8 pllMasterLinkId; 183 NvU8 pllSlaveLinkId; 184 185 // RXDET per-lane status 186 NvU32 laneRxdetStatusMask; 187 188 TMR_EVENT *pTmrEvent; 189 190 } KNVLINK_RM_LINK, *PKNVLINK_RM_LINK; 191 192 typedef struct NVLINK_INBAND_CALLBACK 193 { 194 NvU32 messageType; 195 NV_STATUS (*pCallback)(NvU32 gpuInstance, NvU64 *pNotifyGfIdMask, 196 NV2080_CTRL_NVLINK_INBAND_RECEIVED_DATA_PARAMS *pMessage); 197 NvU32 wqItemFlags; 198 } NVLINK_INBAND_MSG_CALLBACK; 199 200 typedef struct 201 { 202 NvU8 linkId; 203 } NVLINK_ID, *PNVLINK_ID; 204 205 MAKE_LIST(FaultUpList, NVLINK_ID); 206 207 /*! 208 * KernelNvlink is a logical abstraction of the GPU Nvlink Engine. The 209 * Public API of the Nvlink Engine is exposed through this object, and 210 * any interfaces which do not manage the underlying Nvlink hardware 211 * can be managed by this object. 212 */ 213 214 // Private field names are wrapped in PRIVATE_FIELD, which does nothing for 215 // the matching C source file, but causes diagnostics to be issued if another 216 // source file references the field. 217 #ifdef NVOC_KERNEL_NVLINK_H_PRIVATE_ACCESS_ALLOWED 218 #define PRIVATE_FIELD(x) x 219 #else 220 #define PRIVATE_FIELD(x) NVOC_PRIVATE_FIELD(x) 221 #endif 222 223 struct KernelNvlink { 224 const struct NVOC_RTTI *__nvoc_rtti; 225 struct OBJENGSTATE __nvoc_base_OBJENGSTATE; 226 struct Object *__nvoc_pbase_Object; 227 struct OBJENGSTATE *__nvoc_pbase_OBJENGSTATE; 228 struct KernelNvlink *__nvoc_pbase_KernelNvlink; 229 NV_STATUS (*__knvlinkConstructEngine__)(struct OBJGPU *, struct KernelNvlink *, ENGDESCRIPTOR); 230 NV_STATUS (*__knvlinkStatePreInitLocked__)(struct OBJGPU *, struct KernelNvlink *); 231 NV_STATUS (*__knvlinkStateLoad__)(struct OBJGPU *, struct KernelNvlink *, NvU32); 232 NV_STATUS (*__knvlinkStatePostLoad__)(struct OBJGPU *, struct KernelNvlink *, NvU32); 233 NV_STATUS (*__knvlinkStateUnload__)(struct OBJGPU *, struct KernelNvlink *, NvU32); 234 NV_STATUS (*__knvlinkStatePostUnload__)(struct OBJGPU *, struct KernelNvlink *, NvU32); 235 NvBool (*__knvlinkIsPresent__)(struct OBJGPU *, struct KernelNvlink *); 236 NV_STATUS (*__knvlinkSetUniqueFabricBaseAddress__)(struct OBJGPU *, struct KernelNvlink *, NvU64); 237 void (*__knvlinkClearUniqueFabricBaseAddress__)(struct OBJGPU *, struct KernelNvlink *); 238 NV_STATUS (*__knvlinkSetUniqueFabricEgmBaseAddress__)(struct OBJGPU *, struct KernelNvlink *, NvU64); 239 void (*__knvlinkClearUniqueFabricEgmBaseAddress__)(struct OBJGPU *, struct KernelNvlink *); 240 NV_STATUS (*__knvlinkHandleFaultUpInterrupt__)(struct OBJGPU *, struct KernelNvlink *, NvU32); 241 NV_STATUS (*__knvlinkValidateFabricBaseAddress__)(struct OBJGPU *, struct KernelNvlink *, NvU64); 242 NV_STATUS (*__knvlinkValidateFabricEgmBaseAddress__)(struct OBJGPU *, struct KernelNvlink *, NvU64); 243 NvU32 (*__knvlinkGetConnectedLinksMask__)(struct OBJGPU *, struct KernelNvlink *); 244 NV_STATUS (*__knvlinkEnableLinksPostTopology__)(struct OBJGPU *, struct KernelNvlink *, NvU32); 245 NV_STATUS (*__knvlinkOverrideConfig__)(struct OBJGPU *, struct KernelNvlink *, NvU32); 246 NV_STATUS (*__knvlinkFilterBridgeLinks__)(struct OBJGPU *, struct KernelNvlink *); 247 NvU32 (*__knvlinkGetUniquePeerIdMask__)(struct OBJGPU *, struct KernelNvlink *); 248 NvU32 (*__knvlinkGetUniquePeerId__)(struct OBJGPU *, struct KernelNvlink *, struct OBJGPU *); 249 NV_STATUS (*__knvlinkRemoveMapping__)(struct OBJGPU *, struct KernelNvlink *, NvBool, NvU32, NvBool); 250 NV_STATUS (*__knvlinkGetP2POptimalCEs__)(struct OBJGPU *, struct KernelNvlink *, NvU32, NvU32 *, NvU32 *, NvU32 *, NvU32 *); 251 NV_STATUS (*__knvlinkConstructHal__)(struct OBJGPU *, struct KernelNvlink *); 252 void (*__knvlinkSetupPeerMapping__)(struct OBJGPU *, struct KernelNvlink *, struct OBJGPU *, NvU32); 253 NV_STATUS (*__knvlinkProgramLinkSpeed__)(struct OBJGPU *, struct KernelNvlink *); 254 NvBool (*__knvlinkPoweredUpForD3__)(struct OBJGPU *, struct KernelNvlink *); 255 NV_STATUS (*__knvlinkIsAliSupported__)(struct OBJGPU *, struct KernelNvlink *); 256 NV_STATUS (*__knvlinkPostSetupNvlinkPeer__)(struct OBJGPU *, struct KernelNvlink *); 257 NV_STATUS (*__knvlinkDiscoverPostRxDetLinks__)(struct OBJGPU *, struct KernelNvlink *, struct OBJGPU *); 258 NV_STATUS (*__knvlinkLogAliDebugMessages__)(struct OBJGPU *, struct KernelNvlink *); 259 void (*__knvlinkGetEffectivePeerLinkMask__)(struct OBJGPU *, struct KernelNvlink *, struct OBJGPU *, NvU32 *); 260 NvU32 (*__knvlinkGetNumLinksToBeReducedPerIoctrl__)(struct OBJGPU *, struct KernelNvlink *); 261 NvBool (*__knvlinkIsBandwidthModeOff__)(struct KernelNvlink *); 262 void (*__knvlinkDirectConnectCheck__)(struct OBJGPU *, struct KernelNvlink *); 263 NvBool (*__knvlinkIsGpuReducedNvlinkConfig__)(struct OBJGPU *, struct KernelNvlink *); 264 NvBool (*__knvlinkIsFloorSweepingNeeded__)(struct OBJGPU *, struct KernelNvlink *, NvU32, NvU32); 265 NV_STATUS (*__knvlinkStateInitLocked__)(POBJGPU, struct KernelNvlink *); 266 NV_STATUS (*__knvlinkStatePreLoad__)(POBJGPU, struct KernelNvlink *, NvU32); 267 void (*__knvlinkStateDestroy__)(POBJGPU, struct KernelNvlink *); 268 NV_STATUS (*__knvlinkStatePreUnload__)(POBJGPU, struct KernelNvlink *, NvU32); 269 NV_STATUS (*__knvlinkStateInitUnlocked__)(POBJGPU, struct KernelNvlink *); 270 void (*__knvlinkInitMissing__)(POBJGPU, struct KernelNvlink *); 271 NV_STATUS (*__knvlinkStatePreInitUnlocked__)(POBJGPU, struct KernelNvlink *); 272 NvBool PDB_PROP_KNVLINK_ENABLED; 273 NvBool PDB_PROP_KNVLINK_L2_POWER_STATE_ENABLED; 274 NvBool PDB_PROP_KNVLINK_UNSET_NVLINK_PEER_SUPPORTED; 275 NvBool PDB_PROP_KNVLINK_CONFIG_REQUIRE_INITIALIZED_LINKS_CHECK; 276 NvBool PDB_PROP_KNVLINK_LANE_SHUTDOWN_ENABLED; 277 NvBool PDB_PROP_KNVLINK_LANE_SHUTDOWN_ON_UNLOAD; 278 NvBool PDB_PROP_KNVLINK_LINKRESET_AFTER_SHUTDOWN; 279 NvBool PDB_PROP_KNVLINK_BUG2274645_RESET_FOR_RTD3_FGC6; 280 NvBool PDB_PROP_KNVLINK_L2_POWER_STATE_FOR_LONG_IDLE; 281 NvBool PDB_PROP_KNVLINK_WAR_BUG_3471679_PEERID_FILTERING; 282 NvBool PDB_PROP_KNVLINK_MINION_FORCE_ALI_TRAINING; 283 NvBool PDB_PROP_KNVLINK_MINION_FORCE_NON_ALI_TRAINING; 284 NvBool PDB_PROP_KNVLINK_MINION_GFW_BOOT; 285 NvBool PDB_PROP_KNVLINK_SYSMEM_SUPPORT_ENABLED; 286 NvBool PDB_PROP_KNVLINK_FORCED_LOOPBACK_ON_SWITCH_MODE_ENABLED; 287 struct KernelIoctrl *PRIVATE_FIELD(pKernelIoctrl)[3]; 288 NvU32 PRIVATE_FIELD(ioctrlMask); 289 NvU32 PRIVATE_FIELD(ipVerNvlink); 290 NvU8 PRIVATE_FIELD(ioctrlNumEntries); 291 NvU32 PRIVATE_FIELD(ioctrlSize); 292 NvU32 PRIVATE_FIELD(registryControl); 293 NvU32 PRIVATE_FIELD(minionControl); 294 NvU32 PRIVATE_FIELD(verboseMask); 295 NvU32 *PRIVATE_FIELD(pLinkConnection); 296 NvBool PRIVATE_FIELD(bChiplibConfig); 297 NvBool PRIVATE_FIELD(bRegistryLinkOverride); 298 NvU32 PRIVATE_FIELD(registryLinkMask); 299 NvBool PRIVATE_FIELD(bOverrideComputePeerMode); 300 NvU32 PRIVATE_FIELD(discoveredLinks); 301 NvU32 PRIVATE_FIELD(vbiosDisabledLinkMask); 302 NvU32 PRIVATE_FIELD(regkeyDisabledLinksMask); 303 NvU32 PRIVATE_FIELD(initDisabledLinksMask); 304 NvU32 PRIVATE_FIELD(connectedLinksMask); 305 NvU32 PRIVATE_FIELD(bridgeSensableLinks); 306 NvU32 PRIVATE_FIELD(bridgedLinks); 307 NvU32 PRIVATE_FIELD(enabledLinks); 308 FaultUpList PRIVATE_FIELD(faultUpLinks); 309 NvU32 PRIVATE_FIELD(initializedLinks); 310 KNVLINK_RM_LINK PRIVATE_FIELD(nvlinkLinks)[18]; 311 NvBool PRIVATE_FIELD(bIsGpuDegraded); 312 NvU32 PRIVATE_FIELD(postRxDetLinkMask); 313 NvU32 PRIVATE_FIELD(disconnectedLinkMask); 314 NvU32 PRIVATE_FIELD(sysmemLinkMask); 315 NvU32 PRIVATE_FIELD(peerLinkMasks)[32]; 316 NvU32 PRIVATE_FIELD(forcedSysmemDeviceType); 317 nvlink_device *PRIVATE_FIELD(pNvlinkDev); 318 NvU32 PRIVATE_FIELD(deviceLockRefcount); 319 char *PRIVATE_FIELD(driverName); 320 char *PRIVATE_FIELD(deviceName); 321 NvBool PRIVATE_FIELD(bVerifTrainingEnable); 322 NvBool PRIVATE_FIELD(bL2Entry); 323 NvBool PRIVATE_FIELD(bSkipLinkTraining); 324 NvBool PRIVATE_FIELD(bForceAutoconfig); 325 NvBool PRIVATE_FIELD(bForceEnableCoreLibRtlsims); 326 NvBool PRIVATE_FIELD(bEnableTrainingAtLoad); 327 NvBool PRIVATE_FIELD(bEnableSafeModeAtLoad); 328 NvBool PRIVATE_FIELD(bEnableAli); 329 NvBool PRIVATE_FIELD(bFloorSwept); 330 NvBool PRIVATE_FIELD(bLinkTrainingDebugSpew); 331 NvBool PRIVATE_FIELD(bDisableL2Mode); 332 NvU32 PRIVATE_FIELD(nvlinkLinkSpeed); 333 NvU32 PRIVATE_FIELD(errorRecoveries)[18]; 334 NvBool PRIVATE_FIELD(bNvswitchProxy); 335 NvU64 PRIVATE_FIELD(fabricBaseAddr); 336 NvU64 PRIVATE_FIELD(fabricEgmBaseAddr); 337 }; 338 339 struct KernelNvlink_PRIVATE { 340 const struct NVOC_RTTI *__nvoc_rtti; 341 struct OBJENGSTATE __nvoc_base_OBJENGSTATE; 342 struct Object *__nvoc_pbase_Object; 343 struct OBJENGSTATE *__nvoc_pbase_OBJENGSTATE; 344 struct KernelNvlink *__nvoc_pbase_KernelNvlink; 345 NV_STATUS (*__knvlinkConstructEngine__)(struct OBJGPU *, struct KernelNvlink *, ENGDESCRIPTOR); 346 NV_STATUS (*__knvlinkStatePreInitLocked__)(struct OBJGPU *, struct KernelNvlink *); 347 NV_STATUS (*__knvlinkStateLoad__)(struct OBJGPU *, struct KernelNvlink *, NvU32); 348 NV_STATUS (*__knvlinkStatePostLoad__)(struct OBJGPU *, struct KernelNvlink *, NvU32); 349 NV_STATUS (*__knvlinkStateUnload__)(struct OBJGPU *, struct KernelNvlink *, NvU32); 350 NV_STATUS (*__knvlinkStatePostUnload__)(struct OBJGPU *, struct KernelNvlink *, NvU32); 351 NvBool (*__knvlinkIsPresent__)(struct OBJGPU *, struct KernelNvlink *); 352 NV_STATUS (*__knvlinkSetUniqueFabricBaseAddress__)(struct OBJGPU *, struct KernelNvlink *, NvU64); 353 void (*__knvlinkClearUniqueFabricBaseAddress__)(struct OBJGPU *, struct KernelNvlink *); 354 NV_STATUS (*__knvlinkSetUniqueFabricEgmBaseAddress__)(struct OBJGPU *, struct KernelNvlink *, NvU64); 355 void (*__knvlinkClearUniqueFabricEgmBaseAddress__)(struct OBJGPU *, struct KernelNvlink *); 356 NV_STATUS (*__knvlinkHandleFaultUpInterrupt__)(struct OBJGPU *, struct KernelNvlink *, NvU32); 357 NV_STATUS (*__knvlinkValidateFabricBaseAddress__)(struct OBJGPU *, struct KernelNvlink *, NvU64); 358 NV_STATUS (*__knvlinkValidateFabricEgmBaseAddress__)(struct OBJGPU *, struct KernelNvlink *, NvU64); 359 NvU32 (*__knvlinkGetConnectedLinksMask__)(struct OBJGPU *, struct KernelNvlink *); 360 NV_STATUS (*__knvlinkEnableLinksPostTopology__)(struct OBJGPU *, struct KernelNvlink *, NvU32); 361 NV_STATUS (*__knvlinkOverrideConfig__)(struct OBJGPU *, struct KernelNvlink *, NvU32); 362 NV_STATUS (*__knvlinkFilterBridgeLinks__)(struct OBJGPU *, struct KernelNvlink *); 363 NvU32 (*__knvlinkGetUniquePeerIdMask__)(struct OBJGPU *, struct KernelNvlink *); 364 NvU32 (*__knvlinkGetUniquePeerId__)(struct OBJGPU *, struct KernelNvlink *, struct OBJGPU *); 365 NV_STATUS (*__knvlinkRemoveMapping__)(struct OBJGPU *, struct KernelNvlink *, NvBool, NvU32, NvBool); 366 NV_STATUS (*__knvlinkGetP2POptimalCEs__)(struct OBJGPU *, struct KernelNvlink *, NvU32, NvU32 *, NvU32 *, NvU32 *, NvU32 *); 367 NV_STATUS (*__knvlinkConstructHal__)(struct OBJGPU *, struct KernelNvlink *); 368 void (*__knvlinkSetupPeerMapping__)(struct OBJGPU *, struct KernelNvlink *, struct OBJGPU *, NvU32); 369 NV_STATUS (*__knvlinkProgramLinkSpeed__)(struct OBJGPU *, struct KernelNvlink *); 370 NvBool (*__knvlinkPoweredUpForD3__)(struct OBJGPU *, struct KernelNvlink *); 371 NV_STATUS (*__knvlinkIsAliSupported__)(struct OBJGPU *, struct KernelNvlink *); 372 NV_STATUS (*__knvlinkPostSetupNvlinkPeer__)(struct OBJGPU *, struct KernelNvlink *); 373 NV_STATUS (*__knvlinkDiscoverPostRxDetLinks__)(struct OBJGPU *, struct KernelNvlink *, struct OBJGPU *); 374 NV_STATUS (*__knvlinkLogAliDebugMessages__)(struct OBJGPU *, struct KernelNvlink *); 375 void (*__knvlinkGetEffectivePeerLinkMask__)(struct OBJGPU *, struct KernelNvlink *, struct OBJGPU *, NvU32 *); 376 NvU32 (*__knvlinkGetNumLinksToBeReducedPerIoctrl__)(struct OBJGPU *, struct KernelNvlink *); 377 NvBool (*__knvlinkIsBandwidthModeOff__)(struct KernelNvlink *); 378 void (*__knvlinkDirectConnectCheck__)(struct OBJGPU *, struct KernelNvlink *); 379 NvBool (*__knvlinkIsGpuReducedNvlinkConfig__)(struct OBJGPU *, struct KernelNvlink *); 380 NvBool (*__knvlinkIsFloorSweepingNeeded__)(struct OBJGPU *, struct KernelNvlink *, NvU32, NvU32); 381 NV_STATUS (*__knvlinkStateInitLocked__)(POBJGPU, struct KernelNvlink *); 382 NV_STATUS (*__knvlinkStatePreLoad__)(POBJGPU, struct KernelNvlink *, NvU32); 383 void (*__knvlinkStateDestroy__)(POBJGPU, struct KernelNvlink *); 384 NV_STATUS (*__knvlinkStatePreUnload__)(POBJGPU, struct KernelNvlink *, NvU32); 385 NV_STATUS (*__knvlinkStateInitUnlocked__)(POBJGPU, struct KernelNvlink *); 386 void (*__knvlinkInitMissing__)(POBJGPU, struct KernelNvlink *); 387 NV_STATUS (*__knvlinkStatePreInitUnlocked__)(POBJGPU, struct KernelNvlink *); 388 NvBool PDB_PROP_KNVLINK_ENABLED; 389 NvBool PDB_PROP_KNVLINK_L2_POWER_STATE_ENABLED; 390 NvBool PDB_PROP_KNVLINK_UNSET_NVLINK_PEER_SUPPORTED; 391 NvBool PDB_PROP_KNVLINK_CONFIG_REQUIRE_INITIALIZED_LINKS_CHECK; 392 NvBool PDB_PROP_KNVLINK_LANE_SHUTDOWN_ENABLED; 393 NvBool PDB_PROP_KNVLINK_LANE_SHUTDOWN_ON_UNLOAD; 394 NvBool PDB_PROP_KNVLINK_LINKRESET_AFTER_SHUTDOWN; 395 NvBool PDB_PROP_KNVLINK_BUG2274645_RESET_FOR_RTD3_FGC6; 396 NvBool PDB_PROP_KNVLINK_L2_POWER_STATE_FOR_LONG_IDLE; 397 NvBool PDB_PROP_KNVLINK_WAR_BUG_3471679_PEERID_FILTERING; 398 NvBool PDB_PROP_KNVLINK_MINION_FORCE_ALI_TRAINING; 399 NvBool PDB_PROP_KNVLINK_MINION_FORCE_NON_ALI_TRAINING; 400 NvBool PDB_PROP_KNVLINK_MINION_GFW_BOOT; 401 NvBool PDB_PROP_KNVLINK_SYSMEM_SUPPORT_ENABLED; 402 NvBool PDB_PROP_KNVLINK_FORCED_LOOPBACK_ON_SWITCH_MODE_ENABLED; 403 struct KernelIoctrl *pKernelIoctrl[3]; 404 NvU32 ioctrlMask; 405 NvU32 ipVerNvlink; 406 NvU8 ioctrlNumEntries; 407 NvU32 ioctrlSize; 408 NvU32 registryControl; 409 NvU32 minionControl; 410 NvU32 verboseMask; 411 NvU32 *pLinkConnection; 412 NvBool bChiplibConfig; 413 NvBool bRegistryLinkOverride; 414 NvU32 registryLinkMask; 415 NvBool bOverrideComputePeerMode; 416 NvU32 discoveredLinks; 417 NvU32 vbiosDisabledLinkMask; 418 NvU32 regkeyDisabledLinksMask; 419 NvU32 initDisabledLinksMask; 420 NvU32 connectedLinksMask; 421 NvU32 bridgeSensableLinks; 422 NvU32 bridgedLinks; 423 NvU32 enabledLinks; 424 FaultUpList faultUpLinks; 425 NvU32 initializedLinks; 426 KNVLINK_RM_LINK nvlinkLinks[18]; 427 NvBool bIsGpuDegraded; 428 NvU32 postRxDetLinkMask; 429 NvU32 disconnectedLinkMask; 430 NvU32 sysmemLinkMask; 431 NvU32 peerLinkMasks[32]; 432 NvU32 forcedSysmemDeviceType; 433 nvlink_device *pNvlinkDev; 434 NvU32 deviceLockRefcount; 435 char *driverName; 436 char *deviceName; 437 NvBool bVerifTrainingEnable; 438 NvBool bL2Entry; 439 NvBool bSkipLinkTraining; 440 NvBool bForceAutoconfig; 441 NvBool bForceEnableCoreLibRtlsims; 442 NvBool bEnableTrainingAtLoad; 443 NvBool bEnableSafeModeAtLoad; 444 NvBool bEnableAli; 445 NvBool bFloorSwept; 446 NvBool bLinkTrainingDebugSpew; 447 NvBool bDisableL2Mode; 448 NvU32 nvlinkLinkSpeed; 449 NvU32 errorRecoveries[18]; 450 NvBool bNvswitchProxy; 451 NvU64 fabricBaseAddr; 452 NvU64 fabricEgmBaseAddr; 453 }; 454 455 #ifndef __NVOC_CLASS_KernelNvlink_TYPEDEF__ 456 #define __NVOC_CLASS_KernelNvlink_TYPEDEF__ 457 typedef struct KernelNvlink KernelNvlink; 458 #endif /* __NVOC_CLASS_KernelNvlink_TYPEDEF__ */ 459 460 #ifndef __nvoc_class_id_KernelNvlink 461 #define __nvoc_class_id_KernelNvlink 0xce6818 462 #endif /* __nvoc_class_id_KernelNvlink */ 463 464 extern const struct NVOC_CLASS_DEF __nvoc_class_def_KernelNvlink; 465 466 #define __staticCast_KernelNvlink(pThis) \ 467 ((pThis)->__nvoc_pbase_KernelNvlink) 468 469 #ifdef __nvoc_kernel_nvlink_h_disabled 470 #define __dynamicCast_KernelNvlink(pThis) ((KernelNvlink*)NULL) 471 #else //__nvoc_kernel_nvlink_h_disabled 472 #define __dynamicCast_KernelNvlink(pThis) \ 473 ((KernelNvlink*)__nvoc_dynamicCast(staticCast((pThis), Dynamic), classInfo(KernelNvlink))) 474 #endif //__nvoc_kernel_nvlink_h_disabled 475 476 #define PDB_PROP_KNVLINK_MINION_GFW_BOOT_BASE_CAST 477 #define PDB_PROP_KNVLINK_MINION_GFW_BOOT_BASE_NAME PDB_PROP_KNVLINK_MINION_GFW_BOOT 478 #define PDB_PROP_KNVLINK_CONFIG_REQUIRE_INITIALIZED_LINKS_CHECK_BASE_CAST 479 #define PDB_PROP_KNVLINK_CONFIG_REQUIRE_INITIALIZED_LINKS_CHECK_BASE_NAME PDB_PROP_KNVLINK_CONFIG_REQUIRE_INITIALIZED_LINKS_CHECK 480 #define PDB_PROP_KNVLINK_LANE_SHUTDOWN_ENABLED_BASE_CAST 481 #define PDB_PROP_KNVLINK_LANE_SHUTDOWN_ENABLED_BASE_NAME PDB_PROP_KNVLINK_LANE_SHUTDOWN_ENABLED 482 #define PDB_PROP_KNVLINK_SYSMEM_SUPPORT_ENABLED_BASE_CAST 483 #define PDB_PROP_KNVLINK_SYSMEM_SUPPORT_ENABLED_BASE_NAME PDB_PROP_KNVLINK_SYSMEM_SUPPORT_ENABLED 484 #define PDB_PROP_KNVLINK_MINION_FORCE_ALI_TRAINING_BASE_CAST 485 #define PDB_PROP_KNVLINK_MINION_FORCE_ALI_TRAINING_BASE_NAME PDB_PROP_KNVLINK_MINION_FORCE_ALI_TRAINING 486 #define PDB_PROP_KNVLINK_ENABLED_BASE_CAST 487 #define PDB_PROP_KNVLINK_ENABLED_BASE_NAME PDB_PROP_KNVLINK_ENABLED 488 #define PDB_PROP_KNVLINK_UNSET_NVLINK_PEER_SUPPORTED_BASE_CAST 489 #define PDB_PROP_KNVLINK_UNSET_NVLINK_PEER_SUPPORTED_BASE_NAME PDB_PROP_KNVLINK_UNSET_NVLINK_PEER_SUPPORTED 490 #define PDB_PROP_KNVLINK_MINION_FORCE_NON_ALI_TRAINING_BASE_CAST 491 #define PDB_PROP_KNVLINK_MINION_FORCE_NON_ALI_TRAINING_BASE_NAME PDB_PROP_KNVLINK_MINION_FORCE_NON_ALI_TRAINING 492 #define PDB_PROP_KNVLINK_L2_POWER_STATE_ENABLED_BASE_CAST 493 #define PDB_PROP_KNVLINK_L2_POWER_STATE_ENABLED_BASE_NAME PDB_PROP_KNVLINK_L2_POWER_STATE_ENABLED 494 #define PDB_PROP_KNVLINK_IS_MISSING_BASE_CAST __nvoc_base_OBJENGSTATE. 495 #define PDB_PROP_KNVLINK_IS_MISSING_BASE_NAME PDB_PROP_ENGSTATE_IS_MISSING 496 #define PDB_PROP_KNVLINK_WAR_BUG_3471679_PEERID_FILTERING_BASE_CAST 497 #define PDB_PROP_KNVLINK_WAR_BUG_3471679_PEERID_FILTERING_BASE_NAME PDB_PROP_KNVLINK_WAR_BUG_3471679_PEERID_FILTERING 498 #define PDB_PROP_KNVLINK_BUG2274645_RESET_FOR_RTD3_FGC6_BASE_CAST 499 #define PDB_PROP_KNVLINK_BUG2274645_RESET_FOR_RTD3_FGC6_BASE_NAME PDB_PROP_KNVLINK_BUG2274645_RESET_FOR_RTD3_FGC6 500 #define PDB_PROP_KNVLINK_LANE_SHUTDOWN_ON_UNLOAD_BASE_CAST 501 #define PDB_PROP_KNVLINK_LANE_SHUTDOWN_ON_UNLOAD_BASE_NAME PDB_PROP_KNVLINK_LANE_SHUTDOWN_ON_UNLOAD 502 #define PDB_PROP_KNVLINK_FORCED_LOOPBACK_ON_SWITCH_MODE_ENABLED_BASE_CAST 503 #define PDB_PROP_KNVLINK_FORCED_LOOPBACK_ON_SWITCH_MODE_ENABLED_BASE_NAME PDB_PROP_KNVLINK_FORCED_LOOPBACK_ON_SWITCH_MODE_ENABLED 504 #define PDB_PROP_KNVLINK_L2_POWER_STATE_FOR_LONG_IDLE_BASE_CAST 505 #define PDB_PROP_KNVLINK_L2_POWER_STATE_FOR_LONG_IDLE_BASE_NAME PDB_PROP_KNVLINK_L2_POWER_STATE_FOR_LONG_IDLE 506 #define PDB_PROP_KNVLINK_LINKRESET_AFTER_SHUTDOWN_BASE_CAST 507 #define PDB_PROP_KNVLINK_LINKRESET_AFTER_SHUTDOWN_BASE_NAME PDB_PROP_KNVLINK_LINKRESET_AFTER_SHUTDOWN 508 509 NV_STATUS __nvoc_objCreateDynamic_KernelNvlink(KernelNvlink**, Dynamic*, NvU32, va_list); 510 511 NV_STATUS __nvoc_objCreate_KernelNvlink(KernelNvlink**, Dynamic*, NvU32); 512 #define __objCreate_KernelNvlink(ppNewObj, pParent, createFlags) \ 513 __nvoc_objCreate_KernelNvlink((ppNewObj), staticCast((pParent), Dynamic), (createFlags)) 514 515 #define knvlinkConstructEngine(arg0, arg1, arg2) knvlinkConstructEngine_DISPATCH(arg0, arg1, arg2) 516 #define knvlinkStatePreInitLocked(arg0, arg1) knvlinkStatePreInitLocked_DISPATCH(arg0, arg1) 517 #define knvlinkStateLoad(arg0, arg1, arg2) knvlinkStateLoad_DISPATCH(arg0, arg1, arg2) 518 #define knvlinkStatePostLoad(arg0, arg1, arg2) knvlinkStatePostLoad_DISPATCH(arg0, arg1, arg2) 519 #define knvlinkStateUnload(arg0, arg1, arg2) knvlinkStateUnload_DISPATCH(arg0, arg1, arg2) 520 #define knvlinkStatePostUnload(arg0, arg1, arg2) knvlinkStatePostUnload_DISPATCH(arg0, arg1, arg2) 521 #define knvlinkIsPresent(arg0, arg1) knvlinkIsPresent_DISPATCH(arg0, arg1) 522 #define knvlinkSetUniqueFabricBaseAddress(pGpu, pKernelNvlink, arg0) knvlinkSetUniqueFabricBaseAddress_DISPATCH(pGpu, pKernelNvlink, arg0) 523 #define knvlinkSetUniqueFabricBaseAddress_HAL(pGpu, pKernelNvlink, arg0) knvlinkSetUniqueFabricBaseAddress_DISPATCH(pGpu, pKernelNvlink, arg0) 524 #define knvlinkClearUniqueFabricBaseAddress(pGpu, pKernelNvlink) knvlinkClearUniqueFabricBaseAddress_DISPATCH(pGpu, pKernelNvlink) 525 #define knvlinkClearUniqueFabricBaseAddress_HAL(pGpu, pKernelNvlink) knvlinkClearUniqueFabricBaseAddress_DISPATCH(pGpu, pKernelNvlink) 526 #define knvlinkSetUniqueFabricEgmBaseAddress(pGpu, pKernelNvlink, arg0) knvlinkSetUniqueFabricEgmBaseAddress_DISPATCH(pGpu, pKernelNvlink, arg0) 527 #define knvlinkSetUniqueFabricEgmBaseAddress_HAL(pGpu, pKernelNvlink, arg0) knvlinkSetUniqueFabricEgmBaseAddress_DISPATCH(pGpu, pKernelNvlink, arg0) 528 #define knvlinkClearUniqueFabricEgmBaseAddress(pGpu, pKernelNvlink) knvlinkClearUniqueFabricEgmBaseAddress_DISPATCH(pGpu, pKernelNvlink) 529 #define knvlinkClearUniqueFabricEgmBaseAddress_HAL(pGpu, pKernelNvlink) knvlinkClearUniqueFabricEgmBaseAddress_DISPATCH(pGpu, pKernelNvlink) 530 #define knvlinkHandleFaultUpInterrupt(pGpu, pKernelNvlink, arg0) knvlinkHandleFaultUpInterrupt_DISPATCH(pGpu, pKernelNvlink, arg0) 531 #define knvlinkHandleFaultUpInterrupt_HAL(pGpu, pKernelNvlink, arg0) knvlinkHandleFaultUpInterrupt_DISPATCH(pGpu, pKernelNvlink, arg0) 532 #define knvlinkValidateFabricBaseAddress(pGpu, pKernelNvlink, arg0) knvlinkValidateFabricBaseAddress_DISPATCH(pGpu, pKernelNvlink, arg0) 533 #define knvlinkValidateFabricBaseAddress_HAL(pGpu, pKernelNvlink, arg0) knvlinkValidateFabricBaseAddress_DISPATCH(pGpu, pKernelNvlink, arg0) 534 #define knvlinkValidateFabricEgmBaseAddress(pGpu, pKernelNvlink, arg0) knvlinkValidateFabricEgmBaseAddress_DISPATCH(pGpu, pKernelNvlink, arg0) 535 #define knvlinkValidateFabricEgmBaseAddress_HAL(pGpu, pKernelNvlink, arg0) knvlinkValidateFabricEgmBaseAddress_DISPATCH(pGpu, pKernelNvlink, arg0) 536 #define knvlinkGetConnectedLinksMask(pGpu, pKernelNvlink) knvlinkGetConnectedLinksMask_DISPATCH(pGpu, pKernelNvlink) 537 #define knvlinkGetConnectedLinksMask_HAL(pGpu, pKernelNvlink) knvlinkGetConnectedLinksMask_DISPATCH(pGpu, pKernelNvlink) 538 #define knvlinkEnableLinksPostTopology(pGpu, pKernelNvlink, arg0) knvlinkEnableLinksPostTopology_DISPATCH(pGpu, pKernelNvlink, arg0) 539 #define knvlinkEnableLinksPostTopology_HAL(pGpu, pKernelNvlink, arg0) knvlinkEnableLinksPostTopology_DISPATCH(pGpu, pKernelNvlink, arg0) 540 #define knvlinkOverrideConfig(pGpu, pKernelNvlink, arg0) knvlinkOverrideConfig_DISPATCH(pGpu, pKernelNvlink, arg0) 541 #define knvlinkOverrideConfig_HAL(pGpu, pKernelNvlink, arg0) knvlinkOverrideConfig_DISPATCH(pGpu, pKernelNvlink, arg0) 542 #define knvlinkFilterBridgeLinks(pGpu, pKernelNvlink) knvlinkFilterBridgeLinks_DISPATCH(pGpu, pKernelNvlink) 543 #define knvlinkFilterBridgeLinks_HAL(pGpu, pKernelNvlink) knvlinkFilterBridgeLinks_DISPATCH(pGpu, pKernelNvlink) 544 #define knvlinkGetUniquePeerIdMask(pGpu, pKernelNvlink) knvlinkGetUniquePeerIdMask_DISPATCH(pGpu, pKernelNvlink) 545 #define knvlinkGetUniquePeerIdMask_HAL(pGpu, pKernelNvlink) knvlinkGetUniquePeerIdMask_DISPATCH(pGpu, pKernelNvlink) 546 #define knvlinkGetUniquePeerId(pGpu, pKernelNvlink, pRemoteGpu) knvlinkGetUniquePeerId_DISPATCH(pGpu, pKernelNvlink, pRemoteGpu) 547 #define knvlinkGetUniquePeerId_HAL(pGpu, pKernelNvlink, pRemoteGpu) knvlinkGetUniquePeerId_DISPATCH(pGpu, pKernelNvlink, pRemoteGpu) 548 #define knvlinkRemoveMapping(pGpu, pKernelNvlink, bAllMapping, peerMask, bL2Entry) knvlinkRemoveMapping_DISPATCH(pGpu, pKernelNvlink, bAllMapping, peerMask, bL2Entry) 549 #define knvlinkRemoveMapping_HAL(pGpu, pKernelNvlink, bAllMapping, peerMask, bL2Entry) knvlinkRemoveMapping_DISPATCH(pGpu, pKernelNvlink, bAllMapping, peerMask, bL2Entry) 550 #define knvlinkGetP2POptimalCEs(pGpu, pKernelNvlink, arg0, arg1, arg2, arg3, arg4) knvlinkGetP2POptimalCEs_DISPATCH(pGpu, pKernelNvlink, arg0, arg1, arg2, arg3, arg4) 551 #define knvlinkGetP2POptimalCEs_HAL(pGpu, pKernelNvlink, arg0, arg1, arg2, arg3, arg4) knvlinkGetP2POptimalCEs_DISPATCH(pGpu, pKernelNvlink, arg0, arg1, arg2, arg3, arg4) 552 #define knvlinkConstructHal(pGpu, pKernelNvlink) knvlinkConstructHal_DISPATCH(pGpu, pKernelNvlink) 553 #define knvlinkConstructHal_HAL(pGpu, pKernelNvlink) knvlinkConstructHal_DISPATCH(pGpu, pKernelNvlink) 554 #define knvlinkSetupPeerMapping(pGpu, pKernelNvlink, pRemoteGpu, peerId) knvlinkSetupPeerMapping_DISPATCH(pGpu, pKernelNvlink, pRemoteGpu, peerId) 555 #define knvlinkSetupPeerMapping_HAL(pGpu, pKernelNvlink, pRemoteGpu, peerId) knvlinkSetupPeerMapping_DISPATCH(pGpu, pKernelNvlink, pRemoteGpu, peerId) 556 #define knvlinkProgramLinkSpeed(pGpu, pKernelNvlink) knvlinkProgramLinkSpeed_DISPATCH(pGpu, pKernelNvlink) 557 #define knvlinkProgramLinkSpeed_HAL(pGpu, pKernelNvlink) knvlinkProgramLinkSpeed_DISPATCH(pGpu, pKernelNvlink) 558 #define knvlinkPoweredUpForD3(pGpu, pKernelNvlink) knvlinkPoweredUpForD3_DISPATCH(pGpu, pKernelNvlink) 559 #define knvlinkPoweredUpForD3_HAL(pGpu, pKernelNvlink) knvlinkPoweredUpForD3_DISPATCH(pGpu, pKernelNvlink) 560 #define knvlinkIsAliSupported(pGpu, pKernelNvlink) knvlinkIsAliSupported_DISPATCH(pGpu, pKernelNvlink) 561 #define knvlinkIsAliSupported_HAL(pGpu, pKernelNvlink) knvlinkIsAliSupported_DISPATCH(pGpu, pKernelNvlink) 562 #define knvlinkPostSetupNvlinkPeer(pGpu, pKernelNvlink) knvlinkPostSetupNvlinkPeer_DISPATCH(pGpu, pKernelNvlink) 563 #define knvlinkPostSetupNvlinkPeer_HAL(pGpu, pKernelNvlink) knvlinkPostSetupNvlinkPeer_DISPATCH(pGpu, pKernelNvlink) 564 #define knvlinkDiscoverPostRxDetLinks(pGpu, pKernelNvlink, pPeerGpu) knvlinkDiscoverPostRxDetLinks_DISPATCH(pGpu, pKernelNvlink, pPeerGpu) 565 #define knvlinkDiscoverPostRxDetLinks_HAL(pGpu, pKernelNvlink, pPeerGpu) knvlinkDiscoverPostRxDetLinks_DISPATCH(pGpu, pKernelNvlink, pPeerGpu) 566 #define knvlinkLogAliDebugMessages(pGpu, pKernelNvlink) knvlinkLogAliDebugMessages_DISPATCH(pGpu, pKernelNvlink) 567 #define knvlinkLogAliDebugMessages_HAL(pGpu, pKernelNvlink) knvlinkLogAliDebugMessages_DISPATCH(pGpu, pKernelNvlink) 568 #define knvlinkGetEffectivePeerLinkMask(pGpu, pKernelNvlink, pRemoteGpu, pPeerLinkMask) knvlinkGetEffectivePeerLinkMask_DISPATCH(pGpu, pKernelNvlink, pRemoteGpu, pPeerLinkMask) 569 #define knvlinkGetEffectivePeerLinkMask_HAL(pGpu, pKernelNvlink, pRemoteGpu, pPeerLinkMask) knvlinkGetEffectivePeerLinkMask_DISPATCH(pGpu, pKernelNvlink, pRemoteGpu, pPeerLinkMask) 570 #define knvlinkGetNumLinksToBeReducedPerIoctrl(pGpu, pKernelNvlink) knvlinkGetNumLinksToBeReducedPerIoctrl_DISPATCH(pGpu, pKernelNvlink) 571 #define knvlinkGetNumLinksToBeReducedPerIoctrl_HAL(pGpu, pKernelNvlink) knvlinkGetNumLinksToBeReducedPerIoctrl_DISPATCH(pGpu, pKernelNvlink) 572 #define knvlinkIsBandwidthModeOff(pKernelNvlink) knvlinkIsBandwidthModeOff_DISPATCH(pKernelNvlink) 573 #define knvlinkIsBandwidthModeOff_HAL(pKernelNvlink) knvlinkIsBandwidthModeOff_DISPATCH(pKernelNvlink) 574 #define knvlinkDirectConnectCheck(pGpu, pKernelNvlink) knvlinkDirectConnectCheck_DISPATCH(pGpu, pKernelNvlink) 575 #define knvlinkDirectConnectCheck_HAL(pGpu, pKernelNvlink) knvlinkDirectConnectCheck_DISPATCH(pGpu, pKernelNvlink) 576 #define knvlinkIsGpuReducedNvlinkConfig(pGpu, pKernelNvlink) knvlinkIsGpuReducedNvlinkConfig_DISPATCH(pGpu, pKernelNvlink) 577 #define knvlinkIsGpuReducedNvlinkConfig_HAL(pGpu, pKernelNvlink) knvlinkIsGpuReducedNvlinkConfig_DISPATCH(pGpu, pKernelNvlink) 578 #define knvlinkIsFloorSweepingNeeded(pGpu, pKernelNvlink, numActiveLinksPerIoctrl, numLinksPerIoctrl) knvlinkIsFloorSweepingNeeded_DISPATCH(pGpu, pKernelNvlink, numActiveLinksPerIoctrl, numLinksPerIoctrl) 579 #define knvlinkIsFloorSweepingNeeded_HAL(pGpu, pKernelNvlink, numActiveLinksPerIoctrl, numLinksPerIoctrl) knvlinkIsFloorSweepingNeeded_DISPATCH(pGpu, pKernelNvlink, numActiveLinksPerIoctrl, numLinksPerIoctrl) 580 #define knvlinkStateInitLocked(pGpu, pEngstate) knvlinkStateInitLocked_DISPATCH(pGpu, pEngstate) 581 #define knvlinkStatePreLoad(pGpu, pEngstate, arg0) knvlinkStatePreLoad_DISPATCH(pGpu, pEngstate, arg0) 582 #define knvlinkStateDestroy(pGpu, pEngstate) knvlinkStateDestroy_DISPATCH(pGpu, pEngstate) 583 #define knvlinkStatePreUnload(pGpu, pEngstate, arg0) knvlinkStatePreUnload_DISPATCH(pGpu, pEngstate, arg0) 584 #define knvlinkStateInitUnlocked(pGpu, pEngstate) knvlinkStateInitUnlocked_DISPATCH(pGpu, pEngstate) 585 #define knvlinkInitMissing(pGpu, pEngstate) knvlinkInitMissing_DISPATCH(pGpu, pEngstate) 586 #define knvlinkStatePreInitUnlocked(pGpu, pEngstate) knvlinkStatePreInitUnlocked_DISPATCH(pGpu, pEngstate) 587 NvBool knvlinkIsForcedConfig_IMPL(struct OBJGPU *arg0, struct KernelNvlink *arg1); 588 589 590 #ifdef __nvoc_kernel_nvlink_h_disabled 591 static inline NvBool knvlinkIsForcedConfig(struct OBJGPU *arg0, struct KernelNvlink *arg1) { 592 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 593 return NV_FALSE; 594 } 595 #else //__nvoc_kernel_nvlink_h_disabled 596 #define knvlinkIsForcedConfig(arg0, arg1) knvlinkIsForcedConfig_IMPL(arg0, arg1) 597 #endif //__nvoc_kernel_nvlink_h_disabled 598 599 #define knvlinkIsForcedConfig_HAL(arg0, arg1) knvlinkIsForcedConfig(arg0, arg1) 600 601 NV_STATUS knvlinkApplyRegkeyOverrides_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *arg0); 602 603 604 #ifdef __nvoc_kernel_nvlink_h_disabled 605 static inline NV_STATUS knvlinkApplyRegkeyOverrides(struct OBJGPU *pGpu, struct KernelNvlink *arg0) { 606 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 607 return NV_ERR_NOT_SUPPORTED; 608 } 609 #else //__nvoc_kernel_nvlink_h_disabled 610 #define knvlinkApplyRegkeyOverrides(pGpu, arg0) knvlinkApplyRegkeyOverrides_IMPL(pGpu, arg0) 611 #endif //__nvoc_kernel_nvlink_h_disabled 612 613 #define knvlinkApplyRegkeyOverrides_HAL(pGpu, arg0) knvlinkApplyRegkeyOverrides(pGpu, arg0) 614 615 NvBool knvlinkIsNvlinkDefaultEnabled_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *arg0); 616 617 618 #ifdef __nvoc_kernel_nvlink_h_disabled 619 static inline NvBool knvlinkIsNvlinkDefaultEnabled(struct OBJGPU *pGpu, struct KernelNvlink *arg0) { 620 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 621 return NV_FALSE; 622 } 623 #else //__nvoc_kernel_nvlink_h_disabled 624 #define knvlinkIsNvlinkDefaultEnabled(pGpu, arg0) knvlinkIsNvlinkDefaultEnabled_IMPL(pGpu, arg0) 625 #endif //__nvoc_kernel_nvlink_h_disabled 626 627 #define knvlinkIsNvlinkDefaultEnabled_HAL(pGpu, arg0) knvlinkIsNvlinkDefaultEnabled(pGpu, arg0) 628 629 NvBool knvlinkIsP2pLoopbackSupported_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 630 631 632 #ifdef __nvoc_kernel_nvlink_h_disabled 633 static inline NvBool knvlinkIsP2pLoopbackSupported(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 634 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 635 return NV_FALSE; 636 } 637 #else //__nvoc_kernel_nvlink_h_disabled 638 #define knvlinkIsP2pLoopbackSupported(pGpu, pKernelNvlink) knvlinkIsP2pLoopbackSupported_IMPL(pGpu, pKernelNvlink) 639 #endif //__nvoc_kernel_nvlink_h_disabled 640 641 #define knvlinkIsP2pLoopbackSupported_HAL(pGpu, pKernelNvlink) knvlinkIsP2pLoopbackSupported(pGpu, pKernelNvlink) 642 643 NvBool knvlinkIsP2pLoopbackSupportedPerLink_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0); 644 645 646 #ifdef __nvoc_kernel_nvlink_h_disabled 647 static inline NvBool knvlinkIsP2pLoopbackSupportedPerLink(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0) { 648 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 649 return NV_FALSE; 650 } 651 #else //__nvoc_kernel_nvlink_h_disabled 652 #define knvlinkIsP2pLoopbackSupportedPerLink(pGpu, pKernelNvlink, arg0) knvlinkIsP2pLoopbackSupportedPerLink_IMPL(pGpu, pKernelNvlink, arg0) 653 #endif //__nvoc_kernel_nvlink_h_disabled 654 655 #define knvlinkIsP2pLoopbackSupportedPerLink_HAL(pGpu, pKernelNvlink, arg0) knvlinkIsP2pLoopbackSupportedPerLink(pGpu, pKernelNvlink, arg0) 656 657 NvBool knvlinkIsNvlinkP2pSupported_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pPeerGpu); 658 659 660 #ifdef __nvoc_kernel_nvlink_h_disabled 661 static inline NvBool knvlinkIsNvlinkP2pSupported(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pPeerGpu) { 662 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 663 return NV_FALSE; 664 } 665 #else //__nvoc_kernel_nvlink_h_disabled 666 #define knvlinkIsNvlinkP2pSupported(pGpu, pKernelNvlink, pPeerGpu) knvlinkIsNvlinkP2pSupported_IMPL(pGpu, pKernelNvlink, pPeerGpu) 667 #endif //__nvoc_kernel_nvlink_h_disabled 668 669 #define knvlinkIsNvlinkP2pSupported_HAL(pGpu, pKernelNvlink, pPeerGpu) knvlinkIsNvlinkP2pSupported(pGpu, pKernelNvlink, pPeerGpu) 670 671 NvBool knvlinkCheckNvswitchP2pConfig_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pPeerGpu); 672 673 674 #ifdef __nvoc_kernel_nvlink_h_disabled 675 static inline NvBool knvlinkCheckNvswitchP2pConfig(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pPeerGpu) { 676 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 677 return NV_FALSE; 678 } 679 #else //__nvoc_kernel_nvlink_h_disabled 680 #define knvlinkCheckNvswitchP2pConfig(pGpu, pKernelNvlink, pPeerGpu) knvlinkCheckNvswitchP2pConfig_IMPL(pGpu, pKernelNvlink, pPeerGpu) 681 #endif //__nvoc_kernel_nvlink_h_disabled 682 683 #define knvlinkCheckNvswitchP2pConfig_HAL(pGpu, pKernelNvlink, pPeerGpu) knvlinkCheckNvswitchP2pConfig(pGpu, pKernelNvlink, pPeerGpu) 684 685 NV_STATUS knvlinkGetP2pConnectionStatus_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pPeerGpu); 686 687 688 #ifdef __nvoc_kernel_nvlink_h_disabled 689 static inline NV_STATUS knvlinkGetP2pConnectionStatus(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pPeerGpu) { 690 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 691 return NV_ERR_NOT_SUPPORTED; 692 } 693 #else //__nvoc_kernel_nvlink_h_disabled 694 #define knvlinkGetP2pConnectionStatus(pGpu, pKernelNvlink, pPeerGpu) knvlinkGetP2pConnectionStatus_IMPL(pGpu, pKernelNvlink, pPeerGpu) 695 #endif //__nvoc_kernel_nvlink_h_disabled 696 697 #define knvlinkGetP2pConnectionStatus_HAL(pGpu, pKernelNvlink, pPeerGpu) knvlinkGetP2pConnectionStatus(pGpu, pKernelNvlink, pPeerGpu) 698 699 NV_STATUS knvlinkUpdateCurrentConfig_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 700 701 702 #ifdef __nvoc_kernel_nvlink_h_disabled 703 static inline NV_STATUS knvlinkUpdateCurrentConfig(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 704 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 705 return NV_ERR_NOT_SUPPORTED; 706 } 707 #else //__nvoc_kernel_nvlink_h_disabled 708 #define knvlinkUpdateCurrentConfig(pGpu, pKernelNvlink) knvlinkUpdateCurrentConfig_IMPL(pGpu, pKernelNvlink) 709 #endif //__nvoc_kernel_nvlink_h_disabled 710 711 #define knvlinkUpdateCurrentConfig_HAL(pGpu, pKernelNvlink) knvlinkUpdateCurrentConfig(pGpu, pKernelNvlink) 712 713 void knvlinkCoreDriverLoadWar_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 714 715 716 #ifdef __nvoc_kernel_nvlink_h_disabled 717 static inline void knvlinkCoreDriverLoadWar(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 718 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 719 } 720 #else //__nvoc_kernel_nvlink_h_disabled 721 #define knvlinkCoreDriverLoadWar(pGpu, pKernelNvlink) knvlinkCoreDriverLoadWar_IMPL(pGpu, pKernelNvlink) 722 #endif //__nvoc_kernel_nvlink_h_disabled 723 724 #define knvlinkCoreDriverLoadWar_HAL(pGpu, pKernelNvlink) knvlinkCoreDriverLoadWar(pGpu, pKernelNvlink) 725 726 void knvlinkCoreDriverUnloadWar_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 727 728 729 #ifdef __nvoc_kernel_nvlink_h_disabled 730 static inline void knvlinkCoreDriverUnloadWar(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 731 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 732 } 733 #else //__nvoc_kernel_nvlink_h_disabled 734 #define knvlinkCoreDriverUnloadWar(pGpu, pKernelNvlink) knvlinkCoreDriverUnloadWar_IMPL(pGpu, pKernelNvlink) 735 #endif //__nvoc_kernel_nvlink_h_disabled 736 737 #define knvlinkCoreDriverUnloadWar_HAL(pGpu, pKernelNvlink) knvlinkCoreDriverUnloadWar(pGpu, pKernelNvlink) 738 739 NV_STATUS knvlinkCoreIsDriverSupported_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 740 741 742 #ifdef __nvoc_kernel_nvlink_h_disabled 743 static inline NV_STATUS knvlinkCoreIsDriverSupported(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 744 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 745 return NV_ERR_NOT_SUPPORTED; 746 } 747 #else //__nvoc_kernel_nvlink_h_disabled 748 #define knvlinkCoreIsDriverSupported(pGpu, pKernelNvlink) knvlinkCoreIsDriverSupported_IMPL(pGpu, pKernelNvlink) 749 #endif //__nvoc_kernel_nvlink_h_disabled 750 751 #define knvlinkCoreIsDriverSupported_HAL(pGpu, pKernelNvlink) knvlinkCoreIsDriverSupported(pGpu, pKernelNvlink) 752 753 NV_STATUS knvlinkCoreAddDevice_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 754 755 756 #ifdef __nvoc_kernel_nvlink_h_disabled 757 static inline NV_STATUS knvlinkCoreAddDevice(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 758 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 759 return NV_ERR_NOT_SUPPORTED; 760 } 761 #else //__nvoc_kernel_nvlink_h_disabled 762 #define knvlinkCoreAddDevice(pGpu, pKernelNvlink) knvlinkCoreAddDevice_IMPL(pGpu, pKernelNvlink) 763 #endif //__nvoc_kernel_nvlink_h_disabled 764 765 #define knvlinkCoreAddDevice_HAL(pGpu, pKernelNvlink) knvlinkCoreAddDevice(pGpu, pKernelNvlink) 766 767 NV_STATUS knvlinkCoreAddLink_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0); 768 769 770 #ifdef __nvoc_kernel_nvlink_h_disabled 771 static inline NV_STATUS knvlinkCoreAddLink(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0) { 772 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 773 return NV_ERR_NOT_SUPPORTED; 774 } 775 #else //__nvoc_kernel_nvlink_h_disabled 776 #define knvlinkCoreAddLink(pGpu, pKernelNvlink, arg0) knvlinkCoreAddLink_IMPL(pGpu, pKernelNvlink, arg0) 777 #endif //__nvoc_kernel_nvlink_h_disabled 778 779 #define knvlinkCoreAddLink_HAL(pGpu, pKernelNvlink, arg0) knvlinkCoreAddLink(pGpu, pKernelNvlink, arg0) 780 781 NV_STATUS knvlinkCoreRemoveDevice_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 782 783 784 #ifdef __nvoc_kernel_nvlink_h_disabled 785 static inline NV_STATUS knvlinkCoreRemoveDevice(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 786 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 787 return NV_ERR_NOT_SUPPORTED; 788 } 789 #else //__nvoc_kernel_nvlink_h_disabled 790 #define knvlinkCoreRemoveDevice(pGpu, pKernelNvlink) knvlinkCoreRemoveDevice_IMPL(pGpu, pKernelNvlink) 791 #endif //__nvoc_kernel_nvlink_h_disabled 792 793 #define knvlinkCoreRemoveDevice_HAL(pGpu, pKernelNvlink) knvlinkCoreRemoveDevice(pGpu, pKernelNvlink) 794 795 void knvlinkSetDegradedMode_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0); 796 797 798 #ifdef __nvoc_kernel_nvlink_h_disabled 799 static inline void knvlinkSetDegradedMode(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0) { 800 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 801 } 802 #else //__nvoc_kernel_nvlink_h_disabled 803 #define knvlinkSetDegradedMode(pGpu, pKernelNvlink, arg0) knvlinkSetDegradedMode_IMPL(pGpu, pKernelNvlink, arg0) 804 #endif //__nvoc_kernel_nvlink_h_disabled 805 806 #define knvlinkSetDegradedMode_HAL(pGpu, pKernelNvlink, arg0) knvlinkSetDegradedMode(pGpu, pKernelNvlink, arg0) 807 808 NV_STATUS knvlinkCoreRemoveLink_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0); 809 810 811 #ifdef __nvoc_kernel_nvlink_h_disabled 812 static inline NV_STATUS knvlinkCoreRemoveLink(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0) { 813 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 814 return NV_ERR_NOT_SUPPORTED; 815 } 816 #else //__nvoc_kernel_nvlink_h_disabled 817 #define knvlinkCoreRemoveLink(pGpu, pKernelNvlink, arg0) knvlinkCoreRemoveLink_IMPL(pGpu, pKernelNvlink, arg0) 818 #endif //__nvoc_kernel_nvlink_h_disabled 819 820 #define knvlinkCoreRemoveLink_HAL(pGpu, pKernelNvlink, arg0) knvlinkCoreRemoveLink(pGpu, pKernelNvlink, arg0) 821 822 NV_STATUS knvlinkCoreShutdownDeviceLinks_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvBool bForcePowerDown); 823 824 825 #ifdef __nvoc_kernel_nvlink_h_disabled 826 static inline NV_STATUS knvlinkCoreShutdownDeviceLinks(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvBool bForcePowerDown) { 827 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 828 return NV_ERR_NOT_SUPPORTED; 829 } 830 #else //__nvoc_kernel_nvlink_h_disabled 831 #define knvlinkCoreShutdownDeviceLinks(pGpu, pKernelNvlink, bForcePowerDown) knvlinkCoreShutdownDeviceLinks_IMPL(pGpu, pKernelNvlink, bForcePowerDown) 832 #endif //__nvoc_kernel_nvlink_h_disabled 833 834 #define knvlinkCoreShutdownDeviceLinks_HAL(pGpu, pKernelNvlink, bForcePowerDown) knvlinkCoreShutdownDeviceLinks(pGpu, pKernelNvlink, bForcePowerDown) 835 836 NV_STATUS knvlinkCoreResetDeviceLinks_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 837 838 839 #ifdef __nvoc_kernel_nvlink_h_disabled 840 static inline NV_STATUS knvlinkCoreResetDeviceLinks(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 841 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 842 return NV_ERR_NOT_SUPPORTED; 843 } 844 #else //__nvoc_kernel_nvlink_h_disabled 845 #define knvlinkCoreResetDeviceLinks(pGpu, pKernelNvlink) knvlinkCoreResetDeviceLinks_IMPL(pGpu, pKernelNvlink) 846 #endif //__nvoc_kernel_nvlink_h_disabled 847 848 #define knvlinkCoreResetDeviceLinks_HAL(pGpu, pKernelNvlink) knvlinkCoreResetDeviceLinks(pGpu, pKernelNvlink) 849 850 NV_STATUS knvlinkCoreUpdateDeviceUUID_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 851 852 853 #ifdef __nvoc_kernel_nvlink_h_disabled 854 static inline NV_STATUS knvlinkCoreUpdateDeviceUUID(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 855 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 856 return NV_ERR_NOT_SUPPORTED; 857 } 858 #else //__nvoc_kernel_nvlink_h_disabled 859 #define knvlinkCoreUpdateDeviceUUID(pGpu, pKernelNvlink) knvlinkCoreUpdateDeviceUUID_IMPL(pGpu, pKernelNvlink) 860 #endif //__nvoc_kernel_nvlink_h_disabled 861 862 #define knvlinkCoreUpdateDeviceUUID_HAL(pGpu, pKernelNvlink) knvlinkCoreUpdateDeviceUUID(pGpu, pKernelNvlink) 863 864 NV_STATUS knvlinkCoreGetRemoteDeviceInfo_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 865 866 867 #ifdef __nvoc_kernel_nvlink_h_disabled 868 static inline NV_STATUS knvlinkCoreGetRemoteDeviceInfo(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 869 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 870 return NV_ERR_NOT_SUPPORTED; 871 } 872 #else //__nvoc_kernel_nvlink_h_disabled 873 #define knvlinkCoreGetRemoteDeviceInfo(pGpu, pKernelNvlink) knvlinkCoreGetRemoteDeviceInfo_IMPL(pGpu, pKernelNvlink) 874 #endif //__nvoc_kernel_nvlink_h_disabled 875 876 #define knvlinkCoreGetRemoteDeviceInfo_HAL(pGpu, pKernelNvlink) knvlinkCoreGetRemoteDeviceInfo(pGpu, pKernelNvlink) 877 878 NvBool knvlinkIsGpuConnectedToNvswitch_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 879 880 881 #ifdef __nvoc_kernel_nvlink_h_disabled 882 static inline NvBool knvlinkIsGpuConnectedToNvswitch(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 883 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 884 return NV_FALSE; 885 } 886 #else //__nvoc_kernel_nvlink_h_disabled 887 #define knvlinkIsGpuConnectedToNvswitch(pGpu, pKernelNvlink) knvlinkIsGpuConnectedToNvswitch_IMPL(pGpu, pKernelNvlink) 888 #endif //__nvoc_kernel_nvlink_h_disabled 889 890 #define knvlinkIsGpuConnectedToNvswitch_HAL(pGpu, pKernelNvlink) knvlinkIsGpuConnectedToNvswitch(pGpu, pKernelNvlink) 891 892 NvBool knvlinkIsLinkConnected_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0); 893 894 895 #ifdef __nvoc_kernel_nvlink_h_disabled 896 static inline NvBool knvlinkIsLinkConnected(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0) { 897 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 898 return NV_FALSE; 899 } 900 #else //__nvoc_kernel_nvlink_h_disabled 901 #define knvlinkIsLinkConnected(pGpu, pKernelNvlink, arg0) knvlinkIsLinkConnected_IMPL(pGpu, pKernelNvlink, arg0) 902 #endif //__nvoc_kernel_nvlink_h_disabled 903 904 #define knvlinkIsLinkConnected_HAL(pGpu, pKernelNvlink, arg0) knvlinkIsLinkConnected(pGpu, pKernelNvlink, arg0) 905 906 NV_STATUS knvlinkTrainSysmemLinksToActive_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 907 908 909 #ifdef __nvoc_kernel_nvlink_h_disabled 910 static inline NV_STATUS knvlinkTrainSysmemLinksToActive(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 911 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 912 return NV_ERR_NOT_SUPPORTED; 913 } 914 #else //__nvoc_kernel_nvlink_h_disabled 915 #define knvlinkTrainSysmemLinksToActive(pGpu, pKernelNvlink) knvlinkTrainSysmemLinksToActive_IMPL(pGpu, pKernelNvlink) 916 #endif //__nvoc_kernel_nvlink_h_disabled 917 918 #define knvlinkTrainSysmemLinksToActive_HAL(pGpu, pKernelNvlink) knvlinkTrainSysmemLinksToActive(pGpu, pKernelNvlink) 919 920 NV_STATUS knvlinkTrainP2pLinksToActive_IMPL(struct OBJGPU *pGpu0, struct OBJGPU *pGpu1, struct KernelNvlink *pKernelNvlink); 921 922 923 #ifdef __nvoc_kernel_nvlink_h_disabled 924 static inline NV_STATUS knvlinkTrainP2pLinksToActive(struct OBJGPU *pGpu0, struct OBJGPU *pGpu1, struct KernelNvlink *pKernelNvlink) { 925 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 926 return NV_ERR_NOT_SUPPORTED; 927 } 928 #else //__nvoc_kernel_nvlink_h_disabled 929 #define knvlinkTrainP2pLinksToActive(pGpu0, pGpu1, pKernelNvlink) knvlinkTrainP2pLinksToActive_IMPL(pGpu0, pGpu1, pKernelNvlink) 930 #endif //__nvoc_kernel_nvlink_h_disabled 931 932 #define knvlinkTrainP2pLinksToActive_HAL(pGpu0, pGpu1, pKernelNvlink) knvlinkTrainP2pLinksToActive(pGpu0, pGpu1, pKernelNvlink) 933 934 NV_STATUS knvlinkCheckTrainingIsComplete_IMPL(struct OBJGPU *pGpu0, struct OBJGPU *pGpu1, struct KernelNvlink *pKernelNvlink); 935 936 937 #ifdef __nvoc_kernel_nvlink_h_disabled 938 static inline NV_STATUS knvlinkCheckTrainingIsComplete(struct OBJGPU *pGpu0, struct OBJGPU *pGpu1, struct KernelNvlink *pKernelNvlink) { 939 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 940 return NV_ERR_NOT_SUPPORTED; 941 } 942 #else //__nvoc_kernel_nvlink_h_disabled 943 #define knvlinkCheckTrainingIsComplete(pGpu0, pGpu1, pKernelNvlink) knvlinkCheckTrainingIsComplete_IMPL(pGpu0, pGpu1, pKernelNvlink) 944 #endif //__nvoc_kernel_nvlink_h_disabled 945 946 #define knvlinkCheckTrainingIsComplete_HAL(pGpu0, pGpu1, pKernelNvlink) knvlinkCheckTrainingIsComplete(pGpu0, pGpu1, pKernelNvlink) 947 948 NV_STATUS knvlinkTrainFabricLinksToActive_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 949 950 951 #ifdef __nvoc_kernel_nvlink_h_disabled 952 static inline NV_STATUS knvlinkTrainFabricLinksToActive(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 953 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 954 return NV_ERR_NOT_SUPPORTED; 955 } 956 #else //__nvoc_kernel_nvlink_h_disabled 957 #define knvlinkTrainFabricLinksToActive(pGpu, pKernelNvlink) knvlinkTrainFabricLinksToActive_IMPL(pGpu, pKernelNvlink) 958 #endif //__nvoc_kernel_nvlink_h_disabled 959 960 #define knvlinkTrainFabricLinksToActive_HAL(pGpu, pKernelNvlink) knvlinkTrainFabricLinksToActive(pGpu, pKernelNvlink) 961 962 NV_STATUS knvlinkRetrainLink_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 linkId, NvBool bFromOff); 963 964 965 #ifdef __nvoc_kernel_nvlink_h_disabled 966 static inline NV_STATUS knvlinkRetrainLink(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 linkId, NvBool bFromOff) { 967 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 968 return NV_ERR_NOT_SUPPORTED; 969 } 970 #else //__nvoc_kernel_nvlink_h_disabled 971 #define knvlinkRetrainLink(pGpu, pKernelNvlink, linkId, bFromOff) knvlinkRetrainLink_IMPL(pGpu, pKernelNvlink, linkId, bFromOff) 972 #endif //__nvoc_kernel_nvlink_h_disabled 973 974 #define knvlinkRetrainLink_HAL(pGpu, pKernelNvlink, linkId, bFromOff) knvlinkRetrainLink(pGpu, pKernelNvlink, linkId, bFromOff) 975 976 NvU32 knvlinkGetEnabledLinkMask_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *arg0); 977 978 979 #ifdef __nvoc_kernel_nvlink_h_disabled 980 static inline NvU32 knvlinkGetEnabledLinkMask(struct OBJGPU *pGpu, struct KernelNvlink *arg0) { 981 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 982 return 0; 983 } 984 #else //__nvoc_kernel_nvlink_h_disabled 985 #define knvlinkGetEnabledLinkMask(pGpu, arg0) knvlinkGetEnabledLinkMask_IMPL(pGpu, arg0) 986 #endif //__nvoc_kernel_nvlink_h_disabled 987 988 #define knvlinkGetEnabledLinkMask_HAL(pGpu, arg0) knvlinkGetEnabledLinkMask(pGpu, arg0) 989 990 NvU32 knvlinkGetDiscoveredLinkMask_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *arg0); 991 992 993 #ifdef __nvoc_kernel_nvlink_h_disabled 994 static inline NvU32 knvlinkGetDiscoveredLinkMask(struct OBJGPU *pGpu, struct KernelNvlink *arg0) { 995 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 996 return 0; 997 } 998 #else //__nvoc_kernel_nvlink_h_disabled 999 #define knvlinkGetDiscoveredLinkMask(pGpu, arg0) knvlinkGetDiscoveredLinkMask_IMPL(pGpu, arg0) 1000 #endif //__nvoc_kernel_nvlink_h_disabled 1001 1002 #define knvlinkGetDiscoveredLinkMask_HAL(pGpu, arg0) knvlinkGetDiscoveredLinkMask(pGpu, arg0) 1003 1004 NV_STATUS knvlinkProcessInitDisabledLinks_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1005 1006 1007 #ifdef __nvoc_kernel_nvlink_h_disabled 1008 static inline NV_STATUS knvlinkProcessInitDisabledLinks(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1009 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1010 return NV_ERR_NOT_SUPPORTED; 1011 } 1012 #else //__nvoc_kernel_nvlink_h_disabled 1013 #define knvlinkProcessInitDisabledLinks(pGpu, pKernelNvlink) knvlinkProcessInitDisabledLinks_IMPL(pGpu, pKernelNvlink) 1014 #endif //__nvoc_kernel_nvlink_h_disabled 1015 1016 #define knvlinkProcessInitDisabledLinks_HAL(pGpu, pKernelNvlink) knvlinkProcessInitDisabledLinks(pGpu, pKernelNvlink) 1017 1018 NvU32 knvlinkGetNumLinksToSystem_IMPL(struct OBJGPU *arg0, struct KernelNvlink *arg1); 1019 1020 1021 #ifdef __nvoc_kernel_nvlink_h_disabled 1022 static inline NvU32 knvlinkGetNumLinksToSystem(struct OBJGPU *arg0, struct KernelNvlink *arg1) { 1023 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1024 return 0; 1025 } 1026 #else //__nvoc_kernel_nvlink_h_disabled 1027 #define knvlinkGetNumLinksToSystem(arg0, arg1) knvlinkGetNumLinksToSystem_IMPL(arg0, arg1) 1028 #endif //__nvoc_kernel_nvlink_h_disabled 1029 1030 #define knvlinkGetNumLinksToSystem_HAL(arg0, arg1) knvlinkGetNumLinksToSystem(arg0, arg1) 1031 1032 NvU32 knvlinkGetNumLinksToPeer_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pRemoteGpu); 1033 1034 1035 #ifdef __nvoc_kernel_nvlink_h_disabled 1036 static inline NvU32 knvlinkGetNumLinksToPeer(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pRemoteGpu) { 1037 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1038 return 0; 1039 } 1040 #else //__nvoc_kernel_nvlink_h_disabled 1041 #define knvlinkGetNumLinksToPeer(pGpu, pKernelNvlink, pRemoteGpu) knvlinkGetNumLinksToPeer_IMPL(pGpu, pKernelNvlink, pRemoteGpu) 1042 #endif //__nvoc_kernel_nvlink_h_disabled 1043 1044 #define knvlinkGetNumLinksToPeer_HAL(pGpu, pKernelNvlink, pRemoteGpu) knvlinkGetNumLinksToPeer(pGpu, pKernelNvlink, pRemoteGpu) 1045 1046 NvU32 knvlinkGetLinkMaskToPeer_IMPL(struct OBJGPU *pGpu0, struct KernelNvlink *pKernelNvlink0, struct OBJGPU *pGpu1); 1047 1048 1049 #ifdef __nvoc_kernel_nvlink_h_disabled 1050 static inline NvU32 knvlinkGetLinkMaskToPeer(struct OBJGPU *pGpu0, struct KernelNvlink *pKernelNvlink0, struct OBJGPU *pGpu1) { 1051 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1052 return 0; 1053 } 1054 #else //__nvoc_kernel_nvlink_h_disabled 1055 #define knvlinkGetLinkMaskToPeer(pGpu0, pKernelNvlink0, pGpu1) knvlinkGetLinkMaskToPeer_IMPL(pGpu0, pKernelNvlink0, pGpu1) 1056 #endif //__nvoc_kernel_nvlink_h_disabled 1057 1058 #define knvlinkGetLinkMaskToPeer_HAL(pGpu0, pKernelNvlink0, pGpu1) knvlinkGetLinkMaskToPeer(pGpu0, pKernelNvlink0, pGpu1) 1059 1060 NV_STATUS knvlinkSetLinkMaskToPeer_IMPL(struct OBJGPU *pGpu0, struct KernelNvlink *pKernelNvlink0, struct OBJGPU *pGpu1, NvU32 peerLinkMask); 1061 1062 1063 #ifdef __nvoc_kernel_nvlink_h_disabled 1064 static inline NV_STATUS knvlinkSetLinkMaskToPeer(struct OBJGPU *pGpu0, struct KernelNvlink *pKernelNvlink0, struct OBJGPU *pGpu1, NvU32 peerLinkMask) { 1065 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1066 return NV_ERR_NOT_SUPPORTED; 1067 } 1068 #else //__nvoc_kernel_nvlink_h_disabled 1069 #define knvlinkSetLinkMaskToPeer(pGpu0, pKernelNvlink0, pGpu1, peerLinkMask) knvlinkSetLinkMaskToPeer_IMPL(pGpu0, pKernelNvlink0, pGpu1, peerLinkMask) 1070 #endif //__nvoc_kernel_nvlink_h_disabled 1071 1072 #define knvlinkSetLinkMaskToPeer_HAL(pGpu0, pKernelNvlink0, pGpu1, peerLinkMask) knvlinkSetLinkMaskToPeer(pGpu0, pKernelNvlink0, pGpu1, peerLinkMask) 1073 1074 NvU32 knvlinkGetPeersNvlinkMaskFromHshub_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1075 1076 1077 #ifdef __nvoc_kernel_nvlink_h_disabled 1078 static inline NvU32 knvlinkGetPeersNvlinkMaskFromHshub(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1079 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1080 return 0; 1081 } 1082 #else //__nvoc_kernel_nvlink_h_disabled 1083 #define knvlinkGetPeersNvlinkMaskFromHshub(pGpu, pKernelNvlink) knvlinkGetPeersNvlinkMaskFromHshub_IMPL(pGpu, pKernelNvlink) 1084 #endif //__nvoc_kernel_nvlink_h_disabled 1085 1086 #define knvlinkGetPeersNvlinkMaskFromHshub_HAL(pGpu, pKernelNvlink) knvlinkGetPeersNvlinkMaskFromHshub(pGpu, pKernelNvlink) 1087 1088 NV_STATUS knvlinkPrepareForXVEReset_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvBool bForcePowerDown); 1089 1090 1091 #ifdef __nvoc_kernel_nvlink_h_disabled 1092 static inline NV_STATUS knvlinkPrepareForXVEReset(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvBool bForcePowerDown) { 1093 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1094 return NV_ERR_NOT_SUPPORTED; 1095 } 1096 #else //__nvoc_kernel_nvlink_h_disabled 1097 #define knvlinkPrepareForXVEReset(pGpu, pKernelNvlink, bForcePowerDown) knvlinkPrepareForXVEReset_IMPL(pGpu, pKernelNvlink, bForcePowerDown) 1098 #endif //__nvoc_kernel_nvlink_h_disabled 1099 1100 #define knvlinkPrepareForXVEReset_HAL(pGpu, pKernelNvlink, bForcePowerDown) knvlinkPrepareForXVEReset(pGpu, pKernelNvlink, bForcePowerDown) 1101 1102 NV_STATUS knvlinkEnterExitSleep_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0, NvBool arg1); 1103 1104 1105 #ifdef __nvoc_kernel_nvlink_h_disabled 1106 static inline NV_STATUS knvlinkEnterExitSleep(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0, NvBool arg1) { 1107 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1108 return NV_ERR_NOT_SUPPORTED; 1109 } 1110 #else //__nvoc_kernel_nvlink_h_disabled 1111 #define knvlinkEnterExitSleep(pGpu, pKernelNvlink, arg0, arg1) knvlinkEnterExitSleep_IMPL(pGpu, pKernelNvlink, arg0, arg1) 1112 #endif //__nvoc_kernel_nvlink_h_disabled 1113 1114 #define knvlinkEnterExitSleep_HAL(pGpu, pKernelNvlink, arg0, arg1) knvlinkEnterExitSleep(pGpu, pKernelNvlink, arg0, arg1) 1115 1116 NV_STATUS knvlinkSyncLinkMasksAndVbiosInfo_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1117 1118 1119 #ifdef __nvoc_kernel_nvlink_h_disabled 1120 static inline NV_STATUS knvlinkSyncLinkMasksAndVbiosInfo(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1121 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1122 return NV_ERR_NOT_SUPPORTED; 1123 } 1124 #else //__nvoc_kernel_nvlink_h_disabled 1125 #define knvlinkSyncLinkMasksAndVbiosInfo(pGpu, pKernelNvlink) knvlinkSyncLinkMasksAndVbiosInfo_IMPL(pGpu, pKernelNvlink) 1126 #endif //__nvoc_kernel_nvlink_h_disabled 1127 1128 #define knvlinkSyncLinkMasksAndVbiosInfo_HAL(pGpu, pKernelNvlink) knvlinkSyncLinkMasksAndVbiosInfo(pGpu, pKernelNvlink) 1129 1130 NV_STATUS knvlinkInbandMsgCallbackDispatcher_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvLink, NvU32 dataSize, NvU8 *pMessage); 1131 1132 1133 #ifdef __nvoc_kernel_nvlink_h_disabled 1134 static inline NV_STATUS knvlinkInbandMsgCallbackDispatcher(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvLink, NvU32 dataSize, NvU8 *pMessage) { 1135 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1136 return NV_ERR_NOT_SUPPORTED; 1137 } 1138 #else //__nvoc_kernel_nvlink_h_disabled 1139 #define knvlinkInbandMsgCallbackDispatcher(pGpu, pKernelNvLink, dataSize, pMessage) knvlinkInbandMsgCallbackDispatcher_IMPL(pGpu, pKernelNvLink, dataSize, pMessage) 1140 #endif //__nvoc_kernel_nvlink_h_disabled 1141 1142 #define knvlinkInbandMsgCallbackDispatcher_HAL(pGpu, pKernelNvLink, dataSize, pMessage) knvlinkInbandMsgCallbackDispatcher(pGpu, pKernelNvLink, dataSize, pMessage) 1143 1144 NV_STATUS knvlinkFatalErrorRecovery_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvLink); 1145 1146 1147 #ifdef __nvoc_kernel_nvlink_h_disabled 1148 static inline NV_STATUS knvlinkFatalErrorRecovery(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvLink) { 1149 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1150 return NV_ERR_NOT_SUPPORTED; 1151 } 1152 #else //__nvoc_kernel_nvlink_h_disabled 1153 #define knvlinkFatalErrorRecovery(pGpu, pKernelNvLink) knvlinkFatalErrorRecovery_IMPL(pGpu, pKernelNvLink) 1154 #endif //__nvoc_kernel_nvlink_h_disabled 1155 1156 #define knvlinkFatalErrorRecovery_HAL(pGpu, pKernelNvLink) knvlinkFatalErrorRecovery(pGpu, pKernelNvLink) 1157 1158 NV_STATUS knvlinkSendInbandData_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NV2080_CTRL_NVLINK_INBAND_SEND_DATA_PARAMS *pParams); 1159 1160 1161 #ifdef __nvoc_kernel_nvlink_h_disabled 1162 static inline NV_STATUS knvlinkSendInbandData(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NV2080_CTRL_NVLINK_INBAND_SEND_DATA_PARAMS *pParams) { 1163 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1164 return NV_ERR_NOT_SUPPORTED; 1165 } 1166 #else //__nvoc_kernel_nvlink_h_disabled 1167 #define knvlinkSendInbandData(pGpu, pKernelNvlink, pParams) knvlinkSendInbandData_IMPL(pGpu, pKernelNvlink, pParams) 1168 #endif //__nvoc_kernel_nvlink_h_disabled 1169 1170 #define knvlinkSendInbandData_HAL(pGpu, pKernelNvlink, pParams) knvlinkSendInbandData(pGpu, pKernelNvlink, pParams) 1171 1172 NV_STATUS knvlinkUpdateLinkConnectionStatus_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0); 1173 1174 1175 #ifdef __nvoc_kernel_nvlink_h_disabled 1176 static inline NV_STATUS knvlinkUpdateLinkConnectionStatus(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0) { 1177 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1178 return NV_ERR_NOT_SUPPORTED; 1179 } 1180 #else //__nvoc_kernel_nvlink_h_disabled 1181 #define knvlinkUpdateLinkConnectionStatus(pGpu, pKernelNvlink, arg0) knvlinkUpdateLinkConnectionStatus_IMPL(pGpu, pKernelNvlink, arg0) 1182 #endif //__nvoc_kernel_nvlink_h_disabled 1183 1184 #define knvlinkUpdateLinkConnectionStatus_HAL(pGpu, pKernelNvlink, arg0) knvlinkUpdateLinkConnectionStatus(pGpu, pKernelNvlink, arg0) 1185 1186 NV_STATUS knvlinkPreTrainLinksToActiveAli_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0, NvBool arg1); 1187 1188 1189 #ifdef __nvoc_kernel_nvlink_h_disabled 1190 static inline NV_STATUS knvlinkPreTrainLinksToActiveAli(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0, NvBool arg1) { 1191 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1192 return NV_ERR_NOT_SUPPORTED; 1193 } 1194 #else //__nvoc_kernel_nvlink_h_disabled 1195 #define knvlinkPreTrainLinksToActiveAli(pGpu, pKernelNvlink, arg0, arg1) knvlinkPreTrainLinksToActiveAli_IMPL(pGpu, pKernelNvlink, arg0, arg1) 1196 #endif //__nvoc_kernel_nvlink_h_disabled 1197 1198 #define knvlinkPreTrainLinksToActiveAli_HAL(pGpu, pKernelNvlink, arg0, arg1) knvlinkPreTrainLinksToActiveAli(pGpu, pKernelNvlink, arg0, arg1) 1199 1200 NV_STATUS knvlinkTrainLinksToActiveAli_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0, NvBool arg1); 1201 1202 1203 #ifdef __nvoc_kernel_nvlink_h_disabled 1204 static inline NV_STATUS knvlinkTrainLinksToActiveAli(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0, NvBool arg1) { 1205 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1206 return NV_ERR_NOT_SUPPORTED; 1207 } 1208 #else //__nvoc_kernel_nvlink_h_disabled 1209 #define knvlinkTrainLinksToActiveAli(pGpu, pKernelNvlink, arg0, arg1) knvlinkTrainLinksToActiveAli_IMPL(pGpu, pKernelNvlink, arg0, arg1) 1210 #endif //__nvoc_kernel_nvlink_h_disabled 1211 1212 #define knvlinkTrainLinksToActiveAli_HAL(pGpu, pKernelNvlink, arg0, arg1) knvlinkTrainLinksToActiveAli(pGpu, pKernelNvlink, arg0, arg1) 1213 1214 NV_STATUS knvlinkUpdatePostRxDetectLinkMask_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1215 1216 1217 #ifdef __nvoc_kernel_nvlink_h_disabled 1218 static inline NV_STATUS knvlinkUpdatePostRxDetectLinkMask(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1219 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1220 return NV_ERR_NOT_SUPPORTED; 1221 } 1222 #else //__nvoc_kernel_nvlink_h_disabled 1223 #define knvlinkUpdatePostRxDetectLinkMask(pGpu, pKernelNvlink) knvlinkUpdatePostRxDetectLinkMask_IMPL(pGpu, pKernelNvlink) 1224 #endif //__nvoc_kernel_nvlink_h_disabled 1225 1226 #define knvlinkUpdatePostRxDetectLinkMask_HAL(pGpu, pKernelNvlink) knvlinkUpdatePostRxDetectLinkMask(pGpu, pKernelNvlink) 1227 1228 NV_STATUS knvlinkCopyNvlinkDeviceInfo_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1229 1230 1231 #ifdef __nvoc_kernel_nvlink_h_disabled 1232 static inline NV_STATUS knvlinkCopyNvlinkDeviceInfo(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1233 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1234 return NV_ERR_NOT_SUPPORTED; 1235 } 1236 #else //__nvoc_kernel_nvlink_h_disabled 1237 #define knvlinkCopyNvlinkDeviceInfo(pGpu, pKernelNvlink) knvlinkCopyNvlinkDeviceInfo_IMPL(pGpu, pKernelNvlink) 1238 #endif //__nvoc_kernel_nvlink_h_disabled 1239 1240 #define knvlinkCopyNvlinkDeviceInfo_HAL(pGpu, pKernelNvlink) knvlinkCopyNvlinkDeviceInfo(pGpu, pKernelNvlink) 1241 1242 NV_STATUS knvlinkCopyIoctrlDeviceInfo_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1243 1244 1245 #ifdef __nvoc_kernel_nvlink_h_disabled 1246 static inline NV_STATUS knvlinkCopyIoctrlDeviceInfo(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1247 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1248 return NV_ERR_NOT_SUPPORTED; 1249 } 1250 #else //__nvoc_kernel_nvlink_h_disabled 1251 #define knvlinkCopyIoctrlDeviceInfo(pGpu, pKernelNvlink) knvlinkCopyIoctrlDeviceInfo_IMPL(pGpu, pKernelNvlink) 1252 #endif //__nvoc_kernel_nvlink_h_disabled 1253 1254 #define knvlinkCopyIoctrlDeviceInfo_HAL(pGpu, pKernelNvlink) knvlinkCopyIoctrlDeviceInfo(pGpu, pKernelNvlink) 1255 1256 NV_STATUS knvlinkSetupTopologyForForcedConfig_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1257 1258 1259 #ifdef __nvoc_kernel_nvlink_h_disabled 1260 static inline NV_STATUS knvlinkSetupTopologyForForcedConfig(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1261 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1262 return NV_ERR_NOT_SUPPORTED; 1263 } 1264 #else //__nvoc_kernel_nvlink_h_disabled 1265 #define knvlinkSetupTopologyForForcedConfig(pGpu, pKernelNvlink) knvlinkSetupTopologyForForcedConfig_IMPL(pGpu, pKernelNvlink) 1266 #endif //__nvoc_kernel_nvlink_h_disabled 1267 1268 #define knvlinkSetupTopologyForForcedConfig_HAL(pGpu, pKernelNvlink) knvlinkSetupTopologyForForcedConfig(pGpu, pKernelNvlink) 1269 1270 NV_STATUS knvlinkSyncLaneShutdownProps_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1271 1272 1273 #ifdef __nvoc_kernel_nvlink_h_disabled 1274 static inline NV_STATUS knvlinkSyncLaneShutdownProps(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1275 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1276 return NV_ERR_NOT_SUPPORTED; 1277 } 1278 #else //__nvoc_kernel_nvlink_h_disabled 1279 #define knvlinkSyncLaneShutdownProps(pGpu, pKernelNvlink) knvlinkSyncLaneShutdownProps_IMPL(pGpu, pKernelNvlink) 1280 #endif //__nvoc_kernel_nvlink_h_disabled 1281 1282 #define knvlinkSyncLaneShutdownProps_HAL(pGpu, pKernelNvlink) knvlinkSyncLaneShutdownProps(pGpu, pKernelNvlink) 1283 1284 void knvlinkSetPowerFeatures_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1285 1286 1287 #ifdef __nvoc_kernel_nvlink_h_disabled 1288 static inline void knvlinkSetPowerFeatures(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1289 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1290 } 1291 #else //__nvoc_kernel_nvlink_h_disabled 1292 #define knvlinkSetPowerFeatures(pGpu, pKernelNvlink) knvlinkSetPowerFeatures_IMPL(pGpu, pKernelNvlink) 1293 #endif //__nvoc_kernel_nvlink_h_disabled 1294 1295 #define knvlinkSetPowerFeatures_HAL(pGpu, pKernelNvlink) knvlinkSetPowerFeatures(pGpu, pKernelNvlink) 1296 1297 NV_STATUS knvlinkExecGspRmRpc_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0, void *arg1, NvU32 arg2); 1298 1299 1300 #ifdef __nvoc_kernel_nvlink_h_disabled 1301 static inline NV_STATUS knvlinkExecGspRmRpc(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0, void *arg1, NvU32 arg2) { 1302 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1303 return NV_ERR_NOT_SUPPORTED; 1304 } 1305 #else //__nvoc_kernel_nvlink_h_disabled 1306 #define knvlinkExecGspRmRpc(pGpu, pKernelNvlink, arg0, arg1, arg2) knvlinkExecGspRmRpc_IMPL(pGpu, pKernelNvlink, arg0, arg1, arg2) 1307 #endif //__nvoc_kernel_nvlink_h_disabled 1308 1309 #define knvlinkExecGspRmRpc_HAL(pGpu, pKernelNvlink, arg0, arg1, arg2) knvlinkExecGspRmRpc(pGpu, pKernelNvlink, arg0, arg1, arg2) 1310 1311 NvBool knvlinkIsNvswitchProxyPresent_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1312 1313 1314 #ifdef __nvoc_kernel_nvlink_h_disabled 1315 static inline NvBool knvlinkIsNvswitchProxyPresent(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1316 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1317 return NV_FALSE; 1318 } 1319 #else //__nvoc_kernel_nvlink_h_disabled 1320 #define knvlinkIsNvswitchProxyPresent(pGpu, pKernelNvlink) knvlinkIsNvswitchProxyPresent_IMPL(pGpu, pKernelNvlink) 1321 #endif //__nvoc_kernel_nvlink_h_disabled 1322 1323 #define knvlinkIsNvswitchProxyPresent_HAL(pGpu, pKernelNvlink) knvlinkIsNvswitchProxyPresent(pGpu, pKernelNvlink) 1324 1325 void knvlinkDetectNvswitchProxy_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1326 1327 1328 #ifdef __nvoc_kernel_nvlink_h_disabled 1329 static inline void knvlinkDetectNvswitchProxy(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1330 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1331 } 1332 #else //__nvoc_kernel_nvlink_h_disabled 1333 #define knvlinkDetectNvswitchProxy(pGpu, pKernelNvlink) knvlinkDetectNvswitchProxy_IMPL(pGpu, pKernelNvlink) 1334 #endif //__nvoc_kernel_nvlink_h_disabled 1335 1336 #define knvlinkDetectNvswitchProxy_HAL(pGpu, pKernelNvlink) knvlinkDetectNvswitchProxy(pGpu, pKernelNvlink) 1337 1338 NV_STATUS knvlinkSetUniqueFlaBaseAddress_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0); 1339 1340 1341 #ifdef __nvoc_kernel_nvlink_h_disabled 1342 static inline NV_STATUS knvlinkSetUniqueFlaBaseAddress(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0) { 1343 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1344 return NV_ERR_NOT_SUPPORTED; 1345 } 1346 #else //__nvoc_kernel_nvlink_h_disabled 1347 #define knvlinkSetUniqueFlaBaseAddress(pGpu, pKernelNvlink, arg0) knvlinkSetUniqueFlaBaseAddress_IMPL(pGpu, pKernelNvlink, arg0) 1348 #endif //__nvoc_kernel_nvlink_h_disabled 1349 1350 #define knvlinkSetUniqueFlaBaseAddress_HAL(pGpu, pKernelNvlink, arg0) knvlinkSetUniqueFlaBaseAddress(pGpu, pKernelNvlink, arg0) 1351 1352 NV_STATUS knvlinkFloorSweep_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 numLinksPerIp, NvU32 *pNumActiveLinks); 1353 1354 1355 #ifdef __nvoc_kernel_nvlink_h_disabled 1356 static inline NV_STATUS knvlinkFloorSweep(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 numLinksPerIp, NvU32 *pNumActiveLinks) { 1357 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1358 return NV_ERR_NOT_SUPPORTED; 1359 } 1360 #else //__nvoc_kernel_nvlink_h_disabled 1361 #define knvlinkFloorSweep(pGpu, pKernelNvlink, numLinksPerIp, pNumActiveLinks) knvlinkFloorSweep_IMPL(pGpu, pKernelNvlink, numLinksPerIp, pNumActiveLinks) 1362 #endif //__nvoc_kernel_nvlink_h_disabled 1363 1364 #define knvlinkFloorSweep_HAL(pGpu, pKernelNvlink, numLinksPerIp, pNumActiveLinks) knvlinkFloorSweep(pGpu, pKernelNvlink, numLinksPerIp, pNumActiveLinks) 1365 1366 static inline NvU64 knvlinkGetUniqueFabricBaseAddress_e203db(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1367 struct KernelNvlink_PRIVATE *pKernelNvlink_PRIVATE = (struct KernelNvlink_PRIVATE *)pKernelNvlink; 1368 return pKernelNvlink_PRIVATE->fabricBaseAddr; 1369 } 1370 1371 1372 #ifdef __nvoc_kernel_nvlink_h_disabled 1373 static inline NvU64 knvlinkGetUniqueFabricBaseAddress(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1374 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1375 return 0; 1376 } 1377 #else //__nvoc_kernel_nvlink_h_disabled 1378 #define knvlinkGetUniqueFabricBaseAddress(pGpu, pKernelNvlink) knvlinkGetUniqueFabricBaseAddress_e203db(pGpu, pKernelNvlink) 1379 #endif //__nvoc_kernel_nvlink_h_disabled 1380 1381 #define knvlinkGetUniqueFabricBaseAddress_HAL(pGpu, pKernelNvlink) knvlinkGetUniqueFabricBaseAddress(pGpu, pKernelNvlink) 1382 1383 static inline NvU64 knvlinkGetUniqueFabricEgmBaseAddress_4de472(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1384 struct KernelNvlink_PRIVATE *pKernelNvlink_PRIVATE = (struct KernelNvlink_PRIVATE *)pKernelNvlink; 1385 return pKernelNvlink_PRIVATE->fabricEgmBaseAddr; 1386 } 1387 1388 1389 #ifdef __nvoc_kernel_nvlink_h_disabled 1390 static inline NvU64 knvlinkGetUniqueFabricEgmBaseAddress(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1391 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1392 return 0; 1393 } 1394 #else //__nvoc_kernel_nvlink_h_disabled 1395 #define knvlinkGetUniqueFabricEgmBaseAddress(pGpu, pKernelNvlink) knvlinkGetUniqueFabricEgmBaseAddress_4de472(pGpu, pKernelNvlink) 1396 #endif //__nvoc_kernel_nvlink_h_disabled 1397 1398 #define knvlinkGetUniqueFabricEgmBaseAddress_HAL(pGpu, pKernelNvlink) knvlinkGetUniqueFabricEgmBaseAddress(pGpu, pKernelNvlink) 1399 1400 NV_STATUS knvlinkStatePostLoadHal_GV100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1401 1402 1403 #ifdef __nvoc_kernel_nvlink_h_disabled 1404 static inline NV_STATUS knvlinkStatePostLoadHal(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1405 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1406 return NV_ERR_NOT_SUPPORTED; 1407 } 1408 #else //__nvoc_kernel_nvlink_h_disabled 1409 #define knvlinkStatePostLoadHal(pGpu, pKernelNvlink) knvlinkStatePostLoadHal_GV100(pGpu, pKernelNvlink) 1410 #endif //__nvoc_kernel_nvlink_h_disabled 1411 1412 #define knvlinkStatePostLoadHal_HAL(pGpu, pKernelNvlink) knvlinkStatePostLoadHal(pGpu, pKernelNvlink) 1413 1414 NV_STATUS knvlinkApplyNvswitchDegradedModeSettings_GV100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 *switchLinkMasks); 1415 1416 1417 #ifdef __nvoc_kernel_nvlink_h_disabled 1418 static inline NV_STATUS knvlinkApplyNvswitchDegradedModeSettings(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 *switchLinkMasks) { 1419 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1420 return NV_ERR_NOT_SUPPORTED; 1421 } 1422 #else //__nvoc_kernel_nvlink_h_disabled 1423 #define knvlinkApplyNvswitchDegradedModeSettings(pGpu, pKernelNvlink, switchLinkMasks) knvlinkApplyNvswitchDegradedModeSettings_GV100(pGpu, pKernelNvlink, switchLinkMasks) 1424 #endif //__nvoc_kernel_nvlink_h_disabled 1425 1426 #define knvlinkApplyNvswitchDegradedModeSettings_HAL(pGpu, pKernelNvlink, switchLinkMasks) knvlinkApplyNvswitchDegradedModeSettings(pGpu, pKernelNvlink, switchLinkMasks) 1427 1428 NvU32 knvlinkGetNumActiveLinksPerIoctrl_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1429 1430 1431 #ifdef __nvoc_kernel_nvlink_h_disabled 1432 static inline NvU32 knvlinkGetNumActiveLinksPerIoctrl(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1433 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1434 return 0; 1435 } 1436 #else //__nvoc_kernel_nvlink_h_disabled 1437 #define knvlinkGetNumActiveLinksPerIoctrl(pGpu, pKernelNvlink) knvlinkGetNumActiveLinksPerIoctrl_IMPL(pGpu, pKernelNvlink) 1438 #endif //__nvoc_kernel_nvlink_h_disabled 1439 1440 #define knvlinkGetNumActiveLinksPerIoctrl_HAL(pGpu, pKernelNvlink) knvlinkGetNumActiveLinksPerIoctrl(pGpu, pKernelNvlink) 1441 1442 NvU32 knvlinkGetTotalNumLinksPerIoctrl_IMPL(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1443 1444 1445 #ifdef __nvoc_kernel_nvlink_h_disabled 1446 static inline NvU32 knvlinkGetTotalNumLinksPerIoctrl(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1447 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1448 return 0; 1449 } 1450 #else //__nvoc_kernel_nvlink_h_disabled 1451 #define knvlinkGetTotalNumLinksPerIoctrl(pGpu, pKernelNvlink) knvlinkGetTotalNumLinksPerIoctrl_IMPL(pGpu, pKernelNvlink) 1452 #endif //__nvoc_kernel_nvlink_h_disabled 1453 1454 #define knvlinkGetTotalNumLinksPerIoctrl_HAL(pGpu, pKernelNvlink) knvlinkGetTotalNumLinksPerIoctrl(pGpu, pKernelNvlink) 1455 1456 void knvlinkCoreGetDevicePciInfo_GP100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, nvlink_device_info *devInfo); 1457 1458 1459 #ifdef __nvoc_kernel_nvlink_h_disabled 1460 static inline void knvlinkCoreGetDevicePciInfo(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, nvlink_device_info *devInfo) { 1461 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1462 } 1463 #else //__nvoc_kernel_nvlink_h_disabled 1464 #define knvlinkCoreGetDevicePciInfo(pGpu, pKernelNvlink, devInfo) knvlinkCoreGetDevicePciInfo_GP100(pGpu, pKernelNvlink, devInfo) 1465 #endif //__nvoc_kernel_nvlink_h_disabled 1466 1467 #define knvlinkCoreGetDevicePciInfo_HAL(pGpu, pKernelNvlink, devInfo) knvlinkCoreGetDevicePciInfo(pGpu, pKernelNvlink, devInfo) 1468 1469 NV_STATUS knvlinkConstructEngine_IMPL(struct OBJGPU *arg0, struct KernelNvlink *arg1, ENGDESCRIPTOR arg2); 1470 1471 static inline NV_STATUS knvlinkConstructEngine_DISPATCH(struct OBJGPU *arg0, struct KernelNvlink *arg1, ENGDESCRIPTOR arg2) { 1472 return arg1->__knvlinkConstructEngine__(arg0, arg1, arg2); 1473 } 1474 1475 NV_STATUS knvlinkStatePreInitLocked_IMPL(struct OBJGPU *arg0, struct KernelNvlink *arg1); 1476 1477 static inline NV_STATUS knvlinkStatePreInitLocked_DISPATCH(struct OBJGPU *arg0, struct KernelNvlink *arg1) { 1478 return arg1->__knvlinkStatePreInitLocked__(arg0, arg1); 1479 } 1480 1481 NV_STATUS knvlinkStateLoad_IMPL(struct OBJGPU *arg0, struct KernelNvlink *arg1, NvU32 arg2); 1482 1483 static inline NV_STATUS knvlinkStateLoad_DISPATCH(struct OBJGPU *arg0, struct KernelNvlink *arg1, NvU32 arg2) { 1484 return arg1->__knvlinkStateLoad__(arg0, arg1, arg2); 1485 } 1486 1487 NV_STATUS knvlinkStatePostLoad_IMPL(struct OBJGPU *arg0, struct KernelNvlink *arg1, NvU32 arg2); 1488 1489 static inline NV_STATUS knvlinkStatePostLoad_DISPATCH(struct OBJGPU *arg0, struct KernelNvlink *arg1, NvU32 arg2) { 1490 return arg1->__knvlinkStatePostLoad__(arg0, arg1, arg2); 1491 } 1492 1493 NV_STATUS knvlinkStateUnload_IMPL(struct OBJGPU *arg0, struct KernelNvlink *arg1, NvU32 arg2); 1494 1495 static inline NV_STATUS knvlinkStateUnload_DISPATCH(struct OBJGPU *arg0, struct KernelNvlink *arg1, NvU32 arg2) { 1496 return arg1->__knvlinkStateUnload__(arg0, arg1, arg2); 1497 } 1498 1499 NV_STATUS knvlinkStatePostUnload_IMPL(struct OBJGPU *arg0, struct KernelNvlink *arg1, NvU32 arg2); 1500 1501 static inline NV_STATUS knvlinkStatePostUnload_DISPATCH(struct OBJGPU *arg0, struct KernelNvlink *arg1, NvU32 arg2) { 1502 return arg1->__knvlinkStatePostUnload__(arg0, arg1, arg2); 1503 } 1504 1505 NvBool knvlinkIsPresent_IMPL(struct OBJGPU *arg0, struct KernelNvlink *arg1); 1506 1507 static inline NvBool knvlinkIsPresent_DISPATCH(struct OBJGPU *arg0, struct KernelNvlink *arg1) { 1508 return arg1->__knvlinkIsPresent__(arg0, arg1); 1509 } 1510 1511 NV_STATUS knvlinkSetUniqueFabricBaseAddress_GV100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0); 1512 1513 NV_STATUS knvlinkSetUniqueFabricBaseAddress_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0); 1514 1515 static inline NV_STATUS knvlinkSetUniqueFabricBaseAddress_46f6a7(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0) { 1516 return NV_ERR_NOT_SUPPORTED; 1517 } 1518 1519 static inline NV_STATUS knvlinkSetUniqueFabricBaseAddress_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0) { 1520 return pKernelNvlink->__knvlinkSetUniqueFabricBaseAddress__(pGpu, pKernelNvlink, arg0); 1521 } 1522 1523 static inline void knvlinkClearUniqueFabricBaseAddress_b3696a(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1524 return; 1525 } 1526 1527 void knvlinkClearUniqueFabricBaseAddress_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1528 1529 static inline void knvlinkClearUniqueFabricBaseAddress_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1530 pKernelNvlink->__knvlinkClearUniqueFabricBaseAddress__(pGpu, pKernelNvlink); 1531 } 1532 1533 NV_STATUS knvlinkSetUniqueFabricEgmBaseAddress_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0); 1534 1535 static inline NV_STATUS knvlinkSetUniqueFabricEgmBaseAddress_46f6a7(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0) { 1536 return NV_ERR_NOT_SUPPORTED; 1537 } 1538 1539 static inline NV_STATUS knvlinkSetUniqueFabricEgmBaseAddress_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0) { 1540 return pKernelNvlink->__knvlinkSetUniqueFabricEgmBaseAddress__(pGpu, pKernelNvlink, arg0); 1541 } 1542 1543 static inline void knvlinkClearUniqueFabricEgmBaseAddress_b3696a(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1544 return; 1545 } 1546 1547 void knvlinkClearUniqueFabricEgmBaseAddress_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1548 1549 static inline void knvlinkClearUniqueFabricEgmBaseAddress_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1550 pKernelNvlink->__knvlinkClearUniqueFabricEgmBaseAddress__(pGpu, pKernelNvlink); 1551 } 1552 1553 NV_STATUS knvlinkHandleFaultUpInterrupt_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0); 1554 1555 static inline NV_STATUS knvlinkHandleFaultUpInterrupt_46f6a7(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0) { 1556 return NV_ERR_NOT_SUPPORTED; 1557 } 1558 1559 static inline NV_STATUS knvlinkHandleFaultUpInterrupt_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0) { 1560 return pKernelNvlink->__knvlinkHandleFaultUpInterrupt__(pGpu, pKernelNvlink, arg0); 1561 } 1562 1563 NV_STATUS knvlinkValidateFabricBaseAddress_GA100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0); 1564 1565 NV_STATUS knvlinkValidateFabricBaseAddress_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0); 1566 1567 static inline NV_STATUS knvlinkValidateFabricBaseAddress_46f6a7(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0) { 1568 return NV_ERR_NOT_SUPPORTED; 1569 } 1570 1571 static inline NV_STATUS knvlinkValidateFabricBaseAddress_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0) { 1572 return pKernelNvlink->__knvlinkValidateFabricBaseAddress__(pGpu, pKernelNvlink, arg0); 1573 } 1574 1575 NV_STATUS knvlinkValidateFabricEgmBaseAddress_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0); 1576 1577 static inline NV_STATUS knvlinkValidateFabricEgmBaseAddress_46f6a7(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0) { 1578 return NV_ERR_NOT_SUPPORTED; 1579 } 1580 1581 static inline NV_STATUS knvlinkValidateFabricEgmBaseAddress_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU64 arg0) { 1582 return pKernelNvlink->__knvlinkValidateFabricEgmBaseAddress__(pGpu, pKernelNvlink, arg0); 1583 } 1584 1585 static inline NvU32 knvlinkGetConnectedLinksMask_15a734(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1586 return 0U; 1587 } 1588 1589 NvU32 knvlinkGetConnectedLinksMask_TU102(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1590 1591 static inline NvU32 knvlinkGetConnectedLinksMask_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1592 return pKernelNvlink->__knvlinkGetConnectedLinksMask__(pGpu, pKernelNvlink); 1593 } 1594 1595 static inline NV_STATUS knvlinkEnableLinksPostTopology_56cd7a(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0) { 1596 return NV_OK; 1597 } 1598 1599 NV_STATUS knvlinkEnableLinksPostTopology_GV100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0); 1600 1601 static inline NV_STATUS knvlinkEnableLinksPostTopology_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0) { 1602 return pKernelNvlink->__knvlinkEnableLinksPostTopology__(pGpu, pKernelNvlink, arg0); 1603 } 1604 1605 static inline NV_STATUS knvlinkOverrideConfig_56cd7a(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0) { 1606 return NV_OK; 1607 } 1608 1609 NV_STATUS knvlinkOverrideConfig_GV100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0); 1610 1611 NV_STATUS knvlinkOverrideConfig_GA100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0); 1612 1613 static inline NV_STATUS knvlinkOverrideConfig_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0) { 1614 return pKernelNvlink->__knvlinkOverrideConfig__(pGpu, pKernelNvlink, arg0); 1615 } 1616 1617 NV_STATUS knvlinkFilterBridgeLinks_TU102(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1618 1619 static inline NV_STATUS knvlinkFilterBridgeLinks_46f6a7(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1620 return NV_ERR_NOT_SUPPORTED; 1621 } 1622 1623 static inline NV_STATUS knvlinkFilterBridgeLinks_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1624 return pKernelNvlink->__knvlinkFilterBridgeLinks__(pGpu, pKernelNvlink); 1625 } 1626 1627 NvU32 knvlinkGetUniquePeerIdMask_GP100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1628 1629 static inline NvU32 knvlinkGetUniquePeerIdMask_15a734(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1630 return 0U; 1631 } 1632 1633 static inline NvU32 knvlinkGetUniquePeerIdMask_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1634 return pKernelNvlink->__knvlinkGetUniquePeerIdMask__(pGpu, pKernelNvlink); 1635 } 1636 1637 static inline NvU32 knvlinkGetUniquePeerId_c732fb(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pRemoteGpu) { 1638 return 4294967295U; 1639 } 1640 1641 NvU32 knvlinkGetUniquePeerId_GP100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pRemoteGpu); 1642 1643 static inline NvU32 knvlinkGetUniquePeerId_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pRemoteGpu) { 1644 return pKernelNvlink->__knvlinkGetUniquePeerId__(pGpu, pKernelNvlink, pRemoteGpu); 1645 } 1646 1647 static inline NV_STATUS knvlinkRemoveMapping_56cd7a(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvBool bAllMapping, NvU32 peerMask, NvBool bL2Entry) { 1648 return NV_OK; 1649 } 1650 1651 NV_STATUS knvlinkRemoveMapping_GP100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvBool bAllMapping, NvU32 peerMask, NvBool bL2Entry); 1652 1653 NV_STATUS knvlinkRemoveMapping_GA100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvBool bAllMapping, NvU32 peerMask, NvBool bL2Entry); 1654 1655 static inline NV_STATUS knvlinkRemoveMapping_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvBool bAllMapping, NvU32 peerMask, NvBool bL2Entry) { 1656 return pKernelNvlink->__knvlinkRemoveMapping__(pGpu, pKernelNvlink, bAllMapping, peerMask, bL2Entry); 1657 } 1658 1659 static inline NV_STATUS knvlinkGetP2POptimalCEs_56cd7a(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0, NvU32 *arg1, NvU32 *arg2, NvU32 *arg3, NvU32 *arg4) { 1660 return NV_OK; 1661 } 1662 1663 NV_STATUS knvlinkGetP2POptimalCEs_GP100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0, NvU32 *arg1, NvU32 *arg2, NvU32 *arg3, NvU32 *arg4); 1664 1665 static inline NV_STATUS knvlinkGetP2POptimalCEs_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 arg0, NvU32 *arg1, NvU32 *arg2, NvU32 *arg3, NvU32 *arg4) { 1666 return pKernelNvlink->__knvlinkGetP2POptimalCEs__(pGpu, pKernelNvlink, arg0, arg1, arg2, arg3, arg4); 1667 } 1668 1669 static inline NV_STATUS knvlinkConstructHal_56cd7a(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1670 return NV_OK; 1671 } 1672 1673 NV_STATUS knvlinkConstructHal_GV100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1674 1675 static inline NV_STATUS knvlinkConstructHal_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1676 return pKernelNvlink->__knvlinkConstructHal__(pGpu, pKernelNvlink); 1677 } 1678 1679 static inline void knvlinkSetupPeerMapping_b3696a(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pRemoteGpu, NvU32 peerId) { 1680 return; 1681 } 1682 1683 void knvlinkSetupPeerMapping_GP100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pRemoteGpu, NvU32 peerId); 1684 1685 static inline void knvlinkSetupPeerMapping_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pRemoteGpu, NvU32 peerId) { 1686 pKernelNvlink->__knvlinkSetupPeerMapping__(pGpu, pKernelNvlink, pRemoteGpu, peerId); 1687 } 1688 1689 static inline NV_STATUS knvlinkProgramLinkSpeed_56cd7a(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1690 return NV_OK; 1691 } 1692 1693 NV_STATUS knvlinkProgramLinkSpeed_GV100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1694 1695 static inline NV_STATUS knvlinkProgramLinkSpeed_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1696 return pKernelNvlink->__knvlinkProgramLinkSpeed__(pGpu, pKernelNvlink); 1697 } 1698 1699 static inline NvBool knvlinkPoweredUpForD3_491d52(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1700 return ((NvBool)(0 != 0)); 1701 } 1702 1703 NvBool knvlinkPoweredUpForD3_TU102(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1704 1705 static inline NvBool knvlinkPoweredUpForD3_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1706 return pKernelNvlink->__knvlinkPoweredUpForD3__(pGpu, pKernelNvlink); 1707 } 1708 1709 static inline NV_STATUS knvlinkIsAliSupported_56cd7a(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1710 return NV_OK; 1711 } 1712 1713 NV_STATUS knvlinkIsAliSupported_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1714 1715 static inline NV_STATUS knvlinkIsAliSupported_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1716 return pKernelNvlink->__knvlinkIsAliSupported__(pGpu, pKernelNvlink); 1717 } 1718 1719 static inline NV_STATUS knvlinkPostSetupNvlinkPeer_56cd7a(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1720 return NV_OK; 1721 } 1722 1723 NV_STATUS knvlinkPostSetupNvlinkPeer_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1724 1725 static inline NV_STATUS knvlinkPostSetupNvlinkPeer_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1726 return pKernelNvlink->__knvlinkPostSetupNvlinkPeer__(pGpu, pKernelNvlink); 1727 } 1728 1729 NV_STATUS knvlinkDiscoverPostRxDetLinks_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pPeerGpu); 1730 1731 static inline NV_STATUS knvlinkDiscoverPostRxDetLinks_46f6a7(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pPeerGpu) { 1732 return NV_ERR_NOT_SUPPORTED; 1733 } 1734 1735 static inline NV_STATUS knvlinkDiscoverPostRxDetLinks_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pPeerGpu) { 1736 return pKernelNvlink->__knvlinkDiscoverPostRxDetLinks__(pGpu, pKernelNvlink, pPeerGpu); 1737 } 1738 1739 NV_STATUS knvlinkLogAliDebugMessages_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1740 1741 static inline NV_STATUS knvlinkLogAliDebugMessages_46f6a7(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1742 return NV_ERR_NOT_SUPPORTED; 1743 } 1744 1745 static inline NV_STATUS knvlinkLogAliDebugMessages_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1746 return pKernelNvlink->__knvlinkLogAliDebugMessages__(pGpu, pKernelNvlink); 1747 } 1748 1749 static inline void knvlinkGetEffectivePeerLinkMask_b3696a(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pRemoteGpu, NvU32 *pPeerLinkMask) { 1750 return; 1751 } 1752 1753 void knvlinkGetEffectivePeerLinkMask_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pRemoteGpu, NvU32 *pPeerLinkMask); 1754 1755 static inline void knvlinkGetEffectivePeerLinkMask_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, struct OBJGPU *pRemoteGpu, NvU32 *pPeerLinkMask) { 1756 pKernelNvlink->__knvlinkGetEffectivePeerLinkMask__(pGpu, pKernelNvlink, pRemoteGpu, pPeerLinkMask); 1757 } 1758 1759 static inline NvU32 knvlinkGetNumLinksToBeReducedPerIoctrl_4a4dee(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1760 return 0; 1761 } 1762 1763 NvU32 knvlinkGetNumLinksToBeReducedPerIoctrl_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1764 1765 static inline NvU32 knvlinkGetNumLinksToBeReducedPerIoctrl_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1766 return pKernelNvlink->__knvlinkGetNumLinksToBeReducedPerIoctrl__(pGpu, pKernelNvlink); 1767 } 1768 1769 static inline NvBool knvlinkIsBandwidthModeOff_491d52(struct KernelNvlink *pKernelNvlink) { 1770 return ((NvBool)(0 != 0)); 1771 } 1772 1773 NvBool knvlinkIsBandwidthModeOff_GH100(struct KernelNvlink *pKernelNvlink); 1774 1775 static inline NvBool knvlinkIsBandwidthModeOff_DISPATCH(struct KernelNvlink *pKernelNvlink) { 1776 return pKernelNvlink->__knvlinkIsBandwidthModeOff__(pKernelNvlink); 1777 } 1778 1779 static inline void knvlinkDirectConnectCheck_b3696a(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1780 return; 1781 } 1782 1783 void knvlinkDirectConnectCheck_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1784 1785 static inline void knvlinkDirectConnectCheck_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1786 pKernelNvlink->__knvlinkDirectConnectCheck__(pGpu, pKernelNvlink); 1787 } 1788 1789 static inline NvBool knvlinkIsGpuReducedNvlinkConfig_491d52(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1790 return ((NvBool)(0 != 0)); 1791 } 1792 1793 NvBool knvlinkIsGpuReducedNvlinkConfig_GA100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink); 1794 1795 static inline NvBool knvlinkIsGpuReducedNvlinkConfig_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1796 return pKernelNvlink->__knvlinkIsGpuReducedNvlinkConfig__(pGpu, pKernelNvlink); 1797 } 1798 1799 static inline NvBool knvlinkIsFloorSweepingNeeded_491d52(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 numActiveLinksPerIoctrl, NvU32 numLinksPerIoctrl) { 1800 return ((NvBool)(0 != 0)); 1801 } 1802 1803 NvBool knvlinkIsFloorSweepingNeeded_GH100(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 numActiveLinksPerIoctrl, NvU32 numLinksPerIoctrl); 1804 1805 static inline NvBool knvlinkIsFloorSweepingNeeded_DISPATCH(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 numActiveLinksPerIoctrl, NvU32 numLinksPerIoctrl) { 1806 return pKernelNvlink->__knvlinkIsFloorSweepingNeeded__(pGpu, pKernelNvlink, numActiveLinksPerIoctrl, numLinksPerIoctrl); 1807 } 1808 1809 static inline NV_STATUS knvlinkStateInitLocked_DISPATCH(POBJGPU pGpu, struct KernelNvlink *pEngstate) { 1810 return pEngstate->__knvlinkStateInitLocked__(pGpu, pEngstate); 1811 } 1812 1813 static inline NV_STATUS knvlinkStatePreLoad_DISPATCH(POBJGPU pGpu, struct KernelNvlink *pEngstate, NvU32 arg0) { 1814 return pEngstate->__knvlinkStatePreLoad__(pGpu, pEngstate, arg0); 1815 } 1816 1817 static inline void knvlinkStateDestroy_DISPATCH(POBJGPU pGpu, struct KernelNvlink *pEngstate) { 1818 pEngstate->__knvlinkStateDestroy__(pGpu, pEngstate); 1819 } 1820 1821 static inline NV_STATUS knvlinkStatePreUnload_DISPATCH(POBJGPU pGpu, struct KernelNvlink *pEngstate, NvU32 arg0) { 1822 return pEngstate->__knvlinkStatePreUnload__(pGpu, pEngstate, arg0); 1823 } 1824 1825 static inline NV_STATUS knvlinkStateInitUnlocked_DISPATCH(POBJGPU pGpu, struct KernelNvlink *pEngstate) { 1826 return pEngstate->__knvlinkStateInitUnlocked__(pGpu, pEngstate); 1827 } 1828 1829 static inline void knvlinkInitMissing_DISPATCH(POBJGPU pGpu, struct KernelNvlink *pEngstate) { 1830 pEngstate->__knvlinkInitMissing__(pGpu, pEngstate); 1831 } 1832 1833 static inline NV_STATUS knvlinkStatePreInitUnlocked_DISPATCH(POBJGPU pGpu, struct KernelNvlink *pEngstate) { 1834 return pEngstate->__knvlinkStatePreInitUnlocked__(pGpu, pEngstate); 1835 } 1836 1837 static inline NvU32 knvlinkGetInitializedLinkMask(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1838 struct KernelNvlink_PRIVATE *pKernelNvlink_PRIVATE = (struct KernelNvlink_PRIVATE *)pKernelNvlink; 1839 return pKernelNvlink_PRIVATE->initializedLinks; 1840 } 1841 1842 static inline NvBool knvlinkAreLinksRegistryOverriden(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1843 struct KernelNvlink_PRIVATE *pKernelNvlink_PRIVATE = (struct KernelNvlink_PRIVATE *)pKernelNvlink; 1844 return pKernelNvlink_PRIVATE->bRegistryLinkOverride; 1845 } 1846 1847 static inline NvU32 knvlinkGetPeerLinkMask(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 peerId) { 1848 struct KernelNvlink_PRIVATE *pKernelNvlink_PRIVATE = (struct KernelNvlink_PRIVATE *)pKernelNvlink; 1849 return (peerId < ((sizeof (pKernelNvlink_PRIVATE->peerLinkMasks) / sizeof ((pKernelNvlink_PRIVATE->peerLinkMasks)[0])))) ? pKernelNvlink_PRIVATE->peerLinkMasks[peerId] : 0; 1850 } 1851 1852 static inline KNVLINK_RM_LINK *knvlinkGetLinkData(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 linkId) { 1853 struct KernelNvlink_PRIVATE *pKernelNvlink_PRIVATE = (struct KernelNvlink_PRIVATE *)pKernelNvlink; 1854 return (linkId < ((sizeof (pKernelNvlink_PRIVATE->nvlinkLinks) / sizeof ((pKernelNvlink_PRIVATE->nvlinkLinks)[0])))) ? &pKernelNvlink_PRIVATE->nvlinkLinks[linkId] : ((void *)0); 1855 } 1856 1857 static inline NvU32 knvlinkGetIPVersion(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1858 struct KernelNvlink_PRIVATE *pKernelNvlink_PRIVATE = (struct KernelNvlink_PRIVATE *)pKernelNvlink; 1859 return pKernelNvlink_PRIVATE->ipVerNvlink; 1860 } 1861 1862 static inline NvU32 knvlinkGetMinionControl(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink) { 1863 struct KernelNvlink_PRIVATE *pKernelNvlink_PRIVATE = (struct KernelNvlink_PRIVATE *)pKernelNvlink; 1864 return pKernelNvlink_PRIVATE->minionControl; 1865 } 1866 1867 void knvlinkDestruct_IMPL(struct KernelNvlink *arg0); 1868 1869 #define __nvoc_knvlinkDestruct(arg0) knvlinkDestruct_IMPL(arg0) 1870 NV_STATUS knvlinkRemoveMissingIoctrlObjects_IMPL(struct OBJGPU *arg0, struct KernelNvlink *arg1); 1871 1872 #ifdef __nvoc_kernel_nvlink_h_disabled 1873 static inline NV_STATUS knvlinkRemoveMissingIoctrlObjects(struct OBJGPU *arg0, struct KernelNvlink *arg1) { 1874 NV_ASSERT_FAILED_PRECOMP("KernelNvlink was disabled!"); 1875 return NV_ERR_NOT_SUPPORTED; 1876 } 1877 #else //__nvoc_kernel_nvlink_h_disabled 1878 #define knvlinkRemoveMissingIoctrlObjects(arg0, arg1) knvlinkRemoveMissingIoctrlObjects_IMPL(arg0, arg1) 1879 #endif //__nvoc_kernel_nvlink_h_disabled 1880 1881 #undef PRIVATE_FIELD 1882 1883 1884 1885 // IOCTRL GET defines 1886 #define KNVLINK_GET_IOCTRL(pKernelNvlink, PublicId) (pKernelNvlink->pKernelIoctrl[PublicId]) 1887 #define KNVLINK_LINK_GET_IOCTRL(pKernelNvlink, linkId) \ 1888 (KNVLINK_GET_IOCTRL(pKernelNvlink, pKernelNvlink->nvlinkLinks[linkId].ioctrlId)) 1889 1890 #define KNVLINK_IS_LINK_CONNECTED_TO_GPU(pKernelNvlink, linkId, pRemoteGpu) \ 1891 ((pKernelNvlink != NULL) && (pRemoteGpu != NULL) && \ 1892 (pKernelNvlink->nvlinkLinks[linkId].remoteEndInfo.bConnected) && \ 1893 (pKernelNvlink->nvlinkLinks[linkId].remoteEndInfo.domain == gpuGetDomain(pRemoteGpu)) && \ 1894 (pKernelNvlink->nvlinkLinks[linkId].remoteEndInfo.bus == gpuGetBus(pRemoteGpu)) && \ 1895 (pKernelNvlink->nvlinkLinks[linkId].remoteEndInfo.device == gpuGetDevice(pRemoteGpu)) && \ 1896 (pKernelNvlink->nvlinkLinks[linkId].remoteEndInfo.function == 0)) 1897 1898 // 1899 // NVLINK internal functions 1900 // 1901 NV_STATUS knvlinkRetrainLinkFromOff (struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 linkId); 1902 NV_STATUS knvlinkRetrainLinkFromSafe(struct OBJGPU *pGpu, struct KernelNvlink *pKernelNvlink, NvU32 linkId); 1903 1904 // 1905 // NVLINK Callback functions from core library 1906 // 1907 #if defined(INCLUDE_NVLINK_LIB) 1908 1909 // Device callback functions 1910 1911 NvlStatus knvlinkCoreAddDeviceCallback (nvlink_device *dev); 1912 NvlStatus knvlinkCoreRemoveDeviceCallback(nvlink_device *dev); 1913 1914 // Link callback functions 1915 1916 NvlStatus knvlinkCoreAddLinkCallback (nvlink_link *link); 1917 NvlStatus knvlinkCoreRemoveLinkCallback (nvlink_link *link); 1918 NvlStatus knvlinkCoreLockLinkCallback (nvlink_link *link); 1919 void knvlinkCoreUnlockLinkCallback (nvlink_link *link); 1920 NvlStatus knvlinkCoreQueueLinkChangeCallback (nvlink_link_change *link_change); 1921 NvlStatus knvlinkCoreSetDlLinkModeCallback (nvlink_link *link, NvU64 mode, NvU32 flags); 1922 NvlStatus knvlinkCoreGetDlLinkModeCallback (nvlink_link *link, NvU64 *mode); 1923 NvlStatus knvlinkCoreSetTlLinkModeCallback (nvlink_link *link, NvU64 mode, NvU32 flags); 1924 NvlStatus knvlinkCoreGetTlLinkModeCallback (nvlink_link *link, NvU64 *mode); 1925 NvlStatus knvlinkCoreWriteDiscoveryTokenCallback (nvlink_link *link, NvU64 token); 1926 NvlStatus knvlinkCoreReadDiscoveryTokenCallback (nvlink_link *link, NvU64 *token); 1927 NvlStatus knvlinkCoreSetTxSublinkModeCallback (nvlink_link *link, NvU64 mode, NvU32 flags); 1928 NvlStatus knvlinkCoreSetRxSublinkModeCallback (nvlink_link *link, NvU64 mode, NvU32 flags); 1929 NvlStatus knvlinkCoreGetTxSublinkModeCallback (nvlink_link *link, NvU64 *mode, NvU32 *subMode); 1930 NvlStatus knvlinkCoreGetRxSublinkModeCallback (nvlink_link *link, NvU64 *mode, NvU32 *subMode); 1931 NvlStatus knvlinkCoreSetRxSublinkDetectCallback (nvlink_link *link, NvU32 flags); 1932 NvlStatus knvlinkCoreGetRxSublinkDetectCallback (nvlink_link *link); 1933 void knvlinkCoreTrainingCompleteCallback (nvlink_link *link); 1934 void knvlinkCoreGetUphyLoadCallback (nvlink_link *link, NvBool *bUnlocked); 1935 NvlStatus knvlinkCoreAliTrainingCallback (nvlink_link *link); 1936 1937 NvlStatus knvlinkCoreGetCciLinkModeCallback (nvlink_link *link, NvU64 *mode); 1938 1939 #endif 1940 1941 // NVLINK Utility Functions 1942 void knvlinkUtoa(NvU8 *, NvU64, NvU64); 1943 1944 NV_STATUS ioctrlFaultUpTmrHandler(struct OBJGPU *, struct OBJTMR *,TMR_EVENT *); 1945 1946 #endif // _KERNEL_NVLINK_H_ 1947 1948 #ifdef __cplusplus 1949 } // extern "C" 1950 #endif 1951 1952 #endif // _G_KERNEL_NVLINK_NVOC_H_ 1953