diff --git a/kernel/common/inc/nv-linux.h b/kernel/common/inc/nv-linux.h
index 3bce0c0..dd5303b 100644
--- a/kernel/common/inc/nv-linux.h
+++ b/kernel/common/inc/nv-linux.h
@@ -573,11 +573,15 @@ static inline void *nv_ioremap(NvU64 phys, NvU64 size)
     return ptr;
 }
 
 static inline void *nv_ioremap_nocache(NvU64 phys, NvU64 size)
 {
+#if defined(NV_IOREMAP_NOCACHE_PRESENT)
     void *ptr = ioremap_nocache(phys, size);
+#else
+    void *ptr = ioremap(phys, size);
+#endif
     if (ptr)
         NV_MEMDBG_ADD(ptr, size);
     return ptr;
 }
 
diff --git a/kernel/common/inc/nv-procfs.h b/kernel/common/inc/nv-procfs.h
index 3c812ea..e57c4f9 100644
--- a/kernel/common/inc/nv-procfs.h
+++ b/kernel/common/inc/nv-procfs.h
@@ -50,10 +50,23 @@
         }                                                   \
         __entry;                                            \
     })
 #endif
 
+#if defined(NV_HAVE_PROC_OPS)
+#define NV_CREATE_PROC_FILE(filename,parent,__name,__data)               \
+   ({                                                                    \
+        struct proc_dir_entry *__entry;                                  \
+        int mode = (S_IFREG | S_IRUGO);                                  \
+        const struct proc_ops *fops = &nv_procfs_##__name##_fops;        \
+        if (fops->proc_write != 0)                                       \
+            mode |= S_IWUSR;                                             \
+        __entry = NV_CREATE_PROC_ENTRY(filename, mode, parent, fops,     \
+            __data);                                                     \
+        __entry;                                                         \
+    })
+#else
 #define NV_CREATE_PROC_FILE(filename,parent,__name,__data)               \
    ({                                                                    \
         struct proc_dir_entry *__entry;                                  \
         int mode = (S_IFREG | S_IRUGO);                                  \
         const struct file_operations *fops = &nv_procfs_##__name##_fops; \
@@ -61,10 +74,11 @@
             mode |= S_IWUSR;                                             \
         __entry = NV_CREATE_PROC_ENTRY(filename, mode, parent, fops,     \
             __data);                                                     \
         __entry;                                                         \
     })
+#endif
 
 /*
  * proc_mkdir_mode exists in Linux 2.6.9, but isn't exported until Linux 3.0.
  * Use the older interface instead unless the newer interface is necessary.
  */
@@ -102,10 +116,28 @@
 #else
 # define NV_REMOVE_PROC_ENTRY(entry)                           \
     remove_proc_entry(entry->name, entry->parent);
 #endif
 
+#if defined(NV_HAVE_PROC_OPS)
+#define NV_DEFINE_PROCFS_SINGLE_FILE(__name)                                  \
+    static int nv_procfs_open_##__name(                                       \
+        struct inode *inode,                                                  \
+        struct file *filep                                                    \
+    )                                                                         \
+    {                                                                         \
+        return single_open(filep, nv_procfs_read_##__name,                    \
+            NV_PDE_DATA(inode));                                              \
+    }                                                                         \
+                                                                              \
+    static const struct proc_ops nv_procfs_##__name##_fops = {                \
+        .proc_open       = nv_procfs_open_##__name,                           \
+        .proc_read       = seq_read,                                          \
+        .proc_lseek      = seq_lseek,                                         \
+        .proc_release    = single_release,                                    \
+    };
+#else
 #define NV_DEFINE_PROCFS_SINGLE_FILE(__name)                                  \
     static int nv_procfs_open_##__name(                                       \
         struct inode *inode,                                                  \
         struct file *filep                                                    \
     )                                                                         \
@@ -119,10 +151,11 @@
         .open       = nv_procfs_open_##__name,                                \
         .read       = seq_read,                                               \
         .llseek     = seq_lseek,                                              \
         .release    = single_release,                                         \
     };
+#endif
 
 #endif  /* CONFIG_PROC_FS */
 
 #endif /* _NV_PROCFS_H */
 
diff --git a/kernel/common/inc/nv-time.h b/kernel/common/inc/nv-time.h
index 968b873..fefec9d 100644
--- a/kernel/common/inc/nv-time.h
+++ b/kernel/common/inc/nv-time.h
@@ -25,20 +25,26 @@
 
 #include "conftest.h"
 
 #include <linux/ktime.h>
 
-static inline void nv_gettimeofday(struct timeval *tv)
+#if defined(NV_HAVE_TIMEVAL)
+#define nv_timeval timeval
+#else
+#define nv_timeval __kernel_old_timeval
+#endif
+
+static inline void nv_gettimeofday(struct nv_timeval *tv)
 {
 #ifdef NV_DO_GETTIMEOFDAY_PRESENT
     do_gettimeofday(tv);
 #else
     struct timespec64 now;
 
     ktime_get_real_ts64(&now);
 
-    *tv = (struct timeval) {
+    *tv = (struct nv_timeval) {
         .tv_sec = now.tv_sec,
         .tv_usec = now.tv_nsec/1000,
     };
 #endif // NV_DO_GETTIMEOFDAY_PRESENT
 }
diff --git a/kernel/conftest.sh b/kernel/conftest.sh
index 7cf867a..dad704b 100755
--- a/kernel/conftest.sh
+++ b/kernel/conftest.sh
@@ -130,10 +130,11 @@ test_headers() {
     FILES="$FILES linux/sched/signal.h"
     FILES="$FILES linux/sched/task.h"
     FILES="$FILES linux/sched/task_stack.h"
     FILES="$FILES xen/ioemu.h"
     FILES="$FILES linux/fence.h"
+    FILES="$FILES linux/dma-resv.h"
 
     # Arch specific headers which need testing
     FILES_ARCH="asm/book3s/64/hash-64k.h"
     FILES_ARCH="$FILES_ARCH asm/set_memory.h"
     FILES_ARCH="$FILES_ARCH asm/prom.h"
@@ -851,10 +852,26 @@ compile_test() {
             }"
 
             compile_check_conftest "$CODE" "NV_IOREMAP_CACHE_PRESENT" "" "functions"
         ;;
 
+        ioremap_nocache)
+            #
+            # Determine if the ioremap_nocache() function is present.
+            #
+            # Removed by commit 4bdc0d676a64 ("remove ioremap_nocache and
+            # devm_ioremap_nocache") in v5.6 (2020-01-06)
+            #
+            CODE="
+            #include <asm/io.h>
+            void conftest_ioremap_nocache(void) {
+                ioremap_nocache();
+            }"
+
+            compile_check_conftest "$CODE" "NV_IOREMAP_NOCACHE_PRESENT" "" "functions"
+        ;;
+
         ioremap_wc)
             #
             # Determine if the ioremap_wc() function is present.
             # It does not exist on all architectures.
             #
@@ -938,10 +955,59 @@ compile_test() {
             }"
 
             compile_check_conftest "$CODE" "NV_SG_ALLOC_TABLE_FROM_PAGES_PRESENT" "" "functions"
         ;;
 
+        proc_ops)
+            CODE="
+            #include <linux/proc_fs.h>
+            int conftest_proc_ops(void) {
+                return offsetof(struct proc_ops, proc_open);
+            }"
+
+            compile_check_conftest "$CODE" "NV_HAVE_PROC_OPS" "" "types"
+        ;;
+
+        timeval)
+            CODE="
+            #include <linux/time.h>
+            #include <linux/ktime.h>
+            int conftest_timeval(void) {
+                return offsetof(struct timeval, tv_sec);
+            }"
+
+            compile_check_conftest "$CODE" "NV_HAVE_TIMEVAL" "" "types"
+        ;;
+
+        ktime_get_raw_ts64)
+            #
+            # Determine if the ktime_get_raw_ts64() function is present.
+            #
+            CODE="
+            #include <linux/ktime.h>
+            int conftest_ktime_get_raw_ts64(void) {
+                ktime_get_raw_ts64();
+            }"
+
+            compile_check_conftest "$CODE" "NV_KTIME_GET_RAW_TS64_PRESENT" "" "functions"
+        ;;
+
+        ktime_get_real_ts64)
+            #
+            # Determine if ktime_get_real_ts64() is present
+            #
+            # Added by commit d6d29896c665d ("timekeeping: Provide timespec64
+            # based interfaces") in 3.17 (2014-07-16)
+            #
+        CODE="
+        #include <linux/ktime.h>
+        void conftest_ktime_get_real_ts64(void){
+            ktime_get_real_ts64();
+        }"
+            compile_check_conftest "$CODE" "NV_KTIME_GET_REAL_TS64_PRESENT" "" "functions"
+        ;;
+
         efi_enabled)
             #
             # Added in 2.6.12 as a variable
             #
             # Determine if the efi_enabled symbol is present (as a variable),
diff --git a/kernel/nvidia-modeset/nvidia-modeset-linux.c b/kernel/nvidia-modeset/nvidia-modeset-linux.c
index d42aabb..f0404fb 100644
--- a/kernel/nvidia-modeset/nvidia-modeset-linux.c
+++ b/kernel/nvidia-modeset/nvidia-modeset-linux.c
@@ -214,11 +214,11 @@ void NVKMS_API_CALL nvkms_usleep(NvU64 usec)
     }
 }
 
 NvU64 NVKMS_API_CALL nvkms_get_usec(void)
 {
-    struct timeval tv;
+    struct nv_timeval tv;
 
     nv_gettimeofday(&tv);
 
     return (((NvU64)tv.tv_sec) * 1000000) + tv.tv_usec;
 }
diff --git a/kernel/nvidia-uvm/uvm_linux.h b/kernel/nvidia-uvm/uvm_linux.h
index b140f44..2112391 100644
--- a/kernel/nvidia-uvm/uvm_linux.h
+++ b/kernel/nvidia-uvm/uvm_linux.h
@@ -316,11 +316,20 @@ static inline uint64_t NV_DIV64(uint64_t dividend, uint64_t divisor, uint64_t *r
 
     return dividend / divisor;
 }
 #endif
 
-#if defined(CLOCK_MONOTONIC_RAW)
+#if defined(NV_KTIME_GET_RAW_TS64_PRESENT)
+static inline NvU64 NV_GETTIME(void)
+{
+    struct timespec64 ts64 = {0};
+
+    ktime_get_raw_ts64(&ts64);
+
+    return (ts64.tv_sec * 1000000000ULL + ts64.tv_nsec);
+}
+#elif defined(CLOCK_MONOTONIC_RAW)
 /* Return a nanosecond-precise value */
 static inline NvU64 NV_GETTIME(void)
 {
     struct timespec ts = {0};
 
@@ -332,11 +341,11 @@ static inline NvU64 NV_GETTIME(void)
 #else
 /* We can only return a microsecond-precise value with the
  * available non-GPL symbols. */
 static inline NvU64 NV_GETTIME(void)
 {
-    struct timeval tv = {0};
+    struct nv_timeval tv = {0};
 
     nv_gettimeofday(&tv);
 
     return (tv.tv_sec * 1000000000ULL + tv.tv_usec * 1000ULL);
 }
diff --git a/kernel/nvidia/linux_nvswitch.c b/kernel/nvidia/linux_nvswitch.c
index e4381b5..92bda66 100644
--- a/kernel/nvidia/linux_nvswitch.c
+++ b/kernel/nvidia/linux_nvswitch.c
@@ -1557,14 +1557,21 @@ NVLINK_API_CALL
 nvswitch_os_get_platform_time
 (
     void
 )
 {
+#if defined(NV_KTIME_GET_REAL_TS64_PRESENT)
+    struct timespec64 ts;
+
+    ktime_get_real_ts64(&ts);
+    return ((NvU64) timespec64_to_ns(&ts));
+#else
     struct timespec ts;
 
     getnstimeofday(&ts);
     return ((NvU64) timespec_to_ns(&ts));
+#endif
 }
 
 void
 NVLINK_API_CALL
 nvswitch_os_print
diff --git a/kernel/nvidia/nv-procfs.c b/kernel/nvidia/nv-procfs.c
index 220eeef..ebbdb29 100644
--- a/kernel/nvidia/nv-procfs.c
+++ b/kernel/nvidia/nv-procfs.c
@@ -434,18 +434,28 @@ done:
     up(&nvfp->fops_sp_lock[NV_FOPS_STACK_INDEX_PROCFS]);
 
     return ((status < 0) ? status : (int)count);
 }
 
+#if defined(NV_HAVE_PROC_OPS)
+static struct proc_ops nv_procfs_registry_fops = {
+    .proc_open    = nv_procfs_open_registry,
+    .proc_read    = seq_read,
+    .proc_write   = nv_procfs_write_file,
+    .proc_lseek   = seq_lseek,
+    .proc_release = nv_procfs_close_registry,
+};
+#else
 static struct file_operations nv_procfs_registry_fops = {
     .owner   = THIS_MODULE,
     .open    = nv_procfs_open_registry,
     .read    = seq_read,
     .write   = nv_procfs_write_file,
     .llseek  = seq_lseek,
     .release = nv_procfs_close_registry,
 };
+#endif
 
 /*
  * Forwards error to nv_log_error which exposes data to vendor callback
  */
 void
@@ -537,16 +547,24 @@ done:
     nv_free_file_private(nvfp);
 
     return status;
 }
 
+#if defined(NV_HAVE_PROC_OPS)
+static struct proc_ops nv_procfs_exercise_error_forwarding_fops = {
+    .proc_open    = nv_procfs_open_exercise_error_forwarding,
+    .proc_write   = nv_procfs_write_file,
+    .proc_release = nv_procfs_close_exercise_error_forwarding,
+};
+#else
 static struct file_operations nv_procfs_exercise_error_forwarding_fops = {
     .owner   = THIS_MODULE,
     .open    = nv_procfs_open_exercise_error_forwarding,
     .write   = nv_procfs_write_file,
     .release = nv_procfs_close_exercise_error_forwarding,
 };
+#endif
 
 static int
 nv_procfs_read_unbind_lock(
     struct seq_file *s,
     void *v
@@ -670,18 +688,28 @@ done:
     nv_free_file_private(nvfp);
 
     return rc;
 }
 
+#if defined(NV_HAVE_PROC_OPS)
+static struct proc_ops nv_procfs_unbind_lock_fops = {
+    .proc_open    = nv_procfs_open_unbind_lock,
+    .proc_read    = seq_read,
+    .proc_write   = nv_procfs_write_file,
+    .proc_lseek   = seq_lseek,
+    .proc_release = nv_procfs_close_unbind_lock,
+};
+#else
 static struct file_operations nv_procfs_unbind_lock_fops = {
     .owner   = THIS_MODULE,
     .open    = nv_procfs_open_unbind_lock,
     .read    = seq_read,
     .write   = nv_procfs_write_file,
     .llseek  = seq_lseek,
     .release = nv_procfs_close_unbind_lock,
 };
+#endif
 
 static const char*
 numa_status_describe(nv_numa_status_t state)
 {
     if (state < 0 || state >= NV_NUMA_STATUS_COUNT)
@@ -985,10 +1013,26 @@ done:
 
     nv_free_file_private(nvfp);
     return retval;
 }
 
+#if defined(NV_HAVE_PROC_OPS)
+static const struct proc_ops nv_procfs_numa_status_fops = {
+    .proc_open    = nv_procfs_open_numa_status,
+    .proc_read    = seq_read,
+    .proc_write   = nv_procfs_write_file,
+    .proc_lseek   = seq_lseek,
+    .proc_release = nv_procfs_close_numa_status,
+};
+
+static const struct proc_ops nv_procfs_offline_pages_fops = {
+    .proc_open    = nv_procfs_open_offline_pages,
+    .proc_read    = seq_read,
+    .proc_lseek   = seq_lseek,
+    .proc_release = nv_procfs_close_offline_pages,
+};
+#else
 static const struct file_operations nv_procfs_numa_status_fops = {
     .owner   = THIS_MODULE,
     .open    = nv_procfs_open_numa_status,
     .read    = seq_read,
     .write   = nv_procfs_write_file,
@@ -1001,10 +1045,11 @@ static const struct file_operations nv_procfs_offline_pages_fops = {
     .open    = nv_procfs_open_offline_pages,
     .read    = seq_read,
     .llseek  = seq_lseek,
     .release = nv_procfs_close_offline_pages,
 };
+#endif
 
 static int
 nv_procfs_read_text_file(
     struct seq_file *s,
     void *v
diff --git a/kernel/nvidia/nvidia.Kbuild b/kernel/nvidia/nvidia.Kbuild
index d079e5d..0c76cad 100644
--- a/kernel/nvidia/nvidia.Kbuild
+++ b/kernel/nvidia/nvidia.Kbuild
@@ -115,18 +115,21 @@ NV_CONFTEST_FUNCTION_COMPILE_TESTS += console_lock
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += kmem_cache_create
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += on_each_cpu
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += smp_call_function
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += acpi_evaluate_integer
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += ioremap_cache
+NV_CONFTEST_FUNCTION_COMPILE_TESTS += ioremap_nocache
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += ioremap_wc
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += acpi_walk_namespace
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += pci_domain_nr
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += pci_dma_mapping_error
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += sg_alloc_table
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += sg_init_table
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += pci_get_domain_bus_and_slot
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += get_num_physpages
+NV_CONFTEST_FUNCTION_COMPILE_TESTS += ktime_get_raw_ts64
+NV_CONFTEST_FUNCTION_COMPILE_TESTS += ktime_get_real_ts64
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += efi_enabled
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += proc_create_data
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += pde_data
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += proc_remove
 NV_CONFTEST_FUNCTION_COMPILE_TESTS += pm_vt_switch_required
@@ -169,11 +172,13 @@ NV_CONFTEST_TYPE_COMPILE_TESTS += acpi_op_remove
 NV_CONFTEST_TYPE_COMPILE_TESTS += acpi_device_id
 NV_CONFTEST_TYPE_COMPILE_TESTS += outer_flush_all
 NV_CONFTEST_TYPE_COMPILE_TESTS += proc_dir_entry
 NV_CONFTEST_TYPE_COMPILE_TESTS += scatterlist
 NV_CONFTEST_TYPE_COMPILE_TESTS += sg_table
+NV_CONFTEST_TYPE_COMPILE_TESTS += proc_ops
 NV_CONFTEST_TYPE_COMPILE_TESTS += file_operations
+NV_CONFTEST_TYPE_COMPILE_TESTS += timeval
 NV_CONFTEST_TYPE_COMPILE_TESTS += vm_operations_struct
 NV_CONFTEST_TYPE_COMPILE_TESTS += atomic_long_type
 NV_CONFTEST_TYPE_COMPILE_TESTS += file_inode
 NV_CONFTEST_TYPE_COMPILE_TESTS += task_struct
 NV_CONFTEST_TYPE_COMPILE_TESTS += kuid_t
diff --git a/kernel/nvidia/nvlink_linux.c b/kernel/nvidia/nvlink_linux.c
index 546ace9..b74ea71 100644
--- a/kernel/nvidia/nvlink_linux.c
+++ b/kernel/nvidia/nvlink_linux.c
@@ -501,23 +501,23 @@ void * NVLINK_API_CALL nvlink_memcpy(void *dest, void *src, NvLength size)
     return memcpy(dest, src, size);
 }
 
 static NvBool nv_timer_less_than
 (
-    const struct timeval *a,
-    const struct timeval *b
+    const struct nv_timeval *a,
+    const struct nv_timeval *b
 )
 {
     return (a->tv_sec == b->tv_sec) ? (a->tv_usec < b->tv_usec) 
                                     : (a->tv_sec < b->tv_sec);
 }
 
 static void nv_timeradd
 (
-    const struct timeval    *a,
-    const struct timeval    *b,
-    struct timeval          *result
+    const struct nv_timeval    *a,
+    const struct nv_timeval    *b,
+    struct nv_timeval          *result
 )
 {
     result->tv_sec = a->tv_sec + b->tv_sec;
     result->tv_usec = a->tv_usec + b->tv_usec;
     while (result->tv_usec >= 1000000)
@@ -527,13 +527,13 @@ static void nv_timeradd
     }
 }
 
 static void nv_timersub
 (
-    const struct timeval    *a,
-    const struct timeval    *b,
-    struct timeval          *result
+    const struct nv_timeval    *a,
+    const struct nv_timeval    *b,
+    struct nv_timeval          *result
 )
 {
     result->tv_sec = a->tv_sec - b->tv_sec;
     result->tv_usec = a->tv_usec - b->tv_usec;
     while (result->tv_usec < 0)
@@ -549,11 +549,11 @@ static void nv_timersub
 void NVLINK_API_CALL nvlink_sleep(unsigned int ms)
 {
     unsigned long us;
     unsigned long jiffies;
     unsigned long mdelay_safe_msec;
-    struct timeval tm_end, tm_aux;
+    struct nv_timeval tm_end, tm_aux;
 
     nv_gettimeofday(&tm_aux);
 
     if (in_irq() && (ms > NV_MAX_ISR_DELAY_MS))
     {
diff --git a/kernel/nvidia/os-interface.c b/kernel/nvidia/os-interface.c
index 8f2d968..a4a37a8 100644
--- a/kernel/nvidia/os-interface.c
+++ b/kernel/nvidia/os-interface.c
@@ -427,11 +427,11 @@ void NV_API_CALL os_free_mem(void *address)
 NV_STATUS NV_API_CALL os_get_current_time(
     NvU32 *seconds,
     NvU32 *useconds
 )
 {
-    struct timeval tm;
+    struct nv_timeval tm;
 
     nv_gettimeofday(&tm);
 
     *seconds = tm.tv_sec;
     *useconds = tm.tv_usec;
@@ -441,13 +441,19 @@ NV_STATUS NV_API_CALL os_get_current_time(
 
 #if BITS_PER_LONG >= 64
 
 void NV_API_CALL os_get_current_tick(NvU64 *nseconds)
 {
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 5, 0)
+    struct timespec64 ts;
+
+    jiffies_to_timespec64(jiffies, &ts);
+#else
     struct timespec ts;
 
     jiffies_to_timespec(jiffies, &ts);
+#endif
 
     *nseconds = ((NvU64)ts.tv_sec * NSEC_PER_SEC + (NvU64)ts.tv_nsec);
 }
 
 NvU64 NV_API_CALL os_get_tick_resolution(void)
@@ -513,11 +519,11 @@ NV_STATUS NV_API_CALL os_delay_us(NvU32 MicroSeconds)
 {
     unsigned long mdelay_safe_msec;
     unsigned long usec;
 
 #ifdef NV_CHECK_DELAY_ACCURACY
-    struct timeval tm1, tm2;
+    struct nv_timeval tm1, tm2;
 
     nv_gettimeofday(&tm1);
 #endif
 
     if (in_irq() && (MicroSeconds > NV_MAX_ISR_DELAY_US))
@@ -553,13 +559,13 @@ NV_STATUS NV_API_CALL os_delay_us(NvU32 MicroSeconds)
 NV_STATUS NV_API_CALL os_delay(NvU32 MilliSeconds)
 {
     unsigned long MicroSeconds;
     unsigned long jiffies;
     unsigned long mdelay_safe_msec;
-    struct timeval tm_end, tm_aux;
+    struct nv_timeval tm_end, tm_aux;
 #ifdef NV_CHECK_DELAY_ACCURACY
-    struct timeval tm_start;
+    struct nv_timeval tm_start;
 #endif
 
     nv_gettimeofday(&tm_aux);
 #ifdef NV_CHECK_DELAY_ACCURACY
     tm_start = tm_aux;
@@ -1912,11 +1918,11 @@ static NV_STATUS NV_API_CALL _os_ipmi_receive_resp
     nvipmi_resp_t           *p_resp
 )
 {
     struct ipmi_recv_msg    *rx_msg;
     int                     err_no;
-    struct timeval          tv;
+    struct nv_timeval          tv;
     NvU64                   start_time;
 
     nv_gettimeofday(&tv);
     start_time = NV_TIMEVAL_TO_US(tv);
 
-- 
2.28.0

