Fix Corsair K70 RGB PRO V2 direct lighting

The K70 RGB PRO V2 (1B1C:1BB3) was detected but never lit: it blanked
into software render mode and then fell back to its onboard effect.
Getting it working turned up five faults, three of which affect every
Corsair V2 device rather than just this keyboard.

Packet size is now read from the HID report descriptor before the first
write instead of being inferred from a reply. These devices come in a 64
byte and a 1024 byte flavour, and sending a short packet to a 1024 byte
endpoint stalls it until the device is power cycled, so the size has to
be known up front rather than after two short queries have gone out.

CORSAIR_V2_PACKET_SIZE was 1024 while pkt_sze reached 1025, so every
read using pkt_sze overran its stack buffer by a byte. The command
helpers now use pkt_sze against buffers of the corrected size.

The lighting resource probe ran before the device was placed in software
render mode, where the answer is meaningless, and treated any error as
"use resource 1". Devices that answer invalid or unsupported for
resource 1 want the alternate lighting resource, which takes RGB
triplets; this keyboard is one of them. The probe now runs after the
render mode switch and distinguishes a stale open handle from an
unsupported resource.

Direct lighting writes were sized from the keymap, which covers only the
keys that exist. The hardware expects its full slot count and ignores a
short write, so corsair_v2_device carries an optional hw_led_count and
the buffer map is padded to it. Set to 193 for this keyboard.

The keepalive thread wrote LEDs on its first pass, because
last_update_time was left at the clock epoch and so always read as older
than the update period. That raced detection on the same HID handle with
no locking, which both corrupted the transaction and could abort the
process. The clock is now started before the thread runs, device
transactions are serialised behind a mutex, and the thread is stopped
before Shutdown rather than after.

Also fixes an uninitialised stack buffer sent to the device during
setup, and widens the K70 RGB PRO matrix to 22 columns so the numpad
period key has a position in the layout instead of being dropped.

Verified on hardware: repeated colour changes apply and the device stays
responsive across runs.

Co-Authored-By: Claude Opus 5 <[email protected]>

.gitlab-ci.yml

@@ -14,9 +14,9 @@
 #   run only if manually started to save CI minutes if      #
 #   GitLab hosted runners                                   #
 # * For commits to the CalcProgrammer1/OpenRGB repository,  #
-#   automatically run all jobs on the default branch,       #
-#   otherwise run them if the source is part of a merge     #
-#   request                                                 #
+#   automatically run all jobs on the default branch or     #
+#   tag builds, otherwise run them if the source is part    #
+#   of a merge request                                      #
 #-----------------------------------------------------------#
 .downstream_rules:
   rules:
@@ -26,7 +26,7 @@
 
 .upstream_rules:
   rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB" && ($CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH || $CI_PIPELINE_SOURCE == "merge_request_event")'
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB" && ($CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH || $CI_COMMIT_TAG || $CI_PIPELINE_SOURCE == "merge_request_event")'
     when: on_success
   - !reference [.downstream_rules, rules]
 
@@ -51,7 +51,7 @@ before_script:
 # Supported Devices Build Target                            #
 #-----------------------------------------------------------#
 "Supported Devices":
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:trixie-amd64
   tags:
   - linux
   - amd64
@@ -71,10 +71,10 @@ before_script:
     - !reference [.upstream_rules, rules]
 
 #-----------------------------------------------------------#
-# OpenRGB Common Appimage Build Steps                       #
+# OpenRGB Common AppImage Build Steps                       #
 #-----------------------------------------------------------#
 .hidden_appimage_script: &appimage_script_steps
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-${TGT_ARCH}
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:trixie-${TGT_ARCH}
   tags:
   - linux
   - ${TGT_ARCH}
@@ -87,8 +87,6 @@ before_script:
     name: "${CI_PROJECT_NAME}_Linux_${TGT_NAME}_${CI_COMMIT_SHORT_SHA}"
     paths:
     - OpenRGB-${TGT_PATH}.AppImage
-    - 60-openrgb.rules
-    - README.md
     expire_in: 30 days
 
   rules:
@@ -290,13 +288,13 @@ before_script:
   <<: *debian_script_steps
 
 #-----------------------------------------------------------#
-# Linux (.rpm, F43) 64-bit Build Target                     #
+# Linux (.rpm) Fedora 44 amd64 Build Target                 #
 #-----------------------------------------------------------#
-"Linux 64 F43 rpm":
-  image: fedora:43
+"Linux amd64 .rpm (Fedora 44)":
+  image: fedora:44
   stage: build
   script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel git wget -y
+  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt6-qtbase-devel git wget -y
   - 'wget -O hidapi-hotplug.zip https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+64+F43+rpm'
   - unzip hidapi-hotplug.zip
   - dnf install ./*.rpm -y
@@ -312,7 +310,7 @@ before_script:
   - cd ${CI_PROJECT_DIR}
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_64_rpm_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_amd64_rpm_${CI_COMMIT_SHORT_SHA}"
     paths:
     - openrgb*.rpm
     expire_in: 30 days
@@ -320,6 +318,44 @@ before_script:
   rules:
     - !reference [.upstream_rules, rules]
 
+#-----------------------------------------------------------#
+# OpenRGB Common Flatpak Build Steps                        #
+#-----------------------------------------------------------#
+.hidden_flatpak_script: &flatpak_script_steps
+  image: ghcr.io/flathub-infra/flatpak-github-actions:kde-6.10
+  stage: build
+  tags:
+  - linux
+  - ${TGT_ARCH}
+  script:
+  - flatpak-builder --user --disable-rofiles-fuse --repo=build/repo build/flatpak-build flatpak/org.openrgb.OpenRGB.yaml
+  - flatpak build-bundle build/repo org.openrgb.OpenRGB.flatpak org.openrgb.OpenRGB
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_${TGT_ARCH}_Flatpak_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - org.openrgb.OpenRGB.flatpak
+    expire_in: 30 days
+
+  rules:
+    - !reference [.upstream_rules, rules]
+
+#-----------------------------------------------------------#
+# Linux Flatpak amd64 Build Target                          #
+#-----------------------------------------------------------#
+"Linux amd64 Flatpak":
+  variables:
+    TGT_ARCH: "amd64"
+  <<: *flatpak_script_steps
+
+#-----------------------------------------------------------#
+# Linux Flatpak arm64 Build Target                          #
+#-----------------------------------------------------------#
+"Linux arm64 Flatpak":
+  variables:
+    TGT_ARCH: "arm64"
+  <<: *flatpak_script_steps
+
 #-----------------------------------------------------------#
 # Debian i386 Bookworm test                                 #
 #-----------------------------------------------------------#
@@ -387,10 +423,10 @@ before_script:
   - !reference [.upstream_rules, rules]
 
 #-----------------------------------------------------------#
-# Fedora 64 v43 test                                        #
+# Fedora amd64 44 test                                      #
 #-----------------------------------------------------------#
-"Fedora 64 v43":
-  image: fedora:43
+"Fedora 64 44":
+  image: fedora:44
   stage: test
   script:
   - dnf install unzip wget -y
@@ -401,9 +437,9 @@ before_script:
   - openrgb --version
   - dnf5 -y remove openrgb
   dependencies:
-  - "Linux 64 F43 rpm"
+  - "Linux amd64 .rpm (Fedora 44)"
   needs:
-  - "Linux 64 F43 rpm"
+  - "Linux amd64 .rpm (Fedora 44)"
   rules:
   - !reference [.upstream_rules, rules]
 

AutoStart/AutoStart-Flatpak.cpp

@@ -0,0 +1,158 @@
+/*---------------------------------------------------------*\
+| AutoStart-Flatpak.cpp                                     |
+|                                                           |
+|   Autostart implementation for Linux via Flatpak Portal   |
+|                                                           |
+|   Adam Honse <[email protected]>      04 Sep 2026 |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "AutoStart-Flatpak.h"
+#include <gio/gio.h>
+
+AutoStart::AutoStart(std::string name)
+{
+    InitAutoStart(name);
+}
+
+void AutoStart::InitAutoStart(std::string name)
+{
+    app_name = name;
+}
+
+bool AutoStart::CallBackgroundPortal(bool enable, const AutoStartInfo& autostart_info)
+{
+    GError*             error           = nullptr;
+    GDBusConnection*    connection      = g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, &error);
+
+    if(!connection)
+    {
+        if(error)
+        {
+            g_error_free(error);
+        }
+
+        return false;
+    }
+
+    /*-----------------------------------------------------*\
+    | FreeDesktop Background Portal parameters              |
+    \*-----------------------------------------------------*/
+    const char*         bus_name        = "org.freedesktop.portal.Desktop";
+    const char*         object_path     = "/org/freedesktop/portal/desktop";
+    const char*         interface_name  = "org.freedesktop.portal.Background";
+    const char*         method_name     = "RequestBackground";
+
+    /*-----------------------------------------------------*\
+    | Build the options dictionary (vardict) required by    |
+    | the Portal                                            |
+    \*-----------------------------------------------------*/
+    GVariantBuilder     options_builder;
+    g_variant_builder_init(&options_builder, G_VARIANT_TYPE_VARDICT);
+
+    /*-----------------------------------------------------*\
+    | Reason shown to the user in the system settings /     |
+    | permission prompt                                     |
+    \*-----------------------------------------------------*/
+    std::string         reason_str      = "Allow " + app_name + " to launch automatically at startup.";
+    g_variant_builder_add(&options_builder, "{sv}", "reason", g_variant_new_string(reason_str.c_str()));
+
+    /*-----------------------------------------------------*\
+    | Toggle the autostart feature state                    |
+    \*-----------------------------------------------------*/
+    g_variant_builder_add(&options_builder, "{sv}", "autostart", g_variant_new_boolean(enable));
+
+    if(enable)
+    {
+        /*-------------------------------------------------*\
+        | Pass command-line arguments to the background     |
+        | request                                           |
+        \*-------------------------------------------------*/
+        GVariantBuilder arg_builder;
+        g_variant_builder_init(&arg_builder, G_VARIANT_TYPE("as"));
+
+        /*-------------------------------------------------*\
+        | Add the primary executable path inside the        |
+        | Flatpak sandbox                                   |
+        \*-------------------------------------------------*/
+        g_variant_builder_add(&arg_builder, "s", GetExePath().c_str());
+
+        /*-------------------------------------------------*\
+        | Append any additional arguments provided by       |
+        | OpenRGB's autostart config                        |
+        \*-------------------------------------------------*/
+        if(!autostart_info.args.empty())
+        {
+            g_variant_builder_add(&arg_builder, "s", autostart_info.args.c_str());
+        }
+
+        GVariant*   commandline_args    = g_variant_builder_end(&arg_builder);
+        g_variant_builder_add(&options_builder, "{sv}", "commandline", commandline_args);
+    }
+
+    /*-----------------------------------------------------*\
+    | An empty string window handle is used since this is a |
+    | background configuration request                      |
+    \*-----------------------------------------------------*/
+    const char*     parent_window       = "";
+    GVariant*       options             = g_variant_builder_end(&options_builder);
+
+    /*-----------------------------------------------------*\
+    | Bundle parameters: (s a{sv}) -> Parent window handle, |
+    | Options dictionary                                    |
+    \*-----------------------------------------------------*/
+    GVariant*       parameters          = g_variant_new("(s@a{sv})", parent_window, options);
+    GVariant*       reply;
+
+    reply = g_dbus_connection_call_sync(connection, bus_name, object_path, interface_name, method_name, parameters, G_VARIANT_TYPE("(o)"), G_DBUS_CALL_FLAGS_NONE, -1, nullptr, &error);
+
+    g_object_unref(connection);
+
+    if(error)
+    {
+        g_error_free(error);
+        return false;
+    }
+
+    if(reply)
+    {
+        g_variant_unref(reply);
+        return true;
+    }
+
+    return false;
+}
+
+bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
+{
+    return CallBackgroundPortal(true, autostart_info);
+}
+
+bool AutoStart::DisableAutoStart()
+{
+    return CallBackgroundPortal(false);
+}
+
+bool AutoStart::IsAutoStartEnabled()
+{
+    /*-----------------------------------------------------*\
+    | The FreeDesktop Background Portal does not provide a  |
+    | stateless status getter.  Sandbox permissions are     |
+    | securely managed and persisted internally by the      |
+    | host's portal service.  To implement a true state     |
+    | track here, OpenRGB will need to manage a local       |
+    | boolean flag inside its own configuration files (e.g. |
+    | OpenRGB.json).                                        |
+    \*-----------------------------------------------------*/
+    return false;
+}
+
+std::string AutoStart::GetExePath()
+{
+    /*-----------------------------------------------------*\
+    | Flatpak applications always run from this specific    |
+    | exported path hierarchy                               |
+    \*-----------------------------------------------------*/
+    return "/app/bin/openrgb";
+}

AutoStart/AutoStart-Flatpak.h

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------*\
+| AutoStart-Flatpak.h                                       |
+|                                                           |
+|   Autostart implementation for Linux via Flatpak Portal   |
+|                                                           |
+|   Adam Honse <[email protected]>      04 Sep 2026 |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include "AutoStart.h"
+
+class AutoStart : public AutoStartInterface
+{
+public:
+    AutoStart(std::string name);
+
+    bool        DisableAutoStart();
+    bool        EnableAutoStart(AutoStartInfo autostart_info);
+    bool        IsAutoStartEnabled();
+    std::string GetExePath();
+
+private:
+    void        InitAutoStart(std::string name);
+    bool        CallBackgroundPortal(bool enable, const AutoStartInfo& autostart_info = {});
+    
+    std::string app_name;
+};

AutoStart/AutoStart-Linux.cpp

@@ -149,6 +149,64 @@ std::string AutoStart::GetExePath()
 | Private Methods                                           |
 \*---------------------------------------------------------*/
 
+/*---------------------------------------------------------*\
+| Escape a single argument for use in a .desktop Exec=      |
+| field, per the Desktop Entry Specification.               |
+|                                                           |
+| Reserved characters must be escaped by wrapping the whole |
+| argument in double quotes and backslash-escaping the      |
+| quote/backquote/backslash/dollar characters, and any      |
+| literal '%' must be doubled to '%%'.                      |
+\*---------------------------------------------------------*/
+static std::string DesktopExecEscape(const std::string& arg)
+{
+    static const std::string reserved = " \t\n\"'`\\><~|&;$*?#()%";
+
+    bool needs_quotes = false;
+    for(char c : arg)
+    {
+        if(reserved.find(c) != std::string::npos)
+        {
+            needs_quotes = true;
+            break;
+        }
+    }
+
+    std::string escaped;
+
+    if(needs_quotes)
+    {
+        escaped += '"';
+    }
+
+    for(char c : arg)
+    {
+        switch(c)
+        {
+            case '"':
+            case '`':
+            case '\\':
+            case '$':
+                escaped += '\\';
+                escaped += c;
+                break;
+            case '%':
+                escaped += "%%";
+                break;
+            default:
+                escaped += c;
+                break;
+        }
+    }
+
+    if(needs_quotes)
+    {
+        escaped += '"';
+    }
+
+    return(escaped);
+}
+
 std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
 {
     /*-----------------------------------------------------*\
@@ -169,11 +227,17 @@ std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
     /*-----------------------------------------------------*\
     | Add the executable path and arguments                 |
     \*-----------------------------------------------------*/
-    fileContents << "Exec="              << autostart_info.path;
+    fileContents << "Exec="              << DesktopExecEscape(autostart_info.path);
 
     if (autostart_info.args != "")
     {
-        fileContents << " " << autostart_info.args;
+        std::istringstream arg_parser(autostart_info.args);
+        std::string arg;
+
+        while(arg_parser >> arg)
+        {
+            fileContents << " " << DesktopExecEscape(arg);
+        }
     }
 
     fileContents << std::endl;

AutoStart/AutoStart-MacOS.cpp

@@ -137,6 +137,43 @@ std::string AutoStart::GetExePath()
 | Private Methods                                           |
 \*---------------------------------------------------------*/
 
+/*---------------------------------------------------------*\
+| Escape a string for embedding inside an XML element       |
+| (used by the .plist generator) to avoid producing         |
+| malformed property list files.                            |
+\*---------------------------------------------------------*/
+static std::string XmlEscape(const std::string& input)
+{
+    std::string escaped;
+
+    for(char c : input)
+    {
+        switch(c)
+        {
+            case '&':
+                escaped += "&";
+                break;
+            case '<':
+                escaped += "&lt;";
+                break;
+            case '>':
+                escaped += "&gt;";
+                break;
+            case '"':
+                escaped += "&quot;";
+                break;
+            case '\'':
+                escaped += "&apos;";
+                break;
+            default:
+                escaped += c;
+                break;
+        }
+    }
+
+    return(escaped);
+}
+
 std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
 {
     /*-----------------------------------------------------*\
@@ -153,7 +190,8 @@ std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
     fileContents << "    <string>org.openrgb</string>"                                                                              << std::endl;
     fileContents << "    <key>ProgramArguments</key>"                                                                               << std::endl;
     fileContents << "    <array>"                                                                                                   << std::endl;
-    fileContents << "        <string>" << autostart_info.path << "</string>"                                                        << std::endl;
+    fileContents << "        <string>" << XmlEscape(autostart_info.path) << "</string>"
+                 << std::endl;
 
     if(autostart_info.args != "")
     {
@@ -162,7 +200,8 @@ std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
 
         while(arg_parser >> arg)
         {
-            fileContents << "        <string>" << arg << "</string>"                                                                << std::endl;
+            fileContents << "        <string>" << XmlEscape(arg) << "</string>"
+                         << std::endl;
         }
     }
 

AutoStart/AutoStart-Windows.cpp

@@ -12,6 +12,7 @@
 #include <shlobj.h>
 #include "AutoStart-Windows.h"
 #include "LogManager.h"
+#include "StringUtils.h"
 #include "filesystem.h"
 #include "windows.h"
 
@@ -71,11 +72,11 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
         HRESULT         result;
         IShellLinkW*    shellLink                   = NULL;
 
-        std::wstring    exepathw                    = utf8_decode(autostart_info.path);
-        std::wstring    argumentsw                  = utf8_decode(autostart_info.args);
-        std::wstring    startupfilepathw            = utf8_decode(autostart_file);
-        std::wstring    descriptionw                = utf8_decode(autostart_info.desc);
-        std::wstring    iconw                       = utf8_decode(autostart_info.path);
+        std::wstring    exepathw                    = StringUtils::string_to_wstring(autostart_info.path);
+        std::wstring    argumentsw                  = StringUtils::string_to_wstring(autostart_info.args);
+        std::wstring    startupfilepathw            = StringUtils::string_to_wstring(autostart_file);
+        std::wstring    descriptionw                = StringUtils::string_to_wstring(autostart_info.desc);
+        std::wstring    iconw                       = StringUtils::string_to_wstring(autostart_info.path);
 
         result                                      = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);
 
@@ -150,11 +151,16 @@ std::string AutoStart::GetExePath()
     /*-----------------------------------------------------*\
     | Create the OpenRGB executable path                    |
     \*-----------------------------------------------------*/
-    char exepath[MAX_PATH] = "";
+    wchar_t exepath[MAX_PATH] = L"";
 
-    DWORD count = GetModuleFileNameA(NULL, exepath, MAX_PATH);
+    DWORD count = GetModuleFileNameW(NULL, exepath, MAX_PATH);
 
-    return(std::string(exepath, (count > 0) ? count : 0));
+    if(count == 0)
+    {
+        return(std::string());
+    }
+
+    return(StringUtils::wstring_to_string(std::wstring(exepath, count)));
 }
 
 /*---------------------------------------------------------*\
@@ -164,43 +170,39 @@ std::string AutoStart::GetExePath()
 
 void AutoStart::InitAutoStart(std::string name)
 {
-    char startMenuPath[MAX_PATH];
+    wchar_t startMenuPath[MAX_PATH];
 
     autostart_name = name;
 
     /*-----------------------------------------------------*\
     | Get startup applications path                         |
     \*-----------------------------------------------------*/
-    HRESULT result = SHGetFolderPathA(NULL, CSIDL_PROGRAMS, NULL, 0, startMenuPath);
+    HRESULT result = SHGetFolderPathW(NULL, CSIDL_PROGRAMS, NULL, 0, startMenuPath);
 
     if(SUCCEEDED(result))
     {
-        autostart_file = std::string(startMenuPath);
+        std::string autostart_dir = StringUtils::wstring_to_string(startMenuPath);
+        autostart_dir += "\\Startup\\";
 
-        autostart_file += "\\Startup\\" + autostart_name + ".lnk";
+        /*-------------------------------------------------*\
+        | Create the directory if it doesn't exist          |
+        \*-------------------------------------------------*/
+        std::error_code ec;
+
+        bool success = true;
+
+        if(!filesystem::exists(autostart_dir))
+        {
+            success = filesystem::create_directories(autostart_dir, ec);
+        }
+
+        if(success)
+        {
+            autostart_file = autostart_dir + autostart_name + ".lnk";
+        }
     }
     else
     {
         autostart_file.clear();
     }
 }
-
-/*---------------------------------------------------------*\
-| Convert an UTF8 string to a wide Unicode String           |
-| (from wmi.cpp)                                            |
-\*---------------------------------------------------------*/
-std::wstring AutoStart::utf8_decode(const std::string& str)
-{
-    if(str.empty())
-    {
-        return std::wstring();
-    }
-
-    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), nullptr, 0);
-
-    std::wstring wstrTo(size_needed, 0);
-
-    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), &wstrTo[0], size_needed);
-
-    return(wstrTo);
-}

AutoStart/AutoStart-Windows.h

@@ -24,5 +24,4 @@ public:
 
 private:
     void            InitAutoStart(std::string name);
-    std::wstring    utf8_decode(const std::string& str);
 };

AutoStart/AutoStart.h

@@ -40,9 +40,15 @@ protected:
 #include "AutoStart-Windows.h"
 #endif
 
+#ifdef FLATPAK_BUILD
+#include "AutoStart-Flatpak.h"
+#endif
+
 #ifdef __linux__
+#ifndef FLATPAK_BUILD
 #include "AutoStart-Linux.h"
 #endif
+#endif
 
 #ifdef __APPLE__
 #include "AutoStart-MacOS.h"

Controllers/ASRockSMBusController/ASRockGPUSMBusController/ASRockGPUSMBusController.cpp

@@ -186,8 +186,8 @@ void ASRockGPUSMBusController::SetChannelColor(uint8_t channel_idx, uint8_t red,
         red,
         green,
         blue,
-        0x80,  // Brightness
-        0xFF,  // Effect speed
+        0x80,  // Effect speed
+        0xFF,  // Brightness
         0x00,  // Effect direction
         0x1A   // Unknown constant
     };

Controllers/ASRockSMBusController/ASRockGPUSMBusController/ASRockGPUSMBusControllerDetect.cpp

@@ -11,6 +11,7 @@
 #include "ASRockGPUSMBusController.h"
 #include "LogManager.h"
 #include "RGBController_ASRockGPUSMBus.h"
+#include "i2c_amd_gpu.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
 
@@ -18,15 +19,12 @@ DetectedControllers DetectASRockGPUSMBusControllers(i2c_smbus_interface* bus, ui
 {
     DetectedControllers detected_controllers;
 
-    LOG_DEBUG("[ASRock GPU] Checking GPU I2C bus for RGB controller at 0x%02X", address);
-
-    if(bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE) < 0)
+    if(bus->info.pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
     {
-        LOG_DEBUG("[ASRock GPU] No response at address 0x%02X", address);
         return(detected_controllers);
     }
 
-    LOG_DEBUG("[ASRock GPU] Device responded at 0x%02X, creating controller", address);
+    LOG_DEBUG("[ASRock GPU] Checking GPU I2C bus for RGB controller at 0x%02X", address);
 
     ASRockGPUSMBusController* controller = new ASRockGPUSMBusController(bus, address, name);
 
@@ -43,4 +41,7 @@ DetectedControllers DetectASRockGPUSMBusControllers(i2c_smbus_interface* bus, ui
     return(detected_controllers);
 }
 
-REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Steel Legend", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5403, ASROCK_GPU_SMBUS_ADDRESS);
+REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Steel Legend",   DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5403, ASROCK_GPU_SMBUS_ADDRESS);
+REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Steel Legend Dark", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5414, ASROCK_GPU_SMBUS_ADDRESS);
+REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Taichi 16GB OC", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5401, ASROCK_GPU_SMBUS_ADDRESS);
+REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9060 XT Steel Legend",   DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI44_DEV, ASROCK_SUB_VEN, 0x5407, ASROCK_GPU_SMBUS_ADDRESS);

Controllers/ASRockSMBusController/ASRockGPUSMBusController/RGBController_ASRockGPUSMBus.cpp

@@ -11,6 +11,17 @@
 
 #include "RGBController_ASRockGPUSMBus.h"
 
+/**------------------------------------------------------------------*\
+    @name ASRock GPU SMBus
+    @category GPU
+    @type I2C
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectASRockGPUSMBusControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
 RGBController_ASRockGPUSMBus::RGBController_ASRockGPUSMBus(ASRockGPUSMBusController* controller_ptr)
 {
     controller  = controller_ptr;
@@ -33,6 +44,8 @@ RGBController_ASRockGPUSMBus::RGBController_ASRockGPUSMBus(ASRockGPUSMBusControl
 
 RGBController_ASRockGPUSMBus::~RGBController_ASRockGPUSMBus()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AcerNitroHidKeyboardController/RGBController_AcerNitroHidKeyboard.cpp

@@ -11,16 +11,16 @@
 
 #include "RGBController_AcerNitroHidKeyboard.h"
 
-// /**------------------------------------------------------------------*\
-//     @name Acer Nitro HID Keyboard
-//     @category Laptop
-//     @type HID
-//     @save :x:
-//     @direct :white_check_mark:
-//     @effects :white_check_mark:
-//     @detectors DetectAcerHIDControllers
-//     @comment
-// \*-------------------------------------------------------------------*/
+/**------------------------------------------------------------------*\
+    @name Acer Nitro HID Keyboard
+    @category Laptop
+    @type HID
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAcerHIDControllers
+    @comment
+\*-------------------------------------------------------------------*/
 
 RGBController_AcerNitroHidKeyboard::RGBController_AcerNitroHidKeyboard(std::shared_ptr<AcerNitroHidKeyboardController> controller)
 {
@@ -72,7 +72,7 @@ RGBController_AcerNitroHidKeyboard::RGBController_AcerNitroHidKeyboard(std::shar
     Breathing.speed_min         = 1;
     Breathing.speed_max         = 9;
     Breathing.speed             = 4;
-    Breathing.colors.resize(1);    
+    Breathing.colors.resize(1);
 
     modes.push_back(Breathing);
 
@@ -86,7 +86,7 @@ RGBController_AcerNitroHidKeyboard::RGBController_AcerNitroHidKeyboard(std::shar
     Neon.brightness             = 100;
     Neon.speed_min              = 1;
     Neon.speed_max              = 9;
-    Neon.speed                  = 4;  
+    Neon.speed                  = 4;
 
     modes.push_back(Neon);
 
@@ -104,7 +104,7 @@ RGBController_AcerNitroHidKeyboard::RGBController_AcerNitroHidKeyboard(std::shar
     Wave.direction              = 0;
 
     modes.push_back(Wave);
-    
+
     mode Shifting;
     Shifting.name               = "Shifting";
     Shifting.value              = ACER_HID_MODE_SHIFTING;
@@ -199,15 +199,15 @@ void RGBController_AcerNitroHidKeyboard::SetupZones()
 void RGBController_AcerNitroHidKeyboard::DeviceUpdateLEDs()
 {
     mode& current_mode = modes[active_mode];
-    if(current_mode.value == ACER_HID_MODE_DIRECT) 
+    if(current_mode.value == ACER_HID_MODE_DIRECT)
     {
         controller->SetLEDs(colors, current_mode.brightness, device_id);
     }
-    else 
+    else
     {
         RGBColor color          = current_mode.colors.size()==0? (RGBColor)0 :  current_mode.colors[0];
         unsigned char direction = 1;
-        if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && modes[active_mode].direction) 
+        if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && modes[active_mode].direction)
         {
             direction           = 2;
         }

Controllers/AcerNitroHidKeyboardController/RGBController_AcerNitroHidLed.cpp

@@ -11,16 +11,16 @@
 
 #include "RGBController_AcerNitroHidLed.h"
 
-// /**------------------------------------------------------------------*\
-//     @name Acer Nitro HID Led
-//     @category Laptop
-//     @type HID
-//     @save :x:
-//     @direct :white_check_mark:
-//     @effects :white_check_mark:
-//     @detectors DetectAcerHIDControllers
-//     @comment
-// \*-------------------------------------------------------------------*/
+/**------------------------------------------------------------------*\
+    @name Acer Nitro HID Led
+    @category Laptop
+    @type HID
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAcerHIDControllers
+    @comment
+\*-------------------------------------------------------------------*/
 
 RGBController_AcerNitroHidLed::RGBController_AcerNitroHidLed(std::shared_ptr<AcerNitroHidKeyboardController> controller)
 {
@@ -108,27 +108,27 @@ void RGBController_AcerNitroHidLed::SetupZones()
     new_zone->leds_max      = 1;
     new_zone->leds_count    = 1;
     zones.push_back(*new_zone);
-    
+
     led* new_led            = new led();
     new_led->name           = "LED";
     new_led->value          = (unsigned int)leds.size();
     leds.push_back(*new_led);
-    
+
     SetupColors();
 }
 
 void RGBController_AcerNitroHidLed::DeviceUpdateLEDs()
 {
     mode& current_mode = modes[active_mode];
-    if(current_mode.value == ACER_HID_MODE_DIRECT) 
+    if(current_mode.value == ACER_HID_MODE_DIRECT)
     {
         controller->SetLEDs(colors, current_mode.brightness, device_id);
     }
-    else 
+    else
     {
         RGBColor color          = current_mode.colors.size()==0? (RGBColor)0 :  current_mode.colors[0];
         unsigned char direction = 1;
-        if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && modes[active_mode].direction) 
+        if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && modes[active_mode].direction)
         {
             direction           = 2;
         }

Controllers/AlienwareController/AlienwareController.cpp

@@ -32,6 +32,7 @@ static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
     { 0x0C01,   4 },    // Dell G5 SE 5505
     { 0x0A01,  16 },    // Dell G7 15 7500
     { 0x0E03,   4 },    // Dell G15   5511
+    { 0x0E07,   4 },    // Dell G15   5520
     { 0x0E0A,   4 }     // Dell G15   5530
 
 };
@@ -49,9 +50,21 @@ static const std::map<alienware_platform_id, std::vector<const char*>> zone_name
                   "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
                   "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } },
     { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } },
+    { 0x0E07,   { "Left",           "Middle",       "Right",        "Numpad"    } },
     { 0x0E0A,   { "Left",           "Middle",       "Right",        "Numpad"    } }
 };
 
+/*---------------------------------------------------------*\
+| Mapping the platform ID to the actual hardware zone IDs   |
+\*---------------------------------------------------------*/
+static const std::map<alienware_platform_id, std::vector<uint8_t>> zone_ids_table =
+{
+    { 0x0C01,   { 0x00, 0x01, 0x02, 0x03 } }, // Dell G5 SE 5505
+    { 0x0E03,   { 0x00, 0x01, 0x02, 0x03 } }, // Dell G15   5511
+    { 0x0E07,   { 0x10, 0x11, 0x12, 0x13 } }, // Dell G15   5520
+    { 0x0E0A,   { 0x10, 0x11, 0x12, 0x13 } }  // Dell G15   5530
+};
+
 static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
 {
     using namespace std::chrono_literals;
@@ -138,6 +151,21 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
         }
     }
 
+    /*-----------------------------------------------------*\
+    | Initialize hardware zone IDs                          |
+    \*-----------------------------------------------------*/
+    if(zone_ids_table.count(platform_id))
+    {
+        zone_ids = zone_ids_table.at(platform_id);
+    }
+    else
+    {
+        for(size_t i = 0; i < number_of_zones; i++)
+        {
+            zone_ids.push_back(static_cast<uint8_t>(i));
+        }
+    }
+
     /*-----------------------------------------------------*\
     | Set defaults for all zones                            |
     | It doesn't seem possible to read the controller's     |
@@ -155,6 +183,7 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
         zones[zone_idx].period      = 2000;
         zones[zone_idx].tempo       = ALIENWARE_TEMPO_MAX;
         zones[zone_idx].dim         = 0;
+        zones[zone_idx].direction   = 0;
     }
 
     /*-----------------------------------------------------*\
@@ -266,42 +295,53 @@ bool AlienwareController::Dim(std::vector<uint8_t> zones, double percent)
         return(true);
     }
 
-    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+    bool result = true;
 
     /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
+    | Split the zone list into packet-sized chunks so it    |
+    | never overflows usb_buf                               |
     \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet with leading 00, per hidapi     |
-    \*-----------------------------------------------------*/
-    uint16_t num_zones  = (uint16_t)zones.size();
-
-    usb_buf[0x00]       = 0x00;
-    usb_buf[0x01]       = 0x03;
-    usb_buf[0x02]       = ALIENWARE_COMMAND_DIM;
-    usb_buf[0x03]       = static_cast<uint8_t>(percent);
-    usb_buf[0x04]       = num_zones >> 8;
-    usb_buf[0x05]       = num_zones & 0xFF;
-
-    for(size_t i = 0; i < num_zones; i++)
+    for(size_t offset = 0; offset < zones.size(); offset += ALIENWARE_MAX_ZONES_PER_PACKET)
     {
-        usb_buf[0x06+i] = zones[i];
+        unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+        /*-------------------------------------------------*\
+        | Zero out buffer                                   |
+        \*-------------------------------------------------*/
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+
+        /*-------------------------------------------------*\
+        | Set up message packet with leading 00, per hidapi |
+        \*-------------------------------------------------*/
+        uint16_t num_zones  = (uint16_t)std::min<size_t>(ALIENWARE_MAX_ZONES_PER_PACKET, zones.size() - offset);
+
+        usb_buf[0x00]       = 0x00;
+        usb_buf[0x01]       = 0x03;
+        usb_buf[0x02]       = ALIENWARE_COMMAND_DIM;
+        usb_buf[0x03]       = static_cast<uint8_t>(percent);
+        usb_buf[0x04]       = num_zones >> 8;
+        usb_buf[0x05]       = num_zones & 0xFF;
+
+        for(size_t i = 0; i < num_zones; i++)
+        {
+            usb_buf[0x06+i] = zones[offset + i];
+        }
+
+        /*-------------------------------------------------*\
+        | Send packet                                       |
+        \*-------------------------------------------------*/
+        SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+        HidapiAlienwareReport response = GetResponse();
+
+        /*-------------------------------------------------*\
+        | For this command, error is if the output equals   |
+        | the input                                         |
+        \*-------------------------------------------------*/
+        result &= (response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE);
     }
 
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
-
-    HidapiAlienwareReport response = GetResponse();
-
-    /*-----------------------------------------------------*\
-    | For this command, error is if the output equals the   |
-    | input                                                 |
-    \*-----------------------------------------------------*/
-    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
+    return(result);
 }
 
 bool AlienwareController::UserAnimation(uint16_t subcommand, uint16_t animation, uint16_t duration)
@@ -370,42 +410,53 @@ bool AlienwareController::SelectZones(const std::vector<uint8_t>& zones)
         return(false);
     }
 
-    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+    bool result = true;
 
     /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
+    | Split the zone list into packet-sized chunks so it    |
+    | never overflows usb_buf                               |
     \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet with leading 00, per hidapi     |
-    \*-----------------------------------------------------*/
-    uint16_t num_zones  = (uint16_t)zones.size();
-
-    usb_buf[0x00]       = 0x00;
-    usb_buf[0x01]       = 0x03;
-    usb_buf[0x02]       = ALIENWARE_COMMAND_SELECT_ZONES;
-    usb_buf[0x03]       = 1; // loop?
-    usb_buf[0x04]       = num_zones >> 8;
-    usb_buf[0x05]       = num_zones & 0xFF;
-
-    for(size_t i = 0; i < num_zones; i++)
+    for(size_t offset = 0; offset < zones.size(); offset += ALIENWARE_MAX_ZONES_PER_PACKET)
     {
-        usb_buf[0x06+i] = zones[i];
+        unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+        /*-------------------------------------------------*\
+        | Zero out buffer                                   |
+        \*-------------------------------------------------*/
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+
+        /*-------------------------------------------------*\
+        | Set up message packet with leading 00, per hidapi |
+        \*-------------------------------------------------*/
+        uint16_t num_zones  = (uint16_t)std::min<size_t>(ALIENWARE_MAX_ZONES_PER_PACKET, zones.size() - offset);
+
+        usb_buf[0x00]       = 0x00;
+        usb_buf[0x01]       = 0x03;
+        usb_buf[0x02]       = ALIENWARE_COMMAND_SELECT_ZONES;
+        usb_buf[0x03]       = 1; // loop?
+        usb_buf[0x04]       = num_zones >> 8;
+        usb_buf[0x05]       = num_zones & 0xFF;
+
+        for(size_t i = 0; i < num_zones; i++)
+        {
+            usb_buf[0x06+i] = zones[offset + i];
+        }
+
+        /*-------------------------------------------------*\
+        | Send packet                                       |
+        \*-------------------------------------------------*/
+        SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+        HidapiAlienwareReport response = GetResponse();
+
+        /*-------------------------------------------------*\
+        | For this command, error is if the output equals   |
+        | the input                                         |
+        \*-------------------------------------------------*/
+        result &= (response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE);
     }
 
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
-
-    HidapiAlienwareReport response = GetResponse();
-
-    /*-----------------------------------------------------*\
-    | For this command, error is if the output equals the   |
-    | input                                                 |
-    \*-----------------------------------------------------*/
-    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
+    return(result);
 }
 
 bool AlienwareController::ModeAction(uint8_t mode, uint16_t duration, uint16_t tempo, RGBColor color)
@@ -509,44 +560,55 @@ bool AlienwareController::SetColorDirect(RGBColor color, std::vector<uint8_t> zo
         return(true);
     }
 
-    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+    bool result = true;
 
     /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
+    | Split the zone list into packet-sized chunks so it    |
+    | never overflows usb_buf                               |
     \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet with leading 00, per hidapi     |
-    \*-----------------------------------------------------*/
-    uint16_t num_zones      = (uint16_t)zones.size();
-
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x03;
-    usb_buf[0x02]           = ALIENWARE_COMMAND_SET_COLOR;
-    usb_buf[0x03]           = RGBGetRValue(color);
-    usb_buf[0x04]           = RGBGetGValue(color);
-    usb_buf[0x05]           = RGBGetBValue(color);
-    usb_buf[0x06]           = num_zones >> 8;
-    usb_buf[0x07]           = num_zones & 0xFF;
-
-    for(size_t i = 0; i < num_zones; i++)
+    for(size_t offset = 0; offset < zones.size(); offset += ALIENWARE_MAX_ZONES_PER_PACKET)
     {
-        usb_buf[0x08 + i]   = zones[i];
+        unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+        /*-------------------------------------------------*\
+        | Zero out buffer                                   |
+        \*-------------------------------------------------*/
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+
+        /*-------------------------------------------------*\
+        | Set up message packet with leading 00, per hidapi |
+        \*-------------------------------------------------*/
+        uint16_t num_zones      = (uint16_t)std::min<size_t>(ALIENWARE_MAX_ZONES_PER_PACKET, zones.size() - offset);
+
+        usb_buf[0x00]           = 0x00;
+        usb_buf[0x01]           = 0x03;
+        usb_buf[0x02]           = ALIENWARE_COMMAND_SET_COLOR;
+        usb_buf[0x03]           = RGBGetRValue(color);
+        usb_buf[0x04]           = RGBGetGValue(color);
+        usb_buf[0x05]           = RGBGetBValue(color);
+        usb_buf[0x06]           = num_zones >> 8;
+        usb_buf[0x07]           = num_zones & 0xFF;
+
+        for(size_t i = 0; i < num_zones; i++)
+        {
+            usb_buf[0x08 + i]   = zones[offset + i];
+        }
+
+        /*-------------------------------------------------*\
+        | Send packet                                       |
+        \*-------------------------------------------------*/
+        SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+        HidapiAlienwareReport response = GetResponse();
+
+        /*-------------------------------------------------*\
+        | For this command, error is if the output equals   |
+        | the input                                         |
+        \*-------------------------------------------------*/
+        result &= (response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE);
     }
 
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
-
-    HidapiAlienwareReport response = GetResponse();
-
-    /*-----------------------------------------------------*\
-    | For this command, error is if the output equals the   |
-    | input                                                 |
-    \*-----------------------------------------------------*/
-    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
+    return(result);
 }
 
 bool AlienwareController::Reset()
@@ -640,6 +702,15 @@ void AlienwareController::SetDim(uint8_t zone, uint8_t dim)
     }
 }
 
+void AlienwareController::SetDirection(uint8_t zone, uint8_t direction)
+{
+    if(zone < zones.size())
+    {
+        zones[zone].direction   = direction;
+        dirty                   = true;
+    }
+}
+
 void AlienwareController::UpdateDim()
 {
     if(!dirty_dim)
@@ -655,7 +726,8 @@ void AlienwareController::UpdateDim()
 
     for(size_t i = 0; i < zones.size(); i++)
     {
-        dim_zone_map[zones[i].dim].emplace_back((uint8_t)i);
+        uint8_t hw_zone = (i < zone_ids.size()) ? zone_ids[i] : static_cast<uint8_t>(i);
+        dim_zone_map[zones[i].dim].emplace_back(hw_zone);
     }
 
     for(std::pair<const uint8_t, std::vector<uint8_t>> &pair : dim_zone_map)
@@ -682,7 +754,8 @@ bool AlienwareController::UpdateDirect()
 
     for(size_t i = 0; i < zones.size(); i++)
     {
-        color_zone_map[zones[i].color[0]].emplace_back((uint8_t)i);
+        uint8_t hw_zone = (i < zone_ids.size()) ? zone_ids[i] : static_cast<uint8_t>(i);
+        color_zone_map[zones[i].color[0]].emplace_back(hw_zone);
     }
 
     for(std::pair<const RGBColor, std::vector<uint8_t>> &pair : color_zone_map)
@@ -726,8 +799,9 @@ void AlienwareController::UpdateMode()
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
         alienware_zone zone = zones[zone_idx];
+        uint8_t hw_zone = (zone_idx < zone_ids.size()) ? zone_ids[zone_idx] : static_cast<uint8_t>(zone_idx);
 
-        result = SelectZones({static_cast<uint8_t>(zone_idx)});
+        result = SelectZones({hw_zone});
 
         if(!result)
         {
@@ -750,18 +824,18 @@ void AlienwareController::UpdateMode()
 
             case ALIENWARE_MODE_MORPH:
                 {
-                    uint8_t  zones[2]   = { zone.mode,              zone.mode     };
+                    uint8_t  modes[2]   = { zone.mode,              zone.mode     };
                     uint16_t periods[2] = { zone.period,            zone.period   };
                     uint16_t tempos[2]  = { zone.tempo,             zone.tempo    };
                     RGBColor colors[2]  = { zone.color[0],          zone.color[1] };
 
-                    result = MultiModeAction(zones, periods, tempos, colors, 2);
+                    result = MultiModeAction(modes, periods, tempos, colors, 2);
                 }
                 break;
 
             case ALIENWARE_MODE_SPECTRUM:
                 {
-                    uint8_t  zones[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH };
@@ -774,13 +848,13 @@ void AlienwareController::UpdateMode()
                                             zone.tempo,             zone.tempo,
                                             zone.tempo };
 
-                    result = MultiModeAction(zones, periods, tempos, rainbow_colors[0], 7);
+                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[0], 7);
                 }
                 break;
 
             case ALIENWARE_MODE_RAINBOW:
                 {
-                    uint8_t  zones[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH };
@@ -793,18 +867,19 @@ void AlienwareController::UpdateMode()
                                             zone.tempo,             zone.tempo,
                                             zone.tempo };
 
-                    result = MultiModeAction(zones, periods, tempos, rainbow_colors[zone_idx], 7);
+                    unsigned int color_idx = (zone.direction == MODE_DIRECTION_LEFT) ? (4 - 1 - (zone_idx % 4)) : (zone_idx % 4);
+                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[color_idx], 7);
                 }
                 break;
 
             case ALIENWARE_MODE_BREATHING:
                 {
-                    uint8_t  zones[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
+                    uint8_t  modes[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
                     uint16_t periods[2] = { zone.period,            zone.period          };
                     uint16_t tempos[2]  = { zone.tempo,             zone.tempo           };
                     RGBColor colors[2]  = { zone.color[0],          0x0                  };
 
-                    result = MultiModeAction(zones, periods, tempos, colors, 2);
+                    result = MultiModeAction(modes, periods, tempos, colors, 2);
                 }
                 break;
 
@@ -831,6 +906,117 @@ void AlienwareController::UpdateMode()
     dirty = false;
 }
 
+void AlienwareController::SaveController()
+{
+    /*-----------------------------------------------------*\
+    | Save current mode configuration to EEPROM slot 0x0061 |
+    \*-----------------------------------------------------*/
+    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_REMOVE, ALIENWARE_ANIM_DEFAULT, 0);
+    bool result = UserAnimation(ALIENWARE_COMMAND_USER_ANIM_NEW, ALIENWARE_ANIM_DEFAULT, 0);
+
+    if(!result)
+    {
+        return;
+    }
+
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        alienware_zone zone = zones[zone_idx];
+        uint8_t hw_zone = (zone_idx < zone_ids.size()) ? zone_ids[zone_idx] : static_cast<uint8_t>(zone_idx);
+
+        result = SelectZones({hw_zone});
+
+        if(!result)
+        {
+            return;
+        }
+
+        switch (zone.mode)
+        {
+            case ALIENWARE_MODE_COLOR:
+                result = ModeAction(zone.mode, 2000, ALIENWARE_TEMPO_MAX, zone.color[0]);
+                break;
+
+            case ALIENWARE_MODE_PULSE:
+                result = ModeAction(zone.mode, zone.period, zone.tempo, zone.color[0]);
+                break;
+
+            case ALIENWARE_MODE_MORPH:
+                {
+                    uint8_t  modes[2]   = { zone.mode,              zone.mode     };
+                    uint16_t periods[2] = { zone.period,            zone.period   };
+                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo    };
+                    RGBColor colors[2]  = { zone.color[0],          zone.color[1] };
+
+                    result = MultiModeAction(modes, periods, tempos, colors, 2);
+                }
+                break;
+
+            case ALIENWARE_MODE_SPECTRUM:
+                {
+                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH };
+                    uint16_t periods[7] = { zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period };
+                    uint16_t tempos[7] = {  zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo };
+
+                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[0], 7);
+                }
+                break;
+
+            case ALIENWARE_MODE_RAINBOW:
+                {
+                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH };
+                    uint16_t periods[7] = { zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period };
+                    uint16_t tempos[7]  = { zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo };
+
+                    unsigned int color_idx = (zone.direction == MODE_DIRECTION_LEFT) ? (4 - 1 - (zone_idx % 4)) : (zone_idx % 4);
+                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[color_idx], 7);
+                }
+                break;
+
+            case ALIENWARE_MODE_BREATHING:
+                {
+                    uint8_t  modes[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
+                    uint16_t periods[2] = { zone.period,            zone.period          };
+                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo           };
+                    RGBColor colors[2]  = { zone.color[0],          0x0                  };
+
+                    result = MultiModeAction(modes, periods, tempos, colors, 2);
+                }
+                break;
+
+            default:
+                result = false;
+        }
+
+        if(!result)
+        {
+            return;
+        }
+    }
+
+    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE, ALIENWARE_ANIM_DEFAULT, 0);
+    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_DEFAULT, ALIENWARE_ANIM_DEFAULT, 0);
+    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_STARTUP, ALIENWARE_ANIM_DEFAULT, 0);
+}
+
 void AlienwareController::UpdateController()
 {
     UpdateMode();

Controllers/AlienwareController/AlienwareController.h

@@ -22,6 +22,14 @@
 #define ALIENWARE_REPORT_SIZE               33
 #define HIDAPI_ALIENWARE_REPORT_SIZE        (ALIENWARE_REPORT_SIZE + 1)
 #define ALIENWARE_CONTROLLER_NAME           "AlienWare Controller"
+
+/*---------------------------------------------------------*\
+| Max zone IDs that fit in one report after the command     |
+| header.  Selections larger than this must be split across |
+| multiple packets; writing them into a single report       |
+| overflows usb_buf (e.g. desktops with ~100 zones).        |
+\*---------------------------------------------------------*/
+#define ALIENWARE_MAX_ZONES_PER_PACKET      25
 enum
 {
     ALIENWARE_COMMAND_REPORT                = 0x20,     /* Set report type to get               */
@@ -115,11 +123,13 @@ public:
     void                        SetPeriod(uint8_t zone, uint16_t period);
     void                        SetTempo(uint8_t zone, uint16_t tempo);
     void                        SetDim(uint8_t zone, uint8_t dim);
+    void                        SetDirection(uint8_t zone, uint8_t direction);
     AlienwareReport             GetStatus(uint8_t subcommand);
 
     void                        UpdateDim();
     void                        UpdateMode();
     void                        UpdateController();
+    void                        SaveController();
 
 protected:
     hid_device* dev;
@@ -132,6 +142,7 @@ private:
         uint16_t                period;
         uint16_t                tempo;
         uint8_t                 dim;
+        uint8_t                 direction;
     } alienware_zone;
 
     typedef struct
@@ -145,6 +156,7 @@ private:
     std::string                 serial_number;
     std::string                 version;
     std::vector<const char*>    zone_names;
+    std::vector<uint8_t>        zone_ids;
     bool                        dirty;
     bool                        dirty_dim;
 

Controllers/AlienwareController/RGBController_Alienware.cpp

@@ -39,7 +39,7 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Color;
     Color.name                 = "Static";
     Color.value                = ALIENWARE_MODE_COLOR;
-    Color.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Color.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
     Color.color_mode           = MODE_COLORS_PER_LED;
     Color.colors_min           = 1;
     Color.colors_max           = 1;
@@ -51,13 +51,13 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Pulse;
     Pulse.name                 = "Flashing";
     Pulse.value                = ALIENWARE_MODE_PULSE;
-    Pulse.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Pulse.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
     Pulse.color_mode           = MODE_COLORS_PER_LED;
     Pulse.colors_min           = 1;
     Pulse.colors_max           = 1;
-    Pulse.speed_min            = ALIENWARE_TEMPO_MIN;
-    Pulse.speed_max            = ALIENWARE_TEMPO_MAX;
-    Pulse.speed                = ALIENWARE_TEMPO_MIN;
+    Pulse.speed_min            = ALIENWARE_TEMPO_MAX;
+    Pulse.speed_max            = 50;
+    Pulse.speed                = 150;
     Pulse.brightness_min       = 100;
     Pulse.brightness_max       = 0;
     Pulse.brightness           = 0;
@@ -66,14 +66,16 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Morph;
     Morph.name                 = "Morph";
     Morph.value                = ALIENWARE_MODE_MORPH;
-    Morph.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Morph.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
     Morph.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Morph.colors_min           = 2 * controller->GetZoneCount();
-    Morph.colors_max           = Morph.colors_min;
-    Morph.colors.resize(Morph.colors_max);
-    Morph.speed_min            = ALIENWARE_TEMPO_MIN;
-    Morph.speed_max            = ALIENWARE_TEMPO_MAX;
-    Morph.speed                = ALIENWARE_TEMPO_MIN;
+    Morph.colors_min           = 2;
+    Morph.colors_max           = 2 * controller->GetZoneCount();
+    Morph.colors.resize(2);
+    Morph.colors[0]            = 0x0000FF;
+    Morph.colors[1]            = 0xFF0000;
+    Morph.speed_min            = ALIENWARE_TEMPO_MAX;
+    Morph.speed_max            = 20;
+    Morph.speed                = 100;
     Morph.brightness_min       = 100;
     Morph.brightness_max       = 0;
     Morph.brightness           = 0;
@@ -82,11 +84,11 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Spectrum;
     Spectrum.name              = "Spectrum Cycle";
     Spectrum.value             = ALIENWARE_MODE_SPECTRUM;
-    Spectrum.flags             = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Spectrum.flags             = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
     Spectrum.color_mode        = MODE_COLORS_NONE;
-    Spectrum.speed_min         = ALIENWARE_TEMPO_SPECTRUM;
-    Spectrum.speed_max         = ALIENWARE_TEMPO_MAX;
-    Spectrum.speed             = ALIENWARE_TEMPO_SPECTRUM;
+    Spectrum.speed_min         = ALIENWARE_TEMPO_MAX;
+    Spectrum.speed_max         = ALIENWARE_TEMPO_SPECTRUM;
+    Spectrum.speed             = 40;
     Spectrum.brightness_min    = 100;
     Spectrum.brightness_max    = 0;
     Spectrum.brightness        = 0;
@@ -95,11 +97,12 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Rainbow;
     Rainbow.name               = "Rainbow Wave";
     Rainbow.value              = ALIENWARE_MODE_RAINBOW;
-    Rainbow.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Rainbow.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
     Rainbow.color_mode         = MODE_COLORS_NONE;
-    Rainbow.speed_min          = ALIENWARE_TEMPO_SPECTRUM;
-    Rainbow.speed_max          = ALIENWARE_TEMPO_MAX;
-    Rainbow.speed              = ALIENWARE_TEMPO_SPECTRUM;
+    Rainbow.speed_min          = ALIENWARE_TEMPO_MAX;
+    Rainbow.speed_max          = ALIENWARE_TEMPO_SPECTRUM;
+    Rainbow.speed              = 40;
+    Rainbow.direction          = MODE_DIRECTION_RIGHT;
     Rainbow.brightness_min     = 100;
     Rainbow.brightness_max     = 0;
     Rainbow.brightness         = 0;
@@ -108,13 +111,13 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Breathing;
     Breathing.name             = "Breathing";
     Breathing.value            = ALIENWARE_MODE_BREATHING;
-    Breathing.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Breathing.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
     Breathing.color_mode       = MODE_COLORS_PER_LED;
     Breathing.colors_min       = 1;
     Breathing.colors_max       = 1;
-    Breathing.speed_min        = ALIENWARE_TEMPO_MIN;
-    Breathing.speed_max        = ALIENWARE_TEMPO_MAX;
-    Breathing.speed            = ALIENWARE_TEMPO_MIN;
+    Breathing.speed_min        = ALIENWARE_TEMPO_MAX;
+    Breathing.speed_max        = 50;
+    Breathing.speed            = 150;
     Breathing.brightness_min   = 100;
     Breathing.brightness_max   = 0;
     Breathing.brightness       = 0;
@@ -224,6 +227,7 @@ void RGBController_Alienware::DeviceUpdateMode()
             uint16_t period = 0x07d0;
 
             controller->SetMode(zone_idx, current_mode.value);
+            controller->SetDirection(zone_idx, current_mode.direction);
 
             switch(current_mode_idx)
             {
@@ -235,6 +239,7 @@ void RGBController_Alienware::DeviceUpdateMode()
                     break;
 
                 case ALIENWARE_MODE_PULSE:
+                    period = std::max<uint16_t>(500, (uint16_t)(current_mode.speed * 10));
                     controller->SetPeriod(zone_idx, period);
                     controller->SetColor( zone_idx, colors[current_zone.start_idx]);
                     controller->SetTempo( zone_idx, current_mode.speed);
@@ -242,10 +247,22 @@ void RGBController_Alienware::DeviceUpdateMode()
                     break;
 
                 case ALIENWARE_MODE_MORPH:
-                    controller->SetPeriod(zone_idx, period);
-                    controller->SetColor( zone_idx, current_mode.colors[zone_idx * 2], current_mode.colors[(zone_idx * 2) + 1]);
-                    controller->SetTempo( zone_idx, current_mode.speed);
-                    controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    {
+                        RGBColor c1 = (current_mode.colors.size() >= 1) ? current_mode.colors[0] : 0x0000FF;
+                        RGBColor c2 = (current_mode.colors.size() >= 2) ? current_mode.colors[1] : 0xFF0000;
+
+                        if(current_mode.colors.size() >= (std::size_t)((zone_idx + 1) * 2))
+                        {
+                            c1 = current_mode.colors[zone_idx * 2];
+                            c2 = current_mode.colors[(zone_idx * 2) + 1];
+                        }
+
+                        period = std::max<uint16_t>(400, (uint16_t)(current_mode.speed * 10));
+                        controller->SetPeriod(zone_idx, period);
+                        controller->SetColor( zone_idx, c1, c2);
+                        controller->SetTempo( zone_idx, current_mode.speed);
+                        controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    }
                     break;
 
                 case ALIENWARE_MODE_SPECTRUM:
@@ -256,6 +273,7 @@ void RGBController_Alienware::DeviceUpdateMode()
                     break;
 
                 case ALIENWARE_MODE_BREATHING:
+                    period = std::max<uint16_t>(500, (uint16_t)(current_mode.speed * 10));
                     controller->SetPeriod(zone_idx, period);
                     controller->SetColor( zone_idx, colors[current_zone.start_idx], 0x0);
                     controller->SetTempo( zone_idx, current_mode.speed);
@@ -282,3 +300,9 @@ void RGBController_Alienware::DeviceUpdateMode()
         current_mode              = new_current_mode;
     }
 }
+
+void RGBController_Alienware::DeviceSaveMode()
+{
+    controller->SaveController();
+}
+

Controllers/AlienwareController/RGBController_Alienware.h

@@ -28,6 +28,7 @@ public:
     void        DeviceUpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
     AlienwareController*                    controller;

Controllers/AlienwareMonitorController/AlienwareAW3423DWFController/AlienwareAW3423DWFController.cpp

@@ -40,11 +40,11 @@ std::vector<unsigned char> AlienwareAW3423DWFController::GetReportResponse()
 
 void AlienwareAW3423DWFController::PerformLogin()
 {
-    unsigned char init_packet[64] =
-    {
-        0x40, 0xE1, 0x01
-    };
-    SendControlPacket(init_packet, 4);
+    unsigned char init_packet[192] = {0x00};
+    init_packet[0] = 0x40;
+    init_packet[1] = 0xE1;
+    init_packet[2] = 0x01;
+    SendControlPacket(init_packet, 192);
 
     std::vector<unsigned char> response = GetReportResponse();
 

Controllers/AlienwareMonitorController/AlienwareAW3423DWFController/AlienwareAW3423DWFControllerDetect.cpp

@@ -0,0 +1,47 @@
+/*---------------------------------------------------------*\
+| AlienwareAW3423DWFControllerDetect.cpp                    |
+|                                                           |
+|   Detector for Alienware AW3423DWF monitor                |
+|                                                           |
+|   Ferréol DUBOIS COLI (Fefe_du_973)           23 Jan 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "AlienwareAW3423DWFController.h"
+#include "DetectionManager.h"
+#include "RGBController_AlienwareAW3423DWF.h"
+
+/*---------------------------------------------------------*\
+| Alienware Vendor ID                                       |
+\*---------------------------------------------------------*/
+#define ALIENWARE_VID                               0x187C
+
+/*---------------------------------------------------------*\
+| Alienware Vendor ID                                       |
+\*---------------------------------------------------------*/
+#define ALIENWARE_AW3423DWF_PID                     0x100E
+#define ALIENWARE_USAGE_PAGE                        0xFFDA
+#define ALIENWARE_USAGE                             0x00DA
+
+DetectedControllers DetectAlienwareAW3423DWFControllers(hid_device_info* info, const std::string&)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AlienwareAW3423DWFController*     controller     = new AlienwareAW3423DWFController(dev, info->path);
+        RGBController_AlienwareAW3423DWF* rgb_controller = new RGBController_AlienwareAW3423DWF(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR("Alienware AW3423DWF", DetectAlienwareAW3423DWFControllers, ALIENWARE_VID, ALIENWARE_AW3423DWF_PID);

Controllers/AlienwareMonitorController/AlienwareMonitorController/AlienwareMonitorControllerDetect.cpp

@@ -10,10 +10,8 @@
 \*---------------------------------------------------------*/
 
 #include <hidapi.h>
-#include "AlienwareAW3423DWFController.h"
 #include "AlienwareMonitorController.h"
 #include "DetectionManager.h"
-#include "RGBController_AlienwareAW3423DWF.h"
 #include "RGBController_AlienwareMonitor.h"
 
 /*---------------------------------------------------------*\
@@ -24,29 +22,10 @@
 /*---------------------------------------------------------*\
 | Alienware Vendor ID                                       |
 \*---------------------------------------------------------*/
-#define ALIENWARE_AW3423DWF_PID                     0x100E
 #define ALIENWARE_AW3225QF_PID                      0x1013
 #define ALIENWARE_USAGE_PAGE                        0xFFDA
 #define ALIENWARE_USAGE                             0x00DA
 
-DetectedControllers DetectAlienwareAW3423DWFControllers(hid_device_info* info, const std::string&)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AlienwareAW3423DWFController*     controller     = new AlienwareAW3423DWFController(dev, info->path);
-        RGBController_AlienwareAW3423DWF* rgb_controller = new RGBController_AlienwareAW3423DWF(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
-
 DetectedControllers DetectAlienwareMonitorControllers(hid_device_info* info, const std::string& name)
 {
     DetectedControllers detected_controllers;
@@ -65,5 +44,4 @@ DetectedControllers DetectAlienwareMonitorControllers(hid_device_info* info, con
     return(detected_controllers);
 }
 
-REGISTER_HID_DETECTOR("Alienware AW3423DWF", DetectAlienwareAW3423DWFControllers, ALIENWARE_VID, ALIENWARE_AW3423DWF_PID);
 REGISTER_HID_DETECTOR("Alienware AW3225QF", DetectAlienwareMonitorControllers, ALIENWARE_VID, ALIENWARE_AW3225QF_PID);

Controllers/ArcticController/ArcticControllerDetect.cpp

@@ -44,8 +44,4 @@ DetectedControllers DetectArcticControllers()
 }
 
 REGISTER_DETECTOR("Arctic RGB controller", DetectArcticControllers);
-/*---------------------------------------------------------------------------------------------------------*\
-| Entries for dynamic UDEV rules                                                                            |
-|                                                                                                           |
-| DUMMY_DEVICE_DETECTOR("Arctic RGB controller", DetectArcticControllers, 0x1A86, 0x7523 )                  |
-\*---------------------------------------------------------------------------------------------------------*/
+REGISTER_CUSTOM_UDEV_RULE(arctic, "Arctic RGB controller", "SUBSYSTEMS==\"serial|hidraw\", ATTRS{idVendor}==\"1a86\", ATTRS{idProduct}==\"7523\", TAG+=\"uaccess\", TAG+=\"Arctic_RGB_controller\"");

Controllers/AsusAuraCoreController/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

@@ -4,18 +4,15 @@
 |   Detector for ASUS ROG Aura Core                         |
 |                                                           |
 |   Adam Honse (CalcProgrammer1)                13 Apr 2020 |
-|   Chris M (Dr_No)                             28 Jul 2022 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
-#include "AsusAuraCoreController.h"
-#include "RGBController.h"
-#include "RGBController_AsusAuraCore.h"
-#include "RGBController_AsusAuraCoreLaptop.h"
 #include <hidapi.h>
+#include "AsusAuraCoreController.h"
+#include "DetectionManager.h"
+#include "RGBController_AsusAuraCore.h"
 
 #define AURA_CORE_VID                   0x0B05
 
@@ -44,27 +41,6 @@ DetectedControllers DetectAsusAuraCoreControllers(hid_device_info* info, const s
     return(detected_controllers);
 }
 
-DetectedControllers DetectAsusAuraCoreLaptopControllers(hid_device_info* info, const std::string& /*name*/)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AsusAuraCoreLaptopController*     controller        = new AsusAuraCoreLaptopController(dev, info->path);
-        RGBController_AsusAuraCoreLaptop* rgb_controller    = new RGBController_AsusAuraCoreLaptop(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
-
-
 REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1854);
 REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1866);
 REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1869);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 15",      DetectAsusAuraCoreLaptopControllers,    AURA_CORE_VID, AURA_STRIX_SCAR_15_PID,  0xFF31, 0x79);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 17",      DetectAsusAuraCoreLaptopControllers,    AURA_CORE_VID, 0x1866,                  0xFF31, 0x79);

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopControllerDetect.cpp

@@ -0,0 +1,38 @@
+/*---------------------------------------------------------*\
+| AsusAuraCoreLaptopControllerDetect.cpp                    |
+|                                                           |
+|   Detector for ASUS ROG Aura Core Laptop                  |
+|                                                           |
+|   Chris M (Dr_No)                             28 Jul 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "AsusAuraCoreLaptopController.h"
+#include "DetectionManager.h"
+#include "RGBController_AsusAuraCoreLaptop.h"
+
+#define AURA_CORE_VID                   0x0B05
+
+DetectedControllers DetectAsusAuraCoreLaptopControllers(hid_device_info* info, const std::string& /*name*/)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AsusAuraCoreLaptopController*     controller        = new AsusAuraCoreLaptopController(dev, info->path);
+        RGBController_AsusAuraCoreLaptop* rgb_controller    = new RGBController_AsusAuraCoreLaptop(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 15",      DetectAsusAuraCoreLaptopControllers,    AURA_CORE_VID, AURA_STRIX_SCAR_15_PID,  0xFF31, 0x79);
+REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 17",      DetectAsusAuraCoreLaptopControllers,    AURA_CORE_VID, 0x1866,                  0xFF31, 0x79);

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopDevices.cpp

@@ -940,6 +940,25 @@ static const aura_core_laptop_device g814jv_device =
     }
 };
 
+/*-------------------------------------------------------------*\
+|  ASUS ROG Strix G18 (G814JIR)                                 |
+|                                                               |
+|  G814JIR uses the same Aura Core keyboard and lightbar        |
+|  layout as the G814JV G18 profile.                            |
+\*-------------------------------------------------------------*/
+static const aura_core_laptop_device g814jir_device =
+{
+    "G814JIR",
+    {
+        &g814rw_keyboard_zone,
+        &g814jv_lightbar_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    }
+};
+
 /*-------------------------------------------------------------------------*\
 |  DEVICE MASTER LIST                                                       |
 \*-------------------------------------------------------------------------*/
@@ -954,6 +973,7 @@ const aura_core_laptop_device* aura_core_laptop_device_list_data[] =
     &g713rw_device,
     &g733qr_device,
     &g814jv_device,
+    &g814jir_device,
 };
 
 const unsigned int AURA_CORE_LAPTOP_DEVICE_COUNT = (sizeof(aura_core_laptop_device_list_data) / sizeof(aura_core_laptop_device_list_data[ 0 ]));

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -428,7 +428,6 @@ void RGBController_AuraTUFKeyboard::SetupZones()
             break;
         case AURA_TUF_K3_GAMING_PID:
         case AURA_TUF_K7_GAMING_PID:
-        case AURA_TUF_K3_GENII_MIKU_EDITION_PID:
             keyboard_ptr = &AsusTUFK7Layouts;
             break;
         case AURA_ROG_STRIX_SCOPE_PID:
@@ -485,6 +484,7 @@ void RGBController_AuraTUFKeyboard::SetupZones()
             keyboard_ptr = &AsusTufK1Layouts;
             break;
         case AURA_TUF_K3_GAMING_GEN_II_PID:
+        case AURA_TUF_K3_GENII_MIKU_EDITION_PID:
             keyboard_ptr = &AsusTUFK3GamingGen2Layouts;
             break;
         default:

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -417,7 +417,7 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",                       DetectAs
 REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",                       DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_4_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_1_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_2_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_3_PID);
+REGISTER_HID_DETECTOR_PU("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_3_PID,                           0xFF72, 0x00A1);
 REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_4_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_5_PID);
 

Controllers/AsusMonitorController/AsusMonitorControllerDetect.cpp

@@ -22,8 +22,12 @@
 | Product ID                                                |
 \*---------------------------------------------------------*/
 #define ASUS_ROG_STRIX_XG27AQDMG_PID                   0x1BA3
-#define ASUS_ROG_SWIFT_XG27UCG_PID                     0x1BB4
+#define ASUS_ROG_STRIX_XG27ACDNG_PID                   0x1BC9
+#define ASUS_ROG_STRIX_XG27UCG_PID                     0x1BB4
 #define ASUS_ROG_SWIFT_PG32UCDM_PID                    0x1B2B
+#define ASUS_ROG_SWIFT_PG32UCDMR_PID                   0x1C9B
+#define ASUS_ROG_SWIFT_PG32UCDP_PID                    0x1BCA
+#define ASUS_ROG_AURA_MONITOR_LIGHT_BAR_PID            0x1AC8
 
 DetectedControllers DetectAsusMonitorControllers(hid_device_info* info, const std::string& name)
 {
@@ -44,5 +48,13 @@ DetectedControllers DetectAsusMonitorControllers(hid_device_info* info, const st
 }
 
 REGISTER_HID_DETECTOR_IPU("Asus ROG STRIX XG27AQDMG",   DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_STRIX_XG27AQDMG_PID,   1, 0xFF72, 0x00A1);
-REGISTER_HID_DETECTOR_IPU("Asus ROG STRIX XG27UCG",     DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_SWIFT_XG27UCG_PID,     1, 0xFF72, 0x00A1);
-REGISTER_HID_DETECTOR_IPU("Asus ROG STRIX PG32UCDM",    DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_SWIFT_PG32UCDM_PID,    1, 0xFF72, 0x00A1);
+REGISTER_HID_DETECTOR_IPU("Asus ROG STRIX XG27ACDNG",   DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_STRIX_XG27ACDNG_PID,   1, 0xFF72, 0x00A1);
+REGISTER_HID_DETECTOR_IPU("Asus ROG STRIX XG27UCG",     DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_STRIX_XG27UCG_PID,     1, 0xFF72, 0x00A1);
+REGISTER_HID_DETECTOR_IPU("Asus ROG SWIFT PG32UCDM",    DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_SWIFT_PG32UCDM_PID,    1, 0xFF72, 0x00A1);
+REGISTER_HID_DETECTOR_IPU("Asus ROG SWIFT PG32UCDMR",   DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_SWIFT_PG32UCDMR_PID,   1, 0xFF72, 0x00A1);
+REGISTER_HID_DETECTOR_IPU("Asus ROG SWIFT PG32UCDP",    DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_SWIFT_PG32UCDP_PID,    1, 0xFF72, 0x00A1);
+/*---------------------------------------------------------*\
+| ALB01 exposes the Aura HID collection on interface 2.     |
+\*---------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Asus ROG Aura Monitor Light Bar", DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_AURA_MONITOR_LIGHT_BAR_PID, 2, 0xFF72, 0x00A1);
+

Controllers/AsusTUFLaptopController/AsusTUFLaptopDetect_Linux.cpp

@@ -36,3 +36,5 @@ DetectedControllers DetectAsusTUFLaptopLinuxControllers()
 }
 
 REGISTER_DETECTOR("ASUS TUF Laptop", DetectAsusTUFLaptopLinuxControllers);
+
+REGISTER_CUSTOM_UDEV_RULE(asus_wmi, "ASUS TUF Laptops (asus-wmi)", "ACTION==\"add\", SUBSYSTEM==\"leds\", KERNEL==\"asus::kbd_backlight\", RUN+=\"/usr/bin/env chmod a+w /sys%p/kbd_rgb_mode\"\nACTION==\"add\", SUBSYSTEM==\"leds\", KERNEL==\"asus::kbd_backlight\", RUN+=\"/usr/bin/env chmod a+w /sys%p/brightness\"");

Controllers/BlinkyTapeController/BlinkyTapeControllerDetect.cpp

@@ -40,8 +40,4 @@ DetectedControllers DetectBlinkyTapeControllers()
 }
 
 REGISTER_DETECTOR("BlinkyTape", DetectBlinkyTapeControllers);
-/*---------------------------------------------------------------------------------------------------------*\
-| Entries for dynamic UDEV rules                                                                            |
-|                                                                                                           |
-| DUMMY_DEVICE_DETECTOR("BlinkyTape", DetectBlinkyTapeControllers, 0x1D50, 0x605E )                         |
-\*---------------------------------------------------------------------------------------------------------*/
+REGISTER_CUSTOM_UDEV_RULE(blinky_tape, "BlinkyTape", "SUBSYSTEMS==\"serial|hidraw\", ATTRS{idVendor}==\"1d50\", ATTRS{idProduct}==\"605e\", TAG+=\"uaccess\", TAG+=\"BlinkyTape\"");

Controllers/ClevoKeyboardController/ClevoKeyboardController.cpp

@@ -335,7 +335,7 @@ void ClevoKeyboardController::SetEffect829x(unsigned char mode_value, const std:
     {
         for(size_t i = 0; i < colors.size() && i < 2; i++)
         {
-            SendColorSlot829x(CLEVO_829X_CMD_SCAN_COLOR, CLEVO_829X_COLOR_SLOT_BASE + i, colors[i]);
+            SendColorSlot829x(CLEVO_829X_CMD_SCAN_COLOR, CLEVO_829X_COLOR_SLOT_BASE + (unsigned char)i, colors[i]);
         }
     }
 

Controllers/ClevoKeyboardController/ClevoKeyboardDevices.cpp

@@ -18,71 +18,79 @@
 |                                                           |
 | Based on KEYBOARD_SIZE_TKL with numpad added and          |
 | navigation cluster adjusted to match Clevo's layout.      |
-|                                                           |
-| Hardware LED indices (value field):                       |
-| - Row 5 (F-keys):     105-124                             |
-| - Row 4 (numbers):    84-102                              |
-| - Row 3 (QWERTY):     63-81                               |
-| - Row 2 (home):       42-59                               |
-| - Row 1 (Z row):      22-39                               |
-| - Row 0 (modifiers):  0-18                                |
 \*---------------------------------------------------------*/
 
 /*---------------------------------------------------------*\
-| LED values in TKL order (fn_row + main + extras)          |
+| LED values, in physical (row, then column) order.         |
+|                                                           |
+| This must match the order KeyboardLayoutManager assigns   |
+| default_values against: the structural keymap sorted by   |
+| (row, col) across main+fn_row+extras combined, NOT the    |
+| fn_row-then-main-then-extras order the zone tables below  |
+| are declared in. Getting this wrong silently misassigns   |
+| almost every key from Print Screen onward, not just a few.|
 |                                                           |
-| Values follow the key order in KeyboardLayoutManager.cpp. |
 | For ANSI-only keys (not present on this ISO keyboard),    |
 | use 0 as a placeholder - they won't be displayed.         |
 | Numpad values are added via edit_keys.                    |
 \*---------------------------------------------------------*/
 static const std::vector<unsigned int> clevo_tkl_values =
 {
-    /*---------------------------------------------------------*\
-    | Function row (keyboard_zone_fn_row)                       |
-    \*---------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Row 0: fn_row + Print Screen/Scroll Lock/Pause        |
+    \*-----------------------------------------------------*/
     105,                                                        // Escape
     106, 107, 108, 109,                                         // F1-F4
     110, 111, 112, 113,                                         // F5-F8
     114, 115, 116, 117,                                         // F9-F12
+    118,                                                        // Print Screen
+    0,                                                          // Scroll Lock (removed via edit_keys)
+    0,                                                          // Pause (removed via edit_keys)
 
-    /*---------------------------------------------------------*\
-    | Main block - Row 1 (keyboard_zone_main)                   |
-    \*---------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Row 1: numbers row + Insert/Home/Page Up              |
+    \*-----------------------------------------------------*/
     84,                                                         // Back tick
     85, 86, 87, 88, 89, 90, 91, 92, 93, 94,                     // 1-0
     95, 96,                                                     // Minus, Equals
     98,                                                         // Backspace
+    119,                                                        // Insert
+    121,                                                        // Home
+    122,                                                        // Page Up
 
-    /*---------------------------------------------------------*\
-    | Main block - Row 2                                        |
-    \*---------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Row 2: Tab/QWERTY row + Delete/End/PageDown           |
+    \*-----------------------------------------------------*/
     63,                                                         // Tab
     65, 66, 67, 68, 69, 70, 71, 72, 73, 74,                     // Q-P
     75, 76,                                                     // [ ]
     0,                                                          // ANSI backslash (not on ISO)
+    120,                                                        // Delete
+    124,                                                        // End
+    123,                                                        // Page Down
 
-    /*---------------------------------------------------------*\
-    | Main block - Row 3                                        |
-    \*---------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Row 3: Caps Lock/home row/Enter                       |
+    \*-----------------------------------------------------*/
     42,                                                         // Caps Lock
     44, 45, 46, 47, 48, 49, 50, 51, 52,                         // A-L
     53, 54,                                                     // ; '
     55,                                                         // ISO # (POUND)
-    77,                                                         // Enter (ANSI/ISO share same LED)
+    56,                                                         // Enter
 
-    /*---------------------------------------------------------*\
-    | Main block - Row 4                                        |
-    \*---------------------------------------------------------*/
-    22,                                                         // Left Shift
-    23,                                                         // ISO backslash
+    /*-----------------------------------------------------*\
+    | Row 4: Left Shift/ISO backslash/Z row + Up            |
+    \*-----------------------------------------------------*/
+    21,                                                         // Left Shift
+    77,                                                         // ISO backslash
     24, 25, 26, 27, 28, 29, 30, 31, 32,                         // Z-. (9 keys)
     33,                                                         // /
     35,                                                         // Right Shift
+    14,                                                         // Up
 
-    /*---------------------------------------------------------*\
-    | Main block - Row 5                                        |
-    \*---------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Row 5: bottom modifier row + Left/Down/Right          |
+    \*-----------------------------------------------------*/
     0,                                                          // Left Ctrl
     3,                                                          // Left Win
     4,                                                          // Left Alt
@@ -91,24 +99,6 @@ static const std::vector<unsigned int> clevo_tkl_values =
     0,                                                          // Right Fn (removed via edit_keys)
     0,                                                          // Menu (removed via edit_keys)
     12,                                                         // Right Ctrl
-
-    /*---------------------------------------------------------*\
-    | Extras - Navigation cluster (keyboard_zone_extras)        |
-    \*---------------------------------------------------------*/
-    118,                                                        // Print Screen
-    0,                                                          // Scroll Lock (removed via edit_keys)
-    0,                                                          // Pause (removed via edit_keys)
-    119,                                                        // Insert
-    121,                                                        // Home
-    123,                                                        // Page Up
-    120,                                                        // Delete
-    122,                                                        // End
-    124,                                                        // Page Down
-
-    /*---------------------------------------------------------*\
-    | Extras - Arrow keys                                       |
-    \*---------------------------------------------------------*/
-    14,                                                         // Up
     13,                                                         // Left
     18,                                                         // Down
     15,                                                         // Right

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -1,4 +1,4 @@
-/*---------------------------------------------------------*\
+/*---------------------------------------------------------*\
 | ColorfulGPUControllerDetect.cpp                           |
 |                                                           |
 |   Detector for Colorful GPU                               |
@@ -51,6 +51,7 @@ DetectedControllers DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Advanced OC 12G L-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ADVANCED_OC_12G_LV,     0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_GA106_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_GA106_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,        0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,        0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,        0x61);

Controllers/CoolerMasterController/CMSmallARGBController/CMSmallARGBController.cpp

@@ -13,11 +13,6 @@
 #include "CMSmallARGBController.h"
 #include "StringUtils.h"
 
-cm_small_argb_headers cm_small_argb_header_data[1] =
-{
-    { "CM Small ARGB",  0x01, true,  12 }
-};
-
 CMSmallARGBController::CMSmallARGBController(hid_device* dev_handle, char *_path)
 {
     dev                     = dev_handle;
@@ -92,6 +87,24 @@ std::string CMSmallARGBController::GetSerial()
     return(StringUtils::wstring_to_string(serial_string));
 }
 
+std::string CMSmallARGBController::GetVersion()
+{
+    /*-----------------------------------------------------*\
+    | This device uses the serial value to determine the    |
+    | version.  It does not report a proper unique serial.  |
+    \*-----------------------------------------------------*/
+    std::string serial_string = GetSerial();
+
+    if(serial_string == CM_SMALL_ARGB_FW0012)
+    {
+        return("0012");
+    }
+    else
+    {
+        return("Unsupported");
+    }
+}
+
 std::string CMSmallARGBController::GetLocation()
 {
     return("HID: " + location);
@@ -122,6 +135,11 @@ unsigned char CMSmallARGBController::GetLedSpeed()
     return(current_speed);
 }
 
+unsigned char CMSmallARGBController::GetBrightness()
+{
+    return(current_brightness);
+}
+
 bool CMSmallARGBController::GetRandomColours()
 {
     return(bool_random);
@@ -217,9 +235,9 @@ void CMSmallARGBController::SendUpdate()
 
     hid_write(dev, buffer, buffer_size);
 
-    buffer[CM_SMALL_ARGB_COMMAND_BYTE]                  = 0x0b;
-    buffer[CM_SMALL_ARGB_FUNCTION_BYTE]                 = (false) ? 0x01 : 0x02; //This controls custom mode TODO
-    buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = cm_small_argb_header_data[0].header;
+    buffer[CM_SMALL_ARGB_COMMAND_BYTE]                  = 0x0B;
+    buffer[CM_SMALL_ARGB_FUNCTION_BYTE]                 = 0x02;
+    buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = 0x01;
     buffer[CM_SMALL_ARGB_MODE_BYTE]                     = current_mode;
     buffer[CM_SMALL_ARGB_SPEED_BYTE]                    = current_speed;
     buffer[CM_SMALL_ARGB_COLOUR_INDEX_BYTE]             = (bool_random) ? 0x00 : 0x10; //This looks to still be the colour index and controls random colours

Controllers/CoolerMasterController/CMSmallARGBController/CMSmallARGBController.h

@@ -39,16 +39,6 @@ enum
     CM_SMALL_ARGB_BLUE_BYTE             = 11,
 };
 
-struct cm_small_argb_headers
-{
-    const char*     name;
-    unsigned char   header;
-    bool            digital;
-    unsigned int    count;
-};
-
-extern cm_small_argb_headers cm_small_argb_header_data[1];
-
 enum
 {
     CM_SMALL_ARGB_MODE_SPECTRUM       = 0x01,   //Spectrum Mode
@@ -71,6 +61,8 @@ enum
     CM_SMALL_ARGB_SPEED_FASTEST       = 0x04,   // Fastest speed
 };
 
+#define CM_SMALL_ARGB_FW0012            std::string("A202104052336")
+
 class CMSmallARGBController
 {
 public:
@@ -80,12 +72,14 @@ public:
     std::string         GetDeviceName();
     std::string         GetSerial();
     std::string         GetLocation();
+    std::string         GetVersion();
 
     unsigned char       GetMode();
     unsigned char       GetLedRed();
     unsigned char       GetLedGreen();
     unsigned char       GetLedBlue();
     unsigned char       GetLedSpeed();
+    unsigned char       GetBrightness();
     bool                GetRandomColours();
 
     void                SetLedCount(int zone, int led_count);

Controllers/CoolerMasterController/CMSmallARGBController/RGBController_CMSmallARGBController.cpp

@@ -27,22 +27,68 @@
 RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmallARGBController* controller_ptr)
 {
     controller                  = controller_ptr;
-    unsigned char speed         = controller->GetLedSpeed();
 
-    name                        = cm_small_argb_header_data[0].name;
+    name                        = controller->GetDeviceName();
     vendor                      = "Cooler Master";
     type                        = DEVICE_TYPE_LEDSTRIP;
-    description                 = controller->GetDeviceName();
-    version                     = "2.0 for FW0012";
+    description                 = "Cooler Master Small ARGB Controller Device";
+    version                     = controller->GetVersion();
     serial                      = controller->GetSerial();
     location                    = controller->GetLocation();
 
-    if(serial >= CM_SMALL_ARGB_FW0012)
+    SetupModes();
+    SetupZones();
+
+    /*-----------------------------------------------------*\
+    | Initialize the active mode to the device's current    |
+    | mode                                                  |
+    \*-----------------------------------------------------*/
+    int             device_mode         = controller->GetMode();
+
+    for(std::size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
+    {
+        if(modes[mode_idx].value == device_mode)
+        {
+            active_mode = (int)mode_idx;
+
+            if((modes[mode_idx].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR) && (modes[mode_idx].colors.size() > 0))
+            {
+                modes[mode_idx].colors[0] = ToRGBColor(controller->GetLedRed(), controller->GetLedGreen(), controller->GetLedBlue());
+            }
+
+            if(modes[mode_idx].flags & MODE_FLAG_HAS_SPEED)
+            {
+                modes[mode_idx].speed = controller->GetLedSpeed();
+            }
+
+            if(modes[mode_idx].flags & MODE_FLAG_HAS_BRIGHTNESS)
+            {
+                modes[mode_idx].brightness = controller->GetBrightness();
+            }
+
+            if(modes[mode_idx].flags & MODE_FLAG_HAS_RANDOM_COLOR)
+            {
+                modes[mode_idx].color_mode = controller->GetRandomColours() ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
+            }
+
+            break;
+        }
+    }
+}
+
+void RGBController_CMSmallARGBController::SetupModes()
+{
+    /*-----------------------------------------------------*\
+    | The Small ARGB only supports Direct mode from FW0012  |
+    | onwards, older firmware does not accept direct mode   |
+    | packets                                               |
+    \*-----------------------------------------------------*/
+    //if(serial >= CM_SMALL_ARGB_FW0012)
     {
         mode Direct;
         Direct.name             = "Direct";
         Direct.value            = CM_SMALL_ARGB_MODE_DIRECT;
-        Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_REQUIRES_ENTIRE_DEVICE;
         Direct.brightness_min   = 0;
         Direct.brightness_max   = CM_SMALL_ARGB_BRIGHTNESS_MAX;
         Direct.brightness       = CM_SMALL_ARGB_BRIGHTNESS_MAX;
@@ -69,7 +115,7 @@ RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmall
     Reload.speed_min            = CM_SMALL_ARGB_SPEED_SLOWEST;
     Reload.speed_max            = CM_SMALL_ARGB_SPEED_FASTEST;
     Reload.color_mode           = MODE_COLORS_RANDOM;
-    Reload.speed                = speed;
+    Reload.speed                = CM_SMALL_ARGB_SPEED_NORMAL;
     modes.push_back(Reload);
 
     mode Recoil;
@@ -85,7 +131,7 @@ RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmall
     Recoil.speed_min            = CM_SMALL_ARGB_SPEED_SLOWEST;
     Recoil.speed_max            = CM_SMALL_ARGB_SPEED_FASTEST;
     Recoil.color_mode           = MODE_COLORS_RANDOM;
-    Recoil.speed                = speed;
+    Recoil.speed                = CM_SMALL_ARGB_SPEED_NORMAL;
     modes.push_back(Recoil);
 
     mode Breathing;
@@ -101,7 +147,7 @@ RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmall
     Breathing.speed_min         = CM_SMALL_ARGB_SPEED_SLOWEST;
     Breathing.speed_max         = CM_SMALL_ARGB_SPEED_FASTEST;
     Breathing.color_mode        = MODE_COLORS_RANDOM;
-    Breathing.speed             = speed;
+    Breathing.speed             = CM_SMALL_ARGB_SPEED_NORMAL;
     modes.push_back(Breathing);
 
     mode Refill;
@@ -117,7 +163,7 @@ RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmall
     Refill.speed_min            = CM_SMALL_ARGB_SPEED_SLOWEST;
     Refill.speed_max            = CM_SMALL_ARGB_SPEED_FASTEST;
     Refill.color_mode           = MODE_COLORS_RANDOM;
-    Refill.speed                = speed;
+    Refill.speed                = CM_SMALL_ARGB_SPEED_NORMAL;
     modes.push_back(Refill);
 
     mode Demo;
@@ -130,7 +176,7 @@ RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmall
     Demo.speed_min              = CM_SMALL_ARGB_SPEED_SLOWEST;
     Demo.speed_max              = CM_SMALL_ARGB_SPEED_FASTEST;
     Demo.color_mode             = MODE_COLORS_NONE;
-    Demo.speed                  = speed;
+    Demo.speed                  = CM_SMALL_ARGB_SPEED_NORMAL;
     modes.push_back(Demo);
 
     mode Spectrum;
@@ -143,39 +189,19 @@ RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmall
     Spectrum.speed_min          = CM_SMALL_ARGB_SPEED_SLOWEST;
     Spectrum.speed_max          = CM_SMALL_ARGB_SPEED_FASTEST;
     Spectrum.color_mode         = MODE_COLORS_NONE;
-    Spectrum.speed              = speed;
+    Spectrum.speed              = CM_SMALL_ARGB_SPEED_NORMAL;
     modes.push_back(Spectrum);
 
+    /*-----------------------------------------------------*\
+    | Define Passthrough mode as requiring the entire       |
+    | device, it hands control over to the motherboard      |
+    \*-----------------------------------------------------*/
     mode PassThru;
     PassThru.name               = "Pass Thru";
     PassThru.value              = CM_SMALL_ARGB_MODE_PASSTHRU;
+    PassThru.flags              = MODE_FLAG_REQUIRES_ENTIRE_DEVICE;
     PassThru.color_mode         = MODE_COLORS_NONE;
     modes.push_back(PassThru);
-
-    SetupZones();
-
-    int temp_mode               = controller->GetMode();
-
-    for(int mode_idx = 0; mode_idx < (int)modes.size() ; mode_idx++)
-    {
-        if(temp_mode == modes[mode_idx].value)
-        {
-            active_mode         = mode_idx;
-            break;
-        }
-    }
-
-    if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
-    {
-        modes[active_mode].colors[0] = ToRGBColor(controller->GetLedRed(), controller->GetLedGreen(), controller->GetLedBlue());
-    }
-
-    modes[active_mode].color_mode = (controller->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
-
-    if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
-    {
-        modes[active_mode].speed = controller->GetLedSpeed();
-    }
 }
 
 RGBController_CMSmallARGBController::~RGBController_CMSmallARGBController()
@@ -248,7 +274,9 @@ void RGBController_CMSmallARGBController::SetupZones()
         {
             led new_led;
             new_led.name                            = zones[zone_idx].name;
-            new_led.name.append(", LED " + std::to_string(lp_idx));
+            new_led.name.append(", LED ");
+            new_led.name.append(std::to_string(lp_idx + 1));
+            new_led.value                           = (unsigned int)zone_idx;
 
             leds.push_back(new_led);
         }
@@ -261,7 +289,7 @@ void RGBController_CMSmallARGBController::DeviceConfigureZone(int zone_idx)
 {
     if((size_t)zone_idx < zones.size())
     {
-        controller->SetLedCount(cm_small_argb_header_data[zone_idx].header, zones[zone_idx].leds_count);
+        controller->SetLedCount(1, zones[zone_idx].leds_count);
 
         SetupZones();
     }
@@ -277,37 +305,79 @@ void RGBController_CMSmallARGBController::DeviceUpdateLEDs()
 
 void RGBController_CMSmallARGBController::DeviceUpdateZoneLEDs(int zone)
 {
-    if(serial >= CM_SMALL_ARGB_FW0012)
+    /*-----------------------------------------------------*\
+    | Only send direct packets while Direct mode is active. |
+    | Direct mode is only offered on FW0012 and newer, so   |
+    | older firmware will never send direct packets here    |
+    \*-----------------------------------------------------*/
+    if(modes[active_mode].value != CM_SMALL_ARGB_MODE_DIRECT)
     {
-        controller->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
+        return;
     }
+
+    controller->SetLedsDirect(zones[zone].colors, zones[zone].leds_count);
 }
 
 void RGBController_CMSmallARGBController::DeviceUpdateSingleLED(int led)
 {
-    DeviceUpdateZoneLEDs(led);
+    /*-----------------------------------------------------*\
+    | Map the LED back to its zone and update that zone     |
+    \*-----------------------------------------------------*/
+    unsigned int zone_idx = leds[led].value;
+
+    UpdateZoneLEDs(zone_idx);
 }
 
 void RGBController_CMSmallARGBController::SetCustomMode()
 {
-    /*-------------------------------------------------*\
-    | The small ARGB may not support "Direct" mode      |
-    |   in which case this will select "Pass Thru"      |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Direct mode is only supported on FW0012 and newer     |
+    \*-----------------------------------------------------*/
     if(serial >= CM_SMALL_ARGB_FW0012)
     {
-        active_mode = 0;
+        /*-------------------------------------------------*\
+        | Search the mode list for Direct mode              |
+        \*-------------------------------------------------*/
+        for(std::size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
+        {
+            if(modes[mode_idx].name == "Direct")
+            {
+                SetActiveMode((int)mode_idx);
+                break;
+            }
+        }
     }
     else
     {
-        active_mode = 7;
+        /*-------------------------------------------------*\
+        | Direct mode is unsupported by the firmware,       |
+        | fall back to Pass Thru                            |
+        \*-------------------------------------------------*/
+        for(std::size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
+        {
+            if(modes[mode_idx].value == CM_SMALL_ARGB_MODE_PASSTHRU)
+            {
+                SetActiveMode((int)mode_idx);
+                break;
+            }
+        }
     }
 }
 
 void RGBController_CMSmallARGBController::DeviceUpdateMode()
 {
-    bool     random_colours = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-    RGBColor colour         = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
+    /*-----------------------------------------------------*\
+    | Set up mode parameters                                |
+    \*-----------------------------------------------------*/
+    bool            random_colours  = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+    RGBColor        colour          = 0;
+    unsigned int    speed           = modes[active_mode].speed;
+    unsigned int    brightness      = modes[active_mode].brightness;
 
-    controller->SetMode( modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, colour, random_colours);
+    if(modes[active_mode].colors.size() > 0)
+    {
+        colour                      = modes[active_mode].colors[0];
+    }
+
+    controller->SetMode(modes[active_mode].value, speed, brightness, colour, random_colours);
 }

Controllers/CoolerMasterController/CMSmallARGBController/RGBController_CMSmallARGBController.h

@@ -18,7 +18,6 @@
 #define CM_SMALL_ARGB_MIN_LEDS          4
 #define CM_SMALL_ARGB_MAX_LEDS          48
 #define CM_SMALL_ARGB_BRIGHTNESS_MAX    0xFF
-#define CM_SMALL_ARGB_FW0012            "A202104052336"
 
 class RGBController_CMSmallARGBController : public RGBController
 {
@@ -26,7 +25,9 @@ public:
     RGBController_CMSmallARGBController(CMSmallARGBController* controller_ptr);
     ~RGBController_CMSmallARGBController();
 
+    void        SetupModes();
     void        SetupZones();
+
     void        DeviceConfigureZone(int zone_idx);
 
     void        DeviceUpdateLEDs();
@@ -35,9 +36,7 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
-private:
-    void        Init_Controller();
-    int         GetDeviceMode();
 
+private:
     CMSmallARGBController*  controller;
 };

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -327,9 +327,18 @@ DetectedControllers DetectCoolerMasterSmallARGB(hid_device_info* info, const std
     if(dev)
     {
         CMSmallARGBController*               controller     = new CMSmallARGBController(dev, info->path);
-        RGBController_CMSmallARGBController* rgb_controller = new RGBController_CMSmallARGBController(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        if(controller->GetVersion() != "Unsupported")
+        {
+            RGBController_CMSmallARGBController* rgb_controller = new RGBController_CMSmallARGBController(controller);
+
+            detected_controllers.push_back(rgb_controller);
+        }
+        else
+        {
+            LOG_ERROR("[CMSmallARGBController] Unsupported firmware version");
+            delete controller;
+        }
     }
 
     return(detected_controllers);

Controllers/CorsairHydro2Controller/CorsairHydro2ControllerDetect.cpp

@@ -44,8 +44,4 @@ DetectedControllers DetectCorsairHydro2Controllers()
 }
 
 REGISTER_DETECTOR("Corsair H100i v2", DetectCorsairHydro2Controllers);
-/*---------------------------------------------------------------------------------------------------------*\
-| Entries for dynamic UDEV rules                                                                            |
-|                                                                                                           |
-| DUMMY_DEVICE_DETECTOR("Corsair H100i v2", DetectCorsairHydro2Controllers, 0x1B1C, 0x0C09 )                |
-\*---------------------------------------------------------------------------------------------------------*/
+REGISTER_CUSTOM_UDEV_RULE(corsair_h100i_v2, "Corsair H100i v2", "SUBSYSTEMS==\"usb|hidraw\", ATTRS{idVendor}==\"1b1c\", ATTRS{idProduct}==\"0c09\", TAG+=\"uaccess\", TAG+=\"Corsair_H100i_v2\"");

Controllers/CorsairHydroController/CorsairHydroControllerDetect.cpp

@@ -77,10 +77,6 @@ DetectedControllers DetectCorsairHydroControllers()
 }
 
 REGISTER_DETECTOR("Corsair Hydro Series", DetectCorsairHydroControllers);
-/*---------------------------------------------------------------------------------------------------------*\
-| Entries for dynamic UDEV rules                                                                            |
-|                                                                                                           |
-| DUMMY_DEVICE_DETECTOR("Corsair Hydro Series", DetectCorsairHydroControllers, 0x1B1C, 0x0C12 )             |
-| DUMMY_DEVICE_DETECTOR("Corsair Hydro Series", DetectCorsairHydroControllers, 0x1B1C, 0x0C13 )             |
-| DUMMY_DEVICE_DETECTOR("Corsair Hydro Series", DetectCorsairHydroControllers, 0x1B1C, 0x0C15 )             |
-\*---------------------------------------------------------------------------------------------------------*/
+REGISTER_CUSTOM_UDEV_RULE(corsair_hydro_1, "Corsair Hydro Series", "SUBSYSTEMS==\"usb|hidraw\", ATTRS{idVendor}==\"1b1c\", ATTRS{idProduct}==\"0c12\", TAG+=\"uaccess\", TAG+=\"Corsair_Hydro_Series\"");
+REGISTER_CUSTOM_UDEV_RULE(corsair_hydro_2, "Corsair Hydro Series", "SUBSYSTEMS==\"usb|hidraw\", ATTRS{idVendor}==\"1b1c\", ATTRS{idProduct}==\"0c13\", TAG+=\"uaccess\", TAG+=\"Corsair_Hydro_Series\"");
+REGISTER_CUSTOM_UDEV_RULE(corsair_hydro_3, "Corsair Hydro Series", "SUBSYSTEMS==\"usb|hidraw\", ATTRS{idVendor}==\"1b1c\", ATTRS{idProduct}==\"0c15\", TAG+=\"uaccess\", TAG+=\"Corsair_Hydro_Series\"");

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -232,7 +232,7 @@ void CorsairLightingNodeController::SendFirmwareRequest()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    actual = WriteAndRead(usb_buf);
+    actual = WriteAndRead(usb_buf, CORSAIR_LIGHTING_NODE_READ_TIMEOUT);
 
     if(actual > 0)
     {

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -217,7 +217,7 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
             blu_val[keys_k95[color_idx]] = RGBGetBValue(color);
             data_sz = 48; //untested
         }
-        else if (logical_layout == CORSAIR_TYPE_K70_MK2)
+        else if (logical_layout == CORSAIR_TYPE_K70_MK2 || logical_layout == CORSAIR_TYPE_K70_LUX_RGB)
         {
             red_val[keys_k70_mk2[color_idx]] = RGBGetRValue(color);
             grn_val[keys_k70_mk2[color_idx]] = RGBGetGValue(color);
@@ -447,7 +447,7 @@ void CorsairPeripheralController::SetupK55AndK95LightingControl()
 
     if (physical_layout == CORSAIR_LAYOUT_ISO)
     {
-        if(logical_layout == CORSAIR_TYPE_K70_MK2)
+        if(logical_layout == CORSAIR_TYPE_K70_MK2 || logical_layout == CORSAIR_TYPE_K70_LUX_RGB)
         {
             skipped_identifiers = key_mapping_k70_mk2_plat_iso;
             skipped_identifiers_count = sizeof(key_mapping_k70_mk2_plat_iso) / sizeof(key_mapping_k70_mk2_plat_iso[0]);
@@ -632,10 +632,15 @@ void CorsairPeripheralController::ReadFirmwareInfo()
                     logical_layout = CORSAIR_TYPE_K55;
                     break;
 
+                    case 0x1B33:
+                    logical_layout = CORSAIR_TYPE_K70_LUX_RGB;
+                    break;
+
                     case 0x1B38:
                     case 0x1B49:
                     case 0x1B6B:
                     case 0x1B55:
+                    case 0x1B48:
                     logical_layout = CORSAIR_TYPE_K70_MK2;
                     break;
 

Controllers/CorsairPeripheralController/CorsairPeripheralController.h

@@ -67,7 +67,8 @@ enum
     CORSAIR_TYPE_K95                = 2,
     CORSAIR_TYPE_K55                = 3,
     CORSAIR_TYPE_K70_MK2            = 4,
-    CORSAIR_TYPE_K68                = 5
+    CORSAIR_TYPE_K68                = 5,
+    CORSAIR_TYPE_K70_LUX_RGB        = 6
 };
 
 enum

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -48,7 +48,7 @@
 #define CORSAIR_K70_RGB_MK2_PID         0x1B49
 #define CORSAIR_K70_RGB_MK2_SE_PID      0x1B6B
 #define CORSAIR_K70_RGB_MK2_LP_PID      0x1B55
-
+#define CORSAIR_K70_RGB_PRO_OPTO_PID    0x1BC6
 #define CORSAIR_K95_RGB_PID             0x1B11
 #define CORSAIR_K95_PLATINUM_PID        0x1B2D
 #define CORSAIR_K95_PLATINUM_SE_PID     0x1B82
@@ -81,6 +81,7 @@
 #define CORSAIR_SCIMITAR_PRO_RGB_PID    0x1B3E
 #define CORSAIR_SCIMITAR_ELITE_RGB_PID  0x1B8B
 #define CORSAIR_SABRE_RGB_PID           0x1B2F
+#define CORSAIR_SABRE_RGB_OPTICAL_PID   0x1B32
 
 /*---------------------------------------------------------*\
 | Mousepad product IDs                                      |
@@ -192,6 +193,7 @@ REGISTER_HID_DETECTOR_IP("Corsair K70 RGB RAPIDFIRE",       DetectCorsairPeriphe
 REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2",            DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_PID,        1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2 SE",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_SE_PID,     1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2 Low Profile",DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_LP_PID,     1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB PRO Optomechanical", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_PRO_OPTO_PID, 1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K95 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_RGB_PID,            1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K95 RGB PLATINUM",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_PLATINUM_PID,       1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K95 RGB PLATINUM SE",     DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_PLATINUM_SE_PID,    1, 0xFFC2);
@@ -214,6 +216,7 @@ REGISTER_HID_DETECTOR_IP("Corsair Scimitar RGB",            DetectCorsairPeriphe
 REGISTER_HID_DETECTOR_IP("Corsair Scimitar PRO RGB",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_PRO_RGB_PID,   1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Scimitar Elite RGB",      DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_ELITE_RGB_PID, 1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Sabre RGB",               DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SABRE_RGB_PID,          1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Sabre RGB Optical",       DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SABRE_RGB_OPTICAL_PID,  1, 0xFFC2);
 
 /*---------------------------------------------------------*\
 | Mousemats                                                 |

Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.cpp

@@ -23,6 +23,15 @@ static unsigned int matrix_map[6][23] =
       {   4, 111,  22,  32,  40,  50,  NA,  59,  NA,  68,  78,  88,  97, 106,  61,  NA,  NA,  81,  NA,  73,  83,  92, 109 },
       {   5,  14,  23,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  69,  79,  89,  71,  90,  99, 108, 101,  NA, 110,  NA } };
 
+static unsigned int matrix_map_k70_lux_rgb[7][23] =
+    { {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 107,  8,  NA,  NA,  16,  NA,  NA,},
+      {   0,  NA,  10,  18,  28,  36,  NA,  46,  55,  64,  74,  NA,  84,  93, 102,   6,  15,  24,  33,  26,  35,  44,  53 },
+      {   1,  11,  19,  29,  37,  47,  NA,  56,  65,  75,  85,  94, 103,   7,  25,  NA,  42,  51,  60,  62,  72,  82,  91 },
+      {   2,  NA,  12,  20,  30,  38,  48,  57,  66,  76,  86,  NA,  95, 104,  70,  80,  34,  43,  52,  9,   17,  27, 100 },
+      {   3,  NA,  13,  21,  31,  39,  49,  58,  67,  77,  87,  NA,  96, 105,  98, 112,  NA,  NA,  NA,  45,  54,  63,  NA },
+      {   4, 111,  NA,  22,  32,  40,  50,  59,  68,  78,  88,  97,  NA, 106,  61,  NA,  NA,  81,  NA,  73,  83,  92, 109 },
+      {   5,  NA,  14,  23,  NA,  NA,  NA,  41,  NA,  NA,  NA,  69,  NA,  79,  89,  71,  90,  99, 108, 101,  NA, 110,  NA } };
+
 static unsigned int matrix_map_k70_mk2[7][23] =
     { {  NA,  NA,  NA, 115, 107,   8,  NA,  NA,  NA,  NA,  NA, 113, 114,  NA,  NA,  NA,  NA,  NA,  NA,  16,  NA,  NA,  NA,},
       {   0,  NA,  10,  18,  28,  36,  NA,  46,  55,  64,  74,  NA,  84,  93, 102,   6,  15,  24,  33,  26,  35,  44,  53 },
@@ -68,6 +77,24 @@ static const zone_type zone_types[] =
     ZONE_TYPE_MATRIX,
 };
 
+/*---------------------------------------------------------*\
+| K70 LUX RGB Corsair Layout                                    |
+\*---------------------------------------------------------*/
+static const char* zone_names_k70_lux_rgb[] =
+{
+    ZONE_EN_KEYBOARD,
+};
+
+static const unsigned int zone_sizes_k70_lux_rgb[] =
+{
+    116
+};
+
+static const zone_type zone_types_k70_lux_rgb[] =
+{
+    ZONE_TYPE_MATRIX,
+};
+
 /*---------------------------------------------------------*\
 | K70 MK2 Corsair Layout                                    |
 \*---------------------------------------------------------*/
@@ -159,7 +186,7 @@ static const char* led_names[] =
     KEY_EN_LEFT_CONTROL,        //5
     KEY_EN_F12,                 //6
     KEY_EN_EQUALS,              //7
-    "Key: Lock",                //8
+    KEY_EN_WINDOWS_LOCK,        //8
     KEY_EN_NUMPAD_7,            //9
     KEY_EN_F1,                  //12
     KEY_EN_1,                   //13
@@ -258,7 +285,7 @@ static const char* led_names[] =
     KEY_EN_LEFT_BRACKET,        //134
     KEY_EN_QUOTE,               //135
     KEY_EN_FORWARD_SLASH,       //136
-    "Key: Brightness",          //137
+    KEY_EN_BRIGHTNESS,          //137
     KEY_EN_RIGHT_ARROW,         //139
     KEY_EN_NUMPAD_ENTER,        //140
     KEY_EN_NUMPAD_PERIOD,       //141
@@ -266,7 +293,7 @@ static const char* led_names[] =
     KEY_EN_ISO_BACK_SLASH,
 };
 
-static const char* led_names_k70_mk2[] =
+static const char* led_names_k70_lux_rgb[] =
 {
     KEY_EN_ESCAPE,              //0
     KEY_EN_BACK_TICK,           //1
@@ -276,7 +303,7 @@ static const char* led_names_k70_mk2[] =
     KEY_EN_LEFT_CONTROL,        //5
     KEY_EN_F12,                 //6
     KEY_EN_EQUALS,              //7
-    "Key: Lock",                //8
+    KEY_EN_WINDOWS_LOCK,        //8
     KEY_EN_NUMPAD_7,            //9
     KEY_EN_F1,                  //12
     KEY_EN_1,                   //13
@@ -380,7 +407,132 @@ static const char* led_names_k70_mk2[] =
     KEY_EN_LEFT_BRACKET,        //134
     KEY_EN_QUOTE,               //135
     KEY_EN_FORWARD_SLASH,       //136
-    "Key: Brightness",          //137
+    KEY_EN_BRIGHTNESS,          //137
+    KEY_EN_RIGHT_ARROW,         //139
+    KEY_EN_NUMPAD_ENTER,        //140
+    KEY_EN_NUMPAD_PERIOD,       //141
+    "Key: / (ISO)",             //16
+    KEY_EN_ISO_BACK_SLASH,      //114
+    "Key: Logo Left",           //047
+    "Key: Logo Right",          //059
+    "Key: Profile",             //125
+};
+
+static const char* led_names_k70_mk2[] =
+{
+    KEY_EN_ESCAPE,              //0
+    KEY_EN_BACK_TICK,           //1
+    KEY_EN_TAB,                 //2
+    KEY_EN_CAPS_LOCK,           //3
+    KEY_EN_LEFT_SHIFT,          //4
+    KEY_EN_LEFT_CONTROL,        //5
+    KEY_EN_F12,                 //6
+    KEY_EN_EQUALS,              //7
+    KEY_EN_WINDOWS_LOCK,        //8
+    KEY_EN_NUMPAD_7,            //9
+    KEY_EN_F1,                  //12
+    KEY_EN_1,                   //13
+    KEY_EN_Q,                   //14
+    KEY_EN_A,                   //15
+    //"Key: / (ISO)",           //16
+    KEY_EN_LEFT_WINDOWS,        //17
+    KEY_EN_PRINT_SCREEN,        //18
+    KEY_EN_MEDIA_MUTE,          //20
+    KEY_EN_NUMPAD_8,            //21
+    KEY_EN_F2,                  //24
+    KEY_EN_2,                   //25
+    KEY_EN_W,                   //26
+    KEY_EN_S,                   //27
+    KEY_EN_Z,                   //28
+    KEY_EN_LEFT_ALT,            //29
+    KEY_EN_SCROLL_LOCK,         //30
+    KEY_EN_BACKSPACE,           //31
+    KEY_EN_MEDIA_STOP,          //32
+    KEY_EN_NUMPAD_9,            //33
+    KEY_EN_F3,                  //36
+    KEY_EN_3,                   //37
+    KEY_EN_E,                   //38
+    KEY_EN_D,                   //39
+    KEY_EN_X,                   //40
+    KEY_EN_PAUSE_BREAK,         //42
+    KEY_EN_DELETE,              //43
+    KEY_EN_MEDIA_PREVIOUS,      //44
+    //"Key: Logo Left",         //047
+    KEY_EN_F4,                  //48
+    KEY_EN_4,                   //49
+    KEY_EN_R,                   //50
+    KEY_EN_F,                   //51
+    KEY_EN_C,                   //52
+    KEY_EN_SPACE,               //53
+    KEY_EN_INSERT,              //54
+    KEY_EN_END,                 //55
+    KEY_EN_MEDIA_PLAY_PAUSE,    //56
+    KEY_EN_NUMPAD_4,            //57
+    //"Key: Logo Right",        //059
+    KEY_EN_F5,                  //60
+    KEY_EN_5,                   //61
+    KEY_EN_T,                   //62
+    KEY_EN_G,                   //63
+    KEY_EN_V,                   //64
+    KEY_EN_HOME,                //66
+    KEY_EN_PAGE_DOWN,           //67
+    KEY_EN_MEDIA_NEXT,          //68
+    KEY_EN_NUMPAD_5,            //69
+    KEY_EN_F6,                  //72
+    KEY_EN_6,                   //73
+    KEY_EN_Y,                   //74
+    KEY_EN_H,                   //75
+    KEY_EN_B,                   //76
+    KEY_EN_PAGE_UP,             //78
+    KEY_EN_RIGHT_SHIFT,         //79
+    KEY_EN_NUMPAD_LOCK,         //80
+    KEY_EN_NUMPAD_6,            //81
+    KEY_EN_F7,                  //84
+    KEY_EN_7,                   //85
+    KEY_EN_U,                   //86
+    KEY_EN_J,                   //87
+    KEY_EN_N,                   //88
+    KEY_EN_RIGHT_ALT,           //89
+    KEY_EN_RIGHT_BRACKET,       //90
+    KEY_EN_RIGHT_CONTROL,       //91
+    KEY_EN_NUMPAD_DIVIDE,       //92
+    KEY_EN_NUMPAD_1,            //93
+    KEY_EN_F8,                  //96
+    KEY_EN_8,                   //97
+    KEY_EN_I,                   //98
+    KEY_EN_K,                   //99
+    KEY_EN_M,                   //100
+    KEY_EN_RIGHT_WINDOWS,       //101
+    KEY_EN_ANSI_BACK_SLASH,     //102
+    KEY_EN_UP_ARROW,            //103
+    KEY_EN_NUMPAD_TIMES,        //104
+    KEY_EN_NUMPAD_2,            //105
+    KEY_EN_F9,                  //108
+    KEY_EN_9,                   //109
+    KEY_EN_O,                   //110
+    KEY_EN_L,                   //111
+    KEY_EN_COMMA,               //112
+    KEY_EN_MENU,                //113
+    //KEY_EN_ISO_BACK_SLASH,    //114
+    KEY_EN_LEFT_ARROW,          //115
+    KEY_EN_NUMPAD_MINUS,        //116
+    KEY_EN_NUMPAD_3,            //117
+    KEY_EN_F10,                 //120
+    KEY_EN_0,                   //121
+    KEY_EN_P,                   //122
+    KEY_EN_SEMICOLON,           //123
+    //"Key: Profile",           //125
+    KEY_EN_PERIOD,              //124
+    KEY_EN_ANSI_ENTER,          //126
+    KEY_EN_DOWN_ARROW,          //127
+    KEY_EN_NUMPAD_PLUS,         //128
+    KEY_EN_NUMPAD_0,            //129
+    KEY_EN_F11,                 //132
+    KEY_EN_MINUS,               //133
+    KEY_EN_LEFT_BRACKET,        //134
+    KEY_EN_QUOTE,               //135
+    KEY_EN_FORWARD_SLASH,       //136
+    KEY_EN_BRIGHTNESS,          //137
     KEY_EN_RIGHT_ARROW,         //139
     KEY_EN_NUMPAD_ENTER,        //140
     KEY_EN_NUMPAD_PERIOD,       //141
@@ -401,7 +553,7 @@ static const char* led_names_k95_plat[] =
     KEY_EN_LEFT_CONTROL,        //5
     KEY_EN_F12,                 //6
     KEY_EN_EQUALS,              //7
-    "Key: Lock",                //8
+    KEY_EN_WINDOWS_LOCK,        //8
     KEY_EN_NUMPAD_7,            //9
     KEY_EN_F1,                  //12
     KEY_EN_1,                   //13
@@ -500,7 +652,7 @@ static const char* led_names_k95_plat[] =
     KEY_EN_LEFT_BRACKET,        //134
     KEY_EN_QUOTE,               //135
     KEY_EN_FORWARD_SLASH,       //136
-    "Key: Brightness",          //137
+    KEY_EN_BRIGHTNESS,          //137
     KEY_EN_RIGHT_ARROW,         //139
     KEY_EN_NUMPAD_ENTER,        //140
     KEY_EN_NUMPAD_PERIOD,       //141
@@ -544,7 +696,7 @@ static const char* led_names_k95[] =
     KEY_EN_LEFT_CONTROL,        //5
     KEY_EN_F12,                 //6
     KEY_EN_EQUALS,              //7
-    "Key: Lock",                //8
+    KEY_EN_WINDOWS_LOCK,        //8
     KEY_EN_NUMPAD_7,            //9
     KEY_EN_F1,                  //12
     KEY_EN_1,                   //13
@@ -643,7 +795,7 @@ static const char* led_names_k95[] =
     KEY_EN_LEFT_BRACKET,        //134
     KEY_EN_QUOTE,               //135
     KEY_EN_FORWARD_SLASH,       //136
-    "Key: Brightness",          //137
+    KEY_EN_BRIGHTNESS,          //137
     KEY_EN_RIGHT_ARROW,         //139
     KEY_EN_NUMPAD_ENTER,        //140
     KEY_EN_NUMPAD_PERIOD,       //141
@@ -1012,6 +1164,19 @@ void RGBController_CorsairPeripheral::SetupZones()
                     new_zone.leds_max               = zone_sizes_k55[zone_idx];
                     new_zone.leds_count             = zone_sizes_k55[zone_idx];
                 }
+                else if (logical_layout == CORSAIR_TYPE_K70_LUX_RGB)
+                {
+                    new_zone.name                   = zone_names_k70_lux_rgb[zone_idx];
+                    new_zone.type                   = zone_types_k70_lux_rgb[zone_idx];
+                    new_zone.leds_min               = zone_sizes_k70_lux_rgb[zone_idx];
+                    new_zone.leds_max               = zone_sizes_k70_lux_rgb[zone_idx];
+                    new_zone.leds_count             = zone_sizes_k70_lux_rgb[zone_idx];
+
+                    if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
+                    {
+                        new_zone.matrix_map.Set(7, 23, (unsigned int *)&matrix_map_k70_lux_rgb);
+                    }
+                }
                 else if (logical_layout == CORSAIR_TYPE_K70_MK2)
                 {
                     new_zone.name                   = zone_names_k70_mk2[zone_idx];
@@ -1101,6 +1266,10 @@ void RGBController_CorsairPeripheral::SetupZones()
                 {
                     new_led.name = led_names_k55[led_idx];
                 }
+                else if(logical_layout == CORSAIR_TYPE_K70_LUX_RGB)
+                {
+                    new_led.name = led_names_k70_lux_rgb[led_idx];
+                }
                 else if(logical_layout == CORSAIR_TYPE_K70_MK2)
                 {
                     new_led.name = led_names_k70_mk2[led_idx];

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.cpp

@@ -9,6 +9,9 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
+#include <chrono>
+#include <thread>
+
 #include "CorsairPeripheralV2Controller.h"
 #include "StringUtils.h"
 
@@ -19,21 +22,36 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
     dev                 = dev_handle;
     location            = path;
     device_name         = name;
+    device_index        = CORSAIR_V2_DEVICE_NOT_FOUND;
 
     /*---------------------------------------------------------*\
     | Get PID                                                   |
     |   If the PID is in the know wireless receivers list       |
     |   switch the write_cmd to talk to the device and retry    |
     \*---------------------------------------------------------*/
-    unsigned int pid    = GetAddress(0x12);
+    /*---------------------------------------------------------*\
+    | Establish the packet size before talking to the device.   |
+    \*---------------------------------------------------------*/
+    uint16_t report_size = GetOutputReportSize();
+
+    if(report_size >= CORSAIR_V2_WRITE_SIZE && report_size <= CORSAIR_V2_PACKET_SIZE)
+    {
+        pkt_sze = report_size;
+    }
+
+    LOG_DEBUG("[%s] Packet length set to %d", device_name.c_str(), pkt_sze);
+
+    unsigned int pid    = GetAddressRetry(0x12);
 
     switch(pid)
     {
         case CORSAIR_SLIPSTREAM_WIRELESS_PID1:
         case CORSAIR_SLIPSTREAM_WIRELESS_V2_PID1:
         case CORSAIR_SLIPSTREAM_WIRELESS_PID2:
+        case CORSAIR_SLIPSTREAM_M75_PID:
+        case CORSAIR_SLIPSTREAM_IRONCLAW_SE_PID:
             write_cmd   = CORSAIR_V2_WRITE_WIRELESS_ID;
-            pid         = GetAddress(0x12);
+            pid         = GetAddressRetry(0x12);
             break;
 
         case CORSAIR_K57_RGB_WIRED_PID:
@@ -58,14 +76,12 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
     |   the device being set up.                                |
     \*---------------------------------------------------------*/
     uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
+    memset(buffer, 0, pkt_sze);
     buffer[1] = write_cmd;
     buffer[2] = CORSAIR_V2_CMD_GET;
     buffer[3] = 0x11;
-    hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
-    uint16_t result = hid_read_timeout(dev, buffer, CORSAIR_V2_PACKET_SIZE, CORSAIR_V2_TIMEOUT);
-    result++;
-    pkt_sze = std::max(result, (uint16_t)CORSAIR_V2_WRITE_SIZE);
-    LOG_DEBUG("[%s] Packet length set to %d", device_name.c_str(), pkt_sze);
+    hid_write(dev, buffer, pkt_sze);
+    hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT);
 
     /*---------------------------------------------------------*\
     | NB: If the device is not found in the device list         |
@@ -88,28 +104,129 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
         }
     }
 
+    /*---------------------------------------------------------*\
+    | Unknown PID                                               |
+    |   Leave device_index at CORSAIR_V2_DEVICE_NOT_FOUND so    |
+    |   GetDeviceData() returns nullptr and the detector drops  |
+    |   the device, rather than building an RGBController on    |
+    |   top of an out of range index.                           |
+    \*---------------------------------------------------------*/
     if(not_found)
     {
         LOG_ERROR("[%s] device capabilities not found. Please creata a new device request.",
                   device_name.c_str());
+        return;
+    }
+
+}
+
+/*---------------------------------------------------------*\
+| Check lighting control endpoints                          |
+|   If lighting control endpoint 2 is unavailable           |
+|   then use endpoint 1.                                    |
+\*---------------------------------------------------------*/
+uint16_t CorsairPeripheralV2Controller::GetOutputReportSize()
+{
+    unsigned char   descriptor[HID_API_MAX_REPORT_DESCRIPTOR_SIZE];
+    int             length          = hid_get_report_descriptor(dev, descriptor, sizeof(descriptor));
+
+    if(length <= 0)
+    {
+        return 0;
+    }
+
+    unsigned int    report_size     = 0;
+    unsigned int    report_count    = 0;
+    int             index           = 0;
+
+    while(index < length)
+    {
+        unsigned char   item        = descriptor[index];
+        unsigned char   tag         = item & 0xFC;
+        unsigned char   item_size   = item & 0x03;
+
+        /*---------------------------------------------------------*\
+        | A size field of 3 means four data bytes follow.           |
+        \*---------------------------------------------------------*/
+        if(item_size == 3)
+        {
+            item_size = 4;
+        }
+
+        if(index + 1 + item_size > length)
+        {
+            break;
+        }
+
+        unsigned int    value       = 0;
+
+        for(unsigned char byte = 0; byte < item_size; byte++)
+        {
+            value |= (unsigned int)descriptor[index + 1 + byte] << (8 * byte);
+        }
+
+        switch(tag)
+        {
+            case 0x74:                              /* Report Size      */
+                report_size     = value;
+                break;
+
+            case 0x94:                              /* Report Count     */
+                report_count    = value;
+                break;
+
+            case 0x90:                              /* Output           */
+                if(report_size > 0 && report_count > 0)
+                {
+                    return (uint16_t)(((report_size * report_count) / 8) + 1);
+                }
+                break;
+        }
+
+        index += 1 + item_size;
+    }
+
+    return 0;
+}
+
+void CorsairPeripheralV2Controller::DetectLightingEndpoint()
+{
+    /*---------------------------------------------------------*\
+    | A device that cannot be read from cannot be probed; those |
+    |   carry the endpoint they need already set.               |
+    \*---------------------------------------------------------*/
+    if(skip_reads)
+    {
+        return;
     }
 
     /*---------------------------------------------------------*\
-    | Check lighting control endpoints                          |
-    |   If lighting control endpoint 2 is unavailable           |
-    |   then use endpoint 1.                                    |
+    | Lighting control 1 is the plain lighting resource and     |
+    |   takes colour block data.  A device that answers         |
+    |   invalid or unsupported for it wants the alternate       |
+    |   lighting resource, which takes RGB triplets.            |
     \*---------------------------------------------------------*/
-    if(light_ctrl == CORSAIR_V2_LIGHT_CTRL2)
+    light_ctrl              = CORSAIR_V2_LIGHT_CTRL1;
+    unsigned char result    = StartTransaction(0);
+
+    /*---------------------------------------------------------*\
+    | A handle left open by an earlier session answers failed;  |
+    |   close it and open it again.                             |
+    \*---------------------------------------------------------*/
+    if(result == CORSAIR_V2_ERR_FAILED)
     {
-        result = StartTransaction(0);
-        if(result > 0)
-        {
-            light_ctrl = CORSAIR_V2_LIGHT_CTRL1;
-            StartTransaction(0);
-        }
         StopTransaction(0);
-        LOG_DEBUG("[%s] Lighting Endpoint set to %02X", device_name.c_str(), light_ctrl);
+        result              = StartTransaction(0);
     }
+
+    if(result == CORSAIR_V2_ERR_INVALID || result == CORSAIR_V2_ERR_NOT_SUPPORTED)
+    {
+        light_ctrl          = CORSAIR_V2_LIGHT_CTRL2;
+        StartTransaction(0);
+    }
+
+    StopTransaction(0);
+    LOG_DEBUG("[%s] Lighting Endpoint set to %02X", device_name.c_str(), light_ctrl);
 }
 
 CorsairPeripheralV2Controller::~CorsairPeripheralV2Controller()
@@ -119,9 +236,19 @@ CorsairPeripheralV2Controller::~CorsairPeripheralV2Controller()
 
 const corsair_v2_device* CorsairPeripheralV2Controller::GetDeviceData()
 {
+    if(!IsDeviceSupported())
+    {
+        return nullptr;
+    }
+
     return corsair_v2_device_list[device_index];
 }
 
+bool CorsairPeripheralV2Controller::IsDeviceSupported()
+{
+    return device_index < CORSAIR_V2_DEVICE_COUNT;
+}
+
 std::string CorsairPeripheralV2Controller::GetDeviceLocation()
 {
     return("HID: " + location);
@@ -167,9 +294,9 @@ std::string CorsairPeripheralV2Controller::GetSerialString()
 
 void CorsairPeripheralV2Controller::SetRenderMode(corsair_v2_device_mode mode)
 {
-    uint8_t buffer[CORSAIR_V2_WRITE_SIZE];
+    uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
 
-    memset(buffer, 0, CORSAIR_V2_WRITE_SIZE);
+    memset(buffer, 0, pkt_sze);
 
     /*---------------------------------------------------------*\
     | Set Mode                                                  |
@@ -179,19 +306,19 @@ void CorsairPeripheralV2Controller::SetRenderMode(corsair_v2_device_mode mode)
     buffer[3]   = CORSAIR_V2_VALUE_MODE;
     buffer[5]   = mode;
 
-    hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
+    hid_write(dev, buffer, pkt_sze);
 
     if(!skip_reads)
     {
-        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT);
     }
 }
 
 void CorsairPeripheralV2Controller::LightingControl(uint8_t opt1)
 {
-    uint8_t buffer[CORSAIR_V2_WRITE_SIZE];
+    uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
 
-    memset(buffer, 0, CORSAIR_V2_WRITE_SIZE);
+    memset(buffer, 0, pkt_sze);
 
     /*---------------------------------------------------------*\
     | The Corsair command is the same for each initialisation   |
@@ -203,11 +330,11 @@ void CorsairPeripheralV2Controller::LightingControl(uint8_t opt1)
     buffer[3]   = opt1;
     buffer[5]   = 0x00;
 
-    hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
+    hid_write(dev, buffer, pkt_sze);
 
     if(!skip_reads)
     {
-        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT);
     }
 }
 
@@ -216,20 +343,48 @@ unsigned int CorsairPeripheralV2Controller::GetKeyboardLayout()
     return GetAddress(0x41);
 }
 
+/*---------------------------------------------------------*\
+| GetAddress returns NA when the device answers with a      |
+|   protocol error, and a receiver whose device has not     |
+|   woken answers zero.  Straight after enumeration both    |
+|   are normal, so poll before treating either as final.    |
+\*---------------------------------------------------------*/
+unsigned int CorsairPeripheralV2Controller::GetAddressRetry(uint8_t address)
+{
+    unsigned int value = NA;
+
+    for(unsigned int attempt = 0; attempt < CORSAIR_V2_PID_RETRIES; attempt++)
+    {
+        value = GetAddress(address);
+
+        if(value != NA && value != 0)
+        {
+            return value;
+        }
+
+        if(attempt + 1 < CORSAIR_V2_PID_RETRIES)
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(CORSAIR_V2_PID_RETRY_DELAY));
+        }
+    }
+
+    return value;
+}
+
 unsigned int CorsairPeripheralV2Controller::GetAddress(uint8_t address)
 {
-    uint8_t buffer[CORSAIR_V2_WRITE_SIZE];
-    uint8_t read[CORSAIR_V2_WRITE_SIZE];
+    uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
+    uint8_t read[CORSAIR_V2_PACKET_SIZE];
 
-    memset(buffer, 0, CORSAIR_V2_WRITE_SIZE);
-    memset(read, 0, CORSAIR_V2_WRITE_SIZE);
+    memset(buffer, 0, pkt_sze);
+    memset(read, 0, pkt_sze);
 
     buffer[1]   = write_cmd;
     buffer[2]   = CORSAIR_V2_CMD_GET;
     buffer[3]   = address;
 
-    hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
-    hid_read_timeout(dev, read, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+    hid_write(dev, buffer, pkt_sze);
+    hid_read_timeout(dev, read, pkt_sze, CORSAIR_V2_TIMEOUT);
 
     unsigned int temp = (unsigned int)(read[6] << 24 | read[5] << 16 | read[4] << 8 | read[3]);
     LOG_DEBUG("[%s] GetAddress %02X - %02X %02X - %02X %02X %02X %02X   %02X %02X %02X %02X", device_name.c_str(),
@@ -247,20 +402,20 @@ unsigned int CorsairPeripheralV2Controller::GetAddress(uint8_t address)
 
 unsigned char CorsairPeripheralV2Controller::StartTransaction(uint8_t opt1)
 {
-    uint8_t buffer[CORSAIR_V2_WRITE_SIZE];
+    uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
 
-    memset(buffer, 0, CORSAIR_V2_WRITE_SIZE);
+    memset(buffer, 0, pkt_sze);
 
     buffer[1]   = write_cmd;
     buffer[2]   = CORSAIR_V2_CMD_START_TX;
     buffer[3]   = opt1;
     buffer[4]   = light_ctrl;
 
-    hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
+    hid_write(dev, buffer, pkt_sze);
 
     if(!skip_reads)
     {
-        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT);
     }
 
     return buffer[2];
@@ -268,20 +423,20 @@ unsigned char CorsairPeripheralV2Controller::StartTransaction(uint8_t opt1)
 
 void CorsairPeripheralV2Controller::StopTransaction(uint8_t opt1)
 {
-    uint8_t buffer[CORSAIR_V2_WRITE_SIZE];
+    uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
 
-    memset(buffer, 0, CORSAIR_V2_WRITE_SIZE);
+    memset(buffer, 0, pkt_sze);
 
     buffer[1]   = write_cmd;
     buffer[2]   = CORSAIR_V2_CMD_STOP_TX;
     buffer[3]   = 0x01;
     buffer[4]   = opt1;
 
-    hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
+    hid_write(dev, buffer, pkt_sze);
 
     if(!skip_reads)
     {
-        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT);
     }
 }
 
@@ -295,6 +450,11 @@ void CorsairPeripheralV2Controller::ClearPacketBuffer()
     uint8_t result          = 0;
     uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
 
+    /*---------------------------------------------------------*\
+    | Draining expects to find nothing, so the last read here    |
+    |   always waits out the timeout.  Keep it short: this runs  |
+    |   before every LED update.                                 |
+    \*---------------------------------------------------------*/
     do
     {
         result = hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT_SHORT);
@@ -304,6 +464,8 @@ void CorsairPeripheralV2Controller::ClearPacketBuffer()
 
 void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
 {
+    std::lock_guard<std::mutex> lock(device_mutex);
+
     const uint8_t offset1   = 8;
     const uint8_t offset2   = 4;
     uint16_t remaining      = data_size;
@@ -337,7 +499,7 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
 
     if(!skip_reads)
     {
-        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT_SHORT);
+        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT);
     }
 
     remaining              -= copy_bytes;
@@ -362,7 +524,7 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
 
         if(!skip_reads)
         {
-            hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT_SHORT);
+            hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT);
         }
 
         remaining          -= copy_bytes;
@@ -374,6 +536,8 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
 void CorsairPeripheralV2Controller::UpdateHWMode(uint16_t mode, corsair_v2_color /*color_mode*/, uint8_t /*speed*/,
                                                  uint8_t /*direction*/, uint8_t /*brightness*/, std::vector<RGBColor> /*colors*/)
 {
+    std::lock_guard<std::mutex> lock(device_mutex);
+
     /*---------------------------------------------------------*\
     | If we are switching to `Direct` mode                      |
     |   set device in software mode                             |

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.h

@@ -12,6 +12,7 @@
 #pragma once
 
 #include <string>
+#include <mutex>
 #include <vector>
 #include <hidapi.h>
 #include "LogManager.h"
@@ -21,13 +22,33 @@
 #define NA                              0xFFFFFFFF
 #define HID_MAX_STR                     255
 
-#define CORSAIR_V2_TIMEOUT              50
+/*---------------------------------------------------------*\
+| A jumbo packet device answers a 1KB command in well over  |
+|   50ms.  Missing the reply leaves it queued and the next  |
+|   write to the device then fails outright, so this has to |
+|   be generous.  A reply that does arrive is returned as   |
+|   soon as it lands, so this only costs time on failure.   |
+\*---------------------------------------------------------*/
+#define CORSAIR_V2_TIMEOUT              500
 #define CORSAIR_V2_TIMEOUT_SHORT        3
 #define CORSAIR_V2_VALUE_MODE           3
 #define CORSAIR_V2_WRITE_WIRED_ID       8
 #define CORSAIR_V2_WRITE_WIRELESS_ID    9
 #define CORSAIR_V2_WRITE_SIZE           65
-#define CORSAIR_V2_PACKET_SIZE          1024
+/*---------------------------------------------------------*\
+| Largest packet the protocol uses: 1024 payload bytes      |
+|   plus the leading report ID.  pkt_sze is measured        |
+|   against this, and every stack buffer handed to hidapi   |
+|   with pkt_sze is this size, so the two must agree.       |
+\*---------------------------------------------------------*/
+#define CORSAIR_V2_PACKET_SIZE          1025
+
+/*---------------------------------------------------------*\
+| Error codes the device returns in byte 2 of a reply.      |
+\*---------------------------------------------------------*/
+#define CORSAIR_V2_ERR_INVALID          0x01
+#define CORSAIR_V2_ERR_FAILED           0x03
+#define CORSAIR_V2_ERR_NOT_SUPPORTED    0x06
 
 #define CORSAIR_V2_LIGHT_CTRL1          1
 #define CORSAIR_V2_LIGHT_CTRL2          34          /* 0x22                             */
@@ -37,6 +58,19 @@
 #define CORSAIR_V2_BRIGHTNESS_MIN       0
 #define CORSAIR_V2_BRIGHTNESS_MAX       0xFF
 
+/*---------------------------------------------------------*\
+| A device that has just enumerated does not answer the PID |
+|   query straight away, so retry before giving up on it.   |
+\*---------------------------------------------------------*/
+#define CORSAIR_V2_PID_RETRIES          8
+#define CORSAIR_V2_PID_RETRY_DELAY      120
+
+/*---------------------------------------------------------*\
+| device_index when the PID is not in the device list.      |
+|   Never index the device list with it.                    |
+\*---------------------------------------------------------*/
+#define CORSAIR_V2_DEVICE_NOT_FOUND     0xFFFF
+
 enum corsair_v2_cmd
 {
     CORSAIR_V2_CMD_SET                  = 0x01,     /* Command for setting values       */
@@ -84,6 +118,7 @@ public:
     std::string                     GetName();
     std::string                     GetSerialString();
     const corsair_v2_device*        GetDeviceData();
+    bool                            IsDeviceSupported();
     unsigned int                    GetKeyboardLayout();
 
     void                            SetRenderMode(corsair_v2_device_mode mode);
@@ -99,14 +134,46 @@ protected:
     std::string                     device_name;
     uint8_t                         light_ctrl          = CORSAIR_V2_LIGHT_CTRL2;
 
+    /*---------------------------------------------------------*\
+    | Works out which lighting control endpoint the device       |
+    |   accepts.  Must be called only once the device has been   |
+    |   put into software render mode: endpoint 2 rejects the    |
+    |   transaction while the device is still driving its own    |
+    |   lighting, which would pick endpoint 1 for a device that  |
+    |   does not support it.                                     |
+    \*---------------------------------------------------------*/
+    void                            DetectLightingEndpoint();
+
+    /*---------------------------------------------------------*\
+    | Size of one output report, plus the leading report ID.     |
+    |   Read from the HID report descriptor before anything is   |
+    |   sent: these devices come in a 64 byte and a 1024 byte    |
+    |   flavour, and sending a short packet to a 1024 byte       |
+    |   endpoint wedges it until the device is reset, so the     |
+    |   size has to be known before the first write rather than  |
+    |   inferred from a reply.  Returns 0 if it cannot be read.  |
+    \*---------------------------------------------------------*/
+    uint16_t                        GetOutputReportSize();
+
 private:
     void                            ClearPacketBuffer();
     unsigned int                    GetAddress(uint8_t address);
+    unsigned int                    GetAddressRetry(uint8_t address);
     unsigned char                   StartTransaction(uint8_t opt1);
     void                            StopTransaction(uint8_t opt1);
 
     hid_device*                     dev;
 
+    /*---------------------------------------------------------*\
+    | Serialises device transactions.                           |
+    |   The RGB controllers run a keepalive thread that writes  |
+    |   LEDs independently of the caller, and a Corsair block   |
+    |   write spans several packets.  Letting two of those      |
+    |   interleave on one HID handle corrupts the transaction   |
+    |   and leaves the device unresponsive until it is reset.   |
+    \*---------------------------------------------------------*/
+    std::mutex                      device_mutex;
+
     uint8_t                         write_cmd           = CORSAIR_V2_WRITE_WIRED_ID;
     uint16_t                        pkt_sze             = CORSAIR_V2_WRITE_SIZE;
     bool                            skip_reads          = false;

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2ControllerDetect.cpp

@@ -12,6 +12,7 @@
 \*---------------------------------------------------------*/
 #include <hidapi.h>
 #include "DetectionManager.h"
+#include "LogManager.h"
 
 /*---------------------------------------------------------*\
 | Corsair Peripheral specific includes                      |
@@ -37,6 +38,20 @@ DetectedControllers DetectCorsairV2HardwareControllers(hid_device_info* info, co
     if(dev)
     {
         CorsairPeripheralV2HWController*    controller      = new CorsairPeripheralV2HWController(dev, info->path, name);
+
+        /*---------------------------------------------------------*\
+        | A device whose PID is not in the device list has no       |
+        |   zone or LED data to build an RGBController from.        |
+        |   Drop it here: building one anyway indexes the device    |
+        |   list with an index that was never set.                  |
+        \*---------------------------------------------------------*/
+        if(!controller->IsDeviceSupported())
+        {
+            LOG_WARNING("[%s] not registering device, capabilities unknown.", name.c_str());
+            delete controller;
+            return(detected_controllers);
+        }
+
         RGBController_CorsairV2HW*          rgb_controller  = new RGBController_CorsairV2HW(controller);
 
         detected_controllers.push_back(rgb_controller);
@@ -55,6 +70,14 @@ DetectedControllers DetectCorsairV2SoftwareControllers(hid_device_info* info, co
     if(dev)
     {
         CorsairPeripheralV2SWController*    controller      = new CorsairPeripheralV2SWController(dev, info->path, name);
+
+        if(!controller->IsDeviceSupported())
+        {
+            LOG_WARNING("[%s] not registering device, capabilities unknown.", name.c_str());
+            delete controller;
+            return(detected_controllers);
+        }
+
         RGBController_CorsairV2SW*          rgb_controller  = new RGBController_CorsairV2SW(controller);
 
         detected_controllers.push_back(rgb_controller);
@@ -69,6 +92,7 @@ DetectedControllers DetectCorsairV2SoftwareControllers(hid_device_info* info, co
 REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K55_RGB_PRO_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K57 RGB (Wired)",                 DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K57_RGB_WIRED_PID,              1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_PID,                1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO SE",                  DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_SE_PID,             1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO Low Profile",         DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_LP_PID,             1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO TKL Black",           DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_TKL_B_PID,          1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO TKL White",           DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_TKL_W_PID,          1,  0xFF42);
@@ -91,6 +115,8 @@ REGISTER_HID_DETECTOR_IP("Corsair Dark Core RGB SE (Wired)",        DetectCorsai
 REGISTER_HID_DETECTOR_IP("Corsair Dark Core RGB Pro SE (Wired)",    DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_DARK_CORE_RGB_PRO_PID,          1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Harpoon Wireless (Wired)",        DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_HARPOON_WIRELESS_PID,           1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Ironclaw Wireless (Wired)",       DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_IRONCLAW_WIRELESS_PID,          1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair Ironclaw Wireless SE (Wired)",    DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_IRONCLAW_WIRELESS_SE_PID,       1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair Ironclaw Wireless SE",            DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_SLIPSTREAM_IRONCLAW_SE_PID,     1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Katar Pro",                       DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_KATAR_PRO_PID,                  1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Katar Pro V2",                    DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_KATAR_PRO_V2_PID,               1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Katar Pro XT",                    DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_KATAR_PRO_XT_PID,               1,  0xFF42);
@@ -98,6 +124,8 @@ REGISTER_HID_DETECTOR_IP("Corsair M55 RGB PRO",                     DetectCorsai
 REGISTER_HID_DETECTOR_IP("Corsair M65 RGB Ultra Wired",             DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_M65_RGB_ULTRA_WIRED_PID,        1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair M65 RGB Ultra Wireless (Wired)",  DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_M65_RGB_ULTRA_WIRELESS_PID,     1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair M75 Gaming Mouse",                DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_M75_GAMING_MOUSE_PID,           1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair M75 Wireless",                    DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_SLIPSTREAM_M75_PID,             1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair M75 Wireless (Wired)",            DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_M75_WIRELESS_PID,               1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Slipstream Wireless Receiver HW", DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_SLIPSTREAM_WIRELESS_PID1,       1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Slipstream Wireless Receiver SW", DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_SLIPSTREAM_WIRELESS_PID2,       1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Slipstream Wireless Receiver HW", DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_SLIPSTREAM_WIRELESS_V2_PID1,    1,  0xFF42);

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.cpp

@@ -638,6 +638,71 @@ static const corsair_v2_device ironclaw_wireless_device =
     nullptr
 };
 
+/*-------------------------------------------------------------*\
+|  Corsair Ironclaw Wireless SE 1B1C:2B32                       |
+|                                                               |
+|  Zone "Logo"                                                  |
+|       Single                                                  |
+|                                                               |
+|  Zone "Scroll Wheel"                                          |
+|       Single                                                  |
+|                                                               |
+|  Zone "Buttons"                                               |
+|       Single                                                  |
+|                                                               |
+|  Zone "Side"                                                  |
+|       Linear                                                  |
+|       1 Row, 3 Columns                                        |
+\*-------------------------------------------------------------*/
+static const corsair_v2_zone ironclaw_se_logo_zone =
+{
+    "Logo",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_zone ironclaw_se_scroll_zone =
+{
+    "Scroll Wheel",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_zone ironclaw_se_button_zone =
+{
+    "Buttons",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_zone ironclaw_se_side_zone =
+{
+    "Side Zone",
+    ZONE_TYPE_LINEAR,
+    1,
+    3
+};
+
+static const corsair_v2_device ironclaw_wireless_se_device =
+{
+    CORSAIR_IRONCLAW_WIRELESS_SE_PID,
+    DEVICE_TYPE_MOUSE,
+    1,
+    6,
+    {
+        &ironclaw_se_logo_zone,
+        &ironclaw_se_scroll_zone,
+        &ironclaw_se_button_zone,
+        &ironclaw_se_side_zone,
+        nullptr,
+        nullptr
+    },
+    nullptr
+};
+
 /*-------------------------------------------------------------*\
 |  Corsair Katar Pro 1B1C:1B93                                  |
 |                                                               |
@@ -836,7 +901,7 @@ static const corsair_v2_device k57_rgb_wired_device =
 |                                                               |
 |  Zone "Keyboard"                                              |
 |       Matrix                                                  |
-|       6 Rows, 21 Columns                                      |
+|       7 Rows, 22 Columns                                      |
 \*-------------------------------------------------------------*/
 static const corsair_v2_zone k60_rgb_pro_zone =
 {
@@ -863,12 +928,34 @@ static const corsair_v2_device k60_rgb_pro_device =
     &corsair_K60_layout
 };
 
+/*-------------------------------------------------------------*\
+|  Corsair K60 RGB Pro SE 1B1C:1B8D                             |
+|                                                               |
+|  Initial implementation reuses K60 RGB Pro zone/layout        |
+\*-------------------------------------------------------------*/
+static const corsair_v2_device k60_rgb_pro_se_device =
+{
+    CORSAIR_K60_RGB_PRO_SE_PID,
+    DEVICE_TYPE_KEYBOARD,
+    6,
+    21,
+    {
+        &k60_rgb_pro_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    &corsair_K60_layout
+};
+
 /*-------------------------------------------------------------*\
 |  Corsair K60 RGB Pro Low Profile 1B1C:1BAD                    |
 |                                                               |
 |  Zone "Keyboard"                                              |
 |       Matrix                                                  |
-|       6 Rows, 21 Columns                                      |
+|       7 Rows, 22 Columns                                      |
 \*-------------------------------------------------------------*/
 static const corsair_v2_zone k60_rgb_pro_lp_zone =
 {
@@ -901,7 +988,7 @@ static const corsair_v2_device k60_rgb_pro_lp_device =
 |                                                               |
 |  Zone "Keyboard"                                              |
 |       Matrix                                                  |
-|       6 Rows, 21 Columns                                      |
+|       7 Rows, 22 Columns                                      |
 \*-------------------------------------------------------------*/
 static const corsair_v2_zone k60_rgb_pro_tkl_zone =
 {
@@ -951,7 +1038,7 @@ static const corsair_v2_device k60_rgb_pro_tkl_device_w =
 |                                                               |
 |  Zone "Keyboard"                                              |
 |       Matrix                                                  |
-|       6 Rows, 21 Columns                                      |
+|       7 Rows, 22 Columns                                      |
 \*-------------------------------------------------------------*/
 static const corsair_v2_zone k70_core_rgb_zone =
 {
@@ -1080,14 +1167,14 @@ static const corsair_v2_device k70_rgb_tkl_cs_device =
 |                                                               |
 |  Zone "Keyboard"                                              |
 |       Matrix                                                  |
-|       6 Rows, 21 Columns                                      |
+|       7 Rows, 22 Columns                                      |
 \*-------------------------------------------------------------*/
 static const corsair_v2_zone k70_rgb_pro_zone =
 {
     ZONE_EN_KEYBOARD,
     ZONE_TYPE_MATRIX,
     7,
-    21
+    22
 };
 
 static const corsair_v2_device k70_rgb_pro_device =
@@ -1095,7 +1182,7 @@ static const corsair_v2_device k70_rgb_pro_device =
     CORSAIR_K70_RGB_PRO_PID,
     DEVICE_TYPE_KEYBOARD,
     7,
-    21,
+    22,
     {
         &k70_rgb_pro_zone,
         nullptr,
@@ -1112,14 +1199,14 @@ static const corsair_v2_device k70_rgb_pro_device =
 |                                                               |
 |  Zone "Keyboard"                                              |
 |       Matrix                                                  |
-|       6 Rows, 21 Columns                                      |
+|       7 Rows, 22 Columns                                      |
 \*-------------------------------------------------------------*/
 static const corsair_v2_device k70_rgb_pro_v2_device =
     {
         CORSAIR_K70_RGB_PRO_V2_PID,
         DEVICE_TYPE_KEYBOARD,
         7,
-        21,
+        22,
         {
             &k70_rgb_pro_zone,
             nullptr,
@@ -1128,7 +1215,8 @@ static const corsair_v2_device k70_rgb_pro_v2_device =
             nullptr,
             nullptr
         },
-        &corsair_k70_pro_layout
+        &corsair_k70_pro_layout,
+        193
 };
 
 /*-------------------------------------------------------------*\
@@ -1443,6 +1531,44 @@ static const corsair_v2_device m75_device =
     nullptr
 };
 
+/*-------------------------------------------------------------*\
+|  Corsair M75 Wireless 1B1C:1BF1                               |
+|                                                               |
+|  Reached through the Slipstream receiver 1B1C:1BDC, which     |
+|  reports the mouse PID 0x1BF1 once the write command is       |
+|  switched to the wireless ID.                                 |
+|                                                               |
+|  Zone "Logo"                                                  |
+|       Single                                                  |
+|                                                               |
+|  Zone "Bottom"                                                |
+|       Single                                                  |
+\*-------------------------------------------------------------*/
+static const corsair_v2_zone m75_wireless_bottom_zone =
+{
+    "Bottom",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const corsair_v2_device m75_wireless_device =
+{
+    CORSAIR_M75_WIRELESS_PID,
+    DEVICE_TYPE_MOUSE,
+    1,
+    2,
+    {
+        &m75_logo_zone,
+        &m75_wireless_bottom_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    nullptr
+};
+
 /*-------------------------------------------------------------*\
 |  Corsair MM700 1B1C:1B9B                                      |
 |                                                               |
@@ -1522,6 +1648,7 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
     &k55_rgb_pro_device,
     &k57_rgb_wired_device,
     &k60_rgb_pro_device,
+    &k60_rgb_pro_se_device,
     &k60_rgb_pro_lp_device,
     &k60_rgb_pro_tkl_device_b,
     &k60_rgb_pro_tkl_device_w,
@@ -1543,6 +1670,7 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
     &dark_core_pro_se_device,
     &harpoon_wireless_device,
     &ironclaw_wireless_device,
+    &ironclaw_wireless_se_device,
     &katar_pro_device,
     &katar_pro_v2_device,
     &katar_pro_xt_device,
@@ -1550,6 +1678,7 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
     &m65_rgb_ultra_wired_device,
     &m65_ultra_rgb_device,
     &m75_device,
+    &m75_wireless_device,
 
 /*-----------------------------------------------------------------*\
 |  MOUSEMATS                                                        |

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.h

@@ -63,6 +63,15 @@ typedef struct
     uint8_t                             cols;
     const corsair_v2_zone*              zones[CORSAIR_ZONES_MAX];
     keyboard_keymap_overlay_values*     layout_new;
+    /*-------------------------------------------------------*\
+    | Number of LED slots the device expects in a direct       |
+    |   lighting write.  The keymap only covers the keys that  |
+    |   exist, but the device wants its full slot count and    |
+    |   ignores a short write, so the buffer map is padded up  |
+    |   to this.  Left 0 where the count is not known, which   |
+    |   keeps the keymap derived size.                         |
+    \*-------------------------------------------------------*/
+    uint16_t                            hw_led_count;
 }   corsair_v2_device;
 
 /*-----------------------------------------------------*\
@@ -72,6 +81,7 @@ typedef struct
 #define CORSAIR_K57_RGB_WIRED_PID                   0x1B6E
 #define CORSAIR_K57_RGB_WIRELESS_PID                0x1B62
 #define CORSAIR_K60_RGB_PRO_PID                     0x1BA0
+#define CORSAIR_K60_RGB_PRO_SE_PID                  0x1B8D
 #define CORSAIR_K60_RGB_PRO_LP_PID                  0x1BAD
 #define CORSAIR_K60_RGB_PRO_TKL_B_PID               0x1BC7
 #define CORSAIR_K60_RGB_PRO_TKL_W_PID               0x1BED
@@ -93,6 +103,8 @@ typedef struct
 #define CORSAIR_DARK_CORE_RGB_PRO_PID               0x1B7E
 #define CORSAIR_HARPOON_WIRELESS_PID                0x1B5E
 #define CORSAIR_IRONCLAW_WIRELESS_PID               0x1B4C
+#define CORSAIR_IRONCLAW_WIRELESS_SE_PID            0x2B32
+#define CORSAIR_SLIPSTREAM_IRONCLAW_SE_PID          0x2B00
 #define CORSAIR_KATAR_PRO_PID                       0x1B93
 #define CORSAIR_KATAR_PRO_V2_PID                    0x1BBA
 #define CORSAIR_KATAR_PRO_XT_PID                    0x1BAC
@@ -100,6 +112,8 @@ typedef struct
 #define CORSAIR_M65_RGB_ULTRA_WIRED_PID             0x1B9E
 #define CORSAIR_M65_RGB_ULTRA_WIRELESS_PID          0x1BB5
 #define CORSAIR_M75_GAMING_MOUSE_PID                0x1BF0
+#define CORSAIR_M75_WIRELESS_PID                    0x1BF1
+#define CORSAIR_SLIPSTREAM_M75_PID                  0x1BDC
 #define CORSAIR_SLIPSTREAM_WIRELESS_PID1            0x1BA6
 #define CORSAIR_SLIPSTREAM_WIRELESS_V2_PID1         0x1B66
 #define CORSAIR_SLIPSTREAM_WIRELESS_PID2            0x1B65

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2HardwareController.cpp

@@ -16,6 +16,12 @@ CorsairPeripheralV2HWController::CorsairPeripheralV2HWController(hid_device* dev
 {
     SetRenderMode(CORSAIR_V2_MODE_SW);
     LightingControl(0x5F);
+
+    /*---------------------------------------------------------*\
+    | Only now that the device is in software render mode can   |
+    |   its lighting control endpoint be probed reliably.       |
+    \*---------------------------------------------------------*/
+    DetectLightingEndpoint();
 }
 
 CorsairPeripheralV2HWController::~CorsairPeripheralV2HWController()

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2SoftwareController.cpp

@@ -16,6 +16,12 @@ CorsairPeripheralV2SWController::CorsairPeripheralV2SWController(hid_device* dev
 {
     SetRenderMode(CORSAIR_V2_MODE_SW);
     LightingControl(0x5F);
+
+    /*---------------------------------------------------------*\
+    | Only now that the device is in software render mode can   |
+    |   its lighting control endpoint be probed reliably.       |
+    \*---------------------------------------------------------*/
+    DetectLightingEndpoint();
 }
 
 CorsairPeripheralV2SWController::~CorsairPeripheralV2SWController()

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Hardware.cpp

@@ -66,21 +66,32 @@ RGBController_CorsairV2HW::RGBController_CorsairV2HW(CorsairPeripheralV2Controll
     | to not revert back into rainbow mode.  Start a thread |
     | to continuously send a keepalive packet every 50 sec  |
     \*-----------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Start the keepalive clock before the thread runs.     |
+    |   A default constructed time_point sits at the clock  |
+    |   epoch, which is always older than the update        |
+    |   period, so the thread would otherwise fire a write  |
+    |   on its first pass - during detection, racing        |
+    |   whatever the caller is doing.                       |
+    \*-----------------------------------------------------*/
+    last_update_time                    = std::chrono::steady_clock::now();
+
     keepalive_thread_run                = true;
     keepalive_thread                    = new std::thread(&RGBController_CorsairV2HW::KeepaliveThread, this);
 }
 
 RGBController_CorsairV2HW::~RGBController_CorsairV2HW()
 {
-    Shutdown();
-
     /*-----------------------------------------------------*\
-    | Close keepalive thread                                |
+    | Close keepalive thread first, so that it cannot issue |
+    |   a write while the device is being shut down.        |
     \*-----------------------------------------------------*/
     keepalive_thread_run = false;
     keepalive_thread->join();
     delete keepalive_thread;
 
+    Shutdown();
+
     delete controller;
 }
 
@@ -198,6 +209,15 @@ void RGBController_CorsairV2HW::SetupZones()
 
     SetupColors();
 
+    /*---------------------------------------------------------*\
+    | Pad out to the slot count the device expects.  A write    |
+    |   that is short of it is ignored by the hardware.         |
+    \*---------------------------------------------------------*/
+    if(corsair->hw_led_count > max_led_value)
+    {
+        max_led_value                   = corsair->hw_led_count;
+    }
+
     /*---------------------------------------------------------*\
     | Create a buffer map of pointers which contains the        |
     |   layout order of colors the device expects.              |

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Software.cpp

@@ -53,21 +53,32 @@ RGBController_CorsairV2SW::RGBController_CorsairV2SW(CorsairPeripheralV2Controll
     | to not revert back into rainbow mode.  Start a thread |
     | to continuously send a keepalive packet every 50 sec  |
     \*-----------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Start the keepalive clock before the thread runs.     |
+    |   A default constructed time_point sits at the clock  |
+    |   epoch, which is always older than the update        |
+    |   period, so the thread would otherwise fire a write  |
+    |   on its first pass - during detection, racing        |
+    |   whatever the caller is doing.                       |
+    \*-----------------------------------------------------*/
+    last_update_time                    = std::chrono::steady_clock::now();
+
     keepalive_thread_run                = true;
     keepalive_thread                    = new std::thread(&RGBController_CorsairV2SW::KeepaliveThread, this);
 }
 
 RGBController_CorsairV2SW::~RGBController_CorsairV2SW()
 {
-    Shutdown();
-
     /*-----------------------------------------------------*\
-    | Close keepalive thread                                |
+    | Close keepalive thread first, so that it cannot issue |
+    |   a write while the device is being shut down.        |
     \*-----------------------------------------------------*/
     keepalive_thread_run = false;
     keepalive_thread->join();
     delete keepalive_thread;
 
+    Shutdown();
+
     delete controller;
 }
 
@@ -185,6 +196,15 @@ void RGBController_CorsairV2SW::SetupZones()
 
     SetupColors();
 
+    /*---------------------------------------------------------*\
+    | Pad out to the slot count the device expects.  A write    |
+    |   that is short of it is ignored by the hardware.         |
+    \*---------------------------------------------------------*/
+    if(corsair->hw_led_count > max_led_value)
+    {
+        max_led_value                   = corsair->hw_led_count;
+    }
+
     /*---------------------------------------------------------*\
     | Create a buffer map of pointers which contains the        |
     |   layout order of colors the device expects.              |

Controllers/CreativeController/CreativeSoundBlasterAE5Controller/CreativeSoundBlasterAE5ControllerDetect_Windows.cpp

@@ -16,13 +16,10 @@ DetectedControllers DetectCreativeAE5Device()
 {
     DetectedControllers detected_controllers;
 
-    LOG_INFO("[Creative SoundBlaster AE-5] Windows detection function called");
-
     CreativeSoundBlasterAE5Controller_Windows* controller = new CreativeSoundBlasterAE5Controller_Windows();
 
     if(controller->Initialize())
     {
-        LOG_INFO("[Creative SoundBlaster AE-5] Device initialized successfully, registering controller");
         RGBController_CreativeSoundBlasterAE5* rgb_controller = new RGBController_CreativeSoundBlasterAE5(controller);
 
         detected_controllers.push_back(rgb_controller);

Controllers/CreativeController/CreativeSoundBlasterXG6Controller/CreativeSoundBlasterXG6ControllerDetect.cpp

@@ -1,7 +1,7 @@
 /*---------------------------------------------------------*\
-| CreativeControllerDetect.cpp                              |
+| CreativeSoundBlasterXG6ControllerDetect.cpp               |
 |                                                           |
-|   Detector for Creative devices                           |
+|   Detector for Creative Sound Blaster XG6 devices         |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -15,14 +15,14 @@
 /*---------------------------------------------------------*\
 | Creative vendor ID                                        |
 \*---------------------------------------------------------*/
-#define CREATIVE_VID                            0x041E
+#define CREATIVE_VID                                0x041E
 
 /*---------------------------------------------------------*\
-| SoundCards                                                |
+| Creative Sound Blaster XG6 product ID                     |
 \*---------------------------------------------------------*/
-#define CREATIVE_SOUNDBLASTERX_G6_PID           0x3256
+#define CREATIVE_SOUNDBLASTERX_G6_PID               0x3256
 
-DetectedControllers DetectCreativeDevice(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCreativeSoundBlasterXG6Device(hid_device_info* info, const std::string& name)
 {
     DetectedControllers detected_controllers;
     hid_device*         dev;
@@ -40,7 +40,7 @@ DetectedControllers DetectCreativeDevice(hid_device_info* info, const std::strin
     return(detected_controllers);
 }
 
-/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Sound Cards                                                                                                                                       |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_I("Creative SoundBlasterX G6",               DetectCreativeDevice,         CREATIVE_VID,     CREATIVE_SOUNDBLASTERX_G6_PID, 4);
+/*---------------------------------------------------------*\
+| Sound Cards                                               |
+\*---------------------------------------------------------*/
+REGISTER_HID_DETECTOR_I("Creative SoundBlasterX G6",    DetectCreativeSoundBlasterXG6Device,    CREATIVE_VID,     CREATIVE_SOUNDBLASTERX_G6_PID, 4);

Controllers/DDPController/RGBController_DDP.cpp

@@ -59,15 +59,57 @@ RGBController_DDP::~RGBController_DDP()
 
 void RGBController_DDP::SetupZones()
 {
-    for(unsigned int zone_idx = 0; zone_idx < devices.size(); zone_idx++)
+    /*-----------------------------------------------------*\
+    | Only set LED count on the first run                   |
+    \------------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
     {
-        zone led_zone;
-        led_zone.name           = devices[zone_idx].name;
-        led_zone.type           = ZONE_TYPE_LINEAR;
-        led_zone.leds_min       = devices[zone_idx].num_leds;
-        led_zone.leds_max       = devices[zone_idx].num_leds;
-        led_zone.leds_count     = devices[zone_idx].num_leds;
-        zones.push_back(led_zone);
+        first_run = true;
+    }
+
+    /*-----------------------------------------------------*\
+    | Clear any existing color/LED configuration            |
+    \------------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+    zones.resize(devices.size());
+
+    /*-----------------------------------------------------*\
+    | Set zones and leds                                    |
+    \------------------------------------------------------*/
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        zones[zone_idx].leds_min                = devices[zone_idx].num_leds;
+        zones[zone_idx].leds_max                = devices[zone_idx].num_leds;
+
+        if(first_run)
+        {
+            zones[zone_idx].flags               = ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
+                                                | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
+                                                | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
+        }
+
+        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
+        {
+            zones[zone_idx].name                = devices[zone_idx].name;
+        }
+
+        zones[zone_idx].leds_count              = devices[zone_idx].num_leds;
+
+        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
+        {
+            zones[zone_idx].type                = ZONE_TYPE_LINEAR;
+        }
+
+        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
+        {
+            zones[zone_idx].matrix_map.width    = 0;
+            zones[zone_idx].matrix_map.height   = 0;
+            zones[zone_idx].matrix_map.map.resize(0);
+        }
     }
 
     for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
@@ -75,14 +117,22 @@ void RGBController_DDP::SetupZones()
         for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
         {
             led new_led;
-            new_led.name = zones[zone_idx].name + " LED " + std::to_string(led_idx + 1);
-            new_led.value = 0;
+            new_led.name                        = zones[zone_idx].name + " LED " + std::to_string(led_idx + 1);
             leds.push_back(new_led);
         }
     }
+
     SetupColors();
 }
 
+void RGBController_DDP::DeviceConfigureZone(int zone_idx)
+{
+    if((size_t)zone_idx < zones.size())
+    {
+        SetupZones();
+    }
+}
+
 void RGBController_DDP::DeviceUpdateLEDs()
 {
     std::vector<unsigned int> brightness_adjusted_colors;

Controllers/DDPController/RGBController_DDP.h

@@ -21,6 +21,8 @@ public:
 
     void        SetupZones();
 
+    void        DeviceConfigureZone(int zone_idx);
+
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);
     void        DeviceUpdateSingleLED(int led);

Controllers/DygmaRaiseController/DygmaRaiseControllerDetect.cpp

@@ -40,8 +40,4 @@ DetectedControllers DetectDygmaRaiseControllers()
 }
 
 REGISTER_DETECTOR("Dygma Raise", DetectDygmaRaiseControllers);
-/*---------------------------------------------------------------------------------------------------------*\
-| Entries for dynamic UDEV rules                                                                            |
-|                                                                                                           |
-| DUMMY_DEVICE_DETECTOR("Dygma Raise", DetectDygmaRaiseControllers, 0x1209, 0x2201 )                        |
-\*---------------------------------------------------------------------------------------------------------*/
+REGISTER_CUSTOM_UDEV_RULE(dygma_raise, "Dygma Raise", "SUBSYSTEMS==\"serial|hidraw\", ATTRS{idVendor}==\"1209\", ATTRS{idProduct}==\"2201\", TAG+=\"uaccess\", TAG+=\"Dygma_Raise\"");

Controllers/E131Controller/RGBController_E131.cpp

@@ -223,33 +223,68 @@ RGBController_E131::~RGBController_E131()
 void RGBController_E131::SetupZones()
 {
     /*-----------------------------------------------------*\
-    | Add Zones                                             |
+    | Only set LED count on the first run                   |
     \*-----------------------------------------------------*/
-    for(std::size_t zone_idx = 0; zone_idx < devices.size(); zone_idx++)
-    {
-        zone led_zone;
-        led_zone.name           = devices[zone_idx].name;
-        led_zone.type           = ZONE_TYPE_LINEAR;
-        led_zone.leds_min       = devices[zone_idx].num_leds;
-        led_zone.leds_max       = devices[zone_idx].num_leds;
-        led_zone.leds_count     = devices[zone_idx].num_leds;
-        led_zone.flags          = ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
+    bool first_run = false;
 
-        zones.push_back(led_zone);
+    if(zones.size() == 0)
+    {
+        first_run = true;
     }
 
     /*-----------------------------------------------------*\
-    | Add LEDs                                              |
+    | Clear any existing color/LED configuration            |
     \*-----------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+    zones.resize(devices.size());
+
+    /*-----------------------------------------------------*\
+    | Set zones and leds                                    |
+    \*-----------------------------------------------------*/
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        zones[zone_idx].leds_min                = devices[zone_idx].num_leds;
+        zones[zone_idx].leds_max                = devices[zone_idx].num_leds;
+
+        if(first_run)
+        {
+            zones[zone_idx].flags               = ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
+                                                | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
+                                                | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
+        }
+
+        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
+        {
+            zones[zone_idx].name                = devices[zone_idx].name;
+        }
+
+        zones[zone_idx].leds_count = devices[zone_idx].num_leds;
+
+        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
+        {
+            zones[zone_idx].type                = ZONE_TYPE_LINEAR;
+        }
+
+        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
+        {
+            zones[zone_idx].matrix_map.width    = 0;
+            zones[zone_idx].matrix_map.height   = 0;
+            zones[zone_idx].matrix_map.map.resize(0);
+        }
+    }
+
+    /*-----------------------------------------------------*\
+     | Add LEDs                                              |
+     \*-----------------------------------------------------*/
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
         for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
         {
             led new_led;
 
-            new_led.name = zones[zone_idx].name + " LED ";
+            new_led.name                        = zones[zone_idx].name + " LED ";
             new_led.name.append(std::to_string(led_idx));
 
             leds.push_back(new_led);
@@ -259,6 +294,14 @@ void RGBController_E131::SetupZones()
     SetupColors();
 }
 
+void RGBController_E131::DeviceConfigureZone(int zone_idx)
+{
+    if((size_t)zone_idx < zones.size())
+    {
+        SetupZones();
+    }
+}
+
 void RGBController_E131::DeviceUpdateLEDs()
 {
     int color_idx = 0;

Controllers/E131Controller/RGBController_E131.h

@@ -35,6 +35,8 @@ public:
 
     void        SetupZones();
 
+    void        DeviceConfigureZone(int zone_idx);
+
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);
     void        DeviceUpdateSingleLED(int led);

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -427,6 +427,7 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5080 WHITE",
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090 OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING,           0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090",                           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING_2,         0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090 OC BTF",                    DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING_BTF,       0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090 OC BTF",                    DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING_BTF_2,     0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090 OC WHITE",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING_WHITE,     0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL LC GeForce RTX 5090 OC",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_LC_RTX_5090_O32G_GAMING,        0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL LC OC GeForce RTX 5090 OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_LC_OC_RTX_5090_O32G_GAMING,     0x67);

Controllers/EVGAUSBController/EVGAX12Controller/EVGAX12Controller.cpp

@@ -0,0 +1,268 @@
+/*---------------------------------------------------------*\
+| EVGAX12Controller.cpp                                     |
+|                                                           |
+|   Driver for the EVGA X12 gaming mouse                    |
+|                                                           |
+|   QuickMythril                               08 Aug 2026  |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <chrono>
+#include <cstring>
+#include <thread>
+#include "EVGAX12Controller.h"
+#include "LogManager.h"
+#include "StringUtils.h"
+
+#define EVGA_X12_HEADER                     0xEA
+#define EVGA_X12_DIRECTION_GET              0x01
+#define EVGA_X12_DIRECTION_SET              0x02
+#define EVGA_X12_COMMAND_MODE               0x01
+#define EVGA_X12_COMMAND_STATIC             0x02
+#define EVGA_X12_START_WITH_PROFILE         0x01
+#define EVGA_X12_READ_ATTEMPTS              5
+#define EVGA_X12_READ_DELAY_MS              5
+#define EVGA_X12_WRITE_ATTEMPTS             3
+
+static const unsigned int EVGA_X12_LED_TO_FIRMWARE_SLOT[EVGA_X12_LED_COUNT] =
+{
+    EVGA_X12_FIRMWARE_SLOT_HEAD_LEFT,
+    EVGA_X12_FIRMWARE_SLOT_WHEEL,
+    EVGA_X12_FIRMWARE_SLOT_LOGO,
+};
+
+EVGAX12Controller::EVGAX12Controller(hid_device* dev_handle, const hid_device_info& info, const std::string& dev_name)
+{
+    dev         = dev_handle;
+    location    = info.path;
+    name        = dev_name;
+}
+
+EVGAX12Controller::~EVGAX12Controller()
+{
+    hid_close(dev);
+}
+
+std::string EVGAX12Controller::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string EVGAX12Controller::GetNameString()
+{
+    return(name);
+}
+
+std::string EVGAX12Controller::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    return(StringUtils::wstring_to_string(serial_string));
+}
+
+EVGAX12LightingState EVGAX12Controller::GetLightingState()
+{
+    std::lock_guard<std::mutex> lock(device_mutex);
+    EVGAX12LightingState state = {};
+    unsigned char packet[EVGA_X12_REPORT_SIZE];
+
+    state.modes_valid = GetReport(EVGA_X12_COMMAND_MODE, packet);
+
+    if(state.modes_valid)
+    {
+        for(unsigned int led_idx = 0; led_idx < EVGA_X12_LED_COUNT; led_idx++)
+        {
+            unsigned int firmware_slot = EVGA_X12_LED_TO_FIRMWARE_SLOT[led_idx];
+            state.modes[led_idx]        = packet[4 + firmware_slot];
+        }
+    }
+
+    state.static_valid = GetReport(EVGA_X12_COMMAND_STATIC, packet);
+
+    if(state.static_valid)
+    {
+        for(unsigned int led_idx = 0; led_idx < EVGA_X12_LED_COUNT; led_idx++)
+        {
+            unsigned int firmware_slot  = EVGA_X12_LED_TO_FIRMWARE_SLOT[led_idx];
+            unsigned int offset         = 4 + (firmware_slot * 4);
+            state.brightness[led_idx]   = packet[offset];
+            state.colors[led_idx]       = ToRGBColor(packet[offset + 1], packet[offset + 2], packet[offset + 3]);
+        }
+    }
+
+    return(state);
+}
+
+bool EVGAX12Controller::SetMode(unsigned char mode)
+{
+    std::lock_guard<std::mutex> lock(device_mutex);
+    return(SetModeReport(mode));
+}
+
+bool EVGAX12Controller::SetModeReport(unsigned char mode)
+{
+    unsigned char packet[EVGA_X12_REPORT_SIZE] = {};
+
+    packet[0] = EVGA_X12_REPORT_ID;
+    packet[1] = EVGA_X12_HEADER;
+    packet[2] = EVGA_X12_DIRECTION_SET;
+    packet[3] = EVGA_X12_COMMAND_MODE;
+
+    for(unsigned int led_idx = 0; led_idx < EVGA_X12_LED_COUNT; led_idx++)
+    {
+        unsigned int firmware_slot  = EVGA_X12_LED_TO_FIRMWARE_SLOT[led_idx];
+        packet[4 + firmware_slot]   = mode;
+    }
+
+    return(SendReport(packet));
+}
+
+bool EVGAX12Controller::SetStatic(const std::vector<RGBColor>& colors, unsigned char brightness)
+{
+    if(colors.size() < EVGA_X12_LED_COUNT)
+    {
+        LOG_ERROR("[%s] Cannot set static lighting with only %u colors", name.c_str(), (unsigned int)colors.size());
+        return(false);
+    }
+
+    std::lock_guard<std::mutex> lock(device_mutex);
+    return(SetStaticReport(colors, brightness));
+}
+
+bool EVGAX12Controller::SetStaticAndActivate(const std::vector<RGBColor>& colors, unsigned char brightness)
+{
+    if(colors.size() < EVGA_X12_LED_COUNT)
+    {
+        LOG_ERROR("[%s] Cannot set static lighting with only %u colors", name.c_str(), (unsigned int)colors.size());
+        return(false);
+    }
+
+    std::lock_guard<std::mutex> lock(device_mutex);
+
+    if(!SetStaticReport(colors, brightness))
+    {
+        return(false);
+    }
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(EVGA_X12_READ_DELAY_MS));
+    return(SetModeReport(EVGA_X12_MODE_STATIC));
+}
+
+bool EVGAX12Controller::SetStaticReport(const std::vector<RGBColor>& colors, unsigned char brightness)
+{
+    unsigned char packet[EVGA_X12_REPORT_SIZE] = {};
+
+    packet[0] = EVGA_X12_REPORT_ID;
+    packet[1] = EVGA_X12_HEADER;
+    packet[2] = EVGA_X12_DIRECTION_SET;
+    packet[3] = EVGA_X12_COMMAND_STATIC;
+
+    for(unsigned int firmware_slot = 0; firmware_slot < EVGA_X12_FIRMWARE_SLOT_COUNT; firmware_slot++)
+    {
+        packet[20 + firmware_slot] = EVGA_X12_START_WITH_PROFILE;
+    }
+
+    for(unsigned int led_idx = 0; led_idx < EVGA_X12_LED_COUNT; led_idx++)
+    {
+        unsigned int firmware_slot  = EVGA_X12_LED_TO_FIRMWARE_SLOT[led_idx];
+        unsigned int offset         = 4 + (firmware_slot * 4);
+        packet[offset]              = brightness;
+        packet[offset + 1]          = RGBGetRValue(colors[led_idx]);
+        packet[offset + 2]          = RGBGetGValue(colors[led_idx]);
+        packet[offset + 3]          = RGBGetBValue(colors[led_idx]);
+    }
+
+    for(unsigned int attempt = 0; attempt < EVGA_X12_WRITE_ATTEMPTS; attempt++)
+    {
+        if(!SendReport(packet))
+        {
+            return(false);
+        }
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(EVGA_X12_READ_DELAY_MS));
+
+        unsigned char reply[EVGA_X12_REPORT_SIZE];
+
+        if(GetReport(EVGA_X12_COMMAND_STATIC, reply))
+        {
+            bool matches = true;
+
+            for(unsigned int firmware_slot = 0; firmware_slot < EVGA_X12_FIRMWARE_SLOT_COUNT; firmware_slot++)
+            {
+                unsigned int offset = 4 + (firmware_slot * 4);
+
+                if(std::memcmp(&packet[offset], &reply[offset], 4) != 0)
+                {
+                    matches = false;
+                    break;
+                }
+            }
+
+            if(matches)
+            {
+                return(true);
+            }
+        }
+    }
+
+    LOG_VERBOSE("[%s] Retries exhausted setting static lighting", name.c_str());
+    return(false);
+}
+
+bool EVGAX12Controller::GetReport(unsigned char command, unsigned char* packet)
+{
+    std::memset(packet, 0, EVGA_X12_REPORT_SIZE);
+    packet[0] = EVGA_X12_REPORT_ID;
+    packet[1] = EVGA_X12_HEADER;
+    packet[2] = EVGA_X12_DIRECTION_GET;
+    packet[3] = command;
+
+    if(!SendReport(packet))
+    {
+        return(false);
+    }
+
+    for(unsigned int attempt = 0; attempt < EVGA_X12_READ_ATTEMPTS; attempt++)
+    {
+        std::this_thread::sleep_for(std::chrono::milliseconds(EVGA_X12_READ_DELAY_MS));
+        std::memset(packet, 0, EVGA_X12_REPORT_SIZE);
+        packet[0] = EVGA_X12_REPORT_ID;
+
+        int bytes_read = hid_get_feature_report(dev, packet, EVGA_X12_REPORT_SIZE);
+
+        if(bytes_read == EVGA_X12_REPORT_SIZE && packet[1] == EVGA_X12_HEADER && packet[3] == command)
+        {
+            return(true);
+        }
+
+        if(bytes_read < 0)
+        {
+            LOG_DEBUG("[%s] Error reading feature report: %ls", name.c_str(), hid_error(dev));
+            return(false);
+        }
+    }
+
+    LOG_VERBOSE("[%s] Retries exhausted reading command 0x%02X", name.c_str(), command);
+    return(false);
+}
+
+bool EVGAX12Controller::SendReport(const unsigned char* packet)
+{
+    int bytes_written = hid_send_feature_report(dev, packet, EVGA_X12_REPORT_SIZE);
+
+    if(bytes_written != EVGA_X12_REPORT_SIZE)
+    {
+        LOG_DEBUG("[%s] Error writing feature report: %ls", name.c_str(), hid_error(dev));
+        return(false);
+    }
+
+    return(true);
+}

Controllers/EVGAUSBController/EVGAX12Controller/EVGAX12Controller.h

@@ -0,0 +1,80 @@
+/*---------------------------------------------------------*\
+| EVGAX12Controller.h                                       |
+|                                                           |
+|   Driver for the EVGA X12 gaming mouse                    |
+|                                                           |
+|   QuickMythril                               08 Aug 2026  |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <array>
+#include <mutex>
+#include <string>
+#include <vector>
+#include <hidapi.h>
+#include "RGBController.h"
+
+#define EVGA_X12_REPORT_ID                  0x07
+#define EVGA_X12_REPORT_SIZE                40
+#define EVGA_X12_LED_COUNT                  3
+#define EVGA_X12_FIRMWARE_SLOT_COUNT        4
+#define EVGA_X12_BRIGHTNESS_MIN             0
+#define EVGA_X12_BRIGHTNESS_MAX             255
+
+enum
+{
+    EVGA_X12_MODE_OFF                       = 0,
+    EVGA_X12_MODE_STATIC                    = 1,
+};
+
+/*---------------------------------------------------------*\
+| HEAD_LEFT drives both physical side lights. HEAD_RIGHT    |
+| is writable and readable, but has no physical emitter.    |
+\*---------------------------------------------------------*/
+enum
+{
+    EVGA_X12_FIRMWARE_SLOT_HEAD_LEFT        = 0,
+    EVGA_X12_FIRMWARE_SLOT_HEAD_RIGHT       = 1,
+    EVGA_X12_FIRMWARE_SLOT_WHEEL            = 2,
+    EVGA_X12_FIRMWARE_SLOT_LOGO             = 3,
+};
+
+struct EVGAX12LightingState
+{
+    std::array<unsigned char, EVGA_X12_LED_COUNT> modes;
+    std::array<unsigned char, EVGA_X12_LED_COUNT> brightness;
+    std::array<RGBColor, EVGA_X12_LED_COUNT>      colors;
+    bool                                          modes_valid;
+    bool                                          static_valid;
+};
+
+class EVGAX12Controller
+{
+public:
+    EVGAX12Controller(hid_device* dev_handle, const hid_device_info& info, const std::string& dev_name);
+    ~EVGAX12Controller();
+
+    std::string             GetDeviceLocation();
+    std::string             GetNameString();
+    std::string             GetSerialString();
+
+    EVGAX12LightingState    GetLightingState();
+    bool                    SetMode(unsigned char mode);
+    bool                    SetStatic(const std::vector<RGBColor>& colors, unsigned char brightness);
+    bool                    SetStaticAndActivate(const std::vector<RGBColor>& colors, unsigned char brightness);
+
+private:
+    bool                    GetReport(unsigned char command, unsigned char* packet);
+    bool                    SetModeReport(unsigned char mode);
+    bool                    SetStaticReport(const std::vector<RGBColor>& colors, unsigned char brightness);
+    bool                    SendReport(const unsigned char* packet);
+
+    hid_device*             dev;
+    std::string             location;
+    std::string             name;
+    std::mutex              device_mutex;
+};

Controllers/EVGAUSBController/EVGAX12Controller/EVGAX12ControllerDetect.cpp

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------*\
+| EVGAX12ControllerDetect.cpp                               |
+|                                                           |
+|   Detector for the EVGA X12 gaming mouse                  |
+|                                                           |
+|   QuickMythril                               08 Aug 2026  |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "DetectionManager.h"
+#include "EVGAX12Controller.h"
+#include "RGBController_EVGAX12.h"
+
+#define EVGA_USB_VID                        0x3842
+#define EVGA_X12_PID                        0x2422
+#define EVGA_X12_INTERFACE                  1
+#define EVGA_X12_USAGE_PAGE                 0x0008
+#define EVGA_X12_USAGE                      0x004B
+
+DetectedControllers DetectEVGAX12(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        EVGAX12Controller*     controller     = new EVGAX12Controller(dev, *info, name);
+        RGBController_EVGAX12* rgb_controller = new RGBController_EVGAX12(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_IPU("EVGA X12 Gaming Mouse", DetectEVGAX12, EVGA_USB_VID, EVGA_X12_PID, EVGA_X12_INTERFACE, EVGA_X12_USAGE_PAGE, EVGA_X12_USAGE);

Controllers/EVGAUSBController/EVGAX12Controller/RGBController_EVGAX12.cpp

@@ -0,0 +1,150 @@
+/*---------------------------------------------------------*\
+| RGBController_EVGAX12.cpp                                 |
+|                                                           |
+|   RGBController for the EVGA X12 gaming mouse             |
+|                                                           |
+|   QuickMythril                               08 Aug 2026  |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_EVGAX12.h"
+
+/**------------------------------------------------------------------*\
+    @name EVGA X12 Gaming Mouse
+    @category Mouse
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectEVGAX12
+    @comment Lighting changes are volatile and revert to the onboard
+        profile when the mouse is reconnected.
+\*-------------------------------------------------------------------*/
+RGBController_EVGAX12::RGBController_EVGAX12(EVGAX12Controller* controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    name                        = controller->GetNameString();
+    vendor                      = "EVGA";
+    type                        = DEVICE_TYPE_MOUSE;
+    description                 = "EVGA X12 Gaming Mouse";
+    serial                      = controller->GetSerialString();
+    location                    = controller->GetDeviceLocation();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = EVGA_X12_MODE_STATIC;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.brightness_min       = EVGA_X12_BRIGHTNESS_MIN;
+    Direct.brightness_max       = EVGA_X12_BRIGHTNESS_MAX;
+    Direct.brightness           = EVGA_X12_BRIGHTNESS_MAX;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    direct_mode_index           = (unsigned int)modes.size();
+    modes.push_back(Direct);
+
+    mode Off;
+    Off.name                    = "Off";
+    Off.value                   = EVGA_X12_MODE_OFF;
+    Off.color_mode              = MODE_COLORS_NONE;
+    off_mode_index              = (unsigned int)modes.size();
+    modes.push_back(Off);
+
+    active_mode                 = direct_mode_index;
+
+    SetupZones();
+
+    EVGAX12LightingState current_state = controller->GetLightingState();
+
+    if(current_state.static_valid)
+    {
+        modes[direct_mode_index].brightness = current_state.brightness[0];
+
+        for(unsigned int led_idx = 0; led_idx < EVGA_X12_LED_COUNT; led_idx++)
+        {
+            colors[led_idx] = current_state.colors[led_idx];
+        }
+    }
+
+    if(current_state.modes_valid)
+    {
+        bool all_off = true;
+
+        for(unsigned int led_idx = 0; led_idx < EVGA_X12_LED_COUNT; led_idx++)
+        {
+            if(current_state.modes[led_idx] != EVGA_X12_MODE_OFF)
+            {
+                all_off = false;
+                break;
+            }
+        }
+
+        if(all_off)
+        {
+            active_mode = off_mode_index;
+        }
+    }
+}
+
+RGBController_EVGAX12::~RGBController_EVGAX12()
+{
+    Shutdown();
+
+    delete controller;
+}
+
+void RGBController_EVGAX12::SetupZones()
+{
+    const char* zone_names[EVGA_X12_LED_COUNT] =
+    {
+        "Side",
+        "Scroll Wheel",
+        "Logo",
+    };
+
+    for(unsigned int led_idx = 0; led_idx < EVGA_X12_LED_COUNT; led_idx++)
+    {
+        zone new_zone;
+        new_zone.name         = zone_names[led_idx];
+        new_zone.type         = ZONE_TYPE_SINGLE;
+        new_zone.leds_min     = 1;
+        new_zone.leds_max     = 1;
+        new_zone.leds_count   = 1;
+        zones.push_back(new_zone);
+
+        led new_led;
+        new_led.name          = std::string(zone_names[led_idx]) + " LED";
+        new_led.value         = led_idx;
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_EVGAX12::DeviceUpdateLEDs()
+{
+    controller->SetStatic(colors, modes[direct_mode_index].brightness);
+}
+
+void RGBController_EVGAX12::DeviceUpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_EVGAX12::DeviceUpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_EVGAX12::DeviceUpdateMode()
+{
+    if(modes[active_mode].value == EVGA_X12_MODE_OFF)
+    {
+        controller->SetMode(EVGA_X12_MODE_OFF);
+    }
+    else
+    {
+        controller->SetStaticAndActivate(colors, modes[direct_mode_index].brightness);
+    }
+}

Controllers/EVGAUSBController/EVGAX12Controller/RGBController_EVGAX12.h

@@ -0,0 +1,34 @@
+/*---------------------------------------------------------*\
+| RGBController_EVGAX12.h                                   |
+|                                                           |
+|   RGBController for the EVGA X12 gaming mouse             |
+|                                                           |
+|   QuickMythril                               08 Aug 2026  |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "EVGAX12Controller.h"
+#include "RGBController.h"
+
+class RGBController_EVGAX12 : public RGBController
+{
+public:
+    RGBController_EVGAX12(EVGAX12Controller* controller_ptr);
+    ~RGBController_EVGAX12();
+
+    void DeviceUpdateLEDs();
+    void DeviceUpdateZoneLEDs(int zone);
+    void DeviceUpdateSingleLED(int led);
+    void DeviceUpdateMode();
+
+private:
+    void SetupZones();
+
+    EVGAX12Controller* controller;
+    unsigned int       direct_mode_index;
+    unsigned int       off_mode_index;
+};

Controllers/FaustusController/RGBController_Faustus_Linux.cpp

@@ -197,3 +197,5 @@ DetectedControllers DetectFaustusControllers()
 }
 
 REGISTER_DETECTOR("Faustus", DetectFaustusControllers);
+
+REGISTER_CUSTOM_UDEV_RULE(faustus, "ASUS TUF Laptops (faustus)", "ACTION==\"add\", SUBSYSTEM==\"platform\", KERNEL==\"faustus\", RUN+=\"/usr/bin/env chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_blue\"\nACTION==\"add\", SUBSYSTEM==\"platform\", KERNEL==\"faustus\", RUN+=\"/usr/bin/env chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_flags\"\nACTION==\"add\", SUBSYSTEM==\"platform\", KERNEL==\"faustus\", RUN+=\"/usr/bin/env chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_green\"\nACTION==\"add\", SUBSYSTEM==\"platform\", KERNEL==\"faustus\", RUN+=\"/usr/bin/env chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_mode\"\nACTION==\"add\", SUBSYSTEM==\"platform\", KERNEL==\"faustus\", RUN+=\"/usr/bin/env chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_red\"\nACTION==\"add\", SUBSYSTEM==\"platform\", KERNEL==\"faustus\", RUN+=\"/usr/bin/env chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_set\"\nACTION==\"add\", SUBSYSTEM==\"platform\", KERNEL==\"faustus\", RUN+=\"/usr/bin/env chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_speed\"");

Controllers/GainwardGPUController/GainwardGPUControllerDetect.cpp

@@ -1,102 +0,0 @@
-/*---------------------------------------------------------*\
-| GainwardGPUControllerDetect.cpp                           |
-|                                                           |
-|   Detector for Gainward GPU                               |
-|                                                           |
-|   TheRogueZeta                                05 Nov 2020 |
-|   KundaPanda                                  04 Jan 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "DetectionManager.h"
-#include "GainwardGPUv1Controller.h"
-#include "GainwardGPUv2Controller.h"
-#include "i2c_smbus.h"
-#include "pci_ids.h"
-#include "RGBController_GainwardGPUv1.h"
-#include "RGBController_GainwardGPUv2.h"
-
-bool TestForGainwardGPUController(i2c_smbus_interface* bus, uint8_t i2c_addr)
-{
-    bool pass = false;
-
-    switch(i2c_addr)
-    {
-        /*-------------------------------------------------*\
-        | V1 Controller                                     |
-        \*-------------------------------------------------*/
-        case 0x08:
-            pass = bus->i2c_smbus_write_quick(i2c_addr, I2C_SMBUS_WRITE);
-            break;
-
-        /*-------------------------------------------------*\
-        | V2 Controller                                     |
-        \*-------------------------------------------------*/
-        case 0x49:
-            /*---------------------------------------------*\
-            | This detection might need some modifications  |
-            | Reading 0x6F*0x73 and comparing to 0x64 might |
-            | be a possibility                              |
-            \*---------------------------------------------*/
-            s32 data        = bus->i2c_smbus_read_byte_data(i2c_addr, 0x0);
-            s32 mode_data   = bus->i2c_smbus_read_byte_data(i2c_addr, 0xe0);
-            pass            = (data == 0x0) && (mode_data < 0x5);
-            break;
-    }
-
-    return(pass);
-}
-
-DetectedControllers DetectGainwardGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-
-    if(TestForGainwardGPUController(bus, i2c_addr))
-    {
-        switch(i2c_addr)
-        {
-            /*---------------------------------------------*\
-            | V1 Controller                                 |
-            \*---------------------------------------------*/
-            case 0x08:
-                {
-                    GainwardGPUv1Controller*     controller     = new GainwardGPUv1Controller(bus, i2c_addr, name);
-                    RGBController_GainwardGPUv1* rgb_controller = new RGBController_GainwardGPUv1(controller);
-
-                    detected_controllers.push_back(rgb_controller);
-                }
-                break;
-
-            /*---------------------------------------------*\
-            | V2 Controller                                 |
-            \*---------------------------------------------*/
-            case 0x49:
-                {
-                    GainwardGPUv2Controller*     controller     = new GainwardGPUv2Controller(bus, i2c_addr, name);
-                    RGBController_GainwardGPUv2* rgb_controller = new RGBController_GainwardGPUv2(controller);
-
-                    detected_controllers.push_back(rgb_controller);
-                }
-                break;
-        }
-    }
-
-    return(detected_controllers);
-}
-
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce GTX 1080 Phoenix",          DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_GTX1080_DEV,     GAINWARD_SUB_VEN,   GAINWARD_GTX_1080_PHOENIX,      0x08);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce GTX 1080 Ti Phoenix",       DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_GTX1080TI_DEV,   GAINWARD_SUB_VEN,   GAINWARD_GTX_1080TI_PHOENIX,    0x08);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce GTX 1660 SUPER Ghost",      DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_GTX1660S_DEV,    NVIDIA_SUB_VEN,     NVIDIA_GTX1660S_DEV,            0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 2070 SUPER Phantom",    DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, GAINWARD_SUB_VEN,   NVIDIA_RTX2070S_OC_DEV,         0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 2080 Phoenix GS",       DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX2080_DEV,     GAINWARD_SUB_VEN,   NVIDIA_RTX2080_A_DEV,           0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3060 Pegasus 12G",      DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_DEV,     NVIDIA_SUB_VEN,     NVIDIA_RTX3060_DEV,             0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3070 Phantom",          DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,     GAINWARD_SUB_VEN,   GAINWARD_RTX_3070_PHANTOM,      0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3070 Phoenix",          DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,     GAINWARD_SUB_VEN,   NVIDIA_RTX3070_DEV,             0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3070 Ti Phoenix",       DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,   GAINWARD_SUB_VEN,   NVIDIA_RTX3070TI_DEV,           0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3080 Phoenix",          DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,     GAINWARD_SUB_VEN,   NVIDIA_RTX3080_DEV,             0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3080 Ti Phoenix",       DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,   GAINWARD_SUB_VEN,   NVIDIA_RTX3080TI_DEV,           0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3090 Phoenix",          DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3090_DEV,     GAINWARD_SUB_VEN,   NVIDIA_RTX3090_DEV,             0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3090 Ti Phantom",       DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3090TI_DEV,   GAINWARD_SUB_VEN,   GAINWARD_RTX_3090TI_PHANTOM,    0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 4080 Phantom GS",       DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,     GAINWARD_SUB_VEN,   GAINWARD_RTX_4080_PHANTOM_GS_SUB_DEV,   0x49);

Controllers/GainwardGPUController/GainwardGPUv1Controller/GainwardGPUv1Controller.cpp

@@ -1,78 +0,0 @@
-/*---------------------------------------------------------*\
-| GainwardGPUv1Controller.cpp                               |
-|                                                           |
-|   Driver for Gainward v1 GPU                              |
-|                                                           |
-|   TheRogueZeta                                05 Nov 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include "GainwardGPUv1Controller.h"
-
-GainwardGPUv1Controller::GainwardGPUv1Controller(i2c_smbus_interface* bus, gainward_gpu_dev_id dev, std::string dev_name)
-{
-    this->bus   = bus;
-    this->dev   = dev;
-    this->name  = dev_name;
-}
-
-GainwardGPUv1Controller::~GainwardGPUv1Controller()
-{
-
-}
-
-std::string GainwardGPUv1Controller::GetDeviceLocation()
-{
-    std::string return_string(bus->info.device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-std::string GainwardGPUv1Controller::GetDeviceName()
-{
-    return(name);
-}
-
-unsigned char GainwardGPUv1Controller::GetLEDRed()
-{
-    return(GainwardGPURegisterRead(GAINWARD_RED_REGISTER));
-}
-
-unsigned char GainwardGPUv1Controller::GetLEDGreen()
-{
-    return(GainwardGPURegisterRead(GAINWARD_GREEN_REGISTER));
-}
-
-unsigned char GainwardGPUv1Controller::GetLEDBlue()
-{
-    return(GainwardGPURegisterRead(GAINWARD_BLUE_REGISTER));
-}
-
-void GainwardGPUv1Controller::SetLEDColors(unsigned char red, unsigned char green, unsigned char blue)
-{
-    GainwardGPURegisterWrite(GAINWARD_RED_REGISTER, red);
-    GainwardGPURegisterWrite(GAINWARD_GREEN_REGISTER, green);
-    GainwardGPURegisterWrite(GAINWARD_BLUE_REGISTER, blue);
-    GainwardGPURegisterWrite(GAINWARD_06_REGISTER, 0xFF);
-}
-
-void GainwardGPUv1Controller::SetMode()
-{
-
-}
-
-unsigned char GainwardGPUv1Controller::GainwardGPURegisterRead(unsigned char reg)
-{
-    return(bus->i2c_smbus_read_byte_data(dev, reg));
-}
-
-void GainwardGPUv1Controller::GainwardGPURegisterWrite(unsigned char reg, unsigned char val)
-{
-    bus->i2c_smbus_write_byte_data(dev, reg, val);
-}

Controllers/GainwardGPUController/GainwardGPUv1Controller/RGBController_GainwardGPUv1.cpp

@@ -1,115 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_GainwardGPUv1.cpp                           |
-|                                                           |
-|   RGBController for Gainward v1 GPU                       |
-|                                                           |
-|   TheRogueZeta                                05 Nov 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBController_GainwardGPUv1.h"
-
-int RGBController_GainwardGPUv1::GetDeviceMode()
-{
-    active_mode = 1;
-    return(active_mode);
-}
-
-/**------------------------------------------------------------------*\
-    @name Gainward GPU v1
-    @category GPU
-    @type I2C
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectGainwardGPUControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_GainwardGPUv1::RGBController_GainwardGPUv1(GainwardGPUv1Controller* controller_ptr)
-{
-    controller              = controller_ptr;
-
-    name                    = controller->GetDeviceName();
-    vendor                  = "Gainward";
-    type                    = DEVICE_TYPE_GPU;
-    description             = "Gainward GPU V1 Device";
-    location                = controller->GetDeviceLocation();
-
-    mode Direct;
-    Direct.name             = "Direct";
-    Direct.value            = 1;
-    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode       = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-}
-
-RGBController_GainwardGPUv1::~RGBController_GainwardGPUv1()
-{
-    Shutdown();
-
-    delete controller;
-}
-
-void RGBController_GainwardGPUv1::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zone                                               |
-    \*---------------------------------------------------------*/
-    zone gainward_gpu_zone;
-    gainward_gpu_zone.name              = "GPU";
-    gainward_gpu_zone.type              = ZONE_TYPE_SINGLE;
-    gainward_gpu_zone.leds_min          = 1;
-    gainward_gpu_zone.leds_max          = 1;
-    gainward_gpu_zone.leds_count        = 1;
-    zones.push_back(gainward_gpu_zone);
-
-    /*---------------------------------------------------------*\
-    | Set up LED                                                |
-    \*---------------------------------------------------------*/
-    led gainward_gpu_led;
-    gainward_gpu_led.name               = "GPU";
-    leds.push_back(gainward_gpu_led);
-
-    SetupColors();
-
-    /*---------------------------------------------------------*\
-    | Initialize color                                          |
-    \*---------------------------------------------------------*/
-    unsigned char red = controller->GetLEDRed();
-    unsigned char grn = controller->GetLEDGreen();
-    unsigned char blu = controller->GetLEDBlue();
-
-    colors[0] =  ToRGBColor(red, grn, blu);
-}
-
-void RGBController_GainwardGPUv1::DeviceUpdateLEDs()
-{
-    for(std::size_t led = 0; led < colors.size(); led++)
-    {
-        unsigned char red = RGBGetRValue(colors[led]);
-        unsigned char grn = RGBGetGValue(colors[led]);
-        unsigned char blu = RGBGetBValue(colors[led]);
-
-        controller->SetLEDColors(red, grn, blu);
-    }
-}
-
-void RGBController_GainwardGPUv1::DeviceUpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_GainwardGPUv1::DeviceUpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_GainwardGPUv1::DeviceUpdateMode()
-{
-
-}

Controllers/GainwardGPUController/GainwardGPUv2Controller/GainwardGPUv2Controller.cpp

@@ -1,97 +0,0 @@
-/*---------------------------------------------------------*\
-| GainwardGPUv2Controller.cpp                               |
-|                                                           |
-|   Driver for Gainward v2 GPU                              |
-|                                                           |
-|   KundaPanda                                  04 Jan 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include "GainwardGPUv2Controller.h"
-
-GainwardGPUv2Controller::GainwardGPUv2Controller(i2c_smbus_interface* bus, gainward_gpu_dev_id dev, std::string dev_name)
-{
-    this->bus   = bus;
-    this->dev   = dev;
-    this->name  = dev_name;
-}
-
-GainwardGPUv2Controller::~GainwardGPUv2Controller() = default;
-
-std::string GainwardGPUv2Controller::GetDeviceLocation()
-{
-    std::string return_string(bus->info.device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-std::string GainwardGPUv2Controller::GetDeviceName()
-{
-    return(name);
-}
-
-unsigned char GainwardGPUv2Controller::GetLEDRed()
-{
-    return(bus->i2c_smbus_read_byte_data(dev, GAINWARD_V2_RED_REGISTER));
-}
-
-unsigned char GainwardGPUv2Controller::GetLEDGreen()
-{
-    return(bus->i2c_smbus_read_byte_data(dev, GAINWARD_V2_GREEN_REGISTER));
-}
-
-unsigned char GainwardGPUv2Controller::GetLEDBlue()
-{
-    return(bus->i2c_smbus_read_byte_data(dev, GAINWARD_V2_BLUE_REGISTER));
-}
-
-void GainwardGPUv2Controller::SetLEDColors(unsigned char red, unsigned char green, unsigned char blue, unsigned char color_register)
-{
-    switch (color_register)
-    {
-        default:
-            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_RED_REGISTER, red);
-            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_GREEN_REGISTER, green);
-            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BLUE_REGISTER, blue);
-            break;
-        case GAINWARD_V2_COLOR_REGISTER_SECONDARY:
-            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_RED_SECONDARY_REGISTER, red);
-            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_GREEN_SECONDARY_REGISTER, green);
-            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BLUE_SECONDARY_REGISTER, blue);
-            break;
-        case GAINWARD_V2_COLOR_REGISTER_TERTIARY:
-            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_RED_TERTIARY_REGISTER, red);
-            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_GREEN_TERTIARY_REGISTER, green);
-            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BLUE_TERTIARY_REGISTER, blue);
-            break;
-    }
-}
-
-void GainwardGPUv2Controller::SetMode(unsigned char mode, unsigned char speed, unsigned char static_mode)
-{
-    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_MODE_REGISTER, mode);
-    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_STATIC_CONTROL_REGISTER, static_mode);
-    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_SPEED_REGISTER, speed);
-}
-
-void GainwardGPUv2Controller::SetDirection(unsigned char direction)
-{
-    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_MODE_DIRECTION_REGISTER, direction);
-}
-
-void GainwardGPUv2Controller::SetBreathingSpeed(unsigned int speed)
-{
-    unsigned char lower = speed & 0xFF;
-    unsigned char upper = (speed >> 2 * 4) & 0xFF;
-
-    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BREATHE_SPEED_REGISTER_A, lower);
-    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BREATHE_SPEED_SECONDARY_REGISTER_A, lower);
-    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BREATHE_SPEED_REGISTER_B, upper);
-    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BREATHE_SPEED_SECONDARY_REGISTER_B, upper);
-}

Controllers/GainwardGPUController/GainwardGPUv2Controller/GainwardGPUv2Controller.h

@@ -1,101 +0,0 @@
-/*---------------------------------------------------------*\
-| GainwardGPUv2Controller.h                                 |
-|                                                           |
-|   Driver for Gainward v2 GPU                              |
-|                                                           |
-|   KundaPanda                                  04 Jan 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include "i2c_smbus.h"
-
-typedef unsigned char gainward_gpu_dev_id;
-
-/*---------------------------------------------------------------------------------*\
- | Newer Gainward models seem to use addresses very similar to those used by EVGA   |
- \*-------------------------------------------------------------------------------**/
-
-enum
-{
-    /* RGB Registers */
-    GAINWARD_V2_RED_REGISTER                        = 0x6C, /* Red Register */
-    GAINWARD_V2_GREEN_REGISTER                      = 0x6D, /* Green Register */
-    GAINWARD_V2_BLUE_REGISTER                       = 0x6E, /* Blue Register */
-    GAINWARD_V2_RED_SECONDARY_REGISTER              = 0x70, /* Red Register 2 */
-    GAINWARD_V2_GREEN_SECONDARY_REGISTER            = 0x71, /* Green Register 2 */
-    GAINWARD_V2_BLUE_SECONDARY_REGISTER             = 0x72, /* Blue Register 2 */
-    GAINWARD_V2_RED_TERTIARY_REGISTER               = 0xE4, /* Red Register 3 */
-    GAINWARD_V2_GREEN_TERTIARY_REGISTER             = 0xE5, /* Green Register 3 */
-    GAINWARD_V2_BLUE_TERTIARY_REGISTER              = 0xE6, /* Blue Register 3 */
-    GAINWARD_V2_MODE_REGISTER                       = 0xE0, /* Mode Register */
-    /* Direct mode switch register
-     * 0x1 Software control
-     * 0x22 Breathing */
-    GAINWARD_V2_STATIC_CONTROL_REGISTER             = 0x60,
-    GAINWARD_V2_BREATHE_SPEED_REGISTER_A            = 0x62, /* Lower part of speed control for breathe effect */
-    GAINWARD_V2_BREATHE_SPEED_REGISTER_B            = 0x63, /* Upper part of speed control for breathe effect */
-    GAINWARD_V2_BREATHE_SPEED_SECONDARY_REGISTER_A  = 0x64, /* Lower part of speed control for breathe effect - prob. secondary color */
-    GAINWARD_V2_BREATHE_SPEED_SECONDARY_REGISTER_B  = 0x65, /* Upper part of speed control for breathe effect - prob. secondary color */
-    /* Mode direction Register
-     * 0x0
-     * 0x1 */
-    GAINWARD_V2_MODE_DIRECTION_REGISTER             = 0xE1,
-    /* Mode speed Register
-     * 0x0 MAX
-     * 0xF MIN */
-    GAINWARD_V2_SPEED_REGISTER                      = 0xE2,
-};
-
-enum
-{
-    /* Manual color selection using primary registers */
-    GAINWARD_V2_MODE_STATIC                         = 0x00,
-    /* Rainbow cycling with direction and speed controls */
-    GAINWARD_V2_MODE_CYCLE                          = 0x01,
-    /* One strobing color running around the fan
-     * Color using primary registers, direction and speed control */
-    GAINWARD_V2_MODE_STROBE                         = 0x02,
-};
-
-enum
-{
-    GAINWARD_V2_COLOR_REGISTER_PRIMARY,
-    GAINWARD_V2_COLOR_REGISTER_SECONDARY,
-    GAINWARD_V2_COLOR_REGISTER_TERTIARY,
-};
-
-enum
-{
-    /* Software controlled direct mode */
-    GAINWARD_V2_STATIC_SOFTWARE                     = 0x01,
-    /* GPU controlled direct mode with breathing effect */
-    GAINWARD_V2_STATIC_BREATHING                    = 0x22,
-};
-
-class GainwardGPUv2Controller
-{
-public:
-    GainwardGPUv2Controller(i2c_smbus_interface* bus, gainward_gpu_dev_id, std::string dev_name);
-    ~GainwardGPUv2Controller();
-
-    std::string   GetDeviceLocation();
-    std::string   GetDeviceName();
-
-    unsigned char GetLEDRed();
-    unsigned char GetLEDGreen();
-    unsigned char GetLEDBlue();
-    void          SetLEDColors(unsigned char red, unsigned char green, unsigned char blue, unsigned char color_register = GAINWARD_V2_COLOR_REGISTER_PRIMARY);
-    void          SetMode(unsigned char mode, unsigned char speed, unsigned char direct_mode = GAINWARD_V2_STATIC_SOFTWARE);
-    void          SetBreathingSpeed(unsigned int speed);
-    void          SetDirection(unsigned char direction);
-
-private:
-    i2c_smbus_interface *   bus;
-    gainward_gpu_dev_id     dev;
-    std::string             name;
-};

Controllers/GainwardGPUController/GainwardGPUv2Controller/RGBController_GainwardGPUv2.cpp

@@ -1,187 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_GainwardGPUv2.cpp                           |
-|                                                           |
-|   RGBController for Gainward v2 GPU                       |
-|                                                           |
-|   KundaPanda                                  04 Jan 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBController_GainwardGPUv2.h"
-
-/**------------------------------------------------------------------*\
-    @name Gainward GPU v2
-    @category GPU
-    @type I2C
-    @save :x:
-    @direct :x:
-    @effects :white_check_mark:
-    @detectors DetectGainwardGPUControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_GainwardGPUv2::RGBController_GainwardGPUv2(GainwardGPUv2Controller* controller_ptr)
-{
-    controller                  = controller_ptr;
-
-    name                        = controller->GetDeviceName();
-    vendor                      = "Gainward";
-    type                        = DEVICE_TYPE_GPU;
-    description                 = "Gainward GPU V2 Device";
-    location                    = controller->GetDeviceLocation();
-
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = GAINWARD_V2_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Static);
-
-    mode Breathe;
-    Breathe.name                = "Breathing";
-    Breathe.value               = GAINWARD_V2_MODE_STATIC;
-    Breathe.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathe.speed_max           = 0x000a;
-    Breathe.speed_min           = 0x1324;
-    Breathe.color_mode          = MODE_COLORS_MODE_SPECIFIC;
-    Breathe.colors_min          = 2;
-    Breathe.colors_max          = 2;
-    Breathe.colors.resize(2);
-    modes.push_back(Breathe);
-
-    mode RainbowWave;
-    RainbowWave.name            = "Rainbow Wave";
-    RainbowWave.value           = GAINWARD_V2_MODE_CYCLE;
-    RainbowWave.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    RainbowWave.speed_max       = 0x0;
-    RainbowWave.speed_min       = 0xF;
-    RainbowWave.color_mode      = MODE_COLORS_NONE;
-    modes.push_back(RainbowWave);
-
-    mode Strobe;
-    Strobe.name                 = "Strobe";
-    Strobe.value                = GAINWARD_V2_MODE_STROBE;
-    Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Strobe.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Strobe.colors_min           = 1;
-    Strobe.colors_max           = 1;
-    Strobe.colors.resize(1);
-    Strobe.speed_max            = 0x0;
-    Strobe.speed_min            = 0xF;
-    modes.push_back(Strobe);
-
-    SetupZones();
-
-    /*-------------------------*\
-    | Initialize active mode    |
-    \*-------------------------*/
-    active_mode = 0;
-}
-
-RGBController_GainwardGPUv2::~RGBController_GainwardGPUv2()
-{
-    Shutdown();
-
-    delete controller;
-}
-
-void RGBController_GainwardGPUv2::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zone                                               |
-    \*---------------------------------------------------------*/
-    zone gainward_gpu_zone;
-    gainward_gpu_zone.name              = "GPU";
-    gainward_gpu_zone.type              = ZONE_TYPE_SINGLE;
-    gainward_gpu_zone.leds_min          = 1;
-    gainward_gpu_zone.leds_max          = 1;
-    gainward_gpu_zone.leds_count        = 1;
-    zones.push_back(gainward_gpu_zone);
-
-    /*---------------------------------------------------------*\
-    | Set up LED                                                |
-    \*---------------------------------------------------------*/
-    led gainward_gpu_led;
-    gainward_gpu_led.name               = "GPU";
-    leds.push_back(gainward_gpu_led);
-
-    SetupColors();
-
-    /*---------------------------------------------------------*\
-    | Initialize color                                          |
-    \*---------------------------------------------------------*/
-    unsigned char red = controller->GetLEDRed();
-    unsigned char grn = controller->GetLEDGreen();
-    unsigned char blu = controller->GetLEDBlue();
-
-    colors[0] =  ToRGBColor(red, grn, blu);
-}
-
-void RGBController_GainwardGPUv2::DeviceUpdateLEDs()
-{
-    for(unsigned int color : colors)
-    {
-        unsigned char red = RGBGetRValue(color);
-        unsigned char grn = RGBGetGValue(color);
-        unsigned char blu = RGBGetBValue(color);
-
-        controller->SetLEDColors(red, grn, blu);
-        controller->SetMode(GAINWARD_V2_MODE_STATIC, 0x2);
-    }
-}
-
-void RGBController_GainwardGPUv2::DeviceUpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_GainwardGPUv2::DeviceUpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_GainwardGPUv2::DeviceUpdateMode()
-{
-    mode current_mode = modes[(unsigned int)active_mode];
-    switch (active_mode)
-    {
-        case 1:
-            {
-                controller->SetBreathingSpeed(current_mode.speed);
-
-                unsigned char r1 = RGBGetRValue(current_mode.colors[0]);
-                unsigned char g1 = RGBGetGValue(current_mode.colors[0]);
-                unsigned char b1 = RGBGetBValue(current_mode.colors[0]);
-                controller->SetLEDColors(r1, g1, b1);
-
-                unsigned char r2 = RGBGetRValue(current_mode.colors[1]);
-                unsigned char g2 = RGBGetGValue(current_mode.colors[1]);
-                unsigned char b2 = RGBGetBValue(current_mode.colors[1]);
-                controller->SetLEDColors(r2, g2, b2, GAINWARD_V2_COLOR_REGISTER_SECONDARY);
-                controller->SetMode(GAINWARD_V2_MODE_STATIC, 0x2, GAINWARD_V2_STATIC_BREATHING);
-            }
-            break;
-
-        /*---------------------------------------------*\
-        | Case 3 intentionally falls through to case 2  |
-        \*---------------------------------------------*/
-        case 3:
-            {
-                unsigned char r = RGBGetRValue(current_mode.colors[0]);
-                unsigned char g = RGBGetGValue(current_mode.colors[0]);
-                unsigned char b = RGBGetBValue(current_mode.colors[0]);
-                controller->SetLEDColors(r, g, b, GAINWARD_V2_COLOR_REGISTER_TERTIARY);
-            }
-
-        case 2:
-            controller->SetMode((unsigned char)(current_mode.value), (unsigned char)(current_mode.speed));
-            controller->SetDirection(current_mode.direction);
-            break;
-
-        default:
-            controller->SetMode((unsigned char)(current_mode.value), (unsigned char)(current_mode.speed));
-            break;
-    }
-}

Controllers/GalaxGPUController/GalaxGPUControllerDetect.cpp

@@ -109,5 +109,6 @@ REGISTER_I2C_PCI_DETECTOR("GALAX GeForce RTX 2070 SUPER EX Gamer Black",    Dete
 REGISTER_I2C_PCI_DETECTOR("KFA2 GeForce RTX 2080 EX OC",                    DetectGalaxGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2080_DEV,     NVIDIA_SUB_VEN, KFA2_RTX_2080_EX_OC_SUB_DEV,            0x23);
 REGISTER_I2C_PCI_DETECTOR("KFA2 GeForce RTX 2080 SUPER EX OC",              DetectGalaxGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2080S_DEV,    NVIDIA_SUB_VEN, KFA2_RTX_2080_SUPER_EX_OC_SUB_DEV,      0x23);
 REGISTER_I2C_PCI_DETECTOR("KFA2 GeForce RTX 2080 Ti EX OC",                 DetectGalaxGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2080TI_DEV,   NVIDIA_SUB_VEN, KFA2_RTX_2080TI_EX_OC_SUB_DEV,          0x23);
+REGISTER_I2C_PCI_DETECTOR("GALAX GeForce RTX 3070 1-Click OC",              DetectGalaxGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070_DEV,     NVIDIA_SUB_VEN, GALAX_RTX_3070_1_CLICK_OC_SUB_DEV,      0x23);
 REGISTER_I2C_PCI_DETECTOR("GALAX GeForce RTX 3080 SG",                      DetectGalaxGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3080_DEV,     NVIDIA_SUB_VEN, GALAX_RTX_3080_SG_SUB_DEV,              0x23);
 REGISTER_I2C_PCI_DETECTOR("GALAX GeForce RTX 5070 Ti EX Gamer 1-Click OC",  DetectGalaxGPUControllers,  NVIDIA_VEN, NVIDIA_RTX5070TI_DEV,   NVIDIA_SUB_VEN, GALAX_RTX_5070TI_EX_OC_SUB_DEV,         0x51);

Controllers/GameSirController/GameSirController.cpp

@@ -0,0 +1,70 @@
+/*---------------------------------------------------------*\
+| GameSirController.cpp                                     |
+|                                                           |
+|   GameSir RGB Device                                      |
+|                                                           |
+|   Added by OpenRGB Community                  08 Aug 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "GameSirController.h"
+#include <cstring>
+#include "StringUtils.h"
+
+GameSirController::GameSirController(hid_device* dev_handle, const char* path)
+{
+    dev      = dev_handle;
+    location = path;
+}
+
+GameSirController::~GameSirController()
+{
+    hid_close(dev);
+}
+
+std::string GameSirController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+std::string GameSirController::GetSerialString()
+{
+    wchar_t serial_string[128];
+    memset(serial_string, 0x00, sizeof(serial_string));
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    return(StringUtils::wstring_to_string(serial_string));
+}
+
+void GameSirController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char buf[64];
+    memset(buf, 0x00, sizeof(buf));
+
+    buf[0] = 0x05;
+    buf[1] = 0x08;
+    buf[2] = 0x0A;
+    buf[3] = 0x01;
+    buf[4] = 0x03;
+    buf[5] = red;
+    buf[6] = green;
+    buf[7] = blue;
+    buf[8] = 0x00;
+
+    unsigned int checksum = 0;
+    for(int i = 0; i < 9; i++)
+    {
+        checksum += buf[i];
+    }
+    
+    buf[9] = checksum & 0xFF;
+
+    hid_write(dev, buf, sizeof(buf));
+}

Controllers/GameSirController/GameSirController.h

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------*\
+| GameSirController.h                                       |
+|                                                           |
+|   GameSir RGB Device                                      |
+|                                                           |
+|   Added by OpenRGB Community                  08 Aug 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include <hidapi.h>
+
+class GameSirController
+{
+public:
+    GameSirController(hid_device* dev_handle, const char* path);
+    ~GameSirController();
+
+    std::string GetLocation();
+    std::string GetSerialString();
+
+    void SetColor(unsigned char red, unsigned char green, unsigned char blue);
+
+private:
+    hid_device* dev;
+    std::string location;
+};

Controllers/GameSirController/GameSirControllerDetect.cpp

@@ -0,0 +1,34 @@
+/*---------------------------------------------------------*\
+| GameSirControllerDetect.cpp                               |
+|                                                           |
+|   GameSir RGB Device                                      |
+|                                                           |
+|   Added by OpenRGB Community                  08 Aug 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "DetectionManager.h"
+#include "RGBController_GameSir.h"
+
+#define GAMESIR_VID 0x3537
+#define GAMESIR_NOVA_LITE_2_PID 0x100F
+
+DetectedControllers DetectGameSirControllers(hid_device_info* info, const std::string& /*name*/)
+{
+    DetectedControllers detected_controllers;
+
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        GameSirController* controller     = new GameSirController(dev, info->path);
+        RGBController_GameSir* rgb_controller = new RGBController_GameSir(controller);
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return detected_controllers;
+}
+
+REGISTER_HID_DETECTOR_IPU("GameSir Nova 2 Lite", DetectGameSirControllers, GAMESIR_VID, GAMESIR_NOVA_LITE_2_PID, 2, 0xFF7A, 0x0001);

Controllers/GameSirController/RGBController_GameSir.cpp

@@ -0,0 +1,75 @@
+/*---------------------------------------------------------*\
+| RGBController_GameSir.cpp                                 |
+|                                                           |
+|   GameSir RGB Device                                      |
+|                                                           |
+|   Added by OpenRGB Community                  08 Aug 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_GameSir.h"
+
+RGBController_GameSir::RGBController_GameSir(GameSirController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "GameSir Nova 2 Lite";
+    vendor      = "GameSir";
+    type        = DEVICE_TYPE_GAMEPAD;
+    description = "GameSir RGB Device";
+    location    = controller->GetLocation();
+    serial      = controller->GetSerialString();
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = 0xFFFF;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Static);
+
+    SetupZones();
+}
+
+RGBController_GameSir::~RGBController_GameSir()
+{
+    delete controller;
+}
+
+void RGBController_GameSir::SetupZones()
+{
+    zone new_zone;
+    new_zone.name       = "Controller";
+    new_zone.type       = ZONE_TYPE_SINGLE;
+    new_zone.leds_min   = 1;
+    new_zone.leds_max   = 1;
+    new_zone.leds_count = 1;
+    zones.push_back(new_zone);
+
+    led new_led;
+    new_led.name        = "Main LED";
+    leds.push_back(new_led);
+
+    SetupColors();
+}
+
+void RGBController_GameSir::DeviceUpdateLEDs()
+{
+    controller->SetColor(RGBGetRValue(colors[0]), RGBGetGValue(colors[0]), RGBGetBValue(colors[0]));
+}
+
+void RGBController_GameSir::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_GameSir::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_GameSir::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}

Controllers/GameSirController/RGBController_GameSir.h

@@ -1,33 +1,32 @@
-/*---------------------------------------------------------*\
-| RGBController_LogitechG810.h                              |
-|                                                           |
-|   RGBController for Logitech G810 Orion Spectrum          |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                12 Jun 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "LogitechG810Controller.h"
-
-class RGBController_LogitechG810 : public RGBController
-{
-public:
-    RGBController_LogitechG810(LogitechG810Controller* controller_ptr);
-    ~RGBController_LogitechG810();
-
-    void        SetupZones();
-
-    void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    LogitechG810Controller* controller;
-};
+/*---------------------------------------------------------*\
+| RGBController_GameSir.h                                   |
+|                                                           |
+|   GameSir RGB Device                                      |
+|                                                           |
+|   Added by OpenRGB Community                  08 Aug 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "GameSirController.h"
+
+class RGBController_GameSir : public RGBController
+{
+public:
+    RGBController_GameSir(GameSirController* controller_ptr);
+    ~RGBController_GameSir();
+
+    void        SetupZones();
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+    void        DeviceUpdateMode();
+
+private:
+    GameSirController* controller;
+};

Controllers/GigabyteRGBFusion2BlackwellGPUController/GigabyteRGBFusion2BlackwellGPUControllerDetect.cpp

@@ -1,4 +1,4 @@
-/*---------------------------------------------------------*\
+/*---------------------------------------------------------*\
 | GigabyteRGBFusion2BlackwellGPUControllerDetect.cpp        |
 |                                                           |
 |   Detector for Gigabyte RGB Fusion 2 Blackwell GPU        |
@@ -130,8 +130,8 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5080 XTREME WATERFORCE",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5080 XTREME WATERFORCE",            DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers,                NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5080_XTREME_WATERFORCE_16G_SUB_DEV,           0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5080 MASTER ICE",             DetectGigabyteRGBFusion2BlackwellAorusMaster5080LayoutGPUControllers,           NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5080_MASTER_ICE_16G_SUB_DEV,            0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 Gaming OC",                    DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_GAMING_OC_32G_SUB_DEV,                   0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 XTREME WATERFORCE",            DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers,                NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV1,          0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 XTREME WATERFORCE",            DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers,                NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV2,          0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 XTREME WATERFORCE",            DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV,           0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 XTREME WATERFORCE WB",         DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers,                NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_XTREME_WATERFORCE_WB_32G_SUB_DEV,        0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 MASTER",                 DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5090_MASTER_32G_SUB_DEV,                0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 MASTER ICE",             DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5090_MASTER_ICE_32G_SUB_DEV,            0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 D V2 MASTER ICE",        DetectGigabyteRGBFusion2BlackwellAorusMaster5090DV2IceLayoutGPUControllers,     NVIDIA_VEN,     NVIDIA_RTX5090D_V2_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5090D_V2_MASTER_ICE_24G_SUB_DEV,        0x75);
@@ -139,9 +139,11 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 D V2 MASTER ICE",
 /*---------------------------------------------------------*\
 |  AMD GPUs                                                 |
 \*---------------------------------------------------------*/
+REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9060 GAMING OC 8G",                   DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    AMD_GPU_VEN,    AMD_NAVI44_DEV,             GIGABYTE_SUB_VEN, GIGABYTE_RX9060XT_GAMING_OC_8G_SUB_DEV,                   0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9060 XT GAMING",                      DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    AMD_GPU_VEN,    AMD_NAVI44_DEV,             GIGABYTE_SUB_VEN, GIGABYTE_RX9060XT_GAMING_16G_SUB_DEV,                     0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9060 XT GAMING OC",                   DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    AMD_GPU_VEN,    AMD_NAVI44_DEV,             GIGABYTE_SUB_VEN, GIGABYTE_RX9060XT_GAMING_OC_16G_SUB_DEV,                  0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS Radeon RX 9070 XT Elite",                 DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    AMD_GPU_VEN,    AMD_NAVI48_DEV,             GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RX9070XT_ELITE_16G_SUB_DEV,                0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9070 XT GAMING OC",                   DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    AMD_GPU_VEN,    AMD_NAVI48_DEV,             GIGABYTE_SUB_VEN, GIGABYTE_RX9070XT_GAMING_OC_16G_SUB_DEV,                  0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9070 XT GAMING OC ICE",               DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    AMD_GPU_VEN,    AMD_NAVI48_DEV,             GIGABYTE_SUB_VEN, GIGABYTE_RX9070XT_GAMING_OC_ICE_16G_SUB_DEV,              0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9070 XT GAMING",                      DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    AMD_GPU_VEN,    AMD_NAVI48_DEV,             GIGABYTE_SUB_VEN, GIGABYTE_RX9070XT_GAMING_16G_SUB_DEV,                     0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9070 GAMING OC",                      DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    AMD_GPU_VEN,    AMD_NAVI48_DEV,             GIGABYTE_SUB_VEN, GIGABYTE_RX9070_GAMING_OC_16G_SUB_DEV,                    0x75);

Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp

@@ -52,8 +52,12 @@ bool TestForGigabyteRGBFusion2GPUController(i2c_smbus_interface* bus, unsigned c
     //Note that GeForce RTX 4080 Gigabyte AORUS MASTER 16G exposes two i2c bus with writable address 0x71 but one respond
     //0x00 0x00 0x00 0x00 so it should be the one controlling the LCD screen. So we skip this bus
 
-    //All seen responses start with 0xAB, so we check for this.
-    if(res < 0 || data_readpkt[0] != 0xAB)
+    //All seen responses start with 0xAB, so we check for this. A DDC/EDID
+    //style bus can echo the written command byte back for every read, so an
+    //all-0xAB response is a mirror, not a controller; every real controller
+    //seen so far follows 0xAB with version bytes (see table above).
+    if(res < 0 || data_readpkt[0] != 0xAB ||
+       (data_readpkt[1] == 0xAB && data_readpkt[2] == 0xAB && data_readpkt[3] == 0xAB))
     {
         // Assemble C-string with respons for debugging
         std::string text = "";
@@ -108,6 +112,7 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 2080 SUPER Waterforce WB",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 2080 SUPER Waterforce WB",       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_WATERFORCE_WB_SUB_DEV_P,0x51);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 2080 SUPER Waterforce",          DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_WATERFORCE_SUB_DEV_H,   0x08);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 2080 SUPER Waterforce",          DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_WATERFORCE_SUB_DEV_P,   0x08);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 2080 Ti 11G",                    DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080TI_11G_SUB_DEV_H,         0x50);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 2080 Ti XTREME",                 DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080TI_EXTREME_SUB_DEV_H,     0x50);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 2080 Ti XTREME",                 DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080TI_EXTREME_SUB_DEV_P,     0x50);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 3060 ELITE",                     DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3060_GA104_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_ELITE_12GB_SUB_DEV,            0x70);
@@ -139,7 +144,8 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 GAMING OC",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Geforce RTX 4070 Aero OC",                         DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070_AERO_OC_12G_SUB_DEV,           0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 SUPER GAMING OC",                 DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_GAMING_OC_12G,                0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 SUPER Aero OC",                   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_AERO_OC_12G,                  0x71);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 SUPER Eagle OC",                  DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_EAGLE_OC_ICE_12G,             0x71);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 SUPER Eagle OC",                  DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_EAGLE_OC_12G,                 0x71);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 SUPER Eagle OC ICE",              DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_EAGLE_OC_ICE_12G,             0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 Ti GAMING",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070TI_GAMING_12G,                  0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 Ti GAMING OC",                    DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070TI_GAMING_OC_12G,               0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 Ti GAMING OC",                    DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070TI_GAMING_OC_12G_SUB_DEV2,      0x71);
@@ -160,6 +166,8 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4090 AERO OC",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4090 GAMING OC",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4090_GAMING_OC_24G_SUB_DEV,         0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 4090 MASTER",                    DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX4090_MASTER_24G_SUB_DEV,      0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 D MASTER",                  DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX5090D_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX5090D_MASTER_32G_SUB_DEV,     0x71);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5080 GAMING OC",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX5080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX5080_GAMING_OC_16G_SUB_DEV,         0x71);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5080 MASTER ICE",                DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX5080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX5080_MASTER_ICE_16G_SUB_DEV,  0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 GAMING OC",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX5090D_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX5090_GAMING_OC_32G_SUB_DEV,         0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 MASTER",                    DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX5090_MASTER_32G_SUB_DEV,      0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 MASTER ICE",                DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX5090_MASTER_ICE_32G_SUB_DEV,  0x71);
@@ -181,7 +189,9 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 7900 XT GAMING OC",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 7900 XTX GAMING OC",                     DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI31_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX7900XTX_GAMING_OC_24G_SUB_DEV,       0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS Radeon RX 7900 XTX ELITE 24G",               DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI31_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RX7900XTX_ELITE_24G_SUB_DEV,     0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RX 6750 XT ELITE 12G",                       DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI22_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RX_6750_XT_ELITE_12G_SUB_DEV,    0x70);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RX 6900 XT MASTER rev 2.0",                  DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI21_DEV2,           GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RX6900XT_MASTER_SUB_DEV,         0x70);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RX 6900 XT EXTREME WATERFORCE WB",           DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI21_DEV2,           GIGABYTE_SUB_VEN,   GIGABYTE_RX6900XT_XTREME_WATERFORCE_WB_SUB_DEV, 0x70);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9060 XT GAMING OC 8G",                   DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI44_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX9060XT_GAMING_OC_8G_SUB_DEV,         0x73);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS Radeon RX 9070 XT Elite",                    DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI48_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RX9070XT_ELITE_16G_SUB_DEV,      0x73);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9070 XT GAMING OC",                      DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI48_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX9070XT_GAMING_OC_16G_SUB_DEV,        0x73);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9070 XT GAMING OC ICE",                  DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI48_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX9070XT_GAMING_OC_ICE_16G_SUB_DEV,    0x73);

Controllers/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusControllerDetect.cpp

@@ -56,6 +56,7 @@ json rgb_fusion_2_smbus_motherboards[] =
     "X470 AORUS ULTRA GAMING",
     "X470 AORUS ULTRA GAMING-CF",
     "B360M AORUS Gaming 3-CF",
+    "B360 AORUS GAMING 3 WIFI-CF",
     "Z370 AORUS Gaming 5-CF",
     "Z370 AORUS Ultra Gaming-CF"
 };

Controllers/GigabyteRGBFusion2USBController/GigabyteFusion2USB_Devices.cpp

@@ -4,8 +4,8 @@
 |   Gigabyte Fusion 2 USB Device layouts and                |
 |     and mapping to the device IDs stored on chip          |
 |                                                           |
-|   megadjc                                     31 Jul 2025 |
 |   chrism                                      29 Aug 2025 |
+|   megadjc                                     03 Sep 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-only                   |
@@ -19,16 +19,16 @@
 static const gb_fusion2_zone common_d_led_zone =
 {
     HDR_D_LED1,
-    0,
-    1024,
+    RGBFUSION2_DLED_LEDS_MIN,
+    RGBFUSION2_DLED_LEDS_MAX,
     "D_LED"
 };
 
 static const gb_fusion2_zone common_gc_usb_d_led_zone =
 {
     LED1,
-    0,
-    1024,
+    RGBFUSION2_DLED_LEDS_MIN,
+    RGBFUSION2_DLED_LEDS_MAX,
     "D_LED"
 };
 
@@ -36,48 +36,48 @@ static const gb_fusion2_zone common_gc_usb_d_led_zone =
 static const gb_fusion2_zone common_d_led1_zone =
 {
     HDR_D_LED1,
-    0,
-    1024,
+    RGBFUSION2_DLED_LEDS_MIN,
+    RGBFUSION2_DLED_LEDS_MAX,
     "D_LED1"
 };
 
 static const gb_fusion2_zone common_dled1_dled2_zone =
 {
     HDR_D_LED1,
-    0,
-    1024,
+    RGBFUSION2_DLED_LEDS_MIN,
+    RGBFUSION2_DLED_LEDS_MAX,
     "D_LED1/D_LED2"
 };
 
 static const gb_fusion2_zone common_argb_v2_1_zone =
 {
     HDR_D_LED1,
-    0,
-    1024,
+    RGBFUSION2_57XX_LEDS_MIN,
+    RGBFUSION2_57XX_LEDS_MAX,
     "ARGB_V2_1"
 };
 
 static const gb_fusion2_zone alt_argb_v2_1_zone =
 {
     LED3,
-    0,
-    1024,
+    RGBFUSION2_57XX_LEDS_MIN,
+    RGBFUSION2_57XX_LEDS_MAX,
     "ARGB_V2_1"
 };
 
 static const gb_fusion2_zone common_argb_v2_1_3_zone =
 {
     HDR_D_LED1,
-    0,
-    1024,
+    RGBFUSION2_57XX_LEDS_MIN,
+    RGBFUSION2_57XX_LEDS_MAX,
     "ARGB_V2_1/ARGB_V2_3"
 };
 
 static const gb_fusion2_zone common_d_led2_zone =
 {
     HDR_D_LED2,
-    0,
-    1024,
+    RGBFUSION2_DLED_LEDS_MIN,
+    RGBFUSION2_DLED_LEDS_MAX,
     "D_LED2"
 };
 
@@ -85,47 +85,47 @@ static const gb_fusion2_zone common_d_led2_aux_zone =
 {
     HDR_D_LED2,
     2,
-    1024,
+    RGBFUSION2_DLED_LEDS_MAX,
     "D_LED2 + Aux"
 };
 
 static const gb_fusion2_zone common_argb_v2_2_zone =
 {
     HDR_D_LED2,
-    0,
-    1024,
+    RGBFUSION2_57XX_LEDS_MIN,
+    RGBFUSION2_57XX_LEDS_MAX,
     "ARGB_V2_2"
 };
 
 static const gb_fusion2_zone alt_argb_v2_2_zone =
 {
     LED4,
-    0,
-    1024,
+    RGBFUSION2_57XX_LEDS_MIN,
+    RGBFUSION2_57XX_LEDS_MAX,
     "ARGB_V2_2"
 };
 
 static const gb_fusion2_zone common_argb_v2_3_1_zone =
 {
     HDR_D_LED1,
-    0,
-    1024,
+    RGBFUSION2_57XX_LEDS_MIN,
+    RGBFUSION2_57XX_LEDS_MAX,
     "ARGB_V2_3"
 };
 
 static const gb_fusion2_zone common_argb_v2_3_zone =
 {
     HDR_D_LED3,
-    0,
-    1024,
+    RGBFUSION2_57XX_LEDS_MIN,
+    RGBFUSION2_57XX_LEDS_MAX,
     "ARGB_V2_3"
 };
 
 static const gb_fusion2_zone common_argb_v2_4_zone =
 {
     HDR_D_LED4,
-    0,
-    1024,
+    RGBFUSION2_57XX_LEDS_MIN,
+    RGBFUSION2_57XX_LEDS_MAX,
     "ARGB_V2_4"
 };
 

Controllers/GigabyteRGBFusion2USBController/GigabyteFusion2USB_Devices.h

@@ -4,8 +4,8 @@
 |   Gigabyte Fusion 2 USB Device layouts and                |
 |     and mapping to the device IDs stored on chip          |
 |                                                           |
-|   megadjc                                     31 Jul 2025 |
 |   chrism                                      29 Aug 2025 |
+|   megadjc                                     03 Sep 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-only                   |
@@ -54,6 +54,8 @@ enum GB_FUSION2_LED_IDX
     HDR_D_LED4          = 8,
     HDR_D_LED3_ARGB     = 0x62,
     HDR_D_LED4_ARGB     = 0x63,
+    ONBOARD1_ARGB       = 0x64,
+    ONBOARD2_ARGB       = 0x65,
 };
 
 /*-------------------------------------------------*\