diff --git a/debian/changelog b/debian/changelog
index baf93ce..ad01b7e 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,9 @@
+nvidia-settings-tesla-460 (510.60.02-1) UNRELEASED; urgency=low
+
+  * New upstream release.
+
+ -- Debian Janitor <janitor@jelmer.uk>  Sat, 26 Mar 2022 23:15:22 -0000
+
 nvidia-settings-tesla-460 (460.91.03-1) unstable; urgency=medium
 
   * Rebuild as nvidia-settings-tesla-460.
diff --git a/debian/patches/12_nvidia-settings.desktop.diff b/debian/patches/12_nvidia-settings.desktop.diff
index ee8be6e..f3d66ee 100644
--- a/debian/patches/12_nvidia-settings.desktop.diff
+++ b/debian/patches/12_nvidia-settings.desktop.diff
@@ -2,8 +2,10 @@ Author: Andreas Beckmann <debian@abeckmann.de>
 Description: substitute placeholders in desktop file
 Forwarded: not-needed
 
---- a/doc/nvidia-settings.desktop
-+++ b/doc/nvidia-settings.desktop
+Index: nvidia-settings-tesla-460/doc/nvidia-settings.desktop
+===================================================================
+--- nvidia-settings-tesla-460.orig/doc/nvidia-settings.desktop
++++ nvidia-settings-tesla-460/doc/nvidia-settings.desktop
 @@ -1,11 +1,12 @@
  [Desktop Entry]
 +Version=1.0
@@ -19,5 +21,5 @@ Forwarded: not-needed
 -Icon=__PIXMAP_PATH__/nvidia-settings.png
 -Categories=__NVIDIA_SETTINGS_DESKTOP_CATEGORIES__
  
- # Translations provided by Sun Microsystems
- Name[de]=NVIDIA X-Server-Einstellungen
+ # Translation by Marcin Mikołajczak
+ Name[pl]=Ustawienia serwera X NVIDIA
diff --git a/debian/patches/conditionalize-gtk2.patch b/debian/patches/conditionalize-gtk2.patch
index 0843ac4..77ceec2 100644
--- a/debian/patches/conditionalize-gtk2.patch
+++ b/debian/patches/conditionalize-gtk2.patch
@@ -1,8 +1,10 @@
 Author: Andreas Beckmann <anbe@debian.org>
 Description: support building without GTK+ 2
 
---- a/src/Makefile
-+++ b/src/Makefile
+Index: nvidia-settings-tesla-460/src/Makefile
+===================================================================
+--- nvidia-settings-tesla-460.orig/src/Makefile
++++ nvidia-settings-tesla-460/src/Makefile
 @@ -62,6 +62,11 @@ else
    GTK3_LDFLAGS ?=
  endif
@@ -15,7 +17,7 @@ Description: support building without GTK+ 2
  # If GTK3_CFLAGS is set, try and build GTK3LIB
  ifdef GTK3_CFLAGS
    BUILD_GTK3LIB = 1
-@@ -116,10 +121,16 @@ NVIDIA_SETTINGS = $(OUTPUTDIR)/nvidia-se
+@@ -114,10 +119,16 @@ NVIDIA_SETTINGS = $(OUTPUTDIR)/nvidia-se
  
  NVIDIA_SETTINGS_VERSION := $(NVIDIA_VERSION)
  
@@ -32,7 +34,7 @@ Description: support building without GTK+ 2
  
  ifdef BUILD_GTK3LIB
    GTK3LIB_NAME = libnvidia-gtk3.so
-@@ -260,8 +271,10 @@ install: NVIDIA_SETTINGS_install NVIDIA_
+@@ -256,8 +267,10 @@ install: NVIDIA_SETTINGS_install NVIDIA_
  
  NVIDIA_GTKLIB_install: $(GTK2LIB) $(GTK3LIB)
  	$(MKDIR) $(LIBDIR)
diff --git a/debian/patches/include-Xlib.patch b/debian/patches/include-Xlib.patch
index e552ab7..612cb41 100644
--- a/debian/patches/include-Xlib.patch
+++ b/debian/patches/include-Xlib.patch
@@ -2,8 +2,10 @@ Author: Andreas Beckmann <anbe@debian.org>
 Description: NVCtrlLib.h uses macros from X11/Xlib.h
 Bug-Debian: https://bugs.debian.org/978192
 
---- a/src/libXNVCtrl/NVCtrlLib.h
-+++ b/src/libXNVCtrl/NVCtrlLib.h
+Index: nvidia-settings-tesla-460/src/libXNVCtrl/NVCtrlLib.h
+===================================================================
+--- nvidia-settings-tesla-460.orig/src/libXNVCtrl/NVCtrlLib.h
++++ nvidia-settings-tesla-460/src/libXNVCtrl/NVCtrlLib.h
 @@ -26,6 +26,8 @@
  
  #include "NVCtrl.h"
diff --git a/debian/patches/kfreebsd-hurd.diff b/debian/patches/kfreebsd-hurd.diff
index 85feb6b..244453c 100644
--- a/debian/patches/kfreebsd-hurd.diff
+++ b/debian/patches/kfreebsd-hurd.diff
@@ -1,9 +1,11 @@
 Author: Andreas Beckmann <anbe@debian.org>
 Description: link against -ldl on !linux, too
 
---- a/utils.mk
-+++ b/utils.mk
-@@ -140,7 +140,7 @@ endif
+Index: nvidia-settings-tesla-460/utils.mk
+===================================================================
+--- nvidia-settings-tesla-460.orig/utils.mk
++++ nvidia-settings-tesla-460/utils.mk
+@@ -156,7 +156,7 @@ endif
  ifeq ($(TARGET_OS),Linux)
    LIBDL_LIBS = -ldl
  else
diff --git a/debian/patches/link-order.diff b/debian/patches/link-order.diff
index 655988a..61d013a 100644
--- a/debian/patches/link-order.diff
+++ b/debian/patches/link-order.diff
@@ -4,8 +4,10 @@ Description: link libraries after object files
  drop now superfluous --no-as-needed flag
  fail on unresolved symbols
 
---- a/src/Makefile
-+++ b/src/Makefile
+Index: nvidia-settings-tesla-460/src/Makefile
+===================================================================
+--- nvidia-settings-tesla-460.orig/src/Makefile
++++ nvidia-settings-tesla-460/src/Makefile
 @@ -42,7 +42,7 @@ ifndef GTK2_CFLAGS
  endif
  
@@ -24,7 +26,7 @@ Description: link libraries after object files
    endif
  else
    GTK3_CFLAGS ?=
-@@ -279,19 +279,19 @@ $(NVIDIA_SETTINGS).unstripped: $(OBJS) $
+@@ -275,19 +275,19 @@ $(NVIDIA_SETTINGS).unstripped: $(OBJS) $
  $(eval $(call DEBUG_INFO_RULES, $(GTK2LIB)))
  $(GTK2LIB).unstripped: $(LIBXNVCTRL) $(GTK2_OBJS) $(XCP_OBJS) $(IMAGE_OBJS) $(VERSION_MK)
  	$(call quiet_cmd,LINK) -shared $(CFLAGS) $(LDFLAGS) $(BIN_LDFLAGS) \
diff --git a/debian/patches/typos.diff b/debian/patches/typos.diff
index 900f8d8..621fa3e 100644
--- a/debian/patches/typos.diff
+++ b/debian/patches/typos.diff
@@ -1,8 +1,10 @@
 Author: Andreas Beckmann <anbe@debian.org>
 Description: fix some typos found by lintian
 
---- a/src/XF86Config-parser/Monitor.c
-+++ b/src/XF86Config-parser/Monitor.c
+Index: nvidia-settings-tesla-460/src/XF86Config-parser/Monitor.c
+===================================================================
+--- nvidia-settings-tesla-460.orig/src/XF86Config-parser/Monitor.c
++++ nvidia-settings-tesla-460/src/XF86Config-parser/Monitor.c
 @@ -379,7 +379,7 @@ xconfigParseVerboseMode (void)
              Error (UNEXPECTED_EOF_MSG, NULL);
              break;
diff --git a/debian/patches/xorg.patch b/debian/patches/xorg.patch
index 00a21f8..058bca4 100644
--- a/debian/patches/xorg.patch
+++ b/debian/patches/xorg.patch
@@ -2,8 +2,10 @@ Author: Andreas Beckmann <anbe@debian.org>
 Description: resolve xorg libdir at build time
 Forwarded: not-needed
 
---- a/src/XF86Config-parser/Generate.c
-+++ b/src/XF86Config-parser/Generate.c
+Index: nvidia-settings-tesla-460/src/XF86Config-parser/Generate.c
+===================================================================
+--- nvidia-settings-tesla-460.orig/src/XF86Config-parser/Generate.c
++++ nvidia-settings-tesla-460/src/XF86Config-parser/Generate.c
 @@ -204,6 +204,12 @@ static char *find_libdir(GenerateOptions
      FILE *stream = NULL;
      char *s, *libdir = NULL;
diff --git a/doc/nvidia-settings.desktop b/doc/nvidia-settings.desktop
index c573029..252d4fc 100644
--- a/doc/nvidia-settings.desktop
+++ b/doc/nvidia-settings.desktop
@@ -7,6 +7,18 @@ Exec=__UTILS_PATH__/nvidia-settings
 Icon=__PIXMAP_PATH__/nvidia-settings.png
 Categories=__NVIDIA_SETTINGS_DESKTOP_CATEGORIES__
 
+# Translation by Marcin Mikołajczak
+Name[pl]=Ustawienia serwera X NVIDIA
+Comment[pl]=Narzędzie konfiguracyjne dla ustawień serwera X NVIDIA
+
+# Translation by RDL
+Name[ru]=Параметры NVIDIA X Server
+Comment[ru]=Конфигурирование параметров NVIDIA X Server
+
+# Translation by Tractix
+Name[ro]=Setări NVIDIA X Server
+Comment[ro]=Configurează setările NVIDIA X Server
+
 # Translations provided by Sun Microsystems
 Name[de]=NVIDIA X-Server-Einstellungen
 Name[es]=Valores de configuración del servidor NVIDIA X
@@ -28,11 +40,3 @@ Comment[pt_BR]=Definir &configurações de gerenciamento de usuário...
 Comment[zh_CN]=配置 NVIDIA X 服务器设置
 Comment[zh_HK]=配置 NVIDIA X 伺服器設定
 Comment[zh_TW]=配置 NVIDIA X 伺服器設定
-
-# Translation by Marcin Mikołajczak
-Name[pl]=Ustawienia serwera X NVIDIA
-Comment[pl]=Narzędzie konfiguracyjne dla ustawień serwera X NVIDIA
-
-# Translation by RDL
-Name[ru]=Параметры NVIDIA X Server
-Comment[ru]=Конфигурирование параметров NVIDIA X Server
diff --git a/doc/version.mk b/doc/version.mk
index 634141a..05c6021 100644
--- a/doc/version.mk
+++ b/doc/version.mk
@@ -1,4 +1,4 @@
-NVIDIA_VERSION = 460.91.03
+NVIDIA_VERSION = 510.60.02
 
 # This file.
 VERSION_MK_FILE := $(lastword $(MAKEFILE_LIST))
diff --git a/samples/nv-control-events.c b/samples/nv-control-events.c
index 8df39fa..b112ccd 100644
--- a/samples/nv-control-events.c
+++ b/samples/nv-control-events.c
@@ -26,7 +26,6 @@
  * demonstrates how to handle NV-CONTROL events.
  */
 
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -624,7 +623,6 @@ static AttrEntry attr_table[] = {
     MAKE_ENTRY(NV_CTRL_THERMAL_SENSOR_READING),
     MAKE_ENTRY(NV_CTRL_THERMAL_SENSOR_PROVIDER),
     MAKE_ENTRY(NV_CTRL_THERMAL_SENSOR_TARGET),
-    MAKE_ENTRY(NV_CTRL_GPU_CURRENT_PROCESSOR_CLOCK_FREQS),
     MAKE_ENTRY(NV_CTRL_GPU_PCIE_MAX_LINK_SPEED),
     MAKE_ENTRY(NV_CTRL_3D_VISION_PRO_RESET_TRANSCEIVER_TO_FACTORY_SETTINGS),
     MAKE_ENTRY(NV_CTRL_3D_VISION_PRO_TRANSCEIVER_CHANNEL),
@@ -655,8 +653,6 @@ static AttrEntry attr_table[] = {
     MAKE_ENTRY(NV_CTRL_FRAMELOCK_DISPLAY_CONFIG),
     MAKE_ENTRY(NV_CTRL_TOTAL_DEDICATED_GPU_MEMORY),
     MAKE_ENTRY(NV_CTRL_USED_DEDICATED_GPU_MEMORY),
-    MAKE_ENTRY(NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE),
-    MAKE_ENTRY(NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT),
     MAKE_ENTRY(NV_CTRL_DPY_HDMI_3D),
     MAKE_ENTRY(NV_CTRL_BASE_MOSAIC),
     MAKE_ENTRY(NV_CTRL_MULTIGPU_PRIMARY_POSSIBLE),
diff --git a/samples/nv-control-info.c b/samples/nv-control-info.c
index 23aac67..9d09730 100644
--- a/samples/nv-control-info.c
+++ b/samples/nv-control-info.c
@@ -27,7 +27,6 @@
  * present.
  */
 
-
 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
@@ -162,7 +161,6 @@ static const char *attr_int_table[NV_CTRL_LAST_ATTRIBUTE + 1] = {
     MAKE_ENTRY(NV_CTRL_THERMAL_SENSOR_READING),
     MAKE_ENTRY(NV_CTRL_THERMAL_SENSOR_PROVIDER),
     MAKE_ENTRY(NV_CTRL_THERMAL_SENSOR_TARGET),
-    MAKE_ENTRY(NV_CTRL_GPU_CURRENT_PROCESSOR_CLOCK_FREQS),
     MAKE_ENTRY(NV_CTRL_GPU_PCIE_MAX_LINK_SPEED),
     MAKE_ENTRY(NV_CTRL_3D_VISION_PRO_RESET_TRANSCEIVER_TO_FACTORY_SETTINGS),
     MAKE_ENTRY(NV_CTRL_3D_VISION_PRO_TRANSCEIVER_CHANNEL),
@@ -192,8 +190,6 @@ static const char *attr_int_table[NV_CTRL_LAST_ATTRIBUTE + 1] = {
     MAKE_ENTRY(NV_CTRL_FRAMELOCK_DISPLAY_CONFIG),
     MAKE_ENTRY(NV_CTRL_TOTAL_DEDICATED_GPU_MEMORY),
     MAKE_ENTRY(NV_CTRL_USED_DEDICATED_GPU_MEMORY),
-    MAKE_ENTRY(NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE),
-    MAKE_ENTRY(NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT),
     MAKE_ENTRY(NV_CTRL_DPY_HDMI_3D),
     MAKE_ENTRY(NV_CTRL_BASE_MOSAIC),
     MAKE_ENTRY(NV_CTRL_MULTIGPU_PRIMARY_POSSIBLE),
diff --git a/samples/nv-control-warpblend.c b/samples/nv-control-warpblend.c
index abe186f..d009a34 100644
--- a/samples/nv-control-warpblend.c
+++ b/samples/nv-control-warpblend.c
@@ -23,11 +23,11 @@
 
 #include "nv-control-warpblend.h"
 
-typedef struct __attribute__((packed)) {
+typedef struct {
     float x, y;
 } vertex2f;
 
-typedef struct __attribute__((packed)) {
+typedef struct {
     vertex2f pos;
     vertex2f tex;
     vertex2f tex2;
diff --git a/samples/version.mk b/samples/version.mk
index 634141a..05c6021 100644
--- a/samples/version.mk
+++ b/samples/version.mk
@@ -1,4 +1,4 @@
-NVIDIA_VERSION = 460.91.03
+NVIDIA_VERSION = 510.60.02
 
 # This file.
 VERSION_MK_FILE := $(lastword $(MAKEFILE_LIST))
diff --git a/src/Makefile b/src/Makefile
index fe97103..aaa7876 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -86,9 +86,7 @@ ifndef JANSSON_CFLAGS
   JANSSON_CFLAGS  = -Wno-cast-qual
   JANSSON_CFLAGS += -Wno-unused-function
   JANSSON_CFLAGS += -DHAVE_CONFIG_H
-  ifeq ($(TARGET_ARCH),armv7l)
-    JANSSON_CFLAGS += -Wno-unused-but-set-variable
-  endif
+  JANSSON_CFLAGS += -Wno-format-truncation
 endif
 
 ##############################################################################
@@ -141,9 +139,6 @@ endif
 
 LDFLAGS += $(XNVCTRL_LDFLAGS)
 
-NVML_EXPERIMENTAL ?=
-CFLAGS += $(if $(NVML_EXPERIMENTAL),-DNVML_EXPERIMENTAL)
-
 
 # Some older Linux distributions do not have the dynamic library
 # libXxf86vm.so, though some newer Linux distributions do not have the
diff --git a/src/command-line.c b/src/command-line.c
index 69f065a..fb30054 100644
--- a/src/command-line.c
+++ b/src/command-line.c
@@ -49,7 +49,7 @@ static void print_version(void)
 {
     nv_msg(NULL, "");
     nv_msg(NULL, NV_ID_STRING);
-    nv_msg(TAB, "The NVIDIA X Server Settings tool.");
+    nv_msg(TAB, "The NVIDIA Settings tool.");
     nv_msg(NULL, "");
     nv_msg(TAB, "This program is used to configure the "
            "NVIDIA Linux graphics driver.");
diff --git a/src/common-utils/gen-manpage-opts-helper.c b/src/common-utils/gen-manpage-opts-helper.c
index b41e2aa..56ba7b3 100644
--- a/src/common-utils/gen-manpage-opts-helper.c
+++ b/src/common-utils/gen-manpage-opts-helper.c
@@ -31,7 +31,8 @@
 
 static void print_option(const NVGetoptOption *o)
 {
-    char scratch[64], *s;
+    char scratch[64];
+    const char *s;
     int j, len;
 
     int italics, bold, omitWhiteSpace, firstchar;
diff --git a/src/common-utils/msg.c b/src/common-utils/msg.c
index 8a78530..70772a2 100644
--- a/src/common-utils/msg.c
+++ b/src/common-utils/msg.c
@@ -113,7 +113,7 @@ do {                                               \
     NV_VSNPRINTF(buf, fmt);                        \
     format(stream, prefix, buf, whitespace);       \
     free (buf);                                    \
-} while(0)
+} while (0)
 
 
 /*
diff --git a/src/common-utils/nvgetopt.c b/src/common-utils/nvgetopt.c
index 286aee8..5ae3a14 100644
--- a/src/common-utils/nvgetopt.c
+++ b/src/common-utils/nvgetopt.c
@@ -189,7 +189,7 @@ int nvgetopt(int argc,
                     if (a[0] == '-') a++;
                     if (a[0] == '+') a++;
 
-                    while(a[0]) { a[0] = a[1]; a++; }
+                    while (a[0]) { a[0] = a[1]; a++; }
 
                     /*
                      * decrement argv_index so that we process this
diff --git a/src/common-utils/nvgetopt.h b/src/common-utils/nvgetopt.h
index 0262aac..37da80e 100644
--- a/src/common-utils/nvgetopt.h
+++ b/src/common-utils/nvgetopt.h
@@ -117,8 +117,8 @@ typedef struct {
     const char *name;
     int val;
     unsigned int flags;
-    char *arg_name;     /* not used by nvgetopt() */
-    char *description;  /* not used by nvgetopt() */
+    const char *arg_name;     /* not used by nvgetopt() */
+    const char *description;  /* not used by nvgetopt() */
 } NVGetoptOption;
 
 
diff --git a/src/common-utils/nvpci-utils.c b/src/common-utils/nvpci-utils.c
new file mode 100644
index 0000000..62946d2
--- /dev/null
+++ b/src/common-utils/nvpci-utils.c
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2021 NVIDIA Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include "nvpci-utils.h"
+
+/*
+ * libpciaccess stores the device class in bits 16-23, subclass in 8-15, and
+ * interface in bits 0-7 of dev->device_class.  We care only about the class
+ * and subclass.
+ */
+const uint32_t PCI_CLASS_DISPLAY_VGA = 0x30000;
+const uint32_t PCI_CLASS_SUBCLASS_MASK = 0xffff00;
+
+/*
+ * nvpci_find_gpu_by_vendor() - use libpciaccess to find all VGA and 3D PCI
+ * devices matching the passed-in vendor_id (which may be set to PCI_MATCH_ANY).
+ * The caller is responsible for calling pci_system_init() before using this
+ * function, and pci_system_cleanup() when libpciaccess is no longer needed.
+ */
+struct pci_device_iterator *nvpci_find_gpu_by_vendor(uint32_t vendor_id)
+{
+    const struct pci_id_match match = {
+        .vendor_id = vendor_id,
+        .device_id = PCI_MATCH_ANY,
+        .subvendor_id = PCI_MATCH_ANY,
+        .subdevice_id = PCI_MATCH_ANY,
+        .device_class = PCI_CLASS_DISPLAY_VGA,
+        /*
+         * Ignore bit 1 of the subclass, to allow both 0x30000 (VGA controller)
+         * and 0x30200 (3D controller).
+         */
+        .device_class_mask = PCI_CLASS_SUBCLASS_MASK & ~0x200,
+    };
+
+    return pci_id_match_iterator_create(&match);
+}
+
+/*
+ * nvpci_dev_is_vga() - test whether the passed-in struct pci_device* has the
+ * VGA device class 0x0300 (and not 3D class 0x0302).
+ */
+int nvpci_dev_is_vga(struct pci_device *dev)
+{
+    return (dev->device_class & PCI_CLASS_SUBCLASS_MASK) ==
+           PCI_CLASS_DISPLAY_VGA;
+}
diff --git a/src/common-utils/nvpci-utils.h b/src/common-utils/nvpci-utils.h
new file mode 100644
index 0000000..9813e90
--- /dev/null
+++ b/src/common-utils/nvpci-utils.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2021 NVIDIA Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __NVPCI_UTILS_H__
+#define __NVPCI_UTILS_H__
+
+#include <pciaccess.h>
+
+#define NV_PCI_VENDOR_ID 0x10de
+
+struct pci_device_iterator *nvpci_find_gpu_by_vendor(uint32_t vendor_id);
+int nvpci_dev_is_vga(struct pci_device *dev);
+
+#endif /* __NVPCI_UTILS_H__ */
diff --git a/src/common-utils/src.mk b/src/common-utils/src.mk
index 6dbed7a..bb1e1d3 100644
--- a/src/common-utils/src.mk
+++ b/src/common-utils/src.mk
@@ -1,5 +1,8 @@
 # makefile fragment included by nvidia-xconfig, nvidia-settings, and nvidia-installer
 
+# the including makefile should set this if the relevant program uses pciaccess
+COMMON_UTILS_PCIACCESS ?=
+
 COMMON_UTILS_SRC        += nvgetopt.c
 COMMON_UTILS_SRC        += common-utils.c
 COMMON_UTILS_SRC        += msg.c
@@ -9,6 +12,16 @@ COMMON_UTILS_EXTRA_DIST += common-utils.h
 COMMON_UTILS_EXTRA_DIST += msg.h
 COMMON_UTILS_EXTRA_DIST += src.mk
 
+# only build nvpci-utils.c for programs that actually use libpciaccess, to
+# prevent other programs from needing to set the right CFLAGS/LDFLAGS for code
+# they won't use. Otherwise, just package it in the source tarball.
+ifneq ($(COMMON_UTILS_PCIACCESS),)
+    COMMON_UTILS_SRC        += nvpci-utils.c
+else
+    COMMON_UTILS_EXTRA_DIST += nvpci-utils.c
+endif
+COMMON_UTILS_EXTRA_DIST += nvpci-utils.h
+
 # gen-manpage-opts-helper.c is listed in EXTRA_DIST, rather than SRC,
 # because it is not compiled into the utilities themselves, but used
 # when building the utility's gen-manpage-opts
diff --git a/src/config-file.c b/src/config-file.c
index ecf2227..8882641 100644
--- a/src/config-file.c
+++ b/src/config-file.c
@@ -19,7 +19,7 @@
 
 /*
  * config-file.c - this source file contains functions for processing
- * the NVIDIA X Server control panel configuration file.
+ * the NVIDIA Settings control panel configuration file.
  *
  * The configuration file is simply a newline-separated list of
  * attribute strings, where the syntax of an attribute string is
@@ -260,7 +260,7 @@ int nv_write_config_file(const char *filename, const CtrlSystem *system,
     fprintf(stream, "# %s\n", filename);
     fprintf(stream, "#\n");
     fprintf(stream, "# Configuration file for nvidia-settings - the NVIDIA "
-            "X Server Settings utility\n");
+            "Settings utility\n");
 
     /* NOTE: ctime(3) generates a new line */
     
diff --git a/src/gtk+-2.x/ctk3dvisionpro.c b/src/gtk+-2.x/ctk3dvisionpro.c
index 88158e2..22a58bc 100644
--- a/src/gtk+-2.x/ctk3dvisionpro.c
+++ b/src/gtk+-2.x/ctk3dvisionpro.c
@@ -187,7 +187,8 @@ static void ctk_3d_vision_pro_finalize(GObject *object)
 
 
 static void ctk_3d_vision_pro_class_init(Ctk3DVisionProClass
-                                         *ctk_3d_vision_pro_class)
+                                         *ctk_3d_vision_pro_class,
+                                         gpointer class_data)
 {
     GObjectClass *gobject_class = (GObjectClass *)ctk_3d_vision_pro_class;
     gobject_class->finalize = ctk_3d_vision_pro_finalize;
@@ -325,8 +326,11 @@ static const char *new_glasses_name_activate(GtkWidget *widget,
     const gchar *str = gtk_entry_get_text(GTK_ENTRY(widget));
 
     // Store new glasses name in dialog box
-    dlg->glasses_new_name = realloc(dlg->glasses_new_name, strlen(str) + 1);
-    strncpy(dlg->glasses_new_name, str, strlen(str) + 1);
+    char *new_name = strdup(str);
+    if (new_name != NULL) {
+        free(dlg->glasses_new_name);
+        dlg->glasses_new_name = new_name;
+    }
 
     return str;
 }
@@ -1320,7 +1324,7 @@ static void rename_button_clicked(GtkButton *button, gpointer user_data)
                         continue;
                     }
                     strncpy(HTU(0)->glasses_info[dlg->glasses_selected_index]->name, dlg->glasses_new_name,
-                            sizeof(HTU(0)->glasses_info[dlg->glasses_selected_index]->name));
+                            sizeof(HTU(0)->glasses_info[dlg->glasses_selected_index]->name) - 1);
                     HTU(0)->glasses_info[dlg->glasses_selected_index]->name[GLASSES_NAME_MAX_LENGTH - 1] = '\0';
 
                     update_glasses_info_data_table(&(ctk_3d_vision_pro->table), HTU(0)->glasses_info);
diff --git a/src/gtk+-2.x/ctkapcprofilemodel.c b/src/gtk+-2.x/ctkapcprofilemodel.c
index d815195..d2de1cc 100644
--- a/src/gtk+-2.x/ctkapcprofilemodel.c
+++ b/src/gtk+-2.x/ctkapcprofilemodel.c
@@ -29,9 +29,9 @@
 static GObjectClass *parent_class = NULL;
 
 // Forward declarations
-static void apc_profile_model_init(CtkApcProfileModel *prof_model);
+static void apc_profile_model_init(CtkApcProfileModel *prof_model, gpointer);
 static void apc_profile_model_finalize(GObject *object);
-static void apc_profile_model_tree_model_init(GtkTreeModelIface *iface);
+static void apc_profile_model_tree_model_init(GtkTreeModelIface *iface, gpointer);
 static GtkTreeModelFlags apc_profile_model_get_flags(GtkTreeModel *tree_model);
 static gint apc_profile_model_get_n_columns(GtkTreeModel *tree_model);
 static GType apc_profile_model_get_column_type(GtkTreeModel *tree_model, gint index);
@@ -54,7 +54,7 @@ apc_profile_model_iter_nth_child(GtkTreeModel *tree_model,
 static gboolean apc_profile_model_iter_parent(GtkTreeModel *tree_model,
                                               GtkTreeIter *iter,
                                               GtkTreeIter *child);
-static void apc_profile_model_class_init(CtkApcProfileModelClass *klass);
+static void apc_profile_model_class_init(CtkApcProfileModelClass *klass, gpointer);
 static void apc_profile_model_get_value(GtkTreeModel *tree_model,
                                         GtkTreeIter *iter,
                                         gint column,
@@ -62,7 +62,7 @@ static void apc_profile_model_get_value(GtkTreeModel *tree_model,
 
 
 static void
-apc_profile_model_tree_sortable_init(GtkTreeSortableIface *iface);
+apc_profile_model_tree_sortable_init(GtkTreeSortableIface *iface, gpointer);
 
 static gboolean apc_profile_model_get_sort_column_id(GtkTreeSortable *sortable,
                                                      gint *sort_column_id,
@@ -122,7 +122,7 @@ GType ctk_apc_profile_model_get_type(void)
     return apc_profile_model_type;
 }
 
-static void apc_profile_model_class_init(CtkApcProfileModelClass *klass)
+static void apc_profile_model_class_init(CtkApcProfileModelClass *klass, gpointer class_data)
 {
     GObjectClass *object_class;
 
@@ -182,7 +182,7 @@ static gint apc_profile_model_sort_settings(GtkTreeModel *model,
     return result;
 }
 
-static void apc_profile_model_init(CtkApcProfileModel *prof_model)
+static void apc_profile_model_init(CtkApcProfileModel *prof_model, gpointer g_class)
 {
     prof_model->stamp = g_random_int(); // random int to catch iterator type mismatches
     prof_model->config = NULL;
@@ -222,7 +222,8 @@ static void apc_profile_model_finalize(GObject *object)
 }
 
 static void
-apc_profile_model_tree_model_init(GtkTreeModelIface *iface)
+apc_profile_model_tree_model_init(GtkTreeModelIface *iface,
+                                  gpointer iface_data)
 {
     iface->get_flags       = apc_profile_model_get_flags;
     iface->get_n_columns   = apc_profile_model_get_n_columns;
@@ -239,7 +240,8 @@ apc_profile_model_tree_model_init(GtkTreeModelIface *iface)
 }
 
 static void
-apc_profile_model_tree_sortable_init(GtkTreeSortableIface *iface)
+apc_profile_model_tree_sortable_init(GtkTreeSortableIface *iface,
+                                     gpointer iface_data)
 {
     iface->get_sort_column_id = apc_profile_model_get_sort_column_id;
     iface->set_sort_column_id = apc_profile_model_set_sort_column_id;
diff --git a/src/gtk+-2.x/ctkapcrulemodel.c b/src/gtk+-2.x/ctkapcrulemodel.c
index 15354dc..dd5d0f7 100644
--- a/src/gtk+-2.x/ctkapcrulemodel.c
+++ b/src/gtk+-2.x/ctkapcrulemodel.c
@@ -28,12 +28,12 @@ static GObjectClass *parent_class = NULL;
 
 // Forward declarations
 GType ctk_apc_rule_model_get_type(void);
-static void apc_rule_model_class_init(CtkApcRuleModelClass *klass);
-static void apc_rule_model_init(CtkApcRuleModel *rule_model);
+static void apc_rule_model_class_init(CtkApcRuleModelClass *klass, gpointer);
+static void apc_rule_model_init(CtkApcRuleModel *rule_model, gpointer);
 static void apc_rule_model_finalize(GObject *object);
-static void apc_rule_model_tree_model_init(GtkTreeModelIface *iface);
-static void apc_rule_model_drag_source_init(GtkTreeDragSourceIface *iface);
-static void apc_rule_model_drag_dest_init(GtkTreeDragDestIface *iface);
+static void apc_rule_model_tree_model_init(GtkTreeModelIface *iface, gpointer);
+static void apc_rule_model_drag_source_init(GtkTreeDragSourceIface *iface, gpointer);
+static void apc_rule_model_drag_dest_init(GtkTreeDragDestIface *iface, gpointer);
 static GtkTreeModelFlags apc_rule_model_get_flags(GtkTreeModel *tree_model);
 static gint apc_rule_model_get_n_columns(GtkTreeModel *tree_model);
 static GType apc_rule_model_get_column_type(GtkTreeModel *tree_model, gint index);
@@ -132,7 +132,8 @@ GType ctk_apc_rule_model_get_type(void)
     return apc_rule_model_type;
 }
 
-static void apc_rule_model_class_init(CtkApcRuleModelClass *klass)
+static void apc_rule_model_class_init(CtkApcRuleModelClass *klass,
+                                      gpointer class_data)
 {
     GObjectClass *object_class;
 
@@ -142,7 +143,7 @@ static void apc_rule_model_class_init(CtkApcRuleModelClass *klass)
     object_class->finalize = apc_rule_model_finalize;
 }
 
-static void apc_rule_model_init(CtkApcRuleModel *rule_model)
+static void apc_rule_model_init(CtkApcRuleModel *rule_model, gpointer g_class)
 {
     rule_model->stamp = g_random_int(); // random int to catch iterator type mismatches
     rule_model->config = NULL;
@@ -156,7 +157,8 @@ static void apc_rule_model_finalize(GObject *object)
     parent_class->finalize(object);
 }
 
-static void apc_rule_model_tree_model_init(GtkTreeModelIface *iface)
+static void apc_rule_model_tree_model_init(GtkTreeModelIface *iface,
+                                           gpointer iface_data)
 {
     iface->get_flags       = apc_rule_model_get_flags;
     iface->get_n_columns   = apc_rule_model_get_n_columns;
@@ -172,14 +174,16 @@ static void apc_rule_model_tree_model_init(GtkTreeModelIface *iface)
     iface->iter_parent     = apc_rule_model_iter_parent;
 }
 
-static void apc_rule_model_drag_source_init(GtkTreeDragSourceIface *iface)
+static void apc_rule_model_drag_source_init(GtkTreeDragSourceIface *iface,
+                                            gpointer iface_data)
 {
     iface->row_draggable = apc_rule_model_row_draggable;
     iface->drag_data_get = apc_rule_model_drag_data_get;
     iface->drag_data_delete = apc_rule_model_drag_data_delete;
 }
 
-static void apc_rule_model_drag_dest_init(GtkTreeDragDestIface *iface)
+static void apc_rule_model_drag_dest_init(GtkTreeDragDestIface *iface,
+                                          gpointer iface_data)
 {
     iface->drag_data_received = apc_rule_model_drag_data_received;
     iface->row_drop_possible  = apc_rule_model_row_drop_possible;
diff --git a/src/gtk+-2.x/ctkappprofile.c b/src/gtk+-2.x/ctkappprofile.c
index 7e39c24..77dd503 100644
--- a/src/gtk+-2.x/ctkappprofile.c
+++ b/src/gtk+-2.x/ctkappprofile.c
@@ -42,6 +42,10 @@
 
 #define STATUSBAR_UPDATE_WARNING "This will take effect after changes are saved."
 
+#define SHARPEN_ENABLE_DEFAULT FALSE
+#define SHARPEN_VALUE_DEFAULT 50
+#define SHARPEN_FILM_GRAIN_DEFAULT 17
+
 enum {
    RULE_FEATURE_PROCNAME,
    RULE_FEATURE_DSO,
@@ -138,7 +142,7 @@ typedef struct _TreeViewColumnTemplate {
 /*
  * Function prototypes
  */
-static void app_profile_class_init(CtkAppProfileClass *ctk_object_class);
+static void app_profile_class_init(CtkAppProfileClass *ctk_object_class, gpointer);
 static void app_profile_finalize(GObject *object);
 static void edit_rule_dialog_destroy(EditRuleDialog *dialog);
 static void edit_profile_dialog_destroy(EditProfileDialog *dialog);
@@ -232,7 +236,8 @@ GType ctk_app_profile_get_type(void)
 
 } /* ctk_app_profile_get_type() */
 
-static void app_profile_class_init(CtkAppProfileClass *ctk_object_class)
+static void app_profile_class_init(CtkAppProfileClass *ctk_object_class,
+                                   gpointer class_data)
 {
     GObjectClass *gobject_class = G_OBJECT_CLASS(ctk_object_class);
     gobject_class->finalize = app_profile_finalize;
@@ -361,8 +366,13 @@ static GtkWidget *populate_registry_key_combo_callback(gpointer init_data)
     for (i = 0; i < json_array_size(key_docs); i++) {
         json_t *json_key_object = json_array_get(key_docs, i);
         json_t *json_name = json_object_get(json_key_object, "key");
+        const gchar *key_name = json_string_value(json_name);
+        // The GLSharpen* variables have custom UI, so don't add them to the dropdown
+        if (!strncmp(key_name, "GLSharpen", 9)) {
+            continue;
+        }
         ctk_drop_down_menu_append_item(menu,
-                                       json_string_value(json_name),
+                                       key_name,
                                        i);
     }
 
@@ -1381,6 +1391,18 @@ static gboolean profile_browse_button_clicked(GtkWidget *widget, gpointer user_d
     return FALSE;
 }
 
+static void sharpen_enable_checkbox_toggled(GtkWidget *widget,
+                                            gpointer user_data)
+{
+    EditProfileDialog *dialog = (EditProfileDialog *)user_data;
+    gboolean sharpen_enable;
+
+    sharpen_enable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
+
+    ctk_widget_set_visible(dialog->sharpen_value_box, sharpen_enable);
+    ctk_widget_set_visible(dialog->sharpen_film_grain_box, sharpen_enable);
+}
+
 static const char __rule_pattern_help[] =
     "In this section, you write the pattern that will be used to determine whether "
     "the settings in this rule will apply to a given application.";
@@ -2347,12 +2369,47 @@ static gboolean append_setting(GtkTreeModel *model,
     return FALSE;
 }
 
+static void edit_profile_dialog_update_sharpen_settings(EditProfileDialog *dialog)
+{
+    json_t *sharpen_enable_setting, *sharpen_value_setting, *sharpen_film_setting;
+    gboolean sharpen_enable;
+    int sharpen_value, sharpen_film;
+
+    sharpen_enable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->sharpen_enable_check_button));
+
+    if (!sharpen_enable) {
+        return;
+    }
+
+    sharpen_enable_setting = json_object();
+    json_object_set_new(sharpen_enable_setting, "key", json_string("GLSharpenEnable"));
+    json_object_set_new(sharpen_enable_setting, "value", json_boolean(sharpen_enable));
+
+    json_array_append(dialog->settings, sharpen_enable_setting);
+
+    sharpen_value_setting = json_object();
+    json_object_set_new(sharpen_value_setting, "key", json_string("GLSharpenValue"));
+    sharpen_value = gtk_adjustment_get_value(GTK_ADJUSTMENT(dialog->sharpen_value_adjustment));
+    json_object_set_new(sharpen_value_setting, "value", json_integer(sharpen_value));
+
+    json_array_append(dialog->settings, sharpen_value_setting);
+
+    sharpen_film_setting = json_object();
+    json_object_set_new(sharpen_film_setting, "key", json_string("GLSharpenIgnoreFilmGrain"));
+    sharpen_film = gtk_adjustment_get_value(GTK_ADJUSTMENT(dialog->sharpen_film_grain_adjustment));
+    json_object_set_new(sharpen_film_setting, "value", json_integer(sharpen_film));
+
+    json_array_append(dialog->settings, sharpen_film_setting);
+}
+
 static void edit_profile_dialog_update_settings(EditProfileDialog *dialog)
 {
     json_array_clear(dialog->settings);
     gtk_tree_model_foreach(GTK_TREE_MODEL(dialog->settings_store),
                            append_setting,
                            (gpointer)dialog->settings);
+
+    edit_profile_dialog_update_sharpen_settings(dialog);
 }
 
 static gboolean widget_get_visible(GtkWidget *widget)
@@ -2973,6 +3030,11 @@ static EditProfileDialog *edit_profile_dialog_new(CtkAppProfile *ctk_app_profile
     GtkWidget *tree_view;
     GtkWidget *scroll_win;
     GtkWidget *button;
+    GtkWidget *sharpen_enable_checkbox;
+    GtkWidget *sharpen_value_slider;
+    GtkWidget *sharpen_film_slider;
+    GtkAdjustment *sharpen_value_adjustment;
+    GtkAdjustment *sharpen_film_adjustment;
     GList *toolbar_widget_items;
 
     ToolbarItemTemplate *edit_profile_settings_toolbar_items, *edit_profile_dialog_toolbar_items;
@@ -2980,7 +3042,6 @@ static EditProfileDialog *edit_profile_dialog_new(CtkAppProfile *ctk_app_profile
     TreeViewColumnTemplate *settings_tree_view_columns;
     size_t num_settings_tree_view_columns;
 
-
     dialog = malloc(sizeof(EditProfileDialog));
     if (!dialog) {
         return NULL;
@@ -3098,6 +3159,56 @@ static EditProfileDialog *edit_profile_dialog_new(CtkAppProfile *ctk_app_profile
     gtk_container_add(GTK_CONTAINER(scroll_win), tree_view);
     gtk_box_pack_start(GTK_BOX(main_vbox), scroll_win, TRUE, TRUE, 0);
 
+    hbox = gtk_hbox_new(FALSE, 5);
+
+    label = gtk_label_new("Enable Sharpening");
+    dialog->sharpen_enable_check_button = sharpen_enable_checkbox
+        = gtk_check_button_new();
+
+    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sharpen_enable_checkbox),
+                                 SHARPEN_ENABLE_DEFAULT);
+
+    g_signal_connect(G_OBJECT(sharpen_enable_checkbox), "toggled",
+                     G_CALLBACK(sharpen_enable_checkbox_toggled),
+                     (gpointer)dialog);
+
+    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
+    gtk_box_pack_start(GTK_BOX(hbox), sharpen_enable_checkbox, TRUE, TRUE, 0);
+
+    gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 0);
+
+    dialog->sharpen_value_box = hbox = gtk_hbox_new(FALSE, 5);
+    label = gtk_label_new("Sharpening Amount");
+    dialog->sharpen_value_adjustment = sharpen_value_adjustment
+        = GTK_ADJUSTMENT(gtk_adjustment_new(SHARPEN_VALUE_DEFAULT, 0, 100, 1, 1, 0.0));
+
+    dialog->sharpen_value_slider = sharpen_value_slider =
+        gtk_hscale_new(GTK_ADJUSTMENT(sharpen_value_adjustment));
+    gtk_scale_set_draw_value(GTK_SCALE(sharpen_value_slider), TRUE);
+    gtk_scale_set_value_pos(GTK_SCALE(sharpen_value_slider), GTK_POS_TOP);
+    gtk_scale_set_digits(GTK_SCALE(sharpen_value_slider), 0);
+
+    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
+    gtk_box_pack_start(GTK_BOX(hbox), sharpen_value_slider, TRUE, TRUE, 0);
+
+    gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 0);
+
+    dialog->sharpen_film_grain_box = hbox = gtk_hbox_new(FALSE, 5);
+    label = gtk_label_new("Film Grain Reduction");
+    dialog->sharpen_film_grain_adjustment = sharpen_film_adjustment =
+        GTK_ADJUSTMENT(gtk_adjustment_new(SHARPEN_FILM_GRAIN_DEFAULT, 0, 100, 1, 1, 0.0));
+
+    dialog->sharpen_film_grain_slider = sharpen_film_slider =
+        gtk_hscale_new(GTK_ADJUSTMENT(sharpen_film_adjustment));
+    gtk_scale_set_draw_value(GTK_SCALE(sharpen_film_slider), TRUE);
+    gtk_scale_set_value_pos(GTK_SCALE(sharpen_film_slider), GTK_POS_TOP);
+    gtk_scale_set_digits(GTK_SCALE(sharpen_film_slider), 0);
+
+    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
+    gtk_box_pack_start(GTK_BOX(hbox), sharpen_film_slider, TRUE, TRUE, 0);
+
+    gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 0);
+
     dialog->setting_update_canceled = FALSE;
 
     ctk_statusbar_init(&dialog->error_statusbar);
@@ -3399,6 +3510,50 @@ static gboolean profiles_tree_view_key_press_event(GtkWidget *widget,
     return FALSE;
 }
 
+static gboolean check_sharpening_setting(EditProfileDialog *dialog,
+                                         GtkTreeModel *model,
+                                         GtkTreeIter *iter)
+{
+    json_t *setting;
+    json_t *value;
+    const char *key;
+
+    gtk_tree_model_get(model, iter, SETTING_LIST_STORE_COL_SETTING, &setting, -1);
+    if (setting && setting->refcount == 0) {
+        return FALSE;
+    }
+
+    key = json_string_value(json_object_get(setting, "key"));
+    value = json_object_get(setting, "value");
+
+    if (!strcmp(key, "GLSharpenEnable")) {
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->sharpen_enable_check_button),
+                                 json_is_true(value));
+        return TRUE;
+    } else if (!strcmp(key, "GLSharpenValue") && json_is_integer(value)) {
+        gtk_adjustment_set_value(GTK_ADJUSTMENT(dialog->sharpen_value_adjustment), json_integer_value(value));
+        return TRUE;
+    } else if (!strcmp(key, "GLSharpenIgnoreFilmGrain") && json_is_integer(value)) {
+        gtk_adjustment_set_value(GTK_ADJUSTMENT(dialog->sharpen_film_grain_adjustment), json_integer_value(value));
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+static void edit_profile_dialog_load_sharpening_settings(EditProfileDialog *dialog) {
+    gint i, row_count;
+    GtkTreeModel *model = GTK_TREE_MODEL(dialog->settings_store);
+    GtkTreeIter iter;
+    row_count = gtk_tree_model_iter_n_children(model, NULL);
+    for (i = row_count - 1; i >= 0; i--) {
+        gtk_tree_model_iter_nth_child(model, &iter, NULL, i);
+        if (check_sharpening_setting(dialog, model, &iter)) {
+            gtk_list_store_remove(GTK_LIST_STORE(dialog->settings_store), &iter);
+        }
+    }
+}
+
 static void edit_profile_dialog_load_values(EditProfileDialog *dialog)
 {
     // window title
@@ -3435,6 +3590,7 @@ static void edit_profile_dialog_load_values(EditProfileDialog *dialog)
         load_settings_from_profile(CTK_APP_PROFILE(dialog->parent),
                                    dialog->settings_store,
                                    dialog->name->str);
+        edit_profile_dialog_load_sharpening_settings(dialog);
     } else {
         gtk_list_store_clear(dialog->settings_store);
     }
@@ -3444,6 +3600,7 @@ static void edit_profile_dialog_show(EditProfileDialog *dialog)
 {
     edit_profile_dialog_load_values(dialog);
     gtk_widget_show_all(dialog->top_window);
+    sharpen_enable_checkbox_toggled(dialog->sharpen_enable_check_button, dialog);
 
     // disable focusing to calling window until this window closed
     gtk_window_set_transient_for(GTK_WINDOW(dialog->top_window),
diff --git a/src/gtk+-2.x/ctkappprofile.h b/src/gtk+-2.x/ctkappprofile.h
index 3f59ca8..1627214 100644
--- a/src/gtk+-2.x/ctkappprofile.h
+++ b/src/gtk+-2.x/ctkappprofile.h
@@ -104,6 +104,14 @@ typedef struct _EditProfileDialog {
 
     GtkWidget *source_file_combo;
 
+    GtkWidget *sharpen_enable_check_button;
+    GtkWidget *sharpen_value_box;
+    GtkAdjustment *sharpen_value_adjustment;
+    GtkWidget *sharpen_value_slider;
+    GtkWidget *sharpen_film_grain_box;
+    GtkAdjustment *sharpen_film_grain_adjustment;
+    GtkWidget *sharpen_film_grain_slider;
+
     GtkWidget *add_edit_profile_button;
 
     GtkWidget *registry_key_combo;
diff --git a/src/gtk+-2.x/ctkbanner.c b/src/gtk+-2.x/ctkbanner.c
index 0479272..b43af03 100644
--- a/src/gtk+-2.x/ctkbanner.c
+++ b/src/gtk+-2.x/ctkbanner.c
@@ -59,7 +59,7 @@
 
 
 static void
-ctk_banner_class_init    (CtkBannerClass *);
+ctk_banner_class_init    (CtkBannerClass *, gpointer);
 
 static void
 ctk_banner_finalize      (GObject *);
@@ -122,7 +122,8 @@ GType ctk_banner_get_type(
 }
 
 static void ctk_banner_class_init(
-    CtkBannerClass *ctk_banner_class
+    CtkBannerClass *ctk_banner_class,
+    gpointer class_data
 )
 {
     GObjectClass *gobject_class;
@@ -311,7 +312,8 @@ static gboolean ctk_banner_configure_event(
     needed_w = ctk_banner->artwork.w + ctk_banner->artwork_pad_x;
     needed_h = ctk_banner->artwork.h;
 
-    if ((ctk_banner->back.w >= needed_w) &&
+    if (ctk_banner->artwork.pixbuf &&
+        (ctk_banner->back.w >= needed_w) &&
         (ctk_banner->back.h >= needed_h)) {
         
         w = ctk_banner->artwork.w;
@@ -429,13 +431,13 @@ static GdkPixbuf* select_artwork(BannerArtworkType artwork,
         { BANNER_ARTWORK_X,              FALSE, 16,      PNG(x)                   },
         { BANNER_ARTWORK_XVIDEO,         FALSE, 16,      PNG(xvideo)              },
         { BANNER_ARTWORK_SVP,            FALSE, 16,      PNG(svp_3dvp)            },
-        { BANNER_ARTWORK_INVALID,        FALSE, 16,      NULL, NULL               },
+        { BANNER_ARTWORK_BLANK,          FALSE, 16,      NULL, NULL               },
 #undef PNG
     };
 
     int i;
 
-    for (i = 0; ArtworkTable[i].artwork != BANNER_ARTWORK_INVALID; i++) {
+    for (i = 0; ArtworkTable[i].artwork <= BANNER_ARTWORK_BLANK; i++) {
         if (ArtworkTable[i].artwork == artwork) {
             *tall = ArtworkTable[i].tall;
             *pad_x = ArtworkTable[i].pad_x;
@@ -459,13 +461,10 @@ GtkWidget* ctk_banner_new(BannerArtworkType artwork)
 {
     GObject *object;
     CtkBanner *ctk_banner;
-    int tall, pad_x;
+
+    int tall = 0, pad_x = 0;
     GdkPixbuf *pixbuf = select_artwork(artwork, &tall, &pad_x);
 
-    if (!pixbuf) {
-        return NULL;
-    }
-    
     object = g_object_new(CTK_TYPE_BANNER, NULL);
     
     ctk_banner = CTK_BANNER(object);
@@ -524,10 +523,11 @@ GtkWidget* ctk_banner_new(BannerArtworkType artwork)
     
     
     /* load the artwork pixbuf */
-
-    ctk_banner->artwork.pixbuf = pixbuf;
-    ctk_banner->artwork.w = gdk_pixbuf_get_width(pixbuf);
-    ctk_banner->artwork.h = gdk_pixbuf_get_height(pixbuf);
+    if (pixbuf) {
+        ctk_banner->artwork.pixbuf = pixbuf;
+        ctk_banner->artwork.w = gdk_pixbuf_get_width(pixbuf);
+        ctk_banner->artwork.h = gdk_pixbuf_get_height(pixbuf);
+    }
 
     return GTK_WIDGET(object);
 }
diff --git a/src/gtk+-2.x/ctkbanner.h b/src/gtk+-2.x/ctkbanner.h
index 9d4dd4e..86ee0fd 100644
--- a/src/gtk+-2.x/ctkbanner.h
+++ b/src/gtk+-2.x/ctkbanner.h
@@ -66,7 +66,7 @@ typedef enum {
     BANNER_ARTWORK_X,
     BANNER_ARTWORK_XVIDEO,
     BANNER_ARTWORK_SVP,
-    BANNER_ARTWORK_INVALID
+    BANNER_ARTWORK_BLANK
 } BannerArtworkType;
 
 
diff --git a/src/gtk+-2.x/ctkcolorcontrols.c b/src/gtk+-2.x/ctkcolorcontrols.c
index db2d9e7..bcd0253 100644
--- a/src/gtk+-2.x/ctkcolorcontrols.c
+++ b/src/gtk+-2.x/ctkcolorcontrols.c
@@ -37,7 +37,7 @@
 
 /* function prototypes */
 static void
-ctk_color_controls_class_init(CtkColorControlsClass *ctk_object_class);
+ctk_color_controls_class_init(CtkColorControlsClass *ctk_object_class, gpointer);
 
 static void ctk_color_controls_finalize(GObject *object);
 
@@ -122,7 +122,8 @@ GType ctk_color_controls_get_type(void)
 
 
 static void
-ctk_color_controls_class_init(CtkColorControlsClass *ctk_object_class)
+ctk_color_controls_class_init(CtkColorControlsClass *ctk_object_class,
+                              gpointer class_data)
 {
     GObjectClass *gobject_class = (GObjectClass *)ctk_object_class;
     gobject_class->finalize = ctk_color_controls_finalize;
diff --git a/src/gtk+-2.x/ctkcolorcorrection.c b/src/gtk+-2.x/ctkcolorcorrection.c
index 44dc213..8ec1998 100644
--- a/src/gtk+-2.x/ctkcolorcorrection.c
+++ b/src/gtk+-2.x/ctkcolorcorrection.c
@@ -82,7 +82,7 @@ static void
 flush_attribute_channel_values (CtkColorCorrection *, gint, gint);
 
 static void
-ctk_color_correction_class_init(CtkColorCorrectionClass *);
+ctk_color_correction_class_init(CtkColorCorrectionClass *, gpointer);
 
 static void ctk_color_correction_finalize(GObject *);
 
@@ -163,7 +163,8 @@ GType ctk_color_correction_get_type(
 
 static void
 ctk_color_correction_class_init(CtkColorCorrectionClass
-                                *ctk_color_correction_class)
+                                *ctk_color_correction_class,
+                                gpointer class_data)
 {
     GObjectClass *gobject_class = (GObjectClass *)ctk_color_correction_class;
 
diff --git a/src/gtk+-2.x/ctkconfig.c b/src/gtk+-2.x/ctkconfig.c
index e5ca3e4..52939aa 100644
--- a/src/gtk+-2.x/ctkconfig.c
+++ b/src/gtk+-2.x/ctkconfig.c
@@ -74,7 +74,7 @@ static const char *__update_rules_on_profile_name_change_help =
 "that refer to that profile to also be updated to refer to the new "
 "profile name.";
 
-static void ctk_config_class_init(CtkConfigClass *ctk_config_class);
+static void ctk_config_class_init(CtkConfigClass *ctk_config_class, gpointer);
 
 static void display_status_bar_toggled(GtkWidget *, gpointer);
 static void slider_text_entries_toggled(GtkWidget *, gpointer);
@@ -122,7 +122,8 @@ static void config_finalize(GObject *object)
     ctk_help_data_list_free_full(ctk_config->help_data);
 }
 
-static void ctk_config_class_init(CtkConfigClass *ctk_config_class)
+static void ctk_config_class_init(CtkConfigClass *ctk_config_class,
+                                  gpointer class_data)
 {
     GObjectClass *gobject_class = G_OBJECT_CLASS(ctk_config_class);
     gobject_class->finalize = config_finalize;
diff --git a/src/gtk+-2.x/ctkcurve.c b/src/gtk+-2.x/ctkcurve.c
index 2c68605..b6a1dbe 100644
--- a/src/gtk+-2.x/ctkcurve.c
+++ b/src/gtk+-2.x/ctkcurve.c
@@ -28,7 +28,7 @@
 #define REQUESTED_HEIGHT 94
 
 static void
-ctk_curve_class_init    (CtkCurveClass *);
+ctk_curve_class_init    (CtkCurveClass *, gpointer);
 
 static void
 ctk_curve_finalize      (GObject *);
@@ -95,7 +95,8 @@ GType ctk_curve_get_type(
 }
 
 static void ctk_curve_class_init(
-    CtkCurveClass *ctk_curve_class
+    CtkCurveClass *ctk_curve_class,
+    gpointer class_data
 )
 {
     GObjectClass *gobject_class;
diff --git a/src/gtk+-2.x/ctkdisplayconfig-utils.c b/src/gtk+-2.x/ctkdisplayconfig-utils.c
index dc26f5d..3922373 100644
--- a/src/gtk+-2.x/ctkdisplayconfig-utils.c
+++ b/src/gtk+-2.x/ctkdisplayconfig-utils.c
@@ -17,7 +17,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses>.
  */
 
-
 #include <stdlib.h> /* malloc */
 #include <string.h> /* strlen,  strdup */
 #include <unistd.h> /* lseek, close */
@@ -2570,6 +2569,11 @@ void link_screen_to_gpu(nvScreenPtr screen, nvGpuPtr gpu)
         screen->max_displays = MIN(screen->max_displays, gpu->max_displays);
     }
 
+    if (gpu->multigpu_master_possible &&
+        !screen->display_owner_gpu->multigpu_master_possible) {
+        screen->display_owner_gpu = gpu;
+    }
+
     /* Set the display owner GPU. */
     if (screen->display_owner_gpu_id >= 0) {
         /* Link to the multi GPU display owner, if it is specified */
diff --git a/src/gtk+-2.x/ctkdisplayconfig.c b/src/gtk+-2.x/ctkdisplayconfig.c
index d6c15a3..578e543 100644
--- a/src/gtk+-2.x/ctkdisplayconfig.c
+++ b/src/gtk+-2.x/ctkdisplayconfig.c
@@ -17,7 +17,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses>.
  */
 
-
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
@@ -500,6 +499,13 @@ static void register_layout_events(CtkDisplayConfig *ctk_object)
                          CTK_EVENT_NAME(NV_CTRL_STRING_DELETE_METAMODE),
                          G_CALLBACK(display_config_attribute_changed),
                          (gpointer) ctk_object);
+
+        if (screen->num_prime_displays > 0) {
+            g_signal_connect(G_OBJECT(screen->ctk_event),
+                             CTK_EVENT_NAME(NV_CTRL_STRING_PRIME_OUTPUTS_DATA),
+                             G_CALLBACK(display_config_attribute_changed),
+                             (gpointer) ctk_object);
+        }
     }
 
 } /* register_layout_events() */
@@ -2631,21 +2637,21 @@ GtkTextBuffer *ctk_display_config_create_help(GtkTextTagTable *table,
 
 static void setup_mosaic_config(CtkDisplayConfig *ctk_object)
 {
-    nvDisplayPtr display = ctk_display_layout_get_selected_display
-        (CTK_DISPLAY_LAYOUT(ctk_object->obj_layout));
-    nvScreenPtr screen = ctk_display_layout_get_selected_screen
-        (CTK_DISPLAY_LAYOUT(ctk_object->obj_layout));
     nvGpuPtr gpu;
     const char *tooltip;
     const gchar *label;
-    gboolean display_gpu_support_mosaic = (display && display->gpu &&
-        display->gpu->mosaic_type != MOSAIC_TYPE_UNSUPPORTED);
-    gboolean screen_gpu_support_mosaic = (screen && screen->display_owner_gpu &&
-        screen->display_owner_gpu->mosaic_type != MOSAIC_TYPE_UNSUPPORTED);
+    nvLayoutPtr layout = ctk_object->layout;
+    int any_gpu_support_mosaic = FALSE;
 
+    for (gpu = layout->gpus; gpu; gpu = gpu->next_in_layout) {
+        if (gpu->mosaic_type != MOSAIC_TYPE_UNSUPPORTED) {
+            any_gpu_support_mosaic = TRUE;
+            break;
+        }
+    }
 
     if (!ctk_object->advanced_mode ||
-        (!display_gpu_support_mosaic && !screen_gpu_support_mosaic)) {
+        !any_gpu_support_mosaic) {
         gtk_widget_hide(ctk_object->chk_mosaic_enabled);
         gtk_widget_hide(ctk_object->btn_mosaic);
         return;
@@ -2653,12 +2659,6 @@ static void setup_mosaic_config(CtkDisplayConfig *ctk_object)
 
     gtk_widget_show(ctk_object->chk_mosaic_enabled);
 
-    if (display_gpu_support_mosaic) {
-        gpu = display->gpu;
-    } else {
-        gpu = screen->display_owner_gpu;
-    }
-
     /* Only show the Mosaic Config tool with SLI Mosaic and dialog exists */
     if (gpu->mosaic_type == MOSAIC_TYPE_SLI_MOSAIC &&
         ctk_object->dialog_mosaic) {
diff --git a/src/gtk+-2.x/ctkdisplayconfig.h b/src/gtk+-2.x/ctkdisplayconfig.h
index 802ac80..7fcaefc 100644
--- a/src/gtk+-2.x/ctkdisplayconfig.h
+++ b/src/gtk+-2.x/ctkdisplayconfig.h
@@ -20,7 +20,6 @@
 #ifndef __CTK_DISPLAYCONFIG_H__
 #define __CTK_DISPLAYCONFIG_H__
 
-
 #include "ctkevent.h"
 #include "ctkconfig.h"
 #include "ctkdisplaylayout.h"
diff --git a/src/gtk+-2.x/ctkdisplaydevice.c b/src/gtk+-2.x/ctkdisplaydevice.c
index ef112ac..66ff2aa 100644
--- a/src/gtk+-2.x/ctkdisplaydevice.c
+++ b/src/gtk+-2.x/ctkdisplaydevice.c
@@ -17,7 +17,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses>.
  */
 
-
 #include <gtk/gtk.h>
 #include <NvCtrlAttributes.h>
 #include <string.h>
@@ -37,7 +36,7 @@
 #include "ctkhelp.h"
 #include "ctkutils.h"
 
-static void ctk_display_device_class_init(CtkDisplayDeviceClass *);
+static void ctk_display_device_class_init(CtkDisplayDeviceClass *, gpointer);
 static void ctk_display_device_finalize(GObject *);
 
 static void reset_button_clicked(GtkButton *button, gpointer user_data);
@@ -245,7 +244,8 @@ GType ctk_display_device_get_type(void)
 }
 
 static void ctk_display_device_class_init(
-    CtkDisplayDeviceClass *ctk_object_class
+    CtkDisplayDeviceClass *ctk_object_class,
+    gpointer class_data
 )
 {
     GObjectClass *gobject_class = (GObjectClass *)ctk_object_class;
@@ -924,8 +924,6 @@ static gboolean update_vrr_enabled_info(InfoEntry *entry)
 
 
 
-
-
 static gboolean update_refresh_rate(InfoEntry *entry)
 {
     CtkDisplayDevice *ctk_object = entry->ctk_object;
diff --git a/src/gtk+-2.x/ctkdisplaylayout.h b/src/gtk+-2.x/ctkdisplaylayout.h
index fb2aef5..4925e88 100644
--- a/src/gtk+-2.x/ctkdisplaylayout.h
+++ b/src/gtk+-2.x/ctkdisplaylayout.h
@@ -20,7 +20,6 @@
 #ifndef __CTK_DISPLAYLAYOUT_H__
 #define __CTK_DISPLAYLAYOUT_H__
 
-
 #include "ctkevent.h"
 #include "ctkconfig.h"
 
diff --git a/src/gtk+-2.x/ctkditheringcontrols.c b/src/gtk+-2.x/ctkditheringcontrols.c
index 2467bb9..e041e52 100644
--- a/src/gtk+-2.x/ctkditheringcontrols.c
+++ b/src/gtk+-2.x/ctkditheringcontrols.c
@@ -37,7 +37,7 @@
 
 /* function prototypes */
 static void
-ctk_dither_controls_class_init(CtkDitheringControlsClass *ctk_object_class);
+ctk_dither_controls_class_init(CtkDitheringControlsClass *ctk_object_class, gpointer);
 
 static void ctk_dither_controls_finalize(GObject *object);
 
@@ -132,7 +132,8 @@ GType ctk_dithering_controls_get_type(void)
 } /* ctk_dithering_controls_get_type() */
 
 static void
-ctk_dither_controls_class_init(CtkDitheringControlsClass *ctk_object_class)
+ctk_dither_controls_class_init(CtkDitheringControlsClass *ctk_object_class,
+                               gpointer class_data)
 {
     GObjectClass *gobject_class = (GObjectClass *)ctk_object_class;
     gobject_class->finalize = ctk_dither_controls_finalize;
diff --git a/src/gtk+-2.x/ctkdropdownmenu.c b/src/gtk+-2.x/ctkdropdownmenu.c
index f1b33be..c8f6338 100644
--- a/src/gtk+-2.x/ctkdropdownmenu.c
+++ b/src/gtk+-2.x/ctkdropdownmenu.c
@@ -33,7 +33,7 @@ static guint __signals[LAST_SIGNAL] = { 0 };
 
 
 static void
-ctk_drop_down_menu_class_init(CtkDropDownMenuClass *ctk_drop_down_menu_class);
+ctk_drop_down_menu_class_init(CtkDropDownMenuClass *ctk_drop_down_menu_class, gpointer class_data);
 
 static void ctk_drop_down_menu_free(GObject *object);
 
@@ -69,7 +69,8 @@ GType ctk_drop_down_menu_get_type(
 
 
 static void
-ctk_drop_down_menu_class_init(CtkDropDownMenuClass *ctk_drop_down_menu_class)
+ctk_drop_down_menu_class_init(CtkDropDownMenuClass *ctk_drop_down_menu_class,
+                              gpointer class_data)
 {
     GObjectClass *gobject_class;
     
diff --git a/src/gtk+-2.x/ctkecc.c b/src/gtk+-2.x/ctkecc.c
index 591d2aa..82715a2 100644
--- a/src/gtk+-2.x/ctkecc.c
+++ b/src/gtk+-2.x/ctkecc.c
@@ -58,6 +58,22 @@ static const char *__aggregate_dbit_error_help =
 "Returns the number of double-bit ECC errors detected by the "
 "targeted GPU since the last counter reset.";
 
+static const char *__detailed_sbit_error_help =
+"Returns the number of single-bit ECC errors detected for the specified "
+"memory location by the targeted GPU since the last system reboot.";
+
+static const char *__detailed_dbit_error_help =
+"Returns the number of double-bit ECC errors detected for the specified "
+"memory location by the targeted GPU since the last system reboot.";
+
+static const char *__detailed_aggregate_sbit_error_help =
+"Returns the number of single-bit ECC errors detected for the specified "
+"memory location by the targeted GPU since the last counter reset.";
+
+static const char *__detailed_aggregate_dbit_error_help =
+"Returns the number of double-bit ECC errors detected for the specified "
+"memory location by the targeted GPU since the last counter reset.";
+
 static const char *__configuration_status_help =
 "Returns the current ECC configuration setting or specifies new "
 "settings.  Changes to these settings do not take effect until the next "
@@ -156,6 +172,135 @@ static GtkWidget *add_table_int_row(CtkConfig *ctk_config, GtkWidget *table,
 
 
 
+/*
+ * memory_location_label() - returns the proper name of the memory location
+ * specified.
+ */
+static const char *memory_location_label(const int index, int sram_value)
+{
+    if (index < 0 || index >= NVML_MEMORY_LOCATION_COUNT) {
+        return "Unknown";
+    }
+
+    /*
+     * NVML_MEMORY_LOCATION_DRAM and MNML_MEMORY_LOCATION_DEVICE_MEMORY share
+     * the same index value. _DRAM is only for Turing+ while _DEVICE_MEMORY is
+     * used preTuring. Since NVML_MEMORY_LOCATION_SRAM is also only used for
+     * Turing+, if that value is valid then this is Turing+ and we want the DRAM
+     * label.
+     */
+
+    if (index == NVML_MEMORY_LOCATION_DRAM && sram_value >= 0) {
+        return "DRAM";
+    }
+
+    switch (index) {
+        case NVML_MEMORY_LOCATION_L1_CACHE:
+            return "L1 Cache";
+        case NVML_MEMORY_LOCATION_L2_CACHE:
+            return "L2 Cache";
+        case NVML_MEMORY_LOCATION_DEVICE_MEMORY:
+            // See above for duplicate value NVML_MEMORY_LOCATION_DRAM
+            return "Device Memory";
+        case NVML_MEMORY_LOCATION_REGISTER_FILE:
+            return "Register File";
+        case NVML_MEMORY_LOCATION_TEXTURE_MEMORY:
+            return "Texture Memory";
+        case NVML_MEMORY_LOCATION_TEXTURE_SHM:
+            return "Texture Shared";
+        case NVML_MEMORY_LOCATION_CBU:
+            return "CBU";
+        case NVML_MEMORY_LOCATION_SRAM:
+            return "SRAM";
+    }
+
+    return "Unknown";
+}
+
+
+
+/*
+ * update_detailed_widgets() - fills in or clears out the values for the
+ * detailed ECC information.
+ */
+static void update_detailed_widgets(CtkEccDetailedTableRow errors[],
+                                    gboolean vol, int *counts)
+{
+    int loc;
+    int value;
+    char s[32];
+    GtkLabel *label;
+    for (loc = NVML_MEMORY_LOCATION_L1_CACHE;
+         loc < NVML_MEMORY_LOCATION_COUNT;
+         loc++) {
+
+        if (!counts) {
+            value = -1;
+        } else {
+            value = counts[loc];
+        }
+
+        if (vol) {
+            errors[loc].vol_count_value = value;
+            label = GTK_LABEL(errors[loc].vol_count);
+        } else {
+            errors[loc].agg_count_value = value;
+            label = GTK_LABEL(errors[loc].agg_count);
+        }
+
+        if (value < 0) {
+            gtk_label_set_text(label, "N/A");
+        } else {
+            sprintf(s, "%d", value);
+            gtk_label_set_text(label, s);
+        }
+    }
+}
+
+
+
+/*
+ * hide_unavailable_rows() - Hide a row in the table for a memory location if
+ * both the volatile and aggregate values are less than 0, i.e. not supported.
+ */
+
+static void hide_unavailable_rows(CtkEcc *ctk_ecc)
+{
+    int loc;
+    gboolean show_row;
+    gboolean any_detailed_info = FALSE;
+
+    for (loc = NVML_MEMORY_LOCATION_L1_CACHE;
+         loc < NVML_MEMORY_LOCATION_COUNT;
+         loc++) {
+
+        show_row = (ctk_ecc->single_errors[loc].vol_count_value >= 0 ||
+                    ctk_ecc->single_errors[loc].agg_count_value >= 0);
+        ctk_widget_set_visible(ctk_ecc->single_errors[loc].err_type, show_row);
+        ctk_widget_set_visible(ctk_ecc->single_errors[loc].mem_type, show_row);
+        ctk_widget_set_visible(ctk_ecc->single_errors[loc].vol_count,
+                               show_row);
+        ctk_widget_set_visible(ctk_ecc->single_errors[loc].agg_count,
+                               show_row);
+        any_detailed_info |= show_row;
+
+        show_row = (ctk_ecc->double_errors[loc].vol_count_value >= 0 ||
+                    ctk_ecc->double_errors[loc].agg_count_value >= 0);
+        ctk_widget_set_visible(ctk_ecc->double_errors[loc].err_type, show_row);
+        ctk_widget_set_visible(ctk_ecc->double_errors[loc].mem_type, show_row);
+        ctk_widget_set_visible(ctk_ecc->double_errors[loc].vol_count,
+                               show_row);
+        ctk_widget_set_visible(ctk_ecc->double_errors[loc].agg_count,
+                               show_row);
+        any_detailed_info |= show_row;
+    }
+
+    ctk_widget_set_visible(ctk_ecc->detailed_table, any_detailed_info);
+    ctk_widget_set_visible(ctk_ecc->summary_table, !any_detailed_info);
+}
+
+
+
 /*
  * update_ecc_info() - update ECC status and configuration
  */
@@ -167,6 +312,8 @@ static gboolean update_ecc_info(gpointer user_data)
     int64_t val;
     gboolean status;
     ReturnStatus ret;
+    unsigned char *cdata;
+    int *counts, len;
 
 
     if (!ctk_ecc->ecc_config_supported && !ctk_ecc->ecc_enabled ) {
@@ -201,7 +348,18 @@ static gboolean update_ecc_info(gpointer user_data)
 
     /* Query ECC Errors */
 
-    if (ctk_ecc->sbit_error) {
+    /* Detailed Single Bit Volatile */
+    counts = NULL;
+    cdata = NULL;
+    ret = NvCtrlGetBinaryAttribute(ctrl_target, 0,
+              NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS_SINGLE_BIT,
+              &cdata, &len);
+    if (ret == NvCtrlSuccess) {
+        counts = (int *)cdata;
+    }
+    update_detailed_widgets(ctk_ecc->single_errors, 1, counts);
+
+    if (!counts && ctk_ecc->sbit_error) {
         ret = NvCtrlGetAttribute64(ctrl_target,
                                    NV_CTRL_GPU_ECC_SINGLE_BIT_ERRORS,
                                    &val);
@@ -210,8 +368,21 @@ static gboolean update_ecc_info(gpointer user_data)
         }
         set_label_value(ctk_ecc->sbit_error, val);
     }
+    nvfree(cdata);
+
+    /* Detailed Double Bit Volatile */
+    counts = NULL;
+    cdata = NULL;
+    ret = NvCtrlGetBinaryAttribute(ctrl_target, 0,
+              NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS_DOUBLE_BIT,
+              &cdata, &len);
+    if (ret == NvCtrlSuccess) {
+        counts = (int *)cdata;
+    }
+
+    update_detailed_widgets(ctk_ecc->double_errors, 1, counts);
 
-    if (ctk_ecc->dbit_error) {
+    if (!counts && ctk_ecc->dbit_error) {
         ret = NvCtrlGetAttribute64(ctrl_target,
                                    NV_CTRL_GPU_ECC_DOUBLE_BIT_ERRORS,
                                    &val);
@@ -220,8 +391,21 @@ static gboolean update_ecc_info(gpointer user_data)
         }
         set_label_value(ctk_ecc->dbit_error, val);
     }
+    nvfree(cdata);
+
+    /* Detailed Single Bit Aggregate */
+    counts = NULL;
+    cdata = NULL;
+    ret = NvCtrlGetBinaryAttribute(ctrl_target, 0,
+              NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS_SINGLE_BIT_AGGREGATE,
+              &cdata, &len);
+    if (ret == NvCtrlSuccess) {
+        counts = (int *)cdata;
+    }
+
+    update_detailed_widgets(ctk_ecc->single_errors, 0, counts);
 
-    if (ctk_ecc->aggregate_sbit_error) {
+    if (!counts && ctk_ecc->aggregate_sbit_error) {
         ret = NvCtrlGetAttribute64(ctrl_target,
                                    NV_CTRL_GPU_ECC_AGGREGATE_SINGLE_BIT_ERRORS,
                                    &val);
@@ -230,8 +414,21 @@ static gboolean update_ecc_info(gpointer user_data)
         }
         set_label_value(ctk_ecc->aggregate_sbit_error, val);
     }
+    nvfree(cdata);
+
+    /* Detailed Double Bit Aggregate */
+    counts = NULL;
+    cdata = NULL;
+    ret = NvCtrlGetBinaryAttribute(ctrl_target, 0,
+              NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS_DOUBLE_BIT_AGGREGATE,
+              &cdata, &len);
+    if (ret == NvCtrlSuccess) {
+        counts = (int *)cdata;
+    }
+
+    update_detailed_widgets(ctk_ecc->double_errors, 0, counts);
 
-    if (ctk_ecc->aggregate_dbit_error) {
+    if (!counts && ctk_ecc->aggregate_dbit_error) {
         ret = NvCtrlGetAttribute64(ctrl_target,
                                    NV_CTRL_GPU_ECC_AGGREGATE_DOUBLE_BIT_ERRORS,
                                    &val);
@@ -240,6 +437,9 @@ static gboolean update_ecc_info(gpointer user_data)
         }
         set_label_value(ctk_ecc->aggregate_dbit_error, val);
     }
+    nvfree(cdata);
+
+    hide_unavailable_rows(ctk_ecc);
 
     return TRUE;
 } /* update_ecc_info() */
@@ -480,6 +680,99 @@ static void ecc_config_button_toggled(GtkWidget *widget,
 
 
 
+/*
+ * pack_detailed_widgets() - helper function to create a row for detailed ECC
+ * data.
+ */
+
+static void pack_detailed_widgets(CtkEcc *ctk_ecc, gboolean single,
+                                  int row, int loc)
+{
+    CtkConfig *ctk_config = ctk_ecc->ctk_config;
+    GtkWidget *widget_err = NULL;
+    GtkWidget *widget_mem = NULL;
+    int xpad = 12, ypad = 2;
+
+    widget_mem = GTK_WIDGET(gtk_label_new(memory_location_label(loc, 0)));
+    if (single) {
+        widget_err = GTK_WIDGET(gtk_label_new("Single Bit"));
+        ctk_ecc->single_errors[loc].err_type = widget_err;
+        ctk_ecc->single_errors[loc].mem_type = widget_mem;
+    } else {
+        widget_err = GTK_WIDGET(gtk_label_new("Double Bit"));
+        ctk_ecc->double_errors[loc].err_type = widget_err;
+        ctk_ecc->double_errors[loc].mem_type = widget_mem;
+    }
+
+    ctk_widget_set_halign_left(widget_err);
+    ctk_widget_set_halign_left(widget_mem);
+
+    gtk_table_attach(GTK_TABLE(ctk_ecc->detailed_table), widget_err, 0, 1,
+                     row, row + 1, GTK_FILL, GTK_FILL, xpad, ypad);
+
+    gtk_table_attach(GTK_TABLE(ctk_ecc->detailed_table), widget_mem, 1, 2,
+                     row, row + 1, GTK_FILL, GTK_FILL, xpad, ypad);
+
+    if (single) {
+        ctk_config_set_tooltip(ctk_config,
+                               ctk_ecc->single_errors[loc].vol_count,
+                               __detailed_sbit_error_help);
+        ctk_config_set_tooltip(ctk_config,
+                               ctk_ecc->single_errors[loc].agg_count,
+                               __detailed_aggregate_sbit_error_help);
+        gtk_table_attach(GTK_TABLE(ctk_ecc->detailed_table),
+                         ctk_ecc->single_errors[loc].vol_count,
+                         2, 3, row, row + 1, GTK_SHRINK, GTK_SHRINK,
+                         xpad, ypad);
+        gtk_table_attach(GTK_TABLE(ctk_ecc->detailed_table),
+                         ctk_ecc->single_errors[loc].agg_count,
+                         3, 4, row, row + 1, GTK_SHRINK, GTK_SHRINK,
+                         xpad, ypad);
+    } else {
+        ctk_config_set_tooltip(ctk_config,
+                               ctk_ecc->double_errors[loc].vol_count,
+                               __detailed_dbit_error_help);
+        ctk_config_set_tooltip(ctk_config,
+                               ctk_ecc->double_errors[loc].agg_count,
+                               __detailed_aggregate_dbit_error_help);
+        gtk_table_attach(GTK_TABLE(ctk_ecc->detailed_table),
+                         ctk_ecc->double_errors[loc].vol_count,
+                         2, 3, row, row + 1, GTK_SHRINK, GTK_SHRINK,
+                         xpad, ypad);
+        gtk_table_attach(GTK_TABLE(ctk_ecc->detailed_table),
+                         ctk_ecc->double_errors[loc].agg_count,
+                         3, 4, row, row + 1, GTK_SHRINK, GTK_SHRINK,
+                         xpad, ypad);
+    }
+}
+
+
+
+/*
+ * update_detailed_label_for_values() - Sets the label names for the
+ * detailed memory location labels. This need to be run after the first
+ * query for values so that it can propery set the labels for the
+ * memory locations available.
+ */
+static void update_detailed_label_for_values(CtkEcc *ctk_ecc)
+{
+    const char *loc_str;
+
+    loc_str = memory_location_label(NVML_MEMORY_LOCATION_DRAM,
+        ctk_ecc->single_errors[NVML_MEMORY_LOCATION_SRAM].vol_count_value);
+    gtk_label_set_text(
+        GTK_LABEL(ctk_ecc->single_errors[NVML_MEMORY_LOCATION_DRAM].mem_type),
+        loc_str);
+
+    loc_str = memory_location_label(NVML_MEMORY_LOCATION_DRAM,
+        ctk_ecc->double_errors[NVML_MEMORY_LOCATION_SRAM].vol_count_value);
+    gtk_label_set_text(
+        GTK_LABEL(ctk_ecc->double_errors[NVML_MEMORY_LOCATION_DRAM].mem_type),
+        loc_str);
+}
+
+
+
 GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target,
                        CtkConfig *ctk_config,
                        CtkEvent *ctk_event)
@@ -502,6 +795,8 @@ GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target,
     ReturnStatus ret;
     gchar *ecc_enabled_string;
     gchar *str = NULL;
+    int loc;
+    gint xpad = 12, ypad = 2;
 
     /* make sure we have a handle */
 
@@ -635,34 +930,41 @@ GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target,
     hseparator = gtk_hseparator_new();
     gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5);
 
-    table = gtk_table_new(1, 2, FALSE);
-    gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
-    gtk_table_set_row_spacings(GTK_TABLE(table), 3);
-    gtk_table_set_col_spacings(GTK_TABLE(table), 15);
-    gtk_container_set_border_width(GTK_CONTAINER(table), 5);
-
     /* ECC Status */
     hbox2 = gtk_hbox_new(FALSE, 0);
-    gtk_table_attach(GTK_TABLE(table), hbox2, 0, 1, row, row+1,
-                     GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
+    gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 5);
 
     label = gtk_label_new("ECC:");
     gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
-    gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
+    gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 5);
 
     eventbox = gtk_event_box_new();
-    gtk_table_attach(GTK_TABLE(table), eventbox, 1, 2, row, row+1,
-                     GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
+    gtk_box_pack_start(GTK_BOX(hbox2), eventbox, FALSE, FALSE, 5);
 
     label = gtk_label_new(ecc_enabled_string);
     gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
     gtk_container_add(GTK_CONTAINER(eventbox), label);
     ctk_config_set_tooltip(ctk_config, eventbox, __ecc_status_help);
     ctk_ecc->status = label;
-    
-    row += 3;
-    
+
+
     /* Add ECC Errors */
+    hbox = gtk_hbox_new(FALSE, 0);
+    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
+
+    label = gtk_label_new("ECC Errors");
+    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
+
+    hseparator = gtk_hseparator_new();
+    gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5);
+
+    row = 0;
+    table = gtk_table_new(1, 2, FALSE);
+    gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
+    gtk_table_set_row_spacings(GTK_TABLE(table), 3);
+    gtk_table_set_col_spacings(GTK_TABLE(table), 15);
+    gtk_container_set_border_width(GTK_CONTAINER(table), 5);
+
 
     if (sbit_error_available && dbit_error_available) {
         ctk_ecc->sbit_error =
@@ -690,7 +992,79 @@ GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target,
                               "Aggregate Double-bit ECC Errors:",
                               aggregate_dbit_error, row, ecc_enabled);
     }
-    
+
+    ctk_ecc->summary_table = table;
+
+    /*
+     * Create the structures needed for the Detailed ECC information table.
+     */
+
+    /* Initialize the widgets for the Detailed ECC counts */
+    for (loc = NVML_MEMORY_LOCATION_L1_CACHE;
+         loc < NVML_MEMORY_LOCATION_COUNT;
+         loc++) {
+        ctk_ecc->single_errors[loc].vol_count =
+            GTK_WIDGET(gtk_label_new("N/A"));
+        ctk_ecc->single_errors[loc].agg_count =
+            GTK_WIDGET(gtk_label_new("N/A"));
+        ctk_ecc->double_errors[loc].vol_count =
+            GTK_WIDGET(gtk_label_new("N/A"));
+        ctk_ecc->double_errors[loc].agg_count =
+            GTK_WIDGET(gtk_label_new("N/A"));
+    }
+
+    /* Create the detailed ECC table. Headers, labels, and pack the widgets */
+    ctk_ecc->detailed_table = gtk_table_new(5, 4, FALSE);
+
+    /* Header row */
+    row = 0;
+    gtk_table_attach(GTK_TABLE(ctk_ecc->detailed_table),
+                     GTK_WIDGET(gtk_label_new("Error Type")),
+                     0, 1, row, row + 1, GTK_FILL, GTK_FILL, xpad, ypad);
+    gtk_table_attach(GTK_TABLE(ctk_ecc->detailed_table),
+                     GTK_WIDGET(gtk_label_new("Memory Type")),
+                     1, 2, row, row + 1, GTK_FILL, GTK_FILL, xpad, ypad);
+    gtk_table_attach(GTK_TABLE(ctk_ecc->detailed_table),
+                     GTK_WIDGET(gtk_label_new("Volatile")),
+                     2, 3, row, row + 1, GTK_SHRINK, GTK_SHRINK, xpad, ypad);
+    gtk_table_attach(GTK_TABLE(ctk_ecc->detailed_table),
+                     GTK_WIDGET(gtk_label_new("Aggregate")),
+                     3, 4, row, row + 1, GTK_SHRINK, GTK_SHRINK, xpad, ypad);
+
+    /* Start of the data rows, add the single bit error rows first */
+
+    row = 1;
+
+    /* Single Bit */;
+    pack_detailed_widgets(ctk_ecc, TRUE, row++,
+                          NVML_MEMORY_LOCATION_DEVICE_MEMORY);
+    for (loc = NVML_MEMORY_LOCATION_L1_CACHE;
+         loc < NVML_MEMORY_LOCATION_COUNT;
+         loc++, row++) {
+        if (loc == NVML_MEMORY_LOCATION_DEVICE_MEMORY) {
+            continue;
+        }
+        pack_detailed_widgets(ctk_ecc, TRUE, row, loc);
+    }
+
+    /* Double Bit */
+    pack_detailed_widgets(ctk_ecc, FALSE, row++,
+                          NVML_MEMORY_LOCATION_DEVICE_MEMORY);
+    for (loc = NVML_MEMORY_LOCATION_L1_CACHE;
+         loc < NVML_MEMORY_LOCATION_COUNT;
+         loc++, row++) {
+        if (loc == NVML_MEMORY_LOCATION_DEVICE_MEMORY) {
+            continue;
+        }
+        pack_detailed_widgets(ctk_ecc, FALSE, row, loc);
+    }
+
+    gtk_widget_set_sensitive(ctk_ecc->detailed_table, ecc_enabled);
+
+    gtk_box_pack_start(GTK_BOX(vbox), ctk_ecc->detailed_table,
+                       FALSE, FALSE, 0);
+
+
     /* ECC configuration settings */
 
     hbox = gtk_hbox_new(FALSE, 0);
@@ -783,6 +1157,7 @@ GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target,
     gtk_widget_show_all(GTK_WIDGET(ctk_ecc));
 
     update_ecc_info(ctk_ecc);
+    update_detailed_label_for_values(ctk_ecc);
 
     return GTK_WIDGET(ctk_ecc);
 }
diff --git a/src/gtk+-2.x/ctkecc.h b/src/gtk+-2.x/ctkecc.h
index 158cf16..424bb65 100644
--- a/src/gtk+-2.x/ctkecc.h
+++ b/src/gtk+-2.x/ctkecc.h
@@ -22,6 +22,7 @@
 
 #include "ctkevent.h"
 #include "ctkconfig.h"
+#include "nvml.h"
 
 G_BEGIN_DECLS
 
@@ -46,6 +47,16 @@ G_BEGIN_DECLS
 typedef struct _CtkEcc       CtkEcc;
 typedef struct _CtkEccClass  CtkEccClass;
 
+typedef struct _CtkEccDetailedTableRow
+{
+    GtkWidget *err_type;
+    GtkWidget *mem_type;
+    GtkWidget *vol_count;
+    GtkWidget *agg_count;
+    int vol_count_value;
+    int agg_count_value;
+} CtkEccDetailedTableRow;
+
 struct _CtkEcc
 {
     GtkVBox parent;
@@ -62,6 +73,7 @@ struct _CtkEcc
     GtkWidget* clear_aggregate_button;
     GtkWidget* reset_default_config_button;
     GtkWidget* configuration_status;
+    GtkWidget* summary_table;
 
     gboolean ecc_enabled;
     gboolean ecc_configured;
@@ -73,6 +85,9 @@ struct _CtkEcc
     gboolean ecc_config_supported;
     gboolean ecc_default_status;
 
+    GtkWidget* detailed_table;
+    CtkEccDetailedTableRow single_errors[NVML_MEMORY_LOCATION_COUNT];
+    CtkEccDetailedTableRow double_errors[NVML_MEMORY_LOCATION_COUNT];
 };
 
 struct _CtkEccClass
diff --git a/src/gtk+-2.x/ctkedid.c b/src/gtk+-2.x/ctkedid.c
index a681fcb..19f4109 100644
--- a/src/gtk+-2.x/ctkedid.c
+++ b/src/gtk+-2.x/ctkedid.c
@@ -178,7 +178,7 @@ static void normalize_filename(CtkEdid *ctk_edid)
     if (!filename) {
         goto done;
     }
-    strncpy(filename, ctk_edid->filename, len);
+    memcpy(filename, ctk_edid->filename, len + 1);
 
     /*
      * It is possible that filename is entered without any extension,
diff --git a/src/gtk+-2.x/ctkevent.c b/src/gtk+-2.x/ctkevent.c
index 1f2b076..b3e35a9 100644
--- a/src/gtk+-2.x/ctkevent.c
+++ b/src/gtk+-2.x/ctkevent.c
@@ -28,7 +28,6 @@
  *   NV-CONTROL -> event -> glib -> CtkEvent -> signal -> GUI
  */
 
-
 #include <string.h>
 
 #include <gtk/gtk.h>
@@ -40,7 +39,7 @@
 #include "NVCtrlLib.h"
 #include "msg.h"
 
-static void ctk_event_class_init(CtkEventClass *ctk_event_class);
+static void ctk_event_class_init(CtkEventClass *ctk_event_class, gpointer);
 
 static gboolean ctk_event_prepare(GSource *, gint *);
 static gboolean ctk_event_check(GSource *);
@@ -102,7 +101,8 @@ GType ctk_event_get_type(void)
 } /* ctk_event_get_type() */
 
 
-static void ctk_event_class_init(CtkEventClass *ctk_event_class)
+static void ctk_event_class_init(CtkEventClass *ctk_event_class,
+                                 gpointer class_data)
 {
     gint i;
 
@@ -243,7 +243,6 @@ static void ctk_event_class_init(CtkEventClass *ctk_event_class)
     MAKE_SIGNAL(NV_CTRL_THERMAL_SENSOR_READING);
     MAKE_SIGNAL(NV_CTRL_THERMAL_SENSOR_PROVIDER);
     MAKE_SIGNAL(NV_CTRL_THERMAL_SENSOR_TARGET);
-    MAKE_SIGNAL(NV_CTRL_GPU_CURRENT_PROCESSOR_CLOCK_FREQS);
     MAKE_SIGNAL(NV_CTRL_GPU_PCIE_MAX_LINK_SPEED);
     MAKE_SIGNAL(NV_CTRL_3D_VISION_PRO_TRANSCEIVER_CHANNEL);
     MAKE_SIGNAL(NV_CTRL_3D_VISION_PRO_TRANSCEIVER_MODE);
@@ -263,8 +262,6 @@ static void ctk_event_class_init(CtkEventClass *ctk_event_class)
     MAKE_SIGNAL(NV_CTRL_FRAMELOCK_DISPLAY_CONFIG);
     MAKE_SIGNAL(NV_CTRL_TOTAL_DEDICATED_GPU_MEMORY);
     MAKE_SIGNAL(NV_CTRL_USED_DEDICATED_GPU_MEMORY);
-    MAKE_SIGNAL(NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE);
-    MAKE_SIGNAL(NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT);
     MAKE_SIGNAL(NV_CTRL_DPY_HDMI_3D);
     MAKE_SIGNAL(NV_CTRL_BASE_MOSAIC);
     MAKE_SIGNAL(NV_CTRL_MULTIGPU_PRIMARY_POSSIBLE);
@@ -297,6 +294,7 @@ static void ctk_event_class_init(CtkEventClass *ctk_event_class)
     MAKE_SIGNAL(NV_CTRL_DISPLAY_VRR_MIN_REFRESH_RATE);
     MAKE_SIGNAL(NV_CTRL_DISPLAY_VRR_ENABLED);
     MAKE_SIGNAL(NV_CTRL_PLATFORM_POWER_MODE);
+    MAKE_SIGNAL(NV_CTRL_MUX_AUTO_SWITCH);
 #undef MAKE_SIGNAL
 
     /*
@@ -306,7 +304,7 @@ static void ctk_event_class_init(CtkEventClass *ctk_event_class)
      * knows about.
      */
 
-#if NV_CTRL_LAST_ATTRIBUTE != NV_CTRL_PLATFORM_CURRENT_POWER_MODE
+#if NV_CTRL_LAST_ATTRIBUTE != NV_CTRL_DYNAMIC_BOOST_SUPPORT
 #warning "There are attributes that do not emit signals!"
 #endif
 
@@ -351,9 +349,10 @@ static void ctk_event_class_init(CtkEventClass *ctk_event_class)
     MAKE_STRING_SIGNAL(NV_CTRL_STRING_GPU_UTILIZATION);
     MAKE_STRING_SIGNAL(NV_CTRL_STRING_MULTIGPU_MODE);
     MAKE_STRING_SIGNAL(NV_CTRL_STRING_PRIME_OUTPUTS_DATA);
+    MAKE_STRING_SIGNAL(NV_CTRL_STRING_MUX_STATE);
 #undef MAKE_STRING_SIGNAL
 
-#if NV_CTRL_STRING_LAST_ATTRIBUTE != NV_CTRL_STRING_DISPLAY_NAME_CONNECTOR
+#if NV_CTRL_STRING_LAST_ATTRIBUTE != NV_CTRL_STRING_MUX_STATE
 #warning "There are attributes that do not emit signals!"
 #endif
 
@@ -386,7 +385,8 @@ static void ctk_event_class_init(CtkEventClass *ctk_event_class)
     MAKE_BINARY_SIGNAL(NV_CTRL_BINARY_DATA_DISPLAYS_ON_GPU);
 #undef MAKE_BINARY_SIGNAL
 
-#if NV_CTRL_BINARY_DATA_LAST_ATTRIBUTE != NV_CTRL_BINARY_DATA_DISPLAYS_ON_GPU
+#if NV_CTRL_BINARY_DATA_LAST_ATTRIBUTE != \
+    NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS_DOUBLE_BIT_AGGREGATE
 #warning "There are attributes that do not emit signals!"
 #endif
 
diff --git a/src/gtk+-2.x/ctkframelock.c b/src/gtk+-2.x/ctkframelock.c
index 0a57e88..8a0aa1a 100644
--- a/src/gtk+-2.x/ctkframelock.c
+++ b/src/gtk+-2.x/ctkframelock.c
@@ -4618,7 +4618,8 @@ static GObjectClass *parent_class;
  *
  */
 static void ctk_framelock_class_init(
-    CtkFramelockClass *ctk_framelock_class
+    CtkFramelockClass *ctk_framelock_class,
+    gpointer class_data
 )
 {
     parent_class = g_type_class_peek_parent(ctk_framelock_class);
diff --git a/src/gtk+-2.x/ctkgauge.c b/src/gtk+-2.x/ctkgauge.c
index 369f6f9..36e6a97 100644
--- a/src/gtk+-2.x/ctkgauge.c
+++ b/src/gtk+-2.x/ctkgauge.c
@@ -27,7 +27,7 @@
 #define REQUESTED_HEIGHT 86
 
 static void
-ctk_gauge_class_init    (CtkGaugeClass *);
+ctk_gauge_class_init    (CtkGaugeClass *, gpointer);
 
 static void
 ctk_gauge_finalize      (GObject *);
@@ -95,7 +95,8 @@ GType ctk_gauge_get_type(
 }
 
 static void ctk_gauge_class_init(
-    CtkGaugeClass *ctk_gauge_class
+    CtkGaugeClass *ctk_gauge_class,
+    gpointer class_data
 )
 {
     GObjectClass *gobject_class;
diff --git a/src/gtk+-2.x/ctkglwidget.c b/src/gtk+-2.x/ctkglwidget.c
index bd47bcd..5c98c3d 100644
--- a/src/gtk+-2.x/ctkglwidget.c
+++ b/src/gtk+-2.x/ctkglwidget.c
@@ -202,7 +202,8 @@ static void ctk_glwidget_finalize(GObject *gobject)
     assert(!"unimplemented");
 }
 
-static void ctk_glwidget_class_init(CtkGLWidgetClass *klass)
+static void ctk_glwidget_class_init(CtkGLWidgetClass *klass,
+                                    gpointer class_data)
 {
     GtkWidgetClass *widget_class;
     GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
diff --git a/src/gtk+-2.x/ctkglx.c b/src/gtk+-2.x/ctkglx.c
index 05c5612..5e2f13e 100644
--- a/src/gtk+-2.x/ctkglx.c
+++ b/src/gtk+-2.x/ctkglx.c
@@ -1257,7 +1257,7 @@ GtkTextBuffer *ctk_glx_create_help(GtkTextTagTable *table,
 
     ctk_help_title(b, &i, "Graphics Information Help");
     ctk_help_para(b, &i,
-                  "This page in the NVIDIA X Server Control Panel describes "
+                  "This page in the NVIDIA Settings Control Panel describes "
                   "information about graphics libraries available on this X "
                   "screen."
                   );
diff --git a/src/gtk+-2.x/ctkgpu.c b/src/gtk+-2.x/ctkgpu.c
index 497cdcf..db0007d 100644
--- a/src/gtk+-2.x/ctkgpu.c
+++ b/src/gtk+-2.x/ctkgpu.c
@@ -96,7 +96,7 @@ void get_bus_type_str(CtrlTarget *ctrl_target, gchar **bus)
     gchar *bus_type_str, *bus_rate, *pcie_gen;
 
     bus_type = 0xffffffff;
-    bus_type_str = "Unknown";
+    bus_type_str = NULL;
     ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_BUS_TYPE, &bus_type);
     if (ret == NvCtrlSuccess) {
         if      (bus_type == NV_CTRL_BUS_TYPE_AGP)
@@ -107,6 +107,8 @@ void get_bus_type_str(CtrlTarget *ctrl_target, gchar **bus)
             bus_type_str = "PCI Express";
         else if (bus_type == NV_CTRL_BUS_TYPE_INTEGRATED)
             bus_type_str = "Integrated";
+        else
+            bus_type_str = "Unknown";
     }
 
     /* NV_CTRL_GPU_PCIE_MAX_LINK_WIDTH */
@@ -228,8 +230,8 @@ GtkWidget* ctk_gpu_new(CtrlTarget *ctrl_target,
     ReturnStatus ret;
 
     gchar *screens;
-    gchar *displays;
-    gchar *tmp_str;
+    gchar *displays = NULL;
+    gchar *tmp_str = NULL;
     gchar *gpu_cores;
     gchar *memory_interface;
     gchar *bus = NULL;
@@ -245,6 +247,7 @@ GtkWidget* ctk_gpu_new(CtrlTarget *ctrl_target,
     int total_rows = 21;
     int gpu_memory;
     utilizationEntry entry;
+    gboolean resizable_bar;
 
 
     /*
@@ -325,6 +328,14 @@ GtkWidget* ctk_gpu_new(CtrlTarget *ctrl_target,
         gpu_cores = g_strdup_printf("%d", tmp);
     }
 
+    /* NV_CTRL_RESIZABLE_BAR */
+    ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_RESIZABLE_BAR, &tmp);
+    if (ret != NvCtrlSuccess) {
+        resizable_bar = FALSE;
+    } else {
+        resizable_bar = tmp;
+    }
+
     /* NV_CTRL_GPU_MEMORY_BUS_WIDTH  */
 
     ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_MEMORY_BUS_WIDTH, &tmp);
@@ -426,6 +437,7 @@ GtkWidget* ctk_gpu_new(CtrlTarget *ctrl_target,
     ctk_gpu->gpu_cores = (gpu_cores != NULL) ? 1 : 0;
     ctk_gpu->gpu_uuid = (gpu_uuid != NULL) ? 1 : 0;
     ctk_gpu->memory_interface = (memory_interface != NULL) ? 1 : 0;
+    ctk_gpu->resizable_bar = resizable_bar;
     ctk_gpu->ctk_config = ctk_config;
     ctk_gpu->ctk_event = ctk_event;
     ctk_gpu->pcie_gen_queriable = FALSE;
@@ -498,9 +510,11 @@ GtkWidget* ctk_gpu_new(CtrlTarget *ctrl_target,
                       0, 0.5, "VBIOS Version:",
                       0, 0.5, vbios_version);
     }
-    add_table_row(table, row++,
-                  0, 0.5, "Total Memory:",
-                  0, 0.5, video_ram);
+    if (video_ram) {
+        add_table_row(table, row++,
+                      0, 0.5, "Total Memory:",
+                      0, 0.5, video_ram);
+    }
     add_table_row(table, row++,
                   0, 0.5, "Total Dedicated Memory:",
                   0, 0.5, gpu_memory_text);
@@ -508,6 +522,12 @@ GtkWidget* ctk_gpu_new(CtrlTarget *ctrl_target,
         add_table_row(table, row++,
                       0, 0.5, "Used Dedicated Memory:",
                       0, 0.5, NULL);
+    if (ctk_gpu->resizable_bar) {
+        gtk_table_resize(GTK_TABLE(table), ++total_rows, 2);
+        add_table_row(table, row++,
+                      0, 0.5, "Resizable BAR:",
+                      0, 0.5, "Yes");
+    }
     if ( ctk_gpu->memory_interface ) {
         gtk_table_resize(GTK_TABLE(table), ++total_rows, 2);
         add_table_row(table, row++,
@@ -532,9 +552,11 @@ GtkWidget* ctk_gpu_new(CtrlTarget *ctrl_target,
 
     /* spacing */
     row += 3;
-    add_table_row(table, row++,
-                  0, 0.5, "Bus Type:",
-                  0, 0.5, bus);
+    if (bus) {
+        add_table_row(table, row++,
+                      0, 0.5, "Bus Type:",
+                      0, 0.5, bus);
+    }
     if ( pci_bus_id ) {
         add_table_row(table, row++,
                       0, 0.5, "Bus ID:",
@@ -564,13 +586,17 @@ GtkWidget* ctk_gpu_new(CtrlTarget *ctrl_target,
         add_table_row(table, row++,
                       0, 0.5, "Maximum PCIe Link Width:",
                       0, 0.5, link_width_str);
-        add_table_row(table, row++,
-                      0, 0.5, "Maximum PCIe Link Speed:",
-                      0, 0.5, link_speed_str);
-        ctk_gpu->pcie_utilization_label =
+        if (link_speed_str) {
             add_table_row(table, row++,
-                          0, 0.5, "PCIe Bandwidth Utilization:",
-                          0, 0.5, NULL);
+                          0, 0.5, "Maximum PCIe Link Speed:",
+                          0, 0.5, link_speed_str);
+        }
+        if (entry.pcie_specified) {
+            ctk_gpu->pcie_utilization_label =
+                add_table_row(table, row++,
+                              0, 0.5, "PCIe Bandwidth Utilization:",
+                              0, 0.5, NULL);
+        }
 
         g_free(link_speed_str);
         g_free(link_width_str);
@@ -579,19 +605,22 @@ GtkWidget* ctk_gpu_new(CtrlTarget *ctrl_target,
     }
 
     update_gpu_usage(ctk_gpu);
-    /* spacing */
-    row += 3;
-    add_table_row(table, row++,
-                  0, 0, "X Screens:",
-                  0, 0, screens);
-    /* spacing */
-    displays = make_display_device_list(ctrl_target);
 
-    row += 3;
-    ctk_gpu->displays =
-        add_table_row(table, row,
-                      0, 0, "Display Devices:",
-                      0, 0, displays);
+    if (ctrl_target->system->has_nv_control) {
+        /* spacing */
+        row += 3;
+        add_table_row(table, row++,
+                      0, 0, "X Screens:",
+                      0, 0, screens);
+        /* spacing */
+        displays = make_display_device_list(ctrl_target);
+
+        row += 3;
+        ctk_gpu->displays =
+            add_table_row(table, row,
+                          0, 0, "Display Devices:",
+                          0, 0, displays);
+    }
 
     free(product_name);
     free(vbios_version);
@@ -641,7 +670,7 @@ GtkTextBuffer *ctk_gpu_create_help(GtkTextTagTable *table,
     ctk_help_title(b, &i, "Graphics Card Information Help");
 
     ctk_help_para(b, &i, "This page in the NVIDIA "
-                  "X Server Control Panel describes basic "
+                  "Settings Control Panel describes basic "
                   "information about the Graphics Processing Unit "
                   "(GPU).");
     
@@ -680,6 +709,12 @@ GtkTextBuffer *ctk_gpu_create_help(GtkTextTagTable *table,
     ctk_help_para(b, &i, "This is the amount of dedicated memory used "
                   "by your GPU.");
 
+    if (ctk_gpu->resizable_bar) {
+        ctk_help_heading(b, &i, "Resizable BAR");
+        ctk_help_para(b, &i, "This indicates whether Resizable BAR may be "
+                      "available on supported systems.");
+    }
+
     if (ctk_gpu->memory_interface) {
         ctk_help_heading(b, &i, "Memory Interface");
         ctk_help_para(b, &i, "This is the bus bandwidth of the GPU's "
diff --git a/src/gtk+-2.x/ctkgpu.h b/src/gtk+-2.x/ctkgpu.h
index 57e593f..3640779 100644
--- a/src/gtk+-2.x/ctkgpu.h
+++ b/src/gtk+-2.x/ctkgpu.h
@@ -67,6 +67,7 @@ struct _CtkGpu
     gint gpu_cores;
     gint gpu_uuid;
     gint memory_interface;
+    gboolean resizable_bar;
     gboolean pcie_gen_queriable;
 };
 
diff --git a/src/gtk+-2.x/ctkgridlicense.c b/src/gtk+-2.x/ctkgridlicense.c
index 239ba51..7ff1bc7 100644
--- a/src/gtk+-2.x/ctkgridlicense.c
+++ b/src/gtk+-2.x/ctkgridlicense.c
@@ -2,7 +2,7 @@
  * nvidia-settings: A tool for configuring the NVIDIA X driver on Unix
  * and Linux systems.
  *
- * Copyright (C) 2020 NVIDIA Corporation.
+ * Copyright (C) 2021 NVIDIA Corporation.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -21,7 +21,7 @@
 #include <string.h>
 #include <ctype.h>
 #include <inttypes.h>
-#include <sys/stat.h> 
+#include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <dlfcn.h>
@@ -49,10 +49,12 @@
 
 static const char * __manage_grid_licenses_help =
 "Use the Manage License page to obtain licenses "
-"for NVIDIA vGPU or NVIDIA RTX Virtual Workstation on supported Tesla products.";
+"for NVIDIA vGPU or NVIDIA RTX Virtual Workstation on supported Tesla products. "
+"The current license status is displayed on the page. If licensed, the license expiry information in GMT time zone is shown.";
 static const char * __manage_grid_licenses_vcompute_help =
 "Use the Manage License page to obtain licenses "
-"for NVIDIA vGPU or NVIDIA RTX Virtual Workstation or NVIDIA Virtual Compute Server on supported Tesla products.";
+"for NVIDIA vGPU or NVIDIA RTX Virtual Workstation or NVIDIA Virtual Compute Server on supported Tesla products. "
+"The current license status is displayed on the page. If licensed, the license expiry information in GMT time zone is shown.";
 static const char * __grid_virtual_workstation_help =
 "Select this option to enable NVIDIA RTX Virtual Workstation license.";
 static const char * __grid_virtual_compute_help =
@@ -84,7 +86,7 @@ static const char * __cancel_button_help =
 "Clicking the Cancel button sets the text in all textboxes from the gridd.conf file. "
 "Any changes you have done will be lost.";
 
-typedef struct 
+typedef struct
 {
     void                                                *dbusHandle;
     typeof(dbus_bus_get)                                *getDbus;
@@ -116,7 +118,7 @@ struct _DbusData
 static void apply_clicked(GtkWidget *widget, gpointer user_data);
 static void cancel_clicked(GtkWidget *widget, gpointer user_data);
 static void ctk_manage_grid_license_finalize(GObject *object);
-static void ctk_manage_grid_license_class_init(CtkManageGridLicenseClass *);
+static void ctk_manage_grid_license_class_init(CtkManageGridLicenseClass *, gpointer);
 static void dbusClose(DbusData *dbusData);
 static gboolean checkConfigfile(gboolean *writable);
 static gboolean disallow_whitespace(GtkWidget *widget, GdkEvent *event, gpointer user_data);
@@ -127,7 +129,7 @@ static gboolean licenseStateQueryFailed = FALSE;
 static void get_licensable_feature_information(gpointer user_data);
 static gboolean is_feature_supported(gpointer user_data, int featureType);
 static gboolean is_restart_required(gpointer user_data);
-static gboolean queryEnabledFeatureCode = TRUE;
+static gboolean bQueryGridLicenseInfo = TRUE;
 int64_t enabledFeatureCode = NV_GRID_LICENSE_FEATURE_TYPE_VAPP;
 
 GType ctk_manage_grid_license_get_type(void)
@@ -419,8 +421,7 @@ static void UpdateConfigFileLinesFromGriddConfig(
                                                      itemIsPresent);
     }
 
-    /* Append any items not updated in the above loop. */    
-
+    /* Append any items not updated in the above loop. */
     for (i = 0; i < ARRAY_LEN(configParamsList); i++) {
 
         if (itemIsPresent[i]) {
@@ -630,7 +631,8 @@ done:
 }
 
 
-static void ctk_manage_grid_license_class_init(CtkManageGridLicenseClass *ctk_object_class)
+static void ctk_manage_grid_license_class_init(CtkManageGridLicenseClass *ctk_object_class,
+                                               gpointer class_data)
 {
     GObjectClass *gobject_class = (GObjectClass *)ctk_object_class;
     gobject_class->finalize = ctk_manage_grid_license_finalize;
@@ -786,8 +788,8 @@ static gboolean update_manage_grid_license_state_info(gpointer user_data)
     gboolean ret = TRUE;
     char licenseStatusMsgTmp[GRID_MESSAGE_MAX_BUFFER_SIZE] = {0};
 
-    int licenseState = NV_GRID_UNLICENSED;
-    int griddFeatureType = ctk_manage_grid_license->feature_type;
+    int licenseState            = NV_GRID_UNLICENSED;
+    int griddFeatureType        = ctk_manage_grid_license->feature_type;
 
     /* Send license state and feature type request */
     if ((!(send_message_to_gridd(ctk_manage_grid_license, LICENSE_STATE_REQUEST,
@@ -835,7 +837,7 @@ static gboolean update_manage_grid_license_state_info(gpointer user_data)
     ctk_manage_grid_license->gridd_feature_type = griddFeatureType;
 
     if (licenseState == NV_GRID_UNLICENSED) {
-        queryEnabledFeatureCode = TRUE;
+        bQueryGridLicenseInfo = TRUE;
         switch (ctk_manage_grid_license->feature_type) {
             case NV_GRID_LICENSE_FEATURE_TYPE_VAPP:
                 ctk_manage_grid_license->licenseStatus = NV_GRID_UNLICENSED_VAPP;
@@ -893,9 +895,14 @@ static gboolean update_manage_grid_license_state_info(gpointer user_data)
                 default:
                     break;
             }
-            if (queryEnabledFeatureCode == TRUE) {
+
+            if (ctk_manage_grid_license->prevLicenseState == NV_GRID_LICENSE_RENEWING && licenseState == NV_GRID_LICENSED) {
+                bQueryGridLicenseInfo = TRUE;
+            }
+
+            if (bQueryGridLicenseInfo == TRUE) {
                 get_licensable_feature_information(ctk_manage_grid_license);
-                queryEnabledFeatureCode = FALSE;
+                bQueryGridLicenseInfo = FALSE;
             }
         }
         else if (licenseState == NV_GRID_LICENSE_REQUESTING) {
@@ -961,7 +968,8 @@ static gboolean update_manage_grid_license_state_info(gpointer user_data)
           snprintf(licenseStatusMsgTmp, sizeof(licenseStatusMsgTmp), "Your system is currently configured for %s.", NVIDIA_VIRTUAL_APPLICATIONS);
           break;
     case NV_GRID_LICENSE_STATUS_ACQUIRED:
-          snprintf(licenseStatusMsgTmp, sizeof(licenseStatusMsgTmp), "Your system is licensed for %s.", ctk_manage_grid_license->productName);
+          snprintf(licenseStatusMsgTmp, sizeof(licenseStatusMsgTmp), "Your system is licensed for %s, expiring at %s.",
+                ctk_manage_grid_license->productName, ctk_manage_grid_license->licenseExpiry);
           break;
     case NV_GRID_LICENSE_STATUS_REQUESTING:
           snprintf(licenseStatusMsgTmp, sizeof(licenseStatusMsgTmp), "Acquiring license for %s.", ctk_manage_grid_license->productName);
@@ -1010,6 +1018,8 @@ static gboolean update_manage_grid_license_state_info(gpointer user_data)
     gtk_label_set_text(GTK_LABEL(ctk_manage_grid_license->label_license_state),
                       licenseStatusMsgTmp);
 
+    ctk_manage_grid_license->prevLicenseState = licenseState;
+
     return ret;
 }
 
@@ -1142,12 +1152,19 @@ static void get_licensable_feature_information(gpointer user_data)
     {
         if (gridLicensableFeatures->gridLicensableFeatures[i].featureEnabled != 0) {
             enabledFeatureCode = gridLicensableFeatures->gridLicensableFeatures[i].featureCode;
-
             // Save product name of enabled feature
             strncpy(ctk_manage_grid_license->productName,
-                gridLicensableFeatures->gridLicensableFeatures[i].productName,
-                sizeof(ctk_manage_grid_license->productName) - 1);
+                    gridLicensableFeatures->gridLicensableFeatures[i].productName,
+                    sizeof(ctk_manage_grid_license->productName) - 1);
             ctk_manage_grid_license->productName[sizeof(ctk_manage_grid_license->productName) - 1] = '\0';
+            //Save the license expiry information
+            snprintf(ctk_manage_grid_license->licenseExpiry, sizeof(ctk_manage_grid_license->licenseExpiry), "%d-%d-%d %d:%d:%d GMT",
+                     gridLicensableFeatures->gridLicensableFeatures[i].licenseExpiry.year,
+                     gridLicensableFeatures->gridLicensableFeatures[i].licenseExpiry.month,
+                     gridLicensableFeatures->gridLicensableFeatures[i].licenseExpiry.day,
+                     gridLicensableFeatures->gridLicensableFeatures[i].licenseExpiry.hour,
+                     gridLicensableFeatures->gridLicensableFeatures[i].licenseExpiry.min,
+                     gridLicensableFeatures->gridLicensableFeatures[i].licenseExpiry.sec);
         }
         else if (gridLicensableFeatures->gridLicensableFeatures[i].featureEnabled == 0) {
             if ((ctk_manage_grid_license->feature_type == gridLicensableFeatures->gridLicensableFeatures[i].featureCode) &&
@@ -1606,12 +1623,10 @@ GtkWidget* ctk_manage_grid_license_new(CtrlTarget *target,
         (strcmp(griddConfig->str[NV_GRIDD_ENABLE_UI], "TRUE") != 0)) {
         return NULL;
     }
-    
 
     /* create the CtkManageGridLicense object */
-
     object = g_object_new(CTK_TYPE_MANAGE_GRID_LICENSE, NULL);
-    
+
     ctk_manage_grid_license = CTK_MANAGE_GRID_LICENSE(object);
     ctk_manage_grid_license->ctk_config = ctk_config;
     ctk_manage_grid_license->license_edition_state = mode;
@@ -1621,7 +1636,6 @@ GtkWidget* ctk_manage_grid_license_new(CtrlTarget *target,
     ctk_manage_grid_license->licenseStatus = NV_GRID_UNLICENSED_VGPU;
 
     /* set container properties for the CtkManageGridLicense widget */
-
     gtk_box_set_spacing(GTK_BOX(ctk_manage_grid_license), 5);
 
     // Set feature type based on user configured parameter or virtualization mode
@@ -1633,7 +1647,6 @@ GtkWidget* ctk_manage_grid_license_new(CtrlTarget *target,
     get_licensable_feature_information(ctk_manage_grid_license);
 
     /* banner */
-
     banner = ctk_banner_image_new(BANNER_ARTWORK_SERVER_LICENSING);
     gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0);
 
@@ -1756,7 +1769,6 @@ GtkWidget* ctk_manage_grid_license_new(CtrlTarget *target,
 
 
     /* Primary License Server Address */
-
     label = gtk_label_new("Primary Server:");
     ctk_manage_grid_license->txt_server_address = gtk_entry_new();
     hbox = gtk_hbox_new(FALSE, 0);
@@ -1993,6 +2005,12 @@ void ctk_manage_grid_license_start_timer(GtkWidget *widget)
     ctk_config_start_timer(ctk_manage_grid_license->ctk_config,
                            (GSourceFunc) update_manage_grid_license_state_info,
                            (gpointer) ctk_manage_grid_license);
+
+    /* Query licensable feature info if switched to 'Manage License' page
+       from any other page to update license expiry information */
+    if (ctk_manage_grid_license->licenseStatus == NV_GRID_LICENSE_STATUS_ACQUIRED) {
+        get_licensable_feature_information(ctk_manage_grid_license);
+    }
 }
 
 void ctk_manage_grid_license_stop_timer(GtkWidget *widget)
diff --git a/src/gtk+-2.x/ctkgridlicense.h b/src/gtk+-2.x/ctkgridlicense.h
index 4f5345d..b8241c9 100644
--- a/src/gtk+-2.x/ctkgridlicense.h
+++ b/src/gtk+-2.x/ctkgridlicense.h
@@ -2,7 +2,7 @@
  * nvidia-settings: A tool for configuring the NVIDIA X driver on Unix
  * and Linux systems.
  *
- * Copyright (C) 2020 NVIDIA Corporation.
+ * Copyright (C) 2021 NVIDIA Corporation.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -43,42 +43,42 @@ G_BEGIN_DECLS
 #define GRID_MESSAGE_MAX_BUFFER_SIZE        512
 #define NVIDIA_VIRTUAL_APPLICATIONS         "NVIDIA Virtual Applications"
 
-typedef struct _CtkManageGridLicense       CtkManageGridLicense;
-typedef struct _CtkManageGridLicenseClass  CtkManageGridLicenseClass;
-
-typedef struct _DbusData DbusData;
+typedef struct _CtkManageGridLicense        CtkManageGridLicense;
+typedef struct _CtkManageGridLicenseClass   CtkManageGridLicenseClass;
+typedef struct _DbusData                    DbusData;
 
 struct _CtkManageGridLicense
 {
-    GtkVBox parent;
-
-    CtkConfig *ctk_config;
-
-    GtkWidget* txt_secondary_server_port;
-    GtkWidget* txt_secondary_server_address;
-    GtkWidget* txt_server_port;
-    GtkWidget* txt_server_address;
-    GtkWidget* label_license_state;
-    GtkWidget* btn_apply;
-    GtkWidget* radio_btn_vapp;
-    GtkWidget* radio_btn_vws;
-    GtkWidget* radio_btn_vcompute;
-    GtkWidget* btn_cancel;
-    GtkWidget* box_server_info;
-
-    DbusData *dbusData;
-    CtrlTarget *target;
-
-    gint license_edition_state;
-    gint feature_type;                                              // Feature type from UI/vGPU license config file.
-    int gridd_feature_type;                                         // Feature type fetched from nvidia-gridd.
-    char productName[GRID_LICENSE_INFO_MAX_LENGTH];                 // vGPU product name fetched from nvml corresponding to the licensed/applied feature
-    char productNamevWS[GRID_LICENSE_INFO_MAX_LENGTH];              // vGPU product name fetched from nvml corresponding to the feature type '2'
-    char productNamevCompute[GRID_LICENSE_INFO_MAX_LENGTH];         // vGPU product name fetched from nvml corresponding to the feature type '4'
-
-    int licenseStatus;                                              // Current license status to be displayed on UI
-    gboolean isvComputeSupported;                                   // Check if 'NVIDIA Virtual Compute Server' feature is supported
-    gboolean isvWSSupported;                                        // Check if 'NVIDIA RTX Virtual Workstation' feature is supported
+    GtkVBox         parent;
+
+    CtkConfig       *ctk_config;
+
+    GtkWidget*      txt_secondary_server_port;
+    GtkWidget*      txt_secondary_server_address;
+    GtkWidget*      txt_server_port;
+    GtkWidget*      txt_server_address;
+    GtkWidget*      label_license_state;
+    GtkWidget*      btn_apply;
+    GtkWidget*      radio_btn_vapp;
+    GtkWidget*      radio_btn_vws;
+    GtkWidget*      radio_btn_vcompute;
+    GtkWidget*      btn_cancel;
+    GtkWidget*      box_server_info;
+
+    DbusData        *dbusData;
+    CtrlTarget      *target;
+
+    gint            license_edition_state;
+    gint            feature_type;                                       // Feature type from UI/vGPU license config file
+    int             gridd_feature_type;                                 // Feature type fetched from nvidia-gridd
+    char            productName[GRID_LICENSE_INFO_MAX_LENGTH];          // vGPU product name fetched from nvml corresponding to the licensed/applied feature
+    char            productNamevWS[GRID_LICENSE_INFO_MAX_LENGTH];       // vGPU product name fetched from nvml corresponding to the feature type '2'
+    char            productNamevCompute[GRID_LICENSE_INFO_MAX_LENGTH];  // vGPU product name fetched from nvml corresponding to the feature type '4'
+    int             licenseStatus;                                      // Current license status to be displayed on UI
+    int             prevLicenseState;                                   // The previous license state
+    gboolean        isvComputeSupported;                                // Check if 'NVIDIA Virtual Compute Server' feature is supported
+    gboolean        isvWSSupported;                                     // Check if 'NVIDIA RTX Virtual Workstation' feature is supported
+    char            licenseExpiry[GRID_LICENSE_INFO_MAX_LENGTH];        // License expiry timestamp
 };
 
 /*
diff --git a/src/gtk+-2.x/ctkhelp.c b/src/gtk+-2.x/ctkhelp.c
index 6a50461..ac4ce09 100644
--- a/src/gtk+-2.x/ctkhelp.c
+++ b/src/gtk+-2.x/ctkhelp.c
@@ -82,7 +82,7 @@ GtkWidget* ctk_help_new(GtkWidget *toggle_button, GtkTextTagTable *tag_table)
     ctk_help->toggle_button = toggle_button;
 
     gtk_window_set_title(GTK_WINDOW(ctk_help),
-                         "NVIDIA X Server Settings Help");
+                         "NVIDIA Settings Help");
 
     gtk_window_set_default_size(GTK_WINDOW(ctk_help), -1, 400);
 
@@ -203,7 +203,7 @@ static GtkTextBuffer *create_default_help(CtkHelp *ctk_help)
     gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
 
     gtk_text_buffer_insert_with_tags_by_name
-        (buffer, &iter, "\nNVIDIA X Server Settings Help", -1,
+        (buffer, &iter, "\nNVIDIA Settings Help", -1,
          CTK_HELP_TITLE_TAG, NULL);
     
     gtk_text_buffer_insert(buffer, &iter, "\n\nThere is no help available "
diff --git a/src/gtk+-2.x/ctkimagesliders.c b/src/gtk+-2.x/ctkimagesliders.c
index e348462..9b62484 100644
--- a/src/gtk+-2.x/ctkimagesliders.c
+++ b/src/gtk+-2.x/ctkimagesliders.c
@@ -37,7 +37,7 @@ static const char *__image_sharpening_help = "The Image Sharpening slider "
 "alters the level of Image Sharpening for this display device.";
 
 
-static void ctk_image_sliders_class_init(CtkImageSliders *ctk_object_class);
+static void ctk_image_sliders_class_init(CtkImageSliders *ctk_object_class, gpointer);
 static void ctk_image_sliders_finalize(GObject *object);
 
 static GtkWidget * add_scale(CtkConfig *ctk_config,
@@ -85,7 +85,8 @@ GType ctk_image_sliders_get_type(void)
 }
 
 static void ctk_image_sliders_class_init(
-    CtkImageSliders *ctk_object_class
+    CtkImageSliders *ctk_object_class,
+    gpointer class_data
 )
 {
     GObjectClass *gobject_class = (GObjectClass *)ctk_object_class;
diff --git a/src/gtk+-2.x/ctkopengl.c b/src/gtk+-2.x/ctkopengl.c
index da27007..1e7fd3c 100644
--- a/src/gtk+-2.x/ctkopengl.c
+++ b/src/gtk+-2.x/ctkopengl.c
@@ -17,7 +17,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses>.
  */
 
-
 #include <gtk/gtk.h>
 #include <NvCtrlAttributes.h>
 #include <stdlib.h>
@@ -115,7 +114,7 @@ static void build_stereo_swap_mode_table(CtkOpenGL *ctk_opengl);
 static gint map_nvctrl_value_to_table(CtkOpenGL *ctk_opengl,
                                       gint val);
 static void
-ctk_opengl_new_class_init(CtkOpenGLClass *ctk_object_class);
+ctk_opengl_new_class_init(CtkOpenGLClass *ctk_object_class, gpointer);
 
 static void ctk_opengl_new_finalize(GObject *object);
 
@@ -231,8 +230,9 @@ GType ctk_opengl_get_type(
 }
 
 
-    static void
-ctk_opengl_new_class_init(CtkOpenGLClass *ctk_object_class)
+static void
+ctk_opengl_new_class_init(CtkOpenGLClass *ctk_object_class,
+                          gpointer class_data)
 {
     GObjectClass *gobject_class = (GObjectClass *)ctk_object_class;
     gobject_class->finalize = ctk_opengl_new_finalize;
diff --git a/src/gtk+-2.x/ctkopengl.h b/src/gtk+-2.x/ctkopengl.h
index bd404fe..e81a4ae 100644
--- a/src/gtk+-2.x/ctkopengl.h
+++ b/src/gtk+-2.x/ctkopengl.h
@@ -20,7 +20,6 @@
 #ifndef __CTK_OPENGL_H__
 #define __CTK_OPENGL_H__
 
-
 #include "ctkevent.h"
 #include "ctkconfig.h"
 
diff --git a/src/gtk+-2.x/ctkpowermizer.c b/src/gtk+-2.x/ctkpowermizer.c
index 7a2d8b5..c0bc8e6 100644
--- a/src/gtk+-2.x/ctkpowermizer.c
+++ b/src/gtk+-2.x/ctkpowermizer.c
@@ -44,12 +44,6 @@ static void powermizer_menu_changed(GtkWidget*, gpointer);
 static void update_powermizer_menu_event(GObject *object,
                                          gpointer arg1,
                                          gpointer user_data);
-static void dp_config_button_toggled(GtkWidget *, gpointer);
-static void dp_set_config_status(CtkPowermizer *);
-static void dp_update_config_status(CtkPowermizer *, gboolean);
-static void dp_configuration_update_received(GObject *, CtrlEvent *, gpointer);
-static void post_dp_configuration_update(CtkPowermizer *);
-static void show_dp_toggle_warning_dlg(CtkPowermizer *ctk_powermizer);
 static void post_set_attribute_offset_value(CtkPowermizer *ctk_powermizer,
                                             gint attribute,
                                             gint val);
@@ -87,13 +81,10 @@ static const char *__gpu_clock_freq_help =
 static const char *__memory_transfer_rate_freq_help =
 "This indicates the current Memory transfer rate.";
 
-static const char *__processor_clock_freq_help =
-"This indicates the current Processor Clock frequency.";
-
 static const char *__performance_levels_table_help =
 "This indicates the Performance Levels available for the GPU.  Each "
 "performance level is indicated by a Performance Level number, along with "
-"the Graphics, Memory and Processor clocks for that level.  The currently active "
+"the Graphics and Memory clocks for that level.  The currently active "
 "performance level is shown in regular text.  All other performance "
 "levels are shown in gray.  Note that multiple performance levels may share "
 "the same range of available clocks.";
@@ -134,13 +125,6 @@ static const char *__powermizer_prefer_consistent_performance_help =
 "'Prefer Consistent Performance' hints to the driver to lock to GPU base clocks, "
 "when possible.  ";
 
-static const char *__dp_configuration_button_help =
-"CUDA - Double Precision lets you enable "
-"increased double-precision calculations in CUDA applications.  Available on "
-"GPUs with the capability for increased double-precision performance."
-"  NOTE: Selecting a GPU reduces performance for non-CUDA applications, "
-"including games.  To increase game performance, disable this checkbox.";
-
 GType ctk_powermizer_get_type(void)
 {
     static GType ctk_powermizer_type = 0;
@@ -175,8 +159,6 @@ typedef struct {
     gboolean perf_level_specified;
     gint nvclock;
     gboolean nvclock_specified;
-    gint processorclock;
-    gboolean processorclock_specified;
     gint nvclockmin;
     gboolean nvclockmin_specified;
     gint nvclockmax;
@@ -189,11 +171,6 @@ typedef struct {
     gint memtransferratemax;
     gint memtransferrateeditable;
     gboolean memtransferratemax_specified;
-    gint processorclockmin;
-    gboolean processorclockmin_specified;
-    gint processorclockmax;
-    gint processorclockeditable;
-    gboolean processorclockmax_specified;
 } perfModeEntry, * perfModeEntryPtr;
 
 
@@ -226,17 +203,6 @@ static void apply_perf_mode_token(char *token, char *value, void *data)
         pEntry->memtransferratemax_specified = TRUE;
     } else if (!strcasecmp("memtransferrateeditable", token)) {
         pEntry->memtransferrateeditable = atoi(value);
-    } else if (!strcasecmp("processorclock", token)) {
-        pEntry->processorclock = atoi(value);
-        pEntry->processorclock_specified = TRUE;
-    } else if (!strcasecmp("processorclockmin", token)) {
-        pEntry->processorclockmin = atoi(value);
-        pEntry->processorclockmax_specified = TRUE;
-    } else if (!strcasecmp("processorclockmax", token)) {
-        pEntry->processorclockmax = atoi(value);
-        pEntry->processorclockmax_specified = TRUE;
-    } else if (!strcasecmp("processorclockeditable", token)) {
-        pEntry->nvclockeditable = atoi(value);
     }
 }
 
@@ -672,9 +638,7 @@ static void update_perf_mode_table(CtkPowermizer *ctk_powermizer,
             if (!ctk_powermizer->hasDecoupledClock &&
                 ((pEntry[index].nvclockmax != pEntry[index].nvclockmin) ||
                  (pEntry[index].memtransferratemax !=
-                  pEntry[index].memtransferratemin) ||
-                 (pEntry[index].processorclockmax !=
-                  pEntry[index].processorclockmin))) {
+                  pEntry[index].memtransferratemin))) {
                 ctk_powermizer->hasDecoupledClock = TRUE;
             }
             /* Set hasEditablePerfLevel flag to decide editable performance
@@ -780,27 +744,6 @@ static void update_perf_mode_table(CtkPowermizer *ctk_powermizer,
             col_idx += 4;
         }
 
-        if (ctk_powermizer->processor_clock) {
-            /* Processor clock */
-            label = gtk_label_new("Processor Clock");
-            gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
-            gtk_table_attach(GTK_TABLE(table), label, col_idx+1, col_idx+3, 0, 1,
-                             GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-            label = gtk_label_new("Min");
-            gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
-            gtk_table_attach(GTK_TABLE(table), label, col_idx+1, col_idx+2, 1, 2,
-                             GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-            label = gtk_label_new("Max");
-            gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
-            gtk_table_attach(GTK_TABLE(table), label, col_idx+2, col_idx+3, 1, 2,
-                             GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-
-            /* Vertical separator */
-            vsep = gtk_vseparator_new();
-            gtk_table_attach(GTK_TABLE(table), vsep, col_idx+3, col_idx+4,
-                             0, row_idx,
-                             GTK_FILL, GTK_FILL | GTK_EXPAND, 0, 0);
-        }
     } else {
 
         table = gtk_table_new(1, 4, FALSE);
@@ -834,13 +777,6 @@ static void update_perf_mode_table(CtkPowermizer *ctk_powermizer,
                              GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
             col_idx++;
         }
-
-        if (ctk_powermizer->processor_clock) {
-            label = gtk_label_new("Processor Clock");
-            gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
-            gtk_table_attach(GTK_TABLE(table), label, col_idx+1, col_idx+2, 0, 1,
-                             GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-        }
     }
 
     /* Parse the perf levels and populate the table */
@@ -905,22 +841,6 @@ static void update_perf_mode_table(CtkPowermizer *ctk_powermizer,
                                  GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
                 col_idx +=4;
             }
-            if (ctk_powermizer->processor_clock) {
-                g_snprintf(tmp_str, 24, "%d MHz", pEntry[i].processorclockmin);
-                label = gtk_label_new(tmp_str);
-                gtk_widget_set_sensitive(label, active);
-                gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
-                gtk_table_attach(GTK_TABLE(table), label, col_idx+1, col_idx+2,
-                                 row_idx, row_idx+1,
-                                 GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-                g_snprintf(tmp_str, 24, "%d MHz", pEntry[i].processorclockmax);
-                label = gtk_label_new(tmp_str);
-                gtk_widget_set_sensitive(label, active);
-                gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
-                gtk_table_attach(GTK_TABLE(table), label, col_idx+2, col_idx+3,
-                                 row_idx, row_idx+1,
-                                 GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-            }
             row_idx++;
         } else if ((pEntry[i].perf_level_specified) &&
                    (pEntry[i].nvclock_specified)) {
@@ -964,15 +884,6 @@ static void update_perf_mode_table(CtkPowermizer *ctk_powermizer,
                                  GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
                 col_idx++;
             }
-            if (ctk_powermizer->processor_clock) {
-                g_snprintf(tmp_str, 24, "%d MHz", pEntry[i].processorclock);
-                label = gtk_label_new(tmp_str);
-                gtk_widget_set_sensitive(label, active);
-                gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
-                gtk_table_attach(GTK_TABLE(table), label, col_idx, col_idx+1,
-                                 row_idx, row_idx+1,
-                                 GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-            }
             row_idx++;
         } else {
             nv_warning_msg("Incomplete Perf Mode (perf=%d, nvclock=%d,"
@@ -1050,12 +961,6 @@ static gboolean update_powermizer_info(gpointer user_data)
             gtk_label_set_text(GTK_LABEL(ctk_powermizer->memory_transfer_rate), s);
             g_free(s);
         }
-
-        if (ctk_powermizer->processor_clock && pEntry.processorclock_specified) {
-            s = g_strdup_printf("%d Mhz", pEntry.processorclock);
-            gtk_label_set_text(GTK_LABEL(ctk_powermizer->processor_clock), s);
-            g_free(s);
-        }
     }
     free(clock_string);
 
@@ -1077,13 +982,15 @@ static gboolean update_powermizer_info(gpointer user_data)
         g_free(s);
     }
 
-    if (ctk_powermizer->pcie_gen_queriable) {
+    if (ctk_powermizer->link_width) {
         /* NV_CTRL_GPU_PCIE_CURRENT_LINK_WIDTH */
         s = get_pcie_link_width_string(ctrl_target,
                                        NV_CTRL_GPU_PCIE_CURRENT_LINK_WIDTH);
         gtk_label_set_text(GTK_LABEL(ctk_powermizer->link_width), s);
         g_free(s);
+    }
 
+    if (ctk_powermizer->link_speed) {
         /* NV_CTRL_GPU_PCIE_MAX_LINK_SPEED */
         s = get_pcie_link_speed_string(ctrl_target,
                                        NV_CTRL_GPU_PCIE_CURRENT_LINK_SPEED);
@@ -1190,21 +1097,19 @@ GtkWidget* ctk_powermizer_new(CtrlTarget *ctrl_target,
     GtkWidget *hbox, *hbox2, *vbox, *vbox2, *hsep, *table;
     GtkWidget *banner, *label;
     CtkDropDownMenu *menu;
-    ReturnStatus ret, ret1;
-    gint attribute;
+    ReturnStatus ret;
     gint nvclock_attribute = 0, mem_transfer_rate_attribute = 0;
     gint val;
     gint row = 0;
     gchar *s = NULL;
     gint tmp;
-    gboolean processor_clock_available = FALSE;
     gboolean power_source_available = FALSE;
     gboolean perf_level_available = FALSE;
     gboolean gpu_clock_available = FALSE;
     gboolean mem_transfer_rate_available = FALSE;
     gboolean adaptive_clock_state_available = FALSE;
-    gboolean cuda_dp_ui = FALSE;
-    gboolean pcie_gen_queriable = FALSE;
+    gboolean pcie_link_width_available = FALSE;
+    gboolean pcie_link_speed_available = FALSE;
     CtrlAttributeValidValues valid_modes;
     char *clock_string = NULL;
     perfModeEntry pEntry;
@@ -1256,23 +1161,27 @@ GtkWidget* ctk_powermizer_new(CtrlTarget *ctrl_target,
         if (pEntry.memtransferrate_specified) {
             mem_transfer_rate_available = TRUE;
         }
-        if (pEntry.processorclock_specified) {
-            processor_clock_available = TRUE;
-        }
     }
     free(clock_string);
 
     /* NV_CTRL_GPU_PCIE_GENERATION */
 
-    ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_PCIE_GENERATION, &tmp);
+    ret = NvCtrlGetAttribute(ctrl_target,
+                             NV_CTRL_GPU_PCIE_CURRENT_LINK_WIDTH,
+                             &tmp);
     if (ret == NvCtrlSuccess) {
-        pcie_gen_queriable = TRUE;
+        pcie_link_width_available = TRUE;
+    }
+
+    ret = NvCtrlGetAttribute(ctrl_target,
+                             NV_CTRL_GPU_PCIE_CURRENT_LINK_SPEED,
+                             &tmp);
+    if (ret == NvCtrlSuccess) {
+        pcie_link_speed_available = TRUE;
     }
 
     /* return early if query to attributes fail */
-    if (!power_source_available && !perf_level_available &&
-        !adaptive_clock_state_available && !gpu_clock_available &&
-        !processor_clock_available && !pcie_gen_queriable) {
+    if (!perf_level_available && !gpu_clock_available) {
         return NULL;
     }
     /* create the CtkPowermizer object */
@@ -1282,7 +1191,6 @@ GtkWidget* ctk_powermizer_new(CtrlTarget *ctrl_target,
     ctk_powermizer = CTK_POWERMIZER(object);
     ctk_powermizer->ctrl_target = ctrl_target;
     ctk_powermizer->ctk_config = ctk_config;
-    ctk_powermizer->pcie_gen_queriable = pcie_gen_queriable;
     ctk_powermizer->hasDecoupledClock = FALSE;
     ctk_powermizer->hasEditablePerfLevel = FALSE;
     ctk_powermizer->editable_performance_levels_unified = FALSE;
@@ -1399,24 +1307,6 @@ GtkWidget* ctk_powermizer_new(CtrlTarget *ctrl_target,
     } else {
         ctk_powermizer->memory_transfer_rate = NULL;
     }
-    /* Processor clock */
-    if (processor_clock_available) {
-        /* spacing */
-        row += 3;
-        ctk_powermizer->processor_clock =
-            add_table_row_with_help_text(table, ctk_config,
-                                         __processor_clock_freq_help,
-                                         row++, //row
-                                         0,  // column
-                                         0.0f,
-                                         0.5,
-                                         "Processor Clock:",
-                                         0.0,
-                                         0.5,
-                                         NULL);
-    } else {
-        ctk_powermizer->processor_clock = NULL;
-    }
     /* Power Source */
     if (power_source_available) {
         /* spacing */
@@ -1435,10 +1325,13 @@ GtkWidget* ctk_powermizer_new(CtrlTarget *ctrl_target,
     } else {
         ctk_powermizer->power_source = NULL;
     }
-    /* Current PCIe Link Width */
-    if (ctk_powermizer->pcie_gen_queriable) {
+    /* PCIe Gen Info block */
+    if (pcie_link_width_available || pcie_link_speed_available) {
         /* spacing */
         row += 3;
+    }
+    /* Current PCIe Link Width */
+    if (pcie_link_width_available) {
         ctk_powermizer->link_width =
             add_table_row_with_help_text(table, ctk_config,
                                          __current_pcie_link_width_help,
@@ -1451,7 +1344,11 @@ GtkWidget* ctk_powermizer_new(CtrlTarget *ctrl_target,
                                          0.5,
                                          NULL);
 
-        /* Current PCIe Link Speed */
+    } else {
+        ctk_powermizer->link_width = NULL;
+    }
+    /* Current PCIe Link Speed */
+    if (pcie_link_speed_available) {
         ctk_powermizer->link_speed =
             add_table_row_with_help_text(table, ctk_config,
                                          __current_pcie_link_speed_help,
@@ -1464,7 +1361,6 @@ GtkWidget* ctk_powermizer_new(CtrlTarget *ctrl_target,
                                          0.5,
                                          NULL);
     } else {
-        ctk_powermizer->link_width = NULL;
         ctk_powermizer->link_speed = NULL;
     }
 
@@ -1622,109 +1518,6 @@ GtkWidget* ctk_powermizer_new(CtrlTarget *ctrl_target,
         update_powermizer_menu_info(ctk_powermizer);
     }
 
-    /*
-     * check if CUDA - Double Precision Boost support available.
-     */
-
-    ret = NvCtrlGetAttribute(ctrl_target,
-                             NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE,
-                             &val);
-    if (ret == NvCtrlSuccess) {
-        attribute = NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE;
-        cuda_dp_ui = TRUE;
-    } else {
-        ret1 = NvCtrlGetAttribute(ctrl_target,
-                                  NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT,
-                                  &val);
-        if (ret1 == NvCtrlSuccess) {
-            attribute = NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT;
-            cuda_dp_ui = TRUE;
-        }
-    }
-
-    if (cuda_dp_ui) {
-        ctk_powermizer->attribute = attribute;
-        ctk_powermizer->dp_toggle_warning_dlg_shown = FALSE;
-
-        /* Query CUDA - Double Precision Boost Status */
-
-        dp_update_config_status(ctk_powermizer, val);
-
-        /* CUDA - Double Precision Boost configuration settings */
-
-        hbox = gtk_hbox_new(FALSE, 0);
-        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
-
-        label = gtk_label_new("CUDA");
-        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
-
-        hsep = gtk_hseparator_new();
-        gtk_box_pack_start(GTK_BOX(hbox), hsep, TRUE, TRUE, 5);
-
-        hbox2 = gtk_hbox_new(FALSE, 0);
-        ctk_powermizer->configuration_button =
-            gtk_check_button_new_with_label("CUDA - Double precision");
-        gtk_box_pack_start(GTK_BOX(hbox2),
-                           ctk_powermizer->configuration_button,
-                           FALSE, FALSE, 0);
-        gtk_container_set_border_width(GTK_CONTAINER(hbox2), 0);
-        gtk_toggle_button_set_active
-            (GTK_TOGGLE_BUTTON(ctk_powermizer->configuration_button),
-             ctk_powermizer->dp_enabled);
-
-        /* Packing */
-
-        table = gtk_table_new(1, 1, FALSE);
-        gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
-        gtk_table_set_row_spacings(GTK_TABLE(table), 3);
-        gtk_table_set_col_spacings(GTK_TABLE(table), 15);
-        gtk_container_set_border_width(GTK_CONTAINER(table), 5);
-
-        gtk_table_attach(GTK_TABLE(table), hbox2, 0, 1, 0, 1,
-                         GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-
-        if (attribute == NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT) {
-            GtkWidget *separator;
-
-            gtk_table_resize(GTK_TABLE(table), 1, 3);
-            /* V-bar */
-            hbox2 = gtk_hbox_new(FALSE, 0);
-            separator = gtk_vseparator_new();
-            gtk_box_pack_start(GTK_BOX(hbox2), separator, FALSE, FALSE, 0);
-            gtk_table_attach(GTK_TABLE(table), hbox2, 1, 2, 0, 1,
-                             GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-
-            ctk_powermizer->status = gtk_label_new("");
-            gtk_misc_set_alignment(GTK_MISC(ctk_powermizer->status), 0.0f, 0.5f);
-            hbox2 = gtk_hbox_new(FALSE, 0);
-            gtk_box_pack_start(GTK_BOX(hbox2),
-                               ctk_powermizer->status, FALSE, FALSE, 0);
-
-            gtk_table_attach(GTK_TABLE(table), hbox2, 2, 3, 0, 1,
-                             GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-        }
-
-        ctk_config_set_tooltip(ctk_config, ctk_powermizer->configuration_button,
-                               __dp_configuration_button_help);
-        g_signal_connect(G_OBJECT(ctk_powermizer->configuration_button),
-                         "clicked",
-                         G_CALLBACK(dp_config_button_toggled),
-                         (gpointer) ctk_powermizer);
-        if (attribute == NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE) {
-            g_signal_connect(G_OBJECT(ctk_event),
-                   CTK_EVENT_NAME(NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE),
-                   G_CALLBACK(dp_configuration_update_received),
-                   (gpointer) ctk_powermizer);
-        } else if (attribute == NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT) {
-            g_signal_connect(G_OBJECT(ctk_event),
-                   CTK_EVENT_NAME(NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT),
-                   G_CALLBACK(dp_configuration_update_received),
-                   (gpointer) ctk_powermizer);
-        }
-    } else {
-        ctk_powermizer->configuration_button = NULL;
-    }
-
     /* Updating the powermizer page */
 
     update_powermizer_info(ctk_powermizer);
@@ -1891,170 +1684,6 @@ static void powermizer_menu_changed(GtkWidget *widget,
 
 
 
-static void show_dp_toggle_warning_dlg(CtkPowermizer *ctk_powermizer)
-{
-    GtkWidget *dlg, *parent;
-
-    /* return early if message dialog already shown */
-    if (ctk_powermizer->dp_toggle_warning_dlg_shown) {
-        return;
-    }
-    ctk_powermizer->dp_toggle_warning_dlg_shown = TRUE;
-    parent = ctk_get_parent_window(GTK_WIDGET(ctk_powermizer));
-
-    dlg = gtk_message_dialog_new (GTK_WINDOW(parent),
-                                  GTK_DIALOG_MODAL,
-                                  GTK_MESSAGE_WARNING,
-                                  GTK_BUTTONS_OK,
-                                  "Changes to the CUDA - Double precision "
-                                  "setting "
-                                  "require a system reboot before "
-                                  "taking effect.");
-    gtk_dialog_run(GTK_DIALOG(dlg));
-    gtk_widget_destroy (dlg);
-
-} /* show_dp_toggle_warning_dlg() */
-
-
-
-/*
- * post_dp_configuration_update() - this function updates status bar string.
- */
-
-static void post_dp_configuration_update(CtkPowermizer *ctk_powermizer)
-{
-    gboolean enabled = ctk_powermizer->dp_enabled;
-
-    const char *conf_string = enabled ? "enabled" : "disabled";
-    char message[128];
-
-    if (ctk_powermizer->attribute == NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT) {
-        snprintf(message, sizeof(message), "CUDA - Double precision will "
-                 "be %s after reboot.",
-                 conf_string);
-    } else {
-        snprintf(message, sizeof(message), "CUDA - Double precision %s.",
-                 conf_string);
-    }
-
-    ctk_config_statusbar_message(ctk_powermizer->ctk_config, "%s", message);
-} /* post_dp_configuration_update() */
-
-
-
-/*
- * dp_set_config_status() - set CUDA - Double Precision Boost configuration
- * button status.
- */
-
-static void dp_set_config_status(CtkPowermizer *ctk_powermizer)
-{
-    GtkWidget *configuration_button = ctk_powermizer->configuration_button;
-
-    g_signal_handlers_block_by_func(G_OBJECT(configuration_button),
-                                    G_CALLBACK(dp_config_button_toggled),
-                                    (gpointer) ctk_powermizer);
-    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(configuration_button),
-                                 ctk_powermizer->dp_enabled);
-
-    g_signal_handlers_unblock_by_func(G_OBJECT(configuration_button),
-                                      G_CALLBACK(dp_config_button_toggled),
-                                      (gpointer) ctk_powermizer);
-} /* dp_set_config_status() */
-
-
-
-/*
- * dp_update_config_status - get current CUDA - Double Precision Boost status.
- */
-
-static void dp_update_config_status(CtkPowermizer *ctk_powermizer, gboolean val)
-{
-    if ((ctk_powermizer->attribute ==
-         NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE &&
-         val == NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE_DISABLED) ||
-        (ctk_powermizer->attribute ==
-         NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT &&
-         val == NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT_DISABLED)) {
-        ctk_powermizer->dp_enabled = FALSE;
-    } else {
-        ctk_powermizer->dp_enabled = TRUE;
-    }
-} /* dp_update_config_status() */
-
-
-
-/*
- * dp_configuration_update_received() - this function is called when the
- * NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE attribute is changed by another
- * NV-CONTROL client.
- */
-
-static void dp_configuration_update_received(GObject *object,
-                                             CtrlEvent *event,
-                                             gpointer user_data)
-{
-    CtkPowermizer *ctk_powermizer = CTK_POWERMIZER(user_data);
-
-    if (event->type != CTRL_EVENT_TYPE_INTEGER_ATTRIBUTE) {
-        return;
-    }
-
-    ctk_powermizer->dp_enabled = event->int_attr.value;
-
-    /* set CUDA - Double Precision Boost configuration buttion status */
-    dp_set_config_status(ctk_powermizer);
-
-    /* Update status bar message */
-    post_dp_configuration_update(ctk_powermizer);
-} /* dp_configuration_update_received() */
-
-
-/*
- * dp_config_button_toggled() - callback function for
- * enable CUDA - Double Precision Boost checkbox.
- */
-
-static void dp_config_button_toggled(GtkWidget *widget,
-                                     gpointer user_data)
-{
-    gboolean enabled;
-    CtkPowermizer *ctk_powermizer = CTK_POWERMIZER(user_data);
-    CtrlTarget *ctrl_target = ctk_powermizer->ctrl_target;
-    ReturnStatus ret;
-
-    enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
-
-    /* show popup dialog when user first time click DP config */
-    if (ctk_powermizer->attribute == NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT) {
-        show_dp_toggle_warning_dlg(ctk_powermizer);
-    }
-
-    /* set the newly specified CUDA - Double Precision Boost value */
-    ret = NvCtrlSetAttribute(ctrl_target,
-                             ctk_powermizer->attribute,
-                             enabled);
-    if (ret != NvCtrlSuccess) {
-        ctk_config_statusbar_message(ctk_powermizer->ctk_config,
-                                     "Failed to set "
-                                     "CUDA - Double precision "
-                                     "configuration!");
-        return;
-    }
-
-    ctk_powermizer->dp_enabled = enabled;
-    dp_set_config_status(ctk_powermizer);
-    if (ctk_powermizer->status) {
-        gtk_label_set_text(GTK_LABEL(ctk_powermizer->status),
-                           "pending reboot");
-    }
-
-    /* Update status bar message */
-    post_dp_configuration_update(ctk_powermizer);
-} /* dp_config_button_toggled() */
-
-
-
 GtkTextBuffer *ctk_powermizer_create_help(GtkTextTagTable *table,
                                           CtkPowermizer *ctk_powermizer)
 {
@@ -2077,11 +1706,7 @@ GtkTextBuffer *ctk_powermizer_create_help(GtkTextTagTable *table,
 
     if (ctk_powermizer->gpu_clock) {
         ctk_help_heading(b, &i, "Clock Frequencies");
-        if (ctk_powermizer->memory_transfer_rate && 
-            ctk_powermizer->processor_clock) {
-            s = "This indicates the GPU's current Graphics Clock, "
-                "Memory transfer rate and Processor Clock frequencies.";
-        } else if (ctk_powermizer->memory_transfer_rate) {
+        if (ctk_powermizer->memory_transfer_rate) {
             s = "This indicates the GPU's current Graphics Clock and "
                 "Memory transfer rate.";
         } else {
@@ -2095,9 +1720,11 @@ GtkTextBuffer *ctk_powermizer_create_help(GtkTextTagTable *table,
         ctk_help_para(b, &i, "%s", __power_source_help);
     }
 
-    if (ctk_powermizer->pcie_gen_queriable) {
+    if (ctk_powermizer->link_width) {
         ctk_help_heading(b, &i, "Current PCIe link width");
         ctk_help_para(b, &i, "%s", __current_pcie_link_width_help);
+    }
+    if (ctk_powermizer->link_speed) {
         ctk_help_heading(b, &i, "Current PCIe link speed");
         ctk_help_para(b, &i, "%s", __current_pcie_link_speed_help);
     }
@@ -2123,11 +1750,6 @@ GtkTextBuffer *ctk_powermizer_create_help(GtkTextTagTable *table,
         ctk_help_para(b, &i, "%s", ctk_powermizer->powermizer_menu_help);
     }
 
-    if (ctk_powermizer->configuration_button) {
-        ctk_help_heading(b, &i, "CUDA - Double precision");
-        ctk_help_para(b, &i, "%s", __dp_configuration_button_help);
-    }
-
     ctk_help_finish(b);
 
     return b;
diff --git a/src/gtk+-2.x/ctkpowermizer.h b/src/gtk+-2.x/ctkpowermizer.h
index f1a586e..10712e0 100644
--- a/src/gtk+-2.x/ctkpowermizer.h
+++ b/src/gtk+-2.x/ctkpowermizer.h
@@ -55,7 +55,6 @@ struct _CtkPowermizer
     GtkWidget *adaptive_clock_status;
     GtkWidget *gpu_clock;
     GtkWidget *memory_transfer_rate;
-    GtkWidget *processor_clock;
     GtkWidget *power_source;
     GtkWidget *performance_level;
     GtkWidget *performance_table_hbox;
@@ -66,24 +65,18 @@ struct _CtkPowermizer
 
     gchar     *powermizer_menu_help;
 
-    GtkWidget *configuration_button;
-    gboolean  dp_enabled;
-    gboolean  dp_toggle_warning_dlg_shown;
     gboolean  hasDecoupledClock;
     gboolean  hasEditablePerfLevel;
     gboolean  editable_performance_levels_unified;
     gint      nvclock_attribute;
     gint      mem_transfer_rate_attribute;
-    gint      attribute;
     gint      powermizer_default_mode;
-    GtkWidget *status;
 
     GtkWidget *editable_perf_level_table;
     gint      num_perf_levels;
 
     GtkWidget *link_width;
     GtkWidget *link_speed;
-    gboolean  pcie_gen_queriable;
 };
 
 struct _CtkPowermizerClass
diff --git a/src/gtk+-2.x/ctkscale.c b/src/gtk+-2.x/ctkscale.c
index f44cf9e..ded9751 100644
--- a/src/gtk+-2.x/ctkscale.c
+++ b/src/gtk+-2.x/ctkscale.c
@@ -29,7 +29,7 @@
 #endif
 
 static void ctk_scale_finalize(GObject *object);
-static void ctk_scale_init(CtkScaleClass *ctk_object_class);
+static void ctk_scale_init(CtkScaleClass *ctk_object_class, gpointer);
 
 enum {
     PROP_0,
@@ -65,7 +65,8 @@ GType ctk_scale_get_type(
 }
 
 
-static void ctk_scale_init(CtkScaleClass *ctk_object_class)
+static void ctk_scale_init(CtkScaleClass *ctk_object_class,
+                           gpointer class_data)
 {
     GObjectClass *gobject_class = (GObjectClass *)ctk_object_class;
     gobject_class->finalize = ctk_scale_finalize;
diff --git a/src/gtk+-2.x/ctkscreen.c b/src/gtk+-2.x/ctkscreen.c
index a452849..d186d5c 100644
--- a/src/gtk+-2.x/ctkscreen.c
+++ b/src/gtk+-2.x/ctkscreen.c
@@ -367,7 +367,7 @@ GtkTextBuffer *ctk_screen_create_help(GtkTextTagTable *table,
     ctk_help_title(b, &i, "X Screen Information Help");
 
     ctk_help_para(b, &i, "This page in the NVIDIA "
-                  "X Server Control Panel describes basic "
+                  "Settings Control Panel describes basic "
                   "information about the X Screen '%s'.",
                   screen_name);
     
diff --git a/src/gtk+-2.x/ctkserver.c b/src/gtk+-2.x/ctkserver.c
index e4c21c1..1de17d4 100644
--- a/src/gtk+-2.x/ctkserver.c
+++ b/src/gtk+-2.x/ctkserver.c
@@ -247,21 +247,27 @@ GtkWidget* ctk_server_new(CtrlTarget *ctrl_target,
     GtkWidget *hseparator;
     GtkWidget *table;
 
-    gchar *os;
-    gchar *arch;
-    gchar *driver_version;
+    CtrlTarget *gpu_target = NULL;
+
+    gchar *os = NULL;
+    gchar *arch = NULL;
+    gchar *driver_version = NULL;
+    gchar *nvml_version = NULL;
 
     gchar *dname = NvCtrlGetDisplayName(ctrl_target);
-    gchar *display_name;
-    gchar *server_version;
-    gchar *vendor_str;
-    gchar *vendor_ver;
-    gchar *nv_control_server_version;
-    gchar *num_screens;
+    gchar *display_name = NULL;
+    gchar *server_version = NULL;
+    gchar *vendor_str = NULL;
+    gchar *vendor_ver = NULL;
+    gchar *nv_control_server_version = NULL;
+    gchar *num_screens = NULL;
 
     ReturnStatus ret;
     int tmp, os_val;
     int xinerama_enabled;
+    int row;
+
+    gpu_target = NvCtrlGetDefaultTargetByType(ctrl_target->system, GPU_TARGET);
 
     /*
      * get the data that we will display below
@@ -276,72 +282,85 @@ GtkWidget* ctk_server_new(CtrlTarget *ctrl_target,
         xinerama_enabled = FALSE;
     }
 
-    /* NV_CTRL_OPERATING_SYSTEM */
+    if (ctrl_target->system->has_nv_control) {
 
-    os_val = NV_CTRL_OPERATING_SYSTEM_LINUX;
-    ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_OPERATING_SYSTEM, &os_val);
-    os = NULL;
-    if (ret == NvCtrlSuccess) {
-        if      (os_val == NV_CTRL_OPERATING_SYSTEM_LINUX) os = "Linux";
-        else if (os_val == NV_CTRL_OPERATING_SYSTEM_FREEBSD) os = "FreeBSD";
-        else if (os_val == NV_CTRL_OPERATING_SYSTEM_SUNOS) os = "SunOS";
-    }
-    if (!os) os = "Unknown";
-
-    /* NV_CTRL_ARCHITECTURE */
-
-    ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_ARCHITECTURE, &tmp);
-    arch = NULL;
-    if (ret == NvCtrlSuccess) {
-        switch (tmp) {
-            case NV_CTRL_ARCHITECTURE_X86: arch = "x86"; break;
-            case NV_CTRL_ARCHITECTURE_X86_64: arch = "x86_64"; break;
-            case NV_CTRL_ARCHITECTURE_IA64: arch = "ia64"; break;
-            case NV_CTRL_ARCHITECTURE_ARM: arch = "ARM"; break;
-            case NV_CTRL_ARCHITECTURE_AARCH64: arch = "AArch64"; break;
-            case NV_CTRL_ARCHITECTURE_PPC64LE: arch = "ppc64le"; break;
+        /* NV_CTRL_OPERATING_SYSTEM */
+
+        os_val = NV_CTRL_OPERATING_SYSTEM_LINUX;
+        ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_OPERATING_SYSTEM, &os_val);
+        os = NULL;
+        if (ret == NvCtrlSuccess) {
+            if      (os_val == NV_CTRL_OPERATING_SYSTEM_LINUX) os = "Linux";
+            else if (os_val == NV_CTRL_OPERATING_SYSTEM_FREEBSD) os = "FreeBSD";
+            else if (os_val == NV_CTRL_OPERATING_SYSTEM_SUNOS) os = "SunOS";
         }
+        if (!os) os = "Unknown";
+
+        /* NV_CTRL_ARCHITECTURE */
+
+        ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_ARCHITECTURE, &tmp);
+        arch = NULL;
+        if (ret == NvCtrlSuccess) {
+            switch (tmp) {
+                case NV_CTRL_ARCHITECTURE_X86: arch = "x86"; break;
+                case NV_CTRL_ARCHITECTURE_X86_64: arch = "x86_64"; break;
+                case NV_CTRL_ARCHITECTURE_IA64: arch = "ia64"; break;
+                case NV_CTRL_ARCHITECTURE_ARM: arch = "ARM"; break;
+                case NV_CTRL_ARCHITECTURE_AARCH64: arch = "AArch64"; break;
+                case NV_CTRL_ARCHITECTURE_PPC64LE: arch = "ppc64le"; break;
+            }
+        }
+        if (!arch) arch = "Unknown";
+        os = g_strdup_printf("%s-%s", os, arch);
     }
-    if (!arch) arch = "Unknown";
-    os = g_strdup_printf("%s-%s", os, arch);
 
     /* NV_CTRL_STRING_NVIDIA_DRIVER_VERSION */
 
     driver_version = get_nvidia_driver_version(ctrl_target);
 
-    /* Display Name */
+    /* NV_CTRL_STRING_NVML_VERSION */
 
-    display_name = nv_standardize_screen_name(dname, -2);
+    NvCtrlGetStringAttribute(gpu_target,
+                             NV_CTRL_STRING_NVML_VERSION,
+                             &nvml_version);
 
-    /* X Server Version */
+    if (ctrl_target->system->has_nv_control) {
 
-    server_version = g_strdup_printf("%d.%d",
-                                     NvCtrlGetProtocolVersion(ctrl_target),
-                                     NvCtrlGetProtocolRevision(ctrl_target));
+        /* Display Name */
 
-    /* Server Vendor String */
+        display_name = nv_standardize_screen_name(dname, -2);
 
-    vendor_str = g_strdup(NvCtrlGetServerVendor(ctrl_target));
+        /* X Server Version */
 
-    /* Server Vendor Version */
+        server_version = g_strdup_printf("%d.%d",
+                                         NvCtrlGetProtocolVersion(ctrl_target),
+                                         NvCtrlGetProtocolRevision(ctrl_target));
 
-    vendor_ver = get_server_vendor_version(ctrl_target);
+        /* Server Vendor String */
 
-    /* NV_CTRL_STRING_NV_CONTROL_VERSION */
+        vendor_str = g_strdup(NvCtrlGetServerVendor(ctrl_target));
 
-    ret = NvCtrlGetStringAttribute(ctrl_target,
-                                   NV_CTRL_STRING_NV_CONTROL_VERSION,
-                                   &nv_control_server_version);
-    if (ret != NvCtrlSuccess) nv_control_server_version = NULL;
+        /* Server Vendor Version */
 
-    /* # Logical X Screens */
+        vendor_ver = get_server_vendor_version(ctrl_target);
+
+        /* NV_CTRL_STRING_NV_CONTROL_VERSION */
+
+        ret = NvCtrlGetStringAttribute(ctrl_target,
+                                       NV_CTRL_STRING_NV_CONTROL_VERSION,
+                                       &nv_control_server_version);
+        if (ret != NvCtrlSuccess) nv_control_server_version = NULL;
+
+        /* # Logical X Screens */
+
+        if (xinerama_enabled) {
+            num_screens = g_strdup_printf("%d (Xinerama)",
+                                          NvCtrlGetScreenCount(ctrl_target));
+        } else {
+            num_screens = g_strdup_printf("%d",
+                                          NvCtrlGetScreenCount(ctrl_target));
+        }
 
-    if (xinerama_enabled) {
-        num_screens = g_strdup_printf("%d (Xinerama)",
-                                      NvCtrlGetScreenCount(ctrl_target));
-    } else {
-        num_screens = g_strdup_printf("%d",
-                                      NvCtrlGetScreenCount(ctrl_target));
     }
 
 
@@ -363,7 +382,7 @@ GtkWidget* ctk_server_new(CtrlTarget *ctrl_target,
     } else if (os_val == NV_CTRL_OPERATING_SYSTEM_SUNOS) {
         banner = ctk_banner_image_new(BANNER_ARTWORK_SOLARIS);
     } else {
-        banner = ctk_banner_image_new(BANNER_ARTWORK_PENGUIN);
+        banner = ctk_banner_image_new(BANNER_ARTWORK_BLANK);
     }
     gtk_box_pack_start(GTK_BOX(ctk_object), banner, FALSE, FALSE, 0);
 
@@ -384,7 +403,7 @@ GtkWidget* ctk_server_new(CtrlTarget *ctrl_target,
     hseparator = gtk_hseparator_new();
     gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5);
 
-    table = gtk_table_new(2, 2, FALSE);
+    table = gtk_table_new(3, 2, FALSE);
     gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
 
     gtk_table_set_row_spacings(GTK_TABLE(table), 3);
@@ -392,47 +411,56 @@ GtkWidget* ctk_server_new(CtrlTarget *ctrl_target,
 
     gtk_container_set_border_width(GTK_CONTAINER(table), 5);
 
-    add_table_row(table, 0,
-                  0, 0.5, "Operating System:",      0, 0.5, os);
-    add_table_row(table, 1,
+    row = 0;
+    if (os) {
+        add_table_row(table, row++,
+                      0, 0.5, "Operating System:",      0, 0.5, os);
+    }
+    add_table_row(table, row++,
                   0, 0.5, "NVIDIA Driver Version:", 0, 0.5, driver_version);
+    if (nvml_version) {
+        add_table_row(table, row++,
+                      0, 0.5, "NVML Version:", 0, 0.5, nvml_version);
+    }
 
     /*
      * This displays basic X Server information, including
      * version number, vendor information and the number of
      * X Screens.
      */
+    if (ctrl_target->system->has_nv_control) {
 
-    hbox = gtk_hbox_new(FALSE, 0);
-    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
-
-    label = gtk_label_new("X Server Information");
-    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
-
-    hseparator = gtk_hseparator_new();
-    gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5);
+        hbox = gtk_hbox_new(FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 
-    table = gtk_table_new(15, 2, FALSE);
-    gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
-    gtk_table_set_row_spacings(GTK_TABLE(table), 3);
-    gtk_table_set_col_spacings(GTK_TABLE(table), 15);
-    gtk_container_set_border_width(GTK_CONTAINER(table), 5);
+        label = gtk_label_new("X Server Information");
+        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
 
-    add_table_row(table, 0,
-                  0, 0.5, "Display Name:",          0, 0.5, display_name);
-    /* separator */
-    add_table_row(table, 4,
-                  0, 0.5, "Server Version Number:", 0, 0.5, server_version);
-    add_table_row(table, 5,
-                  0, 0.5, "Server Vendor String:",  0, 0.5, vendor_str);
-    add_table_row(table, 6,
-                  0, 0.5, "Server Vendor Version:", 0, 0.5, vendor_ver);
-    /* separator */
-    add_table_row(table, 10,
-                  0, 0,   "NV-CONTROL Version:",    0, 0, nv_control_server_version);
-    /* separator */
-    add_table_row(table, 14,
-                  0, 0,   "Screens:",               0, 0, num_screens);
+        hseparator = gtk_hseparator_new();
+        gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5);
+
+        table = gtk_table_new(15, 2, FALSE);
+        gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
+        gtk_table_set_row_spacings(GTK_TABLE(table), 3);
+        gtk_table_set_col_spacings(GTK_TABLE(table), 15);
+        gtk_container_set_border_width(GTK_CONTAINER(table), 5);
+
+        add_table_row(table, 0,
+                      0, 0.5, "Display Name:",          0, 0.5, display_name);
+        /* separator */
+        add_table_row(table, 4,
+                      0, 0.5, "Server Version Number:", 0, 0.5, server_version);
+        add_table_row(table, 5,
+                      0, 0.5, "Server Vendor String:",  0, 0.5, vendor_str);
+        add_table_row(table, 6,
+                      0, 0.5, "Server Vendor Version:", 0, 0.5, vendor_ver);
+        /* separator */
+        add_table_row(table, 10,
+                      0, 0,   "NV-CONTROL Version:",    0, 0, nv_control_server_version);
+        /* separator */
+        add_table_row(table, 14,
+                      0, 0,   "Screens:",               0, 0, num_screens);
+    }
 
 
     /* print special trademark text for FreeBSD */
@@ -472,6 +500,7 @@ GtkWidget* ctk_server_new(CtrlTarget *ctrl_target,
     g_free(display_name);
     g_free(os);
     free(driver_version);
+    free(nvml_version);
 
     g_free(server_version);
     g_free(vendor_str);
@@ -499,7 +528,7 @@ GtkTextBuffer *ctk_server_create_help(GtkTextTagTable *table,
     
     gtk_text_buffer_get_iter_at_offset(b, &i, 0);
 
-    ctk_help_title(b, &i, "X Server Information Help");
+    ctk_help_title(b, &i, "System Information Help");
 
     ctk_help_heading(b, &i, "Operating System");
     ctk_help_para(b, &i, "This is the operating system on which the NVIDIA "
diff --git a/src/gtk+-2.x/ctkthermal.c b/src/gtk+-2.x/ctkthermal.c
index 1ffb805..f32e0e8 100644
--- a/src/gtk+-2.x/ctkthermal.c
+++ b/src/gtk+-2.x/ctkthermal.c
@@ -92,9 +92,8 @@ static const char *__thermal_sensor_reading_help =
 
 static const char * __enable_button_help =
 "The Enable GPU Fan Settings checkbox enables access to control GPU Fan "
-"Speed.  This option is available after enabling coolbits for GPU Fan control."
-"Note that controlling your GPU Fan Speed is not recommended and "
-"is done at your own risk. You should never have to enable this.";
+"Speed.  Manually configuring the GPU fan speed is not normally required; the "
+"speed should adjust automatically based on current temperature and load.";
 
 static const char * __fan_id_help =
 "This shows the GPU Fan's index.";
@@ -102,9 +101,12 @@ static const char * __fan_id_help =
 static const char * __fan_rpm_help =
 "This shows the current GPU Fan Speed in rotations per minute (RPM).";
 
-static const char * __fan_speed_help =
+static const char * __fan_current_speed_help =
 "This shows the current GPU Fan Speed level as a percentage.";
 
+static const char * __fan_target_speed_help =
+"This shows the target GPU Fan Speed level as a percentage.";
+
 static const char * __fan_control_type_help =
 "Fan Type indicates if and how this fan may be controlled.  Possible "
 "types are Variable, Toggle or Restricted.  Variable fans can be "
@@ -164,9 +166,12 @@ static gboolean update_cooler_info(gpointer user_data)
     gchar *tmp_str;
     CtkThermal *ctk_thermal;
     GtkWidget *table, *label, *eventbox;
-    gint ret;
+    gint ret, ret2;
     gint row_idx; /* Where to insert into the cooler info table */
-    
+    gboolean cooler_extra_info = FALSE;
+    int num_cols = 2;
+    int current_speed_attr;
+
     ctk_thermal = CTK_THERMAL(user_data);
 
     /* Since table cell management in GTK lacks, just remove and rebuild
@@ -179,7 +184,17 @@ static gboolean update_cooler_info(gpointer user_data)
 
     /* Generate a new table */
 
-    table = gtk_table_new(1, 5, FALSE);
+    ret = NvCtrlGetAttribute(ctk_thermal->cooler_control[0].ctrl_target,
+                             NV_CTRL_THERMAL_COOLER_CONTROL_TYPE, &cooler_type);
+    ret2 = NvCtrlGetAttribute(ctk_thermal->cooler_control[0].ctrl_target,
+                              NV_CTRL_THERMAL_COOLER_TARGET, &cooler_target);
+    if (ret == NvCtrlSuccess && ret2 == NvCtrlSuccess) {
+        cooler_extra_info = TRUE;
+        ctk_thermal->thermal_cooler_extra_info_supported = cooler_extra_info;
+        num_cols = 5;
+    }
+
+    table = gtk_table_new(1, num_cols, FALSE);
     gtk_table_set_row_spacings(GTK_TABLE(table), 3);
     gtk_table_set_col_spacings(GTK_TABLE(table), 15);
     gtk_container_set_border_width(GTK_CONTAINER(table), 5);
@@ -195,39 +210,51 @@ static gboolean update_cooler_info(gpointer user_data)
     gtk_container_add(GTK_CONTAINER(eventbox), label);
     ctk_config_set_tooltip(ctk_thermal->ctk_config, eventbox, __fan_id_help);
 
-    label = gtk_label_new("Speed (RPM)");
-    gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
     eventbox = gtk_event_box_new();
+    if (cooler_extra_info) {
+        current_speed_attr = NV_CTRL_THERMAL_COOLER_SPEED;
+        label = gtk_label_new("Speed (RPM)");
+        ctk_config_set_tooltip(ctk_thermal->ctk_config, eventbox,
+                               __fan_rpm_help);
+    } else {
+        current_speed_attr = NV_CTRL_THERMAL_COOLER_CURRENT_LEVEL;
+        label = gtk_label_new("Current Speed (%)");
+        ctk_config_set_tooltip(ctk_thermal->ctk_config, eventbox,
+                               __fan_current_speed_help);
+    }
+    gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
     gtk_table_attach(GTK_TABLE(table), eventbox, 1, 2, 0, 1,
                      GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
     gtk_container_add(GTK_CONTAINER(eventbox), label);
-    ctk_config_set_tooltip(ctk_thermal->ctk_config, eventbox, __fan_rpm_help);
 
-    label = gtk_label_new("Speed (%)");
-    gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
-    eventbox = gtk_event_box_new();
-    gtk_table_attach(GTK_TABLE(table), eventbox, 2, 3, 0, 1,
-                     GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-    gtk_container_add(GTK_CONTAINER(eventbox), label);
-    ctk_config_set_tooltip(ctk_thermal->ctk_config, eventbox, __fan_speed_help);
+    if (cooler_extra_info) {
+        label = gtk_label_new("Target Speed (%)");
+        gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
+        eventbox = gtk_event_box_new();
+        gtk_table_attach(GTK_TABLE(table), eventbox, 2, 3, 0, 1,
+                         GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
+        gtk_container_add(GTK_CONTAINER(eventbox), label);
+        ctk_config_set_tooltip(ctk_thermal->ctk_config, eventbox,
+                              __fan_target_speed_help);
 
-    label = gtk_label_new("Control Type");
-    gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
-    eventbox = gtk_event_box_new();
-    gtk_table_attach(GTK_TABLE(table), eventbox, 3, 4, 0, 1,
-                     GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-    gtk_container_add(GTK_CONTAINER(eventbox), label);
-    ctk_config_set_tooltip(ctk_thermal->ctk_config, eventbox,
-                           __fan_control_type_help);
+        label = gtk_label_new("Control Type");
+        gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
+        eventbox = gtk_event_box_new();
+        gtk_table_attach(GTK_TABLE(table), eventbox, 3, 4, 0, 1,
+                         GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
+        gtk_container_add(GTK_CONTAINER(eventbox), label);
+        ctk_config_set_tooltip(ctk_thermal->ctk_config, eventbox,
+                               __fan_control_type_help);
 
-    label = gtk_label_new("Cooling Target");
-    gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
-    eventbox = gtk_event_box_new();
-    gtk_table_attach(GTK_TABLE(table), eventbox, 4, 5, 0, 1,
-                     GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-    gtk_container_add(GTK_CONTAINER(eventbox), label);
-    ctk_config_set_tooltip(ctk_thermal->ctk_config, eventbox,
-                           __fan_cooling_target_help);
+        label = gtk_label_new("Cooling Target");
+        gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
+        eventbox = gtk_event_box_new();
+        gtk_table_attach(GTK_TABLE(table), eventbox, 4, 5, 0, 1,
+                         GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
+        gtk_container_add(GTK_CONTAINER(eventbox), label);
+        ctk_config_set_tooltip(ctk_thermal->ctk_config, eventbox,
+                               __fan_cooling_target_help);
+    }
 
     /* Fill the cooler info */
     for (i = 0; i < ctk_thermal->cooler_count; i++) {
@@ -243,7 +270,7 @@ static gboolean update_cooler_info(gpointer user_data)
         free(tmp_str);
 
         ret = NvCtrlGetAttribute(ctk_thermal->cooler_control[i].ctrl_target,
-                                 NV_CTRL_THERMAL_COOLER_SPEED,
+                                 current_speed_attr,
                                  &speed);
         if (ret == NvCtrlSuccess) {
             tmp_str = g_strdup_printf("%d", speed);
@@ -257,69 +284,79 @@ static gboolean update_cooler_info(gpointer user_data)
                          GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
         free(tmp_str);
 
-        ret = NvCtrlGetAttribute(ctk_thermal->cooler_control[i].ctrl_target,
-                                 NV_CTRL_THERMAL_COOLER_LEVEL,
-                                 &level);
-        if (ret != NvCtrlSuccess) {
-            /* cooler information no longer available */
-            return FALSE;
-        }
-        tmp_str = g_strdup_printf("%d", level);
-        label = gtk_label_new(tmp_str);
-        gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
-        gtk_table_attach(GTK_TABLE(table), label, 2, 3, row_idx, row_idx+1,
-                         GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-        free(tmp_str);
+        if (cooler_extra_info) {
+            ret = NvCtrlGetAttribute(ctk_thermal->cooler_control[i].ctrl_target,
+                                     NV_CTRL_THERMAL_COOLER_LEVEL,
+                                     &level);
+            if (ret != NvCtrlSuccess) {
+                /* cooler information no longer available */
+                return FALSE;
+            }
+            tmp_str = g_strdup_printf("%d", level);
+            label = gtk_label_new(tmp_str);
+            gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
+            gtk_table_attach(GTK_TABLE(table), label, 2, 3, row_idx, row_idx+1,
+                             GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
+            free(tmp_str);
 
-        ret = NvCtrlGetAttribute(ctk_thermal->cooler_control[i].ctrl_target,
-                                 NV_CTRL_THERMAL_COOLER_CONTROL_TYPE,
-                                 &cooler_type);
-        if (ret != NvCtrlSuccess) {
-            /* cooler information no longer available */
-            return FALSE;
-        }
-        if (cooler_type == NV_CTRL_THERMAL_COOLER_CONTROL_TYPE_VARIABLE) {
-            tmp_str = g_strdup_printf("Variable");
-        } else if (cooler_type == NV_CTRL_THERMAL_COOLER_CONTROL_TYPE_TOGGLE) {
-            tmp_str = g_strdup_printf("Toggle");
-        } else if (cooler_type == NV_CTRL_THERMAL_COOLER_CONTROL_TYPE_NONE) {
-            tmp_str = g_strdup_printf("Restricted");
-        }
-        label = gtk_label_new(tmp_str);
-        gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
-        gtk_table_attach(GTK_TABLE(table), label, 3, 4, row_idx, row_idx+1,
-                         GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-        free(tmp_str);
+            ret = NvCtrlGetAttribute(ctk_thermal->cooler_control[i].ctrl_target,
+                                     NV_CTRL_THERMAL_COOLER_CONTROL_TYPE,
+                                     &cooler_type);
+            if (ret != NvCtrlSuccess && ret != NvCtrlNotSupported) {
+                return FALSE;
+            }
 
-        ret = NvCtrlGetAttribute(ctk_thermal->cooler_control[i].ctrl_target,
-                                 NV_CTRL_THERMAL_COOLER_TARGET,
-                                 &cooler_target);
-        if (ret != NvCtrlSuccess) {
-            /* cooler information no longer available */
-            return FALSE;
-        }
-        switch(cooler_target) {
-            case NV_CTRL_THERMAL_COOLER_TARGET_GPU: 
-                tmp_str = g_strdup_printf("GPU");
-                break;
-            case NV_CTRL_THERMAL_COOLER_TARGET_MEMORY:      
-                tmp_str = g_strdup_printf("Memory");
-                break;
-            case NV_CTRL_THERMAL_COOLER_TARGET_POWER_SUPPLY:             
-                tmp_str = g_strdup_printf("Power Supply");
-                break;    
-            case NV_CTRL_THERMAL_COOLER_TARGET_GPU_RELATED:  
-                tmp_str = g_strdup_printf("GPU, Memory, and Power Supply");
-                break;
-            default:
-                break;
+            if (ret == NvCtrlNotSupported) {
+                tmp_str = g_strdup_printf("Unknown");
+            } else if (cooler_type == NV_CTRL_THERMAL_COOLER_CONTROL_TYPE_VARIABLE) {
+                tmp_str = g_strdup_printf("Variable");
+            } else if (cooler_type == NV_CTRL_THERMAL_COOLER_CONTROL_TYPE_TOGGLE) {
+                tmp_str = g_strdup_printf("Toggle");
+            } else if (cooler_type == NV_CTRL_THERMAL_COOLER_CONTROL_TYPE_NONE) {
+                tmp_str = g_strdup_printf("Restricted");
+            }
+            label = gtk_label_new(tmp_str);
+            gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
+            gtk_table_attach(GTK_TABLE(table), label, 3, 4, row_idx, row_idx+1,
+                             GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
+            free(tmp_str);
+
+            ret = NvCtrlGetAttribute(ctk_thermal->cooler_control[i].ctrl_target,
+                                     NV_CTRL_THERMAL_COOLER_TARGET,
+                                     &cooler_target);
+            if (ret != NvCtrlSuccess && ret != NvCtrlNotSupported) {
+                return FALSE;
+            }
+
+            if (ret == NvCtrlNotSupported) {
+                tmp_str = g_strdup_printf("Unknown");
+            } else {
+
+                switch(cooler_target) {
+                    case NV_CTRL_THERMAL_COOLER_TARGET_GPU:
+                        tmp_str = g_strdup_printf("GPU");
+                        break;
+                    case NV_CTRL_THERMAL_COOLER_TARGET_MEMORY:
+                        tmp_str = g_strdup_printf("Memory");
+                        break;
+                    case NV_CTRL_THERMAL_COOLER_TARGET_POWER_SUPPLY:
+                        tmp_str = g_strdup_printf("Power Supply");
+                        break;
+                    case NV_CTRL_THERMAL_COOLER_TARGET_GPU_RELATED:
+                        tmp_str = g_strdup_printf("GPU, Memory, and Power Supply");
+                        break;
+                    default:
+                        break;
+                }
+            }
+            label = gtk_label_new(tmp_str);
+            gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
+            gtk_table_attach(GTK_TABLE(table), label, 4, 5, row_idx, row_idx+1,
+                             GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
+            free(tmp_str);
         }
-        label = gtk_label_new(tmp_str);
-        gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
-        gtk_table_attach(GTK_TABLE(table), label, 4, 5, row_idx, row_idx+1,
-                         GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
-        free(tmp_str);
     }
+
     gtk_widget_show_all(table);
      
     /* X driver takes fraction of second to refresh newly set value */
@@ -1080,7 +1117,7 @@ GtkWidget* ctk_thermal_new(CtrlTarget *ctrl_target,
     CtrlTarget *sensor_target;
     CtrlAttributeValidValues cooler_range;
     CtrlAttributeValidValues sensor_range;
-    gint trigger, core, ambient;
+    gint slowdown, core, ambient;
     gint upper;
     gchar *s;
     gint i, j;
@@ -1095,7 +1132,6 @@ GtkWidget* ctk_thermal_new(CtrlTarget *ctrl_target,
     Bool cooler_control_enabled;
     int cur_cooler_idx = 0;
     int cur_sensor_idx = 0;
-    int slowdown;
     Bool thermal_sensor_target_type_supported = FALSE;
 
     /* make sure we have a handle */
@@ -1128,21 +1164,21 @@ GtkWidget* ctk_thermal_new(CtrlTarget *ctrl_target,
             /* thermal information unavailable */
             return NULL;
         }
+    }
 
-        ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_MAX_CORE_THRESHOLD,
-                                 &upper);
-        if (ret != NvCtrlSuccess) {
-            /* thermal information unavailable */
-            return NULL;
-        }
+    ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_SLOWDOWN_THRESHOLD,
+                             &slowdown);
+    if (ret != NvCtrlSuccess) {
+        slowdown = 0;
+    }
 
-        ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_CORE_THRESHOLD,
-                                 &trigger);
-        if (ret != NvCtrlSuccess) {
-            /* thermal information unavailable */
-            return NULL;
-        }
+    ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_SHUTDOWN_THRESHOLD,
+                             &upper);
+    if (ret != NvCtrlSuccess) {
+        upper = slowdown;
     }
+
+
     /* Query the list of sensors attached to this GPU */
 
     ret = NvCtrlGetBinaryAttribute(ctrl_target, 0,
@@ -1228,13 +1264,6 @@ GtkWidget* ctk_thermal_new(CtrlTarget *ctrl_target,
         hsep = gtk_hseparator_new();
         gtk_box_pack_start(GTK_BOX(hbox1), hsep, TRUE, TRUE, 0);
         
-        ret = NvCtrlGetAttribute(ctk_thermal->ctrl_target,
-                                 NV_CTRL_GPU_SLOWDOWN_THRESHOLD,
-                                 &slowdown);
-        if (ret != NvCtrlSuccess) {
-            slowdown = 0;
-        }
-
         if (ctk_thermal->sensor_count > 0) {
             ctk_thermal->sensor_info = (SensorInfoPtr)
                 nvalloc(ctk_thermal->sensor_count * sizeof(SensorInfoRec));
@@ -1295,34 +1324,37 @@ GtkWidget* ctk_thermal_new(CtrlTarget *ctrl_target,
 
         vbox1 = gtk_vbox_new(FALSE, 0);
         hbox1 = gtk_hbox_new(FALSE, 0);
-        frame = gtk_frame_new("Slowdown Threshold");
         gtk_box_pack_start(GTK_BOX(vbox), hbox1, FALSE, FALSE, 0);
         gtk_box_pack_start(GTK_BOX(hbox1), vbox1, FALSE, FALSE, 5);
-        gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 0);
 
-        hbox2 = gtk_hbox_new(FALSE, 0);
-        gtk_container_set_border_width(GTK_CONTAINER(hbox2), FRAME_PADDING);
-        gtk_container_add(GTK_CONTAINER(frame), hbox2);
+        if (slowdown > 0) {
+            frame = gtk_frame_new("Slowdown Threshold");
+            gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 0);
 
-        label = gtk_label_new("Degrees: ");
-        gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
+            hbox2 = gtk_hbox_new(FALSE, 0);
+            gtk_container_set_border_width(GTK_CONTAINER(hbox2), FRAME_PADDING);
+            gtk_container_add(GTK_CONTAINER(frame), hbox2);
 
-        eventbox = gtk_event_box_new();
-        gtk_box_pack_start(GTK_BOX(hbox2), eventbox, FALSE, FALSE, 0);
+            label = gtk_label_new("Degrees: ");
+            gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
 
-        entry = gtk_entry_new();
-        gtk_entry_set_max_length(GTK_ENTRY(entry), 5);
-        gtk_container_add(GTK_CONTAINER(eventbox), entry);
-        gtk_widget_set_sensitive(entry, FALSE);
-        gtk_entry_set_width_chars(GTK_ENTRY(entry), 5);
+            eventbox = gtk_event_box_new();
+            gtk_box_pack_start(GTK_BOX(hbox2), eventbox, FALSE, FALSE, 0);
 
-        s = g_strdup_printf(" %d ", trigger);
-        gtk_entry_set_text(GTK_ENTRY(entry), s);
-        g_free(s);
-        ctk_config_set_tooltip(ctk_config, eventbox, __core_threshold_help);
+            entry = gtk_entry_new();
+            gtk_entry_set_max_length(GTK_ENTRY(entry), 5);
+            gtk_container_add(GTK_CONTAINER(eventbox), entry);
+            gtk_widget_set_sensitive(entry, FALSE);
+            gtk_entry_set_width_chars(GTK_ENTRY(entry), 5);
 
-        label = gtk_label_new(" C");
-        gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
+            s = g_strdup_printf(" %d ", slowdown);
+            gtk_entry_set_text(GTK_ENTRY(entry), s);
+            g_free(s);
+            ctk_config_set_tooltip(ctk_config, eventbox, __core_threshold_help);
+
+            label = gtk_label_new(" C");
+            gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
+        }
 
         /* GPU Core Temperature */
 
@@ -1377,7 +1409,7 @@ GtkWidget* ctk_thermal_new(CtrlTarget *ctrl_target,
         }
 
         /* GPU Core Temperature Gauge */
-        
+
         ctk_thermal->core_gauge = pack_gauge(hbox1, 25, upper,
                                              ctk_config, __temp_level_help);
     }
@@ -1680,26 +1712,32 @@ next_help:
     ctk_help_heading(b, &i, "ID");
     ctk_help_para(b, &i, "%s", __fan_id_help);
 
-    ctk_help_heading(b, &i, "Speed (RPM)");
-    ctk_help_para(b, &i,"%s", __fan_rpm_help);
+    if (ctk_thermal->thermal_cooler_extra_info_supported) {
+        ctk_help_heading(b, &i, "Speed (RPM)");
+        ctk_help_para(b, &i,"%s", __fan_rpm_help);
 
-    ctk_help_heading(b, &i, "Speed (%%)");
-    ctk_help_para(b, &i, "%s", __fan_speed_help);
+        ctk_help_heading(b, &i, "Target Speed (%%)");
+        ctk_help_para(b, &i, "%s", __fan_target_speed_help);
 
-    ctk_help_heading(b, &i, "Type");
-    ctk_help_para(b, &i, "%s", __fan_control_type_help);
+        ctk_help_heading(b, &i, "Type");
+        ctk_help_para(b, &i, "%s", __fan_control_type_help);
 
-    ctk_help_heading(b, &i, "Cooling Target");
-    ctk_help_para(b, &i, "%s", __fan_cooling_target_help);
+        ctk_help_heading(b, &i, "Cooling Target");
+        ctk_help_para(b, &i, "%s", __fan_cooling_target_help);
 
-    ctk_help_heading(b, &i, "Enable GPU Fan Settings");
-    ctk_help_para(b, &i, "%s", __enable_button_help);
+    } else {
+        ctk_help_heading(b, &i, "Current Speed (%%)");
+        ctk_help_para(b, &i,"%s", __fan_current_speed_help);
+    }
 
     if ( ctk_thermal->show_fan_control_frame ) {
         ctk_help_heading(b, &i, "Enable GPU Fan Settings");
+        ctk_help_para(b, &i, "%s", __enable_button_help);
+
+        ctk_help_heading(b, &i, "Apply");
         ctk_help_para(b, &i, "%s", __apply_button_help);
 
-        ctk_help_heading(b, &i, "Enable GPU Fan Settings");
+        ctk_help_heading(b, &i, "Reset Hardware Defaults");
         ctk_help_para(b, &i, "%s", __reset_button_help);
     }
 done:
diff --git a/src/gtk+-2.x/ctkthermal.h b/src/gtk+-2.x/ctkthermal.h
index c3406e8..4c24c88 100644
--- a/src/gtk+-2.x/ctkthermal.h
+++ b/src/gtk+-2.x/ctkthermal.h
@@ -104,6 +104,7 @@ struct _CtkThermal
     int cooler_count;
     int sensor_count;
     gboolean thermal_sensor_target_type_supported;
+    gboolean thermal_cooler_extra_info_supported;
 };
 
 struct _CtkThermalClass
diff --git a/src/gtk+-2.x/ctkui.c b/src/gtk+-2.x/ctkui.c
index 170ab8c..e8a3d9e 100644
--- a/src/gtk+-2.x/ctkui.c
+++ b/src/gtk+-2.x/ctkui.c
@@ -49,20 +49,6 @@ void ctk_main(ParsedAttribute *p,
     gtk_window_set_default_icon_list(list);
     window = ctk_window_new(p, conf, system);
 
-    if (!system->has_nv_control) {
-        GtkWidget *dlg;
-        dlg = gtk_message_dialog_new (NULL,
-                                      GTK_DIALOG_MODAL,
-                                      GTK_MESSAGE_WARNING,
-                                      GTK_BUTTONS_OK,
-                                      "You do not appear to be using the NVIDIA "
-                                      "X driver.  Please edit your X configuration "
-                                      "file (just run `nvidia-xconfig` "
-                                      "as root), and restart the X server.");
-        gtk_dialog_run(GTK_DIALOG(dlg));
-        gtk_widget_destroy (dlg);
-    }
-
     ctk_window_set_active_page(CTK_WINDOW(window), page);
 
     gtk_main();
diff --git a/src/gtk+-2.x/ctkutils.c b/src/gtk+-2.x/ctkutils.c
index aa6b412..ad65e5f 100644
--- a/src/gtk+-2.x/ctkutils.c
+++ b/src/gtk+-2.x/ctkutils.c
@@ -67,6 +67,20 @@ gboolean ctk_widget_get_visible(GtkWidget *w)
 #endif
 }
 
+void ctk_widget_set_visible(GtkWidget *w, gboolean visible)
+{
+#ifdef CTK_GTK3
+    /* GTK function added in 2.18 */
+    gtk_widget_set_visible(w, visible);
+#else
+    if (visible) {
+        gtk_widget_show(w);
+    } else {
+        gtk_widget_hide(w);
+    }
+#endif
+}
+
 gboolean ctk_widget_is_drawable(GtkWidget *w)
 {
 #ifdef CTK_GTK3
@@ -323,6 +337,15 @@ void ctk_cell_renderer_set_alignment(GtkCellRenderer *renderer,
 #endif
 }
 
+void ctk_widget_set_halign_left(GtkWidget *w)
+{
+#ifdef CTK_GTK3
+    gtk_widget_set_halign(w, GTK_ALIGN_START);
+#else
+    g_object_set(w, "xalign", 0.0, NULL);
+#endif
+}
+
 GtkWidget *ctk_file_chooser_dialog_new(const gchar *title,
                                        GtkWindow *parent,
                                        GtkFileChooserAction action)
@@ -457,9 +480,7 @@ gchar *get_pcie_link_speed_string(CtrlTarget *ctrl_target, int attribute)
     gchar *s = NULL;
 
     ret = NvCtrlGetAttribute(ctrl_target, attribute, &tmp);
-    if (ret != NvCtrlSuccess) {
-        s = g_strdup_printf("Unknown");
-    } else {
+    if (ret == NvCtrlSuccess) {
         s = g_strdup_printf("%.1f GT/s", tmp/1000.0);
     }
 
@@ -551,11 +572,11 @@ gchar* create_display_name_list_string(CtrlTarget *ctrl_target,
     ret = NvCtrlGetBinaryAttribute(ctrl_target, 0,
                                    attr,
                                    (unsigned char **)(&pData), &len);
-    if (ret != NvCtrlSuccess) {
-        goto done;
+    if (ret == NvCtrlNotSupported) {
+        return NULL;
     }
 
-    for (i = 0; i < pData[0]; i++) {
+    for (i = 0; ret == NvCtrlSuccess && i < pData[0]; i++) {
         CtrlTarget *ctrl_other;
         int display_id = pData[i+1];
         gchar *logName = NULL;
@@ -601,8 +622,6 @@ gchar* create_display_name_list_string(CtrlTarget *ctrl_target,
         }
     }
 
- done:
-
     if (!displays) {
         displays = g_strdup("None");
     }
@@ -772,6 +791,10 @@ void ctk_empty_container(GtkWidget *container)
     GList *list;
     GList *node;
 
+    if (!container) {
+        return;
+    }
+
     list = gtk_container_get_children(GTK_CONTAINER(container));
     node = list;
     while (node) {
diff --git a/src/gtk+-2.x/ctkutils.h b/src/gtk+-2.x/ctkutils.h
index 92fa64b..6b7c3be 100644
--- a/src/gtk+-2.x/ctkutils.h
+++ b/src/gtk+-2.x/ctkutils.h
@@ -90,6 +90,7 @@ G_BEGIN_DECLS
 gboolean ctk_widget_is_sensitive(GtkWidget *w);
 gboolean ctk_widget_get_sensitive(GtkWidget *w);
 gboolean ctk_widget_get_visible(GtkWidget *w);
+void ctk_widget_set_visible(GtkWidget *w, gboolean visible);
 gboolean ctk_widget_is_drawable(GtkWidget *w);
 GdkWindow *ctk_widget_get_window(GtkWidget *w);
 void ctk_widget_get_allocation(GtkWidget *w, GtkAllocation *a);
@@ -110,6 +111,7 @@ void ctk_scrolled_window_add(GtkScrolledWindow *sw, GtkWidget *child);
 GtkWidget *ctk_statusbar_get_message_area(GtkStatusbar *statusbar);
 void ctk_cell_renderer_set_alignment(GtkCellRenderer *widget,
                                      gfloat x, gfloat y);
+void ctk_widget_set_halign_left(GtkWidget *w);
 
 GtkWidget *ctk_file_chooser_dialog_new(const gchar *title, GtkWindow *parent,
                                        GtkFileChooserAction action);
diff --git a/src/gtk+-2.x/ctkvdpau.c b/src/gtk+-2.x/ctkvdpau.c
index 3d07408..ff93ef8 100644
--- a/src/gtk+-2.x/ctkvdpau.c
+++ b/src/gtk+-2.x/ctkvdpau.c
@@ -228,6 +228,11 @@ static int queryBaseInfo(CtkVDPAU *ctk_vdpau, VdpDevice device,
         {"VP9",             VDP_DECODER_PROFILE_VP9_PROFILE_1, 0x100},
         {"VP9",             VDP_DECODER_PROFILE_VP9_PROFILE_2, 0x100},
         {"VP9",             VDP_DECODER_PROFILE_VP9_PROFILE_3, 0x100},
+#endif
+#ifdef VDP_DECODER_PROFILE_AV1_MAIN
+        {"AV1",           VDP_DECODER_PROFILE_AV1_MAIN, 0x200},
+        {"AV1",           VDP_DECODER_PROFILE_AV1_HIGH, 0x200},
+        {"AV1",   VDP_DECODER_PROFILE_AV1_PROFESSIONAL, 0x200},
 #endif
     };
     const size_t decoder_list_count = sizeof(decoder_list)/sizeof(Desc);
@@ -576,6 +581,11 @@ static int queryDecoderCaps(CtkVDPAU *ctk_vdpau, VdpDevice device,
         {"VP9 PROFILE 1",      VDP_DECODER_PROFILE_VP9_PROFILE_1,      0},
         {"VP9 PROFILE 2",      VDP_DECODER_PROFILE_VP9_PROFILE_2,      0},
         {"VP9 PROFILE 3",      VDP_DECODER_PROFILE_VP9_PROFILE_3,      0},
+#endif
+#ifdef VDP_DECODER_PROFILE_AV1_MAIN
+        {"AV1 MAIN",           VDP_DECODER_PROFILE_AV1_MAIN,   0},
+        {"AV1 HIGH",           VDP_DECODER_PROFILE_AV1_HIGH,   0},
+        {"AV1 PROFESSIONAL",   VDP_DECODER_PROFILE_AV1_PROFESSIONAL, 0},
 #endif
     };
     const size_t decoder_profile_count = sizeof(decoder_profiles)/sizeof(Desc);
diff --git a/src/gtk+-2.x/ctkwindow.c b/src/gtk+-2.x/ctkwindow.c
index 629984c..525796e 100644
--- a/src/gtk+-2.x/ctkwindow.c
+++ b/src/gtk+-2.x/ctkwindow.c
@@ -103,7 +103,7 @@ typedef void (*config_file_attributes_func_t)(GtkWidget *, ParsedAttribute *);
 typedef void (*select_widget_func_t)(GtkWidget *);
 typedef void (*unselect_widget_func_t)(GtkWidget *);
 
-static void ctk_window_class_init(CtkWindowClass *);
+static void ctk_window_class_init(CtkWindowClass *, gpointer);
 
 #ifdef CTK_GTK3
 static void ctk_window_real_destroy(GtkWidget *);
@@ -175,7 +175,8 @@ GType ctk_window_get_type(void)
  * class structure
  */
 
-static void ctk_window_class_init(CtkWindowClass *ctk_window_class)
+static void ctk_window_class_init(CtkWindowClass *ctk_window_class,
+                                  gpointer class_data)
 {
 #ifdef CTK_GTK3
     GtkWidgetClass *widget_class;
@@ -499,8 +500,9 @@ GtkWidget *ctk_window_new(ParsedAttribute *p, ConfigProperties *conf,
     GtkTextBuffer *help;
 
     CtrlTargetNode *node;
-    CtrlTarget *server_target = NULL;
-    CtrlTarget *ctrl_target = NULL;
+    CtrlTarget *default_x_target = NULL;
+    CtrlTarget *default_gpu_target = NULL;
+    CtrlTarget *ctrl_target;
 
     CtkEvent *ctk_event;
     CtkConfig *ctk_config;
@@ -655,53 +657,56 @@ GtkWidget *ctk_window_new(ParsedAttribute *p, ConfigProperties *conf,
     ctk_window->page_viewer = hbox;
     ctk_window->page = NULL;
 
+    /*
+     * Create generic and specific default system targets. X Screen target
+     * will only exist if the X Server is available. In that case, the generic
+     * default target will be the default gpu target instead.
+     */
+    default_x_target = NvCtrlGetDefaultTargetByType(system, X_SCREEN_TARGET);
+    default_gpu_target = NvCtrlGetDefaultTargetByType(system, GPU_TARGET);
 
-    /* X Server info & configuration */
+    ctrl_target = default_x_target;
+    if (!ctrl_target) {
+        ctrl_target = default_gpu_target;
+    }
 
-    if (system->targets[X_SCREEN_TARGET]) {
+    /* System Information */
 
-        GtkWidget *child;
+    if (ctrl_target) {
 
-        /*
-         * XXX For now, just use the first handle in the list
-         *     to communicate with the X server for these two
-         *     pages and the app profile page below.
-         */
+        GtkWidget *child;
 
-        server_target = NvCtrlGetDefaultTargetByType(system, X_SCREEN_TARGET);
-        if (server_target) {
+        child = ctk_server_new(ctrl_target, ctk_config);
+        add_page(child,
+                 ctk_server_create_help(tag_table, CTK_SERVER(child)),
+                 ctk_window, NULL, NULL, "System Information",
+                 NULL, NULL, NULL);
+    }
 
-            /* X Server information */
+    /* X Server Display Configuration */
 
-            child = ctk_server_new(server_target, ctk_config);
-            add_page(child,
-                     ctk_server_create_help(tag_table,
-                                            CTK_SERVER(child)),
-                     ctk_window, NULL, NULL, "X Server Information",
-                     NULL, NULL, NULL);
+    if (default_x_target) {
 
-            /* X Server Display Configuration */
+        GtkWidget *child;
 
-            child = ctk_display_config_new(server_target, ctk_config);
-            if (child) {
-                ctk_window->display_config_widget = child;
-                add_page(child,
-                         ctk_display_config_create_help(tag_table,
-                                                        CTK_DISPLAY_CONFIG(child)),
-                         ctk_window, NULL, NULL,
-                         "X Server Display Configuration",
-                         NULL, ctk_display_config_selected,
-                         ctk_display_config_unselected);
-            }
+        child = ctk_display_config_new(default_x_target, ctk_config);
+        if (child) {
+            ctk_window->display_config_widget = child;
+            add_page(child,
+                     ctk_display_config_create_help(tag_table,
+                                                    CTK_DISPLAY_CONFIG(child)),
+                     ctk_window, NULL, NULL,
+                     "X Server Display Configuration",
+                     NULL, ctk_display_config_selected,
+                     ctk_display_config_unselected);
 
         }
     }
 
     /* Platform Power Mode */
 
-    ctrl_target = NvCtrlGetDefaultTargetByType(system, GPU_TARGET);
-    ctk_event = CTK_EVENT(ctk_event_new(ctrl_target));
-    widget = ctk_powermode_new(ctrl_target, ctk_config, ctk_event);
+    ctk_event = CTK_EVENT(ctk_event_new(default_gpu_target));
+    widget = ctk_powermode_new(default_gpu_target, ctk_config, ctk_event);
     if (widget) {
         help = ctk_powermode_create_help(tag_table, CTK_POWERMODE(widget));
         add_page(widget, help, ctk_window, NULL, NULL,
@@ -963,7 +968,7 @@ GtkWidget *ctk_window_new(ParsedAttribute *p, ConfigProperties *conf,
     }
 
     /* app profile configuration */
-    widget = ctk_app_profile_new(server_target, ctk_config);
+    widget = ctk_app_profile_new(ctrl_target, ctk_config);
     if (widget) {
         add_page(widget, ctk_app_profile_create_help(CTK_APP_PROFILE(widget), tag_table),
                  ctk_window, NULL, NULL, "Application Profiles",
@@ -1018,7 +1023,7 @@ GtkWidget *ctk_window_new(ParsedAttribute *p, ConfigProperties *conf,
 
     /* set the window title */
     
-    gtk_window_set_title(GTK_WINDOW(object), "NVIDIA X Server Settings");
+    gtk_window_set_title(GTK_WINDOW(object), "NVIDIA Settings");
     
     gtk_widget_show_all(GTK_WIDGET(object));
 
diff --git a/src/jansson/error.c b/src/jansson/error.c
index f5da6b9..310af88 100644
--- a/src/jansson/error.c
+++ b/src/jansson/error.c
@@ -25,7 +25,7 @@ void jsonp_error_set_source(json_error_t *error, const char *source)
 
     length = strlen(source);
     if(length < JSON_ERROR_SOURCE_LENGTH)
-        strncpy(error->source, source, length + 1);
+        strcpy(error->source, source);
     else {
         size_t extra = length - JSON_ERROR_SOURCE_LENGTH + 4;
         memcpy(error->source, "...", 3);
diff --git a/src/libXNVCtrl/NVCtrl.h b/src/libXNVCtrl/NVCtrl.h
index d98a722..df888cf 100644
--- a/src/libXNVCtrl/NVCtrl.h
+++ b/src/libXNVCtrl/NVCtrl.h
@@ -24,7 +24,6 @@
 #ifndef __NVCTRL_H
 #define __NVCTRL_H
 
-
 #include <stdint.h>
 
 /**************************************************************************/
@@ -50,6 +49,7 @@
 #define NV_CTRL_TARGET_TYPE_THERMAL_SENSOR 6
 #define NV_CTRL_TARGET_TYPE_3D_VISION_PRO_TRANSCEIVER 7
 #define NV_CTRL_TARGET_TYPE_DISPLAY        8
+#define NV_CTRL_TARGET_TYPE_MUX            9
 
 /**************************************************************************/
 
@@ -2846,8 +2846,7 @@
 #define NV_CTRL_SHOW_MULTIGPU_VISUAL_INDICATOR_TRUE               1
 
 /*
- * NV_CTRL_GPU_CURRENT_PROCESSOR_CLOCK_FREQS - Returns GPU's processor
- * clock freqs.
+ * NV_CTRL_GPU_CURRENT_PROCESSOR_CLOCK_FREQS - not supported
  */
 #define NV_CTRL_GPU_CURRENT_PROCESSOR_CLOCK_FREQS               359 /* RW-G */
 
@@ -3162,30 +3161,14 @@
 #define NV_CTRL_USED_DEDICATED_GPU_MEMORY                       394 /* R--G */
 
 /*
- * NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE
- * Some GPUs can make a tradeoff between double-precision floating-point
- * performance and clock speed.  Enabling double-precision floating point
- * performance may benefit CUDA or OpenGL applications that require high
- * bandwidth double-precision performance.  Disabling this feature may benefit
- * graphics applications that require higher clock speeds.
- *
- * This attribute is only available when toggling double precision boost
- * can be done immediately (without need for a rebooot).
+ * NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE - not supported
  */
 #define NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE            395 /* RW-G */
 #define NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE_DISABLED     0
 #define NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE_ENABLED      1
 
 /*
- * NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT
- * Some GPUs can make a tradeoff between double-precision floating-point
- * performance and clock speed.  Enabling double-precision floating point
- * performance may benefit CUDA or OpenGL applications that require high
- * bandwidth double-precision performance.  Disabling this feature may benefit
- * graphics applications that require higher clock speeds.
- *
- * This attribute is only available when toggling double precision boost
- * requires a reboot.
+ * NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT - not supported
  */
 
 #define NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT              396 /* RW-G */
@@ -3629,9 +3612,32 @@
 #define NV_CTRL_PLATFORM_CURRENT_POWER_MODE_QUIET                 2
 #define NV_CTRL_PLATFORM_CURRENT_POWER_MODE_LIMITED_POWER_POLICY  3
 
-#define NV_CTRL_LAST_ATTRIBUTE NV_CTRL_PLATFORM_CURRENT_POWER_MODE
+/*
+ * NV_CTRL_MUX_AUTO_SWITCH - Controls whether the mux specified will
+ * automatically switch when possible.
+ */
 
+#define NV_CTRL_MUX_AUTO_SWITCH                                 436
+#define NV_CTRL_MUX_AUTO_SWITCH_DISABLED                          0
+#define NV_CTRL_MUX_AUTO_SWITCH_ENABLED                           1
 
+/*
+ *  NV_CTRL_MUX_IS_INTERNAL - Returns whether the specified mux is an internal
+ *  mux.
+ */
+#define NV_CTRL_MUX_IS_INTERNAL                                 437
+
+/*
+ * NV_CTRL_RESIZABLE_BAR - Returns whether the system has resizable BAR support.
+ */
+#define NV_CTRL_RESIZABLE_BAR                                   438
+
+/*
+ * NV_CTRL_DYNAMIC_BOOST_SUPPORT - Returns whether the system has Dynamic Boost support.
+ */
+#define NV_CTRL_DYNAMIC_BOOST_SUPPORT                           439
+
+#define NV_CTRL_LAST_ATTRIBUTE NV_CTRL_DYNAMIC_BOOST_SUPPORT
 
 /**************************************************************************/
 
@@ -3997,9 +4003,8 @@
  * NV Clock and Memory Clock values.
  * Not all tokens will be reported on all GPUs, and additional tokens
  * may be added in the future.
- * For backwards compatibility we still provide nvclock, memclock, and
- * processorclock those are the same as nvclockmin, memclockmin and
- * processorclockmin.
+ * For backwards compatibility we still provide nvclock and memclock;
+ * those are the same as nvclockmin and memclockmin.
  *
  * Note: These clock values take into account the offset
  * set by clients through NV_CTRL_GPU_NVCLOCK_OFFSET and
@@ -4029,14 +4034,6 @@
  *                                 for the perf level
  *   "memtransferrateeditable" integer - if the memory transfer rate is editable
  *                                       for the perf level
- *   "processorclock"         integer - the processor clocks (in MHz)
- *                                       for the perf level
- *   "processorclockmin"      integer - the processor clocks min (in MHz)
- *                                       for the perf level
- *   "processorclockmax"      integer - the processor clocks max (in MHz)
- *                                      for the perf level
- *   "processorclockeditable" integer - if the processor clock domain is editable
- *                                      for the perf level
  *
  * Example:
  *
@@ -4102,11 +4099,8 @@
 
 /*
  * NV_CTRL_STRING_GPU_CURRENT_CLOCK_FREQS - returns a string with the
- * associated NV Clock, Memory Clock and Processor Clock values.
+ * associated NV Clock and Memory Clock values.
  *
- * Current valid tokens are "nvclock", "nvclockmin", "nvclockmax",
- * "memclock", "memclockmin", "memclockmax", "processorclock",
- * "processorclockmin" and "processorclockmax".
  * Not all tokens will be reported on all GPUs, and additional tokens
  * may be added in the future.
  *
@@ -4137,14 +4131,6 @@
  *                                 for the perf level
  *   "memtransferrateeditable" integer - if the memory transfer rate is editable
  *                                       for the perf level
- *   "processorclock"     integer  - the processor clocks (in MHz)
- *                                 for the perf level
- *   "processorclockmin"  integer  - the processor clocks min (in MHz)
- *                                 for the perf level
- *   "processorclockmax"  integer  - the processor clocks max (in MHz)
- *                                 for the perf level
- *   "processorclockeditable" integer - if the processor clock domain is editable
- *                                      for the perf level
  *
  * Example:
  *
@@ -4156,7 +4142,7 @@
  * using an NV_CTRL_TARGET_TYPE_GPU or NV_CTRL_TARGET_TYPE_X_SCREEN target.
  */
 
-#define NV_CTRL_STRING_GPU_CURRENT_CLOCK_FREQS                 34  /* RW-G */
+#define NV_CTRL_STRING_GPU_CURRENT_CLOCK_FREQS                 34  /* R--G */
 
 /*
  * NV_CTRL_STRING_3D_VISION_PRO_TRANSCEIVER_HARDWARE_REVISION - Returns the
@@ -4352,9 +4338,15 @@
  */
 #define NV_CTRL_STRING_DISPLAY_NAME_CONNECTOR                       56 /* R-D- */
 
+/*
+ * NV_CTRL_STRING_MUX_STATE - Controls whether the mux specified is configured to
+ * use the integrated or discrete GPU.
+ */
+#define NV_CTRL_STRING_MUX_STATE                                    57 /* RW--- */
+
 
 #define NV_CTRL_STRING_LAST_ATTRIBUTE \
-    NV_CTRL_STRING_DISPLAY_NAME_CONNECTOR
+    NV_CTRL_STRING_MUX_STATE
 
 
 /**************************************************************************/
@@ -4749,8 +4741,24 @@
 
 #define NV_CTRL_BINARY_DATA_DISPLAYS_ON_GPU                  20  /* R--G */
 
+/*
+ * NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS - Returns volatile or aggregate
+ * detailed ECC error information of bit width specified.
+ *
+ * The format of the returned data is:
+ *
+ *     4 * n   int number of ECC errors where n is equal to
+               NVML_MEMORY_LOCATION_COUNT.
+ *
+ * This attribute is queried through NVML.
+ */
+#define NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS_SINGLE_BIT             21  /* R--G */
+#define NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS_DOUBLE_BIT             22  /* R--G */
+#define NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS_SINGLE_BIT_AGGREGATE   23  /* R--G */
+#define NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS_DOUBLE_BIT_AGGREGATE   24  /* R--G */
+
 #define NV_CTRL_BINARY_DATA_LAST_ATTRIBUTE \
-    NV_CTRL_BINARY_DATA_DISPLAYS_ON_GPU
+    NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS_DOUBLE_BIT_AGGREGATE
 
 
 /**************************************************************************/
@@ -5016,6 +5024,7 @@
  * ATTRIBUTE_TYPE_COOLER    - Attribute is valid for Cooler target types.
  * ATTRIBUTE_TYPE_3D_VISION_PRO_TRANSCEIVER - Attribute is valid for 3D Vision
  *                                            Pro Transceiver target types.
+ * ATTRIBUTE_TYPE_MUX       - Attribute is valid for Multiplexer target types.
  *
  * See 'Key to Integer Attribute "Permissions"' at the top of this
  * file for a description of what these permission bits mean.
@@ -5044,6 +5053,7 @@
 #define ATTRIBUTE_TYPE_COOLER     0x200
 #define ATTRIBUTE_TYPE_THERMAL_SENSOR 0x400
 #define ATTRIBUTE_TYPE_3D_VISION_PRO_TRANSCEIVER 0x800
+#define ATTRIBUTE_TYPE_MUX        0x1000
 
 #define ATTRIBUTE_TYPE_ALL_TARGETS                \
     ((ATTRIBUTE_TYPE_DISPLAY)                   | \
@@ -5054,7 +5064,9 @@
      (ATTRIBUTE_TYPE_GVI)                       | \
      (ATTRIBUTE_TYPE_COOLER)                    | \
      (ATTRIBUTE_TYPE_THERMAL_SENSOR)            | \
-     (ATTRIBUTE_TYPE_3D_VISION_PRO_TRANSCEIVER))
+     (ATTRIBUTE_TYPE_3D_VISION_PRO_TRANSCEIVER) | \
+     (ATTRIBUTE_TYPE_MUX))
+
 
 typedef struct _NVCTRLAttributeValidValues {
     int type;
diff --git a/src/libXNVCtrl/utils.mk b/src/libXNVCtrl/utils.mk
index af0e3d7..2b15880 100644
--- a/src/libXNVCtrl/utils.mk
+++ b/src/libXNVCtrl/utils.mk
@@ -33,10 +33,11 @@
 ##############################################################################
 
 CC                    ?= gcc
+CXX                   ?= g++
 LD                    ?= ld
 AR                    ?= ar
-# only set these warnings and optimizations if CFLAGS is unset
-CFLAGS                ?= -Wall -O2
+# only set these warnings if CFLAGS is unset
+CFLAGS                ?= -Wall
 # always set these -f CFLAGS
 CFLAGS                += -fno-strict-aliasing -fno-omit-frame-pointer -Wformat=2
 CC_ONLY_CFLAGS        ?=
@@ -58,16 +59,31 @@ CFLAGS                += -Wno-unused-parameter
 HOST_CC_ONLY_CFLAGS   += -Wno-format-zero-length
 HOST_CFLAGS           += -Wno-unused-parameter
 
+# Treat warnings as errors, if requested
+WARNINGS_AS_ERRORS    ?=
+CFLAGS                += $(if $(WARNINGS_AS_ERRORS),-Werror)
+
+DEBUG                 ?=
+DEVELOP               ?=
+
 ifeq ($(DEBUG),1)
   STRIP_CMD           ?= true
   DO_STRIP            ?=
   CFLAGS              += -O0 -g
   CFLAGS              += -DDEBUG=1
 else
-  STRIP_CMD           ?= strip
-  DO_STRIP            ?= 1
+  CFLAGS              += -O2
+endif
+
+ifeq ($(DEVELOP),1)
+  STRIP_CMD           ?= true
+  DO_STRIP            ?=
+  CFLAGS              += -DDEVELOP=1
 endif
 
+STRIP_CMD             ?= strip
+DO_STRIP              ?= 1
+
 INSTALL               ?= install
 INSTALL_BIN_ARGS      ?= -m 755
 INSTALL_LIB_ARGS      ?= -m 644
@@ -170,6 +186,8 @@ NV_QUIET_COMMAND_REMOVED_TARGET_PREFIX ?=
 
 NV_GENERATED_HEADERS ?=
 
+PCIACCESS_CFLAGS      ?=
+PCIACCESS_LDFLAGS     ?=
 
 ##############################################################################
 # This makefile uses the $(eval) builtin function, which was added in
@@ -185,6 +203,21 @@ ifneq ($(_eval_available),T)
 endif
 
 
+##############################################################################
+# Test passing $(1) to $(CC).  If $(CC) succeeds, then echo $(1).
+#
+# Because this uses $(shell), it is best to use this to assign simply expanded
+# variables (e.g., ":=").
+#
+# Example usage:
+#  CONDITIONAL_CFLAGS := $(call TEST_CC_ARG, -ffoo)
+##############################################################################
+
+TEST_CC_ARG = \
+ $(shell $(CC) -c -x c /dev/null $(1) -o /dev/null > /dev/null 2>&1 && \
+   $(ECHO) $(1))
+
+
 ##############################################################################
 # define variables used when installing the open source utilities from
 # the source tarball
@@ -276,7 +309,7 @@ host_target = $(patsubst HOST,HOST_,$(patsubst TARGET,,$(1)))
 
 ifeq ($(NV_AUTO_DEPEND),1)
   AUTO_DEP_SUFFIX = -MMD -MF $$(@:.o=.d.to_be_processed) -MP -MT $$@ && \
-    $$(SED) -e "1,3s@ $$< @ @" < $$(@:.o=.d.to_be_processed) > $$(@:.o=.d)
+    $$(SED) -e "1,3s| $$< | |" < $$(@:.o=.d.to_be_processed) > $$(@:.o=.d)
 else
   AUTO_DEP_SUFFIX =
 endif
@@ -349,6 +382,7 @@ BUILD_OBJECT_LIST_WITH_DIR = \
 BUILD_OBJECT_LIST = \
   $(call BUILD_OBJECT_LIST_WITH_DIR,$(1),$(OUTPUTDIR))
 
+$(call BUILD_OBJECT_LIST,nvpci-utils.c): CFLAGS += $(PCIACCESS_CFLAGS)
 
 ##############################################################################
 # function to generate a list of dependency files from their
@@ -486,8 +520,9 @@ endif
 define GENERATE_NVIDSTRING
   # g_nvid_string.c depends on all objects except g_nvid_string.o, and version.mk
   $(NVIDSTRING): $$(filter-out $$(call BUILD_OBJECT_LIST,$$(NVIDSTRING)), $(3)) $$(VERSION_MK)
-	@$$(ECHO) "const char $(1)[] = \"nvidia id: NVIDIA $$(strip $(2)) for $$(TARGET_ARCH)  $$(NVIDIA_VERSION)  $$(NVIDSTRING_BUILD_TYPE_STRING)  (`$$(WHOAMI)`@`$$(HOSTNAME)`)  `$$(DATE)`\";" > $$@
-	@$$(ECHO) "const char *const p$$(strip $(1)) = $(1) + 11;" >> $$@;
+	$(at_if_quiet)$$(MKDIR) $$(dir $$@)
+	$(at_if_quiet)$$(ECHO) "const char $(1)[] = \"nvidia id: NVIDIA $$(strip $(2)) for $$(TARGET_ARCH)  $$(NVIDIA_VERSION)  $$(NVIDSTRING_BUILD_TYPE_STRING)  (`$$(WHOAMI)`@`$$(HOSTNAME)`)  `$$(DATE)`\";" > $$@
+	$(at_if_quiet)$$(ECHO) "const char *const p$$(strip $(1)) = $(1) + 11;" >> $$@;
 endef
 
 
@@ -510,6 +545,7 @@ endef
 
 define READ_ONLY_OBJECT_FROM_FILE_RULE
   $$(OUTPUTDIR)/$$(notdir $(1)).o: $(1)
+	$(at_if_quiet)$$(MKDIR) $$(OUTPUTDIR)
 	$(at_if_quiet)cd $$(dir $(1)); \
 	$$(call quiet_cmd_no_at,LD) -r -z noexecstack --format=binary \
 	    $$(notdir $(1)) -o $$(OUTPUTDIR_ABSOLUTE)/$$(notdir $$@)
diff --git a/src/libXNVCtrl/version.mk b/src/libXNVCtrl/version.mk
index 634141a..05c6021 100644
--- a/src/libXNVCtrl/version.mk
+++ b/src/libXNVCtrl/version.mk
@@ -1,4 +1,4 @@
-NVIDIA_VERSION = 460.91.03
+NVIDIA_VERSION = 510.60.02
 
 # This file.
 VERSION_MK_FILE := $(lastword $(MAKEFILE_LIST))
diff --git a/src/libXNVCtrlAttributes/NvCtrlAttributes.c b/src/libXNVCtrlAttributes/NvCtrlAttributes.c
index 0d4aea0..661f77c 100644
--- a/src/libXNVCtrlAttributes/NvCtrlAttributes.c
+++ b/src/libXNVCtrlAttributes/NvCtrlAttributes.c
@@ -100,6 +100,14 @@ const CtrlTargetTypeInfo targetTypeInfoTable[] = {
       CTRL_TARGET_PERM_BIT(DISPLAY_TARGET),                          /* permission_bit */
       NV_FALSE,                                                      /* uses_display_devices */
       1, 27 },                                                       /* required major,minor protocol rev */
+
+    [MUX_TARGET] =
+    { "Mux Device",                                                  /* name */
+      "mux",                                                         /* parsed_name */
+      NV_CTRL_TARGET_TYPE_MUX,                                       /* nvctrl */
+      CTRL_TARGET_PERM_BIT(MUX_TARGET),                              /* permission_bit */
+      NV_FALSE,                                                      /* uses_display_devices */
+      1, 28 },                                                       /* required major,minor protocol rev */
 };
 
 const int targetTypeInfoTableLen = ARRAY_LEN(targetTypeInfoTable);
@@ -121,6 +129,7 @@ Bool NvCtrlIsTargetTypeValid(CtrlTargetType target_type)
         case THERMAL_SENSOR_TARGET:
         case NVIDIA_3D_VISION_PRO_TRANSCEIVER_TARGET:
         case DISPLAY_TARGET:
+        case MUX_TARGET:
             return TRUE;
         default:
             return FALSE;
@@ -587,6 +596,7 @@ ReturnStatus NvCtrlQueryTargetCount(const CtrlTarget *ctrl_target,
                                     int *val)
 {
     const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
+    ReturnStatus ret = NvCtrlMissingExtension;
 
     if (h == NULL) {
         return NvCtrlBadHandle;
@@ -597,9 +607,9 @@ ReturnStatus NvCtrlQueryTargetCount(const CtrlTarget *ctrl_target,
         case THERMAL_SENSOR_TARGET:
         case COOLER_TARGET:
             {
-                ReturnStatus ret = NvCtrlNvmlQueryTargetCount(ctrl_target,
-                                                              target_type,
-                                                              val);
+                ret = NvCtrlNvmlQueryTargetCount(ctrl_target,
+                                                 target_type,
+                                                 val);
                 if ((ret != NvCtrlMissingExtension) &&
                     (ret != NvCtrlBadHandle) &&
                     (ret != NvCtrlNotSupported)) {
@@ -611,6 +621,14 @@ ReturnStatus NvCtrlQueryTargetCount(const CtrlTarget *ctrl_target,
         case X_SCREEN_TARGET:
         case FRAMELOCK_TARGET:
         case NVIDIA_3D_VISION_PRO_TRANSCEIVER_TARGET:
+        case MUX_TARGET:
+            if (!h->nv) {
+                /*
+                 * If there is no connection to the X Driver, return the
+                 * non-success value from the NVML query, if available.
+                 */
+                return ret;
+            }
             return NvCtrlNvControlQueryTargetCount(h, target_type, val);
         default:
             return NvCtrlBadHandle;
@@ -664,6 +682,7 @@ ReturnStatus NvCtrlGetAttributePerms(const CtrlTarget *ctrl_target,
                                      CtrlAttributePerms *perms)
 {
     const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
+    ReturnStatus ret = NvCtrlError;
 
     if (h == NULL) {
         return NvCtrlBadHandle;
@@ -678,6 +697,12 @@ ReturnStatus NvCtrlGetAttributePerms(const CtrlTarget *ctrl_target,
         case CTRL_ATTRIBUTE_TYPE_STRING:
         case CTRL_ATTRIBUTE_TYPE_BINARY_DATA:
         case CTRL_ATTRIBUTE_TYPE_STRING_OPERATION:
+
+            ret = NvCtrlNvmlGetAttributePerms(h, attr_type, attr, perms);
+
+            if (ret == NvCtrlSuccess || h->dpy == NULL) {
+                return ret;
+            }
             return NvCtrlNvControlGetAttributePerms(h, attr_type, attr, perms);
 
         case CTRL_ATTRIBUTE_TYPE_COLOR:
@@ -750,18 +775,17 @@ ReturnStatus NvCtrlGetDisplayAttribute64(const CtrlTarget *ctrl_target,
     if (((attr >= 0) && (attr <= NV_CTRL_LAST_ATTRIBUTE)) ||
         ((attr >= NV_CTRL_ATTR_NV_BASE) &&
          (attr <= NV_CTRL_ATTR_NV_LAST_ATTRIBUTE))) {
+        ReturnStatus ret = NvCtrlMissingExtension;
 
         switch (h->target_type) {
             case GPU_TARGET:
             case THERMAL_SENSOR_TARGET:
             case COOLER_TARGET:
                 {
-                    ReturnStatus ret = NvCtrlNvmlGetAttribute(ctrl_target,
-                                                              attr,
-                                                              val);
-                    if ((ret != NvCtrlMissingExtension) &&
-                        (ret != NvCtrlBadHandle) &&
-                        (ret != NvCtrlNotSupported)) {
+                    ret = NvCtrlNvmlGetAttribute(ctrl_target,
+                                                 attr,
+                                                 val);
+                    if (ret == NvCtrlSuccess) {
                         return ret;
                     }
                 }
@@ -770,7 +794,14 @@ ReturnStatus NvCtrlGetDisplayAttribute64(const CtrlTarget *ctrl_target,
             case X_SCREEN_TARGET:
             case FRAMELOCK_TARGET:
             case NVIDIA_3D_VISION_PRO_TRANSCEIVER_TARGET:
-                if (!h->nv) return NvCtrlMissingExtension;
+            case MUX_TARGET:
+                if (!h->nv) {
+                    /*
+                     * If there is no connection to the X Driver, return the
+                     * non-success value from the NVML query, if available.
+                     */
+                    return ret;
+                }
                 return NvCtrlNvControlGetAttribute(h, display_mask, attr, val);
             default:
                 return NvCtrlBadHandle;
@@ -804,6 +835,7 @@ ReturnStatus NvCtrlSetDisplayAttribute(CtrlTarget *ctrl_target,
                                        int attr, int val)
 {
     NvCtrlAttributePrivateHandle *h = getPrivateHandle(ctrl_target);
+    ReturnStatus ret = NvCtrlMissingExtension;
 
     if (h == NULL) {
         return NvCtrlBadHandle;
@@ -815,7 +847,6 @@ ReturnStatus NvCtrlSetDisplayAttribute(CtrlTarget *ctrl_target,
             case THERMAL_SENSOR_TARGET:
             case COOLER_TARGET:
                 {
-                    ReturnStatus ret;
                     ret = NvCtrlNvmlSetAttribute(ctrl_target,
                                                  attr,
                                                  display_mask,
@@ -831,8 +862,13 @@ ReturnStatus NvCtrlSetDisplayAttribute(CtrlTarget *ctrl_target,
             case X_SCREEN_TARGET:
             case FRAMELOCK_TARGET:
             case NVIDIA_3D_VISION_PRO_TRANSCEIVER_TARGET:
+            case MUX_TARGET:
                 if (!h->nv) {
-                    return NvCtrlMissingExtension;
+                    /*
+                     * If there is no connection to the X Driver, return the
+                     * non-success value from the NVML query, if available.
+                     */
+                    return ret;
                 }
                 return NvCtrlNvControlSetAttribute(h, display_mask, attr, val);
             default:
@@ -879,6 +915,7 @@ NvCtrlGetValidDisplayAttributeValues(const CtrlTarget *ctrl_target,
                                      CtrlAttributeValidValues *val)
 {
     const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
+    ReturnStatus ret = NvCtrlMissingExtension;
 
     if (h == NULL) {
         return NvCtrlBadHandle;
@@ -890,13 +927,10 @@ NvCtrlGetValidDisplayAttributeValues(const CtrlTarget *ctrl_target,
             case THERMAL_SENSOR_TARGET:
             case COOLER_TARGET:
                 {
-                    ReturnStatus ret;
                     ret = NvCtrlNvmlGetValidAttributeValues(ctrl_target,
                                                             attr,
                                                             val);
-                    if ((ret != NvCtrlMissingExtension) &&
-                        (ret != NvCtrlBadHandle) &&
-                        (ret != NvCtrlNotSupported)) {
+                    if (ret == NvCtrlSuccess) {
                         return ret;
                     }
                 }
@@ -905,8 +939,13 @@ NvCtrlGetValidDisplayAttributeValues(const CtrlTarget *ctrl_target,
             case X_SCREEN_TARGET:
             case FRAMELOCK_TARGET:
             case NVIDIA_3D_VISION_PRO_TRANSCEIVER_TARGET:
+            case MUX_TARGET:
                 if (!h->nv) {
-                    return NvCtrlMissingExtension;
+                    /*
+                     * If there is no connection to the X Driver, return the
+                     * non-success value from the NVML query, if available.
+                     */
+                    return ret;
                 }
                 return NvCtrlNvControlGetValidAttributeValues(h, display_mask,
                                                               attr, val);
@@ -952,6 +991,7 @@ NvCtrlGetValidStringDisplayAttributeValues(const CtrlTarget *ctrl_target,
                                            CtrlAttributeValidValues *val)
 {
     const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
+    ReturnStatus ret = NvCtrlMissingExtension;
 
     if (h == NULL) {
         return NvCtrlBadHandle;
@@ -963,13 +1003,10 @@ NvCtrlGetValidStringDisplayAttributeValues(const CtrlTarget *ctrl_target,
             case THERMAL_SENSOR_TARGET:
             case COOLER_TARGET:
                 {
-                    ReturnStatus ret;
                     ret = NvCtrlNvmlGetValidStringAttributeValues(ctrl_target,
                                                                   attr,
                                                                   val);
-                    if ((ret != NvCtrlMissingExtension) &&
-                        (ret != NvCtrlBadHandle) &&
-                        (ret != NvCtrlNotSupported)) {
+                    if (ret == NvCtrlSuccess) {
                         return ret;
                     }
                 }
@@ -978,8 +1015,13 @@ NvCtrlGetValidStringDisplayAttributeValues(const CtrlTarget *ctrl_target,
             case X_SCREEN_TARGET:
             case FRAMELOCK_TARGET:
             case NVIDIA_3D_VISION_PRO_TRANSCEIVER_TARGET:
+            case MUX_TARGET:
                 if (!h->nv) {
-                    return NvCtrlMissingExtension;
+                    /*
+                     * If there is no connection to the X Driver, return the
+                     * non-success value from the NVML query, if available.
+                     */
+                    return ret;
                 }
                 return NvCtrlNvControlGetValidStringDisplayAttributeValues(
                            h, display_mask, attr, val);
@@ -1061,6 +1103,7 @@ ReturnStatus NvCtrlGetStringDisplayAttribute(const CtrlTarget *ctrl_target,
         case X_SCREEN_TARGET:
         case FRAMELOCK_TARGET:
         case NVIDIA_3D_VISION_PRO_TRANSCEIVER_TARGET:
+        case MUX_TARGET:
             if ((attr >= 0) && (attr <= NV_CTRL_STRING_LAST_ATTRIBUTE)) {
                 if (!h->nv) return NvCtrlMissingExtension;
                 return NvCtrlNvControlGetStringAttribute(h, display_mask, attr, ptr);
@@ -1141,6 +1184,7 @@ ReturnStatus NvCtrlSetStringDisplayAttribute(CtrlTarget *ctrl_target,
             case X_SCREEN_TARGET:
             case FRAMELOCK_TARGET:
             case NVIDIA_3D_VISION_PRO_TRANSCEIVER_TARGET:
+            case MUX_TARGET:
                 if (!h->nv) return NvCtrlMissingExtension;
                 return NvCtrlNvControlSetStringAttribute(h, display_mask, attr,
                                                          ptr);
@@ -1158,6 +1202,7 @@ ReturnStatus NvCtrlGetBinaryAttribute(const CtrlTarget *ctrl_target,
                                       unsigned char **data, int *len)
 {
     const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
+    ReturnStatus ret = NvCtrlMissingExtension;
 
     if (h == NULL) {
         return NvCtrlBadHandle;
@@ -1168,10 +1213,10 @@ ReturnStatus NvCtrlGetBinaryAttribute(const CtrlTarget *ctrl_target,
         case THERMAL_SENSOR_TARGET:
         case COOLER_TARGET:
             {
-                ReturnStatus ret = NvCtrlNvmlGetBinaryAttribute(ctrl_target,
-                                                                attr,
-                                                                data,
-                                                                len);
+                ret = NvCtrlNvmlGetBinaryAttribute(ctrl_target,
+                                                   attr,
+                                                   data,
+                                                   len);
                 if ((ret != NvCtrlMissingExtension) &&
                     (ret != NvCtrlBadHandle) &&
                     (ret != NvCtrlNotSupported)) {
@@ -1183,6 +1228,13 @@ ReturnStatus NvCtrlGetBinaryAttribute(const CtrlTarget *ctrl_target,
         case X_SCREEN_TARGET:
         case FRAMELOCK_TARGET:
         case NVIDIA_3D_VISION_PRO_TRANSCEIVER_TARGET:
+            if (!h->nv) {
+                /*
+                 * If there is no connection to the X Driver, return the
+                 * non-success value from the NVML query, if available.
+                 */
+                return ret;
+            }
             return NvCtrlNvControlGetBinaryAttribute(h, display_mask, attr, data, len);
         default:
             return NvCtrlBadHandle;
@@ -1621,6 +1673,11 @@ NvCtrlEventHandle *NvCtrlGetEventHandle(const CtrlTarget *ctrl_target)
         return NULL;
     }
 
+    if (!h->dpy && !h->nv && h->nvml) {
+        /* We are running with NVML lib only. Events not yet supported.*/
+        return NULL;
+    }
+
     /* Look for the event handle */
     evt_h = NULL;
     for (evt_hnode = __event_handles;
diff --git a/src/libXNVCtrlAttributes/NvCtrlAttributes.h b/src/libXNVCtrlAttributes/NvCtrlAttributes.h
index 4d5e46d..20b0dde 100644
--- a/src/libXNVCtrlAttributes/NvCtrlAttributes.h
+++ b/src/libXNVCtrlAttributes/NvCtrlAttributes.h
@@ -44,6 +44,7 @@ typedef enum {
     THERMAL_SENSOR_TARGET,
     NVIDIA_3D_VISION_PRO_TRANSCEIVER_TARGET,
     DISPLAY_TARGET,
+    MUX_TARGET,
 
     MAX_TARGET_TYPES,
     INVALID_TARGET = -1
@@ -138,6 +139,7 @@ struct _CtrlSystem {
     char *display;  /* string for XOpenDisplay */
     Display *dpy;   /* X display connection */
     Bool has_nv_control;
+    Bool has_nvml;
 
     CtrlTargetNode *targets[MAX_TARGET_TYPES]; /* Shadows targetTypeTable */
     CtrlTargetNode *physical_screens;
@@ -573,6 +575,17 @@ typedef struct {
 #define NV_CTRL_STRING_XV_LAST_ATTRIBUTE  (NV_CTRL_STRING_XV_VERSION)
 
 
+/*
+ * Additional XVideo string attributes for NvCtrlGetStringDisplayAttribute();
+ */
+
+#define NV_CTRL_STRING_NVML_BASE            (NV_CTRL_STRING_XV_LAST_ATTRIBUTE + 1)
+
+#define NV_CTRL_STRING_NVML_VERSION         (NV_CTRL_STRING_NVML_BASE)
+
+#define NV_CTRL_STRING_NVML_LAST_ATTRIBUTE  (NV_CTRL_STRING_NVML_VERSION)
+
+
 
 #define NV_CTRL_ATTRIBUTES_NV_CONTROL_SUBSYSTEM   0x1
 #define NV_CTRL_ATTRIBUTES_XF86VIDMODE_SUBSYSTEM  0x2
diff --git a/src/libXNVCtrlAttributes/NvCtrlAttributesNvControl.c b/src/libXNVCtrlAttributes/NvCtrlAttributesNvControl.c
index bd6e829..6cd46c2 100644
--- a/src/libXNVCtrlAttributes/NvCtrlAttributesNvControl.c
+++ b/src/libXNVCtrlAttributes/NvCtrlAttributesNvControl.c
@@ -41,7 +41,12 @@ NvCtrlInitNvControlAttributes (NvCtrlAttributePrivateHandle *h)
     NvCtrlNvControlAttributes *nv;
     int ret, major, minor, event, error;
     const CtrlTargetTypeInfo *targetTypeInfo;
-    
+
+    if (!h->dpy) {
+        nv_warning_msg("NV-CONTROL Display not found.");
+        return NULL;
+    }
+
     ret = XNVCTRLQueryExtension (h->dpy, &event, &error);
     if (ret != True) {
         nv_warning_msg("NV-CONTROL extension not found on this Display.");
@@ -160,6 +165,11 @@ NvCtrlNvControlQueryTargetCount(const NvCtrlAttributePrivateHandle *h,
         return NvCtrlBadArgument;
     }
 
+    if (!h->dpy) {
+        nv_warning_msg("NV-CONTROL Display not found.");
+        return NvCtrlError;
+    }
+
     ret = XNVCTRLQueryTargetCount(h->dpy, targetTypeInfo->nvctrl, val);
     return (ret) ? NvCtrlSuccess : NvCtrlError;
 
@@ -174,6 +184,10 @@ ReturnStatus NvCtrlNvControlGetAttribute(const NvCtrlAttributePrivateHandle *h,
     int value_32;
     int major, minor;
 
+    if (!h->nv) {
+        return NvCtrlMissingExtension;
+    }
+
     major = h->nv->major_version;
     minor = h->nv->minor_version;
 
@@ -287,6 +301,9 @@ static void convertFromNvCtrlPermissions(CtrlAttributePerms *dst,
         dst->valid_targets |=
             CTRL_TARGET_PERM_BIT(NVIDIA_3D_VISION_PRO_TRANSCEIVER_TARGET);
     }
+    if (permissions & ATTRIBUTE_TYPE_MUX) {
+        dst->valid_targets |= CTRL_TARGET_PERM_BIT(MUX_TARGET);
+    }
 }
 
 
diff --git a/src/libXNVCtrlAttributes/NvCtrlAttributesNvml.c b/src/libXNVCtrlAttributes/NvCtrlAttributesNvml.c
index 6fab109..bf99291 100644
--- a/src/libXNVCtrlAttributes/NvCtrlAttributesNvml.c
+++ b/src/libXNVCtrlAttributes/NvCtrlAttributesNvml.c
@@ -39,6 +39,15 @@
 
 #define MAX_NVML_STR_LEN 64
 
+static inline const NvCtrlNvmlAttributes *
+getNvmlHandleConst(const NvCtrlAttributePrivateHandle *h)
+{
+    if ((h == NULL) || (h->nvml == NULL)) {
+        return NULL;
+    }
+
+    return h->nvml;
+}
 
 static void printNvmlError(nvmlReturn_t error)
 {
@@ -55,8 +64,6 @@ static void printNvmlError(nvmlReturn_t error)
             break;
 
         case NVML_ERROR_NOT_SUPPORTED:
-            nv_error_msg("The requested operation is not available on target "
-                         "device");
             break;
 
         case NVML_ERROR_NO_PERMISSION:
@@ -192,21 +199,37 @@ static Bool LoadNvml(NvCtrlNvmlAttributes *nvml)
     GET_SYMBOL_REQUIRED(deviceGetUUID,                  "nvmlDeviceGetUUID");
     GET_SYMBOL_REQUIRED(deviceGetCount,                 "nvmlDeviceGetCount");
     GET_SYMBOL_REQUIRED(deviceGetTemperature,           "nvmlDeviceGetTemperature");
-    GET_SYMBOL_REQUIRED(deviceGetFanSpeed,              "nvmlDeviceGetFanSpeed");
     GET_SYMBOL_REQUIRED(deviceGetName,                  "nvmlDeviceGetName");
     GET_SYMBOL_REQUIRED(deviceGetVbiosVersion,          "nvmlDeviceGetVbiosVersion");
     GET_SYMBOL_REQUIRED(deviceGetMemoryInfo,            "nvmlDeviceGetMemoryInfo");
     GET_SYMBOL_REQUIRED(deviceGetPciInfo,               "nvmlDeviceGetPciInfo");
+    GET_SYMBOL_REQUIRED(deviceGetCurrPcieLinkWidth,     "nvmlDeviceGetCurrPcieLinkWidth");
     GET_SYMBOL_REQUIRED(deviceGetMaxPcieLinkGeneration, "nvmlDeviceGetMaxPcieLinkGeneration");
     GET_SYMBOL_REQUIRED(deviceGetMaxPcieLinkWidth,      "nvmlDeviceGetMaxPcieLinkWidth");
     GET_SYMBOL_REQUIRED(deviceGetVirtualizationMode,    "nvmlDeviceGetVirtualizationMode");
+    GET_SYMBOL_REQUIRED(deviceGetUtilizationRates,      "nvmlDeviceGetUtilizationRates");
+    GET_SYMBOL_REQUIRED(deviceGetTemperatureThreshold,  "nvmlDeviceGetTemperatureThreshold");
+    GET_SYMBOL_REQUIRED(deviceGetFanSpeed_v2,           "nvmlDeviceGetFanSpeed_v2");
+    GET_SYMBOL_REQUIRED(systemGetDriverVersion,         "nvmlSystemGetDriverVersion");
+    GET_SYMBOL_REQUIRED(deviceGetEccMode,               "nvmlDeviceGetEccMode");
+    GET_SYMBOL_REQUIRED(deviceSetEccMode,               "nvmlDeviceSetEccMode");
+    GET_SYMBOL_REQUIRED(deviceGetTotalEccErrors,        "nvmlDeviceGetTotalEccErrors");
+    GET_SYMBOL_REQUIRED(deviceClearEccErrorCounts,      "nvmlDeviceClearEccErrorCounts");
+    GET_SYMBOL_REQUIRED(systemGetNVMLVersion,           "nvmlSystemGetNVMLVersion");
+    GET_SYMBOL_REQUIRED(deviceGetMemoryErrorCounter,    "nvmlDeviceGetMemoryErrorCounter");
+    GET_SYMBOL_REQUIRED(deviceGetNumGpuCores,           "nvmlDeviceGetNumGpuCores");
+    GET_SYMBOL_REQUIRED(deviceGetMemoryBusWidth,        "nvmlDeviceGetMemoryBusWidth");
+    GET_SYMBOL_REQUIRED(deviceGetIrqNum,                "nvmlDeviceGetIrqNum");
+    GET_SYMBOL_REQUIRED(deviceGetPowerSource,           "nvmlDeviceGetPowerSource");
+    GET_SYMBOL_REQUIRED(deviceGetNumFans,               "nvmlDeviceGetNumFans");
 #undef GET_SYMBOL_REQUIRED
     
 /* Do not fail with older drivers */
 #define GET_SYMBOL_OPTIONAL(_proc, _name)             \
     nvml->lib._proc = dlsym(nvml->lib.handle, _name); 
     
-    GET_SYMBOL_OPTIONAL(deviceGetGridLicensableFeatures, "nvmlDeviceGetGridLicensableFeatures_v3");
+    GET_SYMBOL_OPTIONAL(deviceGetGridLicensableFeatures, "nvmlDeviceGetGridLicensableFeatures_v4");
+    GET_SYMBOL_OPTIONAL(deviceGetMemoryInfo_v2,          "nvmlDeviceGetMemoryInfo_v2");
 #undef GET_SYMBOL_OPTIONAL
 
     ret = nvml->lib.init();
@@ -243,8 +266,8 @@ static Bool matchNvCtrlWithNvmlIds(const NvCtrlNvmlAttributes *nvml,
     int nvctrlGpuCount = 0;
 
     /* Get the gpu count returned by NV-CONTROL. */
-    if (!XNVCTRLQueryTargetCount(h->dpy, NV_CTRL_TARGET_TYPE_GPU,
-                                 &nvctrlGpuCount)) {
+    if (h->nv && !XNVCTRLQueryTargetCount(h->dpy, NV_CTRL_TARGET_TYPE_GPU,
+                                          &nvctrlGpuCount)) {
         return FALSE;
     }
 
@@ -367,7 +390,7 @@ NvCtrlNvmlAttributes *NvCtrlInitNvmlAttributes(NvCtrlAttributePrivateHandle *h)
         nvmlReturn_t ret = nvml->lib.deviceGetHandleByIndex(devIdx, &device);
         if (ret == NVML_SUCCESS) {
             unsigned int temp;
-            unsigned int speed;
+            unsigned int fans;
 
             /*
              * XXX Currently, NVML only allows to get the GPU temperature so
@@ -387,12 +410,7 @@ NvCtrlNvmlAttributes *NvCtrlInitNvmlAttributes(NvCtrlAttributePrivateHandle *h)
                 nvml->sensorCount++;
             }
 
-            /*
-             * XXX NVML assumes at most 1 fan per GPU so check for
-             *     nvmlDeviceGetFanSpeed success to figure out if that fan is
-             *     available.
-             */
-            ret = nvml->lib.deviceGetFanSpeed(device, &speed);
+            ret = nvml->lib.deviceGetNumFans(device, &fans);
             if (ret == NVML_SUCCESS) {
                 if ((h->target_type == COOLER_TARGET) &&
                     (h->target_id == nvml->coolerCount)) {
@@ -400,21 +418,20 @@ NvCtrlNvmlAttributes *NvCtrlInitNvmlAttributes(NvCtrlAttributePrivateHandle *h)
                     nvml->deviceIdx = devIdx;
                 }
 
-                nvml->coolerCountPerGPU[i] = 1;
-                nvml->coolerCount++;
+                nvml->coolerCountPerGPU[i] = fans;
+                nvml->coolerCount += fans;
             }
         }
     }
 
     /*
-     * NVML doesn't have support to handle more than 1 fan per GPU. Make sure
-     * total number of cooler probed by NVML are same as that of reported by
-     * NV-CONTROL, otherwise do not initialize NVML sub-system.
+     * Consistency check between X/NV-CONTROL and NVML.
      */
-    if (!XNVCTRLQueryTargetCount(h->dpy, NV_CTRL_TARGET_TYPE_COOLER,
-                                 &nvctrlCoolerCount) ||
-        (nvctrlCoolerCount != nvml->coolerCount)) {
-        goto fail;
+    if (h->nv &&
+        (!XNVCTRLQueryTargetCount(h->dpy, NV_CTRL_TARGET_TYPE_COOLER,
+                                   &nvctrlCoolerCount) ||
+         (nvctrlCoolerCount != nvml->coolerCount))) {
+        nv_warning_msg("Inconsistent number of fans detected.");
     }
 
     nvfree(nvctrlToNvmlId);
@@ -495,10 +512,50 @@ ReturnStatus NvCtrlNvmlQueryTargetCount(const CtrlTarget *ctrl_target,
 
 
 /*
- * Get NVML String Attribute Values
+ * Get NVML String Attribute Values that do not require a control target.
  */
 
-#ifdef NVML_EXPERIMENTAL
+static ReturnStatus NvCtrlNvmlGetGeneralStringAttribute(const CtrlTarget *ctrl_target,
+                                                        int attr, char **ptr)
+{
+    char res[MAX_NVML_STR_LEN];
+    const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
+    nvmlReturn_t ret;
+    *ptr = NULL;
+
+    if ((h == NULL) || (h->nvml == NULL)) {
+        return NvCtrlBadHandle;
+    }
+
+    switch (attr) {
+        case NV_CTRL_STRING_NVIDIA_DRIVER_VERSION:
+            ret = h->nvml->lib.systemGetDriverVersion(res, MAX_NVML_STR_LEN);
+            break;
+
+        case NV_CTRL_STRING_NVML_VERSION:
+            ret = h->nvml->lib.systemGetNVMLVersion(res, MAX_NVML_STR_LEN);
+            break;
+
+        default:
+            /* This is expected to fall through silently. */
+            return NvCtrlNotSupported;
+    }
+
+    if (ret == NVML_SUCCESS) {
+        *ptr = strdup(res);
+        return NvCtrlSuccess;
+    }
+
+    /* An NVML error occurred */
+    printNvmlError(ret);
+    return NvCtrlNotSupported;
+}
+
+
+
+/*
+ * Get NVML String Attribute Values
+ */
 
 static ReturnStatus NvCtrlNvmlGetGPUStringAttribute(const CtrlTarget *ctrl_target,
                                                     int attr, char **ptr)
@@ -510,12 +567,11 @@ static ReturnStatus NvCtrlNvmlGetGPUStringAttribute(const CtrlTarget *ctrl_targe
     nvmlReturn_t ret;
     *ptr = NULL;
 
-    if ((h == NULL) || (h->nvml == NULL)) {
+    nvml = getNvmlHandleConst(h);
+    if (nvml == NULL) {
         return NvCtrlBadHandle;
     }
 
-    nvml = h->nvml;
-
     ret = nvml->lib.deviceGetHandleByIndex(nvml->deviceIdx, &device);
     if (ret == NVML_SUCCESS) {
         switch (attr) {
@@ -531,11 +587,33 @@ static ReturnStatus NvCtrlNvmlGetGPUStringAttribute(const CtrlTarget *ctrl_targe
                 ret = nvml->lib.deviceGetUUID(device, res, MAX_NVML_STR_LEN);
                 break;
 
-            case NV_CTRL_STRING_NVIDIA_DRIVER_VERSION:
+            case NV_CTRL_STRING_GPU_UTILIZATION:
+            {
+                nvmlUtilization_t util;
+
+                if (ctrl_target->system->has_nv_control) {
+                    /*
+                     * Not all utilization types are currently available via
+                     * NVML so, if accessible, get the rates from X.
+                     */
+                    return NvCtrlNotSupported;
+                }
+
+                ret = nvml->lib.deviceGetUtilizationRates(device, &util);
+
+                if (ret != NVML_SUCCESS) {
+                    break;
+                }
+
+                snprintf(res, sizeof(res),
+                         "graphics=%d, memory=%d",
+                         util.gpu, util.memory);
+
+                break;
+            }
             case NV_CTRL_STRING_SLI_MODE:
             case NV_CTRL_STRING_PERFORMANCE_MODES:
             case NV_CTRL_STRING_GPU_CURRENT_CLOCK_FREQS:
-            case NV_CTRL_STRING_GPU_UTILIZATION:
             case NV_CTRL_STRING_MULTIGPU_MODE:
                 /*
                  * XXX We'll eventually need to add support for this attributes
@@ -562,22 +640,26 @@ static ReturnStatus NvCtrlNvmlGetGPUStringAttribute(const CtrlTarget *ctrl_targe
     return NvCtrlNotSupported;
 }
 
-#endif // NVML_EXPERIMENTAL
+
 
 ReturnStatus NvCtrlNvmlGetStringAttribute(const CtrlTarget *ctrl_target,
                                           int attr, char **ptr)
 {
+    ReturnStatus ret;
+
     if (NvmlMissing(ctrl_target)) {
         return NvCtrlMissingExtension;
     }
 
-#ifdef NVML_EXPERIMENTAL
     /*
-     * This shouldn't be reached for target types that are not handled through
-     * NVML (Keep TARGET_TYPE_IS_NVML_COMPATIBLE in NvCtrlAttributesPrivate.h up
-     * to date).
+     * Check for attributes that don't require a target, else continue to
+     * supported target types.
      */
-    assert(TARGET_TYPE_IS_NVML_COMPATIBLE(NvCtrlGetTargetType(ctrl_target)));
+    ret = NvCtrlNvmlGetGeneralStringAttribute(ctrl_target, attr, ptr);
+
+    if (ret == NvCtrlSuccess) {
+        return NvCtrlSuccess;
+    }
 
     switch (NvCtrlGetTargetType(ctrl_target)) {
         case GPU_TARGET:
@@ -600,10 +682,6 @@ ReturnStatus NvCtrlNvmlGetStringAttribute(const CtrlTarget *ctrl_target,
         default:
             return NvCtrlBadHandle;
     }
-
-#else
-    return NvCtrlNotSupported;
-#endif
 }
 
 
@@ -612,7 +690,7 @@ ReturnStatus NvCtrlNvmlGetStringAttribute(const CtrlTarget *ctrl_target,
  * Set NVML String Attribute Values
  */
 
-#ifdef NVML_EXPERIMENTAL
+
 
 static ReturnStatus NvCtrlNvmlSetGPUStringAttribute(CtrlTarget *ctrl_target,
                                                     int attr, const char *ptr)
@@ -622,12 +700,11 @@ static ReturnStatus NvCtrlNvmlSetGPUStringAttribute(CtrlTarget *ctrl_target,
     nvmlDevice_t device;
     nvmlReturn_t ret;
 
-    if ((h == NULL) || (h->nvml == NULL)) {
+    nvml = getNvmlHandleConst(h);
+    if (nvml == NULL) {
         return NvCtrlBadHandle;
     }
 
-    nvml = h->nvml;
-
     ret = nvml->lib.deviceGetHandleByIndex(nvml->deviceIdx, &device);
     if (ret == NVML_SUCCESS) {
         switch (attr) {
@@ -656,7 +733,7 @@ static ReturnStatus NvCtrlNvmlSetGPUStringAttribute(CtrlTarget *ctrl_target,
     return NvCtrlNotSupported;
 }
 
-#endif // NVML_EXPERIMENTAL
+
 
 ReturnStatus NvCtrlNvmlSetStringAttribute(CtrlTarget *ctrl_target,
                                           int attr, const char *ptr)
@@ -665,7 +742,6 @@ ReturnStatus NvCtrlNvmlSetStringAttribute(CtrlTarget *ctrl_target,
         return NvCtrlMissingExtension;
     }
 
-#ifdef NVML_EXPERIMENTAL
     /*
      * This shouldn't be reached for target types that are not handled through
      * NVML (Keep TARGET_TYPE_IS_NVML_COMPATIBLE in NvCtrlAttributesPrivate.h up
@@ -695,10 +771,6 @@ ReturnStatus NvCtrlNvmlSetStringAttribute(CtrlTarget *ctrl_target,
         default:
             return NvCtrlBadHandle;
     }
-
-#else
-    return NvCtrlNotSupported;
-#endif
 }
 
 
@@ -710,35 +782,49 @@ ReturnStatus NvCtrlNvmlSetStringAttribute(CtrlTarget *ctrl_target,
 static ReturnStatus NvCtrlNvmlGetGPUAttribute(const CtrlTarget *ctrl_target,
                                               int attr, int64_t *val)
 {
-    unsigned int res;
+    unsigned int res = 0;
     const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
     const NvCtrlNvmlAttributes *nvml;
     nvmlDevice_t device;
     nvmlReturn_t ret;
 
-    if ((h == NULL) || (h->nvml == NULL)) {
+    nvml = getNvmlHandleConst(h);
+    if (nvml == NULL) {
         return NvCtrlBadHandle;
     }
 
-    nvml = h->nvml;
-
     ret = nvml->lib.deviceGetHandleByIndex(nvml->deviceIdx, &device);
     if (ret == NVML_SUCCESS) {
         switch (attr) {
-#ifdef NVML_EXPERIMENTAL
             case NV_CTRL_TOTAL_DEDICATED_GPU_MEMORY:
             case NV_CTRL_USED_DEDICATED_GPU_MEMORY:
                 {
-                    nvmlMemory_t memory;
-                    ret = nvml->lib.deviceGetMemoryInfo(device, &memory);
-                    if (ret == NVML_SUCCESS) {
-                        switch (attr) {
-                            case NV_CTRL_TOTAL_DEDICATED_GPU_MEMORY:
-                                res = memory.total >> 20; // bytes --> MB
-                                break;
-                            case NV_CTRL_USED_DEDICATED_GPU_MEMORY:
-                                res = memory.used >> 20; // bytes --> MB
-                                break;
+                    if (nvml->lib.deviceGetMemoryInfo_v2) {
+                        nvmlMemory_v2_t memory;
+                        memory.version = nvmlMemory_v2;
+                        ret = nvml->lib.deviceGetMemoryInfo_v2(device, &memory);
+                        if (ret == NVML_SUCCESS) {
+                            switch (attr) {
+                                case NV_CTRL_TOTAL_DEDICATED_GPU_MEMORY:
+                                    res = memory.total >> 20; // bytes --> MB
+                                    break;
+                                case NV_CTRL_USED_DEDICATED_GPU_MEMORY:
+                                    res = memory.used >> 20; // bytes --> MB
+                                    break;
+                            }
+                        }
+                    } else {
+                        nvmlMemory_t memory;
+                        ret = nvml->lib.deviceGetMemoryInfo(device, &memory);
+                        if (ret == NVML_SUCCESS) {
+                            switch (attr) {
+                                case NV_CTRL_TOTAL_DEDICATED_GPU_MEMORY:
+                                    res = memory.total >> 20; // bytes --> MB
+                                    break;
+                                case NV_CTRL_USED_DEDICATED_GPU_MEMORY:
+                                    res = memory.used >> 20; // bytes --> MB
+                                    break;
+                            }
                         }
                     }
                 }
@@ -787,43 +873,132 @@ static ReturnStatus NvCtrlNvmlGetGPUAttribute(const CtrlTarget *ctrl_target,
                 ret = nvml->lib.deviceGetMaxPcieLinkGeneration(device, &res);
                 break;
 
+            case NV_CTRL_GPU_PCIE_CURRENT_LINK_WIDTH:
+                ret = nvml->lib.deviceGetCurrPcieLinkWidth(device, &res);
+                break;
             case NV_CTRL_GPU_PCIE_MAX_LINK_WIDTH:
                 ret = nvml->lib.deviceGetMaxPcieLinkWidth(device, &res);
                 break;
-#else
-            case NV_CTRL_TOTAL_DEDICATED_GPU_MEMORY:
-            case NV_CTRL_USED_DEDICATED_GPU_MEMORY:
-            case NV_CTRL_PCI_DOMAIN:
-            case NV_CTRL_PCI_BUS:
-            case NV_CTRL_PCI_DEVICE:
-            case NV_CTRL_PCI_FUNCTION:
-            case NV_CTRL_PCI_ID:
-            case NV_CTRL_GPU_PCIE_GENERATION:
-            case NV_CTRL_GPU_PCIE_MAX_LINK_WIDTH:
-#endif // NVML_EXPERIMENTAL
+            case NV_CTRL_GPU_SLOWDOWN_THRESHOLD:
+                ret = nvml->lib.deviceGetTemperatureThreshold(device,
+                          NVML_TEMPERATURE_THRESHOLD_SLOWDOWN ,&res);
+                break;
+            case NV_CTRL_GPU_SHUTDOWN_THRESHOLD:
+                ret = nvml->lib.deviceGetTemperatureThreshold(device,
+                          NVML_TEMPERATURE_THRESHOLD_SHUTDOWN ,&res);
+                break;
+            case NV_CTRL_GPU_CORE_TEMPERATURE:
+                ret = nvml->lib.deviceGetTemperature(device,
+                                                     NVML_TEMPERATURE_GPU,
+                                                     &res);
+                break;
+
+            case NV_CTRL_GPU_ECC_CONFIGURATION_SUPPORTED:
+            case NV_CTRL_GPU_ECC_SUPPORTED:
+                {
+                    nvmlEnableState_t current, pending;
+                    ret = nvml->lib.deviceGetEccMode(device, &current, &pending);
+                    switch (attr) {
+                        case NV_CTRL_GPU_ECC_CONFIGURATION_SUPPORTED:
+                            res = (ret == NVML_SUCCESS) ?
+                                NV_CTRL_GPU_ECC_CONFIGURATION_SUPPORTED_TRUE :
+                                NV_CTRL_GPU_ECC_CONFIGURATION_SUPPORTED_FALSE;
+                            break;
+                        case NV_CTRL_GPU_ECC_SUPPORTED:
+                            res = (ret == NVML_SUCCESS) ?
+                                NV_CTRL_GPU_ECC_SUPPORTED_TRUE :
+                                NV_CTRL_GPU_ECC_SUPPORTED_FALSE;
+                            break;
+                    }
+
+                    // Avoid printing misleading error message
+                    if (ret == NVML_ERROR_NOT_SUPPORTED) { 
+                        ret = NVML_SUCCESS;
+                    }
+                }
+                break;
+
+            case NV_CTRL_GPU_ECC_CONFIGURATION:
+            case NV_CTRL_GPU_ECC_STATUS:
+                {
+                    nvmlEnableState_t current, pending;
+                    ret = nvml->lib.deviceGetEccMode(device, &current, &pending);
+                    if (ret == NVML_SUCCESS) {
+                        switch (attr) {
+                            case NV_CTRL_GPU_ECC_STATUS:
+                                res = current;
+                                break;
+                            case NV_CTRL_GPU_ECC_CONFIGURATION:
+                                res = pending;
+                                break;
+                        }
+                    }
+                }
+                break;
+
+            case NV_CTRL_GPU_ECC_SINGLE_BIT_ERRORS:
+            case NV_CTRL_GPU_ECC_AGGREGATE_SINGLE_BIT_ERRORS:
+            case NV_CTRL_GPU_ECC_DOUBLE_BIT_ERRORS:
+            case NV_CTRL_GPU_ECC_AGGREGATE_DOUBLE_BIT_ERRORS:
+                {
+                    unsigned long long eccCounts;
+                    nvmlEccCounterType_t counterType;
+                    nvmlMemoryErrorType_t errorType;
+                    switch (attr) {
+                        case NV_CTRL_GPU_ECC_SINGLE_BIT_ERRORS:
+                            errorType = NVML_MEMORY_ERROR_TYPE_CORRECTED;
+                            counterType = NVML_VOLATILE_ECC;
+                            break;
+                        case NV_CTRL_GPU_ECC_AGGREGATE_SINGLE_BIT_ERRORS:
+                            errorType = NVML_MEMORY_ERROR_TYPE_CORRECTED;
+                            counterType = NVML_AGGREGATE_ECC;
+                            break;
+                        case NV_CTRL_GPU_ECC_DOUBLE_BIT_ERRORS:
+                            errorType = NVML_MEMORY_ERROR_TYPE_UNCORRECTED;
+                            counterType = NVML_VOLATILE_ECC;
+                            break;
+                        case NV_CTRL_GPU_ECC_AGGREGATE_DOUBLE_BIT_ERRORS:
+                            errorType = NVML_MEMORY_ERROR_TYPE_UNCORRECTED;
+                            counterType = NVML_AGGREGATE_ECC;
+                            break;
+                    }
+
+                    ret = nvml->lib.deviceGetTotalEccErrors(device, errorType,
+                                                        counterType, &eccCounts);
+                    if (ret == NVML_SUCCESS) {
+                        if (val) {
+                            *val = eccCounts;
+                        }
+                        return NvCtrlSuccess;
+                    }
+                }
+                break;
+
+            case NV_CTRL_GPU_CORES:
+                ret = nvml->lib.deviceGetNumGpuCores(device, &res);
+                break;
+            case NV_CTRL_GPU_MEMORY_BUS_WIDTH:
+                ret = nvml->lib.deviceGetMemoryBusWidth(device, &res);
+                break;
+            case NV_CTRL_IRQ:
+                ret = nvml->lib.deviceGetIrqNum(device, &res);
+                break;
+            case NV_CTRL_GPU_POWER_SOURCE:
+                assert(NV_CTRL_GPU_POWER_SOURCE_AC == NVML_POWER_SOURCE_AC);
+                assert(NV_CTRL_GPU_POWER_SOURCE_BATTERY == NVML_POWER_SOURCE_BATTERY);
+                ret = nvml->lib.deviceGetPowerSource(device, &res);
+                break;
+
+            case NV_CTRL_GPU_ECC_DEFAULT_CONFIGURATION:
             case NV_CTRL_VIDEO_RAM:
-            case NV_CTRL_GPU_PCIE_CURRENT_LINK_WIDTH:
             case NV_CTRL_GPU_PCIE_MAX_LINK_SPEED:
             case NV_CTRL_GPU_PCIE_CURRENT_LINK_SPEED:
             case NV_CTRL_BUS_TYPE:
-            case NV_CTRL_GPU_MEMORY_BUS_WIDTH:
-            case NV_CTRL_GPU_CORES:
-            case NV_CTRL_IRQ:
             case NV_CTRL_GPU_COOLER_MANUAL_CONTROL:
-            case NV_CTRL_GPU_POWER_SOURCE:
             case NV_CTRL_GPU_CURRENT_PERFORMANCE_LEVEL:
             case NV_CTRL_GPU_ADAPTIVE_CLOCK_STATE:
             case NV_CTRL_GPU_POWER_MIZER_MODE:
             case NV_CTRL_GPU_POWER_MIZER_DEFAULT_MODE:
-            case NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE:
-            case NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT:
-            case NV_CTRL_GPU_ECC_SUPPORTED:
-            case NV_CTRL_GPU_ECC_STATUS:
-            case NV_CTRL_GPU_ECC_CONFIGURATION:
-            case NV_CTRL_GPU_ECC_DEFAULT_CONFIGURATION:
-            case NV_CTRL_GPU_ECC_DOUBLE_BIT_ERRORS:
-            case NV_CTRL_GPU_ECC_AGGREGATE_DOUBLE_BIT_ERRORS:
-            case NV_CTRL_GPU_ECC_CONFIGURATION_SUPPORTED:
             case NV_CTRL_ENABLED_DISPLAYS:
             case NV_CTRL_CONNECTED_DISPLAYS:
             case NV_CTRL_MAX_SCREEN_WIDTH:
@@ -838,10 +1013,8 @@ static ReturnStatus NvCtrlNvmlGetGPUAttribute(const CtrlTarget *ctrl_target,
             case NV_CTRL_ATTR_NV_MINOR_VERSION:
             case NV_CTRL_OPERATING_SYSTEM:
             case NV_CTRL_NO_SCANOUT:
-            case NV_CTRL_GPU_CORE_TEMPERATURE:
             case NV_CTRL_AMBIENT_TEMPERATURE:
             case NV_CTRL_GPU_CURRENT_CLOCK_FREQS:
-            case NV_CTRL_GPU_CURRENT_PROCESSOR_CLOCK_FREQS:
             case NV_CTRL_VIDEO_ENCODER_UTILIZATION:
             case NV_CTRL_VIDEO_DECODER_UTILIZATION:
             case NV_CTRL_FRAMELOCK:
@@ -888,14 +1061,16 @@ static ReturnStatus NvCtrlNvmlGetGPUAttribute(const CtrlTarget *ctrl_target,
 
             default:
                 /* Did we forget to handle a GPU integer attribute? */
-                nv_warning_msg("Unhandled integer attribute %s (%d) of GPU "
-                               "(%d)", INT_ATTRIBUTE_NAME(attr), attr,
-                               NvCtrlGetTargetId(ctrl_target));
+                nv_info_msg("", "Unhandled integer attribute %s (%d) of GPU "
+                            "(%d)", INT_ATTRIBUTE_NAME(attr), attr,
+                            NvCtrlGetTargetId(ctrl_target));
                 return NvCtrlNotSupported;
         }
 
         if (ret == NVML_SUCCESS) {
-            *val = res;
+            if (val) {
+                *val = res;
+            }
             return NvCtrlSuccess;
         }
     }
@@ -913,12 +1088,11 @@ static ReturnStatus NvCtrlNvmlGetGridLicensableFeatures(const CtrlTarget *ctrl_t
     nvmlDevice_t device;
     nvmlReturn_t ret;
 
-    if ((h == NULL) || (h->nvml == NULL)) {
+    nvml = getNvmlHandleConst(h);
+    if (nvml == NULL) {
         return NvCtrlBadHandle;
     }
 
-    nvml = h->nvml;
-
     ret = nvml->lib.deviceGetHandleByIndex(nvml->deviceIdx, &device);
         if (ret == NVML_SUCCESS) {
         switch (attr) {
@@ -953,63 +1127,62 @@ static ReturnStatus NvCtrlNvmlGetGridLicensableFeatures(const CtrlTarget *ctrl_t
     return NvCtrlNotSupported;
 }
 
-#ifdef NVML_EXPERIMENTAL
 
-static int getThermalCoolerId(const NvCtrlAttributePrivateHandle *h,
-                              unsigned int thermalCoolerCount,
-                              const unsigned int *thermalCoolerCountPerGPU)
+static void getDeviceAndTargetIndex(const NvCtrlAttributePrivateHandle *h,
+                                    unsigned int targetCount,
+                                    const unsigned int *targetCountPerGPU,
+                                    int *deviceIdx, int *targetIdx)
 {
     int i, count;
+    *targetIdx = -1;
 
-    if ((h->target_id < 0) || (h->target_id >= thermalCoolerCount)) {
-        return -1;
+    if ((h->target_id < 0) || (h->target_id >= targetCount)) {
+        return;
     }
 
     count = 0;
     for (i = 0; i < h->nvml->deviceCount; i++) {
-        int tmp = count + thermalCoolerCountPerGPU[i];
+        int tmp = count + targetCountPerGPU[i];
+        *deviceIdx = i;
         if (h->target_id < tmp) {
-            return (h->target_id - count);
+            *targetIdx = (h->target_id - count);
+            return;
         }
         count = tmp;
     }
 
-    return -1;
+    return;
 }
 
+
 static ReturnStatus NvCtrlNvmlGetThermalAttribute(const CtrlTarget *ctrl_target,
                                                   int attr, int64_t *val)
 {
     unsigned int res;
     const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
     const NvCtrlNvmlAttributes *nvml;
-    int sensorId;
+    int deviceId, sensorId;
     nvmlDevice_t device;
     nvmlReturn_t ret;
 
-    if ((h == NULL) || (h->nvml == NULL)) {
+    nvml = getNvmlHandleConst(h);
+    if (nvml == NULL) {
         return NvCtrlBadHandle;
     }
 
-    nvml = h->nvml;
-
     /* Get the proper device according to the sensor ID */
-    sensorId = getThermalCoolerId(h, nvml->sensorCount,
-                                  nvml->sensorCountPerGPU);
+    getDeviceAndTargetIndex(h, nvml->sensorCount, nvml->sensorCountPerGPU,
+                            &deviceId, &sensorId);
     if (sensorId == -1) {
         return NvCtrlBadHandle;
     }
 
 
-    ret = nvml->lib.deviceGetHandleByIndex(nvml->deviceIdx, &device);
+    ret = nvml->lib.deviceGetHandleByIndex(deviceId, &device);
     if (ret == NVML_SUCCESS) {
         switch (attr) {
             case NV_CTRL_THERMAL_SENSOR_READING:
-                ret = nvml->lib.deviceGetTemperature(device,
-                                                     NVML_TEMPERATURE_GPU,
-                                                     &res);
-                break;
-
+               
             case NV_CTRL_THERMAL_SENSOR_PROVIDER:
             case NV_CTRL_THERMAL_SENSOR_TARGET:
                 /*
@@ -1020,9 +1193,9 @@ static ReturnStatus NvCtrlNvmlGetThermalAttribute(const CtrlTarget *ctrl_target,
 
             default:
                 /* Did we forget to handle a sensor integer attribute? */
-                nv_warning_msg("Unhandled integer attribute %s (%d) of "
-                               "Thermal sensor (%d)", INT_ATTRIBUTE_NAME(attr),
-                               attr, NvCtrlGetTargetId(ctrl_target));
+                nv_info_msg("", "Unhandled integer attribute %s (%d) of "
+                            "Thermal sensor (%d)", INT_ATTRIBUTE_NAME(attr),
+                            attr, NvCtrlGetTargetId(ctrl_target));
                 return NvCtrlNotSupported;
         }
 
@@ -1043,31 +1216,30 @@ static ReturnStatus NvCtrlNvmlGetCoolerAttribute(const CtrlTarget *ctrl_target,
     unsigned int res;
     const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
     const NvCtrlNvmlAttributes *nvml;
-    int coolerId;
+    int deviceId, coolerId;
     nvmlDevice_t device;
     nvmlReturn_t ret;
 
-    if ((h == NULL) || (h->nvml == NULL)) {
+    nvml = getNvmlHandleConst(h);
+    if (nvml == NULL) {
         return NvCtrlBadHandle;
     }
 
-    nvml = h->nvml;
-
     /* Get the proper device according to the cooler ID */
-    coolerId = getThermalCoolerId(h, nvml->coolerCount,
-                                  nvml->coolerCountPerGPU);
+    getDeviceAndTargetIndex(h, nvml->coolerCount, nvml->coolerCountPerGPU,
+                            &deviceId, &coolerId);
     if (coolerId == -1) {
         return NvCtrlBadHandle;
     }
 
-
-    ret = nvml->lib.deviceGetHandleByIndex(nvml->deviceIdx, &device);
+    ret = nvml->lib.deviceGetHandleByIndex(deviceId, &device);
     if (ret == NVML_SUCCESS) {
         switch (attr) {
-            case NV_CTRL_THERMAL_COOLER_LEVEL:
-                ret = nvml->lib.deviceGetFanSpeed(device, &res);
+            case NV_CTRL_THERMAL_COOLER_CURRENT_LEVEL:
+                ret = nvml->lib.deviceGetFanSpeed_v2(device, coolerId, &res);
                 break;
 
+            case NV_CTRL_THERMAL_COOLER_LEVEL:
             case NV_CTRL_THERMAL_COOLER_SPEED:
             case NV_CTRL_THERMAL_COOLER_CONTROL_TYPE:
             case NV_CTRL_THERMAL_COOLER_TARGET:
@@ -1079,9 +1251,9 @@ static ReturnStatus NvCtrlNvmlGetCoolerAttribute(const CtrlTarget *ctrl_target,
 
             default:
                 /* Did we forget to handle a cooler integer attribute? */
-                nv_warning_msg("Unhandled integer attribute %s (%d) of Fan "
-                               "(%d)", INT_ATTRIBUTE_NAME(attr), attr,
-                               NvCtrlGetTargetId(ctrl_target));
+                nv_info_msg("", "Unhandled integer attribute %s (%d) of Fan "
+                            "(%d)", INT_ATTRIBUTE_NAME(attr), attr,
+                            NvCtrlGetTargetId(ctrl_target));
                 return NvCtrlNotSupported;
         }
 
@@ -1095,7 +1267,8 @@ static ReturnStatus NvCtrlNvmlGetCoolerAttribute(const CtrlTarget *ctrl_target,
     printNvmlError(ret);
     return NvCtrlNotSupported;
 }
-#endif // NVML_EXPERIMENTAL
+
+
 
 ReturnStatus NvCtrlNvmlGetAttribute(const CtrlTarget *ctrl_target,
                                     int attr, int64_t *val)
@@ -1114,18 +1287,12 @@ ReturnStatus NvCtrlNvmlGetAttribute(const CtrlTarget *ctrl_target,
     switch (NvCtrlGetTargetType(ctrl_target)) {
         case GPU_TARGET:
             return NvCtrlNvmlGetGPUAttribute(ctrl_target, attr, val);
-#ifdef NVML_EXPERIMENTAL
         case THERMAL_SENSOR_TARGET:
             return NvCtrlNvmlGetThermalAttribute(ctrl_target, attr, val);
         case COOLER_TARGET:
             return NvCtrlNvmlGetCoolerAttribute(ctrl_target, attr, val);
-#else
-        case THERMAL_SENSOR_TARGET:
-        case COOLER_TARGET:
-            return NvCtrlNotSupported;
-#endif
         default:
-            return NvCtrlBadHandle;
+            return NvCtrlNotSupported;
     }
 }
 
@@ -1157,7 +1324,7 @@ ReturnStatus NvCtrlNvmlGetGridLicenseAttributes(const CtrlTarget *ctrl_target,
  * Set NVML Attribute Values
  */
 
-#ifdef NVML_EXPERIMENTAL
+
 
 static ReturnStatus NvCtrlNvmlSetGPUAttribute(CtrlTarget *ctrl_target,
                                               int attr, int index, int val)
@@ -1167,18 +1334,36 @@ static ReturnStatus NvCtrlNvmlSetGPUAttribute(CtrlTarget *ctrl_target,
     nvmlDevice_t device;
     nvmlReturn_t ret;
 
-    if ((h == NULL) || (h->nvml == NULL)) {
+    nvml = getNvmlHandleConst(h);
+    if (nvml == NULL) {
         return NvCtrlBadHandle;
     }
 
-    nvml = h->nvml;
-
     ret = nvml->lib.deviceGetHandleByIndex(nvml->deviceIdx, &device);
     if (ret == NVML_SUCCESS) {
         switch (attr) {
+            case NV_CTRL_GPU_ECC_CONFIGURATION:
+                ret = nvml->lib.deviceSetEccMode(device, val);
+                break;
+
+            case NV_CTRL_GPU_ECC_RESET_ERROR_STATUS:
+                {
+                    nvmlEccCounterType_t counterType = 0;
+                    switch (val) {
+                        case NV_CTRL_GPU_ECC_RESET_ERROR_STATUS_VOLATILE:
+                            counterType = NVML_VOLATILE_ECC;
+                            break;
+                        case NV_CTRL_GPU_ECC_RESET_ERROR_STATUS_AGGREGATE:
+                            counterType = NVML_AGGREGATE_ECC;
+                            break;
+                    }
+                    ret = nvml->lib.deviceClearEccErrorCounts(device,
+                                                              counterType);
+                }
+                break;
+
             case NV_CTRL_GPU_CURRENT_CLOCK_FREQS:
             case NV_CTRL_GPU_POWER_MIZER_MODE:
-            case NV_CTRL_GPU_ECC_CONFIGURATION:
             case NV_CTRL_GPU_COOLER_MANUAL_CONTROL:
             case NV_CTRL_DITHERING:
             case NV_CTRL_DITHERING_MODE:
@@ -1195,9 +1380,9 @@ static ReturnStatus NvCtrlNvmlSetGPUAttribute(CtrlTarget *ctrl_target,
 
             default:
                 /* Did we forget to handle a GPU integer attribute? */
-                nv_warning_msg("Unhandled integer attribute %s (%d) of GPU "
-                               "(%d) (set to %d)", INT_ATTRIBUTE_NAME(attr),
-                               attr, NvCtrlGetTargetId(ctrl_target), val);
+                nv_info_msg("", "Unhandled integer attribute %s (%d) of GPU "
+                            "(%d) (set to %d)", INT_ATTRIBUTE_NAME(attr),
+                            attr, NvCtrlGetTargetId(ctrl_target), val);
                 return NvCtrlNotSupported;
         }
 
@@ -1216,24 +1401,23 @@ static ReturnStatus NvCtrlNvmlSetCoolerAttribute(CtrlTarget *ctrl_target,
 {
     NvCtrlAttributePrivateHandle *h = getPrivateHandle(ctrl_target);
     const NvCtrlNvmlAttributes *nvml;
-    int coolerId;
+    int deviceId, coolerId;
     nvmlDevice_t device;
     nvmlReturn_t ret;
 
-    if ((h == NULL) || (h->nvml == NULL)) {
+    nvml = getNvmlHandleConst(h);
+    if (nvml == NULL) {
         return NvCtrlBadHandle;
     }
 
-    nvml = h->nvml;
-
     /* Get the proper device according to the cooler ID */
-    coolerId = getThermalCoolerId(h, nvml->coolerCount,
-                                  nvml->coolerCountPerGPU);
+    getDeviceAndTargetIndex(h, nvml->coolerCount, nvml->coolerCountPerGPU,
+                            &deviceId, &coolerId);
     if (coolerId == -1) {
         return NvCtrlBadHandle;
     }
 
-    ret = nvml->lib.deviceGetHandleByIndex(nvml->deviceIdx, &device);
+    ret = nvml->lib.deviceGetHandleByIndex(deviceId, &device);
     if (ret == NVML_SUCCESS) {
         switch (attr) {
             case NV_CTRL_THERMAL_COOLER_LEVEL:
@@ -1246,9 +1430,9 @@ static ReturnStatus NvCtrlNvmlSetCoolerAttribute(CtrlTarget *ctrl_target,
 
             default:
                 /* Did we forget to handle a cooler integer attribute? */
-                nv_warning_msg("Unhandled integer attribute %s (%d) of Fan "
-                               "(%d) (set to %d)", INT_ATTRIBUTE_NAME(attr),
-                               attr, NvCtrlGetTargetId(ctrl_target), val);
+                nv_info_msg("", "Unhandled integer attribute %s (%d) of Fan "
+                            "(%d) (set to %d)", INT_ATTRIBUTE_NAME(attr),
+                            attr, NvCtrlGetTargetId(ctrl_target), val);
                 return NvCtrlNotSupported;
         }
 
@@ -1262,7 +1446,7 @@ static ReturnStatus NvCtrlNvmlSetCoolerAttribute(CtrlTarget *ctrl_target,
     return NvCtrlNotSupported;
 }
 
-#endif // NVML_EXPERIMENTAL
+
 
 ReturnStatus NvCtrlNvmlSetAttribute(CtrlTarget *ctrl_target, int attr,
                                     int index, int val)
@@ -1271,7 +1455,6 @@ ReturnStatus NvCtrlNvmlSetAttribute(CtrlTarget *ctrl_target, int attr,
         return NvCtrlMissingExtension;
     }
 
-#ifdef NVML_EXPERIMENTAL
     /*
      * This shouldn't be reached for target types that are not handled through
      * NVML (Keep TARGET_TYPE_IS_NVML_COMPATIBLE in NvCtrlAttributesPrivate.h up
@@ -1285,9 +1468,9 @@ ReturnStatus NvCtrlNvmlSetAttribute(CtrlTarget *ctrl_target, int attr,
 
         case THERMAL_SENSOR_TARGET:
             /* Did we forget to handle a sensor integer attribute? */
-            nv_warning_msg("Unhandled integer attribute %s (%d) of Thermal "
-                           "sensor (%d) (set to %d)", INT_ATTRIBUTE_NAME(attr),
-                           attr, NvCtrlGetTargetId(ctrl_target), val);
+            nv_info_msg("", "Unhandled integer attribute %s (%d) of Thermal "
+                        "sensor (%d) (set to %d)", INT_ATTRIBUTE_NAME(attr),
+                        attr, NvCtrlGetTargetId(ctrl_target), val);
             return NvCtrlNotSupported;
 
         case COOLER_TARGET:
@@ -1295,19 +1478,47 @@ ReturnStatus NvCtrlNvmlSetAttribute(CtrlTarget *ctrl_target, int attr,
         default:
             return NvCtrlBadHandle;
     }
-
-#else
-    return NvCtrlNotSupported;
-#endif
 }
 
 
 
+static nvmlReturn_t getDeviceMemoryCounts(const CtrlTarget *ctrl_target,
+                                          const NvCtrlNvmlAttributes *nvml,
+                                          nvmlDevice_t device,
+                                          nvmlMemoryErrorType_t errorType,
+                                          nvmlEccCounterType_t counterType,
+                                          unsigned char **data, int *len)
+{
+    unsigned long long count;
+    int *counts = (int *) nvalloc(sizeof(int) * NVML_MEMORY_LOCATION_COUNT);
+    nvmlReturn_t ret, anySuccess = NVML_ERROR_NOT_SUPPORTED;
+    int i;
+
+    for (i = NVML_MEMORY_LOCATION_L1_CACHE;
+         i < NVML_MEMORY_LOCATION_COUNT;
+         i++) {
+
+        ret = nvml->lib.deviceGetMemoryErrorCounter(device, errorType,
+                                                    counterType, i, &count);
+        if (ret == NVML_SUCCESS) {
+            anySuccess = NVML_SUCCESS;
+            counts[i] = (int) count;
+        } else {
+            counts[i] = -1;
+        }
+    }
+
+    *data = (unsigned char *) counts;
+    *len  = sizeof(int) * NVML_MEMORY_LOCATION_COUNT;
+
+    return anySuccess;
+}
+
 /*
  * Get NVML Binary Attribute Values
  */
 
-#ifdef NVML_EXPERIMENTAL
+
 
 static ReturnStatus
 NvCtrlNvmlGetGPUBinaryAttribute(const CtrlTarget *ctrl_target,
@@ -1318,17 +1529,74 @@ NvCtrlNvmlGetGPUBinaryAttribute(const CtrlTarget *ctrl_target,
     nvmlDevice_t device;
     nvmlReturn_t ret;
 
-    if ((h == NULL) || (h->nvml == NULL)) {
+    nvml = getNvmlHandleConst(h);
+    if (nvml == NULL) {
         return NvCtrlBadHandle;
     }
 
-    nvml = h->nvml;
-
     ret = nvml->lib.deviceGetHandleByIndex(nvml->deviceIdx, &device);
     if (ret == NVML_SUCCESS) {
         switch (attr) {
-            case NV_CTRL_BINARY_DATA_FRAMELOCKS_USED_BY_GPU:
             case NV_CTRL_BINARY_DATA_COOLERS_USED_BY_GPU:
+            {
+                unsigned int *fan_data;
+                unsigned int count = 0;
+                int offset = 0;
+                int i = 0;
+
+                ret = nvml->lib.deviceGetNumFans(device, &count);
+                if (ret != NVML_SUCCESS) {
+                    return NvCtrlNotSupported;
+                }
+
+                /*
+                 * The format of the returned data is:
+                 *
+                 * int       unsigned int number of COOLERS
+                 * int * n   unsigned int COOLER indices
+                 */
+
+                *len = (count + 1) * sizeof(unsigned int);
+                fan_data = (unsigned int *) nvalloc(*len);
+                memset(fan_data, 0, *len);
+                *data = (unsigned char *) fan_data;
+
+                /* Calculate global fan index offset for this GPU */
+                for (i = 0; i < nvml->deviceIdx; i++) {
+                    offset += nvml->coolerCountPerGPU[i];
+                }
+
+                fan_data[0] = count;
+                for (i = 0; i < count; i++) {
+                    fan_data[i+1] = i + offset;
+                }
+                break;
+            }
+            case NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS_SINGLE_BIT:
+                ret = getDeviceMemoryCounts(ctrl_target, nvml, device,
+                                            NVML_MEMORY_ERROR_TYPE_CORRECTED,
+                                            NVML_VOLATILE_ECC,
+                                            data, len);
+                break;
+            case NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS_DOUBLE_BIT:
+                ret = getDeviceMemoryCounts(ctrl_target, nvml, device,
+                                            NVML_MEMORY_ERROR_TYPE_UNCORRECTED,
+                                            NVML_VOLATILE_ECC,
+                                            data, len);
+                break;
+            case NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS_SINGLE_BIT_AGGREGATE:
+                ret = getDeviceMemoryCounts(ctrl_target, nvml, device,
+                                            NVML_MEMORY_ERROR_TYPE_CORRECTED,
+                                            NVML_AGGREGATE_ECC,
+                                            data, len);
+                break;
+            case NV_CTRL_BINARY_DATA_GPU_ECC_DETAILED_ERRORS_DOUBLE_BIT_AGGREGATE:
+                ret = getDeviceMemoryCounts(ctrl_target, nvml, device,
+                                            NVML_MEMORY_ERROR_TYPE_UNCORRECTED,
+                                            NVML_AGGREGATE_ECC,
+                                            data, len);
+                break;
+            case NV_CTRL_BINARY_DATA_FRAMELOCKS_USED_BY_GPU:
             case NV_CTRL_BINARY_DATA_THERMAL_SENSORS_USED_BY_GPU:
             case NV_CTRL_BINARY_DATA_DISPLAYS_CONNECTED_TO_GPU:
             case NV_CTRL_BINARY_DATA_DISPLAYS_ON_GPU:
@@ -1358,7 +1626,7 @@ NvCtrlNvmlGetGPUBinaryAttribute(const CtrlTarget *ctrl_target,
     return NvCtrlNotSupported;
 }
 
-#endif // NVML_EXPERIMENTAL
+
 
 ReturnStatus
 NvCtrlNvmlGetBinaryAttribute(const CtrlTarget *ctrl_target,
@@ -1368,7 +1636,6 @@ NvCtrlNvmlGetBinaryAttribute(const CtrlTarget *ctrl_target,
         return NvCtrlMissingExtension;
     }
 
-#ifdef NVML_EXPERIMENTAL
     /*
      * This shouldn't be reached for target types that are not handled through
      * NVML (Keep TARGET_TYPE_IS_NVML_COMPATIBLE in NvCtrlAttributesPrivate.h up
@@ -1400,10 +1667,6 @@ NvCtrlNvmlGetBinaryAttribute(const CtrlTarget *ctrl_target,
         default:
             return NvCtrlBadHandle;
     }
-
-#else
-    return NvCtrlNotSupported;
-#endif
 }
 
 
@@ -1412,28 +1675,31 @@ NvCtrlNvmlGetBinaryAttribute(const CtrlTarget *ctrl_target,
  * Get NVML Valid String Attribute Values
  */
 
-#ifdef NVML_EXPERIMENTAL
+
 
 static ReturnStatus
 NvCtrlNvmlGetGPUValidStringAttributeValues(int attr,
                                            CtrlAttributeValidValues *val)
 {
     switch (attr) {
+        case NV_CTRL_STRING_NVIDIA_DRIVER_VERSION:
         case NV_CTRL_STRING_PRODUCT_NAME:
         case NV_CTRL_STRING_VBIOS_VERSION:
-        case NV_CTRL_STRING_NVIDIA_DRIVER_VERSION:
+        case NV_CTRL_STRING_GPU_UUID:
+            val->valid_type = CTRL_ATTRIBUTE_VALID_TYPE_STRING;
+            return NvCtrlSuccess;
+
         case NV_CTRL_STRING_SLI_MODE:
         case NV_CTRL_STRING_PERFORMANCE_MODES:
         case NV_CTRL_STRING_MULTIGPU_MODE:
         case NV_CTRL_STRING_GPU_CURRENT_CLOCK_FREQS:
-        case NV_CTRL_STRING_GPU_UUID:
         case NV_CTRL_STRING_GPU_UTILIZATION:
             /*
              * XXX We'll eventually need to add support for this attributes. For
              *     string attributes, NV-CONTROL only sets the attribute type
              *     and permissions so no actual NVML call will be needed.
              */
-            return NvCtrlNotSupported;
+            return NvCtrlAttributeNotAvailable;
 
         default:
             /* The attribute queried is not GPU-targeted */
@@ -1443,25 +1709,54 @@ NvCtrlNvmlGetGPUValidStringAttributeValues(int attr,
     return NvCtrlSuccess;
 }
 
-#endif // NVML_EXPERIMENTAL
+
+
+static ReturnStatus convertValidTypeToAttributeType(CtrlAttributeValidType val,
+                                                   CtrlAttributeType *type)
+{
+    switch (val) {
+        case CTRL_ATTRIBUTE_VALID_TYPE_INTEGER:
+        case CTRL_ATTRIBUTE_VALID_TYPE_BOOL:
+        case CTRL_ATTRIBUTE_VALID_TYPE_BITMASK:
+        case CTRL_ATTRIBUTE_VALID_TYPE_64BIT_INTEGER:
+            *type = CTRL_ATTRIBUTE_TYPE_INTEGER;
+            break;
+        case CTRL_ATTRIBUTE_VALID_TYPE_STRING:
+            *type = CTRL_ATTRIBUTE_TYPE_STRING;
+            break;
+        case CTRL_ATTRIBUTE_VALID_TYPE_STRING_OPERATION:
+            *type = CTRL_ATTRIBUTE_TYPE_STRING_OPERATION;
+            break;
+        case CTRL_ATTRIBUTE_VALID_TYPE_BINARY_DATA:
+            *type = CTRL_ATTRIBUTE_TYPE_BINARY_DATA;
+            break;
+        default:
+            return NvCtrlAttributeNotAvailable;
+    }
+
+    return NvCtrlSuccess;
+}
+
+
 
 ReturnStatus
 NvCtrlNvmlGetValidStringAttributeValues(const CtrlTarget *ctrl_target,
                                         int attr,
                                         CtrlAttributeValidValues *val)
 {
+    const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
+    ReturnStatus ret = NvCtrlAttributeNotAvailable;
+    CtrlAttributeType attr_type;
+
     if (NvmlMissing(ctrl_target)) {
         return NvCtrlMissingExtension;
     }
 
-#ifdef NVML_EXPERIMENTAL
-    ReturnStatus ret;
-    /*
-     * This shouldn't be reached for target types that are not handled through
-     * NVML (Keep TARGET_TYPE_IS_NVML_COMPATIBLE in NvCtrlAttributesPrivate.h up
-     * to date).
-     */
-    assert(TARGET_TYPE_IS_NVML_COMPATIBLE(NvCtrlGetTargetType(ctrl_target)));
+    if (val) {
+        memset(val, 0, sizeof(*val));
+    } else {
+        return NvCtrlBadArgument;
+    }
 
     switch (NvCtrlGetTargetType(ctrl_target)) {
         case GPU_TARGET:
@@ -1479,31 +1774,17 @@ NvCtrlNvmlGetValidStringAttributeValues(const CtrlTarget *ctrl_target,
             break;
     }
 
-    
-    /*
-     * XXX Did we forgot to handle this attribute? - REMOVE THIS after
-     *     nvidia-settings NVML migration work is done
-     */
-    if (ret == NvCtrlAttributeNotAvailable) {
-        const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
-        ReturnStatus ret2;
-
-        if (!h->nv) {
-            return NvCtrlMissingExtension;
-        }
-
-        ret2 = NvCtrlNvControlGetValidStringDisplayAttributeValues(h, 0, attr, val);
+    if (ret == NvCtrlSuccess) {
+        val->valid_type = CTRL_ATTRIBUTE_VALID_TYPE_STRING;
+    }
 
-        assert(ret2 == NvCtrlAttributeNotAvailable);
+    ret = convertValidTypeToAttributeType(val->valid_type, &attr_type);
 
-        return ret2;
+    if (ret != NvCtrlSuccess) {
+        return ret;
     }
 
-    return ret;
-
-#else
-    return NvCtrlNotSupported;
-#endif
+    return NvCtrlNvmlGetAttributePerms(h, attr_type, attr, &val->permissions);
 }
 
 
@@ -1512,7 +1793,7 @@ NvCtrlNvmlGetValidStringAttributeValues(const CtrlTarget *ctrl_target,
  * Get NVML Valid Attribute Values
  */
 
-#ifdef NVML_EXPERIMENTAL
+
 
 static ReturnStatus
 NvCtrlNvmlGetGPUValidAttributeValues(const CtrlTarget *ctrl_target, int attr,
@@ -1523,16 +1804,16 @@ NvCtrlNvmlGetGPUValidAttributeValues(const CtrlTarget *ctrl_target, int attr,
     nvmlDevice_t device;
     nvmlReturn_t ret;
 
-    if ((h == NULL) || (h->nvml == NULL)) {
+    nvml = getNvmlHandleConst(h);
+    if (nvml == NULL) {
         return NvCtrlBadHandle;
     }
 
-    nvml = h->nvml;
+    val->permissions.write = NV_FALSE;
 
     ret = nvml->lib.deviceGetHandleByIndex(nvml->deviceIdx, &device);
     if (ret == NVML_SUCCESS) {
         switch (attr) {
-            case NV_CTRL_VIDEO_RAM:
             case NV_CTRL_TOTAL_DEDICATED_GPU_MEMORY:
             case NV_CTRL_USED_DEDICATED_GPU_MEMORY:
             case NV_CTRL_PCI_DOMAIN:
@@ -1541,29 +1822,46 @@ NvCtrlNvmlGetGPUValidAttributeValues(const CtrlTarget *ctrl_target, int attr,
             case NV_CTRL_PCI_FUNCTION:
             case NV_CTRL_PCI_ID:
             case NV_CTRL_GPU_PCIE_GENERATION:
-            case NV_CTRL_GPU_PCIE_MAX_LINK_WIDTH:
             case NV_CTRL_GPU_PCIE_CURRENT_LINK_WIDTH:
-            case NV_CTRL_GPU_PCIE_MAX_LINK_SPEED:
-            case NV_CTRL_GPU_PCIE_CURRENT_LINK_SPEED:
-            case NV_CTRL_BUS_TYPE:
+            case NV_CTRL_GPU_PCIE_MAX_LINK_WIDTH:
+            case NV_CTRL_GPU_SLOWDOWN_THRESHOLD:
+            case NV_CTRL_GPU_SHUTDOWN_THRESHOLD:
+            case NV_CTRL_GPU_CORE_TEMPERATURE:
             case NV_CTRL_GPU_MEMORY_BUS_WIDTH:
             case NV_CTRL_GPU_CORES:
             case NV_CTRL_IRQ:
-            case NV_CTRL_GPU_COOLER_MANUAL_CONTROL:
             case NV_CTRL_GPU_POWER_SOURCE:
-            case NV_CTRL_GPU_CURRENT_PERFORMANCE_LEVEL:
-            case NV_CTRL_GPU_ADAPTIVE_CLOCK_STATE:
-            case NV_CTRL_GPU_POWER_MIZER_MODE:
-            case NV_CTRL_GPU_POWER_MIZER_DEFAULT_MODE:
-            case NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE:
-            case NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT:
+                val->valid_type = CTRL_ATTRIBUTE_VALID_TYPE_INTEGER;
+                break;
+
             case NV_CTRL_GPU_ECC_SUPPORTED:
             case NV_CTRL_GPU_ECC_STATUS:
             case NV_CTRL_GPU_ECC_CONFIGURATION:
-            case NV_CTRL_GPU_ECC_DEFAULT_CONFIGURATION:
+            case NV_CTRL_GPU_ECC_CONFIGURATION_SUPPORTED:
+                val->valid_type = CTRL_ATTRIBUTE_VALID_TYPE_BOOL;
+                break;
+
+            case NV_CTRL_GPU_ECC_SINGLE_BIT_ERRORS:
+            case NV_CTRL_GPU_ECC_AGGREGATE_SINGLE_BIT_ERRORS:
             case NV_CTRL_GPU_ECC_DOUBLE_BIT_ERRORS:
             case NV_CTRL_GPU_ECC_AGGREGATE_DOUBLE_BIT_ERRORS:
-            case NV_CTRL_GPU_ECC_CONFIGURATION_SUPPORTED:
+                val->valid_type = CTRL_ATTRIBUTE_VALID_TYPE_64BIT_INTEGER;
+                break;
+
+            case NV_CTRL_GPU_ECC_RESET_ERROR_STATUS:
+                val->valid_type = CTRL_ATTRIBUTE_VALID_TYPE_BITMASK;
+                break;
+
+            case NV_CTRL_GPU_ECC_DEFAULT_CONFIGURATION:
+            case NV_CTRL_VIDEO_RAM:
+            case NV_CTRL_GPU_PCIE_MAX_LINK_SPEED:
+            case NV_CTRL_GPU_PCIE_CURRENT_LINK_SPEED:
+            case NV_CTRL_BUS_TYPE:
+            case NV_CTRL_GPU_COOLER_MANUAL_CONTROL:
+            case NV_CTRL_GPU_CURRENT_PERFORMANCE_LEVEL:
+            case NV_CTRL_GPU_ADAPTIVE_CLOCK_STATE:
+            case NV_CTRL_GPU_POWER_MIZER_MODE:
+            case NV_CTRL_GPU_POWER_MIZER_DEFAULT_MODE:
             case NV_CTRL_ENABLED_DISPLAYS:
             case NV_CTRL_CONNECTED_DISPLAYS:
             case NV_CTRL_MAX_SCREEN_WIDTH:
@@ -1578,10 +1876,8 @@ NvCtrlNvmlGetGPUValidAttributeValues(const CtrlTarget *ctrl_target, int attr,
             case NV_CTRL_ATTR_NV_MINOR_VERSION:
             case NV_CTRL_OPERATING_SYSTEM:
             case NV_CTRL_NO_SCANOUT:
-            case NV_CTRL_GPU_CORE_TEMPERATURE:
             case NV_CTRL_AMBIENT_TEMPERATURE:
             case NV_CTRL_GPU_CURRENT_CLOCK_FREQS:
-            case NV_CTRL_GPU_CURRENT_PROCESSOR_CLOCK_FREQS:
             case NV_CTRL_VIDEO_ENCODER_UTILIZATION:
             case NV_CTRL_VIDEO_DECODER_UTILIZATION:
             case NV_CTRL_FRAMELOCK:
@@ -1603,7 +1899,7 @@ NvCtrlNvmlGetGPUValidAttributeValues(const CtrlTarget *ctrl_target, int attr,
                  * XXX We'll eventually need to add support for this attributes
                  *     through NVML
                  */
-                return NvCtrlNotSupported;
+                return NvCtrlAttributeNotAvailable;
 
             default:
                 /* The attribute queried is not GPU-targeted */
@@ -1617,7 +1913,7 @@ NvCtrlNvmlGetGPUValidAttributeValues(const CtrlTarget *ctrl_target, int attr,
 
     /* An NVML error occurred */
     printNvmlError(ret);
-    return NvCtrlNotSupported;
+    return NvCtrlNoAttribute;
 }
 
 static ReturnStatus
@@ -1627,25 +1923,24 @@ NvCtrlNvmlGetThermalValidAttributeValues(const CtrlTarget *ctrl_target,
 {
     const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
     const NvCtrlNvmlAttributes *nvml;
-    int sensorId;
+    int deviceId, sensorId;
     nvmlDevice_t device;
     nvmlReturn_t ret;
 
-    if ((h == NULL) || (h->nvml == NULL)) {
+    nvml = getNvmlHandleConst(h);
+    if (nvml == NULL) {
         return NvCtrlBadHandle;
     }
 
-    nvml = h->nvml;
-
     /* Get the proper device and sensor ID according to the target ID */
-    sensorId = getThermalCoolerId(h, nvml->sensorCount,
-                                  nvml->sensorCountPerGPU);
+    getDeviceAndTargetIndex(h, nvml->sensorCount, nvml->sensorCountPerGPU,
+                            &deviceId, &sensorId);
     if (sensorId == -1) {
         return NvCtrlBadHandle;
     }
 
 
-    ret = nvml->lib.deviceGetHandleByIndex(nvml->deviceIdx, &device);
+    ret = nvml->lib.deviceGetHandleByIndex(deviceId, &device);
     if (ret == NVML_SUCCESS) {
         switch (attr) {
             case NV_CTRL_THERMAL_SENSOR_READING:
@@ -1655,7 +1950,7 @@ NvCtrlNvmlGetThermalValidAttributeValues(const CtrlTarget *ctrl_target,
                  * XXX We'll eventually need to add support for this attributes
                  *     through NVML
                  */
-                return NvCtrlNotSupported;
+                return NvCtrlAttributeNotAvailable;
 
             default:
                 /* The attribute queried is not sensor-targeted */
@@ -1669,7 +1964,7 @@ NvCtrlNvmlGetThermalValidAttributeValues(const CtrlTarget *ctrl_target,
 
     /* An NVML error occurred */
     printNvmlError(ret);
-    return NvCtrlNotSupported;
+    return NvCtrlNoAttribute;
 }
 
 static ReturnStatus
@@ -1679,27 +1974,33 @@ NvCtrlNvmlGetCoolerValidAttributeValues(const CtrlTarget *ctrl_target,
 {
     const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
     const NvCtrlNvmlAttributes *nvml;
-    int coolerId;
+    int deviceId, coolerId;
     nvmlDevice_t device;
     nvmlReturn_t ret;
 
-    if ((h == NULL) || (h->nvml == NULL)) {
+    nvml = getNvmlHandleConst(h);
+    if (nvml == NULL) {
         return NvCtrlBadHandle;
     }
 
-    nvml = h->nvml;
-
     /* Get the proper device and cooler ID according to the target ID */
-    coolerId = getThermalCoolerId(h, nvml->coolerCount,
-                                  nvml->coolerCountPerGPU);
+    getDeviceAndTargetIndex(h, nvml->coolerCount, nvml->coolerCountPerGPU,
+                            &deviceId, &coolerId);
     if (coolerId == -1) {
         return NvCtrlBadHandle;
     }
 
 
-    ret = nvml->lib.deviceGetHandleByIndex(nvml->deviceIdx, &device);
+    ret = nvml->lib.deviceGetHandleByIndex(deviceId, &device);
     if (ret == NVML_SUCCESS) {
         switch (attr) {
+            case NV_CTRL_THERMAL_COOLER_CURRENT_LEVEL:
+                /* Range as a percent */
+                val->valid_type = CTRL_ATTRIBUTE_VALID_TYPE_RANGE;
+                val->range.min = 0;
+                val->range.max = 100;
+                return NvCtrlSuccess;
+
             case NV_CTRL_THERMAL_COOLER_LEVEL:
             case NV_CTRL_THERMAL_COOLER_SPEED:
             case NV_CTRL_THERMAL_COOLER_CONTROL_TYPE:
@@ -1708,7 +2009,7 @@ NvCtrlNvmlGetCoolerValidAttributeValues(const CtrlTarget *ctrl_target,
                  * XXX We'll eventually need to add support for this attributes
                  *     through NVML
                  */
-                return NvCtrlNotSupported;
+                return NvCtrlAttributeNotAvailable;
 
             default:
                 /* The attribute queried is not fan-targeted */
@@ -1722,22 +2023,24 @@ NvCtrlNvmlGetCoolerValidAttributeValues(const CtrlTarget *ctrl_target,
 
     /* An NVML error occurred */
     printNvmlError(ret);
-    return NvCtrlNotSupported;
+    return NvCtrlNoAttribute;
 }
 
-#endif // NVML_EXPERIMENTAL
+
 
 ReturnStatus
 NvCtrlNvmlGetValidAttributeValues(const CtrlTarget *ctrl_target,
                                   int attr,
                                   CtrlAttributeValidValues *val)
 {
+    const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
+    ReturnStatus ret = NvCtrlAttributeNotAvailable;
+    CtrlAttributeType attr_type;
+
     if (NvmlMissing(ctrl_target)) {
         return NvCtrlMissingExtension;
     }
 
-#ifdef NVML_EXPERIMENTAL
-    ReturnStatus ret;
     /*
      * This shouldn't be reached for target types that are not handled through
      * NVML (Keep TARGET_TYPE_IS_NVML_COMPATIBLE in NvCtrlAttributesPrivate.h up
@@ -1768,30 +2071,136 @@ NvCtrlNvmlGetValidAttributeValues(const CtrlTarget *ctrl_target,
             ret = NvCtrlBadHandle;
     }
 
-    
-    /*
-     * XXX Did we forgot to handle this attribute? - REMOVE THIS after
-     *     nvidia-settings NVML migration work is done
-     */
-    if (ret == NvCtrlAttributeNotAvailable) {
-        const NvCtrlAttributePrivateHandle *h = getPrivateHandleConst(ctrl_target);
-        ReturnStatus ret2;
+    if (ret != NvCtrlSuccess) {
+        return ret;
+    }
 
-        if (!h->nv) {
-            return NvCtrlMissingExtension;
-        }
+    ret = convertValidTypeToAttributeType(val->valid_type, &attr_type);
 
-        ret2 = NvCtrlNvControlGetValidAttributeValues(h, 0, attr, val);
+    if (ret != NvCtrlSuccess) {
+        return ret;
+    }
+
+    return NvCtrlNvmlGetAttributePerms(h, attr_type, attr, &val->permissions);
+}
+
+static ReturnStatus NvCtrlNvmlGetIntegerAttributePerms(int attr,
+                                                       CtrlAttributePerms *perms)
+{
+    /* Set write permissions */
+    switch (attr) {
+        case NV_CTRL_GPU_ECC_CONFIGURATION:
+        case NV_CTRL_GPU_ECC_RESET_ERROR_STATUS:
+            perms->write = NV_TRUE;
+            break;
+        default:
+            perms->write = NV_FALSE;
+    }
+
+    /* Valid target and read permissions */
+    switch (attr) {
+        case NV_CTRL_TOTAL_DEDICATED_GPU_MEMORY:
+        case NV_CTRL_USED_DEDICATED_GPU_MEMORY:
+        case NV_CTRL_PCI_DOMAIN:
+        case NV_CTRL_PCI_BUS:
+        case NV_CTRL_PCI_DEVICE:
+        case NV_CTRL_PCI_FUNCTION:
+        case NV_CTRL_PCI_ID:
+        case NV_CTRL_GPU_PCIE_GENERATION:
+        case NV_CTRL_GPU_PCIE_CURRENT_LINK_WIDTH:
+        case NV_CTRL_GPU_PCIE_MAX_LINK_WIDTH:
+        case NV_CTRL_GPU_SLOWDOWN_THRESHOLD:
+        case NV_CTRL_GPU_SHUTDOWN_THRESHOLD:
+        case NV_CTRL_GPU_CORE_TEMPERATURE:
+        case NV_CTRL_GPU_MEMORY_BUS_WIDTH:
+        case NV_CTRL_GPU_CORES:
+        case NV_CTRL_IRQ:
+        case NV_CTRL_GPU_POWER_SOURCE:
+        /* CTRL_ATTRIBUTE_VALID_TYPE_BOOL */
+        case NV_CTRL_GPU_ECC_SUPPORTED:
+        case NV_CTRL_GPU_ECC_CONFIGURATION_SUPPORTED:
+        case NV_CTRL_GPU_ECC_STATUS:
+        case NV_CTRL_GPU_ECC_CONFIGURATION:
+        /* CTRL_ATTRIBUTE_VALID_TYPE_64BIT_INTEGER */
+        case NV_CTRL_GPU_ECC_SINGLE_BIT_ERRORS:
+        case NV_CTRL_GPU_ECC_AGGREGATE_SINGLE_BIT_ERRORS:
+        case NV_CTRL_GPU_ECC_DOUBLE_BIT_ERRORS:
+        case NV_CTRL_GPU_ECC_AGGREGATE_DOUBLE_BIT_ERRORS:
+            perms->read = NV_TRUE;
+            perms->valid_targets = CTRL_TARGET_PERM_BIT(GPU_TARGET);
+            break;
+
+        /* GPU_TARGET non-readable attribute */
+        case NV_CTRL_GPU_ECC_RESET_ERROR_STATUS:
+            perms->read  = NV_FALSE;
+            perms->valid_targets = CTRL_TARGET_PERM_BIT(GPU_TARGET);
+            break;
 
-        assert(ret2 == NvCtrlAttributeNotAvailable);
+        case NV_CTRL_THERMAL_COOLER_CURRENT_LEVEL:
+            perms->valid_targets = CTRL_TARGET_PERM_BIT(COOLER_TARGET);
+            perms->read = NV_TRUE;
+            break;
 
-        return ret2;
+        default:
+            perms->valid_targets = 0;
+            perms->read = NV_FALSE;
+            return NvCtrlNotSupported;
+    }
+
+    return NvCtrlSuccess;
+}
+
+static ReturnStatus NvCtrlNvmlGetStringAttributePerms(int attr,
+                                                      CtrlAttributePerms *perms)
+{
+    perms->write = NV_FALSE;
+
+    switch (attr) {
+        case NV_CTRL_STRING_NVIDIA_DRIVER_VERSION:
+        case NV_CTRL_STRING_PRODUCT_NAME:
+        case NV_CTRL_STRING_VBIOS_VERSION:
+        case NV_CTRL_STRING_GPU_UUID:
+            perms->valid_targets = CTRL_TARGET_PERM_BIT(GPU_TARGET);
+            perms->read = NV_TRUE;
+            break;
+        default:
+            perms->valid_targets = 0;
+            perms->read = NV_FALSE;
+            return NvCtrlNotSupported;
+    }
+    return NvCtrlSuccess;
+}
+
+
+ReturnStatus
+NvCtrlNvmlGetAttributePerms(const NvCtrlAttributePrivateHandle *h,
+                            CtrlAttributeType attr_type, int attr,
+                            CtrlAttributePerms *perms)
+{
+    ReturnStatus ret = NvCtrlSuccess;
+
+    if (!h->nvml) {
+        return NvCtrlBadArgument;
+    }
+
+    switch (attr_type) {
+        case CTRL_ATTRIBUTE_TYPE_INTEGER:
+            ret = NvCtrlNvmlGetIntegerAttributePerms(attr, perms);
+            break;
+
+        case CTRL_ATTRIBUTE_TYPE_STRING:
+            ret = NvCtrlNvmlGetStringAttributePerms(attr, perms);
+            break;
+
+        case CTRL_ATTRIBUTE_TYPE_BINARY_DATA:
+            return NvCtrlBadArgument;
+            break;
+
+        default:
+            return NvCtrlBadArgument;
     }
 
     return ret;
 
-#else
-        return NvCtrlNotSupported;
-#endif
 }
 
diff --git a/src/libXNVCtrlAttributes/NvCtrlAttributesPrivate.h b/src/libXNVCtrlAttributes/NvCtrlAttributesPrivate.h
index 51d538c..d93e207 100644
--- a/src/libXNVCtrlAttributes/NvCtrlAttributesPrivate.h
+++ b/src/libXNVCtrlAttributes/NvCtrlAttributesPrivate.h
@@ -85,7 +85,8 @@
 #define TARGET_TYPE_IS_NVML_COMPATIBLE(_TARGET_TYPE_) \
     (((_TARGET_TYPE_) == GPU_TARGET) ||               \
      ((_TARGET_TYPE_) == THERMAL_SENSOR_TARGET) ||    \
-     ((_TARGET_TYPE_) == COOLER_TARGET))
+     ((_TARGET_TYPE_) == COOLER_TARGET) ||            \
+     ((_TARGET_TYPE_) == MUX_TARGET))
 
 #define TARGET_TYPE_NEEDS_NVCONTROL(_TARGET_TYPE_)     \
     (!(TARGET_TYPE_IS_NVML_COMPATIBLE(_TARGET_TYPE_)))
@@ -169,15 +170,31 @@ struct __NvCtrlNvmlAttributes {
         typeof(nvmlDeviceGetUUID)                       (*deviceGetUUID);
         typeof(nvmlDeviceGetCount)                      (*deviceGetCount);
         typeof(nvmlDeviceGetTemperature)                (*deviceGetTemperature);
-        typeof(nvmlDeviceGetFanSpeed)                   (*deviceGetFanSpeed);
         typeof(nvmlDeviceGetName)                       (*deviceGetName);
         typeof(nvmlDeviceGetVbiosVersion)               (*deviceGetVbiosVersion);
         typeof(nvmlDeviceGetMemoryInfo)                 (*deviceGetMemoryInfo);
+        typeof(nvmlDeviceGetMemoryInfo_v2)              (*deviceGetMemoryInfo_v2);
         typeof(nvmlDeviceGetPciInfo)                    (*deviceGetPciInfo);
+        typeof(nvmlDeviceGetCurrPcieLinkWidth)          (*deviceGetCurrPcieLinkWidth);
         typeof(nvmlDeviceGetMaxPcieLinkGeneration)      (*deviceGetMaxPcieLinkGeneration);
         typeof(nvmlDeviceGetMaxPcieLinkWidth)           (*deviceGetMaxPcieLinkWidth);
         typeof(nvmlDeviceGetVirtualizationMode)         (*deviceGetVirtualizationMode);
-        typeof(nvmlDeviceGetGridLicensableFeatures_v3)  (*deviceGetGridLicensableFeatures);
+        typeof(nvmlDeviceGetGridLicensableFeatures_v4)  (*deviceGetGridLicensableFeatures);
+        typeof(nvmlDeviceGetUtilizationRates)           (*deviceGetUtilizationRates);
+        typeof(nvmlDeviceGetTemperatureThreshold)       (*deviceGetTemperatureThreshold);
+        typeof(nvmlDeviceGetFanSpeed_v2)                (*deviceGetFanSpeed_v2);
+        typeof(nvmlSystemGetDriverVersion)              (*systemGetDriverVersion);
+        typeof(nvmlDeviceGetEccMode)                    (*deviceGetEccMode);
+        typeof(nvmlDeviceSetEccMode)                    (*deviceSetEccMode);
+        typeof(nvmlDeviceGetTotalEccErrors)             (*deviceGetTotalEccErrors);
+        typeof(nvmlDeviceClearEccErrorCounts)           (*deviceClearEccErrorCounts);
+        typeof(nvmlDeviceGetMemoryErrorCounter)         (*deviceGetMemoryErrorCounter);
+        typeof(nvmlSystemGetNVMLVersion)                (*systemGetNVMLVersion);
+        typeof(nvmlDeviceGetNumGpuCores)                (*deviceGetNumGpuCores);
+        typeof(nvmlDeviceGetMemoryBusWidth)             (*deviceGetMemoryBusWidth);
+        typeof(nvmlDeviceGetIrqNum)                     (*deviceGetIrqNum);
+        typeof(nvmlDeviceGetPowerSource)                (*deviceGetPowerSource);
+        typeof(nvmlDeviceGetNumFans)                    (*deviceGetNumFans);
 
     } lib;
 
@@ -456,4 +473,9 @@ NvCtrlNvmlGetValidAttributeValues(const CtrlTarget *ctrl_target,
                                   int attr,
                                   CtrlAttributeValidValues *val);
 
+ReturnStatus
+NvCtrlNvmlGetAttributePerms(const NvCtrlAttributePrivateHandle *,
+                            CtrlAttributeType, int,
+                            CtrlAttributePerms *);
+
 #endif /* __NVCTRL_ATTRIBUTES_PRIVATE__ */
diff --git a/src/libXNVCtrlAttributes/NvCtrlAttributesUtils.c b/src/libXNVCtrlAttributes/NvCtrlAttributesUtils.c
index f1cd2e5..111b24c 100644
--- a/src/libXNVCtrlAttributes/NvCtrlAttributesUtils.c
+++ b/src/libXNVCtrlAttributes/NvCtrlAttributesUtils.c
@@ -505,7 +505,9 @@ static void add_target_relationships(CtrlTarget *target,
     status = NvCtrlGetBinaryAttribute(target, 0, attr,
                                       (unsigned char **)(&pData), &len);
     if ((status != NvCtrlSuccess) || !pData) {
-        nv_error_msg("Error querying target relations");
+        if (status != NvCtrlNotSupported) {
+            nv_error_msg("Error querying target relations");
+        }
         return;
     }
 
@@ -673,7 +675,7 @@ static CtrlTarget *nv_alloc_ctrl_target(CtrlSystem *system,
      * not being specified in xorg.conf, it can cause errors down the line.
      */
 
-    if (target_type == GPU_TARGET) {
+    if (target_type == GPU_TARGET && t->system->has_nv_control) {
         /* NV_CTRL_DEPTH_30_ALLOWED expected to succeed for any valid device */
         status = NvCtrlGetAttribute(t, NV_CTRL_DEPTH_30_ALLOWED, &d);
         if (status != NvCtrlSuccess) {
@@ -733,7 +735,7 @@ static CtrlTarget *nv_alloc_ctrl_target(CtrlSystem *system,
      * (framelock), we just assign this to 0.
      */
 
-    if (targetTypeInfo->uses_display_devices) {
+    if (targetTypeInfo->uses_display_devices && system->has_nv_control) {
 
         status = NvCtrlGetAttribute(t,
                                     NV_CTRL_ENABLED_DISPLAYS, &d);
@@ -817,6 +819,16 @@ static Bool is_nvcontrol_protocol_valid(const CtrlTarget *ctrl_target,
 }
 
 
+static const char *get_display_name(CtrlSystem *system)
+{
+    if (system->has_nv_control) {
+        return XDisplayName(system->display);
+    } else {
+        return system->display;
+    }
+}
+
+
 static Bool load_system_info(CtrlSystem *system, const char *display)
 {
     ReturnStatus status;
@@ -826,6 +838,8 @@ static Bool load_system_info(CtrlSystem *system, const char *display)
     int unused;
     int *pData = NULL;
     const CtrlTargetTypeInfo *targetTypeInfo;
+    int subsystems = NV_CTRL_ATTRIBUTES_NV_CONTROL_SUBSYSTEM |
+                     NV_CTRL_ATTRIBUTES_NVML_SUBSYSTEM;
 
     if (!system) {
         return FALSE;
@@ -841,19 +855,19 @@ static Bool load_system_info(CtrlSystem *system, const char *display)
     system->dpy = XOpenDisplay(system->display);
 
     if (system->dpy == NULL) {
-        nv_error_msg("Unable to find display on any available system");
-        return FALSE;
+        /* If it fails, just use NVML */
+        subsystems = NV_CTRL_ATTRIBUTES_NVML_SUBSYSTEM;
+    } else {
+        system->has_nv_control =
+            XNVCTRLQueryExtension(system->dpy, &unused, &unused);
     }
 
-    system->has_nv_control =
-        XNVCTRLQueryExtension(system->dpy, &unused, &unused);
-
     /* Try to initialize the NVML library */
-    nvmlQueryTarget = nv_alloc_ctrl_target(system, GPU_TARGET, 0,
-                                   NV_CTRL_ATTRIBUTES_NV_CONTROL_SUBSYSTEM |
-                                   NV_CTRL_ATTRIBUTES_NVML_SUBSYSTEM);
+    nvmlQueryTarget = nv_alloc_ctrl_target(system, GPU_TARGET, 0, subsystems);
 
-    if (nvmlQueryTarget == NULL) {
+    system->has_nvml = (nvmlQueryTarget != NULL);
+
+    if (system->has_nvml == FALSE) {
         nv_error_msg("Unable to load info from any available system");
         return FALSE;
     }
@@ -883,6 +897,16 @@ static Bool load_system_info(CtrlSystem *system, const char *display)
                 target_count = ScreenCount(system->dpy);
             }
         }
+        else if (target_type == MUX_TARGET) {
+
+            status = NvCtrlQueryTargetCount(nvmlQueryTarget,
+                                            target_type,
+                                            &val);
+            if (status == NvCtrlSuccess) {
+                target_count = val;
+            }
+
+        }
         else if ((h != NULL) && (h->nvml != NULL) &&
                  TARGET_TYPE_IS_NVML_COMPATIBLE(target_type)) {
 
@@ -942,7 +966,7 @@ static Bool load_system_info(CtrlSystem *system, const char *display)
                 nv_warning_msg("Unable to determine number of NVIDIA "
                                "%ss on '%s'.",
                                targetTypeInfo->name,
-                               XDisplayName(system->display));
+                               get_display_name(system));
                 val = 0;
             }
 
@@ -966,6 +990,7 @@ static Bool load_system_info(CtrlSystem *system, const char *display)
             case COOLER_TARGET:
             case THERMAL_SENSOR_TARGET:
             case NVIDIA_3D_VISION_PRO_TRANSCEIVER_TARGET:
+            case MUX_TARGET:
             default:
                 targetId = i;
             }
@@ -1017,7 +1042,7 @@ static Bool load_system_info(CtrlSystem *system, const char *display)
 
     if (status != NvCtrlSuccess) {
         nv_warning_msg("Unable to determine number of NVIDIA %ss on '%s'.",
-                       targetTypeInfo->name, XDisplayName(system->display));
+                       targetTypeInfo->name, get_display_name(system));
         val = 0;
     }
 
diff --git a/src/nvidia-settings.c b/src/nvidia-settings.c
index 75a5a28..da4cab8 100644
--- a/src/nvidia-settings.c
+++ b/src/nvidia-settings.c
@@ -367,7 +367,7 @@ int main(int argc, char **argv)
 
     system = NvCtrlGetSystem(op->ctrl_display, &systems);
 
-    if (!system || !system->dpy) {
+    if (!system) {
         return 1;
     }
 
diff --git a/src/nvml.h b/src/nvml.h
index 58de790..073aa61 100644
--- a/src/nvml.h
+++ b/src/nvml.h
@@ -1,42 +1,42 @@
 /*
- * Copyright 1993-2020 NVIDIA Corporation.  All rights reserved.
+ * Copyright 1993-2021 NVIDIA Corporation.  All rights reserved.
  *
- * NOTICE TO USER:   
+ * NOTICE TO USER:
  *
- * This source code is subject to NVIDIA ownership rights under U.S. and 
- * international Copyright laws.  Users and possessors of this source code 
- * are hereby granted a nonexclusive, royalty-free license to use this code 
+ * This source code is subject to NVIDIA ownership rights under U.S. and
+ * international Copyright laws.  Users and possessors of this source code
+ * are hereby granted a nonexclusive, royalty-free license to use this code
  * in individual and commercial software.
  *
- * NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE 
- * CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR 
- * IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH 
- * REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF 
+ * NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE
+ * CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR
+ * IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
- * IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, 
- * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS 
- * OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
- * OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE 
- * OR PERFORMANCE OF THIS SOURCE CODE.  
- *
- * U.S. Government End Users.   This source code is a "commercial item" as 
- * that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of 
- * "commercial computer  software"  and "commercial computer software 
- * documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995) 
- * and is provided to the U.S. Government only as a commercial end item.  
- * Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through 
- * 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the 
- * source code with only those rights set forth herein. 
- *
- * Any use of this source code in individual and commercial software must 
+ * IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
+ * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+ * OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE
+ * OR PERFORMANCE OF THIS SOURCE CODE.
+ *
+ * U.S. Government End Users.   This source code is a "commercial item" as
+ * that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of
+ * "commercial computer  software"  and "commercial computer software
+ * documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995)
+ * and is provided to the U.S. Government only as a commercial end item.
+ * Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through
+ * 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the
+ * source code with only those rights set forth herein.
+ *
+ * Any use of this source code in individual and commercial software must
  * include, in the user documentation and internal comments to the code,
  * the above Disclaimer and U.S. Government End Users Notice.
  */
 
-/* 
+/*
 NVML API Reference
 
-The NVIDIA Management Library (NVML) is a C-based programmatic interface for monitoring and 
+The NVIDIA Management Library (NVML) is a C-based programmatic interface for monitoring and
 managing various states within NVIDIA Tesla &tm; GPUs. It is intended to be a platform for building
 3rd party applications, and is also the underlying library for the NVIDIA-supported nvidia-smi
 tool. NVML is thread-safe so it is safe to make simultaneous NVML calls from multiple threads.
@@ -58,7 +58,7 @@ Supported products:
     - All Geforce products, starting with the Fermi architecture
 
 The NVML library can be found at \%ProgramW6432\%\\"NVIDIA Corporation"\\NVSMI\\ on Windows. It is
-not be added to the system path by default. To dynamically link to NVML, add this path to the PATH 
+not be added to the system path by default. To dynamically link to NVML, add this path to the PATH
 environmental variable. To dynamically load NVML, call LoadLibrary with this path.
 
 On Linux the NVML library will be found on the standard library path. For 64 bit Linux, both the 32 bit
@@ -103,21 +103,30 @@ extern "C" {
  * guard if you need to support older versions of the API
  */
 #ifndef NVML_NO_UNVERSIONED_FUNC_DEFS
-    #define nvmlInit                                nvmlInit_v2
-    #define nvmlDeviceGetPciInfo                    nvmlDeviceGetPciInfo_v3
-    #define nvmlDeviceGetCount                      nvmlDeviceGetCount_v2
-    #define nvmlDeviceGetHandleByIndex              nvmlDeviceGetHandleByIndex_v2
-    #define nvmlDeviceGetHandleByPciBusId           nvmlDeviceGetHandleByPciBusId_v2
-    #define nvmlDeviceGetNvLinkRemotePciInfo        nvmlDeviceGetNvLinkRemotePciInfo_v2
-    #define nvmlDeviceRemoveGpu                     nvmlDeviceRemoveGpu_v2
-    #define nvmlDeviceGetGridLicensableFeatures     nvmlDeviceGetGridLicensableFeatures_v3
-    #define nvmlEventSetWait                        nvmlEventSetWait_v2
-    #define nvmlDeviceGetAttributes                 nvmlDeviceGetAttributes_v2
-    #define nvmlComputeInstanceGetInfo              nvmlComputeInstanceGetInfo_v2
-    #define nvmlDeviceGetComputeRunningProcesses    nvmlDeviceGetComputeRunningProcesses_v2
-    #define nvmlDeviceGetGraphicsRunningProcesses   nvmlDeviceGetGraphicsRunningProcesses_v2
+    #define nvmlInit                                    nvmlInit_v2
+    #define nvmlDeviceGetPciInfo                        nvmlDeviceGetPciInfo_v3
+    #define nvmlDeviceGetCount                          nvmlDeviceGetCount_v2
+    #define nvmlDeviceGetHandleByIndex                  nvmlDeviceGetHandleByIndex_v2
+    #define nvmlDeviceGetHandleByPciBusId               nvmlDeviceGetHandleByPciBusId_v2
+    #define nvmlDeviceGetNvLinkRemotePciInfo            nvmlDeviceGetNvLinkRemotePciInfo_v2
+    #define nvmlDeviceRemoveGpu                         nvmlDeviceRemoveGpu_v2
+    #define nvmlDeviceGetGridLicensableFeatures         nvmlDeviceGetGridLicensableFeatures_v4
+    #define nvmlEventSetWait                            nvmlEventSetWait_v2
+    #define nvmlDeviceGetAttributes                     nvmlDeviceGetAttributes_v2
+    #define nvmlComputeInstanceGetInfo                  nvmlComputeInstanceGetInfo_v2
+    #define nvmlDeviceGetComputeRunningProcesses        nvmlDeviceGetComputeRunningProcesses_v3
+    #define nvmlDeviceGetGraphicsRunningProcesses       nvmlDeviceGetGraphicsRunningProcesses_v3
+    #define nvmlDeviceGetMPSComputeRunningProcesses     nvmlDeviceGetMPSComputeRunningProcesses_v3
+    #define nvmlBlacklistDeviceInfo_t                   nvmlExcludedDeviceInfo_t
+    #define nvmlGetBlacklistDeviceCount                 nvmlGetExcludedDeviceCount
+    #define nvmlGetBlacklistDeviceInfoByIndex           nvmlGetExcludedDeviceInfoByIndex
+    #define nvmlDeviceGetGpuInstancePossiblePlacements  nvmlDeviceGetGpuInstancePossiblePlacements_v2
+    #define nvmlVgpuInstanceGetLicenseInfo              nvmlVgpuInstanceGetLicenseInfo_v2
 #endif // #ifndef NVML_NO_UNVERSIONED_FUNC_DEFS
 
+#define NVML_STRUCT_VERSION(data, ver) (unsigned int)(sizeof(nvml ## data ## _v ## ver ## _t) | \
+                                                      (ver << 24U))
+
 /***************************************************************************************************/
 /** @defgroup nvmlDeviceStructs Device Structs
  *  @{
@@ -184,7 +193,7 @@ typedef struct nvmlPciInfo_st
  * @deprecated  Different GPU families can have different memory error counters
  *              See \ref nvmlDeviceGetMemoryErrorCounter
  */
-typedef struct nvmlEccErrorCounts_st 
+typedef struct nvmlEccErrorCounts_st
 {
     unsigned long long l1Cache;      //!< L1 cache errors
     unsigned long long l2Cache;      //!< L2 cache errors
@@ -192,26 +201,45 @@ typedef struct nvmlEccErrorCounts_st
     unsigned long long registerFile; //!< Register file errors
 } nvmlEccErrorCounts_t;
 
-/** 
+/**
  * Utilization information for a device.
  * Each sample period may be between 1 second and 1/6 second, depending on the product being queried.
  */
-typedef struct nvmlUtilization_st 
+typedef struct nvmlUtilization_st
 {
     unsigned int gpu;                //!< Percent of time over the past sample period during which one or more kernels was executing on the GPU
     unsigned int memory;             //!< Percent of time over the past sample period during which global (device) memory was being read or written
 } nvmlUtilization_t;
 
-/** 
- * Memory allocation information for a device.
+/**
+ * Memory allocation information for a device (v1).
+ * The total amount is equal to the sum of the amounts of free and used memory.
  */
-typedef struct nvmlMemory_st 
+typedef struct nvmlMemory_st
 {
-    unsigned long long total;        //!< Total installed FB memory (in bytes)
-    unsigned long long free;         //!< Unallocated FB memory (in bytes)
-    unsigned long long used;         //!< Allocated FB memory (in bytes). Note that the driver/GPU always sets aside a small amount of memory for bookkeeping
+    unsigned long long total;        //!< Total physical device memory (in bytes)
+    unsigned long long free;         //!< Unallocated device memory (in bytes)
+    unsigned long long used;         //!< Sum of Reserved and Allocated device memory (in bytes).
+                                     //!< Note that the driver/GPU always sets aside a small amount of memory for bookkeeping
 } nvmlMemory_t;
 
+/**
+ * Memory allocation information for a device (v2).
+ * 
+ * Version 2 adds versioning for the struct and the amount of system-reserved memory as an output.
+ * @note The \ref nvmlMemory_v2_t.used amount also includes the \ref nvmlMemory_v2_t.reserved amount.
+ */
+typedef struct nvmlMemory_v2_st
+{
+    unsigned int version;            //!< Structure format version (must be 2)
+    unsigned long long total;        //!< Total physical device memory (in bytes)
+    unsigned long long reserved;     //!< Device memory (in bytes) reserved for system use (driver or firmware)
+    unsigned long long free;         //!< Unallocated device memory (in bytes)
+    unsigned long long used;         //!< Allocated device memory (in bytes). Note that the driver/GPU always sets aside a small amount of memory for bookkeeping
+} nvmlMemory_v2_t;
+
+#define nvmlMemory_v2 NVML_STRUCT_VERSION(Memory, 2)
+
 /**
  * BAR1 Memory allocation Information for a device
  */
@@ -222,8 +250,36 @@ typedef struct nvmlBAR1Memory_st
     unsigned long long bar1Used;     //!< Allocated Used Memory (in bytes)
 }nvmlBAR1Memory_t;
 
+/**
+ * Information about running compute processes on the GPU, legacy version
+ * for older versions of the API.
+ */
+typedef struct nvmlProcessInfo_v1_st
+{
+    unsigned int        pid;                //!< Process ID
+    unsigned long long  usedGpuMemory;      //!< Amount of used GPU memory in bytes.
+                                            //! Under WDDM, \ref NVML_VALUE_NOT_AVAILABLE is always reported
+                                            //! because Windows KMD manages all the memory and not the NVIDIA driver
+} nvmlProcessInfo_v1_t;
+
+/**
+ * Information about running compute processes on the GPU
+ */
+typedef struct nvmlProcessInfo_v2_st
+{
+    unsigned int        pid;                //!< Process ID
+    unsigned long long  usedGpuMemory;      //!< Amount of used GPU memory in bytes.
+                                            //! Under WDDM, \ref NVML_VALUE_NOT_AVAILABLE is always reported
+                                            //! because Windows KMD manages all the memory and not the NVIDIA driver
+    unsigned int        gpuInstanceId;      //!< If MIG is enabled, stores a valid GPU instance ID. gpuInstanceId is set to
+                                            //  0xFFFFFFFF otherwise.
+    unsigned int        computeInstanceId;  //!< If MIG is enabled, stores a valid compute instance ID. computeInstanceId is set to
+                                            //  0xFFFFFFFF otherwise.
+} nvmlProcessInfo_v2_t;
+
 /**
  * Information about running compute processes on the GPU
+ * Version 2 adds versioning for the struct and the conf compute protected memory in output.
  */
 typedef struct nvmlProcessInfo_st
 {
@@ -271,11 +327,11 @@ typedef struct nvmlRowRemapperHistogramValues_st
 typedef enum nvmlBridgeChipType_enum
 {
     NVML_BRIDGE_CHIP_PLX = 0,
-    NVML_BRIDGE_CHIP_BRO4 = 1           
+    NVML_BRIDGE_CHIP_BRO4 = 1
 }nvmlBridgeChipType_t;
 
 /**
- * Maximum number of NvLink links supported 
+ * Maximum number of NvLink links supported
  */
 #define NVML_NVLINK_MAX_LINKS 12
 
@@ -297,7 +353,7 @@ typedef enum nvmlNvLinkUtilizationCountUnits_enum
  *  ** this is ONLY applicable with the units as packets or bytes
  *  ** as specified in \a nvmlNvLinkUtilizationCountUnits_t
  *  ** all packet filter descriptions are target GPU centric
- *  ** these can be "OR'd" together 
+ *  ** these can be "OR'd" together
  */
 typedef enum nvmlNvLinkUtilizationCountPktTypes_enum
 {
@@ -312,7 +368,7 @@ typedef enum nvmlNvLinkUtilizationCountPktTypes_enum
     NVML_NVLINK_COUNTER_PKTFILTER_ALL        = 0xFF     // all packets
 } nvmlNvLinkUtilizationCountPktTypes_t;
 
-/** 
+/**
  * Struct to define the NVLINK counter controls
  */
 typedef struct nvmlNvLinkUtilizationControl_st
@@ -351,6 +407,17 @@ typedef enum nvmlNvLinkErrorCounter_enum
     NVML_NVLINK_ERROR_COUNT
 } nvmlNvLinkErrorCounter_t;
 
+/**
+ * Enum to represent NvLink's remote device type
+ */
+typedef enum nvmlIntNvLinkDeviceType_enum
+{
+    NVML_NVLINK_DEVICE_TYPE_GPU     = 0x00,
+    NVML_NVLINK_DEVICE_TYPE_IBMNPU  = 0x01,
+    NVML_NVLINK_DEVICE_TYPE_SWITCH  = 0x02,
+    NVML_NVLINK_DEVICE_TYPE_UNKNOWN = 0xFF
+} nvmlIntNvLinkDeviceType_t;
+
 /**
  * Represents level relationships within a system between two GPUs
  * The enums are spaced to allow for future relationships
@@ -362,7 +429,7 @@ typedef enum nvmlGpuLevel_enum
     NVML_TOPOLOGY_MULTIPLE           = 20, // all devices that need not traverse a host bridge
     NVML_TOPOLOGY_HOSTBRIDGE         = 30, // all devices that are connected to the same host bridge
     NVML_TOPOLOGY_NODE               = 40, // all devices that are connected to the same NUMA node but possibly multiple host bridges
-    NVML_TOPOLOGY_SYSTEM             = 50, // all devices in the system
+    NVML_TOPOLOGY_SYSTEM             = 50  // all devices in the system
 
     // there is purposefully no COUNT here because of the need for spacing above
 } nvmlGpuTopologyLevel_t;
@@ -404,12 +471,12 @@ typedef enum nvmlGpuP2PCapsIndex_enum
  */
 typedef struct nvmlBridgeChipInfo_st
 {
-    nvmlBridgeChipType_t type;                  //!< Type of Bridge Chip 
+    nvmlBridgeChipType_t type;                  //!< Type of Bridge Chip
     unsigned int fwVersion;                     //!< Firmware Version. 0=Version is unavailable
 }nvmlBridgeChipInfo_t;
 
 /**
- * This structure stores the complete Hierarchy of the Bridge Chip within the board. The immediate 
+ * This structure stores the complete Hierarchy of the Bridge Chip within the board. The immediate
  * bridge is stored at index 0 of bridgeInfoList, parent to immediate bridge is at index 1 and so forth.
  */
 typedef struct nvmlBridgeChipHierarchy_st
@@ -427,12 +494,12 @@ typedef enum nvmlSamplingType_enum
     NVML_GPU_UTILIZATION_SAMPLES    = 1, //!< To represent percent of time during which one or more kernels was executing on the GPU
     NVML_MEMORY_UTILIZATION_SAMPLES = 2, //!< To represent percent of time during which global (device) memory was being read or written
     NVML_ENC_UTILIZATION_SAMPLES    = 3, //!< To represent percent of time during which NVENC remains busy
-    NVML_DEC_UTILIZATION_SAMPLES    = 4, //!< To represent percent of time during which NVDEC remains busy            
+    NVML_DEC_UTILIZATION_SAMPLES    = 4, //!< To represent percent of time during which NVDEC remains busy
     NVML_PROCESSOR_CLK_SAMPLES      = 5, //!< To represent processor clock samples
     NVML_MEMORY_CLK_SAMPLES         = 6, //!< To represent memory clock samples
-            
+
     // Keep this last
-    NVML_SAMPLINGTYPE_COUNT               
+    NVML_SAMPLINGTYPE_COUNT
 }nvmlSamplingType_t;
 
 /**
@@ -442,7 +509,7 @@ typedef enum nvmlPcieUtilCounter_enum
 {
     NVML_PCIE_UTIL_TX_BYTES             = 0, // 1KB granularity
     NVML_PCIE_UTIL_RX_BYTES             = 1, // 1KB granularity
-    
+
     // Keep this last
     NVML_PCIE_UTIL_COUNT
 } nvmlPcieUtilCounter_t;
@@ -450,7 +517,7 @@ typedef enum nvmlPcieUtilCounter_enum
 /**
  * Represents the type for sample value returned
  */
-typedef enum nvmlValueType_enum 
+typedef enum nvmlValueType_enum
 {
     NVML_VALUE_TYPE_DOUBLE = 0,
     NVML_VALUE_TYPE_UNSIGNED_INT = 1,
@@ -478,14 +545,14 @@ typedef union nvmlValue_st
 /**
  * Information for Sample
  */
-typedef struct nvmlSample_st 
+typedef struct nvmlSample_st
 {
     unsigned long long timeStamp;       //!< CPU Timestamp in microseconds
     nvmlValue_t sampleValue;        //!< Sample Value
 }nvmlSample_t;
 
 /**
- * Represents type of perf policy for which violation times can be queried 
+ * Represents type of perf policy for which violation times can be queried
  */
 typedef enum nvmlPerfPolicyType_enum
 {
@@ -520,42 +587,43 @@ typedef struct nvmlViolationTime_st
  */
 /***************************************************************************************************/
 
-/** 
- * Generic enable/disable enum. 
+/**
+ * Generic enable/disable enum.
  */
-typedef enum nvmlEnableState_enum 
+typedef enum nvmlEnableState_enum
 {
-    NVML_FEATURE_DISABLED    = 0,     //!< Feature disabled 
+    NVML_FEATURE_DISABLED    = 0,     //!< Feature disabled
     NVML_FEATURE_ENABLED     = 1      //!< Feature enabled
 } nvmlEnableState_t;
 
 //! Generic flag used to specify the default behavior of some functions. See description of particular functions for details.
-#define nvmlFlagDefault     0x00      
+#define nvmlFlagDefault     0x00
 //! Generic flag used to force some behavior. See description of particular functions for details.
-#define nvmlFlagForce       0x01      
+#define nvmlFlagForce       0x01
 
 /**
  *  * The Brand of the GPU
  *   */
 typedef enum nvmlBrandType_enum
 {
-    NVML_BRAND_UNKNOWN          = 0, 
-    NVML_BRAND_QUADRO           = 1,
-    NVML_BRAND_TESLA            = 2,
-    NVML_BRAND_NVS              = 3,
-    NVML_BRAND_GRID             = 4,   // Deprecated from API reporting. Keeping definition for backward compatibility.
-    NVML_BRAND_GEFORCE          = 5,
-    NVML_BRAND_TITAN            = 6,
-    NVML_BRAND_NVIDIA_VAPPS     = 7,   // NVIDIA Virtual Applications
-    NVML_BRAND_NVIDIA_VPC       = 8,   // NVIDIA Virtual PC
-    NVML_BRAND_NVIDIA_VCS       = 9,   // NVIDIA Virtual Compute Server
-    NVML_BRAND_NVIDIA_VWS       = 10,  // NVIDIA RTX Virtual Workstation
-    NVML_BRAND_NVIDIA_VGAMING   = 11,  // NVIDIA vGaming
-    NVML_BRAND_QUADRO_RTX       = 12,
-    NVML_BRAND_NVIDIA_RTX       = 13,
-    NVML_BRAND_NVIDIA           = 14,
-    NVML_BRAND_GEFORCE_RTX      = 15,  // Unused
-    NVML_BRAND_TITAN_RTX        = 16,  // Unused
+    NVML_BRAND_UNKNOWN              = 0,
+    NVML_BRAND_QUADRO               = 1,
+    NVML_BRAND_TESLA                = 2,
+    NVML_BRAND_NVS                  = 3,
+    NVML_BRAND_GRID                 = 4,   // Deprecated from API reporting. Keeping definition for backward compatibility.
+    NVML_BRAND_GEFORCE              = 5,
+    NVML_BRAND_TITAN                = 6,
+    NVML_BRAND_NVIDIA_VAPPS         = 7,   // NVIDIA Virtual Applications
+    NVML_BRAND_NVIDIA_VPC           = 8,   // NVIDIA Virtual PC
+    NVML_BRAND_NVIDIA_VCS           = 9,   // NVIDIA Virtual Compute Server
+    NVML_BRAND_NVIDIA_VWS           = 10,  // NVIDIA RTX Virtual Workstation
+    NVML_BRAND_NVIDIA_CLOUD_GAMING  = 11,  // NVIDIA Cloud Gaming
+    NVML_BRAND_NVIDIA_VGAMING       = NVML_BRAND_NVIDIA_CLOUD_GAMING,  // Deprecated from API reporting. Keeping definition for backward compatibility.
+    NVML_BRAND_QUADRO_RTX           = 12,
+    NVML_BRAND_NVIDIA_RTX           = 13,
+    NVML_BRAND_NVIDIA               = 14,
+    NVML_BRAND_GEFORCE_RTX          = 15,  // Unused
+    NVML_BRAND_TITAN_RTX            = 16,  // Unused
 
     // Keep this last
     NVML_BRAND_COUNT
@@ -584,35 +652,75 @@ typedef enum nvmlTemperatureThresholds_enum
     NVML_TEMPERATURE_THRESHOLD_COUNT
 } nvmlTemperatureThresholds_t;
 
-/** 
- * Temperature sensors. 
+/**
+ * Temperature sensors.
  */
-typedef enum nvmlTemperatureSensors_enum 
+typedef enum nvmlTemperatureSensors_enum
 {
     NVML_TEMPERATURE_GPU      = 0,    //!< Temperature sensor for the GPU die
-    
+
     // Keep this last
     NVML_TEMPERATURE_COUNT
 } nvmlTemperatureSensors_t;
 
-/** 
- * Compute mode. 
+/**
+ * Compute mode.
  *
  * NVML_COMPUTEMODE_EXCLUSIVE_PROCESS was added in CUDA 4.0.
- * Earlier CUDA versions supported a single exclusive mode, 
+ * Earlier CUDA versions supported a single exclusive mode,
  * which is equivalent to NVML_COMPUTEMODE_EXCLUSIVE_THREAD in CUDA 4.0 and beyond.
  */
-typedef enum nvmlComputeMode_enum 
+typedef enum nvmlComputeMode_enum
 {
     NVML_COMPUTEMODE_DEFAULT           = 0,  //!< Default compute mode -- multiple contexts per device
     NVML_COMPUTEMODE_EXCLUSIVE_THREAD  = 1,  //!< Support Removed
     NVML_COMPUTEMODE_PROHIBITED        = 2,  //!< Compute-prohibited mode -- no contexts per device
     NVML_COMPUTEMODE_EXCLUSIVE_PROCESS = 3,  //!< Compute-exclusive-process mode -- only one context per device, usable from multiple threads at a time
-    
+
     // Keep this last
     NVML_COMPUTEMODE_COUNT
 } nvmlComputeMode_t;
 
+/**
+ * Max Clock Monitors available
+ */
+#define MAX_CLK_DOMAINS			32
+
+/**
+ * Clock Monitor error types
+ */
+typedef struct nvmlClkMonFaultInfo_struct {
+    /**
+     * The Domain which faulted
+     */
+    unsigned int   clkApiDomain;
+
+    /**
+     * Faults Information
+     */
+    unsigned int   clkDomainFaultMask;
+} nvmlClkMonFaultInfo_t;
+
+/**
+ * Clock Monitor Status
+ */
+typedef struct nvmlClkMonStatus_status {
+    /**
+     * Fault status Indicator
+     */
+    unsigned int  bGlobalStatus;
+
+    /**
+     * Total faulted domain numbers
+     */
+    unsigned int   clkMonListSize;
+
+    /**
+     * The fault Information structure
+     */
+    nvmlClkMonFaultInfo_t clkMonList[MAX_CLK_DOMAINS];
+} nvmlClkMonStatus_t;
+
 /** 
  * ECC bit types.
  *
@@ -641,54 +749,54 @@ typedef enum nvmlMemoryErrorType_enum
 {
     /**
      * A memory error that was corrected
-     * 
+     *
      * For ECC errors, these are single bit errors
      * For Texture memory, these are errors fixed by resend
      */
     NVML_MEMORY_ERROR_TYPE_CORRECTED = 0,
     /**
      * A memory error that was not corrected
-     * 
+     *
      * For ECC errors, these are double bit errors
      * For Texture memory, these are errors where the resend fails
      */
     NVML_MEMORY_ERROR_TYPE_UNCORRECTED = 1,
-    
-    
+
+
     // Keep this last
     NVML_MEMORY_ERROR_TYPE_COUNT //!< Count of memory error types
 
 } nvmlMemoryErrorType_t;
 
-/** 
- * ECC counter types. 
+/**
+ * ECC counter types.
  *
  * Note: Volatile counts are reset each time the driver loads. On Windows this is once per boot. On Linux this can be more frequent.
- *       On Linux the driver unloads when no active clients exist. If persistence mode is enabled or there is always a driver 
+ *       On Linux the driver unloads when no active clients exist. If persistence mode is enabled or there is always a driver
  *       client active (e.g. X11), then Linux also sees per-boot behavior. If not, volatile counts are reset each time a compute app
  *       is run.
  */
-typedef enum nvmlEccCounterType_enum 
+typedef enum nvmlEccCounterType_enum
 {
     NVML_VOLATILE_ECC      = 0,      //!< Volatile counts are reset each time the driver loads.
     NVML_AGGREGATE_ECC     = 1,      //!< Aggregate counts persist across reboots (i.e. for the lifetime of the device)
-    
+
     // Keep this last
     NVML_ECC_COUNTER_TYPE_COUNT      //!< Count of memory counter types
 } nvmlEccCounterType_t;
 
-/** 
- * Clock types. 
- * 
+/**
+ * Clock types.
+ *
  * All speeds are in Mhz.
  */
-typedef enum nvmlClockType_enum 
+typedef enum nvmlClockType_enum
 {
     NVML_CLOCK_GRAPHICS  = 0,        //!< Graphics clock domain
     NVML_CLOCK_SM        = 1,        //!< SM clock domain
     NVML_CLOCK_MEM       = 2,        //!< Memory clock domain
     NVML_CLOCK_VIDEO     = 3,        //!< Video encoder/decoder clock domain
-    
+
     // Keep this last
     NVML_CLOCK_COUNT //!< Count of clock types
 } nvmlClockType_t;
@@ -708,12 +816,12 @@ typedef enum nvmlClockId_enum
     NVML_CLOCK_ID_COUNT //!< Count of Clock Ids.
 } nvmlClockId_t;
 
-/** 
- * Driver models. 
+/**
+ * Driver models.
  *
  * Windows only.
  */
-typedef enum nvmlDriverModel_enum 
+typedef enum nvmlDriverModel_enum
 {
     NVML_DRIVER_WDDM      = 0,       //!< WDDM driver model -- GPU treated as a display device
     NVML_DRIVER_WDM       = 1        //!< WDM (TCC) model (recommended) -- GPU treated as a generic device
@@ -722,10 +830,10 @@ typedef enum nvmlDriverModel_enum
 /**
  * Allowed PStates.
  */
-typedef enum nvmlPStates_enum 
+typedef enum nvmlPStates_enum
 {
     NVML_PSTATE_0               = 0,       //!< Performance state 0 -- Maximum Performance
-    NVML_PSTATE_1               = 1,       //!< Performance state 1 
+    NVML_PSTATE_1               = 1,       //!< Performance state 1
     NVML_PSTATE_2               = 2,       //!< Performance state 2
     NVML_PSTATE_3               = 3,       //!< Performance state 3
     NVML_PSTATE_4               = 4,       //!< Performance state 4
@@ -739,7 +847,7 @@ typedef enum nvmlPStates_enum
     NVML_PSTATE_12              = 12,      //!< Performance state 12
     NVML_PSTATE_13              = 13,      //!< Performance state 13
     NVML_PSTATE_14              = 14,      //!< Performance state 14
-    NVML_PSTATE_15              = 15,      //!< Performance state 15 -- Minimum Performance 
+    NVML_PSTATE_15              = 15,      //!< Performance state 15 -- Minimum Performance
     NVML_PSTATE_UNKNOWN         = 32       //!< Unknown performance state
 } nvmlPstates_t;
 
@@ -761,10 +869,10 @@ typedef enum nvmlGom_enum
                                             //!< high bandwidth double precision
 } nvmlGpuOperationMode_t;
 
-/** 
+/**
  * Available infoROM objects.
  */
-typedef enum nvmlInforomObject_enum 
+typedef enum nvmlInforomObject_enum
 {
     NVML_INFOROM_OEM            = 0,       //!< An object defined by OEM
     NVML_INFOROM_ECC            = 1,       //!< The ECC object determining the level of ECC support
@@ -774,10 +882,10 @@ typedef enum nvmlInforomObject_enum
     NVML_INFOROM_COUNT                     //!< This counts the number of infoROM objects the driver knows about
 } nvmlInforomObject_t;
 
-/** 
- * Return values for NVML API calls. 
+/**
+ * Return values for NVML API calls.
  */
-typedef enum nvmlReturn_enum 
+typedef enum nvmlReturn_enum
 {
     // cppcheck-suppress *
     NVML_SUCCESS = 0,                        //!< The operation was successful
@@ -804,6 +912,7 @@ typedef enum nvmlReturn_enum
     NVML_ERROR_NO_DATA = 21,                 //!< No data
     NVML_ERROR_VGPU_ECC_NOT_SUPPORTED = 22,  //!< The requested vgpu operation is not available on target device, becasue ECC is enabled
     NVML_ERROR_INSUFFICIENT_RESOURCES = 23,  //!< Ran out of critical resources, other than memory
+    NVML_ERROR_FREQ_NOT_SUPPORTED = 24,  //!< Ran out of critical resources, other than memory
     NVML_ERROR_UNKNOWN = 999                 //!< An internal driver error occurred
 } nvmlReturn_t;
 
@@ -842,7 +951,7 @@ typedef enum nvmlPageRetirementCause_enum
  */
 typedef enum nvmlRestrictedAPI_enum
 {
-    NVML_RESTRICTED_API_SET_APPLICATION_CLOCKS = 0,   //!< APIs that change application clocks, see nvmlDeviceSetApplicationsClocks 
+    NVML_RESTRICTED_API_SET_APPLICATION_CLOCKS = 0,   //!< APIs that change application clocks, see nvmlDeviceSetApplicationsClocks
                                                       //!< and see nvmlDeviceResetApplicationsClocks
     NVML_RESTRICTED_API_SET_AUTO_BOOSTED_CLOCKS = 1,  //!< APIs that enable/disable Auto Boosted clocks
                                                       //!< see nvmlDeviceSetAutoBoostedClocksEnabled
@@ -884,7 +993,7 @@ typedef enum nvmlGpuVirtualizationMode {
     NVML_GPU_VIRTUALIZATION_MODE_PASSTHROUGH = 1,  //!< Device is associated with GPU-Passthorugh
     NVML_GPU_VIRTUALIZATION_MODE_VGPU = 2,  //!< Device is associated with vGPU inside virtual machine.
     NVML_GPU_VIRTUALIZATION_MODE_HOST_VGPU = 3,  //!< Device is associated with VGX hypervisor in vGPU mode
-    NVML_GPU_VIRTUALIZATION_MODE_HOST_VSGA = 4,  //!< Device is associated with VGX hypervisor in vSGA mode
+    NVML_GPU_VIRTUALIZATION_MODE_HOST_VSGA = 4   //!< Device is associated with VGX hypervisor in vSGA mode
 } nvmlGpuVirtualizationMode_t;
 
 /**
@@ -901,16 +1010,16 @@ typedef enum nvmlHostVgpuMode_enum
  */
 typedef enum nvmlVgpuVmIdType {
     NVML_VGPU_VM_ID_DOMAIN_ID = 0, //!< VM ID represents DOMAIN ID
-    NVML_VGPU_VM_ID_UUID = 1,      //!< VM ID represents UUID
+    NVML_VGPU_VM_ID_UUID = 1       //!< VM ID represents UUID
 } nvmlVgpuVmIdType_t;
 
 /**
- * vGPU GUEST info state.
+ * vGPU GUEST info state
  */
 typedef enum nvmlVgpuGuestInfoState_enum
 {
     NVML_VGPU_INSTANCE_GUEST_INFO_STATE_UNINITIALIZED = 0,  //!< Guest-dependent fields uninitialized
-    NVML_VGPU_INSTANCE_GUEST_INFO_STATE_INITIALIZED   = 1,  //!< Guest-dependent fields initialized
+    NVML_VGPU_INSTANCE_GUEST_INFO_STATE_INITIALIZED   = 1   //!< Guest-dependent fields initialized
 } nvmlVgpuGuestInfoState_t;
 
 /**
@@ -925,6 +1034,26 @@ typedef enum {
     NVML_GRID_LICENSE_FEATURE_CODE_COMPUTE      = 4                                          //!< Compute
 } nvmlGridLicenseFeatureCode_t;
 
+/**
+ * Status codes for license expiry
+ */
+#define NVML_GRID_LICENSE_EXPIRY_NOT_AVAILABLE   0   //!< Expiry information not available
+#define NVML_GRID_LICENSE_EXPIRY_INVALID         1   //!< Invalid expiry or error fetching expiry
+#define NVML_GRID_LICENSE_EXPIRY_VALID           2   //!< Valid expiry
+#define NVML_GRID_LICENSE_EXPIRY_NOT_APPLICABLE  3   //!< Expiry not applicable
+#define NVML_GRID_LICENSE_EXPIRY_PERMANENT       4   //!< Permanent expiry
+
+/**
+ * vGPU queryable capabilities
+ */
+typedef enum nvmlVgpuCapability_enum
+{
+    NVML_VGPU_CAP_NVLINK_P2P                    = 0,  //!< P2P over NVLink is supported
+    NVML_VGPU_CAP_GPUDIRECT                     = 1,  //!< GPUDirect capability is supported
+    // Keep this last
+    NVML_VGPU_CAP_COUNT
+} nvmlVgpuCapability_t;
+
 /** @} */
 
 /***************************************************************************************************/
@@ -978,12 +1107,12 @@ typedef unsigned int nvmlVgpuInstance_t;
  */
 typedef struct nvmlVgpuInstanceUtilizationSample_st
 {
-    nvmlVgpuInstance_t vgpuInstance;    //!< vGPU Instance
-    unsigned long long timeStamp;       //!< CPU Timestamp in microseconds
-    nvmlValue_t smUtil;                 //!< SM (3D/Compute) Util Value
-    nvmlValue_t memUtil;                //!< Frame Buffer Memory Util Value
-    nvmlValue_t encUtil;                //!< Encoder Util Value
-    nvmlValue_t decUtil;                //!< Decoder Util Value
+    nvmlVgpuInstance_t  vgpuInstance;       //!< vGPU Instance
+    unsigned long long  timeStamp;          //!< CPU Timestamp in microseconds
+    nvmlValue_t         smUtil;             //!< SM (3D/Compute) Util Value
+    nvmlValue_t         memUtil;            //!< Frame Buffer Memory Util Value
+    nvmlValue_t         encUtil;            //!< Encoder Util Value
+    nvmlValue_t         decUtil;            //!< Decoder Util Value
 } nvmlVgpuInstanceUtilizationSample_t;
 
 /**
@@ -991,29 +1120,74 @@ typedef struct nvmlVgpuInstanceUtilizationSample_st
  */
 typedef struct nvmlVgpuProcessUtilizationSample_st
 {
-    nvmlVgpuInstance_t vgpuInstance;                //!< vGPU Instance
-    unsigned int pid;                               //!< PID of process running within the vGPU VM
-    char processName[NVML_VGPU_NAME_BUFFER_SIZE];   //!< Name of process running within the vGPU VM
-    unsigned long long timeStamp;                   //!< CPU Timestamp in microseconds
-    unsigned int smUtil;                            //!< SM (3D/Compute) Util Value
-    unsigned int memUtil;                           //!< Frame Buffer Memory Util Value
-    unsigned int encUtil;                           //!< Encoder Util Value
-    unsigned int decUtil;                           //!< Decoder Util Value
+    nvmlVgpuInstance_t  vgpuInstance;                               //!< vGPU Instance
+    unsigned int        pid;                                        //!< PID of process running within the vGPU VM
+    char                processName[NVML_VGPU_NAME_BUFFER_SIZE];    //!< Name of process running within the vGPU VM
+    unsigned long long  timeStamp;                                  //!< CPU Timestamp in microseconds
+    unsigned int        smUtil;                                     //!< SM (3D/Compute) Util Value
+    unsigned int        memUtil;                                    //!< Frame Buffer Memory Util Value
+    unsigned int        encUtil;                                    //!< Encoder Util Value
+    unsigned int        decUtil;                                    //!< Decoder Util Value
 } nvmlVgpuProcessUtilizationSample_t;
 
+/**
+ * Structure to store the vGPU license expiry details
+ */
+typedef struct nvmlVgpuLicenseExpiry_st
+{
+    unsigned int    year;        //!< Year of license expiry
+    unsigned short  month;       //!< Month of license expiry
+    unsigned short  day;         //!< Day of license expiry
+    unsigned short  hour;        //!< Hour of license expiry
+    unsigned short  min;         //!< Minutes of license expiry
+    unsigned short  sec;         //!< Seconds of license expiry
+    unsigned char   status;      //!< License expiry status
+} nvmlVgpuLicenseExpiry_t;
+
+/**
+ * vGPU license state
+ */
+#define NVML_GRID_LICENSE_STATE_UNKNOWN                 0   //!< Unknown state
+#define NVML_GRID_LICENSE_STATE_UNINITIALIZED           1   //!< Uninitialized state
+#define NVML_GRID_LICENSE_STATE_UNLICENSED_UNRESTRICTED 2   //!< Unlicensed unrestricted state
+#define NVML_GRID_LICENSE_STATE_UNLICENSED_RESTRICTED   3   //!< Unlicensed restricted state
+#define NVML_GRID_LICENSE_STATE_UNLICENSED              4   //!< Unlicensed state
+#define NVML_GRID_LICENSE_STATE_LICENSED                5   //!< Licensed state
+
+typedef struct nvmlVgpuLicenseInfo_st
+{
+    unsigned char               isLicensed;     //!< License status
+    nvmlVgpuLicenseExpiry_t     licenseExpiry;  //!< License expiry information
+    unsigned int                currentState;   //!< Current license state
+} nvmlVgpuLicenseInfo_t;
+
 /**
  * Structure to store utilization value and process Id
  */
 typedef struct nvmlProcessUtilizationSample_st
 {
-    unsigned int pid;                   //!< PID of process
-    unsigned long long timeStamp;       //!< CPU Timestamp in microseconds
-    unsigned int smUtil;                //!< SM (3D/Compute) Util Value
-    unsigned int memUtil;               //!< Frame Buffer Memory Util Value
-    unsigned int encUtil;               //!< Encoder Util Value
-    unsigned int decUtil;               //!< Decoder Util Value
+    unsigned int        pid;            //!< PID of process
+    unsigned long long  timeStamp;      //!< CPU Timestamp in microseconds
+    unsigned int        smUtil;         //!< SM (3D/Compute) Util Value
+    unsigned int        memUtil;        //!< Frame Buffer Memory Util Value
+    unsigned int        encUtil;        //!< Encoder Util Value
+    unsigned int        decUtil;        //!< Decoder Util Value
 } nvmlProcessUtilizationSample_t;
 
+/**
+ * Structure to store license expiry date and time values
+ */
+typedef struct nvmlGridLicenseExpiry_st
+{
+    unsigned int   year;        //!< Year value of license expiry
+    unsigned short month;       //!< Month value of license expiry
+    unsigned short day;         //!< Day value of license expiry
+    unsigned short hour;        //!< Hour value of license expiry
+    unsigned short min;         //!< Minutes value of license expiry
+    unsigned short sec;         //!< Seconds value of license expiry
+    unsigned char  status;      //!< License expiry status
+} nvmlGridLicenseExpiry_t;
+
 /**
  * Structure containing vGPU software licensable feature information
  */
@@ -1022,8 +1196,9 @@ typedef struct nvmlGridLicensableFeature_st
     nvmlGridLicenseFeatureCode_t    featureCode;                                 //!< Licensed feature code
     unsigned int                    featureState;                                //!< Non-zero if feature is currently licensed, otherwise zero
     char                            licenseInfo[NVML_GRID_LICENSE_BUFFER_SIZE];  //!< Deprecated.
-    char                            productName[NVML_GRID_LICENSE_BUFFER_SIZE];
+    char                            productName[NVML_GRID_LICENSE_BUFFER_SIZE];  //!< Product name of feature
     unsigned int                    featureEnabled;                              //!< Non-zero if feature is enabled, otherwise zero
+    nvmlGridLicenseExpiry_t         licenseExpiry;                               //!< License expiry structure containing date and time
 } nvmlGridLicensableFeature_t;
 
 /**
@@ -1051,6 +1226,41 @@ typedef struct nvmlGridLicensableFeatures_st
 
 typedef unsigned int nvmlDeviceArchitecture_t;
 
+/**
+ * PCI bus types
+ */
+#define NVML_BUS_TYPE_UNKNOWN  0
+#define NVML_BUS_TYPE_PCI      1
+#define NVML_BUS_TYPE_PCIE     2
+#define NVML_BUS_TYPE_FPCI     3
+#define NVML_BUS_TYPE_AGP      4
+
+typedef unsigned int nvmlBusType_t;
+
+/**
+ * Device Power Source
+ */
+#define NVML_POWER_SOURCE_AC      0x00000000
+#define NVML_POWER_SOURCE_BATTERY 0x00000001
+
+typedef unsigned int nvmlPowerSource_t;
+
+/*
+ * Device PCIE link Max Speed
+ */
+#define NVML_PCIE_LINK_MAX_SPEED_INVALID   0x00000000
+#define NVML_PCIE_LINK_MAX_SPEED_2500MBPS  0x00000001
+#define NVML_PCIE_LINK_MAX_SPEED_5000MBPS  0x00000002
+#define NVML_PCIE_LINK_MAX_SPEED_8000MBPS  0x00000003
+#define NVML_PCIE_LINK_MAX_SPEED_16000MBPS 0x00000004
+#define NVML_PCIE_LINK_MAX_SPEED_32000MBPS 0x00000005
+
+/*
+ * Adaptive clocking status
+ */
+#define NVML_ADAPTIVE_CLOCKING_INFO_STATUS_DISABLED 0x00000000
+#define NVML_ADAPTIVE_CLOCKING_INFO_STATUS_ENABLED  0x00000001
+
 /** @} */
 /** @} */
 
@@ -1336,47 +1546,47 @@ typedef struct nvmlFieldValue_st
 
 typedef struct nvmlUnit_st* nvmlUnit_t;
 
-/** 
- * Description of HWBC entry 
+/**
+ * Description of HWBC entry
  */
-typedef struct nvmlHwbcEntry_st 
+typedef struct nvmlHwbcEntry_st
 {
     unsigned int hwbcId;
     char firmwareVersion[32];
 } nvmlHwbcEntry_t;
 
-/** 
- * Fan state enum. 
+/**
+ * Fan state enum.
  */
-typedef enum nvmlFanState_enum 
+typedef enum nvmlFanState_enum
 {
     NVML_FAN_NORMAL       = 0,     //!< Fan is working properly
     NVML_FAN_FAILED       = 1      //!< Fan has failed
 } nvmlFanState_t;
 
-/** 
- * Led color enum. 
+/**
+ * Led color enum.
  */
-typedef enum nvmlLedColor_enum 
+typedef enum nvmlLedColor_enum
 {
     NVML_LED_COLOR_GREEN       = 0,     //!< GREEN, indicates good health
     NVML_LED_COLOR_AMBER       = 1      //!< AMBER, indicates problem
 } nvmlLedColor_t;
 
 
-/** 
+/**
  * LED states for an S-class unit.
  */
-typedef struct nvmlLedState_st 
+typedef struct nvmlLedState_st
 {
     char cause[256];               //!< If amber, a text description of the cause
     nvmlLedColor_t color;          //!< GREEN or AMBER
 } nvmlLedState_t;
 
-/** 
+/**
  * Static S-class unit info.
  */
-typedef struct nvmlUnitInfo_st 
+typedef struct nvmlUnitInfo_st
 {
     char name[96];                      //!< Product name
     char id[96];                        //!< Product identifier
@@ -1384,11 +1594,11 @@ typedef struct nvmlUnitInfo_st
     char firmwareVersion[96];           //!< Firmware version
 } nvmlUnitInfo_t;
 
-/** 
+/**
  * Power usage information for an S-class unit.
  * The power supply state is a human readable string that equals "Normal" or contains
  * a combination of "Abnormal" plus one or more of the following:
- *    
+ *
  *    - High voltage
  *    - Fan failure
  *    - Heatsink temperature
@@ -1397,9 +1607,9 @@ typedef struct nvmlUnitInfo_st
  *    - Low-voltage
  *    - SI2C remote off command
  *    - MOD_DISABLE input
- *    - Short pin transition 
+ *    - Short pin transition
 */
-typedef struct nvmlPSUInfo_st 
+typedef struct nvmlPSUInfo_st
 {
     char state[256];                 //!< The power supply state
     unsigned int current;            //!< PSU current (A)
@@ -1407,19 +1617,19 @@ typedef struct nvmlPSUInfo_st
     unsigned int power;              //!< PSU power draw (W)
 } nvmlPSUInfo_t;
 
-/** 
+/**
  * Fan speed reading for a single fan in an S-class unit.
  */
-typedef struct nvmlUnitFanInfo_st 
+typedef struct nvmlUnitFanInfo_st
 {
     unsigned int speed;              //!< Fan speed (RPM)
     nvmlFanState_t state;            //!< Flag that indicates whether fan is working properly
 } nvmlUnitFanInfo_t;
 
-/** 
+/**
  * Fan speed readings for an entire S-class unit.
  */
-typedef struct nvmlUnitFanSpeeds_st 
+typedef struct nvmlUnitFanSpeeds_st
 {
     nvmlUnitFanInfo_t fans[24];      //!< Fan speed data for each fan
     unsigned int count;              //!< Number of fans in unit
@@ -1428,12 +1638,12 @@ typedef struct nvmlUnitFanSpeeds_st
 /** @} */
 
 /***************************************************************************************************/
-/** @addtogroup nvmlEvents 
+/** @addtogroup nvmlEvents
  *  @{
  */
 /***************************************************************************************************/
 
-/** 
+/**
  * Handle to an event set
  */
 typedef struct nvmlEventSet_st* nvmlEventSet_t;
@@ -1443,7 +1653,7 @@ typedef struct nvmlEventSet_st* nvmlEventSet_t;
  * Event Types which user can be notified about.
  * See description of particular functions for details.
  *
- * See \ref nvmlDeviceRegisterEvents and \ref nvmlDeviceGetSupportedEventTypes to check which devices 
+ * See \ref nvmlDeviceRegisterEvents and \ref nvmlDeviceGetSupportedEventTypes to check which devices
  * support each event.
  *
  * Types can be combined with bitwise or operator '|' when passed to \ref nvmlDeviceRegisterEvents
@@ -1498,7 +1708,7 @@ typedef struct nvmlEventSet_st* nvmlEventSet_t;
         )
 /** @} */
 
-/** 
+/**
  * Information about occurred event
  */
 typedef struct nvmlEventData_st
@@ -1535,13 +1745,13 @@ typedef struct nvmlEventData_st
  */
 #define nvmlClocksThrottleReasonApplicationsClocksSetting 0x0000000000000002LL
 
-/** 
- * @deprecated Renamed to \ref nvmlClocksThrottleReasonApplicationsClocksSetting 
+/**
+ * @deprecated Renamed to \ref nvmlClocksThrottleReasonApplicationsClocksSetting
  *             as the name describes the situation more accurately.
  */
-#define nvmlClocksThrottleReasonUserDefinedClocks         nvmlClocksThrottleReasonApplicationsClocksSetting 
+#define nvmlClocksThrottleReasonUserDefinedClocks         nvmlClocksThrottleReasonApplicationsClocksSetting
 
-/** SW Power Scaling algorithm is reducing the clocks below requested clocks 
+/** SW Power Scaling algorithm is reducing the clocks below requested clocks
  *
  * @see nvmlDeviceGetPowerUsage
  * @see nvmlDeviceSetPowerManagementLimit
@@ -1550,7 +1760,7 @@ typedef struct nvmlEventData_st
 #define nvmlClocksThrottleReasonSwPowerCap                0x0000000000000004LL
 
 /** HW Slowdown (reducing the core clocks by a factor of 2 or more) is engaged
- * 
+ *
  * This is an indicator of:
  *   - temperature being too high
  *   - External Power Brake Assertion is triggered (e.g. by the system power supply)
@@ -1585,7 +1795,7 @@ typedef struct nvmlEventData_st
 #define nvmlClocksThrottleReasonSwThermalSlowdown         0x0000000000000020LL
 
 /** HW Thermal Slowdown (reducing the core clocks by a factor of 2 or more) is engaged
- * 
+ *
  * This is an indicator of:
  *   - temperature being too high
  *
@@ -1596,7 +1806,7 @@ typedef struct nvmlEventData_st
 #define nvmlClocksThrottleReasonHwThermalSlowdown         0x0000000000000040LL
 
 /** HW Power Brake Slowdown (reducing the core clocks by a factor of 2 or more) is engaged
- * 
+ *
  * This is an indicator of:
  *   - External Power Brake Assertion being triggered (e.g. by the system power supply)
  *
@@ -1618,7 +1828,7 @@ typedef struct nvmlEventData_st
  * */
 #define nvmlClocksThrottleReasonNone                      0x0000000000000000LL
 
-/** Bit mask representing all supported clocks throttling reasons 
+/** Bit mask representing all supported clocks throttling reasons
  * New reasons might be added to this list in the future
  */
 #define nvmlClocksThrottleReasonAll (nvmlClocksThrottleReasonNone \
@@ -1640,7 +1850,7 @@ typedef struct nvmlEventData_st
  *
  *  Set of APIs designed to provide per process information about usage of GPU.
  *
- *  @note All accounting statistics and accounting mode live in nvidia driver and reset 
+ *  @note All accounting statistics and accounting mode live in nvidia driver and reset
  *        to default (Disabled) when driver unloads.
  *        It is advised to run with persistence mode enabled.
  *
@@ -1656,19 +1866,19 @@ typedef struct nvmlAccountingStats_st {
                                                 //! Utilization stats just like returned by \ref nvmlDeviceGetUtilizationRates but for the life time of a
                                                 //! process (not just the last sample period).
                                                 //! Set to NVML_VALUE_NOT_AVAILABLE if nvmlDeviceGetUtilizationRates is not supported
-    
+
     unsigned int memoryUtilization;             //!< Percent of time over the process's lifetime during which global (device) memory was being read or written.
                                                 //! Set to NVML_VALUE_NOT_AVAILABLE if nvmlDeviceGetUtilizationRates is not supported
-    
+
     unsigned long long maxMemoryUsage;          //!< Maximum total memory in bytes that was ever allocated by the process.
                                                 //! Set to NVML_VALUE_NOT_AVAILABLE if nvmlProcessInfo_t->usedGpuMemory is not supported
-    
 
-    unsigned long long time;                    //!< Amount of time in ms during which the compute context was active. The time is reported as 0 if 
+
+    unsigned long long time;                    //!< Amount of time in ms during which the compute context was active. The time is reported as 0 if
                                                 //!< the process is not terminated
-    
+
     unsigned long long startTime;               //!< CPU Timestamp in usec representing start time for the process
-    
+
     unsigned int isRunning;                     //!< Flag to represent if the process is running (1 for running, 0 for terminated)
 
     unsigned int reserved[5];                   //!< Reserved for future use
@@ -1688,7 +1898,7 @@ typedef struct nvmlAccountingStats_st {
 typedef enum nvmlEncoderQueryType_enum
 {
     NVML_ENCODER_QUERY_H264 = 0,        //!< H264 encoder
-    NVML_ENCODER_QUERY_HEVC = 1,        //!< HEVC encoder
+    NVML_ENCODER_QUERY_HEVC = 1         //!< HEVC encoder
 }nvmlEncoderType_t;
 
 /**
@@ -1723,7 +1933,7 @@ typedef enum nvmlFBCSessionType_enum
     NVML_FBC_SESSION_TYPE_TOSYS,           //!< ToSys
     NVML_FBC_SESSION_TYPE_CUDA,            //!< Cuda
     NVML_FBC_SESSION_TYPE_VID,             //!< Vid
-    NVML_FBC_SESSION_TYPE_HWENC,           //!< HEnc
+    NVML_FBC_SESSION_TYPE_HWENC            //!< HEnc
 } nvmlFBCSessionType_t;
 
 /**
@@ -1775,7 +1985,7 @@ typedef struct nvmlFBCSessionInfo_st
 typedef enum nvmlDetachGpuState_enum
 {
     NVML_DETACH_GPU_KEEP         = 0,
-    NVML_DETACH_GPU_REMOVE,
+    NVML_DETACH_GPU_REMOVE
 } nvmlDetachGpuState_t;
 
 /**
@@ -1784,7 +1994,7 @@ typedef enum nvmlDetachGpuState_enum
 typedef enum nvmlPcieLinkState_enum
 {
     NVML_PCIE_LINK_KEEP         = 0,
-    NVML_PCIE_LINK_SHUT_DOWN,
+    NVML_PCIE_LINK_SHUT_DOWN
 } nvmlPcieLinkState_t;
 
 /** @} */
@@ -1792,7 +2002,7 @@ typedef enum nvmlPcieLinkState_enum
 /***************************************************************************************************/
 /** @defgroup nvmlInitializationAndCleanup Initialization and Cleanup
  * This chapter describes the methods that handle NVML initialization and cleanup.
- * It is the user's responsibility to call \ref nvmlInit_v2() before calling any other methods, and 
+ * It is the user's responsibility to call \ref nvmlInit_v2() before calling any other methods, and
  * nvmlShutdown() once NVML is no longer being used.
  *  @{
  */
@@ -1808,21 +2018,21 @@ typedef enum nvmlPcieLinkState_enum
  *       modifying the behaviour of nvmlInit().
  * \note In NVML 5.319 new nvmlInit_v2 has replaced nvmlInit"_v1" (default in NVML 4.304 and older) that
  *       did initialize all GPU devices in the system.
- *       
+ *
  * This allows NVML to communicate with a GPU
  * when other GPUs in the system are unstable or in a bad state.  When using this API, GPUs are
  * discovered and initialized in nvmlDeviceGetHandleBy* functions instead.
- * 
+ *
  * \note To contrast nvmlInit_v2 with nvmlInit"_v1", NVML 4.304 nvmlInit"_v1" will fail when any detected GPU is in
  *       a bad or unstable state.
- * 
+ *
  * For all products.
  *
  * This method, should be called once before invoking any other methods in the library.
  * A reference count of the number of initializations is maintained.  Shutdown only occurs
  * when the reference count reaches zero.
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                   if NVML has been properly initialized
  *         - \ref NVML_ERROR_DRIVER_NOT_LOADED   if NVIDIA driver is not running
  *         - \ref NVML_ERROR_NO_PERMISSION       if NVML does not have permission to talk to the driver
@@ -1834,12 +2044,12 @@ nvmlReturn_t DECLDIR nvmlInit_v2(void);
  * nvmlInitWithFlags is a variant of nvmlInit(), that allows passing a set of boolean values
  *       modifying the behaviour of nvmlInit().
  *       Other than the "flags" parameter it is completely similar to \ref nvmlInit_v2.
- *       
+ *
  * For all products.
  *
  * @param flags                                 behaviour modifier flags
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                   if NVML has been properly initialized
  *         - \ref NVML_ERROR_DRIVER_NOT_LOADED   if NVIDIA driver is not running
  *         - \ref NVML_ERROR_NO_PERMISSION       if NVML does not have permission to talk to the driver
@@ -1849,15 +2059,15 @@ nvmlReturn_t DECLDIR nvmlInitWithFlags(unsigned int flags);
 
 /**
  * Shut down NVML by releasing all GPU resources previously allocated with \ref nvmlInit_v2().
- * 
+ *
  * For all products.
  *
  * This method should be called after NVML work is done, once for each call to \ref nvmlInit_v2()
  * A reference count of the number of initializations is maintained.  Shutdown only occurs
  * when the reference count reaches zero.  For backwards compatibility, no error is reported if
  * nvmlShutdown() is called more times than nvmlInit().
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if NVML has been properly shut down
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
@@ -1955,7 +2165,7 @@ const DECLDIR char* nvmlErrorString(nvmlReturn_t result);
 
 /**
  * Retrieves the version of the system's graphics driver.
- * 
+ *
  * For all products.
  *
  * The version identifier is an alphanumeric string.  It will not exceed 80 characters in length
@@ -1964,17 +2174,17 @@ const DECLDIR char* nvmlErrorString(nvmlReturn_t result);
  * @param version                              Reference in which to return the version identifier
  * @param length                               The maximum allowed length of the string returned in \a version
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a version has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a version is NULL
- *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small 
+ *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small
  */
 nvmlReturn_t DECLDIR nvmlSystemGetDriverVersion(char *version, unsigned int length);
 
 /**
  * Retrieves the version of the NVML library.
- * 
+ *
  * For all products.
  *
  * The version identifier is an alphanumeric string.  It will not exceed 80 characters in length
@@ -1983,10 +2193,10 @@ nvmlReturn_t DECLDIR nvmlSystemGetDriverVersion(char *version, unsigned int leng
  * @param version                              Reference in which to return the version identifier
  * @param length                               The maximum allowed length of the string returned in \a version
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a version has been set
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a version is NULL
- *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small 
+ *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small
  */
 nvmlReturn_t DECLDIR nvmlSystemGetNVMLVersion(char *version, unsigned int length);
 
@@ -2040,8 +2250,8 @@ nvmlReturn_t DECLDIR nvmlSystemGetCudaDriverVersion_v2(int *cudaDriverVersion);
  * @param pid                                  The identifier of the process
  * @param name                                 Reference in which to return the process name
  * @param length                               The maximum allowed length of the string returned in \a name
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a name has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a name is NULL or \a length is 0.
@@ -2056,7 +2266,7 @@ nvmlReturn_t DECLDIR nvmlSystemGetProcessName(unsigned int pid, char *name, unsi
 /***************************************************************************************************/
 /** @defgroup nvmlUnitQueries Unit Queries
  * This chapter describes that queries that NVML can perform against each unit. For S-class systems only.
- * In each case the device is identified with an nvmlUnit_t handle. This handle is obtained by 
+ * In each case the device is identified with an nvmlUnit_t handle. This handle is obtained by
  * calling \ref nvmlUnitGetHandleByIndex().
  *  @{
  */
@@ -2068,8 +2278,8 @@ nvmlReturn_t DECLDIR nvmlSystemGetProcessName(unsigned int pid, char *name, unsi
  * For S-class products.
  *
  * @param unitCount                            Reference in which to return the number of units
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a unitCount has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a unitCount is NULL
@@ -2082,15 +2292,15 @@ nvmlReturn_t DECLDIR nvmlUnitGetCount(unsigned int *unitCount);
  *
  * For S-class products.
  *
- * Valid indices are derived from the \a unitCount returned by \ref nvmlUnitGetCount(). 
+ * Valid indices are derived from the \a unitCount returned by \ref nvmlUnitGetCount().
  *   For example, if \a unitCount is 2 the valid indices are 0 and 1, corresponding to UNIT 0 and UNIT 1.
  *
  * The order in which NVML enumerates units has no guarantees of consistency between reboots.
  *
  * @param index                                The index of the target unit, >= 0 and < \a unitCount
  * @param unit                                 Reference in which to return the unit handle
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a unit has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a index is invalid or \a unit is NULL
@@ -2107,8 +2317,8 @@ nvmlReturn_t DECLDIR nvmlUnitGetHandleByIndex(unsigned int index, nvmlUnit_t *un
  *
  * @param unit                                 The identifier of the target unit
  * @param info                                 Reference in which to return the unit information
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a info has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a unit is invalid or \a info is NULL
@@ -2124,14 +2334,14 @@ nvmlReturn_t DECLDIR nvmlUnitGetUnitInfo(nvmlUnit_t unit, nvmlUnitInfo_t *info);
  *
  * @param unit                                 The identifier of the target unit
  * @param state                                Reference in which to return the current LED state
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a state has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a unit is invalid or \a state is NULL
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if this is not an S-class product
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
- * 
+ *
  * @see nvmlUnitSetLedState()
  */
 nvmlReturn_t DECLDIR nvmlUnitGetLedState(nvmlUnit_t unit, nvmlLedState_t *state);
@@ -2145,8 +2355,8 @@ nvmlReturn_t DECLDIR nvmlUnitGetLedState(nvmlUnit_t unit, nvmlLedState_t *state)
  *
  * @param unit                                 The identifier of the target unit
  * @param psu                                  Reference in which to return the PSU information
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a psu has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a unit is invalid or \a psu is NULL
@@ -2160,14 +2370,14 @@ nvmlReturn_t DECLDIR nvmlUnitGetPsuInfo(nvmlUnit_t unit, nvmlPSUInfo_t *psu);
  *
  * For S-class products.
  *
- * Depending on the product, readings may be available for intake (type=0), 
+ * Depending on the product, readings may be available for intake (type=0),
  * exhaust (type=1) and board (type=2).
  *
  * @param unit                                 The identifier of the target unit
  * @param type                                 The type of reading to take
  * @param temp                                 Reference in which to return the intake temperature
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a temp has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a unit or \a type is invalid or \a temp is NULL
@@ -2185,8 +2395,8 @@ nvmlReturn_t DECLDIR nvmlUnitGetTemperature(nvmlUnit_t unit, unsigned int type,
  *
  * @param unit                                 The identifier of the target unit
  * @param fanSpeeds                            Reference in which to return the fan speed information
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a fanSpeeds has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a unit is invalid or \a fanSpeeds is NULL
@@ -2206,8 +2416,8 @@ nvmlReturn_t DECLDIR nvmlUnitGetFanSpeedInfo(nvmlUnit_t unit, nvmlUnitFanSpeeds_
  * @param deviceCount                          Reference in which to provide the \a devices array size, and
  *                                             to return the number of attached GPU devices
  * @param devices                              Reference in which to return the references to the attached GPU devices
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a deviceCount and \a devices have been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a deviceCount indicates that the \a devices array is too small
@@ -2218,7 +2428,7 @@ nvmlReturn_t DECLDIR nvmlUnitGetDevices(nvmlUnit_t unit, unsigned int *deviceCou
 
 /**
  * Retrieves the IDs and firmware versions for any Host Interface Cards (HICs) in the system.
- * 
+ *
  * For S-class products.
  *
  * The \a hwbcCount argument is expected to be set to the size of the input \a hwbcEntries array.
@@ -2227,7 +2437,7 @@ nvmlReturn_t DECLDIR nvmlUnitGetDevices(nvmlUnit_t unit, unsigned int *deviceCou
  * @param hwbcCount                            Size of hwbcEntries array
  * @param hwbcEntries                          Array holding information about hwbc
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a hwbcCount and \a hwbcEntries have been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if either \a hwbcCount or \a hwbcEntries is NULL
@@ -2239,16 +2449,16 @@ nvmlReturn_t DECLDIR nvmlSystemGetHicVersion(unsigned int *hwbcCount, nvmlHwbcEn
 /***************************************************************************************************/
 /** @defgroup nvmlDeviceQueries Device Queries
  * This chapter describes that queries that NVML can perform against each device.
- * In each case the device is identified with an nvmlDevice_t handle. This handle is obtained by  
+ * In each case the device is identified with an nvmlDevice_t handle. This handle is obtained by
  * calling one of \ref nvmlDeviceGetHandleByIndex_v2(), \ref nvmlDeviceGetHandleBySerial(),
- * \ref nvmlDeviceGetHandleByPciBusId_v2(). or \ref nvmlDeviceGetHandleByUUID(). 
+ * \ref nvmlDeviceGetHandleByPciBusId_v2(). or \ref nvmlDeviceGetHandleByUUID().
  *  @{
  */
 /***************************************************************************************************/
 
  /**
  * Retrieves the number of compute devices in the system. A compute device is a single GPU.
- * 
+ *
  * For all products.
  *
  * Note: New nvmlDeviceGetCount_v2 (default in NVML 5.319) returns count of all devices in the system
@@ -2259,8 +2469,8 @@ nvmlReturn_t DECLDIR nvmlSystemGetHicVersion(unsigned int *hwbcCount, nvmlHwbcEn
  *       Old _v1 version of nvmlDeviceGetCount doesn't count devices that NVML has no permission to talk to.
  *
  * @param deviceCount                          Reference in which to return the number of accessible devices
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a deviceCount has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a deviceCount is NULL
@@ -2290,15 +2500,15 @@ nvmlReturn_t DECLDIR nvmlDeviceGetAttributes_v2(nvmlDevice_t device, nvmlDeviceA
 
 /**
  * Acquire the handle for a particular device, based on its index.
- * 
+ *
  * For all products.
  *
- * Valid indices are derived from the \a accessibleDevices count returned by 
- *   \ref nvmlDeviceGetCount_v2(). For example, if \a accessibleDevices is 2 the valid indices  
+ * Valid indices are derived from the \a accessibleDevices count returned by
+ *   \ref nvmlDeviceGetCount_v2(). For example, if \a accessibleDevices is 2 the valid indices
  *   are 0 and 1, corresponding to GPU 0 and GPU 1.
  *
  * The order in which NVML enumerates devices has no guarantees of consistency between reboots. For that reason it
- *   is recommended that devices be looked up by their PCI ids or UUID. See 
+ *   is recommended that devices be looked up by their PCI ids or UUID. See
  *   \ref nvmlDeviceGetHandleByUUID() and \ref nvmlDeviceGetHandleByPciBusId_v2().
  *
  * Note: The NVML index may not correlate with other APIs, such as the CUDA device index.
@@ -2306,7 +2516,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetAttributes_v2(nvmlDevice_t device, nvmlDeviceA
  * Starting from NVML 5, this API causes NVML to initialize the target GPU
  * NVML may initialize additional GPUs if:
  *  - The target GPU is an SLI slave
- * 
+ *
  * Note: New nvmlDeviceGetCount_v2 (default in NVML 5.319) returns count of all devices in the system
  *       even if nvmlDeviceGetHandleByIndex_v2 returns NVML_ERROR_NO_PERMISSION for such device.
  *       Update your code to handle this error, or use NVML 4.304 or older nvml header file.
@@ -2320,8 +2530,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetAttributes_v2(nvmlDevice_t device, nvmlDeviceA
  *
  * @param index                                The index of the target GPU, >= 0 and < \a accessibleDevices
  * @param device                               Reference in which to return the device handle
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                  if \a device has been set
  *         - \ref NVML_ERROR_UNINITIALIZED      if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT   if \a index is invalid or \a device is NULL
@@ -2344,7 +2554,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetHandleByIndex_v2(unsigned int index, nvmlDevic
  * This number corresponds to the value printed directly on the board, and to the value returned by
  *   \ref nvmlDeviceGetSerial().
  *
- * @deprecated Since more than one GPU can exist on a single board this function is deprecated in favor 
+ * @deprecated Since more than one GPU can exist on a single board this function is deprecated in favor
  *             of \ref nvmlDeviceGetHandleByUUID.
  *             For dual GPU boards this function will return NVML_ERROR_INVALID_ARGUMENT.
  *
@@ -2353,8 +2563,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetHandleByIndex_v2(unsigned int index, nvmlDevic
  *
  * @param serial                               The board serial number of the target GPU
  * @param device                               Reference in which to return the device handle
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                  if \a device has been set
  *         - \ref NVML_ERROR_UNINITIALIZED      if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT   if \a serial is invalid, \a device is NULL or more than one
@@ -2375,15 +2585,13 @@ nvmlReturn_t DECLDIR nvmlDeviceGetHandleBySerial(const char *serial, nvmlDevice_
  *
  * For all products.
  *
- * @param uuid                                 The UUID of the target GPU
- * @param device                               Reference in which to return the device handle
- * 
+ * @param uuid                                 The UUID of the target GPU or MIG instance
+ * @param device                               Reference in which to return the device handle or MIG device handle
+ *
  * Starting from NVML 5, this API causes NVML to initialize the target GPU
  * NVML may initialize additional GPUs as it searches for the target GPU
  *
- * This API does not currently support acquiring MIG device handles using MIG device UUIDs.
- *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                  if \a device has been set
  *         - \ref NVML_ERROR_UNINITIALIZED      if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT   if \a uuid is invalid or \a device is null
@@ -2399,7 +2607,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetHandleByUUID(const char *uuid, nvmlDevice_t *d
 
 /**
  * Acquire the handle for a particular device, based on its PCI bus id.
- * 
+ *
  * For all products.
  *
  * This value corresponds to the nvmlPciInfo_t::busId returned by \ref nvmlDeviceGetPciInfo_v3().
@@ -2408,13 +2616,13 @@ nvmlReturn_t DECLDIR nvmlDeviceGetHandleByUUID(const char *uuid, nvmlDevice_t *d
  * NVML may initialize additional GPUs if:
  *  - The target GPU is an SLI slave
  *
- * \note NVML 4.304 and older version of nvmlDeviceGetHandleByPciBusId"_v1" returns NVML_ERROR_NOT_FOUND 
+ * \note NVML 4.304 and older version of nvmlDeviceGetHandleByPciBusId"_v1" returns NVML_ERROR_NOT_FOUND
  *       instead of NVML_ERROR_NO_PERMISSION.
  *
  * @param pciBusId                             The PCI bus id of the target GPU
  * @param device                               Reference in which to return the device handle
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                  if \a device has been set
  *         - \ref NVML_ERROR_UNINITIALIZED      if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT   if \a pciBusId is invalid or \a device is NULL
@@ -2428,8 +2636,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetHandleByUUID(const char *uuid, nvmlDevice_t *d
 nvmlReturn_t DECLDIR nvmlDeviceGetHandleByPciBusId_v2(const char *pciBusId, nvmlDevice_t *device);
 
 /**
- * Retrieves the name of this device. 
- * 
+ * Retrieves the name of this device.
+ *
  * For all products.
  *
  * The name is an alphanumeric string that denotes a particular product, e.g. Tesla &tm; C2070. It will not
@@ -2442,8 +2650,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetHandleByPciBusId_v2(const char *pciBusId, nvml
  * @param device                               The identifier of the target device
  * @param name                                 Reference in which to return the product name
  * @param length                               The maximum allowed length of the string returned in \a name
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a name has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, or \a name is NULL
@@ -2476,13 +2684,13 @@ nvmlReturn_t DECLDIR nvmlDeviceGetBrand(nvmlDevice_t device, nvmlBrandType_t *ty
  * Retrieves the NVML index of this device.
  *
  * For all products.
- * 
- * Valid indices are derived from the \a accessibleDevices count returned by 
- *   \ref nvmlDeviceGetCount_v2(). For example, if \a accessibleDevices is 2 the valid indices  
+ *
+ * Valid indices are derived from the \a accessibleDevices count returned by
+ *   \ref nvmlDeviceGetCount_v2(). For example, if \a accessibleDevices is 2 the valid indices
  *   are 0 and 1, corresponding to GPU 0 and GPU 1.
  *
  * The order in which NVML enumerates devices has no guarantees of consistency between reboots. For that reason it
- *   is recommended that devices be looked up by their PCI ids or GPU UUID. See 
+ *   is recommended that devices be looked up by their PCI ids or GPU UUID. See
  *   \ref nvmlDeviceGetHandleByPciBusId_v2() and \ref nvmlDeviceGetHandleByUUID().
  *
  * When used with MIG device handles this API returns indices that can be
@@ -2494,7 +2702,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetBrand(nvmlDevice_t device, nvmlBrandType_t *ty
  * @param device                               The identifier of the target device
  * @param index                                Reference in which to return the NVML index of the device
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a index has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, or \a index is NULL
@@ -2518,8 +2726,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetIndex(nvmlDevice_t device, unsigned int *index
  * @param device                               The identifier of the target device
  * @param serial                               Reference in which to return the board/module serial number
  * @param length                               The maximum allowed length of the string returned in \a serial
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a serial has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, or \a serial is NULL
@@ -2592,11 +2800,11 @@ nvmlReturn_t DECLDIR nvmlDeviceGetMemoryAffinity(nvmlDevice_t device, unsigned i
  *
  * @param device                               The identifier of the target device
  * @param cpuSetSize                           The size of the cpuSet array that is safe to access
- * @param cpuSet                               Array reference in which to return a bitmask of CPUs, 64 CPUs per 
+ * @param cpuSet                               Array reference in which to return a bitmask of CPUs, 64 CPUs per
  *                                                 unsigned long on 64-bit machines, 32 on 32-bit machines
  * @param scope                                Scope that change the default behavior
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a cpuAffinity has been filled
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, cpuSetSize == 0, cpuSet is NULL or sope is invalid
@@ -2618,10 +2826,10 @@ nvmlReturn_t DECLDIR nvmlDeviceGetCpuAffinityWithinScope(nvmlDevice_t device, un
  *
  * @param device                               The identifier of the target device
  * @param cpuSetSize                           The size of the cpuSet array that is safe to access
- * @param cpuSet                               Array reference in which to return a bitmask of CPUs, 64 CPUs per 
+ * @param cpuSet                               Array reference in which to return a bitmask of CPUs, 64 CPUs per
  *                                                 unsigned long on 64-bit machines, 32 on 32-bit machines
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a cpuAffinity has been filled
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, cpuSetSize == 0, or cpuSet is NULL
@@ -2632,8 +2840,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetCpuAffinityWithinScope(nvmlDevice_t device, un
 nvmlReturn_t DECLDIR nvmlDeviceGetCpuAffinity(nvmlDevice_t device, unsigned int cpuSetSize, unsigned long *cpuSet);
 
 /**
- * Sets the ideal affinity for the calling thread and device using the guidelines 
- * given in nvmlDeviceGetCpuAffinity().  Note, this is a change as of version 8.0.  
+ * Sets the ideal affinity for the calling thread and device using the guidelines
+ * given in nvmlDeviceGetCpuAffinity().  Note, this is a change as of version 8.0.
  * Older versions set the affinity for a calling process and all children.
  * Currently supports up to 1024 processors.
  *
@@ -2642,7 +2850,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetCpuAffinity(nvmlDevice_t device, unsigned int
  *
  * @param device                               The identifier of the target device
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if the calling process has been successfully bound
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid
@@ -2661,7 +2869,7 @@ nvmlReturn_t DECLDIR nvmlDeviceSetCpuAffinity(nvmlDevice_t device);
  *
  * @param device                               The identifier of the target device
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if the calling process has been successfully unbound
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
@@ -2695,7 +2903,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetTopologyCommonAncestor(nvmlDevice_t device1, n
  *
  * @param device                               The identifier of the first device
  * @param level                                The \ref nvmlGpuTopologyLevel_t level to search for other GPUs
- * @param count                                When zero, is set to the number of matching GPUs such that \a deviceArray 
+ * @param count                                When zero, is set to the number of matching GPUs such that \a deviceArray
  *                                             can be malloc'd.  When non-zero, \a deviceArray will be filled with \a count
  *                                             number of device handles.
  * @param deviceArray                          An array of device handles for GPUs found at \a level
@@ -2714,7 +2922,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetTopologyNearestGpus(nvmlDevice_t device, nvmlG
  * Supported on Linux only.
  *
  * @param cpuNumber                            The CPU number
- * @param count                                When zero, is set to the number of matching GPUs such that \a deviceArray 
+ * @param count                                When zero, is set to the number of matching GPUs such that \a deviceArray
  *                                             can be malloc'd.  When non-zero, \a deviceArray will be filled with \a count
  *                                             number of device handles.
  * @param deviceArray                          An array of device handles for GPUs found with affinity to \a cpuNumber
@@ -2728,18 +2936,18 @@ nvmlReturn_t DECLDIR nvmlDeviceGetTopologyNearestGpus(nvmlDevice_t device, nvmlG
 nvmlReturn_t DECLDIR nvmlSystemGetTopologyGpuSet(unsigned int cpuNumber, unsigned int *count, nvmlDevice_t *deviceArray);
 
 /**
- * Retrieve the status for a given p2p capability index between a given pair of GPU 
- * 
- * @param device1                              The first device 
+ * Retrieve the status for a given p2p capability index between a given pair of GPU
+ *
+ * @param device1                              The first device
  * @param device2                              The second device
  * @param p2pIndex                             p2p Capability Index being looked for between \a device1 and \a device2
  * @param p2pStatus                            Reference in which to return the status of the \a p2pIndex
  *                                             between \a device1 and \a device2
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS         if \a p2pStatus has been populated
  *         - \ref NVML_ERROR_INVALID_ARGUMENT     if \a device1 or \a device2 or \a p2pIndex is invalid or \a p2pStatus is NULL
  *         - \ref NVML_ERROR_UNKNOWN              on any unexpected error
- */ 
+ */
 nvmlReturn_t DECLDIR nvmlDeviceGetP2PStatus(nvmlDevice_t device1, nvmlDevice_t device2, nvmlGpuP2PCapsIndex_t p2pIndex,nvmlGpuP2PStatus_t *p2pStatus);
 
 /**
@@ -2758,12 +2966,12 @@ nvmlReturn_t DECLDIR nvmlDeviceGetP2PStatus(nvmlDevice_t device1, nvmlDevice_t d
  * @param device                               The identifier of the target device
  * @param uuid                                 Reference in which to return the GPU UUID
  * @param length                               The maximum allowed length of the string returned in \a uuid
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a uuid has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, or \a uuid is NULL
- *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small 
+ *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device does not support this feature
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
@@ -2796,7 +3004,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetUUID(nvmlDevice_t device, char *uuid, unsigned
 nvmlReturn_t DECLDIR nvmlVgpuInstanceGetMdevUUID(nvmlVgpuInstance_t vgpuInstance, char *mdevUuid, unsigned int size);
 
 /**
- * Retrieves minor number for the device. The minor number for the device is such that the Nvidia device node file for 
+ * Retrieves minor number for the device. The minor number for the device is such that the Nvidia device node file for
  * each GPU will have the form /dev/nvidia[minor number].
  *
  * For all products.
@@ -2838,7 +3046,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetBoardPartNumber(nvmlDevice_t device, char* par
  *
  * For all products with an inforom.
  *
- * Fermi and higher parts have non-volatile on-board memory for persisting device info, such as aggregate 
+ * Fermi and higher parts have non-volatile on-board memory for persisting device info, such as aggregate
  * ECC counts. The version of the data structures in this memory may change from time to time. It will not
  * exceed 16 characters in length (including the NULL terminator).
  * See \ref nvmlConstants::NVML_DEVICE_INFOROM_VERSION_BUFFER_SIZE.
@@ -2850,11 +3058,11 @@ nvmlReturn_t DECLDIR nvmlDeviceGetBoardPartNumber(nvmlDevice_t device, char* par
  * @param version                              Reference in which to return the infoROM version
  * @param length                               The maximum allowed length of the string returned in \a version
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a version has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a version is NULL
- *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small 
+ *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device does not have an infoROM
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
@@ -2868,7 +3076,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetInforomVersion(nvmlDevice_t device, nvmlInforo
  *
  * For all products with an inforom.
  *
- * Image version just like VBIOS version uniquely describes the exact version of the infoROM flashed on the board 
+ * Image version just like VBIOS version uniquely describes the exact version of the infoROM flashed on the board
  * in contrast to infoROM object version which is only an indicator of supported features.
  * Version string will not exceed 16 characters in length (including the NULL terminator).
  * See \ref nvmlConstants::NVML_DEVICE_INFOROM_VERSION_BUFFER_SIZE.
@@ -2877,11 +3085,11 @@ nvmlReturn_t DECLDIR nvmlDeviceGetInforomVersion(nvmlDevice_t device, nvmlInforo
  * @param version                              Reference in which to return the infoROM image version
  * @param length                               The maximum allowed length of the string returned in \a version
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a version has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a version is NULL
- *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small 
+ *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device does not have an infoROM
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
@@ -2902,14 +3110,14 @@ nvmlReturn_t DECLDIR nvmlDeviceGetInforomImageVersion(nvmlDevice_t device, char
  * @param device                               The identifier of the target device
  * @param checksum                             Reference in which to return the infoROM configuration checksum
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a checksum has been set
  *         - \ref NVML_ERROR_CORRUPTED_INFOROM if the device's checksum couldn't be retrieved due to infoROM corruption
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a checksum is NULL
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device does not support this feature
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
- *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error 
+ *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  */
 nvmlReturn_t DECLDIR nvmlDeviceGetInforomConfigurationChecksum(nvmlDevice_t device, unsigned int *checksum);
 
@@ -2920,13 +3128,13 @@ nvmlReturn_t DECLDIR nvmlDeviceGetInforomConfigurationChecksum(nvmlDevice_t devi
  *
  * @param device                               The identifier of the target device
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if infoROM is not corrupted
  *         - \ref NVML_ERROR_CORRUPTED_INFOROM if the device's infoROM is corrupted
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device does not support this feature
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
- *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error 
+ *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  */
 nvmlReturn_t DECLDIR nvmlDeviceValidateInforom(nvmlDevice_t device);
 
@@ -2942,8 +3150,8 @@ nvmlReturn_t DECLDIR nvmlDeviceValidateInforom(nvmlDevice_t device);
  *
  * @param device                               The identifier of the target device
  * @param display                              Reference in which to return the display mode
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a display has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a display is NULL
@@ -2967,8 +3175,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetDisplayMode(nvmlDevice_t device, nvmlEnableSta
  *
  * @param device                               The identifier of the target device
  * @param isActive                             Reference in which to return the display active state
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a isActive has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a isActive is NULL
@@ -2984,15 +3192,15 @@ nvmlReturn_t DECLDIR nvmlDeviceGetDisplayActive(nvmlDevice_t device, nvmlEnableS
  * For all products.
  * For Linux only.
  *
- * When driver persistence mode is enabled the driver software state is not torn down when the last 
- * client disconnects. By default this feature is disabled. 
+ * When driver persistence mode is enabled the driver software state is not torn down when the last
+ * client disconnects. By default this feature is disabled.
  *
  * See \ref nvmlEnableState_t for details on allowed modes.
  *
  * @param device                               The identifier of the target device
  * @param mode                                 Reference in which to return the current driver persistence mode
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a mode has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a mode is NULL
@@ -3006,15 +3214,15 @@ nvmlReturn_t DECLDIR nvmlDeviceGetPersistenceMode(nvmlDevice_t device, nvmlEnabl
 
 /**
  * Retrieves the PCI attributes of this device.
- * 
+ *
  * For all products.
  *
  * See \ref nvmlPciInfo_t for details on the available PCI info.
  *
  * @param device                               The identifier of the target device
  * @param pci                                  Reference in which to return the PCI info
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a pci has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a pci is NULL
@@ -3028,13 +3236,13 @@ nvmlReturn_t DECLDIR nvmlDeviceGetPciInfo_v3(nvmlDevice_t device, nvmlPciInfo_t
  *
  * I.E. for a generation 2 PCIe device attached to a generation 1 PCIe bus the max link generation this function will
  * report is generation 1.
- * 
+ *
  * For Fermi &tm; or newer fully supported devices.
- * 
+ *
  * @param device                               The identifier of the target device
  * @param maxLinkGen                           Reference in which to return the max PCIe link generation
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a maxLinkGen has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a maxLinkGen is null
@@ -3049,13 +3257,13 @@ nvmlReturn_t DECLDIR nvmlDeviceGetMaxPcieLinkGeneration(nvmlDevice_t device, uns
  *
  * I.E. for a device with a 16x PCIe bus width attached to a 8x PCIe system bus this function will report
  * a max link width of 8.
- * 
+ *
  * For Fermi &tm; or newer fully supported devices.
- * 
+ *
  * @param device                               The identifier of the target device
  * @param maxLinkWidth                         Reference in which to return the max PCIe link generation
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a maxLinkWidth has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a maxLinkWidth is null
@@ -3067,13 +3275,13 @@ nvmlReturn_t DECLDIR nvmlDeviceGetMaxPcieLinkWidth(nvmlDevice_t device, unsigned
 
 /**
  * Retrieves the current PCIe link generation
- * 
+ *
  * For Fermi &tm; or newer fully supported devices.
- * 
+ *
  * @param device                               The identifier of the target device
  * @param currLinkGen                          Reference in which to return the current PCIe link generation
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a currLinkGen has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a currLinkGen is null
@@ -3085,13 +3293,13 @@ nvmlReturn_t DECLDIR nvmlDeviceGetCurrPcieLinkGeneration(nvmlDevice_t device, un
 
 /**
  * Retrieves the current PCIe link width
- * 
+ *
  * For Fermi &tm; or newer fully supported devices.
- * 
+ *
  * @param device                               The identifier of the target device
  * @param currLinkWidth                        Reference in which to return the current PCIe link generation
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a currLinkWidth has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a currLinkWidth is null
@@ -3103,7 +3311,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetCurrPcieLinkWidth(nvmlDevice_t device, unsigne
 
 /**
  * Retrieve PCIe utilization information.
- * This function is querying a byte counter over a 20ms interval and thus is the 
+ * This function is querying a byte counter over a 20ms interval and thus is the
  *   PCIe throughput over that interval.
  *
  * For Maxwell &tm; or newer fully supported devices.
@@ -3124,7 +3332,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetCurrPcieLinkWidth(nvmlDevice_t device, unsigne
  */
 nvmlReturn_t DECLDIR nvmlDeviceGetPcieThroughput(nvmlDevice_t device, nvmlPcieUtilCounter_t counter, unsigned int *value);
 
-/**  
+/**
  * Retrieve the PCIe replay counter.
  *
  * For Kepler &tm; or newer fully supported devices.
@@ -3152,8 +3360,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetPcieReplayCounter(nvmlDevice_t device, unsigne
  * @param device                               The identifier of the target device
  * @param type                                 Identify which clock domain to query
  * @param clock                                Reference in which to return the clock speed in MHz
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a clock has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a clock is NULL
@@ -3176,8 +3384,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetClockInfo(nvmlDevice_t device, nvmlClockType_t
  * @param device                               The identifier of the target device
  * @param type                                 Identify which clock domain to query
  * @param clock                                Reference in which to return the clock speed in MHz
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a clock has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a clock is NULL
@@ -3196,8 +3404,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetMaxClockInfo(nvmlDevice_t device, nvmlClockTyp
  * @param device                               The identifier of the target device
  * @param clockType                            Identify which clock domain to query
  * @param clockMHz                             Reference in which to return the clock in MHz
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a clockMHz has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a clockMHz is NULL or \a clockType is invalid
@@ -3208,7 +3416,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetMaxClockInfo(nvmlDevice_t device, nvmlClockTyp
 nvmlReturn_t DECLDIR nvmlDeviceGetApplicationsClock(nvmlDevice_t device, nvmlClockType_t clockType, unsigned int *clockMHz);
 
 /**
- * Retrieves the default applications clock that GPU boots with or 
+ * Retrieves the default applications clock that GPU boots with or
  * defaults to after \ref nvmlDeviceResetApplicationsClocks call.
  *
  * For Kepler &tm; or newer fully supported devices.
@@ -3216,8 +3424,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetApplicationsClock(nvmlDevice_t device, nvmlClo
  * @param device                               The identifier of the target device
  * @param clockType                            Identify which clock domain to query
  * @param clockMHz                             Reference in which to return the default clock in MHz
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a clockMHz has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a clockMHz is NULL or \a clockType is invalid
@@ -3245,8 +3453,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetDefaultApplicationsClock(nvmlDevice_t device,
  * For Fermi &tm; or newer non-GeForce fully supported devices and Maxwell or newer GeForce devices.
  *
  * @param device                               The identifier of the target device
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if new settings were successfully set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid
@@ -3304,9 +3512,9 @@ nvmlReturn_t DECLDIR nvmlDeviceGetMaxCustomerBoostClock(nvmlDevice_t device, nvm
  * @param count                                Reference in which to provide the \a clocksMHz array size, and
  *                                             to return the number of elements
  * @param clocksMHz                            Reference in which to return the clock in MHz
- * 
- * @return 
- *         - \ref NVML_SUCCESS                 if \a count and \a clocksMHz have been populated 
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 if \a count and \a clocksMHz have been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a count is NULL
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device does not support this feature
@@ -3330,14 +3538,14 @@ nvmlReturn_t DECLDIR nvmlDeviceGetSupportedMemoryClocks(nvmlDevice_t device, uns
  * @param count                                Reference in which to provide the \a clocksMHz array size, and
  *                                             to return the number of elements
  * @param clocksMHz                            Reference in which to return the clocks in MHz
- * 
- * @return 
- *         - \ref NVML_SUCCESS                 if \a count and \a clocksMHz have been populated 
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 if \a count and \a clocksMHz have been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_NOT_FOUND         if the specified \a memoryClockMHz is not a supported frequency
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a clock is NULL
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device does not support this feature
- *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a count is too small 
+ *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a count is too small
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  *
@@ -3442,7 +3650,7 @@ nvmlReturn_t DECLDIR nvmlDeviceSetDefaultAutoBoostedClocksEnabled(nvmlDevice_t d
  *
  * Note: The reported speed is the intended fan speed.  If the fan is physically blocked and unable to spin, the
  * output will not match the actual fan speed.
- * 
+ *
  * For all discrete products with dedicated fans.
  *
  * The fan speed is expressed as a percentage of the product's maximum noise tolerance fan speed.
@@ -3450,8 +3658,8 @@ nvmlReturn_t DECLDIR nvmlDeviceSetDefaultAutoBoostedClocksEnabled(nvmlDevice_t d
  *
  * @param device                               The identifier of the target device
  * @param speed                                Reference in which to return the fan speed percentage
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a speed has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a speed is NULL
@@ -3487,10 +3695,27 @@ nvmlReturn_t DECLDIR nvmlDeviceGetFanSpeed(nvmlDevice_t device, unsigned int *sp
  */
 nvmlReturn_t DECLDIR nvmlDeviceGetFanSpeed_v2(nvmlDevice_t device, unsigned int fan, unsigned int * speed);
 
+/**
+ * Retrieves the number of fans on the device.
+ *
+ * For all discrete products with dedicated fans.
+ *
+ * @param device                               The identifier of the target device
+ * @param numFans                              The number of fans
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 if \a fan number query was successful
+ *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a numFans is NULL
+ *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device does not have a fan
+ *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
+ *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
+ */
+nvmlReturn_t DECLDIR nvmlDeviceGetNumFans(nvmlDevice_t device, unsigned int *numFans);
 
 /**
- * Retrieves the current temperature readings for the device, in degrees C. 
- * 
+ * Retrieves the current temperature readings for the device, in degrees C.
+ *
  * For all products.
  *
  * See \ref nvmlTemperatureSensors_t for details on available temperature sensors.
@@ -3498,8 +3723,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetFanSpeed_v2(nvmlDevice_t device, unsigned int
  * @param device                               The identifier of the target device
  * @param sensorType                           Flag that indicates which sensor reading to retrieve
  * @param temp                                 Reference in which to return the temperature reading
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a temp has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, \a sensorType is invalid or \a temp is NULL
@@ -3550,7 +3775,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetTemperatureThreshold(nvmlDevice_t device, nvml
 nvmlReturn_t DECLDIR nvmlDeviceSetTemperatureThreshold(nvmlDevice_t device, nvmlTemperatureThresholds_t thresholdType, int *temp);
 
 /**
- * Retrieves the current performance state for the device. 
+ * Retrieves the current performance state for the device.
  *
  * For Fermi &tm; or newer fully supported devices.
  *
@@ -3558,8 +3783,8 @@ nvmlReturn_t DECLDIR nvmlDeviceSetTemperatureThreshold(nvmlDevice_t device, nvml
  *
  * @param device                               The identifier of the target device
  * @param pState                               Reference in which to return the performance state reading
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a pState has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a pState is NULL
@@ -3580,7 +3805,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetPerformanceState(nvmlDevice_t device, nvmlPsta
  * @param clocksThrottleReasons                 Reference in which to return bitmask of active clocks throttle
  *                                                  reasons
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a clocksThrottleReasons has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a clocksThrottleReasons is NULL
@@ -3594,7 +3819,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetPerformanceState(nvmlDevice_t device, nvmlPsta
 nvmlReturn_t DECLDIR nvmlDeviceGetCurrentClocksThrottleReasons(nvmlDevice_t device, unsigned long long *clocksThrottleReasons);
 
 /**
- * Retrieves bitmask of supported clocks throttle reasons that can be returned by 
+ * Retrieves bitmask of supported clocks throttle reasons that can be returned by
  * \ref nvmlDeviceGetCurrentClocksThrottleReasons
  *
  * For all fully supported products.
@@ -3605,7 +3830,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetCurrentClocksThrottleReasons(nvmlDevice_t devi
  * @param supportedClocksThrottleReasons       Reference in which to return bitmask of supported
  *                                              clocks throttle reasons
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a supportedClocksThrottleReasons has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a supportedClocksThrottleReasons is NULL
@@ -3620,7 +3845,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetSupportedClocksThrottleReasons(nvmlDevice_t de
 /**
  * Deprecated: Use \ref nvmlDeviceGetPerformanceState. This function exposes an incorrect generalization.
  *
- * Retrieve the current performance state for the device. 
+ * Retrieve the current performance state for the device.
  *
  * For Fermi &tm; or newer fully supported devices.
  *
@@ -3628,8 +3853,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetSupportedClocksThrottleReasons(nvmlDevice_t de
  *
  * @param device                               The identifier of the target device
  * @param pState                               Reference in which to return the performance state reading
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a pState has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a pState is NULL
@@ -3650,16 +3875,16 @@ nvmlReturn_t DECLDIR nvmlDeviceGetPowerState(nvmlDevice_t device, nvmlPstates_t
  * For from the Kepler or newer families.
  *     - Does not require \a NVML_INFOROM_POWER object.
  *
- * This flag indicates whether any power management algorithm is currently active on the device. An 
- * enabled state does not necessarily mean the device is being actively throttled -- only that 
+ * This flag indicates whether any power management algorithm is currently active on the device. An
+ * enabled state does not necessarily mean the device is being actively throttled -- only that
  * that the driver will do so if the appropriate conditions are met.
  *
  * See \ref nvmlEnableState_t for details on allowed modes.
  *
  * @param device                               The identifier of the target device
  * @param mode                                 Reference in which to return the current power management mode
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a mode has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a mode is NULL
@@ -3677,13 +3902,13 @@ nvmlReturn_t DECLDIR nvmlDeviceGetPowerManagementMode(nvmlDevice_t device, nvmlE
  * The power limit defines the upper boundary for the card's power draw. If
  * the card's total power draw reaches this limit the power management algorithm kicks in.
  *
- * This reading is only available if power management mode is supported. 
+ * This reading is only available if power management mode is supported.
  * See \ref nvmlDeviceGetPowerManagementMode.
  *
  * @param device                               The identifier of the target device
  * @param limit                                Reference in which to return the power management limit in milliwatts
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a limit has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a limit is NULL
@@ -3701,8 +3926,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetPowerManagementLimit(nvmlDevice_t device, unsi
  * @param device                               The identifier of the target device
  * @param minLimit                             Reference in which to return the minimum power management limit in milliwatts
  * @param maxLimit                             Reference in which to return the maximum power management limit in milliwatts
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a minLimit and \a maxLimit have been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a minLimit or \a maxLimit is NULL
@@ -3722,8 +3947,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetPowerManagementLimitConstraints(nvmlDevice_t d
  *
  * @param device                               The identifier of the target device
  * @param defaultLimit                         Reference in which to return the default power management limit in milliwatts
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a defaultLimit has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a defaultLimit is NULL
@@ -3744,8 +3969,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetPowerManagementDefaultLimit(nvmlDevice_t devic
  *
  * @param device                               The identifier of the target device
  * @param power                                Reference in which to return the power usage information
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a power has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a power is NULL
@@ -3784,7 +4009,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetTotalEnergyConsumption(nvmlDevice_t device, un
  * @param device                           The device to communicate with
  * @param limit                            Reference in which to return the power management limit in milliwatts
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a limit has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a limit is NULL
@@ -3804,8 +4029,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetEnforcedPowerLimit(nvmlDevice_t device, unsign
  * @param device                               The identifier of the target device
  * @param current                              Reference in which to return the current GOM
  * @param pending                              Reference in which to return the pending GOM
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a mode has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a current or \a pending is NULL
@@ -3819,26 +4044,29 @@ nvmlReturn_t DECLDIR nvmlDeviceGetEnforcedPowerLimit(nvmlDevice_t device, unsign
 nvmlReturn_t DECLDIR nvmlDeviceGetGpuOperationMode(nvmlDevice_t device, nvmlGpuOperationMode_t *current, nvmlGpuOperationMode_t *pending);
 
 /**
- * Retrieves the amount of used, free and total memory available on the device, in bytes.
- * 
+ * Retrieves the amount of used, free, reserved and total memory available on the device, in bytes.
+ * The reserved amount is supported on version 2 only.
+ *
  * For all products.
  *
  * Enabling ECC reduces the amount of total available memory, due to the extra required parity bits.
  * Under WDDM most device memory is allocated and managed on startup by Windows.
  *
- * Under Linux and Windows TCC, the reported amount of used memory is equal to the sum of memory allocated 
+ * Under Linux and Windows TCC, the reported amount of used memory is equal to the sum of memory allocated
  * by all active channels on the device.
  *
- * See \ref nvmlMemory_t for details on available memory info.
+ * See \ref nvmlMemory_v2_t for details on available memory info.
  *
  * @note In MIG mode, if device handle is provided, the API returns aggregate
  *       information, only if the caller has appropriate privileges. Per-instance
  *       information can be queried by using specific MIG device handles.
+ * 
+ * @note nvmlDeviceGetMemoryInfo_v2 adds additional memory information.
  *
  * @param device                               The identifier of the target device
  * @param memory                               Reference in which to return the memory information
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a memory has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_NO_PERMISSION     if the user doesn't have permission to perform this operation
@@ -3847,6 +4075,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetGpuOperationMode(nvmlDevice_t device, nvmlGpuO
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  */
 nvmlReturn_t DECLDIR nvmlDeviceGetMemoryInfo(nvmlDevice_t device, nvmlMemory_t *memory);
+nvmlReturn_t DECLDIR nvmlDeviceGetMemoryInfo_v2(nvmlDevice_t device, nvmlMemory_v2_t *memory);
 
 /**
  * Retrieves the current compute mode for the device.
@@ -3857,8 +4086,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetMemoryInfo(nvmlDevice_t device, nvmlMemory_t *
  *
  * @param device                               The identifier of the target device
  * @param mode                                 Reference in which to return the current compute mode
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a mode has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a mode is NULL
@@ -3909,8 +4138,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetCudaComputeCapability(nvmlDevice_t device, int
  * @param device                               The identifier of the target device
  * @param current                              Reference in which to return the current ECC mode
  * @param pending                              Reference in which to return the pending ECC mode
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a current and \a pending have been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or either \a current or \a pending is NULL
@@ -3924,13 +4153,13 @@ nvmlReturn_t DECLDIR nvmlDeviceGetEccMode(nvmlDevice_t device, nvmlEnableState_t
 
 /**
  * Retrieves the device boardId from 0-N.
- * Devices with the same boardId indicate GPUs connected to the same PLX.  Use in conjunction with 
+ * Devices with the same boardId indicate GPUs connected to the same PLX.  Use in conjunction with
  *  \ref nvmlDeviceGetMultiGpuBoard() to decide if they are on the same board as well.
- *  The boardId returned is a unique ID for the current configuration.  Uniqueness and ordering across 
+ *  The boardId returned is a unique ID for the current configuration.  Uniqueness and ordering across
  *  reboots and system configurations is not guaranteed (i.e. if a Tesla K40c returns 0x100 and
- *  the two GPUs on a Tesla K10 in the same system returns 0x200 it is not guaranteed they will 
+ *  the two GPUs on a Tesla K10 in the same system returns 0x200 it is not guaranteed they will
  *  always return those values but they will always be different from each other).
- *  
+ *
  *
  * For Fermi &tm; or newer fully supported devices.
  *
@@ -3975,18 +4204,18 @@ nvmlReturn_t DECLDIR nvmlDeviceGetMultiGpuBoard(nvmlDevice_t device, unsigned in
  * Requires \a NVML_INFOROM_ECC version 1.0 or higher.
  * Requires ECC Mode to be enabled.
  *
- * The total error count is the sum of errors across each of the separate memory systems, i.e. the total set of 
+ * The total error count is the sum of errors across each of the separate memory systems, i.e. the total set of
  * errors across the entire device.
  *
  * See \ref nvmlMemoryErrorType_t for a description of available error types.\n
  * See \ref nvmlEccCounterType_t for a description of available counter types.
  *
  * @param device                               The identifier of the target device
- * @param errorType                            Flag that specifies the type of the errors. 
- * @param counterType                          Flag that specifies the counter-type of the errors. 
+ * @param errorType                            Flag that specifies the type of the errors.
+ * @param counterType                          Flag that specifies the counter-type of the errors.
  * @param eccCounts                            Reference in which to return the specified ECC errors
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a eccCounts has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device, \a errorType or \a counterType is invalid, or \a eccCounts is NULL
@@ -4020,11 +4249,11 @@ nvmlReturn_t DECLDIR nvmlDeviceGetTotalEccErrors(nvmlDevice_t device, nvmlMemory
  * See \ref nvmlEccErrorCounts_t for a description of provided detailed ECC counts.
  *
  * @param device                               The identifier of the target device
- * @param errorType                            Flag that specifies the type of the errors. 
- * @param counterType                          Flag that specifies the counter-type of the errors. 
+ * @param errorType                            Flag that specifies the type of the errors.
+ * @param counterType                          Flag that specifies the counter-type of the errors.
  * @param eccCounts                            Reference in which to return the specified ECC errors
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a eccCounts has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device, \a errorType or \a counterType is invalid, or \a eccCounts is NULL
@@ -4055,14 +4284,14 @@ nvmlReturn_t DECLDIR nvmlDeviceGetDetailedEccErrors(nvmlDevice_t device, nvmlMem
  * See \ref nvmlMemoryErrorType_t for a description of available memory error types.\n
  * See \ref nvmlEccCounterType_t for a description of available counter types.\n
  * See \ref nvmlMemoryLocation_t for a description of available counter locations.\n
- * 
+ *
  * @param device                               The identifier of the target device
  * @param errorType                            Flag that specifies the type of error.
- * @param counterType                          Flag that specifies the counter-type of the errors. 
- * @param locationType                         Specifies the location of the counter. 
+ * @param counterType                          Flag that specifies the counter-type of the errors.
+ * @param locationType                         Specifies the location of the counter.
  * @param count                                Reference in which to return the ECC counter
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a count has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device, \a bitTyp,e \a counterType or \a locationType is
@@ -4089,8 +4318,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetMemoryErrorCounter(nvmlDevice_t device, nvmlMe
  *
  * @param device                               The identifier of the target device
  * @param utilization                          Reference in which to return the utilization information
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a utilization has been populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a utilization is NULL
@@ -4129,7 +4358,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetEncoderUtilization(nvmlDevice_t device, unsign
  * @param device                            The identifier of the target device
  * @param encoderQueryType                  Type of encoder to query
  * @param encoderCapacity                   Reference to an unsigned int for the encoder capacity
- * 
+ *
  * @return
  *         - \ref NVML_SUCCESS                  if \a encoderCapacity is fetched
  *         - \ref NVML_ERROR_UNINITIALIZED      if the library has not been successfully initialized
@@ -4150,7 +4379,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetEncoderCapacity (nvmlDevice_t device, nvmlEnco
  * @param sessionCount                      Reference to an unsigned int for count of active encoder sessions
  * @param averageFps                        Reference to an unsigned int for trailing average FPS of all active sessions
  * @param averageLatency                    Reference to an unsigned int for encode latency in microseconds
- * 
+ *
  * @return
  *         - \ref NVML_SUCCESS                  if \a sessionCount, \a averageFps and \a averageLatency is fetched
  *         - \ref NVML_ERROR_UNINITIALIZED      if the library has not been successfully initialized
@@ -4179,7 +4408,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetEncoderStats (nvmlDevice_t device, unsigned in
  * @param device                            The identifier of the target device
  * @param sessionCount                      Reference to caller supplied array size, and returns the number of sessions.
  * @param sessionInfos                      Reference in which to return the session information
- * 
+ *
  * @return
  *         - \ref NVML_SUCCESS                  if \a sessionInfos is fetched
  *         - \ref NVML_ERROR_UNINITIALIZED      if the library has not been successfully initialized
@@ -4274,15 +4503,15 @@ nvmlReturn_t DECLDIR nvmlDeviceGetFBCSessions(nvmlDevice_t device, unsigned int
  * @param device                               The identifier of the target device
  * @param current                              Reference in which to return the current driver model
  * @param pending                              Reference in which to return the pending driver model
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if either \a current and/or \a pending have been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or both \a current and \a pending are NULL
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the platform is not windows
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
- * 
+ *
  * @see nvmlDeviceSetDriverModel()
  */
 nvmlReturn_t DECLDIR nvmlDeviceGetDriverModel(nvmlDevice_t device, nvmlDriverModel_t *current, nvmlDriverModel_t *pending);
@@ -4292,18 +4521,18 @@ nvmlReturn_t DECLDIR nvmlDeviceGetDriverModel(nvmlDevice_t device, nvmlDriverMod
  *
  * For all products.
  *
- * The VBIOS version may change from time to time. It will not exceed 32 characters in length 
+ * The VBIOS version may change from time to time. It will not exceed 32 characters in length
  * (including the NULL terminator).  See \ref nvmlConstants::NVML_DEVICE_VBIOS_VERSION_BUFFER_SIZE.
  *
  * @param device                               The identifier of the target device
  * @param version                              Reference to which to return the VBIOS version
  * @param length                               The maximum allowed length of the string returned in \a version
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a version has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, or \a version is NULL
- *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small 
+ *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  */
@@ -4311,21 +4540,21 @@ nvmlReturn_t DECLDIR nvmlDeviceGetVbiosVersion(nvmlDevice_t device, char *versio
 
 /**
  * Get Bridge Chip Information for all the bridge chips on the board.
- * 
+ *
  * For all fully supported products.
  * Only applicable to multi-GPU products.
- * 
+ *
  * @param device                                The identifier of the target device
  * @param bridgeHierarchy                       Reference to the returned bridge chip Hierarchy
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if bridge chip exists
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, or \a bridgeInfo is NULL
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if bridge chip not supported on the device
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
- * 
+ *
  */
 nvmlReturn_t DECLDIR nvmlDeviceGetBridgeChipInfo(nvmlDevice_t device, nvmlBridgeChipHierarchy_t *bridgeHierarchy);
 
@@ -4370,7 +4599,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetBridgeChipInfo(nvmlDevice_t device, nvmlBridge
  *
  * @see \ref nvmlSystemGetProcessName
  */
-nvmlReturn_t DECLDIR nvmlDeviceGetComputeRunningProcesses_v2(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_t *infos);
+nvmlReturn_t DECLDIR nvmlDeviceGetComputeRunningProcesses_v3(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_t *infos);
 
 /**
  * Get information about processes with a graphics context on a device
@@ -4394,7 +4623,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetComputeRunningProcesses_v2(nvmlDevice_t device
  *       specific MIG device handles.
  *       Querying per-instance information using MIG device handles is not supported if the device is in vGPU Host virtualization mode.
  *
- * @param device                               The identifier of the target device
+ * @param device                               The device handle or MIG device handle
  * @param infoCount                            Reference in which to provide the \a infos array size, and
  *                                             to return the number of returned elements
  * @param infos                                Reference in which to return the process information
@@ -4413,7 +4642,50 @@ nvmlReturn_t DECLDIR nvmlDeviceGetComputeRunningProcesses_v2(nvmlDevice_t device
  *
  * @see \ref nvmlSystemGetProcessName
  */
-nvmlReturn_t DECLDIR nvmlDeviceGetGraphicsRunningProcesses_v2(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_t *infos);
+nvmlReturn_t DECLDIR nvmlDeviceGetGraphicsRunningProcesses_v3(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_t *infos);
+
+/**
+ * Get information about processes with a MPS compute context on a device
+ *
+ * For Volta &tm; or newer fully supported devices.
+ *
+ * This function returns information only about compute running processes (e.g. CUDA application which have
+ * active context) utilizing MPS. Any graphics applications (e.g. using OpenGL, DirectX) won't be listed by
+ * this function.
+ *
+ * To query the current number of running compute processes, call this function with *infoCount = 0. The
+ * return code will be NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if none are running. For this call
+ * \a infos is allowed to be NULL.
+ *
+ * The usedGpuMemory field returned is all of the memory used by the application.
+ *
+ * Keep in mind that information returned by this call is dynamic and the number of elements might change in
+ * time. Allocate more space for \a infos table in case new compute processes are spawned.
+ * 
+ * @note In MIG mode, if device handle is provided, the API returns aggregate information, only if
+ *       the caller has appropriate privileges. Per-instance information can be queried by using
+ *       specific MIG device handles.
+ *       Querying per-instance information using MIG device handles is not supported if the device is in vGPU Host virtualization mode.
+ *
+ * @param device                               The device handle or MIG device handle
+ * @param infoCount                            Reference in which to provide the \a infos array size, and
+ *                                             to return the number of returned elements
+ * @param infos                                Reference in which to return the process information
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 if \a infoCount and \a infos have been populated
+ *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
+ *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a infoCount indicates that the \a infos array is too small
+ *                                             \a infoCount will contain minimal amount of space necessary for
+ *                                             the call to complete
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, either of \a infoCount or \a infos is NULL
+ *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
+ *         - \ref NVML_ERROR_NOT_SUPPORTED     if this query is not supported by \a device
+ *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
+ *
+ * @see \ref nvmlSystemGetProcessName
+ */
+nvmlReturn_t DECLDIR nvmlDeviceGetMPSComputeRunningProcesses_v3(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_t *infos);
 
 /**
  * Check if the GPU devices are on the same physical board.
@@ -4443,7 +4715,7 @@ nvmlReturn_t DECLDIR nvmlDeviceOnSameBoard(nvmlDevice_t device1, nvmlDevice_t de
  *
  * @param device                               The identifier of the target device
  * @param apiType                              Target API type for this operation
- * @param isRestricted                         Reference in which to return the current restriction 
+ * @param isRestricted                         Reference in which to return the current restriction
  *                                             NVML_FEATURE_ENABLED indicates that the API is root-only
  *                                             NVML_FEATURE_DISABLED indicates that the API is accessible to all users
  *
@@ -4463,24 +4735,24 @@ nvmlReturn_t DECLDIR nvmlDeviceGetAPIRestriction(nvmlDevice_t device, nvmlRestri
 
 /**
  * Gets recent samples for the GPU.
- * 
+ *
  * For Kepler &tm; or newer fully supported devices.
- * 
- * Based on type, this method can be used to fetch the power, utilization or clock samples maintained in the buffer by 
+ *
+ * Based on type, this method can be used to fetch the power, utilization or clock samples maintained in the buffer by
  * the driver.
- * 
+ *
  * Power, Utilization and Clock samples are returned as type "unsigned int" for the union nvmlValue_t.
- * 
- * To get the size of samples that user needs to allocate, the method is invoked with samples set to NULL. 
- * The returned samplesCount will provide the number of samples that can be queried. The user needs to 
+ *
+ * To get the size of samples that user needs to allocate, the method is invoked with samples set to NULL.
+ * The returned samplesCount will provide the number of samples that can be queried. The user needs to
  * allocate the buffer with size as samplesCount * sizeof(nvmlSample_t).
- * 
- * lastSeenTimeStamp represents CPU timestamp in microseconds. Set it to 0 to fetch all the samples maintained by the 
- * underlying buffer. Set lastSeenTimeStamp to one of the timeStamps retrieved from the date of the previous query 
+ *
+ * lastSeenTimeStamp represents CPU timestamp in microseconds. Set it to 0 to fetch all the samples maintained by the
+ * underlying buffer. Set lastSeenTimeStamp to one of the timeStamps retrieved from the date of the previous query
  * to get more recent samples.
- * 
- * This method fetches the number of entries which can be accommodated in the provided samples array, and the 
- * reference samplesCount is updated to indicate how many samples were actually retrieved. The advantage of using this 
+ *
+ * This method fetches the number of entries which can be accommodated in the provided samples array, and the
+ * reference samplesCount is updated to indicate how many samples were actually retrieved. The advantage of using this
  * method for samples in contrast to polling via existing methods is to get get higher frequency data at lower polling cost.
  *
  * @note On MIG-enabled GPUs, querying the following sample types, NVML_GPU_UTILIZATION_SAMPLES, NVML_MEMORY_UTILIZATION_SAMPLES
@@ -4488,15 +4760,15 @@ nvmlReturn_t DECLDIR nvmlDeviceGetAPIRestriction(nvmlDevice_t device, nvmlRestri
  *
  * @param device                        The identifier for the target device
  * @param type                          Type of sampling event
- * @param lastSeenTimeStamp             Return only samples with timestamp greater than lastSeenTimeStamp. 
+ * @param lastSeenTimeStamp             Return only samples with timestamp greater than lastSeenTimeStamp.
  * @param sampleValType                 Output parameter to represent the type of sample value as described in nvmlSampleVal_t
  * @param sampleCount                   Reference to provide the number of elements which can be queried in samples array
  * @param samples                       Reference in which samples are returned
- 
- * @return 
+
+ * @return
  *         - \ref NVML_SUCCESS                 if samples are successfully retrieved
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
- *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, \a samplesCount is NULL or 
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, \a samplesCount is NULL or
  *                                             reference to \a sampleCount is 0 for non null \a samples
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if this query is not supported by the device
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
@@ -4508,9 +4780,9 @@ nvmlReturn_t DECLDIR nvmlDeviceGetSamples(nvmlDevice_t device, nvmlSamplingType_
 
 /**
  * Gets Total, Available and Used size of BAR1 memory.
- * 
- * BAR1 is used to map the FB (device memory) so that it can be directly accessed by the CPU or by 3rd party 
- * devices (peer-to-peer on the PCIE bus). 
+ *
+ * BAR1 is used to map the FB (device memory) so that it can be directly accessed by the CPU or by 3rd party
+ * devices (peer-to-peer on the PCIE bus).
  *
  * @note In MIG mode, if device handle is provided, the API returns aggregate
  *       information, only if the caller has appropriate privileges. Per-instance
@@ -4534,20 +4806,20 @@ nvmlReturn_t DECLDIR nvmlDeviceGetSamples(nvmlDevice_t device, nvmlSamplingType_
 nvmlReturn_t DECLDIR nvmlDeviceGetBAR1MemoryInfo(nvmlDevice_t device, nvmlBAR1Memory_t *bar1Memory);
 
 /**
- * Gets the duration of time during which the device was throttled (lower than requested clocks) due to power 
+ * Gets the duration of time during which the device was throttled (lower than requested clocks) due to power
  * or thermal constraints.
  *
  * The method is important to users who are tying to understand if their GPUs throttle at any point during their applications. The
- * difference in violation times at two different reference times gives the indication of GPU throttling event. 
+ * difference in violation times at two different reference times gives the indication of GPU throttling event.
  *
  * Violation for thermal capping is not supported at this time.
- * 
+ *
  * For Kepler &tm; or newer fully supported devices.
  *
  * @param device                               The identifier of the target device
  * @param perfPolicyType                       Represents Performance policy which can trigger GPU throttling
- * @param violTime                             Reference to which violation time related information is returned 
- *                                         
+ * @param violTime                             Reference to which violation time related information is returned
+ *
  *
  * @return
  *         - \ref NVML_SUCCESS                 if violation time is successfully retrieved
@@ -4559,6 +4831,102 @@ nvmlReturn_t DECLDIR nvmlDeviceGetBAR1MemoryInfo(nvmlDevice_t device, nvmlBAR1Me
  */
 nvmlReturn_t DECLDIR nvmlDeviceGetViolationStatus(nvmlDevice_t device, nvmlPerfPolicyType_t perfPolicyType, nvmlViolationTime_t *violTime);
 
+/**
+ * Gets the device's interrupt number
+ *
+ * @param device                               The identifier of the target device
+ * @param irqNum                               The interrupt number associated with the specified device
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 if irq number is successfully retrieved
+ *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, or \a irqNum is NULL
+ *         - \ref NVML_ERROR_NOT_SUPPORTED     if this query is not supported by the device
+ *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
+ *
+ */
+nvmlReturn_t DECLDIR nvmlDeviceGetIrqNum(nvmlDevice_t device, unsigned int *irqNum);
+
+/**
+ * Gets the device's core count
+ *
+ * @param device                               The identifier of the target device
+ * @param numCores                             The number of cores for the specified device
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 if Gpu core count is successfully retrieved
+ *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, or \a numCores is NULL
+ *         - \ref NVML_ERROR_NOT_SUPPORTED     if this query is not supported by the device
+ *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
+ *
+ */
+nvmlReturn_t DECLDIR nvmlDeviceGetNumGpuCores(nvmlDevice_t device, unsigned int *numCores);
+
+/**
+ * Gets the devices power source
+ *
+ * @param device                               The identifier of the target device
+ * @param powerSource                          The power source of the device
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 if the current power source was successfully retrieved
+ *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, or \a powerSource is NULL
+ *         - \ref NVML_ERROR_NOT_SUPPORTED     if this query is not supported by the device
+ *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
+ *
+ */
+nvmlReturn_t DECLDIR nvmlDeviceGetPowerSource(nvmlDevice_t device, nvmlPowerSource_t *powerSource);
+
+/**
+ * Gets the device's memory bus width
+ *
+ * @param device                               The identifier of the target device
+ * @param maxSpeed                             The devices's memory bus width
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 if the memory bus width is successfully retrieved
+ *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, or \a busWidth is NULL
+ *         - \ref NVML_ERROR_NOT_SUPPORTED     if this query is not supported by the device
+ *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
+ *
+ */
+nvmlReturn_t DECLDIR nvmlDeviceGetMemoryBusWidth(nvmlDevice_t device, unsigned int *busWidth);
+
+/**
+ * Gets the device's PCIE Max Link speed in MBPS
+ *
+ * @param device                               The identifier of the target device
+ * @param maxSpeed                             The devices's PCIE Max Link speed in MBPS
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 if Pcie Max Link Speed is successfully retrieved
+ *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, or \a maxSpeed is NULL
+ *         - \ref NVML_ERROR_NOT_SUPPORTED     if this query is not supported by the device
+ *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
+ *
+ */
+nvmlReturn_t DECLDIR nvmlDeviceGetPcieLinkMaxSpeed(nvmlDevice_t device, unsigned int *maxSpeed);
+
+/**
+ * Gets the device's Adaptive Clock status
+ *
+ * @param device                               The identifier of the target device
+ * @param adaptiveClockStatus                  The current adaptive clocking status
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 if the current adaptive clocking status is successfully retrieved
+ *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, or \a adaptiveClockStatus is NULL
+ *         - \ref NVML_ERROR_NOT_SUPPORTED     if this query is not supported by the device
+ *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
+ *
+ */
+nvmlReturn_t DECLDIR nvmlDeviceGetAdaptiveClockInfoStatus(nvmlDevice_t device, unsigned int *adaptiveClockStatus);
+
 /**
  * @}
  */
@@ -4578,8 +4946,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetViolationStatus(nvmlDevice_t device, nvmlPerfP
  * @param device                               The identifier of the target device
  * @param mode                                 Reference in which to return the current accounting mode
  *
- * @return 
- *         - \ref NVML_SUCCESS                 if the mode has been successfully retrieved 
+ * @return
+ *         - \ref NVML_SUCCESS                 if the mode has been successfully retrieved
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a mode are NULL
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device doesn't support this feature
@@ -4591,10 +4959,10 @@ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingMode(nvmlDevice_t device, nvmlEnable
  * Queries process's accounting stats.
  *
  * For Kepler &tm; or newer fully supported devices.
- * 
+ *
  * Accounting stats capture GPU utilization and other statistics across the lifetime of a process.
  * Accounting stats can be queried during life time of the process and after its termination.
- * The time field in \ref nvmlAccountingStats_t is reported as 0 during the lifetime of the process and 
+ * The time field in \ref nvmlAccountingStats_t is reported as 0 during the lifetime of the process and
  * updated to actual running time after its termination.
  * Accounting stats are kept in a circular buffer, newly created processes overwrite information about old
  * processes.
@@ -4608,12 +4976,12 @@ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingMode(nvmlDevice_t device, nvmlEnable
  * @note In case of pid collision stats of only the latest process (that terminated last) will be reported
  *
  * @warning On Kepler devices per process statistics are accurate only if there's one process running on a GPU.
- * 
+ *
  * @param device                               The identifier of the target device
  * @param pid                                  Process Id of the target process to query stats for
  * @param stats                                Reference in which to return the process's accounting stats
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if stats have been successfully retrieved
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a stats are NULL
@@ -4627,14 +4995,14 @@ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingMode(nvmlDevice_t device, nvmlEnable
 nvmlReturn_t DECLDIR nvmlDeviceGetAccountingStats(nvmlDevice_t device, unsigned int pid, nvmlAccountingStats_t *stats);
 
 /**
- * Queries list of processes that can be queried for accounting stats. The list of processes returned 
+ * Queries list of processes that can be queried for accounting stats. The list of processes returned
  * can be in running or terminated state.
  *
  * For Kepler &tm; or newer fully supported devices.
  *
  * To just query the number of processes ready to be queried, call this function with *count = 0 and
  * pids=NULL. The return code will be NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if list is empty.
- * 
+ *
  * For more details see \ref nvmlDeviceGetAccountingStats.
  *
  * @note In case of PID collision some processes might not be accessible before the circular buffer is full.
@@ -4643,8 +5011,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingStats(nvmlDevice_t device, unsigned
  * @param count                                Reference in which to provide the \a pids array size, and
  *                                               to return the number of elements ready to be queried
  * @param pids                                 Reference in which to return list of process ids
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if pids were successfully retrieved
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a count is NULL
@@ -4669,14 +5037,14 @@ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingPids(nvmlDevice_t device, unsigned i
  * @param device                               The identifier of the target device
  * @param bufferSize                           Reference in which to provide the size (in number of elements)
  *                                               of the circular buffer for accounting stats.
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if buffer size was successfully retrieved
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a bufferSize is NULL
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device doesn't support this feature or accounting mode is disabled
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
- * 
+ *
  * @see nvmlDeviceGetAccountingStats
  * @see nvmlDeviceGetAccountingPids
  */
@@ -4692,7 +5060,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingBufferSize(nvmlDevice_t device, unsi
  * Returns the list of retired pages by source, including pages that are pending retirement
  * The address information provided from this API is the hardware address of the page that was retired.  Note
  * that this does not match the virtual address used in CUDA, but will match the address information in XID 63
- * 
+ *
  * For Kepler &tm; or newer fully supported devices.
  *
  * @param device                            The identifier of the target device
@@ -4701,13 +5069,13 @@ nvmlReturn_t DECLDIR nvmlDeviceGetAccountingBufferSize(nvmlDevice_t device, unsi
  *                                          to return the number of retired pages that match \a cause
  *                                          Set to 0 to query the size without allocating an \a addresses buffer
  * @param addresses                         Buffer to write the page addresses into
- * 
+ *
  * @return
  *         - \ref NVML_SUCCESS                 if \a pageCount was populated and \a addresses was filled
  *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a pageCount indicates the buffer is not large enough to store all the
  *                                             matching page addresses.  \a pageCount is set to the needed size.
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
- *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, \a pageCount is NULL, \a cause is invalid, or 
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, \a pageCount is NULL, \a cause is invalid, or
  *                                             \a addresses is NULL
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device doesn't support this feature
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
@@ -4723,7 +5091,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetRetiredPages(nvmlDevice_t device, nvmlPageReti
  *
  * \note nvmlDeviceGetRetiredPages_v2 adds an additional timestamps paramter to return the time of each page's
  *       retirement.
- * 
+ *
  * For Kepler &tm; or newer fully supported devices.
  *
  * @param device                            The identifier of the target device
@@ -4733,13 +5101,13 @@ nvmlReturn_t DECLDIR nvmlDeviceGetRetiredPages(nvmlDevice_t device, nvmlPageReti
  *                                          Set to 0 to query the size without allocating an \a addresses buffer
  * @param addresses                         Buffer to write the page addresses into
  * @param timestamps                        Buffer to write the timestamps of page retirement, additional for _v2
- * 
+ *
  * @return
  *         - \ref NVML_SUCCESS                 if \a pageCount was populated and \a addresses was filled
  *         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a pageCount indicates the buffer is not large enough to store all the
  *                                             matching page addresses.  \a pageCount is set to the needed size.
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
- *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, \a pageCount is NULL, \a cause is invalid, or 
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid, \a pageCount is NULL, \a cause is invalid, or
  *                                             \a addresses is NULL
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device doesn't support this feature
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
@@ -4755,7 +5123,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetRetiredPages_v2(nvmlDevice_t device, nvmlPageR
  *
  * @param device                            The identifier of the target device
  * @param isPending                         Reference in which to return the pending status
- * 
+ *
  * @return
  *         - \ref NVML_SUCCESS                 if \a isPending was populated
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
@@ -4839,24 +5207,24 @@ nvmlReturn_t DECLDIR nvmlDeviceGetArchitecture(nvmlDevice_t device, nvmlDeviceAr
  * Requires root/admin permissions.
  *
  * This operation takes effect immediately.
- * 
  *
- * <b>Current S-Class products don't provide unique LEDs for each unit. As such, both front 
+ *
+ * <b>Current S-Class products don't provide unique LEDs for each unit. As such, both front
  * and back LEDs will be toggled in unison regardless of which unit is specified with this command.</b>
  *
  * See \ref nvmlLedColor_t for available colors.
  *
  * @param unit                                 The identifier of the target unit
  * @param color                                The target LED color
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if the LED color has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a unit or \a color is invalid
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if this is not an S-class product
  *         - \ref NVML_ERROR_NO_PERMISSION     if the user doesn't have permission to perform this operation
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
- * 
+ *
  * @see nvmlUnitGetLedState()
  */
 nvmlReturn_t DECLDIR nvmlUnitSetLedState(nvmlUnit_t unit, nvmlLedColor_t color);
@@ -4895,8 +5263,8 @@ nvmlReturn_t DECLDIR nvmlUnitSetLedState(nvmlUnit_t unit, nvmlLedColor_t color);
  *
  * @param device                               The identifier of the target device
  * @param mode                                 The target persistence mode
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if the persistence mode was set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a mode is invalid
@@ -4929,8 +5297,8 @@ nvmlReturn_t DECLDIR nvmlDeviceSetPersistenceMode(nvmlDevice_t device, nvmlEnabl
  *
  * @param device                               The identifier of the target device
  * @param mode                                 The target compute mode
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if the compute mode was set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a mode is invalid
@@ -4959,8 +5327,8 @@ nvmlReturn_t DECLDIR nvmlDeviceSetComputeMode(nvmlDevice_t device, nvmlComputeMo
  *
  * @param device                               The identifier of the target device
  * @param ecc                                  The target ECC mode
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if the ECC mode was set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a ecc is invalid
@@ -4971,7 +5339,7 @@ nvmlReturn_t DECLDIR nvmlDeviceSetComputeMode(nvmlDevice_t device, nvmlComputeMo
  *
  * @see nvmlDeviceGetEccMode()
  */
-nvmlReturn_t DECLDIR nvmlDeviceSetEccMode(nvmlDevice_t device, nvmlEnableState_t ecc);  
+nvmlReturn_t DECLDIR nvmlDeviceSetEccMode(nvmlDevice_t device, nvmlEnableState_t ecc);
 
 /**
  * Clear the ECC error and other memory error counts for the device.
@@ -4991,8 +5359,8 @@ nvmlReturn_t DECLDIR nvmlDeviceSetEccMode(nvmlDevice_t device, nvmlEnableState_t
  *
  * @param device                               The identifier of the target device
  * @param counterType                          Flag that indicates which type of errors should be cleared.
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if the error counts were cleared
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a counterType is invalid
@@ -5001,7 +5369,7 @@ nvmlReturn_t DECLDIR nvmlDeviceSetEccMode(nvmlDevice_t device, nvmlEnableState_t
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  *
- * @see 
+ * @see
  *      - nvmlDeviceGetDetailedEccErrors()
  *      - nvmlDeviceGetTotalEccErrors()
  */
@@ -5015,17 +5383,17 @@ nvmlReturn_t DECLDIR nvmlDeviceClearEccErrorCounts(nvmlDevice_t device, nvmlEccC
  * Requires root/admin permissions.
  *
  * On Windows platforms the device driver can run in either WDDM or WDM (TCC) mode. If a display is attached
- * to the device it must run in WDDM mode.  
+ * to the device it must run in WDDM mode.
  *
  * It is possible to force the change to WDM (TCC) while the display is still attached with a force flag (nvmlFlagForce).
  * This should only be done if the host is subsequently powered down and the display is detached from the device
- * before the next reboot. 
+ * before the next reboot.
  *
  * This operation takes effect after the next reboot.
- * 
+ *
  * Windows driver model may only be set to WDDM when running in DEFAULT compute mode.
  *
- * Change driver model to WDDM is not supported when GPU doesn't support graphics acceleration or 
+ * Change driver model to WDDM is not supported when GPU doesn't support graphics acceleration or
  * will not support it after reboot. See \ref nvmlDeviceSetGpuOperationMode.
  *
  * See \ref nvmlDriverModel_t for details on available driver models.
@@ -5034,8 +5402,8 @@ nvmlReturn_t DECLDIR nvmlDeviceClearEccErrorCounts(nvmlDevice_t device, nvmlEccC
  * @param device                               The identifier of the target device
  * @param driverModel                          The target driver model
  * @param flags                                Flags that change the default behavior
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if the driver model has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a driverModel is invalid
@@ -5043,7 +5411,7 @@ nvmlReturn_t DECLDIR nvmlDeviceClearEccErrorCounts(nvmlDevice_t device, nvmlEccC
  *         - \ref NVML_ERROR_NO_PERMISSION     if the user doesn't have permission to perform this operation
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
- * 
+ *
  * @see nvmlDeviceGetDriverModel()
  */
 nvmlReturn_t DECLDIR nvmlDeviceSetDriverModel(nvmlDevice_t device, nvmlDriverModel_t driverModel, unsigned int flags);
@@ -5055,37 +5423,91 @@ typedef enum nvmlClockLimitId_enum {
 } nvmlClockLimitId_t;
 
 /**
- * Set clocks that device will lock to.
+ * Set clocks that device will lock to.
+ *
+ * Sets the clocks that the device will be running at to the value in the range of minGpuClockMHz to maxGpuClockMHz.
+ * Setting this will supercede application clock values and take effect regardless if a cuda app is running.
+ * See /ref nvmlDeviceSetApplicationsClocks
+ *
+ * Can be used as a setting to request constant performance.
+ *
+ * This can be called with a pair of integer clock frequencies in MHz, or a pair of /ref nvmlClockLimitId_t values.
+ * See the table below for valid combinations of these values.
+ *
+ * minGpuClock | maxGpuClock | Effect
+ * ------------+-------------+--------------------------------------------------
+ *     tdp     |     tdp     | Lock clock to TDP
+ *  unlimited  |     tdp     | Upper bound is TDP but clock may drift below this
+ *     tdp     |  unlimited  | Lower bound is TDP but clock may boost above this
+ *  unlimited  |  unlimited  | Unlocked (== nvmlDeviceResetGpuLockedClocks)
+ *
+ * If one arg takes one of these values, the other must be one of these values as
+ * well. Mixed numeric and symbolic calls return NVML_ERROR_INVALID_ARGUMENT.
+ *
+ * Requires root/admin permissions.
+ *
+ * After system reboot or driver reload applications clocks go back to their default value.
+ * See \ref nvmlDeviceResetGpuLockedClocks.
+ *
+ * For Volta &tm; or newer fully supported devices.
+ *
+ * @param device                               The identifier of the target device
+ * @param minGpuClockMHz                       Requested minimum gpu clock in MHz
+ * @param maxGpuClockMHz                       Requested maximum gpu clock in MHz
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 if new settings were successfully set
+ *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a minGpuClockMHz and \a maxGpuClockMHz
+ *                                                 is not a valid clock combination
+ *         - \ref NVML_ERROR_NO_PERMISSION     if the user doesn't have permission to perform this operation
+ *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device doesn't support this feature
+ *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
+ *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
+ */
+nvmlReturn_t DECLDIR nvmlDeviceSetGpuLockedClocks(nvmlDevice_t device, unsigned int minGpuClockMHz, unsigned int maxGpuClockMHz);
+
+/**
+ * Resets the gpu clock to the default value
+ *
+ * This is the gpu clock that will be used after system reboot or driver reload.
+ * Default values are idle clocks, but the current values can be changed using \ref nvmlDeviceSetApplicationsClocks.
+ *
+ * @see nvmlDeviceSetGpuLockedClocks
+ *
+ * For Volta &tm; or newer fully supported devices.
+ *
+ * @param device                               The identifier of the target device
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 if new settings were successfully set
+ *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid
+ *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device does not support this feature
+ *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
+ *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
+ */
+nvmlReturn_t DECLDIR nvmlDeviceResetGpuLockedClocks(nvmlDevice_t device);
+
+/**
+ * Set memory clocks that device will lock to.
  *
- * Sets the clocks that the device will be running at to the value in the range of minGpuClockMHz to maxGpuClockMHz.
- * Setting this will supercede application clock values and take effect regardless if a cuda app is running.
+ * Sets the device's memory clocks to the value in the range of minMemClockMHz to maxMemClockMHz.
+ * Setting this will supersede application clock values and take effect regardless of whether a cuda app is running.
  * See /ref nvmlDeviceSetApplicationsClocks
  *
  * Can be used as a setting to request constant performance.
  *
- * This can be called with a pair of integer clock frequencies in MHz, or a pair of /ref nvmlClockLimitId_t values.
- * See the table below for valid combinations of these values.
- *
- * minGpuClock | maxGpuClock | Effect
- * ------------+-------------+--------------------------------------------------
- *     tdp     |     tdp     | Lock clock to TDP
- *  unlimited  |     tdp     | Upper bound is TDP but clock may drift below this
- *     tdp     |  unlimited  | Lower bound is TDP but clock may boost above this
- *  unlimited  |  unlimited  | Unlocked (== nvmlDeviceResetGpuLockedClocks)
- *
- * If one arg takes one of these values, the other must be one of these values as
- * well. Mixed numeric and symbolic calls return NVML_ERROR_INVALID_ARGUMENT.
- *
  * Requires root/admin permissions.
  *
  * After system reboot or driver reload applications clocks go back to their default value.
- * See \ref nvmlDeviceResetGpuLockedClocks.
+ * See \ref nvmlDeviceResetMemoryLockedClocks.
  *
- * For Volta &tm; or newer fully supported devices.
+ * For Ampere &tm; or newer fully supported devices.
  *
  * @param device                               The identifier of the target device
- * @param minGpuClockMHz                       Requested minimum gpu clock in MHz
- * @param maxGpuClockMHz                       Requested maximum gpu clock in MHz
+ * @param minMemClockMHz                       Requested minimum memory clock in MHz
+ * @param maxMemClockMHz                       Requested maximum memory clock in MHz
  *
  * @return
  *         - \ref NVML_SUCCESS                 if new settings were successfully set
@@ -5097,17 +5519,17 @@ typedef enum nvmlClockLimitId_enum {
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  */
-nvmlReturn_t DECLDIR nvmlDeviceSetGpuLockedClocks(nvmlDevice_t device, unsigned int minGpuClockMHz, unsigned int maxGpuClockMHz);
+nvmlReturn_t DECLDIR nvmlDeviceSetMemoryLockedClocks(nvmlDevice_t device, unsigned int minMemClockMHz, unsigned int maxMemClockMHz);
 
 /**
- * Resets the gpu clock to the default value
+ * Resets the memory clock to the default value
  *
- * This is the gpu clock that will be used after system reboot or driver reload.
+ * This is the memory clock that will be used after system reboot or driver reload.
  * Default values are idle clocks, but the current values can be changed using \ref nvmlDeviceSetApplicationsClocks.
  *
- * @see nvmlDeviceSetGpuLockedClocks
+ * @see nvmlDeviceSetMemoryLockedClocks
  *
- * For Volta &tm; or newer fully supported devices.
+ * For Ampere &tm; or newer fully supported devices.
  *
  * @param device                               The identifier of the target device
  *
@@ -5119,7 +5541,7 @@ nvmlReturn_t DECLDIR nvmlDeviceSetGpuLockedClocks(nvmlDevice_t device, unsigned
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  */
-nvmlReturn_t DECLDIR nvmlDeviceResetGpuLockedClocks(nvmlDevice_t device);
+nvmlReturn_t DECLDIR nvmlDeviceResetMemoryLockedClocks(nvmlDevice_t device);
 
 /**
  * Set clocks that applications will lock to.
@@ -5163,8 +5585,31 @@ nvmlReturn_t DECLDIR nvmlDeviceResetGpuLockedClocks(nvmlDevice_t device);
 nvmlReturn_t DECLDIR nvmlDeviceSetApplicationsClocks(nvmlDevice_t device, unsigned int memClockMHz, unsigned int graphicsClockMHz);
 
 /**
- * Set new power limit of this device.
+ * Retrieves the frequency monitor fault status for the device.
+ *
+ * For Ampere &tm; or newer fully supported devices.
+ * Requires root user.
+ *
+ * See \ref nvmlClkMonStatus_t for details on decoding the status output.
+ *
+ * @param device                               The identifier of the target device
+ * @param status                               Reference in which to return the clkmon fault status
  * 
+ * @return 
+ *         - \ref NVML_SUCCESS                 if \a status has been set
+ *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a status is NULL
+ *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device does not support this feature
+ *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
+ *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
+ *
+ * @see nvmlDeviceGetClkMonStatus()
+ */
+nvmlReturn_t DECLDIR nvmlDeviceGetClkMonStatus(nvmlDevice_t device, nvmlClkMonStatus_t *status);
+
+/**
+ * Set new power limit of this device.
+ *
  * For Kepler &tm; or newer fully supported devices.
  * Requires root/admin permissions.
  *
@@ -5175,8 +5620,8 @@ nvmlReturn_t DECLDIR nvmlDeviceSetApplicationsClocks(nvmlDevice_t device, unsign
  *
  * @param device                               The identifier of the target device
  * @param limit                                Power management limit in milliwatts to set
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a limit has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a defaultLimit is out of range
@@ -5196,17 +5641,17 @@ nvmlReturn_t DECLDIR nvmlDeviceSetPowerManagementLimit(nvmlDevice_t device, unsi
  * Modes \ref NVML_GOM_LOW_DP and \ref NVML_GOM_ALL_ON are supported on fully supported GeForce products.
  * Not supported on Quadro &reg; and Tesla &tm; C-class products.
  * Requires root/admin permissions.
- * 
- * Changing GOMs requires a reboot. 
+ *
+ * Changing GOMs requires a reboot.
  * The reboot requirement might be removed in the future.
  *
  * Compute only GOMs don't support graphics acceleration. Under windows switching to these GOMs when
  * pending driver model is WDDM is not supported. See \ref nvmlDeviceSetDriverModel.
- * 
+ *
  * @param device                               The identifier of the target device
  * @param mode                                 Target GOM
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a mode has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a mode incorrect
@@ -5225,7 +5670,7 @@ nvmlReturn_t DECLDIR nvmlDeviceSetGpuOperationMode(nvmlDevice_t device, nvmlGpuO
  * This method can be used by a root/admin user to give non-root/admin access to certain otherwise-restricted APIs.
  * The new setting lasts for the lifetime of the NVIDIA driver; it is not persistent. See \a nvmlDeviceGetAPIRestriction
  * to query the current restriction settings.
- * 
+ *
  * For Kepler &tm; or newer fully supported devices.
  * Requires root/admin permissions.
  *
@@ -5238,7 +5683,7 @@ nvmlReturn_t DECLDIR nvmlDeviceSetGpuOperationMode(nvmlDevice_t device, nvmlGpuO
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device is invalid or \a apiType incorrect
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device does not support changing API restrictions or the device does not support
- *                                                 the feature that api restrictions are being set for (E.G. Enabling/disabling auto 
+ *                                                 the feature that api restrictions are being set for (E.G. Enabling/disabling auto
  *                                                 boosted clocks is not supported by the device)
  *         - \ref NVML_ERROR_NO_PERMISSION     if the user doesn't have permission to perform this operation
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
@@ -5251,7 +5696,7 @@ nvmlReturn_t DECLDIR nvmlDeviceSetAPIRestriction(nvmlDevice_t device, nvmlRestri
 /**
  * @}
  */
- 
+
 /** @addtogroup nvmlAccountingStats
  *  @{
  */
@@ -5264,7 +5709,7 @@ nvmlReturn_t DECLDIR nvmlDeviceSetAPIRestriction(nvmlDevice_t device, nvmlRestri
  *
  * @note This setting is not persistent and will default to disabled after driver unloads.
  *       Enable persistence mode to be sure the setting doesn't switch off to disabled.
- * 
+ *
  * @note Enabling accounting mode has no negative impact on the GPU performance.
  *
  * @note Disabling accounting clears all accounting pids information.
@@ -5278,7 +5723,7 @@ nvmlReturn_t DECLDIR nvmlDeviceSetAPIRestriction(nvmlDevice_t device, nvmlRestri
  * @param device                               The identifier of the target device
  * @param mode                                 The target accounting mode
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if the new mode has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device or \a mode are invalid
@@ -5300,8 +5745,8 @@ nvmlReturn_t DECLDIR nvmlDeviceSetAccountingMode(nvmlDevice_t device, nvmlEnable
  *
  * @param device                               The identifier of the target device
  *
- * @return 
- *         - \ref NVML_SUCCESS                 if accounting information has been cleared 
+ * @return
+ *         - \ref NVML_SUCCESS                 if accounting information has been cleared
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device are invalid
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device doesn't support this feature
@@ -5327,10 +5772,10 @@ nvmlReturn_t DECLDIR nvmlDeviceClearAccountingPids(nvmlDevice_t device);
  * @param device                               The identifier of the target device
  * @param link                                 Specifies the NvLink link to be queried
  * @param isActive                             \a nvmlEnableState_t where NVML_FEATURE_ENABLED indicates that
- *                                             the link is active and NVML_FEATURE_DISABLED indicates it 
+ *                                             the link is active and NVML_FEATURE_DISABLED indicates it
  *                                             is inactive
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a isActive has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device or \a link is invalid or \a isActive is NULL
@@ -5348,7 +5793,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetNvLinkState(nvmlDevice_t device, unsigned int
  * @param link                                 Specifies the NvLink link to be queried
  * @param version                              Requested NvLink version
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a version has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device or \a link is invalid or \a version is NULL
@@ -5369,7 +5814,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetNvLinkVersion(nvmlDevice_t device, unsigned in
  * @param capability                           Specifies the \a nvmlNvLinkCapability_t to be queried
  * @param capResult                            A boolean for the queried capability indicating that feature is available
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a capResult has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device, \a link, or \a capability is invalid or \a capResult is NULL
@@ -5377,19 +5822,19 @@ nvmlReturn_t DECLDIR nvmlDeviceGetNvLinkVersion(nvmlDevice_t device, unsigned in
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  */
 nvmlReturn_t DECLDIR nvmlDeviceGetNvLinkCapability(nvmlDevice_t device, unsigned int link,
-                                                   nvmlNvLinkCapability_t capability, unsigned int *capResult); 
+                                                   nvmlNvLinkCapability_t capability, unsigned int *capResult);
 
 /**
- * Retrieves the PCI information for the remote node on a NvLink link 
+ * Retrieves the PCI information for the remote node on a NvLink link
  * Note: pciSubSystemId is not filled in this function and is indeterminate
  *
  * For Pascal &tm; or newer fully supported devices.
  *
  * @param device                               The identifier of the target device
  * @param link                                 Specifies the NvLink link to be queried
- * @param pci                                  \a nvmlPciInfo_t of the remote node for the specified link                            
+ * @param pci                                  \a nvmlPciInfo_t of the remote node for the specified link
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a pci has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device or \a link is invalid or \a pci is NULL
@@ -5409,7 +5854,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetNvLinkRemotePciInfo_v2(nvmlDevice_t device, un
  * @param counter                              Specifies the NvLink counter to be queried
  * @param counterValue                         Returned counter value
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a counter has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device, \a link, or \a counter is invalid or \a counterValue is NULL
@@ -5428,7 +5873,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetNvLinkErrorCounter(nvmlDevice_t device, unsign
  * @param device                               The identifier of the target device
  * @param link                                 Specifies the NvLink link to be queried
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if the reset is successful
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device or \a link is invalid
@@ -5452,10 +5897,10 @@ nvmlReturn_t DECLDIR nvmlDeviceResetNvLinkErrorCounters(nvmlDevice_t device, uns
  * @param control                              A reference to the \a nvmlNvLinkUtilizationControl_t to set
  * @param reset                                Resets the counters on set if non-zero
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if the control has been set successfully
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
- *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device, \a counter, \a link, or \a control is invalid 
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device, \a counter, \a link, or \a control is invalid
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device doesn't support this feature
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  */
@@ -5475,10 +5920,10 @@ nvmlReturn_t DECLDIR nvmlDeviceSetNvLinkUtilizationControl(nvmlDevice_t device,
  * @param link                                 Specifies the NvLink link to be queried
  * @param control                              A reference to the \a nvmlNvLinkUtilizationControl_t to place information
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if the control has been set successfully
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
- *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device, \a counter, \a link, or \a control is invalid 
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device, \a counter, \a link, or \a control is invalid
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device doesn't support this feature
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  */
@@ -5501,20 +5946,20 @@ nvmlReturn_t DECLDIR nvmlDeviceGetNvLinkUtilizationControl(nvmlDevice_t device,
  * @param rxcounter                            Receive counter return value
  * @param txcounter                            Transmit counter return value
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if \a rxcounter and \a txcounter have been successfully set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device, \a counter, or \a link is invalid or \a rxcounter or \a txcounter are NULL
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device doesn't support this feature
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  */
-nvmlReturn_t DECLDIR nvmlDeviceGetNvLinkUtilizationCounter(nvmlDevice_t device, unsigned int link, unsigned int counter, 
+nvmlReturn_t DECLDIR nvmlDeviceGetNvLinkUtilizationCounter(nvmlDevice_t device, unsigned int link, unsigned int counter,
                                                            unsigned long long *rxcounter, unsigned long long *txcounter);
 
 /**
  * Deprecated: Freezing NVLINK utilization counters is no longer supported.
  *
- * Freeze the NVLINK utilization counters 
+ * Freeze the NVLINK utilization counters
  * Both the receive and transmit counters are operated on by this function
  *
  * For Pascal &tm; or newer fully supported devices.
@@ -5525,20 +5970,20 @@ nvmlReturn_t DECLDIR nvmlDeviceGetNvLinkUtilizationCounter(nvmlDevice_t device,
  * @param freeze                               NVML_FEATURE_ENABLED = freeze the receive and transmit counters
  *                                             NVML_FEATURE_DISABLED = unfreeze the receive and transmit counters
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if counters were successfully frozen or unfrozen
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device, \a link, \a counter, or \a freeze is invalid
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the device doesn't support this feature
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  */
-nvmlReturn_t DECLDIR nvmlDeviceFreezeNvLinkUtilizationCounter (nvmlDevice_t device, unsigned int link, 
+nvmlReturn_t DECLDIR nvmlDeviceFreezeNvLinkUtilizationCounter (nvmlDevice_t device, unsigned int link,
                                             unsigned int counter, nvmlEnableState_t freeze);
 
 /**
  * Deprecated: Resetting NVLINK utilization counters is no longer supported.
  *
- * Reset the NVLINK utilization counters 
+ * Reset the NVLINK utilization counters
  * Both the receive and transmit counters are operated on by this function
  *
  * For Pascal &tm; or newer fully supported devices.
@@ -5547,7 +5992,7 @@ nvmlReturn_t DECLDIR nvmlDeviceFreezeNvLinkUtilizationCounter (nvmlDevice_t devi
  * @param link                                 Specifies the NvLink link to be reset
  * @param counter                              Specifies the counter that should be reset (0 or 1)
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if counters were successfully reset
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a device, \a link, or \a counter is invalid
@@ -5556,11 +6001,30 @@ nvmlReturn_t DECLDIR nvmlDeviceFreezeNvLinkUtilizationCounter (nvmlDevice_t devi
  */
 nvmlReturn_t DECLDIR nvmlDeviceResetNvLinkUtilizationCounter (nvmlDevice_t device, unsigned int link, unsigned int counter);
 
+/**
+* Get the NVLink device type of the remote device connected over the given link.
+*
+* @param device                                The device handle of the target GPU
+* @param link                                  The NVLink link index on the target GPU
+* @param pNvLinkDeviceType                     Pointer in which the output remote device type is returned
+*
+* @return
+*         - \ref NVML_SUCCESS                  if \a pNvLinkDeviceType has been set
+*         - \ref NVML_ERROR_UNINITIALIZED      if the library has not been successfully initialized
+*         - \ref NVML_ERROR_NOT_SUPPORTED      if NVLink is not supported
+*         - \ref NVML_ERROR_INVALID_ARGUMENT   if \a device or \a link is invalid, or
+*                                              \a pNvLinkDeviceType is NULL
+*         - \ref NVML_ERROR_GPU_IS_LOST        if the target GPU has fallen off the bus or is
+*                                              otherwise inaccessible
+*         - \ref NVML_ERROR_UNKNOWN            on any unexpected error
+*/
+nvmlReturn_t DECLDIR nvmlDeviceGetNvLinkRemoteDeviceType(nvmlDevice_t device, unsigned int link, nvmlIntNvLinkDeviceType_t *pNvLinkDeviceType);
+
 /** @} */
 
 /***************************************************************************************************/
 /** @defgroup nvmlEvents Event Handling Methods
- * This chapter describes methods that NVML can perform against each device to register and wait for 
+ * This chapter describes methods that NVML can perform against each device to register and wait for
  * some event to occur.
  *  @{
  */
@@ -5572,13 +6036,13 @@ nvmlReturn_t DECLDIR nvmlDeviceResetNvLinkUtilizationCounter (nvmlDevice_t devic
  *
  * For Fermi &tm; or newer fully supported devices.
  * @param set                                  Reference in which to return the event handle
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if the event has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a set is NULL
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
- * 
+ *
  * @see nvmlEventSetFree
  */
 nvmlReturn_t DECLDIR nvmlEventSetCreate(nvmlEventSet_t *set);
@@ -5605,15 +6069,15 @@ nvmlReturn_t DECLDIR nvmlEventSetCreate(nvmlEventSet_t *set);
  * @param device                               The identifier of the target device
  * @param eventTypes                           Bitmask of \ref nvmlEventType to record
  * @param set                                  Set to which add new event types
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if the event has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a eventTypes is invalid or \a set is NULL
  *         - \ref NVML_ERROR_NOT_SUPPORTED     if the platform does not support this feature or some of requested event types
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
- * 
+ *
  * @see nvmlEventType
  * @see nvmlDeviceGetSupportedEventTypes
  * @see nvmlEventSetWait
@@ -5630,14 +6094,14 @@ nvmlReturn_t DECLDIR nvmlDeviceRegisterEvents(nvmlDevice_t device, unsigned long
  *
  * @param device                               The identifier of the target device
  * @param eventTypes                           Reference in which to return bitmask of supported events
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if the eventTypes has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a eventType is NULL
  *         - \ref NVML_ERROR_GPU_IS_LOST       if the target GPU has fallen off the bus or is otherwise inaccessible
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
- * 
+ *
  * @see nvmlEventType
  * @see nvmlDeviceRegisterEvents
  */
@@ -5649,7 +6113,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetSupportedEventTypes(nvmlDevice_t device, unsig
  * For Fermi &tm; or newer fully supported devices.
  *
  * If some events are ready to be delivered at the time of the call, function returns immediately.
- * If there are no events ready to be delivered, function sleeps till event arrives 
+ * If there are no events ready to be delivered, function sleeps till event arrives
  * but not longer than specified timeout. This function in certain conditions can return before
  * specified timeout passes (e.g. when interrupt arrives)
  *
@@ -5668,15 +6132,15 @@ nvmlReturn_t DECLDIR nvmlDeviceGetSupportedEventTypes(nvmlDevice_t device, unsig
  * @param set                                  Reference to set of events to wait on
  * @param data                                 Reference in which to return event data
  * @param timeoutms                            Maximum amount of wait time in milliseconds for registered event
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if the data has been set
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a data is NULL
  *         - \ref NVML_ERROR_TIMEOUT           if no event arrived in specified timeout or interrupt arrived
  *         - \ref NVML_ERROR_GPU_IS_LOST       if a GPU has fallen off the bus or is otherwise inaccessible
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
- * 
+ *
  * @see nvmlEventType
  * @see nvmlDeviceRegisterEvents
  */
@@ -5687,13 +6151,13 @@ nvmlReturn_t DECLDIR nvmlEventSetWait_v2(nvmlEventSet_t set, nvmlEventData_t * d
  *
  * For Fermi &tm; or newer fully supported devices.
  *
- * @param set                                  Reference to events to be released 
- * 
- * @return 
+ * @param set                                  Reference to events to be released
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if the event has been successfully released
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
- * 
+ *
  * @see nvmlDeviceRegisterEvents
  */
 nvmlReturn_t DECLDIR nvmlEventSetFree(nvmlEventSet_t set);
@@ -5701,7 +6165,7 @@ nvmlReturn_t DECLDIR nvmlEventSetFree(nvmlEventSet_t set);
 /** @} */
 
 /***************************************************************************************************/
-/** @defgroup nvmlZPI Drain states 
+/** @defgroup nvmlZPI Drain states
  * This chapter describes methods that NVML can perform against each device to control their drain state
  * and recognition by NVML and NVIDIA kernel driver. These methods can be used with out-of-band tools to
  * power on/off GPUs, enable robust reset scenarios, etc.
@@ -5715,14 +6179,14 @@ nvmlReturn_t DECLDIR nvmlEventSetFree(nvmlEventSet_t set);
  * this call is made.
  * Must be called as administrator.
  * For Linux only.
- * 
+ *
  * For Pascal &tm; or newer fully supported devices.
  * Some Kepler devices supported.
  *
  * @param pciInfo                              The PCI address of the GPU drain state to be modified
  * @param newState                             The drain state that should be entered, see \ref nvmlEnableState_t
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if counters were successfully reset
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a nvmlIndex or \a newState is invalid
@@ -5737,14 +6201,14 @@ nvmlReturn_t DECLDIR nvmlDeviceModifyDrainState (nvmlPciInfo_t *pciInfo, nvmlEna
  * Query the drain state of a GPU.  This method is used to check if a GPU is in a currently draining
  * state.
  * For Linux only.
- * 
+ *
  * For Pascal &tm; or newer fully supported devices.
  * Some Kepler devices supported.
  *
  * @param pciInfo                              The PCI address of the GPU drain state to be queried
  * @param currentState                         The current drain state for this GPU, see \ref nvmlEnableState_t
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if counters were successfully reset
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a nvmlIndex or \a currentState is invalid
@@ -5758,14 +6222,14 @@ nvmlReturn_t DECLDIR nvmlDeviceQueryDrainState (nvmlPciInfo_t *pciInfo, nvmlEnab
  * as long as no other processes are attached. If other processes are attached, this call will return
  * NVML_ERROR_IN_USE and the GPU will be returned to its original "draining" state. Note: the
  * only situation where a process can still be attached after nvmlDeviceModifyDrainState() is called
- * to initiate the draining state is if that process was using, and is still using, a GPU before the 
+ * to initiate the draining state is if that process was using, and is still using, a GPU before the
  * call was made. Also note, persistence mode counts as an attachment to the GPU thus it must be disabled
  * prior to this call.
  *
  * For long-running NVML processes please note that this will change the enumeration of current GPUs.
  * For example, if there are four GPUs present and GPU1 is removed, the new enumeration will be 0-2.
  * Also, device handles after the removed GPU will not be valid and must be re-established.
- * Must be run as administrator. 
+ * Must be run as administrator.
  * For Linux only.
  *
  * For Pascal &tm; or newer fully supported devices.
@@ -5787,7 +6251,7 @@ nvmlReturn_t DECLDIR nvmlDeviceRemoveGpu_v2(nvmlPciInfo_t *pciInfo, nvmlDetachGp
 
 /**
  * Request the OS and the NVIDIA kernel driver to rediscover a portion of the PCI subsystem looking for GPUs that
- * were previously removed. The portion of the PCI tree can be narrowed by specifying a domain, bus, and device.  
+ * were previously removed. The portion of the PCI tree can be narrowed by specifying a domain, bus, and device.
  * If all are zeroes then the entire PCI tree will be searched.  Please note that for long-running NVML processes
  * the enumeration will change based on how many GPUs are discovered and where they are inserted in bus order.
  *
@@ -5796,14 +6260,14 @@ nvmlReturn_t DECLDIR nvmlDeviceRemoveGpu_v2(nvmlPciInfo_t *pciInfo, nvmlDetachGp
  *
  * Must be run as administrator.
  * For Linux only.
- * 
+ *
  * For Pascal &tm; or newer fully supported devices.
  * Some Kepler devices supported.
  *
  * @param pciInfo                              The PCI tree to be searched.  Only the domain, bus, and device
  *                                             fields are used in this call.
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                 if counters were successfully reset
  *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a pciInfo is invalid
@@ -5865,8 +6329,8 @@ nvmlReturn_t DECLDIR nvmlDeviceGetFieldValues(nvmlDevice_t device, int valuesCou
  *
  * @param device                    Identifier of the target device
  * @param pVirtualMode              Reference to virtualization mode. One of NVML_GPU_VIRTUALIZATION_?
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                  if \a pVirtualMode is fetched
  *         - \ref NVML_ERROR_UNINITIALIZED      if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT   if \a device is invalid or \a pVirtualMode is NULL
@@ -5901,7 +6365,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetHostVgpuMode(nvmlDevice_t device, nvmlHostVgpu
  * @param device                    Identifier of the target device
  * @param virtualMode               virtualization mode. One of NVML_GPU_VIRTUALIZATION_?
  *
- * @return 
+ * @return
  *         - \ref NVML_SUCCESS                  if \a pVirtualMode is set
  *         - \ref NVML_ERROR_UNINITIALIZED      if the library has not been successfully initialized
  *         - \ref NVML_ERROR_INVALID_ARGUMENT   if \a device is invalid or \a pVirtualMode is NULL
@@ -5925,7 +6389,7 @@ nvmlReturn_t DECLDIR nvmlDeviceSetVirtualizationMode(nvmlDevice_t device, nvmlGp
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a pGridLicensableFeatures is NULL
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  */
-nvmlReturn_t DECLDIR nvmlDeviceGetGridLicensableFeatures_v3(nvmlDevice_t device, nvmlGridLicensableFeatures_t *pGridLicensableFeatures);
+nvmlReturn_t DECLDIR nvmlDeviceGetGridLicensableFeatures_v4(nvmlDevice_t device, nvmlGridLicensableFeatures_t *pGridLicensableFeatures);
 
 /**
  * Retrieves the current utilization and process ID
@@ -6357,6 +6821,8 @@ nvmlReturn_t DECLDIR nvmlVgpuInstanceGetVmDriverVersion(nvmlVgpuInstance_t vgpuI
 nvmlReturn_t DECLDIR nvmlVgpuInstanceGetFbUsage(nvmlVgpuInstance_t vgpuInstance, unsigned long long *fbUsage);
 
 /**
+ * @deprecated Use \ref nvmlVgpuInstanceGetLicenseInfo_v2.
+ *
  * Retrieve the current licensing state of the vGPU instance.
  *
  * If the vGPU is currently licensed, \a licensed is set to 1, otherwise it is set to 0.
@@ -6582,6 +7048,45 @@ nvmlReturn_t DECLDIR nvmlVgpuInstanceGetFBCSessions(nvmlVgpuInstance_t vgpuInsta
 */
 nvmlReturn_t DECLDIR nvmlVgpuInstanceGetGpuInstanceId(nvmlVgpuInstance_t vgpuInstance, unsigned int *gpuInstanceId);
 
+/**
+* Retrieves the PCI Id of the given vGPU Instance i.e. the PCI Id of the GPU as seen inside the VM.
+*
+* The vGPU PCI id is returned as "00000000:00:00.0" if NVIDIA driver is not installed on the vGPU instance.
+*
+* @param vgpuInstance                         Identifier of the target vGPU instance
+* @param vgpuPciId                            Caller-supplied buffer to return vGPU PCI Id string
+* @param length                               Size of the vgpuPciId buffer
+*
+* @return
+*         - \ref NVML_SUCCESS                 if vGPU PCI Id is sucessfully retrieved
+*         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
+*         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a vgpuInstance is 0, or \a vgpuPciId is NULL
+*         - \ref NVML_ERROR_NOT_FOUND         if \a vgpuInstance does not match a valid active vGPU instance on the system
+*         - \ref NVML_ERROR_DRIVER_NOT_LOADED if NVIDIA driver is not running on the vGPU instance
+*         - \ref NVML_ERROR_INSUFFICIENT_SIZE if \a length is too small, \a length is set to required length
+*         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
+*/
+nvmlReturn_t DECLDIR nvmlVgpuInstanceGetGpuPciId(nvmlVgpuInstance_t vgpuInstance, char *vgpuPciId, unsigned int *length);
+
+/**
+* Retrieve the requested capability for a given vGPU type. Refer to the \a nvmlVgpuCapability_t structure
+* for the specific capabilities that can be queried. The return value in \a capResult should be treated as
+* a boolean, with a non-zero value indicating that the capability is supported.
+*
+* For Maxwell &tm; or newer fully supported devices.
+*
+* @param vgpuTypeId                           Handle to vGPU type
+* @param capability                           Specifies the \a nvmlVgpuCapability_t to be queried
+* @param capResult                            A boolean for the queried capability indicating that feature is supported
+*
+* @return
+*         - \ref NVML_SUCCESS                 successful completion
+*         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
+*         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a vgpuTypeId is invalid, or \a capability is invalid, or \a capResult is NULL
+*         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
+*/
+nvmlReturn_t DECLDIR nvmlVgpuTypeGetCapabilities(nvmlVgpuTypeId_t vgpuTypeId, nvmlVgpuCapability_t capability, unsigned int *capResult);
+
 /** @} */
 
 /***************************************************************************************************/
@@ -6641,7 +7146,7 @@ typedef enum nvmlVgpuVmCompatibility_enum
     NVML_VGPU_VM_COMPATIBILITY_COLD         = 0x1,    //!< vGPU is runnable from a cold / powered-off state (ACPI S5)
     NVML_VGPU_VM_COMPATIBILITY_HIBERNATE    = 0x2,    //!< vGPU is runnable from a hibernated state (ACPI S4)
     NVML_VGPU_VM_COMPATIBILITY_SLEEP        = 0x4,    //!< vGPU is runnable from a sleeped state (ACPI S3)
-    NVML_VGPU_VM_COMPATIBILITY_LIVE         = 0x8,    //!< vGPU is runnable from a live/paused (ACPI S0)
+    NVML_VGPU_VM_COMPATIBILITY_LIVE         = 0x8     //!< vGPU is runnable from a live/paused (ACPI S0)
 } nvmlVgpuVmCompatibility_t;
 
 /**
@@ -6653,7 +7158,7 @@ typedef enum nvmlVgpuPgpuCompatibilityLimitCode_enum
     NVML_VGPU_COMPATIBILITY_LIMIT_HOST_DRIVER   = 0x1,           //!< ompatibility is limited by host driver version.
     NVML_VGPU_COMPATIBILITY_LIMIT_GUEST_DRIVER  = 0x2,           //!< Compatibility is limited by guest driver version.
     NVML_VGPU_COMPATIBILITY_LIMIT_GPU           = 0x4,           //!< Compatibility is limited by GPU hardware.
-    NVML_VGPU_COMPATIBILITY_LIMIT_OTHER         = 0x80000000,    //!< Compatibility is limited by an undefined factor.
+    NVML_VGPU_COMPATIBILITY_LIMIT_OTHER         = 0x80000000     //!< Compatibility is limited by an undefined factor.
 } nvmlVgpuPgpuCompatibilityLimitCode_t;
 
 /**
@@ -6764,7 +7269,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetPgpuMetadataString(nvmlDevice_t device, char *
  * Virtual GPU (vGPU) version
  *
  * The NVIDIA vGPU Manager and the guest drivers are tagged with a range of supported vGPU versions. This determines the range of NVIDIA guest driver versions that
- * are compatible for vGPU feature support with a given NVIDIA vGPU Manager. For vGPU feature support, the range of supported versions for the NVIDIA vGPU Manager 
+ * are compatible for vGPU feature support with a given NVIDIA vGPU Manager. For vGPU feature support, the range of supported versions for the NVIDIA vGPU Manager
  * and the guest driver must overlap. Otherwise, the guest driver fails to load in the VM.
  *
  * When the NVIDIA guest driver loads, either when the VM is booted or when the driver is installed or upgraded, a negotiation occurs between the guest driver
@@ -6805,7 +7310,7 @@ nvmlReturn_t DECLDIR nvmlGetVgpuVersion(nvmlVgpuVersion_t *supported, nvmlVgpuVe
  *
  * @note 1. The range set by the administrator must be a subset of the preset range that the NVIDIA vGPU Manager supports. Otherwise, an error is returned.
  *       2. If the range of supported guest driver versions does not overlap the range set by the administrator, the guest driver fails to load.
- *       3. If the range of supported guest driver versions overlaps the range set by the administrator, the guest driver will load with a negotiated 
+ *       3. If the range of supported guest driver versions overlaps the range set by the administrator, the guest driver will load with a negotiated
  *          vGPU version that is the maximum value in the overlapping range.
  *       4. No VMs must be running on the host when this function is called. If a VM is running on the host, the call to this function fails.
  *
@@ -6822,7 +7327,7 @@ nvmlReturn_t DECLDIR nvmlSetVgpuVersion(nvmlVgpuVersion_t *vgpuVersion);
 /** @} */
 
 /***************************************************************************************************/
-/** @defgroup nvmlUtil vGPU Utilization and Accounting 
+/** @defgroup nvmlUtil vGPU Utilization and Accounting
  * This chapter describes operations that are associated with vGPU Utilization and Accounting.
  *  @{
  */
@@ -7029,56 +7534,73 @@ nvmlReturn_t DECLDIR nvmlVgpuInstanceGetAccountingStats(nvmlVgpuInstance_t vgpuI
  *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
  */
 nvmlReturn_t DECLDIR nvmlVgpuInstanceClearAccountingPids(nvmlVgpuInstance_t vgpuInstance);
+
+/**
+ * Query the license information of the vGPU instance.
+ *
+ * For Maxwell &tm; or newer fully supported devices.
+ *
+ * @param vgpuInstance              Identifier of the target vGPU instance
+ * @param licenseInfo               Pointer to vGPU license information structure
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 if information is successfully retrieved
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a vgpuInstance is 0, or \a licenseInfo is NULL
+ *         - \ref NVML_ERROR_NOT_FOUND         if \a vgpuInstance does not match a valid active vGPU instance on the system
+ *         - \ref NVML_ERROR_DRIVER_NOT_LOADED if NVIDIA driver is not running on the vGPU instance
+ *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
+ */
+nvmlReturn_t DECLDIR nvmlVgpuInstanceGetLicenseInfo_v2(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuLicenseInfo_t *licenseInfo);
 /** @} */
 
 /***************************************************************************************************/
-/** @defgroup nvmlGpuBlacklistQueries GPU Blacklist Queries
- * This chapter describes NVML operations that are associated with blacklisted GPUs.
+/** @defgroup nvmlExcludedGpuQueries Excluded GPU Queries
+ * This chapter describes NVML operations that are associated with excluded GPUs.
  *  @{
  */
 /***************************************************************************************************/
 
 /**
- * Blacklist GPU device information
+ * Excluded GPU device information
  **/
-typedef struct nvmlBlacklistDeviceInfo_st
+typedef struct nvmlExcludedDeviceInfo_st
 {
-    nvmlPciInfo_t pciInfo;                   //!< The PCI information for the blacklisted GPU
-    char uuid[NVML_DEVICE_UUID_BUFFER_SIZE]; //!< The ASCII string UUID for the blacklisted GPU
-} nvmlBlacklistDeviceInfo_t;
+    nvmlPciInfo_t pciInfo;                   //!< The PCI information for the excluded GPU
+    char uuid[NVML_DEVICE_UUID_BUFFER_SIZE]; //!< The ASCII string UUID for the excluded GPU
+} nvmlExcludedDeviceInfo_t;
 
  /**
- * Retrieves the number of blacklisted GPU devices in the system.
- * 
+ * Retrieves the number of excluded GPU devices in the system.
+ *
  * For all products.
  *
- * @param deviceCount                          Reference in which to return the number of blacklisted devices
- * 
- * @return 
+ * @param deviceCount                          Reference in which to return the number of excluded devices
+ *
+ * @return
  *         - \ref NVML_SUCCESS                 if \a deviceCount has been set
  *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \a deviceCount is NULL
  */
-nvmlReturn_t DECLDIR nvmlGetBlacklistDeviceCount(unsigned int *deviceCount);
+nvmlReturn_t DECLDIR nvmlGetExcludedDeviceCount(unsigned int *deviceCount);
 
 /**
- * Acquire the device information for a blacklisted device, based on its index.
- * 
+ * Acquire the device information for an excluded GPU device, based on its index.
+ *
  * For all products.
  *
- * Valid indices are derived from the \a deviceCount returned by 
- *   \ref nvmlGetBlacklistDeviceCount(). For example, if \a deviceCount is 2 the valid indices  
+ * Valid indices are derived from the \a deviceCount returned by
+ *   \ref nvmlGetExcludedDeviceCount(). For example, if \a deviceCount is 2 the valid indices
  *   are 0 and 1, corresponding to GPU 0 and GPU 1.
  *
  * @param index                                The index of the target GPU, >= 0 and < \a deviceCount
  * @param info                                 Reference in which to return the device information
- * 
- * @return 
+ *
+ * @return
  *         - \ref NVML_SUCCESS                  if \a device has been set
  *         - \ref NVML_ERROR_INVALID_ARGUMENT   if \a index is invalid or \a info is NULL
  *
- * @see nvmlGetBlacklistDeviceCount
+ * @see nvmlGetExcludedDeviceCount
  */
-nvmlReturn_t DECLDIR nvmlGetBlacklistDeviceInfoByIndex(unsigned int index, nvmlBlacklistDeviceInfo_t *info);
+nvmlReturn_t DECLDIR nvmlGetExcludedDeviceInfoByIndex(unsigned int index, nvmlExcludedDeviceInfo_t *info);
 
 /** @} */
 
@@ -7105,21 +7627,25 @@ nvmlReturn_t DECLDIR nvmlGetBlacklistDeviceInfoByIndex(unsigned int index, nvmlB
  * These macros should be passed to \ref nvmlDeviceGetGpuInstanceProfileInfo to retrieve the
  * detailed information about a GPU instance such as profile ID, engine counts.
  */
-#define NVML_GPU_INSTANCE_PROFILE_1_SLICE 0x0
-#define NVML_GPU_INSTANCE_PROFILE_2_SLICE 0x1
-#define NVML_GPU_INSTANCE_PROFILE_3_SLICE 0x2
-#define NVML_GPU_INSTANCE_PROFILE_4_SLICE 0x3
-#define NVML_GPU_INSTANCE_PROFILE_7_SLICE 0x4
-#define NVML_GPU_INSTANCE_PROFILE_8_SLICE 0x5
-#define NVML_GPU_INSTANCE_PROFILE_6_SLICE 0x6
-#define NVML_GPU_INSTANCE_PROFILE_COUNT   0x7
+#define NVML_GPU_INSTANCE_PROFILE_1_SLICE      0x0
+#define NVML_GPU_INSTANCE_PROFILE_2_SLICE      0x1
+#define NVML_GPU_INSTANCE_PROFILE_3_SLICE      0x2
+#define NVML_GPU_INSTANCE_PROFILE_4_SLICE      0x3
+#define NVML_GPU_INSTANCE_PROFILE_7_SLICE      0x4
+#define NVML_GPU_INSTANCE_PROFILE_8_SLICE      0x5
+#define NVML_GPU_INSTANCE_PROFILE_6_SLICE      0x6
+#define NVML_GPU_INSTANCE_PROFILE_1_SLICE_REV1 0x7
+#define NVML_GPU_INSTANCE_PROFILE_COUNT        0x8
 
 typedef struct nvmlGpuInstancePlacement_st
 {
-    unsigned int start;
-    unsigned int size;
+    unsigned int start;               //!< Index of first occupied memory slice
+    unsigned int size;                //!< Number of memory slices occupied
 } nvmlGpuInstancePlacement_t;
 
+/**
+ * GPU instance profile information.
+ */
 typedef struct nvmlGpuInstanceProfileInfo_st
 {
     unsigned int id;                  //!< Unique profile ID within the device
@@ -7135,6 +7661,36 @@ typedef struct nvmlGpuInstanceProfileInfo_st
     unsigned long long memorySizeMB;  //!< Memory size in MBytes
 } nvmlGpuInstanceProfileInfo_t;
 
+/**
+ * GPU instance profile information (v2).
+ * 
+ * Version 2 adds the \ref nvmlGpuInstanceProfileInfo_v2_t.version field
+ * to the start of the structure, and the \ref nvmlGpuInstanceProfileInfo_v2_t.name
+ * field to the end. This structure is not backwards-compatible with
+ * \ref nvmlGpuInstanceProfileInfo_t.
+ */
+typedef struct nvmlGpuInstanceProfileInfo_v2_st
+{
+    unsigned int version;                       //!< Structure version identifier (set to \ref nvmlGpuInstanceProfileInfo_v2)
+    unsigned int id;                            //!< Unique profile ID within the device
+    unsigned int isP2pSupported;                //!< Peer-to-Peer support
+    unsigned int sliceCount;                    //!< GPU Slice count
+    unsigned int instanceCount;                 //!< GPU instance count
+    unsigned int multiprocessorCount;           //!< Streaming Multiprocessor count
+    unsigned int copyEngineCount;               //!< Copy Engine count
+    unsigned int decoderCount;                  //!< Decoder Engine count
+    unsigned int encoderCount;                  //!< Encoder Engine count
+    unsigned int jpegCount;                     //!< JPEG Engine count
+    unsigned int ofaCount;                      //!< OFA Engine count
+    unsigned long long memorySizeMB;            //!< Memory size in MBytes
+    char name[NVML_DEVICE_NAME_V2_BUFFER_SIZE]; //!< Profile name
+} nvmlGpuInstanceProfileInfo_v2_t;
+
+/**
+ * Version identifier value for \ref nvmlGpuInstanceProfileInfo_v2_t.version.
+ */
+#define nvmlGpuInstanceProfileInfo_v2 NVML_STRUCT_VERSION(GpuInstanceProfileInfo, 2)
+
 typedef struct nvmlGpuInstanceInfo_st
 {
     nvmlDevice_t device;                      //!< Parent device
@@ -7165,10 +7721,13 @@ typedef struct nvmlGpuInstance_st* nvmlGpuInstance_t;
 
 typedef struct nvmlComputeInstancePlacement_st
 {
-    unsigned int start;
-    unsigned int size;
+    unsigned int start;                 //!< Index of first occupied compute slice
+    unsigned int size;                  //!< Number of compute slices occupied
 } nvmlComputeInstancePlacement_t;
 
+/**
+ * Compute instance profile information.
+ */
 typedef struct nvmlComputeInstanceProfileInfo_st
 {
     unsigned int id;                    //!< Unique profile ID within the GPU instance
@@ -7182,13 +7741,41 @@ typedef struct nvmlComputeInstanceProfileInfo_st
     unsigned int sharedOfaCount;        //!< Shared OFA Engine count
 } nvmlComputeInstanceProfileInfo_t;
 
+/**
+ * Compute instance profile information (v2).
+ * 
+ * Version 2 adds the \ref nvmlComputeInstanceProfileInfo_v2_t.version field
+ * to the start of the structure, and the \ref nvmlComputeInstanceProfileInfo_v2_t.name
+ * field to the end. This structure is not backwards-compatible with
+ * \ref nvmlComputeInstanceProfileInfo_t.
+ */
+typedef struct nvmlComputeInstanceProfileInfo_v2_st
+{
+    unsigned int version;                       //!< Structure version identifier (set to \ref nvmlComputeInstanceProfileInfo_v2)
+    unsigned int id;                            //!< Unique profile ID within the GPU instance
+    unsigned int sliceCount;                    //!< GPU Slice count
+    unsigned int instanceCount;                 //!< Compute instance count
+    unsigned int multiprocessorCount;           //!< Streaming Multiprocessor count
+    unsigned int sharedCopyEngineCount;         //!< Shared Copy Engine count
+    unsigned int sharedDecoderCount;            //!< Shared Decoder Engine count
+    unsigned int sharedEncoderCount;            //!< Shared Encoder Engine count
+    unsigned int sharedJpegCount;               //!< Shared JPEG Engine count
+    unsigned int sharedOfaCount;                //!< Shared OFA Engine count
+    char name[NVML_DEVICE_NAME_V2_BUFFER_SIZE]; //!< Profile name
+} nvmlComputeInstanceProfileInfo_v2_t;
+
+/**
+ * Version identifier value for \ref nvmlComputeInstanceProfileInfo_v2_t.version.
+ */
+#define nvmlComputeInstanceProfileInfo_v2 NVML_STRUCT_VERSION(ComputeInstanceProfileInfo, 2)
+
 typedef struct nvmlComputeInstanceInfo_st
 {
     nvmlDevice_t device;                      //!< Parent device
     nvmlGpuInstance_t gpuInstance;            //!< Parent GPU instance
     unsigned int id;                          //!< Unique instance ID within the GPU instance
     unsigned int profileId;                   //!< Unique profile ID within the GPU instance
-    nvmlComputeInstancePlacement_t placement; //!< Placement for this instance within the GPU instance's slice range {0, sliceCount}
+    nvmlComputeInstancePlacement_t placement; //!< Placement for this instance within the GPU instance's compute slice range {0, sliceCount}
 } nvmlComputeInstanceInfo_t;
 
 typedef struct nvmlComputeInstance_st* nvmlComputeInstance_t;
@@ -7257,7 +7844,6 @@ nvmlReturn_t DECLDIR nvmlDeviceGetMigMode(nvmlDevice_t device, unsigned int *cur
  *
  * For Ampere &tm; or newer fully supported devices.
  * Supported on Linux only.
- * Requires privileged user.
  *
  * @param device                               The identifier of the target device
  * @param profile                              One of the NVML_GPU_INSTANCE_PROFILE_*
@@ -7273,11 +7859,44 @@ nvmlReturn_t DECLDIR nvmlDeviceGetMigMode(nvmlDevice_t device, unsigned int *cur
 nvmlReturn_t DECLDIR nvmlDeviceGetGpuInstanceProfileInfo(nvmlDevice_t device, unsigned int profile,
                                                          nvmlGpuInstanceProfileInfo_t *info);
 
+/**
+ * Versioned wrapper around \ref nvmlDeviceGetGpuInstanceProfileInfo that accepts a versioned
+ * \ref nvmlGpuInstanceProfileInfo_v2_t or later output structure.
+ * 
+ * @note The caller must set the \ref nvmlGpuInstanceProfileInfo_v2_t.version field to the
+ * appropriate version prior to calling this function. For example:
+ * \code
+ *     nvmlGpuInstanceProfileInfo_v2_t profileInfo =
+ *         { .version = nvmlGpuInstanceProfileInfo_v2 };
+ *     nvmlReturn_t result = nvmlDeviceGetGpuInstanceProfileInfoV(device,
+ *                                                                profile,
+ *                                                                &profileInfo);
+ * \endcode
+ *
+ * For Ampere &tm; or newer fully supported devices.
+ * Supported on Linux only.
+ *
+ * @param device                               The identifier of the target device
+ * @param profile                              One of the NVML_GPU_INSTANCE_PROFILE_*
+ * @param info                                 Returns detailed profile information
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 Upon success
+ *         - \ref NVML_ERROR_UNINITIALIZED     If library has not been successfully initialized
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  If \a device, \a profile, \a info, or \a info->version are invalid
+ *         - \ref NVML_ERROR_NOT_SUPPORTED     If \a device doesn't have MIG mode enabled or \a profile isn't supported
+ *         - \ref NVML_ERROR_NO_PERMISSION     If user doesn't have permission to perform the operation
+ */
+nvmlReturn_t DECLDIR nvmlDeviceGetGpuInstanceProfileInfoV(nvmlDevice_t device, unsigned int profile,
+                                                          nvmlGpuInstanceProfileInfo_v2_t *info);
+
 /**
  * Get GPU instance placements.
  *
  * A placement represents the location of a GPU instance within a device. This API only returns all the possible
  * placements for the given profile.
+ * A created GPU instance occupies memory slices described by its placement. Creation of new GPU instance will
+ * fail if there is overlap with the already occupied memory slices.
  *
  * For Ampere &tm; or newer fully supported devices.
  * Supported on Linux only.
@@ -7285,21 +7904,21 @@ nvmlReturn_t DECLDIR nvmlDeviceGetGpuInstanceProfileInfo(nvmlDevice_t device, un
  *
  * @param device                               The identifier of the target device
  * @param profileId                            The GPU instance profile ID. See \ref nvmlDeviceGetGpuInstanceProfileInfo
- * @param placements                           Returns placements, the buffer must be large enough to accommodate
- *                                             the instances supported by the profile.
- *                                             See \ref nvmlDeviceGetGpuInstanceProfileInfo
- * @param count                                The count of returned placements
+ * @param placements                           Returns placements allowed for the profile. Can be NULL to discover number
+ *                                             of allowed placements for this profile. If non-NULL must be large enough
+ *                                             to accommodate the placements supported by the profile.
+ * @param count                                Returns number of allowed placemenets for the profile.
  *
  * @return
  *         - \ref NVML_SUCCESS                 Upon success
  *         - \ref NVML_ERROR_UNINITIALIZED     If library has not been successfully initialized
- *         - \ref NVML_ERROR_INVALID_ARGUMENT  If \a device, \a profileId, \a placements or \a count are invalid
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  If \a device, \a profileId or \a count are invalid
  *         - \ref NVML_ERROR_NOT_SUPPORTED     If \a device doesn't have MIG mode enabled or \a profileId isn't supported
  *         - \ref NVML_ERROR_NO_PERMISSION     If user doesn't have permission to perform the operation
  */
-nvmlReturn_t DECLDIR nvmlDeviceGetGpuInstancePossiblePlacements(nvmlDevice_t device, unsigned int profileId,
-                                                                nvmlGpuInstancePlacement_t *placements,
-                                                                unsigned int *count);
+nvmlReturn_t DECLDIR nvmlDeviceGetGpuInstancePossiblePlacements_v2(nvmlDevice_t device, unsigned int profileId,
+                                                                   nvmlGpuInstancePlacement_t *placements,
+                                                                   unsigned int *count);
 
 /**
  * Get GPU instance profile capacity.
@@ -7359,7 +7978,7 @@ nvmlReturn_t DECLDIR nvmlDeviceCreateGpuInstance(nvmlDevice_t device, unsigned i
  *
  * @param device                               The identifier of the target device
  * @param profileId                            The GPU instance profile ID. See \ref nvmlDeviceGetGpuInstanceProfileInfo
- * @param placement                            The requested placement. See \ref nvmlDeviceGetGpuInstancePossiblePlacements
+ * @param placement                            The requested placement. See \ref nvmlDeviceGetGpuInstancePossiblePlacements_v2
  * @param gpuInstance                          Returns the GPU instance handle
  *
  * @return
@@ -7464,7 +8083,6 @@ nvmlReturn_t DECLDIR nvmlGpuInstanceGetInfo(nvmlGpuInstance_t gpuInstance, nvmlG
  *
  * For Ampere &tm; or newer fully supported devices.
  * Supported on Linux only.
- * Requires privileged user.
  *
  * @param gpuInstance                          The identifier of the target GPU instance
  * @param profile                              One of the NVML_COMPUTE_INSTANCE_PROFILE_*
@@ -7482,6 +8100,40 @@ nvmlReturn_t DECLDIR nvmlGpuInstanceGetComputeInstanceProfileInfo(nvmlGpuInstanc
                                                                   unsigned int engProfile,
                                                                   nvmlComputeInstanceProfileInfo_t *info);
 
+/**
+ * Versioned wrapper around \ref nvmlGpuInstanceGetComputeInstanceProfileInfo that accepts a versioned
+ * \ref nvmlComputeInstanceProfileInfo_v2_t or later output structure.
+ *
+ * @note The caller must set the \ref nvmlGpuInstanceProfileInfo_v2_t.version field to the
+ * appropriate version prior to calling this function. For example:
+ * \code
+ *     nvmlComputeInstanceProfileInfo_v2_t profileInfo =
+ *         { .version = nvmlComputeInstanceProfileInfo_v2 };
+ *     nvmlReturn_t result = nvmlGpuInstanceGetComputeInstanceProfileInfoV(gpuInstance,
+ *                                                                         profile,
+ *                                                                         engProfile,
+ *                                                                         &profileInfo);
+ * \endcode
+ *
+ * For Ampere &tm; or newer fully supported devices.
+ * Supported on Linux only.
+ *
+ * @param gpuInstance                          The identifier of the target GPU instance
+ * @param profile                              One of the NVML_COMPUTE_INSTANCE_PROFILE_*
+ * @param engProfile                           One of the NVML_COMPUTE_INSTANCE_ENGINE_PROFILE_*
+ * @param info                                 Returns detailed profile information
+ *
+ * @return
+ *         - \ref NVML_SUCCESS                 Upon success
+ *         - \ref NVML_ERROR_UNINITIALIZED     If library has not been successfully initialized
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  If \a gpuInstance, \a profile, \a engProfile, \a info, or \a info->version are invalid
+ *         - \ref NVML_ERROR_NOT_SUPPORTED     If \a profile isn't supported
+ *         - \ref NVML_ERROR_NO_PERMISSION     If user doesn't have permission to perform the operation
+ */
+nvmlReturn_t DECLDIR nvmlGpuInstanceGetComputeInstanceProfileInfoV(nvmlGpuInstance_t gpuInstance, unsigned int profile,
+                                                                   unsigned int engProfile,
+                                                                   nvmlComputeInstanceProfileInfo_v2_t *info);
+
 /**
  * Get compute instance profile capacity.
  *
@@ -7743,6 +8395,20 @@ nvmlReturn_t DECLDIR nvmlDeviceGetMigDeviceHandleByIndex(nvmlDevice_t device, un
  */
 nvmlReturn_t DECLDIR nvmlDeviceGetDeviceHandleFromMigDeviceHandle(nvmlDevice_t migDevice, nvmlDevice_t *device);
 
+/**
+ * Get the type of the GPU Bus (PCIe, PCI, ...)
+ *
+ * @param device                               The identifier of the target device
+ * @param type                                 The PCI Bus type
+ *
+ * return
+ *         - \ref NVML_SUCCESS                 if the bus \a type is successfully retreived
+ *         - \ref NVML_ERROR_UNINITIALIZED     if the library has not been successfully initialized
+ *         - \ref NVML_ERROR_INVALID_ARGUMENT  if \device is invalid or \type is NULL
+ *         - \ref NVML_ERROR_UNKNOWN           on any unexpected error
+ */
+nvmlReturn_t DECLDIR nvmlDeviceGetBusType(nvmlDevice_t device, nvmlBusType_t *type);
+
 /** @} */
 
 /**
@@ -7759,12 +8425,19 @@ nvmlReturn_t DECLDIR nvmlDeviceGetPciInfo_v2(nvmlDevice_t device, nvmlPciInfo_t
 nvmlReturn_t DECLDIR nvmlDeviceGetNvLinkRemotePciInfo(nvmlDevice_t device, unsigned int link, nvmlPciInfo_t *pci);
 nvmlReturn_t DECLDIR nvmlDeviceGetGridLicensableFeatures(nvmlDevice_t device, nvmlGridLicensableFeatures_t *pGridLicensableFeatures);
 nvmlReturn_t DECLDIR nvmlDeviceGetGridLicensableFeatures_v2(nvmlDevice_t device, nvmlGridLicensableFeatures_t *pGridLicensableFeatures);
+nvmlReturn_t DECLDIR nvmlDeviceGetGridLicensableFeatures_v3(nvmlDevice_t device, nvmlGridLicensableFeatures_t *pGridLicensableFeatures);
 nvmlReturn_t DECLDIR nvmlDeviceRemoveGpu(nvmlPciInfo_t *pciInfo);
 nvmlReturn_t DECLDIR nvmlEventSetWait(nvmlEventSet_t set, nvmlEventData_t * data, unsigned int timeoutms);
 nvmlReturn_t DECLDIR nvmlDeviceGetAttributes(nvmlDevice_t device, nvmlDeviceAttributes_t *attributes);
 nvmlReturn_t DECLDIR nvmlComputeInstanceGetInfo(nvmlComputeInstance_t computeInstance, nvmlComputeInstanceInfo_t *info);
-nvmlReturn_t DECLDIR nvmlDeviceGetComputeRunningProcesses(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_t *infos);
-nvmlReturn_t DECLDIR nvmlDeviceGetGraphicsRunningProcesses(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_t *infos);
+nvmlReturn_t DECLDIR nvmlDeviceGetComputeRunningProcesses(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_v1_t *infos);
+nvmlReturn_t DECLDIR nvmlDeviceGetComputeRunningProcesses_v2(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_v2_t *infos);
+nvmlReturn_t DECLDIR nvmlDeviceGetGraphicsRunningProcesses(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_v1_t *infos);
+nvmlReturn_t DECLDIR nvmlDeviceGetGraphicsRunningProcesses_v2(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_v2_t *infos);
+nvmlReturn_t DECLDIR nvmlDeviceGetMPSComputeRunningProcesses(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_v1_t *infos);
+nvmlReturn_t DECLDIR nvmlDeviceGetMPSComputeRunningProcesses_v2(nvmlDevice_t device, unsigned int *infoCount, nvmlProcessInfo_v2_t *infos);
+nvmlReturn_t DECLDIR nvmlDeviceGetGpuInstancePossiblePlacements(nvmlDevice_t device, unsigned int profileId, nvmlGpuInstancePlacement_t *placements, unsigned int *count);
+nvmlReturn_t DECLDIR nvmlVgpuInstanceGetLicenseInfo(nvmlVgpuInstance_t vgpuInstance, nvmlVgpuLicenseInfo_t *licenseInfo);
 #endif // #ifdef NVML_NO_UNVERSIONED_FUNC_DEFS
 
 #if defined(NVML_NO_UNVERSIONED_FUNC_DEFS)
@@ -7773,6 +8446,7 @@ nvmlReturn_t DECLDIR nvmlDeviceGetGraphicsRunningProcesses(nvmlDevice_t device,
 #elif defined(__NVML_API_VERSION_INTERNAL)
 #undef nvmlDeviceGetGraphicsRunningProcesses
 #undef nvmlDeviceGetComputeRunningProcesses
+#undef nvmlDeviceGetMPSComputeRunningProcesses
 #undef nvmlDeviceGetAttributes
 #undef nvmlComputeInstanceGetInfo
 #undef nvmlEventSetWait
@@ -7784,6 +8458,11 @@ nvmlReturn_t DECLDIR nvmlDeviceGetGraphicsRunningProcesses(nvmlDevice_t device,
 #undef nvmlDeviceGetHandleByIndex
 #undef nvmlDeviceGetHandleByPciBusId
 #undef nvmlInit
+#undef nvmlBlacklistDeviceInfo_t
+#undef nvmlGetBlacklistDeviceCount
+#undef nvmlGetBlacklistDeviceInfoByIndex
+#undef nvmlDeviceGetGpuInstancePossiblePlacements
+#undef nvmlVgpuInstanceGetLicenseInfo
 #endif
 
 #ifdef __cplusplus
diff --git a/src/option-table.h b/src/option-table.h
index d8109de..fd6ff56 100644
--- a/src/option-table.h
+++ b/src/option-table.h
@@ -181,7 +181,7 @@ static const NVGetoptOption __options[] = {
       TAB "--page=\"GPU 0 - (Quadro 6000), PowerMizer\"\n"
       "\n"
       "The first page with a name matching the &PAGE& argument will be used.  "
-      "By default, the \"X Server Information\" page is displayed." },
+      "By default, the \"System Information\" page is displayed." },
 
     { "list-targets-only", 'L', NVGETOPT_HELP_ALWAYS, NULL,
       "When performing an attribute query (from the '--query' command line "
diff --git a/src/parse.c b/src/parse.c
index 7f5d51e..f6f641d 100644
--- a/src/parse.c
+++ b/src/parse.c
@@ -17,7 +17,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses>.
  */
 
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
@@ -68,7 +67,7 @@ const AttributeTableEntry attributeTable[] = {
      */
 
     /* Version information */
-    { "OperatingSystem",                  NV_CTRL_OPERATING_SYSTEM,                     INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "The operating system on which the X server is running.  0-Linux, 1-FreeBSD, 2-SunOS." },
+    { "OperatingSystem",                  NV_CTRL_OPERATING_SYSTEM,                     INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "The operating system on which the NVIDIA driver is running.  0-Linux, 1-FreeBSD, 2-SunOS." },
     { "NvidiaDriverVersion",              NV_CTRL_STRING_NVIDIA_DRIVER_VERSION,         STR_ATTR, {0,0,0,1,0}, {}, "The NVIDIA X driver version." },
     { "NvControlVersion",                 NV_CTRL_STRING_NV_CONTROL_VERSION,            STR_ATTR, {0,0,0,1,0}, {}, "The NV-CONTROL X driver extension version." },
     { "GLXServerVersion",                 NV_CTRL_STRING_GLX_SERVER_VERSION,            STR_ATTR, {0,0,0,1,0}, {}, "The GLX X server extension version." },
@@ -128,9 +127,9 @@ const AttributeTableEntry attributeTable[] = {
     { "SliMosaicModeAvailable",           NV_CTRL_SLI_MOSAIC_MODE_AVAILABLE,            INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns whether or not SLI Mosaic Mode is supported." },
     { "SLIMode",                          NV_CTRL_STRING_SLI_MODE,                      STR_ATTR, {0,0,0,1,0}, {}, "Returns a string describing the current SLI mode, if any." },
     { "MultiGpuMode",                     NV_CTRL_STRING_MULTIGPU_MODE,                 STR_ATTR, {0,0,0,1,0}, {}, "Returns a string describing the current MultiGPU mode, if any." },
-    { "AllowGSYNC",                       NV_CTRL_GSYNC_ALLOWED,                        INT_ATTR, {0,0,0,0,0}, { .int_flags = {0,0,0,0,0,0,0} }, "DEPRECATED: use \"AllowVRR\" instead." },
+    { "AllowGSYNC",                       NV_CTRL_VRR_ALLOWED,                          INT_ATTR, {0,0,0,0,0}, { .int_flags = {0,0,0,0,0,0,0} }, "DEPRECATED: use \"AllowVRR\" instead." },
     { "AllowVRR",                         NV_CTRL_VRR_ALLOWED,                          INT_ATTR, {0,0,0,0,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Enables or disables the use of G-SYNC and G-SYNC Compatible when available." },
-    { "ShowGSYNCVisualIndicator",         NV_CTRL_SHOW_GSYNC_VISUAL_INDICATOR,          INT_ATTR, {0,0,0,0,0}, { .int_flags = {0,0,0,0,0,0,0} }, "DEPRECATED: use \"ShowVRRVisualIndicator\" instead." },
+    { "ShowGSYNCVisualIndicator",         NV_CTRL_SHOW_VRR_VISUAL_INDICATOR,            INT_ATTR, {0,0,0,0,0}, { .int_flags = {0,0,0,0,0,0,0} }, "DEPRECATED: use \"ShowVRRVisualIndicator\" instead." },
     { "ShowVRRVisualIndicator",           NV_CTRL_SHOW_VRR_VISUAL_INDICATOR,            INT_ATTR, {0,0,0,0,0}, { .int_flags = {0,0,0,0,0,0,0} }, "If this is enabled (1), the driver will draw an indicator showing whether G-SYNC or G-SYNC Compatible is in use, when an application is swapping using flipping." },
     { "StereoSwapMode",                   NV_CTRL_STEREO_SWAP_MODE,                     INT_ATTR, {0,0,0,0,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Controls the swap mode when Quad-Buffered stereo is used." },
     { "ShowGraphicsVisualIndicator",      NV_CTRL_SHOW_GRAPHICS_VISUAL_INDICATOR,       INT_ATTR, {0,0,0,0,0}, { .int_flags = {0,0,0,0,0,0,0} }, "If this is enabled (1), the driver will draw information about the graphics API in use into a \"visual indicator\" inside application windows.  This setting only takes effect on clients started after it is set." },
@@ -143,6 +142,7 @@ const AttributeTableEntry attributeTable[] = {
     { "PCIECurrentLinkWidth",             NV_CTRL_GPU_PCIE_CURRENT_LINK_WIDTH,          INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the current PCIe link width of the GPU, in number of lanes." },
     { "VideoRam",                         NV_CTRL_VIDEO_RAM,                            INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the total amount of memory available to the specified GPU (or the GPU driving the specified X screen).  Note: if the GPU supports TurboCache(TM), the value reported may exceed the amount of video memory installed on the GPU.  The value reported for integrated GPUs may likewise exceed the amount of dedicated system memory set aside by the system BIOS for use by the integrated GPU." },
     { "TotalDedicatedGPUMemory",          NV_CTRL_TOTAL_DEDICATED_GPU_MEMORY,           INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the amount of total dedicated memory on the specified GPU in MB." },
+    { "GPUResizableBAR",                  NV_CTRL_RESIZABLE_BAR,                        INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns whether Resizable BAR is supported." },
     { "UsedDedicatedGPUMemory",           NV_CTRL_USED_DEDICATED_GPU_MEMORY,            INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the amount of dedicated memory used on the specified GPU in MB." },
     { "Irq",                              NV_CTRL_IRQ,                                  INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the interrupt request line used by the specified device.  If the target is an X screen, then it uses the GPU driving the X screen as the device." },
     { "CUDACores",                        NV_CTRL_GPU_CORES,                            INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns number of CUDA cores supported by the graphics pipeline." },
@@ -161,7 +161,6 @@ const AttributeTableEntry attributeTable[] = {
     { "GPUDefault2DClockFreqs",           NV_CTRL_GPU_DEFAULT_2D_CLOCK_FREQS,           INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,1,0,0,0,0} }, "NOT SUPPORTED." },
     { "GPUDefault3DClockFreqs",           NV_CTRL_GPU_DEFAULT_3D_CLOCK_FREQS,           INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,1,0,0,0,0} }, "NOT SUPPORTED." },
     { "GPUCurrentClockFreqs",             NV_CTRL_GPU_CURRENT_CLOCK_FREQS,              INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,1,0,0,0,0} }, "Returns the current GPU and memory clocks of the graphics device driving the X screen." },
-    { "GPUCurrentProcessorClockFreqs",    NV_CTRL_GPU_CURRENT_PROCESSOR_CLOCK_FREQS,    INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the current processor clock of the graphics device driving the X screen." },
     { "BusRate",                          NV_CTRL_BUS_RATE,                             INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "If the device is on an AGP bus, then BusRate returns the configured AGP rate.  If the device is on a PCI Express bus, then this attribute returns the width of the physical link." },
     { "PCIDomain",                        NV_CTRL_PCI_DOMAIN,                           INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the PCI domain number for the specified device." },
     { "PCIBus",                           NV_CTRL_PCI_BUS,                              INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the PCI bus number for the specified device." },
@@ -197,8 +196,6 @@ const AttributeTableEntry attributeTable[] = {
     { "ThermalSensorReading",             NV_CTRL_THERMAL_SENSOR_READING,               INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the thermal sensor's current reading." },
     { "ThermalSensorProvider",            NV_CTRL_THERMAL_SENSOR_PROVIDER,              INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the hardware device that provides the thermal sensor." },
     { "ThermalSensorTarget",              NV_CTRL_THERMAL_SENSOR_TARGET,                INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns what hardware component the thermal sensor is measuring." },  
-    { "GPUDoublePrecisionBoostImmediate", NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_IMMEDIATE, INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Toggles GPU double precision; the change is applied immediately.  Only available when the change can be made immediately." },
-    { "GPUDoublePrecisionBoostReboot",    NV_CTRL_GPU_DOUBLE_PRECISION_BOOST_REBOOT,    INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Toggles GPU double precision; the change is applied on the next reboot.  Only available when the change requires a reboot." },
     { "BaseMosaic",                       NV_CTRL_BASE_MOSAIC,                          INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the current Base Mosaic configuration." },
     { "MultiGpuPrimaryPossible",          NV_CTRL_MULTIGPU_PRIMARY_POSSIBLE,            INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns whether or not the GPU can be configured as the primary GPU for a Multi GPU configuration (SLI, SLI Mosaic, Base Mosaic, ...)." },
     { "MultiGpuMasterPossible",           NV_CTRL_MULTIGPU_PRIMARY_POSSIBLE,            INT_ATTR, {0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "This attribute is deprecated. Please use 'MultiGpuPrimaryPossible' instead." },
@@ -331,10 +328,18 @@ const AttributeTableEntry attributeTable[] = {
     { "3DVisionProGlassesAddress",                    NV_CTRL_STRING_3D_VISION_PRO_GLASSES_ADDRESS,                STR_ATTR, {0,0,1,1,0}, {}, "Returns the RF address of the glasses."},
     { "3DVisionProGlassesName",                       NV_CTRL_STRING_3D_VISION_PRO_GLASSES_NAME,                   STR_ATTR, {0,0,1,1,0}, {}, "Controls the name the glasses should use."},
 
+    /* Mux Control */
+    { "MuxState",                                     NV_CTRL_STRING_MUX_STATE,         STR_ATTR, {0,0,0,1,0}, {}, "Controls whether the specified mux is configured to use the discrete or integrated GPU."},
+    { "MuxAutoSwitch",                                NV_CTRL_MUX_AUTO_SWITCH,          INT_ATTR, {0,0,0,1,0}, {}, "Controls whether the specified mux switches automatically."},
+    { "MuxIsInternal",                                NV_CTRL_MUX_IS_INTERNAL,          INT_ATTR, {0,0,0,1,0}, {}, "Returns whether the specified mux is internal."},
+
+
     /* Misc */
     { "GTFModeline",                      NV_CTRL_STRING_OPERATION_GTF_MODELINE,        SOP_ATTR, {0,0,0,1,1}, { }, "Builds a modeline using the GTF formula." },
     { "CVTModeline",                      NV_CTRL_STRING_OPERATION_CVT_MODELINE,        SOP_ATTR, {0,0,0,1,1}, { }, "Builds a modeline using the CVT formula." },
 
+    /* Dynamic Boost */
+    { "DynamicBoostSupport",              NV_CTRL_DYNAMIC_BOOST_SUPPORT,                INT_ATTR, {0,0,0,1,0}, {},  "Returns whether the system supports Dynamic Boost." },
 };
 
 const int attributeTableLen = ARRAY_LEN(attributeTable);
@@ -345,11 +350,11 @@ const int attributeTableLen = ARRAY_LEN(attributeTable);
  * the last attribute that the table knows about.
  */
 
-#if NV_CTRL_LAST_ATTRIBUTE != NV_CTRL_PLATFORM_CURRENT_POWER_MODE
+#if NV_CTRL_LAST_ATTRIBUTE != NV_CTRL_DYNAMIC_BOOST_SUPPORT
 #warning "Have you forgotten to add a new integer attribute to attributeTable?"
 #endif
 
-#if NV_CTRL_STRING_LAST_ATTRIBUTE != NV_CTRL_STRING_DISPLAY_NAME_CONNECTOR
+#if NV_CTRL_STRING_LAST_ATTRIBUTE != NV_CTRL_STRING_MUX_STATE
 #warning "Have you forgotten to add a new string attribute to attributeTable?"
 #endif
 
diff --git a/src/query-assign.c b/src/query-assign.c
index ee3b24c..ec5d389 100644
--- a/src/query-assign.c
+++ b/src/query-assign.c
@@ -601,7 +601,7 @@ static int resolve_attribute_targets(ParsedAttribute *p, CtrlSystem *system,
                                      const char *whence)
 {
     CtrlAttributePerms perms;
-    CtrlTarget *ctrl_target;
+    CtrlTarget *ctrl_target = NULL;
     ReturnStatus status;
     int ret = NV_PARSER_STATUS_SUCCESS;
     int i;
@@ -614,7 +614,13 @@ static int resolve_attribute_targets(ParsedAttribute *p, CtrlSystem *system,
         return NV_PARSER_STATUS_BAD_ARGUMENT;
     }
 
-    ctrl_target = NvCtrlGetDefaultTarget(system);
+    if (system->has_nvml) {
+        ctrl_target = NvCtrlGetDefaultTargetByType(system, GPU_TARGET);
+    }
+    if (!ctrl_target) {
+        ctrl_target = NvCtrlGetDefaultTarget(system);
+    }
+
     if (ctrl_target == NULL) {
         return NV_PARSER_STATUS_TARGET_SPEC_NO_TARGETS;
     }
@@ -774,6 +780,11 @@ static int process_attribute_queries(const Options *op,
             continue;
         }
 
+        if (nv_strcasecmp(queries[query], "muxes")) {
+            query_all_targets(display_name, MUX_TARGET, systems);
+            continue;
+        }
+
         /* call the parser to parse queries[query] */
 
         ret = nv_parse_attribute_string(queries[query], NV_PARSER_QUERY, &a);
@@ -1436,7 +1447,8 @@ static int query_all(const Options *op, const char *display_name,
                             goto exit_bit_loop;
                         }
 
-                        if (status != NvCtrlSuccess) {
+                        if (status != NvCtrlSuccess &&
+                            status != NvCtrlMissingExtension) {
                             nv_error_msg("Error while querying valid values for "
                                          "attribute '%s' on %s (%s).",
                                          a->name, t->name,
@@ -1675,6 +1687,7 @@ static int print_target_connections(CtrlTarget *t,
             case COOLER_TARGET:
             case FRAMELOCK_TARGET:
             case X_SCREEN_TARGET:
+            case MUX_TARGET:
             default:
                 break;
             }
@@ -1743,7 +1756,11 @@ static int query_all_targets(const char *display_name, const int target_type,
 
     /* build the standard X server name */
 
-    str = nv_standardize_screen_name(XDisplayName(system->display), -2);
+    if (system->has_nv_control) {
+        str = nv_standardize_screen_name(XDisplayName(system->display), -2);
+    } else {
+        str = strdup(system->display);
+    }
 
     /* warn if we don't have any of the target type */
 
@@ -1786,6 +1803,7 @@ static int query_all_targets(const char *display_name, const int target_type,
         case COOLER_TARGET:
         case THERMAL_SENSOR_TARGET:
         case NVIDIA_3D_VISION_PRO_TRANSCEIVER_TARGET:
+        case MUX_TARGET:
              snprintf(product_name, PRODUCT_NAME_LEN, "%s %d",
                      targetTypeInfo->name, target_id);
              break;
@@ -1909,6 +1927,10 @@ static int query_all_targets(const char *display_name, const int target_type,
                      GPU_TARGET);
                 break;
 
+            case MUX_TARGET:
+                /* Target connections not yet supported. */
+                break;
+
             default:
                 break;
             }
@@ -1957,6 +1979,19 @@ static int process_parsed_attribute_internal(const Options *op,
     if (assign) {
         if (a->type == CTRL_ATTRIBUTE_TYPE_STRING) {
             status = NvCtrlSetStringAttribute(t, a->attr, p->val.str);
+
+            if (status != NvCtrlSuccess) {
+                nv_error_msg("Error assigning value %s to attribute '%s' "
+                             "(%s%s) as specified %s (%s).",
+                             p->val.str, a->name, t->name, str, whence,
+                             NvCtrlAttributesStrError(status));
+                return NV_FALSE;
+            }
+
+            if (verbose) {
+                 nv_msg("  ", "Attribute '%s' (%s%s) assigned value '%s'.",
+                 a->name, t->name, str, p->val.str);
+            }
         } else {
 
             ret = validate_value(op, t, p, d, target_type, whence);
@@ -2110,7 +2145,7 @@ int nv_process_parsed_attribute(const Options *op,
 
     /* if we don't have a Display connection, abort now */
 
-    if (system == NULL || system->dpy == NULL) {
+    if (system == NULL) {
         nv_error_msg("Unable to %s attribute %s specified %s (no Display "
                      "connection).", assign ? "assign" : "query",
                      a->name, whence);
diff --git a/src/version.mk b/src/version.mk
index 634141a..05c6021 100644
--- a/src/version.mk
+++ b/src/version.mk
@@ -1,4 +1,4 @@
-NVIDIA_VERSION = 460.91.03
+NVIDIA_VERSION = 510.60.02
 
 # This file.
 VERSION_MK_FILE := $(lastword $(MAKEFILE_LIST))
diff --git a/utils.mk b/utils.mk
index af0e3d7..2b15880 100644
--- a/utils.mk
+++ b/utils.mk
@@ -33,10 +33,11 @@
 ##############################################################################
 
 CC                    ?= gcc
+CXX                   ?= g++
 LD                    ?= ld
 AR                    ?= ar
-# only set these warnings and optimizations if CFLAGS is unset
-CFLAGS                ?= -Wall -O2
+# only set these warnings if CFLAGS is unset
+CFLAGS                ?= -Wall
 # always set these -f CFLAGS
 CFLAGS                += -fno-strict-aliasing -fno-omit-frame-pointer -Wformat=2
 CC_ONLY_CFLAGS        ?=
@@ -58,16 +59,31 @@ CFLAGS                += -Wno-unused-parameter
 HOST_CC_ONLY_CFLAGS   += -Wno-format-zero-length
 HOST_CFLAGS           += -Wno-unused-parameter
 
+# Treat warnings as errors, if requested
+WARNINGS_AS_ERRORS    ?=
+CFLAGS                += $(if $(WARNINGS_AS_ERRORS),-Werror)
+
+DEBUG                 ?=
+DEVELOP               ?=
+
 ifeq ($(DEBUG),1)
   STRIP_CMD           ?= true
   DO_STRIP            ?=
   CFLAGS              += -O0 -g
   CFLAGS              += -DDEBUG=1
 else
-  STRIP_CMD           ?= strip
-  DO_STRIP            ?= 1
+  CFLAGS              += -O2
+endif
+
+ifeq ($(DEVELOP),1)
+  STRIP_CMD           ?= true
+  DO_STRIP            ?=
+  CFLAGS              += -DDEVELOP=1
 endif
 
+STRIP_CMD             ?= strip
+DO_STRIP              ?= 1
+
 INSTALL               ?= install
 INSTALL_BIN_ARGS      ?= -m 755
 INSTALL_LIB_ARGS      ?= -m 644
@@ -170,6 +186,8 @@ NV_QUIET_COMMAND_REMOVED_TARGET_PREFIX ?=
 
 NV_GENERATED_HEADERS ?=
 
+PCIACCESS_CFLAGS      ?=
+PCIACCESS_LDFLAGS     ?=
 
 ##############################################################################
 # This makefile uses the $(eval) builtin function, which was added in
@@ -185,6 +203,21 @@ ifneq ($(_eval_available),T)
 endif
 
 
+##############################################################################
+# Test passing $(1) to $(CC).  If $(CC) succeeds, then echo $(1).
+#
+# Because this uses $(shell), it is best to use this to assign simply expanded
+# variables (e.g., ":=").
+#
+# Example usage:
+#  CONDITIONAL_CFLAGS := $(call TEST_CC_ARG, -ffoo)
+##############################################################################
+
+TEST_CC_ARG = \
+ $(shell $(CC) -c -x c /dev/null $(1) -o /dev/null > /dev/null 2>&1 && \
+   $(ECHO) $(1))
+
+
 ##############################################################################
 # define variables used when installing the open source utilities from
 # the source tarball
@@ -276,7 +309,7 @@ host_target = $(patsubst HOST,HOST_,$(patsubst TARGET,,$(1)))
 
 ifeq ($(NV_AUTO_DEPEND),1)
   AUTO_DEP_SUFFIX = -MMD -MF $$(@:.o=.d.to_be_processed) -MP -MT $$@ && \
-    $$(SED) -e "1,3s@ $$< @ @" < $$(@:.o=.d.to_be_processed) > $$(@:.o=.d)
+    $$(SED) -e "1,3s| $$< | |" < $$(@:.o=.d.to_be_processed) > $$(@:.o=.d)
 else
   AUTO_DEP_SUFFIX =
 endif
@@ -349,6 +382,7 @@ BUILD_OBJECT_LIST_WITH_DIR = \
 BUILD_OBJECT_LIST = \
   $(call BUILD_OBJECT_LIST_WITH_DIR,$(1),$(OUTPUTDIR))
 
+$(call BUILD_OBJECT_LIST,nvpci-utils.c): CFLAGS += $(PCIACCESS_CFLAGS)
 
 ##############################################################################
 # function to generate a list of dependency files from their
@@ -486,8 +520,9 @@ endif
 define GENERATE_NVIDSTRING
   # g_nvid_string.c depends on all objects except g_nvid_string.o, and version.mk
   $(NVIDSTRING): $$(filter-out $$(call BUILD_OBJECT_LIST,$$(NVIDSTRING)), $(3)) $$(VERSION_MK)
-	@$$(ECHO) "const char $(1)[] = \"nvidia id: NVIDIA $$(strip $(2)) for $$(TARGET_ARCH)  $$(NVIDIA_VERSION)  $$(NVIDSTRING_BUILD_TYPE_STRING)  (`$$(WHOAMI)`@`$$(HOSTNAME)`)  `$$(DATE)`\";" > $$@
-	@$$(ECHO) "const char *const p$$(strip $(1)) = $(1) + 11;" >> $$@;
+	$(at_if_quiet)$$(MKDIR) $$(dir $$@)
+	$(at_if_quiet)$$(ECHO) "const char $(1)[] = \"nvidia id: NVIDIA $$(strip $(2)) for $$(TARGET_ARCH)  $$(NVIDIA_VERSION)  $$(NVIDSTRING_BUILD_TYPE_STRING)  (`$$(WHOAMI)`@`$$(HOSTNAME)`)  `$$(DATE)`\";" > $$@
+	$(at_if_quiet)$$(ECHO) "const char *const p$$(strip $(1)) = $(1) + 11;" >> $$@;
 endef
 
 
@@ -510,6 +545,7 @@ endef
 
 define READ_ONLY_OBJECT_FROM_FILE_RULE
   $$(OUTPUTDIR)/$$(notdir $(1)).o: $(1)
+	$(at_if_quiet)$$(MKDIR) $$(OUTPUTDIR)
 	$(at_if_quiet)cd $$(dir $(1)); \
 	$$(call quiet_cmd_no_at,LD) -r -z noexecstack --format=binary \
 	    $$(notdir $(1)) -o $$(OUTPUTDIR_ABSOLUTE)/$$(notdir $$@)
diff --git a/version.mk b/version.mk
index 634141a..05c6021 100644
--- a/version.mk
+++ b/version.mk
@@ -1,4 +1,4 @@
-NVIDIA_VERSION = 460.91.03
+NVIDIA_VERSION = 510.60.02
 
 # This file.
 VERSION_MK_FILE := $(lastword $(MAKEFILE_LIST))