580.94.06

Author: russellcnv

README.md

@@ -1,7 +1,7 @@
 # NVIDIA Linux Open GPU Kernel Module Source
 
 This is the source release of the NVIDIA Linux open GPU kernel modules,
-version 580.94.03.
+version 580.94.06.
 
 
 ## How to Build
@@ -17,7 +17,7 @@ as root:
 
 Note that the kernel modules built here must be used with GSP
 firmware and user-space NVIDIA GPU driver components from a corresponding
-580.94.03 driver release.  This can be achieved by installing
+580.94.06 driver release.  This can be achieved by installing
 the NVIDIA GPU driver from the .run file using the `--no-kernel-modules`
 option.  E.g.,
 
@@ -185,7 +185,7 @@ table below).
 For details on feature support and limitations, see the NVIDIA GPU driver
 end user README here:
 
-https://us.download.nvidia.com/XFree86/Linux-x86_64/580.94.03/README/kernel_open.html
+https://us.download.nvidia.com/XFree86/Linux-x86_64/580.94.06/README/kernel_open.html
 
 For vGPU support, please refer to the README.vgpu packaged in the vGPU Host
 Package for more details.

kernel-open/Kbuild

@@ -79,7 +79,7 @@ ccflags-y += -I$(src)/common/inc
 ccflags-y += -I$(src)
 ccflags-y += -Wall $(DEFINES) $(INCLUDES) -Wno-cast-qual -Wno-format-extra-args
 ccflags-y += -D__KERNEL__ -DMODULE -DNVRM
-ccflags-y += -DNV_VERSION_STRING=\"580.94.03\"
+ccflags-y += -DNV_VERSION_STRING=\"580.94.06\"
 
 # Include and link Tegra out-of-tree modules.
 ifneq ($(wildcard /usr/src/nvidia/nvidia-oot),)

kernel-open/common/inc/nv-modeset-interface.h

@@ -58,6 +58,12 @@ typedef struct {
      */
     void (*suspend)(NvU32 gpu_id);
     void (*resume)(NvU32 gpu_id);
+
+    /* Remove callback, called when a device is going away completely. */
+    void (*remove)(NvU32 gpu_id);
+
+    /* Probe callback, called when a device is being hotplugged. */
+    void (*probe)(const nv_gpu_info_t *gpu_info);
 } nvidia_modeset_callbacks_t;
 
 /*

kernel-open/common/inc/nv-proto.h

@@ -78,6 +78,8 @@ NV_STATUS     nv_set_system_power_state (nv_power_state_t, nv_pm_action_depth_t)
 
 void          nvidia_modeset_suspend           (NvU32 gpuId);
 void          nvidia_modeset_resume            (NvU32 gpuId);
+void          nvidia_modeset_remove            (NvU32 gpuId);
+void          nvidia_modeset_probe             (const nv_linux_state_t *nvl);
 NvBool        nv_is_uuid_in_gpu_exclusion_list (const char *);
 
 NV_STATUS     nv_parse_per_device_option_string(nvidia_stack_t *sp);

kernel-open/common/inc/nv_uvm_types.h

@@ -688,6 +688,13 @@ typedef struct UvmGpuInfo_tag
 
     // GPU setup in CDMM mode
     NvBool cdmmEnabled;
+
+    // If nvlinkDirectConnect is NV_TRUE,
+    // nvlDirectConnectMemoryWindowStart is the GPA base address for the GPU's vidmem over
+    // direct-connect NVLink. It is used when creating PTEs of GPU memory mappings
+    // to direct NVLink peers.
+    NvBool nvlDirectConnect;
+    NvU64 nvlDirectConnectMemoryWindowStart;
 } UvmGpuInfo;
 
 typedef struct UvmGpuFbInfo_tag

kernel-open/common/inc/nvkms-kapi.h

@@ -598,13 +598,17 @@ typedef enum NvKmsKapiRegisterWaiterResultRec {
     NVKMS_KAPI_REG_WAITER_ALREADY_SIGNALLED,
 } NvKmsKapiRegisterWaiterResult;
 
-typedef void NvKmsKapiSuspendResumeCallbackFunc(NvBool suspend);
-
 struct NvKmsKapiGpuInfo {
     nv_gpu_info_t gpuInfo;
     MIGDeviceId   migDevice;
 };
 
+struct NvKmsKapiCallbacks {
+    void (*suspendResume)(NvBool suspend);
+    void (*remove)(NvU32 gpuId);
+    void (*probe)(const struct NvKmsKapiGpuInfo *gpu_info);
+};
+
 struct NvKmsKapiFunctionsTable {
 
     /*!
@@ -1473,12 +1477,12 @@ struct NvKmsKapiFunctionsTable {
     );
 
     /*!
-     * Set the callback function for suspending and resuming the display system.
+     * Set the pointer to the callback function table.
      */
     void
-    (*setSuspendResumeCallback)
+    (*setCallbacks)
     (
-        NvKmsKapiSuspendResumeCallbackFunc *function
+        const struct NvKmsKapiCallbacks *callbacks
     );
 
     /*!

kernel-open/nvidia-drm/nvidia-drm-drv.c

@@ -101,6 +101,7 @@ static int nv_drm_revoke_modeset_permission(struct drm_device *dev,
                                             NvU32 dpyId);
 static int nv_drm_revoke_sub_ownership(struct drm_device *dev);
 
+static DEFINE_MUTEX(dev_list_mutex);
 static struct nv_drm_device *dev_list = NULL;
 
 static const char* nv_get_input_colorspace_name(
@@ -2067,8 +2068,10 @@ void nv_drm_register_drm_device(const struct NvKmsKapiGpuInfo *gpu_info)
 
     /* Add NVIDIA-DRM device into list */
 
+    mutex_lock(&dev_list_mutex);
     nv_dev->next = dev_list;
     dev_list = nv_dev;
+    mutex_unlock(&dev_list_mutex);
 
     return; /* Success */
 
@@ -2106,22 +2109,81 @@ int nv_drm_probe_devices(void)
 }
 #endif
 
+static struct nv_drm_device*
+nv_drm_pop_device(void)
+{
+    struct nv_drm_device *nv_dev;
+
+    mutex_lock(&dev_list_mutex);
+
+    nv_dev = dev_list;
+    if (nv_dev) {
+        dev_list = nv_dev->next;
+        nv_dev->next = NULL;
+    }
+
+    mutex_unlock(&dev_list_mutex);
+    return nv_dev;
+}
+
+static struct nv_drm_device*
+nv_drm_find_and_remove_device(NvU32 gpuId)
+{
+    struct nv_drm_device **pPrev = &dev_list;
+    struct nv_drm_device *nv_dev;
+
+    mutex_lock(&dev_list_mutex);
+    nv_dev = *pPrev;
+
+    while (nv_dev) {
+        if (nv_dev->gpu_info.gpu_id == gpuId) {
+            /* Remove it from the linked list */
+            *pPrev = nv_dev->next;
+            nv_dev->next = NULL;
+            break;
+        }
+
+        pPrev = &nv_dev->next;
+        nv_dev = *pPrev;
+    }
+
+    mutex_unlock(&dev_list_mutex);
+    return nv_dev;
+}
+
+static void nv_drm_dev_destroy(struct nv_drm_device *nv_dev)
+{
+    struct drm_device *dev = nv_dev->dev;
+
+    nv_drm_dev_unload(dev);
+    drm_dev_put(dev);
+    nv_drm_free(nv_dev);
+}
+
 /*
- * Unregister all NVIDIA DRM devices.
+ * Unregister a single NVIDIA DRM device.
  */
-void nv_drm_remove_devices(void)
+void nv_drm_remove(NvU32 gpuId)
 {
-    while (dev_list != NULL) {
-        struct nv_drm_device *next = dev_list->next;
-        struct drm_device *dev = dev_list->dev;
+    struct nv_drm_device *nv_dev = nv_drm_find_and_remove_device(gpuId);
 
-        drm_dev_unregister(dev);
-        nv_drm_dev_unload(dev);
-        drm_dev_put(dev);
+    if (nv_dev) {
+        NV_DRM_DEV_LOG_INFO(nv_dev, "Removing device");
+        drm_dev_unplug(nv_dev->dev);
+        nv_drm_dev_destroy(nv_dev);
+    }
+}
 
-        nv_drm_free(dev_list);
+/*
+ * Unregister all NVIDIA DRM devices.
+ */
+void nv_drm_remove_devices(void)
+{
+    struct nv_drm_device *nv_dev;
 
-        dev_list = next;
+    while ((nv_dev = nv_drm_pop_device())) {
+        drm_dev_unregister(nv_dev->dev);
+        nv_drm_dev_destroy(nv_dev);
     }
 }
 
@@ -2143,11 +2205,10 @@ void nv_drm_remove_devices(void)
  */
 void nv_drm_suspend_resume(NvBool suspend)
 {
-    static DEFINE_MUTEX(nv_drm_suspend_mutex);
     static NvU32 nv_drm_suspend_count = 0;
     struct nv_drm_device *nv_dev;
 
-    mutex_lock(&nv_drm_suspend_mutex);
+    mutex_lock(&dev_list_mutex);
 
     /*
      * Count the number of times the driver is asked to suspend. Suspend all DRM
@@ -2195,7 +2256,7 @@ void nv_drm_suspend_resume(NvBool suspend)
     }
 
 done:
-    mutex_unlock(&nv_drm_suspend_mutex);
+    mutex_unlock(&dev_list_mutex);
 }
 
 #endif /* NV_DRM_AVAILABLE */

kernel-open/nvidia-drm/nvidia-drm-drv.h

@@ -31,6 +31,7 @@ struct NvKmsKapiGpuInfo;
 
 int nv_drm_probe_devices(void);
 
+void nv_drm_remove(NvU32 gpuId);
 void nv_drm_remove_devices(void);
 
 void nv_drm_suspend_resume(NvBool suspend);

kernel-open/nvidia-drm/nvidia-drm.c

@@ -33,6 +33,12 @@ static struct NvKmsKapiFunctionsTable nvKmsFuncsTable = {
 
 const struct NvKmsKapiFunctionsTable* const nvKms = &nvKmsFuncsTable;
 
+const struct NvKmsKapiCallbacks nv_drm_kapi_callbacks = {
+    .suspendResume = nv_drm_suspend_resume,
+    .remove = nv_drm_remove,
+    .probe = nv_drm_register_drm_device,
+};
+
 #endif
 
 int nv_drm_init(void)
@@ -45,7 +51,7 @@ int nv_drm_init(void)
         return -EINVAL;
     }
 
-    nvKms->setSuspendResumeCallback(nv_drm_suspend_resume);
+    nvKms->setCallbacks(&nv_drm_kapi_callbacks);
     return nv_drm_probe_devices();
 #else
     return 0;
@@ -55,7 +61,7 @@ int nv_drm_init(void)
 void nv_drm_exit(void)
 {
 #if defined(NV_DRM_AVAILABLE)
-    nvKms->setSuspendResumeCallback(NULL);
+    nvKms->setCallbacks(NULL);
     nv_drm_remove_devices();
 #endif
 }

kernel-open/nvidia-modeset/nvidia-modeset-linux.c

@@ -820,6 +820,20 @@ static void nvkms_resume(NvU32 gpuId)
     nvKmsKapiSuspendResume(NV_FALSE /* suspend */);
 }
 
+static void nvkms_remove(NvU32 gpuId)
+{
+    nvKmsKapiRemove(gpuId);
+
+    // Eventually, this function should also terminate all NVKMS clients and
+    // free the NVDevEvoRec. Until that is implemented, all NVKMS clients must
+    // be closed before a device is removed.
+}
+
+static void nvkms_probe(const nv_gpu_info_t *gpu_info)
+{
+    nvKmsKapiProbe(gpu_info);
+}
+
 
 /*************************************************************************
  * Interface with resman.
@@ -828,7 +842,9 @@ static void nvkms_resume(NvU32 gpuId)
 static nvidia_modeset_rm_ops_t __rm_ops = { 0 };
 static nvidia_modeset_callbacks_t nvkms_rm_callbacks = {
     .suspend = nvkms_suspend,
-    .resume  = nvkms_resume
+    .resume  = nvkms_resume,
+    .remove  = nvkms_remove,
+    .probe   = nvkms_probe,
 };
 
 static int nvkms_alloc_rm(void)