352.09352.09

18 files changed, 637 insertions, 171 deletions

diff --git a/doc/version.mk b/doc/version.mk
index 7064f31..61aeb50 100644
--- a/doc/version.mk
+++ b/doc/version.mk
@@ -1 +1 @@
-NVIDIA_VERSION = 349.16
+NVIDIA_VERSION = 352.09
diff --git a/samples/nv-control-info.c b/samples/nv-control-info.c
index f8912f1..d6a7049 100644
--- a/samples/nv-control-info.c
+++ b/samples/nv-control-info.c
@@ -36,48 +36,17 @@
 #include "NVCtrl.h"
 #include "NVCtrlLib.h"
 
-// Used to convert the NV-CONTROL #defines to human readable text.
-#define MAKE_ENTRY(ATTRIBUTE) { ATTRIBUTE, #ATTRIBUTE, NULL }
-
-typedef struct {
-    int num;
-    char *str;
-    char *name;
-} AttrEntry;
+#define ARRAY_LEN(_arr) (sizeof(_arr) / sizeof(_arr[0]))
 
-static const char *attr2str(int n, AttrEntry *tbl)
-{
-    AttrEntry *entry;
-
-    entry = tbl;
-    while (entry->str) {
-        if (entry->num == n) {
-            if (!entry->name) {
-                int len;
-                entry->name = strdup(entry->str + 8);
-                for (len = 0; len < strlen(entry->name); len++) {
-                    entry->name[len] = tolower(entry->name[len]);
-                }
-            }
-            return entry->name;
-        }
-        entry++;
-    }
-
-    return NULL;
-}
+// Used to convert the NV-CONTROL #defines to human readable text.
+#define MAKE_ENTRY(ATTRIBUTE) [ATTRIBUTE] = #ATTRIBUTE
 
-// Attribute -> String table, generated using:
-//
-// grep 'define.*\/\*' NVCtrl.h | sed 's/.*define \([^ ]*\).*/    MAKE_ENTRY(\1),/' > DATA | head DATA
-//
-static AttrEntry attr_int_table[] = {
-    MAKE_ENTRY(NV_CTRL_FLATPANEL_SCALING),
-    MAKE_ENTRY(NV_CTRL_FLATPANEL_DITHERING),
+// grep 'define.*\/\*' NVCtrl.h | grep -v NV_CTRL_TARGET_TYPE_ | grep -v "not supported" | grep -v "renamed" | grep -v "deprecated" | grep -v NV_CTRL_STRING_ | grep -v NV_CTRL_BINARY_DATA_ | sed 's/.*define \([^ ]*\).*/    MAKE_ENTRY(\1),/'
+static const char *attr_int_table[NV_CTRL_LAST_ATTRIBUTE + 1] = {
     MAKE_ENTRY(NV_CTRL_DITHERING),
     MAKE_ENTRY(NV_CTRL_DIGITAL_VIBRANCE),
     MAKE_ENTRY(NV_CTRL_BUS_TYPE),
-    MAKE_ENTRY(NV_CTRL_VIDEO_RAM),
+    MAKE_ENTRY(NV_CTRL_TOTAL_GPU_MEMORY),
     MAKE_ENTRY(NV_CTRL_IRQ),
     MAKE_ENTRY(NV_CTRL_OPERATING_SYSTEM),
     MAKE_ENTRY(NV_CTRL_SYNC_TO_VBLANK),
@@ -87,12 +56,9 @@ static AttrEntry attr_int_table[] = {
     MAKE_ENTRY(NV_CTRL_UBB),
     MAKE_ENTRY(NV_CTRL_OVERLAY),
     MAKE_ENTRY(NV_CTRL_STEREO),
-    MAKE_ENTRY(NV_CTRL_EMULATE),
     MAKE_ENTRY(NV_CTRL_TWINVIEW),
-    MAKE_ENTRY(NV_CTRL_CONNECTED_DISPLAYS),
     MAKE_ENTRY(NV_CTRL_ENABLED_DISPLAYS),
     MAKE_ENTRY(NV_CTRL_FRAMELOCK),
-    MAKE_ENTRY(NV_CTRL_FRAMELOCK_MASTER),
     MAKE_ENTRY(NV_CTRL_FRAMELOCK_POLARITY),
     MAKE_ENTRY(NV_CTRL_FRAMELOCK_SYNC_DELAY),
     MAKE_ENTRY(NV_CTRL_FRAMELOCK_SYNC_INTERVAL),
@@ -106,7 +72,6 @@ static AttrEntry attr_int_table[] = {
     MAKE_ENTRY(NV_CTRL_FRAMELOCK_ETHERNET_DETECTED),
     MAKE_ENTRY(NV_CTRL_FRAMELOCK_VIDEO_MODE),
     MAKE_ENTRY(NV_CTRL_FRAMELOCK_SYNC_RATE),
-    MAKE_ENTRY(NV_CTRL_FORCE_GENERIC_CPU),
     MAKE_ENTRY(NV_CTRL_OPENGL_AA_LINE_GAMMA),
     MAKE_ENTRY(NV_CTRL_FRAMELOCK_TIMING),
     MAKE_ENTRY(NV_CTRL_FLIPPING_ALLOWED),
@@ -115,20 +80,11 @@ static AttrEntry attr_int_table[] = {
     MAKE_ENTRY(NV_CTRL_FSAA_APPLICATION_CONTROLLED),
     MAKE_ENTRY(NV_CTRL_LOG_ANISO_APPLICATION_CONTROLLED),
     MAKE_ENTRY(NV_CTRL_IMAGE_SHARPENING),
-    MAKE_ENTRY(NV_CTRL_TV_OVERSCAN),
-    MAKE_ENTRY(NV_CTRL_TV_FLICKER_FILTER),
-    MAKE_ENTRY(NV_CTRL_TV_BRIGHTNESS),
-    MAKE_ENTRY(NV_CTRL_TV_HUE),
-    MAKE_ENTRY(NV_CTRL_TV_CONTRAST),
-    MAKE_ENTRY(NV_CTRL_TV_SATURATION),
-    MAKE_ENTRY(NV_CTRL_TV_RESET_SETTINGS),
     MAKE_ENTRY(NV_CTRL_GPU_CORE_TEMPERATURE),
     MAKE_ENTRY(NV_CTRL_GPU_CORE_THRESHOLD),
     MAKE_ENTRY(NV_CTRL_GPU_DEFAULT_CORE_THRESHOLD),
     MAKE_ENTRY(NV_CTRL_GPU_MAX_CORE_THRESHOLD),
     MAKE_ENTRY(NV_CTRL_AMBIENT_TEMPERATURE),
-    MAKE_ENTRY(NV_CTRL_PBUFFER_SCANOUT_SUPPORTED),
-    MAKE_ENTRY(NV_CTRL_PBUFFER_SCANOUT_XID),
     MAKE_ENTRY(NV_CTRL_GVO_SUPPORTED),
     MAKE_ENTRY(NV_CTRL_GVO_SYNC_MODE),
     MAKE_ENTRY(NV_CTRL_GVO_SYNC_SOURCE),
@@ -139,11 +95,9 @@ static AttrEntry attr_int_table[] = {
     MAKE_ENTRY(NV_CTRL_GVO_COMPOSITE_SYNC_INPUT_DETECT_MODE),
     MAKE_ENTRY(NV_CTRL_GVO_SDI_SYNC_INPUT_DETECTED),
     MAKE_ENTRY(NV_CTRL_GVO_VIDEO_OUTPUTS),
-    MAKE_ENTRY(NV_CTRL_GVO_FIRMWARE_VERSION),
     MAKE_ENTRY(NV_CTRL_GVO_SYNC_DELAY_PIXELS),
     MAKE_ENTRY(NV_CTRL_GVO_SYNC_DELAY_LINES),
     MAKE_ENTRY(NV_CTRL_GVO_INPUT_VIDEO_FORMAT_REACQUIRE),
-    MAKE_ENTRY(NV_CTRL_GVO_GLX_LOCKED),
     MAKE_ENTRY(NV_CTRL_GVIO_VIDEO_FORMAT_WIDTH),
     MAKE_ENTRY(NV_CTRL_GVIO_VIDEO_FORMAT_HEIGHT),
     MAKE_ENTRY(NV_CTRL_GVIO_VIDEO_FORMAT_REFRESH_RATE),
@@ -160,15 +114,11 @@ static AttrEntry attr_int_table[] = {
     MAKE_ENTRY(NV_CTRL_BUS_RATE),
     MAKE_ENTRY(NV_CTRL_SHOW_SLI_VISUAL_INDICATOR),
     MAKE_ENTRY(NV_CTRL_XV_SYNC_TO_DISPLAY),
-    MAKE_ENTRY(NV_CTRL_XV_SYNC_TO_DISPLAY_ID),
     MAKE_ENTRY(NV_CTRL_CURRENT_XV_SYNC_TO_DISPLAY_ID),
     MAKE_ENTRY(NV_CTRL_GVIO_REQUESTED_VIDEO_FORMAT2),
     MAKE_ENTRY(NV_CTRL_GVO_OVERRIDE_HW_CSC),
     MAKE_ENTRY(NV_CTRL_GVO_CAPABILITIES),
     MAKE_ENTRY(NV_CTRL_GVO_COMPOSITE_TERMINATION),
-    MAKE_ENTRY(NV_CTRL_ASSOCIATED_DISPLAY_DEVICES),
-    MAKE_ENTRY(NV_CTRL_FRAMELOCK_SLAVES),
-    MAKE_ENTRY(NV_CTRL_FRAMELOCK_MASTERABLE),
     MAKE_ENTRY(NV_CTRL_PROBE_DISPLAYS),
     MAKE_ENTRY(NV_CTRL_REFRESH_RATE),
     MAKE_ENTRY(NV_CTRL_GVO_FLIP_QUEUE_SIZE),
@@ -190,7 +140,6 @@ static AttrEntry attr_int_table[] = {
     MAKE_ENTRY(NV_CTRL_NUM_GPU_ERRORS_RECOVERED),
     MAKE_ENTRY(NV_CTRL_REFRESH_RATE_3),
     MAKE_ENTRY(NV_CTRL_GPU_POWER_SOURCE),
-    MAKE_ENTRY(NV_CTRL_GPU_CURRENT_PERFORMANCE_MODE),
     MAKE_ENTRY(NV_CTRL_GLYPH_CACHE),
     MAKE_ENTRY(NV_CTRL_GPU_CURRENT_PERFORMANCE_LEVEL),
     MAKE_ENTRY(NV_CTRL_GPU_ADAPTIVE_CLOCK_STATE),
@@ -203,9 +152,6 @@ static AttrEntry attr_int_table[] = {
     MAKE_ENTRY(NV_CTRL_GVO_COMPOSITE_CR_KEY_RANGE),
     MAKE_ENTRY(NV_CTRL_GVO_COMPOSITE_CB_KEY_RANGE),
     MAKE_ENTRY(NV_CTRL_GVO_COMPOSITE_NUM_KEY_RANGES),
-    MAKE_ENTRY(NV_CTRL_SWITCH_TO_DISPLAYS),
-    MAKE_ENTRY(NV_CTRL_NOTEBOOK_DISPLAY_CHANGE_LID_EVENT),
-    MAKE_ENTRY(NV_CTRL_NOTEBOOK_INTERNAL_LCD),
     MAKE_ENTRY(NV_CTRL_DEPTH_30_ALLOWED),
     MAKE_ENTRY(NV_CTRL_MODE_SET_EVENT),
     MAKE_ENTRY(NV_CTRL_OPENGL_AA_LINE_GAMMA_VALUE),
@@ -214,7 +160,6 @@ static AttrEntry attr_int_table[] = {
     MAKE_ENTRY(NV_CTRL_STEREO_EYES_EXCHANGE),
     MAKE_ENTRY(NV_CTRL_NO_SCANOUT),
     MAKE_ENTRY(NV_CTRL_GVO_CSC_CHANGED_EVENT),
-    MAKE_ENTRY(NV_CTRL_FRAMELOCK_SLAVEABLE),
     MAKE_ENTRY(NV_CTRL_GVO_SYNC_TO_DISPLAY),
     MAKE_ENTRY(NV_CTRL_X_SERVER_UNIQUE_ID),
     MAKE_ENTRY(NV_CTRL_PIXMAP_CACHE),
@@ -258,7 +203,6 @@ static AttrEntry attr_int_table[] = {
     MAKE_ENTRY(NV_CTRL_GVI_MAX_CHANNELS_PER_JACK),
     MAKE_ENTRY(NV_CTRL_GVI_MAX_STREAMS),
     MAKE_ENTRY(NV_CTRL_GVI_NUM_CAPTURE_SURFACES),
-    MAKE_ENTRY(NV_CTRL_OVERSCAN_COMPENSATION),
     MAKE_ENTRY(NV_CTRL_GPU_PCIE_GENERATION),
     MAKE_ENTRY(NV_CTRL_GVI_BOUND_GPU),
     MAKE_ENTRY(NV_CTRL_GVIO_REQUESTED_VIDEO_FORMAT3),
@@ -268,9 +212,6 @@ static AttrEntry attr_int_table[] = {
     MAKE_ENTRY(NV_CTRL_GVI_TEST_MODE),
     MAKE_ENTRY(NV_CTRL_COLOR_SPACE),
     MAKE_ENTRY(NV_CTRL_COLOR_RANGE),
-    MAKE_ENTRY(NV_CTRL_SHOW_GSYNC_VISUAL_INDICATOR),
-    MAKE_ENTRY(NV_CTRL_GPU_SCALING_DEFAULT_TARGET),
-    MAKE_ENTRY(NV_CTRL_GPU_SCALING_DEFAULT_METHOD),
     MAKE_ENTRY(NV_CTRL_DITHERING_MODE),
     MAKE_ENTRY(NV_CTRL_CURRENT_DITHERING),
     MAKE_ENTRY(NV_CTRL_CURRENT_DITHERING_MODE),
@@ -300,17 +241,50 @@ static AttrEntry attr_int_table[] = {
     MAKE_ENTRY(NV_CTRL_GVO_ANC_PARITY_COMPUTATION),
     MAKE_ENTRY(NV_CTRL_3D_VISION_PRO_GLASSES_PAIR_EVENT),
     MAKE_ENTRY(NV_CTRL_3D_VISION_PRO_GLASSES_UNPAIR_EVENT),
-    { -1, NULL, NULL }
+    MAKE_ENTRY(NV_CTRL_GPU_PCIE_CURRENT_LINK_WIDTH),
+    MAKE_ENTRY(NV_CTRL_GPU_PCIE_CURRENT_LINK_SPEED),
+    MAKE_ENTRY(NV_CTRL_GVO_AUDIO_BLANKING),
+    MAKE_ENTRY(NV_CTRL_CURRENT_METAMODE_ID),
+    MAKE_ENTRY(NV_CTRL_DISPLAY_ENABLED),
+    MAKE_ENTRY(NV_CTRL_FRAMELOCK_INCOMING_HOUSE_SYNC_RATE),
+    MAKE_ENTRY(NV_CTRL_FXAA),
+    MAKE_ENTRY(NV_CTRL_DISPLAY_RANDR_OUTPUT_ID),
+    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_MASTER_POSSIBLE),
+    MAKE_ENTRY(NV_CTRL_GPU_POWER_MIZER_DEFAULT_MODE),
+    MAKE_ENTRY(NV_CTRL_XV_SYNC_TO_DISPLAY_ID),
+    MAKE_ENTRY(NV_CTRL_BACKLIGHT_BRIGHTNESS),
+    MAKE_ENTRY(NV_CTRL_GPU_LOGO_BRIGHTNESS),
+    MAKE_ENTRY(NV_CTRL_GPU_SLI_LOGO_BRIGHTNESS),
+    MAKE_ENTRY(NV_CTRL_THERMAL_COOLER_SPEED),
+    MAKE_ENTRY(NV_CTRL_PALETTE_UPDATE_EVENT),
+    MAKE_ENTRY(NV_CTRL_VIDEO_ENCODER_UTILIZATION),
+    MAKE_ENTRY(NV_CTRL_GSYNC_ALLOWED),
+    MAKE_ENTRY(NV_CTRL_GPU_NVCLOCK_OFFSET),
+    MAKE_ENTRY(NV_CTRL_GPU_MEM_TRANSFER_RATE_OFFSET),
+    MAKE_ENTRY(NV_CTRL_VIDEO_DECODER_UTILIZATION),
+    MAKE_ENTRY(NV_CTRL_GPU_OVER_VOLTAGE_OFFSET),
+    MAKE_ENTRY(NV_CTRL_GPU_CURRENT_CORE_VOLTAGE),
+    MAKE_ENTRY(NV_CTRL_CURRENT_COLOR_SPACE),
+    MAKE_ENTRY(NV_CTRL_CURRENT_COLOR_RANGE),
+    MAKE_ENTRY(NV_CTRL_SHOW_GSYNC_VISUAL_INDICATOR),
+    MAKE_ENTRY(NV_CTRL_THERMAL_COOLER_CURRENT_LEVEL),
+    MAKE_ENTRY(NV_CTRL_STEREO_SWAP_MODE),
 };
 
-static AttrEntry attr_str_table[] = {
+// grep 'define.*\/\*' NVCtrl.h | grep -v NV_CTRL_TARGET_TYPE_ | grep -v "not supported" | grep -v "renamed" | grep -v "deprecated" | grep NV_CTRL_STRING_ | grep -v NV_CTRL_STRING_OPERATION_ | sed 's/.*define \([^ ]*\).*/    MAKE_ENTRY(\1),/'
+static const char *attr_str_table[NV_CTRL_STRING_LAST_ATTRIBUTE + 1] = {
     MAKE_ENTRY(NV_CTRL_STRING_PRODUCT_NAME),
     MAKE_ENTRY(NV_CTRL_STRING_VBIOS_VERSION),
     MAKE_ENTRY(NV_CTRL_STRING_NVIDIA_DRIVER_VERSION),
     MAKE_ENTRY(NV_CTRL_STRING_DISPLAY_DEVICE_NAME),
-    MAKE_ENTRY(NV_CTRL_STRING_TV_ENCODER_NAME),
     MAKE_ENTRY(NV_CTRL_STRING_GVIO_FIRMWARE_VERSION),
-    MAKE_ENTRY(NV_CTRL_STRING_GVO_FIRMWARE_VERSION),
     MAKE_ENTRY(NV_CTRL_STRING_CURRENT_MODELINE),
     MAKE_ENTRY(NV_CTRL_STRING_ADD_MODELINE),
     MAKE_ENTRY(NV_CTRL_STRING_DELETE_MODELINE),
@@ -328,7 +302,7 @@ static AttrEntry attr_str_table[] = {
     MAKE_ENTRY(NV_CTRL_STRING_MOVE_METAMODE),
     MAKE_ENTRY(NV_CTRL_STRING_VALID_HORIZ_SYNC_RANGES),
     MAKE_ENTRY(NV_CTRL_STRING_VALID_VERT_REFRESH_RANGES),
-    MAKE_ENTRY(NV_CTRL_STRING_XINERAMA_SCREEN_INFO),
+    MAKE_ENTRY(NV_CTRL_STRING_SCREEN_RECTANGLE),
     MAKE_ENTRY(NV_CTRL_STRING_NVIDIA_XINERAMA_INFO_ORDER),
     MAKE_ENTRY(NV_CTRL_STRING_SLI_MODE),
     MAKE_ENTRY(NV_CTRL_STRING_PERFORMANCE_MODES),
@@ -336,7 +310,6 @@ static AttrEntry attr_str_table[] = {
     MAKE_ENTRY(NV_CTRL_STRING_VCSC_TEMPERATURES),
     MAKE_ENTRY(NV_CTRL_STRING_VCSC_PSU_INFO),
     MAKE_ENTRY(NV_CTRL_STRING_GVIO_VIDEO_FORMAT_NAME),
-    MAKE_ENTRY(NV_CTRL_STRING_GVO_VIDEO_FORMAT_NAME),
     MAKE_ENTRY(NV_CTRL_STRING_GPU_CURRENT_CLOCK_FREQS),
     MAKE_ENTRY(NV_CTRL_STRING_3D_VISION_PRO_TRANSCEIVER_HARDWARE_REVISION),
     MAKE_ENTRY(NV_CTRL_STRING_3D_VISION_PRO_TRANSCEIVER_FIRMWARE_VERSION_A),
@@ -355,13 +328,16 @@ static AttrEntry attr_str_table[] = {
     MAKE_ENTRY(NV_CTRL_STRING_DISPLAY_NAME_EDID_HASH),
     MAKE_ENTRY(NV_CTRL_STRING_DISPLAY_NAME_TARGET_INDEX),
     MAKE_ENTRY(NV_CTRL_STRING_DISPLAY_NAME_RANDR),
-    { -1, NULL, NULL }
+    MAKE_ENTRY(NV_CTRL_STRING_GPU_UUID),
+    MAKE_ENTRY(NV_CTRL_STRING_GPU_UTILIZATION),
+    MAKE_ENTRY(NV_CTRL_STRING_MULTIGPU_MODE),
 };
 
-static AttrEntry attr_bin_table[] = {
+// grep 'define.*\/\*' NVCtrl.h | grep -v NV_CTRL_TARGET_TYPE_ | grep -v "not supported" | grep -v "renamed" | grep -v "deprecated" | grep NV_CTRL_BINARY_DATA_ | sed 's/.*define \([^ ]*\).*/    MAKE_ENTRY(\1),/'
+static const char *attr_bin_table[NV_CTRL_BINARY_DATA_LAST_ATTRIBUTE + 1] = {
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_EDID),
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_MODELINES),
-    MAKE_ENTRY(NV_CTRL_BINARY_DATA_METAMODES_VERSION_1),
+    MAKE_ENTRY(NV_CTRL_BINARY_DATA_METAMODES),
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_XSCREENS_USING_GPU),
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_GPUS_USED_BY_XSCREEN),
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_GPUS_USING_FRAMELOCK),
@@ -376,17 +352,20 @@ static AttrEntry attr_bin_table[] = {
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_DISPLAY_TARGETS),
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_DISPLAYS_CONNECTED_TO_GPU),
     MAKE_ENTRY(NV_CTRL_BINARY_DATA_METAMODES_VERSION_2),
-    { -1, NULL, NULL }
+    MAKE_ENTRY(NV_CTRL_BINARY_DATA_DISPLAYS_ENABLED_ON_XSCREEN),
+    MAKE_ENTRY(NV_CTRL_BINARY_DATA_DISPLAYS_ASSIGNED_TO_XSCREEN),
+    MAKE_ENTRY(NV_CTRL_BINARY_DATA_GPU_FLAGS),
+    MAKE_ENTRY(NV_CTRL_BINARY_DATA_DISPLAYS_ON_GPU),
 };
 
-
-static AttrEntry attr_strop_table[] = {
+// grep 'define.*\/\*' NVCtrl.h | grep -v NV_CTRL_TARGET_TYPE_ | grep -v "not supported" | grep -v "renamed" | grep -v "deprecated" | grep NV_CTRL_STRING_OPERATION_ | sed 's/.*define \([^ ]*\).*/    MAKE_ENTRY(\1),/'
+static const char *attr_strop_table[NV_CTRL_STRING_OPERATION_LAST_ATTRIBUTE + 1] = {
     MAKE_ENTRY(NV_CTRL_STRING_OPERATION_ADD_METAMODE),
     MAKE_ENTRY(NV_CTRL_STRING_OPERATION_GTF_MODELINE),
     MAKE_ENTRY(NV_CTRL_STRING_OPERATION_CVT_MODELINE),
     MAKE_ENTRY(NV_CTRL_STRING_OPERATION_BUILD_MODEPOOL),
     MAKE_ENTRY(NV_CTRL_STRING_OPERATION_GVI_CONFIGURE_STREAMS),
-    { -1, NULL, NULL }
+    MAKE_ENTRY(NV_CTRL_STRING_OPERATION_PARSE_METAMODE),
 };
 
 
@@ -431,6 +410,33 @@ static const char *GetAttrTypeName(int value)
 }
 
 
+static void print_table_entry(NVCTRLAttributePermissionsRec *perms,
+                              const int index,
+                              const char *name)
+{
+    /*
+     * Don't print the attribute if *both* the permissions are empty
+     * and the attribute table was missing an entry for the attribute.
+     * Either condition by itself is acceptable:
+     *
+     * - Event-only attributes (e.g., NV_CTRL_GVO_CSC_CHANGED_EVENT)
+     *   don't have any permissions.
+     *
+     * - A missing table entry could just mean the table is stale
+     *   relative to NVCtrl.h.
+     */
+    if ((perms->permissions == 0) && (name == NULL)) {
+        return;
+    }
+
+    printf("  (%3d) [Perms: ", index);
+    print_perms(perms);
+    printf("] [ ");
+    printf("%-32s", GetAttrTypeName(perms->type));
+    printf("] - %s\n", name ? name : "Unknown");
+}
+
+
 
 int main(void)
 {
@@ -438,7 +444,8 @@ int main(void)
     Bool ret;
     int event_base, error_base, major, minor, screens, i;
     char *str;
-        
+    NVCTRLAttributePermissionsRec perms;
+
     /*
      * open a connection to the X server indicated by the DISPLAY
      * environment variable
@@ -529,74 +536,34 @@ int main(void)
      */
 
     printf("Attributes (Integers):\n");
-    for (i = 0; i < NV_CTRL_LAST_ATTRIBUTE; i++) {
-        const char *name = attr2str(i, attr_int_table);
-        if (name) {
-            NVCTRLAttributePermissionsRec perms;
-
-            printf("  (%3d) [Perms: ", i);
-
-            memset(&perms, 0, sizeof(NVCTRLAttributePermissionsRec));
-
-            XNVCTRLQueryAttributePermissions(dpy, i, &perms);
-            print_perms(&perms);
-            printf("] [ ");
-            printf("%-32s", GetAttrTypeName(perms.type));
-            printf("] - %s\n", name);
+    for (i = 0; i < ARRAY_LEN(attr_int_table); i++) {
+        memset(&perms, 0, sizeof(NVCTRLAttributePermissionsRec));
+        if (XNVCTRLQueryAttributePermissions(dpy, i, &perms)) {
+            print_table_entry(&perms, i, attr_int_table[i]);
         }
     }
 
     printf("Attributes (Strings):\n");
-    for (i = 0; i < NV_CTRL_STRING_LAST_ATTRIBUTE; i++) {
-        const char *name = attr2str(i, attr_str_table);
-        if (name) {
-            NVCTRLAttributePermissionsRec perms;
-
-            printf("  (%3d) [Perms: ", i);
-
-            memset(&perms, 0, sizeof(NVCTRLAttributePermissionsRec));
-
-            XNVCTRLQueryStringAttributePermissions(dpy, i, &perms);
-            print_perms(&perms);
-            printf("] [ ");
-            printf("%-32s", GetAttrTypeName(perms.type));
-            printf("] - %s\n", name);
+    for (i = 0; i < ARRAY_LEN(attr_str_table); i++) {
+        memset(&perms, 0, sizeof(NVCTRLAttributePermissionsRec));
+        if (XNVCTRLQueryStringAttributePermissions(dpy, i, &perms)) {
+            print_table_entry(&perms, i, attr_str_table[i]);
         }
     }
 
     printf("Attributes (Binary Data):\n");
-    for (i = 0; i < NV_CTRL_BINARY_DATA_LAST_ATTRIBUTE; i++) {
-        const char *name = attr2str(i, attr_bin_table);
-        if (name) {
-            NVCTRLAttributePermissionsRec perms;
-
-            printf("  (%3d) [Perms: ", i);
-
-            memset(&perms, 0, sizeof(NVCTRLAttributePermissionsRec));
-
-            XNVCTRLQueryBinaryDataAttributePermissions(dpy, i, &perms);
-            print_perms(&perms);
-            printf("] [ ");
-            printf("%-32s", GetAttrTypeName(perms.type));
-            printf("] - %s\n", name);
+    for (i = 0; i < ARRAY_LEN(attr_bin_table); i++) {
+        memset(&perms, 0, sizeof(NVCTRLAttributePermissionsRec));
+        if (XNVCTRLQueryBinaryDataAttributePermissions(dpy, i, &perms)) {
+            print_table_entry(&perms, i, attr_bin_table[i]);
         }
     }
 
     printf("Attributes (String Operations):\n");
-    for (i = 0; i < NV_CTRL_STRING_OPERATION_LAST_ATTRIBUTE; i++) {
-        const char *name = attr2str(i, attr_strop_table);
-        if (name) {
-            NVCTRLAttributePermissionsRec perms;
-
-            printf("  (%3d) [Perms: ", i);
-
-            memset(&perms, 0, sizeof(NVCTRLAttributePermissionsRec));
-
-            XNVCTRLQueryStringOperationAttributePermissions(dpy, i, &perms);
-            print_perms(&perms);
-            printf("] [ ");
-            printf("%-32s", GetAttrTypeName(perms.type));
-            printf("] - %s\n", name);
+    for (i = 0; i < ARRAY_LEN(attr_strop_table); i++) {
+        memset(&perms, 0, sizeof(NVCTRLAttributePermissionsRec));
+        if (XNVCTRLQueryStringOperationAttributePermissions(dpy, i, &perms)) {
+            print_table_entry(&perms, i, attr_strop_table[i]);
         }
     }
 
diff --git a/samples/nv-control-targets.c b/samples/nv-control-targets.c
index 9d3bc6a..4cdee93 100644
--- a/samples/nv-control-targets.c
+++ b/samples/nv-control-targets.c
@@ -41,7 +41,7 @@
 
 
 
-static void print_display_device_target_indices(const int *pData)
+static void print_target_indices(const char *prefix, const int *pData)
 {
     int i, first = 1;
 
@@ -50,10 +50,29 @@ static void print_display_device_target_indices(const int *pData)
             printf(", ");
         }
         first = 0;
-        printf("DPY-%d", pData[i]);
+        printf("%s-%d", prefix, pData[i]);
     }
 }
 
+static void print_display_device_target_indices(const int *pData)
+{
+    print_target_indices("DPY", pData);
+}
+
+static void print_cooler_target_indices(const int *pData)
+{
+    print_target_indices("COOLER", pData);
+}
+
+static void print_thermal_sensor_target_indices(const int *pData)
+{
+    print_target_indices("THERMAL-SENSOR", pData);
+}
+
+static void print_framelock_target_indices(const int *pData)
+{
+    print_target_indices("FRAMELOCK", pData);
+}
 
 int main(int argc, char *argv[])
 {
@@ -249,6 +268,44 @@ int main(int argc, char *argv[])
         XFree(str);
         str = NULL;
 
+        /* Coolers on GPU */
+
+        ret = XNVCTRLQueryTargetBinaryData
+            (dpy,
+             NV_CTRL_TARGET_TYPE_GPU,
+             gpu, // target_id
+             0, // display_mask
+             NV_CTRL_BINARY_DATA_COOLERS_USED_BY_GPU,
+             (unsigned char **) &pData,
+             &len);
+        if (!ret) {
+            fprintf(stderr, "Failed to query connected coolers\n");
+            return 1;
+        }
+        printf("   Coolers on GPU                  : ");
+        print_cooler_target_indices(pData);
+        XFree(pData);
+        printf("\n");
+
+        /* Thermal Sensors on GPU */
+
+        ret = XNVCTRLQueryTargetBinaryData
+            (dpy,
+             NV_CTRL_TARGET_TYPE_GPU,
+             gpu, // target_id
+             0, // display_mask
+             NV_CTRL_BINARY_DATA_THERMAL_SENSORS_USED_BY_GPU,
+             (unsigned char **) &pData,
+             &len);
+        if (!ret) {
+            fprintf(stderr, "Failed to query connected thermal sensors\n");
+            return 1;
+        }
+        printf("   Thermal Sensors on GPU          : ");
+        print_thermal_sensor_target_indices(pData);
+        XFree(pData);
+        printf("\n");
+
         /* Connected Display Devices on GPU */
 
         ret = XNVCTRLQueryTargetBinaryData
@@ -268,6 +325,25 @@ int main(int argc, char *argv[])
         XFree(pDisplayData);
         printf("\n");
 
+        /* FrameLock Devices on GPU */
+
+        ret = XNVCTRLQueryTargetBinaryData
+            (dpy,
+             NV_CTRL_TARGET_TYPE_GPU,
+             gpu, // target_id
+             0, // display_mask
+             NV_CTRL_BINARY_DATA_FRAMELOCKS_USED_BY_GPU,
+             (unsigned char **) &pData,
+             &len);
+        if (!ret) {
+            fprintf(stderr, "Failed to query framelock devices\n");
+            return 1;
+        }
+        printf("   Framelock Devices               : ");
+        print_framelock_target_indices(pData);
+        XFree(pData);
+        printf("\n");
+
         /* X Screens driven by this GPU */
 
         ret = XNVCTRLQueryTargetBinaryData
diff --git a/samples/version.mk b/samples/version.mk
index 7064f31..61aeb50 100644
--- a/samples/version.mk
+++ b/samples/version.mk
@@ -1 +1 @@
-NVIDIA_VERSION = 349.16
+NVIDIA_VERSION = 352.09
diff --git a/src/command-line.c b/src/command-line.c
index 6327780..21dccaf 100644
--- a/src/command-line.c
+++ b/src/command-line.c
@@ -58,8 +58,6 @@ static void print_version(void)
     nv_msg(TAB, "For more detail, please see the nvidia-settings(1) "
            "man page.");
     nv_msg(NULL, "");
-    nv_msg(TAB, "Copyright (C) 2004 - 2010 NVIDIA Corporation.");
-    nv_msg(NULL, "");
     
 } /* print_version() */
 
diff --git a/src/gtk+-2.x/ctkecc.c b/src/gtk+-2.x/ctkecc.c
index d7208b1..13a5f22 100644
--- a/src/gtk+-2.x/ctkecc.c
+++ b/src/gtk+-2.x/ctkecc.c
@@ -42,10 +42,18 @@ static const char *__ecc_status_help =
 "Returns the current hardware ECC setting "
 "for the targeted GPU.";
 
+static const char *__sbit_error_help =
+"Returns the number of single-bit ECC errors detected by "
+"the targeted GPU since the last system reboot.";
+
 static const char *__dbit_error_help =
 "Returns the number of double-bit ECC errors detected by "
 "the targeted GPU since the last system reboot.";
 
+static const char *__aggregate_sbit_error_help =
+"Returns the number of single-bit ECC errors detected by the "
+"targeted GPU since the last counter reset.";
+
 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.";
@@ -158,27 +166,47 @@ static gboolean update_ecc_info(gpointer user_data)
     int64_t val;
     ReturnStatus ret;
 
-    if ( ctk_ecc->ecc_enabled == FALSE ) {
+    if (ctk_ecc->ecc_enabled == FALSE) {
         return FALSE;
     }
 
     /* Query ECC Errors */
 
-    if ( ctk_ecc->dbit_error ) {
+    if (ctk_ecc->sbit_error) {
+        ret = NvCtrlGetAttribute64(ctrl_target,
+                                   NV_CTRL_GPU_ECC_SINGLE_BIT_ERRORS,
+                                   &val);
+        if (ret != NvCtrlSuccess) {
+            val = 0;
+        }
+        set_label_value(ctk_ecc->sbit_error, val);
+    }
+
+    if (ctk_ecc->dbit_error) {
         ret = NvCtrlGetAttribute64(ctrl_target,
                                    NV_CTRL_GPU_ECC_DOUBLE_BIT_ERRORS,
                                    &val);
-        if ( ret != NvCtrlSuccess ) {
+        if (ret != NvCtrlSuccess) {
             val = 0;
         }
         set_label_value(ctk_ecc->dbit_error, val);
     }
 
-    if ( ctk_ecc->aggregate_dbit_error ) {
+    if (ctk_ecc->aggregate_sbit_error) {
+        ret = NvCtrlGetAttribute64(ctrl_target,
+                                   NV_CTRL_GPU_ECC_AGGREGATE_SINGLE_BIT_ERRORS,
+                                   &val);
+        if (ret != NvCtrlSuccess) {
+            val = 0;
+        }
+        set_label_value(ctk_ecc->aggregate_sbit_error, val);
+    }
+
+    if (ctk_ecc->aggregate_dbit_error) {
         ret = NvCtrlGetAttribute64(ctrl_target,
                                    NV_CTRL_GPU_ECC_AGGREGATE_DOUBLE_BIT_ERRORS,
                                    &val);
-        if ( ret != NvCtrlSuccess ) {
+        if (ret != NvCtrlSuccess) {
             val = 0;
         }
         set_label_value(ctk_ecc->aggregate_dbit_error, val);
@@ -419,10 +447,14 @@ GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target,
     CtkEcc *ctk_ecc;
     GtkWidget *hbox, *hbox2, *vbox, *hsep, *hseparator, *table;
     GtkWidget *banner, *label, *eventbox;
+    int64_t sbit_error;
+    int64_t aggregate_sbit_error;
     int64_t dbit_error;
     int64_t aggregate_dbit_error;
     gint ecc_config_supported;
     gint val, row = 0;
+    gboolean sbit_error_available;
+    gboolean aggregate_sbit_error_available;
     gboolean dbit_error_available;
     gboolean aggregate_dbit_error_available;
     gboolean ecc_enabled;
@@ -456,10 +488,14 @@ GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target,
     ctk_ecc->ctk_config = ctk_config;
     ctk_ecc->ecc_toggle_warning_dlg_shown = FALSE;
 
+    sbit_error_available = TRUE;
     dbit_error_available = TRUE;
+    aggregate_sbit_error_available = TRUE;
     aggregate_dbit_error_available = TRUE;
     
+    sbit_error = 0;
     dbit_error = 0;
+    aggregate_sbit_error = 0;
     aggregate_dbit_error = 0;
 
     /* Query ECC Status */
@@ -500,17 +536,31 @@ GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target,
     /* Query ECC errors */
     
     ret = NvCtrlGetAttribute64(ctrl_target,
+                               NV_CTRL_GPU_ECC_SINGLE_BIT_ERRORS,
+                               &sbit_error);
+    if (ret != NvCtrlSuccess) {
+        sbit_error_available = FALSE;
+    }
+    ret = NvCtrlGetAttribute64(ctrl_target,
                                NV_CTRL_GPU_ECC_DOUBLE_BIT_ERRORS,
                                &dbit_error);
-    if ( ret != NvCtrlSuccess ) {
+    if (ret != NvCtrlSuccess) {
         dbit_error_available = FALSE;
     }
     ret = NvCtrlGetAttribute64(ctrl_target,
+                               NV_CTRL_GPU_ECC_AGGREGATE_SINGLE_BIT_ERRORS,
+                               &aggregate_sbit_error);
+    if (ret != NvCtrlSuccess) {
+        aggregate_sbit_error_available = FALSE;
+    }
+    ret = NvCtrlGetAttribute64(ctrl_target,
                                NV_CTRL_GPU_ECC_AGGREGATE_DOUBLE_BIT_ERRORS,
                                &aggregate_dbit_error);
-    if ( ret != NvCtrlSuccess ) {
+    if (ret != NvCtrlSuccess) {
         aggregate_dbit_error_available = FALSE;
     }
+    ctk_ecc->sbit_error_available = sbit_error_available;
+    ctk_ecc->aggregate_sbit_error_available = aggregate_sbit_error_available;
     ctk_ecc->dbit_error_available = dbit_error_available;
     ctk_ecc->aggregate_dbit_error_available = aggregate_dbit_error_available;
     /* Query ECC configuration supported */
@@ -518,7 +568,7 @@ GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target,
     ret = NvCtrlGetAttribute(ctrl_target,
                              NV_CTRL_GPU_ECC_CONFIGURATION_SUPPORTED,
                              &ecc_config_supported);
-    if ( ret != NvCtrlSuccess ) {
+    if (ret != NvCtrlSuccess) {
         ecc_config_supported = 0;
     }
 
@@ -572,15 +622,27 @@ GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target,
     
     /* Add ECC Errors */
 
-    if ( dbit_error_available ) {
+    if (sbit_error_available && dbit_error_available) {
+        ctk_ecc->sbit_error =
+            add_table_int_row(ctk_config, table, __sbit_error_help,
+                              "Single-bit ECC Errors:", sbit_error,
+                              row, ecc_enabled);
+        row += 1; // add vertical padding between rows
+
         ctk_ecc->dbit_error =
             add_table_int_row(ctk_config, table, __dbit_error_help,
                               "Double-bit ECC Errors:", dbit_error,
                               row, ecc_enabled);
         row += 3; // add vertical padding between rows
     }
-    
-    if ( aggregate_dbit_error_available ) {
+
+    if (aggregate_sbit_error_available && aggregate_dbit_error_available) {
+        ctk_ecc->aggregate_sbit_error =
+            add_table_int_row(ctk_config, table, __aggregate_sbit_error_help,
+                              "Aggregate Single-bit ECC Errors:",
+                              aggregate_sbit_error, row, ecc_enabled);
+        row += 1; // add vertical padding between rows
+
         ctk_ecc->aggregate_dbit_error =
             add_table_int_row(ctk_config, table, __aggregate_dbit_error_help,
                               "Aggregate Double-bit ECC Errors:",
@@ -623,7 +685,7 @@ GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target,
     
     /* Add buttons */
 
-    if ( dbit_error_available ) {
+    if (sbit_error_available && dbit_error_available) {
         ctk_ecc->clear_button = gtk_button_new_with_label("Clear ECC Errors");
         gtk_box_pack_end(GTK_BOX(hbox), ctk_ecc->clear_button, FALSE, FALSE, 0);
         ctk_config_set_tooltip(ctk_config, ctk_ecc->clear_button,
@@ -634,7 +696,7 @@ GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target,
                          (gpointer) ctk_ecc);
     }
 
-    if ( aggregate_dbit_error_available ) {
+    if (aggregate_sbit_error_available && aggregate_dbit_error_available) {
         ctk_ecc->clear_aggregate_button =
             gtk_button_new_with_label("Clear Aggregate ECC Errors");
         gtk_box_pack_end(GTK_BOX(hbox), ctk_ecc->clear_aggregate_button,
@@ -699,11 +761,16 @@ GtkTextBuffer *ctk_ecc_create_help(GtkTextTagTable *table,
     ctk_help_heading(b, &i, "ECC");
     ctk_help_para(b, &i, "%s", __ecc_status_help);
 
-    if (ctk_ecc->dbit_error_available) {
+    if (ctk_ecc->sbit_error_available && ctk_ecc->dbit_error_available) {
+        ctk_help_heading(b, &i, "Single-bit ECC Errors");
+        ctk_help_para(b, &i, "%s", __sbit_error_help);
         ctk_help_heading(b, &i, "Double-bit ECC Errors");
         ctk_help_para(b, &i, "%s", __dbit_error_help);
     }
-    if (ctk_ecc->aggregate_dbit_error_available) {
+    if (ctk_ecc->aggregate_sbit_error_available &&
+        ctk_ecc->aggregate_dbit_error_available) {
+        ctk_help_heading(b, &i, "Aggregate Single-bit ECC Errors");
+        ctk_help_para(b, &i, "%s", __aggregate_sbit_error_help);
         ctk_help_heading(b, &i, "Aggregate Double-bit ECC Errors");
         ctk_help_para(b, &i, "%s", __aggregate_dbit_error_help);
     }
@@ -713,11 +780,12 @@ GtkTextBuffer *ctk_ecc_create_help(GtkTextTagTable *table,
     ctk_help_heading(b, &i, "Enable ECC");
     ctk_help_para(b, &i, "%s", __ecc_status_help);
 
-    if (ctk_ecc->dbit_error_available) {
+    if (ctk_ecc->sbit_error_available && ctk_ecc->dbit_error_available) {
         ctk_help_heading(b, &i, "Clear ECC Errors");
         ctk_help_para(b, &i, "%s", __clear_button_help);
     }
-    if (ctk_ecc->aggregate_dbit_error_available) {
+    if (ctk_ecc->aggregate_sbit_error_available &&
+        ctk_ecc->aggregate_dbit_error_available) {
         ctk_help_heading(b, &i, "Clear Aggregate ECC Errors");
         ctk_help_para(b, &i, "%s", __clear_aggregate_button_help);
     }
diff --git a/src/gtk+-2.x/ctkecc.h b/src/gtk+-2.x/ctkecc.h
index 3251a75..eb605e8 100644
--- a/src/gtk+-2.x/ctkecc.h
+++ b/src/gtk+-2.x/ctkecc.h
@@ -54,7 +54,9 @@ struct _CtkEcc
     CtkConfig *ctk_config;
 
     GtkWidget* status;
+    GtkWidget* sbit_error;
     GtkWidget* dbit_error;
+    GtkWidget* aggregate_sbit_error;
     GtkWidget* aggregate_dbit_error;
     GtkWidget* ecc_config_supported;
     GtkWidget* clear_button;
@@ -65,7 +67,9 @@ struct _CtkEcc
     gboolean ecc_enabled;
     gboolean ecc_configured;
     gboolean ecc_toggle_warning_dlg_shown;
+    gboolean sbit_error_available;
     gboolean dbit_error_available;
+    gboolean aggregate_sbit_error_available;
     gboolean aggregate_dbit_error_available;
 
 };
diff --git a/src/gtk+-2.x/ctkevent.c b/src/gtk+-2.x/ctkevent.c
index 3bf820c..b4125f0 100644
--- a/src/gtk+-2.x/ctkevent.c
+++ b/src/gtk+-2.x/ctkevent.c
@@ -338,6 +338,7 @@ static void ctk_event_class_init(CtkEventClass *ctk_event_class)
     MAKE_SIGNAL(NV_CTRL_GPU_CURRENT_CORE_VOLTAGE);
     MAKE_SIGNAL(NV_CTRL_SHOW_GSYNC_VISUAL_INDICATOR);
     MAKE_SIGNAL(NV_CTRL_THERMAL_COOLER_CURRENT_LEVEL);
+    MAKE_SIGNAL(NV_CTRL_STEREO_SWAP_MODE);
 #undef MAKE_SIGNAL
 
     /*
diff --git a/src/gtk+-2.x/ctkopengl.c b/src/gtk+-2.x/ctkopengl.c
index 494ac37..30321f1 100644
--- a/src/gtk+-2.x/ctkopengl.c
+++ b/src/gtk+-2.x/ctkopengl.c
@@ -19,9 +19,11 @@
 
 #include <gtk/gtk.h>
 #include <NvCtrlAttributes.h>
+#include <stdlib.h>
 
 #include "ctkbanner.h"
 
+#include "ctkdropdownmenu.h"
 #include "ctkopengl.h"
 #include "ctkscale.h"
 
@@ -102,6 +104,28 @@ static GtkWidget *create_slider(CtkOpenGL *ctk_opengl,
 
 static void slider_changed(GtkAdjustment *adjustment, gpointer user_data);
 
+static GtkWidget *create_stereo_swap_mode_menu(CtkOpenGL *ctk_opengl,
+                                               CtkEvent *ctk_event,
+                                               gint stereo_swap_mode);
+
+static void stereo_swap_mode_menu_changed(GObject *object,
+                                          gpointer user_data);
+
+static void stereo_swap_mode_update_received(GObject *object,
+                                             CtrlEvent *event,
+                                             gpointer user_data);
+
+static void post_stereo_swap_mode_changed(CtkOpenGL *ctk_opengl, gint idx);
+
+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);
+
+static void ctk_opengl_new_finalize(GObject *object);
+
 #define FRAME_PADDING 5
 
 static const char *__sync_to_vblank_help =
@@ -114,6 +138,15 @@ static const char *__aa_line_gamma_checkbox_help =
 "Enable the antialiased lines gamma correction checkbox to make the "
 "gamma correction slider active.";
 
+static const char *__ssm_menu_help =
+"This menu controls the swap mode when Quad-Buffered stereo is used."
+"  Application-controled: Stereo swap mode is derived from the "
+"value of swap interval.  If it's odd, the per eye "
+"swap mode is used.  If it's even, the per eye pair swap mode is used."
+"  Per Eye: The driver swaps each eye as it is ready."
+"  Per Eye-Pair: The driver waits for both eyes to complete rendering "
+"before swapping.";
+
 static const char *__aa_line_gamma_slider_help =
 "This option allows Gamma-corrected "
 "antialiased lines to consider variances in the color "
@@ -180,6 +213,7 @@ static const char *__show_gsync_visual_indicator_help  =
 #define __CONFORMANT_CLAMPING (1 << 12)
 #define __ALLOW_GSYNC         (1 << 13)
 #define __SHOW_GSYNC_VISUAL_INDICATOR       (1 << 14)
+#define __STEREO_SWAP_MODE    (1 << 15)
 
 
 
@@ -194,7 +228,7 @@ GType ctk_opengl_get_type(
             sizeof (CtkOpenGLClass),
             NULL, /* base_init */
             NULL, /* base_finalize */
-            NULL, /* class_init, */
+            (GClassInitFunc) ctk_opengl_new_class_init, /* class_init, */
             NULL, /* class_finalize */
             NULL, /* class_data */
             sizeof (CtkOpenGL),
@@ -211,6 +245,27 @@ GType ctk_opengl_get_type(
 }
 
 
+    static void
+ctk_opengl_new_class_init(CtkOpenGLClass *ctk_object_class)
+{
+    GObjectClass *gobject_class = (GObjectClass *)ctk_object_class;
+    gobject_class->finalize = ctk_opengl_new_finalize;
+}
+
+static void ctk_opengl_new_finalize(GObject *object)
+{
+    CtkOpenGL *ctk_object = CTK_OPENGL(object);
+
+    g_signal_handlers_disconnect_matched(G_OBJECT(ctk_object->ctk_event),
+                                         G_SIGNAL_MATCH_DATA,
+                                         0,
+                                         0,
+                                         NULL,
+                                         NULL,
+                                         (gpointer) ctk_object);
+}
+
+
 GtkWidget* ctk_opengl_new(CtrlTarget *ctrl_target,
                           CtkConfig *ctk_config,
                           CtkEvent *ctk_event)
@@ -226,6 +281,7 @@ GtkWidget* ctk_opengl_new(CtrlTarget *ctrl_target,
     GtkWidget *check_button;
     GtkWidget *scale;
     GtkAdjustment *adjustment;
+    GtkWidget *menu;
 
     gint sync_to_vblank;
     gint flipping_allowed;
@@ -234,6 +290,7 @@ GtkWidget* ctk_opengl_new(CtrlTarget *ctrl_target,
     gint force_stereo;
     gint xinerama_stereo;
     gint stereo_eyes_exchange;
+    gint stereo_swap_mode;
     CtrlAttributeValidValues image_settings_valid;
     gint image_settings_value;
     gint aa_line_gamma;
@@ -248,6 +305,7 @@ GtkWidget* ctk_opengl_new(CtrlTarget *ctrl_target,
     ReturnStatus ret_force_stereo;
     ReturnStatus ret_xinerama_stereo;
     ReturnStatus ret_stereo_eyes_exchange;
+    ReturnStatus ret_stereo_swap_mode;
     ReturnStatus ret_image_settings;
     ReturnStatus ret_aa_line_gamma;
     ReturnStatus ret_use_conformant_clamping;
@@ -291,6 +349,11 @@ GtkWidget* ctk_opengl_new(CtrlTarget *ctrl_target,
                            NV_CTRL_STEREO_EYES_EXCHANGE,
                            &stereo_eyes_exchange);
 
+    ret_stereo_swap_mode =
+        NvCtrlGetAttribute(ctrl_target,
+                           NV_CTRL_STEREO_SWAP_MODE,
+                           &stereo_swap_mode);
+
     ret_image_settings = NvCtrlGetValidAttributeValues(ctrl_target,
                                                        NV_CTRL_IMAGE_SETTINGS,
                                                        &image_settings_valid);
@@ -332,6 +395,7 @@ GtkWidget* ctk_opengl_new(CtrlTarget *ctrl_target,
         (ret_force_stereo != NvCtrlSuccess) &&
         (ret_xinerama_stereo != NvCtrlSuccess) &&
         (ret_stereo_eyes_exchange != NvCtrlSuccess) &&
+        (ret_stereo_swap_mode != NvCtrlSuccess) &&
         (ret_image_settings != NvCtrlSuccess) &&
         (ret_aa_line_gamma != NvCtrlSuccess) &&
         (ret_use_conformant_clamping != NvCtrlSuccess) &&
@@ -591,7 +655,21 @@ GtkWidget* ctk_opengl_new(CtrlTarget *ctrl_target,
     
         ctk_opengl->stereo_eyes_exchange_button = check_button;
     }
+    if (ret_stereo_eyes_exchange == NvCtrlSuccess) {
+        /* Create a menu */
+        label = gtk_label_new("Stereo - swap mode:");
+        ctk_opengl->active_attributes |= __STEREO_SWAP_MODE;
+
+        menu = create_stereo_swap_mode_menu(ctk_opengl, ctk_event,
+                                            stereo_swap_mode);
+
+        ctk_opengl->stereo_swap_mode_menu = menu;
 
+        hbox = gtk_hbox_new(FALSE, 5);
+        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
+        gtk_box_pack_start(GTK_BOX(hbox), menu, FALSE, FALSE, 5);
+        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
+    }
     /*
      * Image Quality settings.
      */
@@ -1165,6 +1243,232 @@ static void value_changed(GObject *object, CtrlEvent *event, gpointer user_data)
 } /* value_changed() */
 
 
+
+/*
+ * build_stereo_swap_mode_table() - build a table of stereo swap mode, showing
+ * modes supported by the hardware.
+ */
+static void build_stereo_swap_mode_table(CtkOpenGL *ctk_opengl)
+{
+    CtrlTarget *ctrl_target = ctk_opengl->ctrl_target;
+    ReturnStatus ret;
+    CtrlAttributeValidValues valid;
+    gint i = 0, n = 0, num_of_modes = 0, mask;
+
+    if (ctk_opengl->stereo_swap_mode_table_size > 0 &&
+        ctk_opengl->stereo_swap_mode_table != NULL) {
+        ctk_opengl->stereo_swap_mode_table_size = 0;
+        free(ctk_opengl->stereo_swap_mode_table);
+    }
+
+    ret =
+        NvCtrlGetValidAttributeValues(ctrl_target,
+                                      NV_CTRL_STEREO_SWAP_MODE,
+                                      &valid);
+    if ((ret != NvCtrlSuccess) ||
+        (valid.valid_type != CTRL_ATTRIBUTE_VALID_TYPE_INT_BITS)) {
+        /*
+         * We do not have valid information to build a mode table
+         * so we need to create default data for the placeholder menu.
+         */
+        ctk_opengl->stereo_swap_mode_table_size = 1;
+        ctk_opengl->stereo_swap_mode_table =
+            calloc(1, sizeof(ctk_opengl->stereo_swap_mode_table[0]));
+        if (ctk_opengl->stereo_swap_mode_table) {
+            ctk_opengl->stereo_swap_mode_table[0] =
+                NV_CTRL_STEREO_SWAP_MODE_APPLICATION_CONTROL;
+        } else {
+            ctk_opengl->stereo_swap_mode_table_size = 0;
+        }
+        return;
+    }
+
+    /* count no. of supported modes */
+    mask = valid.allowed_ints;
+    while(mask) {
+        mask = mask & (mask - 1);
+        num_of_modes++;
+    }
+
+    ctk_opengl->stereo_swap_mode_table_size = num_of_modes;
+    ctk_opengl->stereo_swap_mode_table =
+        calloc(num_of_modes, sizeof(ctk_opengl->stereo_swap_mode_table[0]));
+    if (!ctk_opengl->stereo_swap_mode_table) {
+        ctk_opengl->stereo_swap_mode_table_size = 0;
+        return;
+    }
+
+    mask = valid.allowed_ints;
+    while (mask) {
+
+        while (!(mask & (1 << i))) {
+            i++;
+        }
+
+        ctk_opengl->stereo_swap_mode_table[n++] = i;
+        mask = mask & (mask - 1);
+    }
+
+    return;
+}
+
+
+
+/*
+ * create_stereo_swap_mode_menu() - Helper function that creates the
+ * Stereo swap mode dropdown menu.
+ */
+
+static GtkWidget *create_stereo_swap_mode_menu(CtkOpenGL *ctk_opengl,
+                                               CtkEvent *ctk_event,
+                                               gint stereo_swap_mode)
+{
+    CtkDropDownMenu *stereo_swap_mode_menu;
+    gint i, idx = 0;
+
+    /* Create the menu */
+
+    stereo_swap_mode_menu = (CtkDropDownMenu *)
+        ctk_drop_down_menu_new(CTK_DROP_DOWN_MENU_FLAG_READONLY);
+
+    /* setup stereo swap mode */
+    build_stereo_swap_mode_table(ctk_opengl);
+
+    /* populate dropdown list for stereo swap mode */
+
+    ctk_drop_down_menu_reset(stereo_swap_mode_menu);
+
+    for (i = 0; i < ctk_opengl->stereo_swap_mode_table_size; i++) {
+        switch (ctk_opengl->stereo_swap_mode_table[i]) {
+        case NV_CTRL_STEREO_SWAP_MODE_PER_EYE:
+            ctk_drop_down_menu_append_item(stereo_swap_mode_menu, "Per Eye", i);
+            break;
+        case NV_CTRL_STEREO_SWAP_MODE_PER_EYE_PAIR:
+            ctk_drop_down_menu_append_item(stereo_swap_mode_menu,
+                                           "Per Eye-Pair", i);
+            break;
+        default:
+        case NV_CTRL_STEREO_SWAP_MODE_APPLICATION_CONTROL:
+            ctk_drop_down_menu_append_item(stereo_swap_mode_menu,
+                                           "Application-controlled", i);
+            break;
+        }
+    }
+
+    /* set the menu item */
+    idx = map_nvctrl_value_to_table(ctk_opengl, stereo_swap_mode);
+    ctk_drop_down_menu_set_current_value(stereo_swap_mode_menu, idx);
+
+    ctk_drop_down_menu_set_tooltip(ctk_opengl->ctk_config, stereo_swap_mode_menu,
+                                   __ssm_menu_help);
+
+    g_signal_connect(G_OBJECT(stereo_swap_mode_menu),
+                     "changed",
+                     G_CALLBACK(stereo_swap_mode_menu_changed),
+                     (gpointer) ctk_opengl);
+
+    g_signal_connect(G_OBJECT(ctk_event),
+                     CTK_EVENT_NAME
+                     (NV_CTRL_STEREO_SWAP_MODE),
+                     G_CALLBACK(stereo_swap_mode_update_received),
+                     (gpointer) ctk_opengl);
+
+    return GTK_WIDGET(stereo_swap_mode_menu);
+}
+
+
+
+static gint map_nvctrl_value_to_table(CtkOpenGL *ctk_opengl,
+                                      gint val)
+{
+    int i;
+    for (i = 0; i < ctk_opengl->stereo_swap_mode_table_size; i++) {
+        if (val == ctk_opengl->stereo_swap_mode_table[i]) {
+            return i;
+        }
+    }
+
+    return 0;
+}
+
+
+
+/*
+ * stereo_swap_mode_menu_changed() - callback function for menu change
+ */
+
+static void stereo_swap_mode_menu_changed(GObject *object, gpointer user_data)
+{
+    CtkOpenGL *ctk_opengl = CTK_OPENGL(user_data);
+    CtrlTarget *ctrl_target = ctk_opengl->ctrl_target;
+    gint idx;
+
+    idx = ctk_drop_down_menu_get_current_value
+        (CTK_DROP_DOWN_MENU(ctk_opengl->stereo_swap_mode_menu));
+
+    NvCtrlSetAttribute(ctrl_target, NV_CTRL_STEREO_SWAP_MODE,
+                       ctk_opengl->stereo_swap_mode_table[idx]);
+
+    post_stereo_swap_mode_changed(ctk_opengl,
+                                  ctk_opengl->stereo_swap_mode_table[idx]);
+}
+
+
+
+/*
+ * post_stereo_swap_mode_changed() - helper function to print status bar message
+ */
+
+static void post_stereo_swap_mode_changed(CtkOpenGL *ctk_opengl, gint idx)
+{
+    static const char *stereo_swap_mode_table[] = {
+        "Application-controlled", /* NV_CTRL_STEREO_SWAP_MODE_APPLICATION_CONTROL */
+        "Per Eye",                /* NV_CTRL_STEREO_SWAP_MODE_PER_EYE */
+        "Per Eye-Pair",           /* NV_CTRL_STEREO_SWAP_MODE_PER_EYE_PAIR */
+    };
+
+    if (idx < NV_CTRL_STEREO_SWAP_MODE_APPLICATION_CONTROL ||
+        idx > NV_CTRL_STEREO_SWAP_MODE_PER_EYE_PAIR) {
+        return;
+    }
+
+    ctk_config_statusbar_message(ctk_opengl->ctk_config,
+                                 "Set %s Stereo swap mode.",
+                                 stereo_swap_mode_table[idx]);
+}
+
+
+
+static void stereo_swap_mode_update_received(GObject *object,
+                                             CtrlEvent *event,
+                                             gpointer user_data)
+{
+    CtkOpenGL *ctk_opengl = CTK_OPENGL(user_data);
+    GtkWidget *menu;
+    gint idx = map_nvctrl_value_to_table(ctk_opengl,
+                                         event->int_attr.value);
+
+    if (event->type != CTRL_EVENT_TYPE_INTEGER_ATTRIBUTE) {
+        return;
+    }
+    /* Update the dropdown menu */
+    menu = GTK_WIDGET(ctk_opengl->stereo_swap_mode_menu);
+
+    g_signal_handlers_block_by_func
+        (G_OBJECT(menu),
+         G_CALLBACK(stereo_swap_mode_menu_changed),
+         (gpointer) ctk_opengl);
+
+    ctk_drop_down_menu_set_current_value
+        (CTK_DROP_DOWN_MENU(ctk_opengl->stereo_swap_mode_menu), idx);
+
+    g_signal_handlers_unblock_by_func
+        (G_OBJECT(menu),
+         G_CALLBACK(stereo_swap_mode_menu_changed),
+         (gpointer) ctk_opengl);
+    post_stereo_swap_mode_changed(ctk_opengl, idx);
+}
+
 /*
  * get_image_settings_string() - translate the NV-CONTROL image settings value
  * to a more comprehensible string.
@@ -1432,6 +1736,15 @@ GtkTextBuffer *ctk_opengl_create_help(GtkTextTagTable *table,
                       "applied to OpenGL applications that are started "
                       "after the option is set.");
 
+        ctk_help_para(b, &i, "When G-SYNC is active and \"Sync to VBlank\" is "
+                      "disabled, applications rendering faster than the "
+                      "maximum refresh rate will tear. This eliminates tearing "
+                      "for frame rates below the monitor's maximum refresh "
+                      "rate while minimizing latency for frame rates above it. "
+                      "When \"Sync to VBlank\" is enabled, the frame rate is "
+                      "limited to the monitor's maximum refresh rate to "
+                      "eliminate tearing completely.");
+
         ctk_help_para(b, &i, "This option can be overridden on a "
                       "per-application basis using the GLGSYNCAllowed "
                       "application profile key.");
@@ -1457,6 +1770,11 @@ GtkTextBuffer *ctk_opengl_create_help(GtkTextTagTable *table,
         ctk_help_para(b, &i, "%s", __stereo_eyes_exchange_help);
     }
     
+    if (ctk_opengl->active_attributes & __STEREO_SWAP_MODE) {
+        ctk_help_term(b, &i, "Stereo - swap mode");
+        ctk_help_para(b, &i, "%s", __ssm_menu_help);
+    }
+
     if (ctk_opengl->active_attributes & __IMAGE_SETTINGS) {
         ctk_help_heading(b, &i, "Image Settings");
         ctk_help_para(b, &i, "This setting gives you full control over the "
diff --git a/src/gtk+-2.x/ctkopengl.h b/src/gtk+-2.x/ctkopengl.h
index 12f413e..63ab4f3 100644
--- a/src/gtk+-2.x/ctkopengl.h
+++ b/src/gtk+-2.x/ctkopengl.h
@@ -52,6 +52,7 @@ struct _CtkOpenGL
 
     CtrlTarget *ctrl_target;
     CtkConfig *ctk_config;
+    CtrlEvent *ctk_event;
 
     GtkWidget *sync_to_vblank_button;
     GtkWidget *allow_flipping_button;
@@ -61,12 +62,16 @@ struct _CtkOpenGL
     GtkWidget *force_stereo_button;
     GtkWidget *xinerama_stereo_button;
     GtkWidget *stereo_eyes_exchange_button;
+    GtkWidget *stereo_swap_mode_menu;
     GtkWidget *image_settings_scale;
     GtkWidget *aa_line_gamma_button;
     GtkWidget *aa_line_gamma_scale;
     GtkWidget *show_sli_visual_indicator_button;
     GtkWidget *show_multigpu_visual_indicator_button;
 
+    gint *stereo_swap_mode_table;
+    gint stereo_swap_mode_table_size;
+
     unsigned int active_attributes;
 };
 
diff --git a/src/gtk+-2.x/ctkslimm.c b/src/gtk+-2.x/ctkslimm.c
index 784c3dd..70b5fac 100644
--- a/src/gtk+-2.x/ctkslimm.c
+++ b/src/gtk+-2.x/ctkslimm.c
@@ -112,6 +112,7 @@ static GridConfig gridConfigs[] = {
     {2, 2,  FALSE},
     {2, 3,  FALSE},
     {2, 4,  FALSE},
+    {4, 2,  FALSE},
     {3, 1,  FALSE},
     {3, 2,  FALSE},
     {1, 3,  FALSE},
diff --git a/src/gtk+-2.x/ctkvdpau.c b/src/gtk+-2.x/ctkvdpau.c
index 1b076fc..58b756d 100644
--- a/src/gtk+-2.x/ctkvdpau.c
+++ b/src/gtk+-2.x/ctkvdpau.c
@@ -185,6 +185,11 @@ static int queryBaseInfo(CtkVDPAU *ctk_vdpau, VdpDevice device,
         {"DIVX5",             VDP_DECODER_PROFILE_DIVX5_MOBILE, 0x40},
         {"DIVX5",       VDP_DECODER_PROFILE_DIVX5_HOME_THEATER, 0x40},
         {"DIVX5",           VDP_DECODER_PROFILE_DIVX5_HD_1080P, 0x40},
+        {"HEVC",                 VDP_DECODER_PROFILE_HEVC_MAIN, 0x80},
+        {"HEVC",              VDP_DECODER_PROFILE_HEVC_MAIN_10, 0x80},
+        {"HEVC",           VDP_DECODER_PROFILE_HEVC_MAIN_STILL, 0x80},
+        {"HEVC",              VDP_DECODER_PROFILE_HEVC_MAIN_12, 0x80},
+        {"HEVC",             VDP_DECODER_PROFILE_HEVC_MAIN_444, 0x80},
     };
     const size_t decoder_list_count = sizeof(decoder_list)/sizeof(Desc);
 
@@ -504,6 +509,11 @@ static int queryDecoderCaps(CtkVDPAU *ctk_vdpau, VdpDevice device,
         {"DIVX5 Mobile",       VDP_DECODER_PROFILE_DIVX5_MOBILE,       0},
         {"DIVX5 Home Theater", VDP_DECODER_PROFILE_DIVX5_HOME_THEATER, 0},
         {"DIVX5 HD 1080P",     VDP_DECODER_PROFILE_DIVX5_HD_1080P,     0},
+        {"HEVC Main",          VDP_DECODER_PROFILE_HEVC_MAIN,          0},
+        {"HEVC Main 10",       VDP_DECODER_PROFILE_HEVC_MAIN_10,       0},
+        {"HEVC Main Still Picture", VDP_DECODER_PROFILE_HEVC_MAIN_STILL, 0},
+        {"HEVC Main 12",       VDP_DECODER_PROFILE_HEVC_MAIN_12,       0},
+        {"HEVC Main 4:4:4",    VDP_DECODER_PROFILE_HEVC_MAIN_444,      0},
     };
     const size_t decoder_profile_count = sizeof(decoder_profiles)/sizeof(Desc);
 
diff --git a/src/libXNVCtrl/NVCtrl.h b/src/libXNVCtrl/NVCtrl.h
index b62c22f..e65540e 100644
--- a/src/libXNVCtrl/NVCtrl.h
+++ b/src/libXNVCtrl/NVCtrl.h
@@ -867,7 +867,7 @@
  *   scanout the pbuffer.  
  * - The desktop is running in with 16 bits per pixel.
  */
-#define NV_CTRL_PBUFFER_SCANOUT_SUPPORTED                       65  /* R-- */
+#define NV_CTRL_PBUFFER_SCANOUT_SUPPORTED                       65  /* not supported */
 #define NV_CTRL_PBUFFER_SCANOUT_FALSE                           0
 #define NV_CTRL_PBUFFER_SCANOUT_TRUE                            1
 
@@ -875,7 +875,7 @@
  * NV_CTRL_PBUFFER_SCANOUT_XID indicates the XID of the pbuffer used for
  * scanout.
  */
-#define NV_CTRL_PBUFFER_SCANOUT_XID                             66  /* RW- */
+#define NV_CTRL_PBUFFER_SCANOUT_XID                             66  /* not supported */
 
 /**************************************************************************/
 /*
@@ -3399,7 +3399,22 @@
 
 #define NV_CTRL_THERMAL_COOLER_CURRENT_LEVEL                    417 /* R--C */
 
+/*
+ * NV_CTRL_STEREO_SWAP_MODE - This attribute controls the swap mode when
+ * Quad-Buffered stereo is used.
+ * NV_CTRL_STEREO_SWAP_MODE_APPLICATION_CONTROL : Stereo swap mode is derived
+ * from the value of swap interval.
+ * If it's odd, the per eye swap mode is used.
+ * If it's even, the per eye pair swap mode is used.
+ * NV_CTRL_STEREO_SWAP_MODE_PER_EYE : The driver swaps each eye as it is ready.
+ * NV_CTRL_STEREO_SWAP_MODE_PER_EYE_PAIR : The driver waits for both eyes to
+ * complete rendering before swapping.
+ */
 
+#define NV_CTRL_STEREO_SWAP_MODE                                418 /* RW-X */
+#define NV_CTRL_STEREO_SWAP_MODE_APPLICATION_CONTROL              0
+#define NV_CTRL_STEREO_SWAP_MODE_PER_EYE                          1
+#define NV_CTRL_STEREO_SWAP_MODE_PER_EYE_PAIR                     2
 
 /*
  * NV_CTRL_CURRENT_XV_SYNC_TO_DISPLAY_ID - When XVideo Sync To VBlank is
@@ -3474,7 +3489,7 @@
  * NV_CTRL_STRING_TV_ENCODER_NAME - not supported
  */
 
-#define NV_CTRL_STRING_TV_ENCODER_NAME                          5  /* R-DG */
+#define NV_CTRL_STRING_TV_ENCODER_NAME                          5  /* not supported */
 
 
 /*
@@ -4111,7 +4126,7 @@
 /*
  * NV_CTRL_STRING_DISPLAY_NAME_TYPE_ID - Returns the type-based name + ID for
  * the display device, e.g. "CRT-0", "DFP-1", "TV-2".  If this device is a
- * DisplayPort 1.2 device, then this name will also be prepended with the
+ * DisplayPort multistream device, then this name will also be prepended with the
  * device's port address like so: "DFP-1.0.1.2.3".  See
  * NV_CTRL_STRING_DISPLAY_NAME_TYPE_BASENAME for more information about the
  * construction of type-based names.
@@ -4660,7 +4675,7 @@
  * XRandR and XF86VidMode.
  */
 
-#define NV_CTRL_STRING_OPERATION_ADD_METAMODE                  0
+#define NV_CTRL_STRING_OPERATION_ADD_METAMODE                  0 /* ---- */
 
 
 /*
@@ -4680,7 +4695,7 @@
  * for generating ModeLines.
  */
 
-#define NV_CTRL_STRING_OPERATION_GTF_MODELINE                  1
+#define NV_CTRL_STRING_OPERATION_GTF_MODELINE                  1 /* --- */
 
 
 /*
@@ -4702,7 +4717,7 @@
  * for generating ModeLines.
  */
 
-#define NV_CTRL_STRING_OPERATION_CVT_MODELINE                  2
+#define NV_CTRL_STRING_OPERATION_CVT_MODELINE                  2 /* --- */
 
 
 /*
diff --git a/src/libXNVCtrl/version.mk b/src/libXNVCtrl/version.mk
index 7064f31..61aeb50 100644
--- a/src/libXNVCtrl/version.mk
+++ b/src/libXNVCtrl/version.mk
@@ -1 +1 @@
-NVIDIA_VERSION = 349.16
+NVIDIA_VERSION = 352.09
diff --git a/src/parse.c b/src/parse.c
index 4fadb3c..6ab7877 100644
--- a/src/parse.c
+++ b/src/parse.c
@@ -130,6 +130,7 @@ const AttributeTableEntry attributeTable[] = {
     { "MultiGpuMode",                     NV_CTRL_STRING_MULTIGPU_MODE,                 STR_ATTR, {0,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,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Enables or disables the use of G-SYNC when available." },
     { "ShowGSYNCVisualIndicator",         NV_CTRL_SHOW_GSYNC_VISUAL_INDICATOR,          INT_ATTR, {0,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 is in use, when an application is swapping using flipping." },
+    { "StereoSwapMode",                   NV_CTRL_STEREO_SWAP_MODE,                     INT_ATTR, {0,0,0,0,0,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Controls the swap mode when Quad-Buffered stereo is used." },
 
     /* GPU */
     { "BusType",                          NV_CTRL_BUS_TYPE,                             INT_ATTR, {0,0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the type of bus connecting the specified device to the computer.  If the target is an X screen, then it uses the GPU driving the X screen as the device." },
@@ -177,7 +178,9 @@ const AttributeTableEntry attributeTable[] = {
     { "ECCConfigurationSupported",        NV_CTRL_GPU_ECC_CONFIGURATION_SUPPORTED,      INT_ATTR, {0,0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Reports whether ECC whether the ECC configuration setting can be changed." },
     { "ECCConfiguration",                 NV_CTRL_GPU_ECC_CONFIGURATION,                INT_ATTR, {0,0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the current ECC configuration setting." },
     { "ECCDefaultConfiguration",          NV_CTRL_GPU_ECC_DEFAULT_CONFIGURATION,        INT_ATTR, {0,0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the default ECC configuration setting." },
-    { "ECCDoubleBitErrors",               NV_CTRL_GPU_ECC_DOUBLE_BIT_ERRORS,            INT_ATTR, {0,0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the number of double-bit ECC errors detected by the targeted GPU since the last POST." },
+    { "ECCSingleBitErrors",               NV_CTRL_GPU_ECC_SINGLE_BIT_ERRORS,            INT_ATTR, {0,0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the number of single-bit ECC errors detected by the targeted GPU since the last system reboot." },
+    { "ECCDoubleBitErrors",               NV_CTRL_GPU_ECC_DOUBLE_BIT_ERRORS,            INT_ATTR, {0,0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the number of double-bit ECC errors detected by the targeted GPU since the last system reboot." },
+    { "ECCAggregateSingleBitErrors",      NV_CTRL_GPU_ECC_AGGREGATE_SINGLE_BIT_ERRORS,  INT_ATTR, {0,0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the number of single-bit ECC errors detected by the targeted GPU since the last counter reset." },
     { "ECCAggregateDoubleBitErrors",      NV_CTRL_GPU_ECC_AGGREGATE_DOUBLE_BIT_ERRORS,  INT_ATTR, {0,0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the number of double-bit ECC errors detected by the targeted GPU since the last counter reset." },
     { "GPUFanControlState",               NV_CTRL_GPU_COOLER_MANUAL_CONTROL,            INT_ATTR, {0,0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "The current fan control state; the value of this attribute controls the availability of additional fan control attributes.  Note that this attribute is unavailable unless fan control support has been enabled by setting the \"Coolbits\" X config option." },
     { "GPUTargetFanSpeed",                NV_CTRL_THERMAL_COOLER_LEVEL,                 INT_ATTR, {0,0,0,0,1,0}, { .int_flags = {0,0,0,0,0,0,0} }, "Returns the GPU fan's target speed." },
diff --git a/src/version.h b/src/version.h
index bfd9c21..2a4f19c 100644
--- a/src/version.h
+++ b/src/version.h
@@ -1 +1 @@
-#define NVIDIA_VERSION "349.16"
+#define NVIDIA_VERSION "352.09"
diff --git a/src/version.mk b/src/version.mk
index 7064f31..61aeb50 100644
--- a/src/version.mk
+++ b/src/version.mk
@@ -1 +1 @@
-NVIDIA_VERSION = 349.16
+NVIDIA_VERSION = 352.09
diff --git a/version.mk b/version.mk
index 7064f31..61aeb50 100644
--- a/version.mk
+++ b/version.mk
@@ -1 +1 @@
-NVIDIA_VERSION = 349.16
+NVIDIA_VERSION = 352.09