580.105.08

Author: mmaneetsingh

README.md

@@ -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.95.05\"
+ccflags-y += -DNV_VERSION_STRING=\"580.105.08\"
 
 # Include and link Tegra out-of-tree modules.
 ifneq ($(wildcard /usr/src/nvidia/nvidia-oot),)

kernel-open/Kbuild

@@ -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-modeset-interface.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-proto.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/nv_uvm_types.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/common/inc/nvkms-kapi.h

@@ -165,6 +165,7 @@ NV_STATUS_CODE(NV_ERR_FABRIC_STATE_OUT_OF_SYNC,        0x00000087, "NVLink fabri
 NV_STATUS_CODE(NV_ERR_BUFFER_FULL,                     0x00000088, "Buffer is full")
 NV_STATUS_CODE(NV_ERR_BUFFER_EMPTY,                    0x00000089, "Buffer is empty")
 NV_STATUS_CODE(NV_ERR_MC_FLA_OFFSET_TABLE_FULL,        0x0000008A, "Multicast FLA offset table has no available slots")
+NV_STATUS_CODE(NV_ERR_DMA_XFER_FAILED,                 0x0000008B, "DMA transfer failed")
 
 // Warnings:
 NV_STATUS_CODE(NV_WARN_HOT_SWITCH,                     0x00010001, "WARNING Hot switch")

kernel-open/common/inc/nvstatuscodes.h

@@ -62,6 +62,11 @@ struct os_work_queue;
 /* Each OS defines its own version of this opaque type */
 typedef struct os_wait_queue os_wait_queue;
 
+/* Flags needed by os_get_current_proccess_flags */
+#define OS_CURRENT_PROCESS_FLAG_NONE            0x0
+#define OS_CURRENT_PROCESS_FLAG_KERNEL_THREAD   0x1
+#define OS_CURRENT_PROCESS_FLAG_EXITING         0x2
+
 /*
  * ---------------------------------------------------------------------------
  *
@@ -194,6 +199,7 @@ NV_STATUS   NV_API_CALL  os_open_readonly_file            (const char *, void **
 NV_STATUS   NV_API_CALL  os_open_and_read_file            (const char *, NvU8 *, NvU64);
 NvBool      NV_API_CALL  os_is_nvswitch_present           (void);
 NV_STATUS   NV_API_CALL  os_get_random_bytes              (NvU8 *, NvU16);
+NvU32       NV_API_CALL  os_get_current_process_flags     (void);
 NV_STATUS   NV_API_CALL  os_alloc_wait_queue              (os_wait_queue **);
 void        NV_API_CALL  os_free_wait_queue               (os_wait_queue *);
 void        NV_API_CALL  os_wait_uninterruptible          (os_wait_queue *);

kernel-open/common/inc/os-interface.h

@@ -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.c

@@ -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);