Use read byte data for ENE detect

.gitignore

@@ -6,8 +6,6 @@ OpenRGB
 openrgb
 OpenRGB-x86_64.AppImage
 60-openrgb.rules
-debian/changelog
-fedora/OpenRGB.spec
 
 # Directories
 .build/

.gitlab-ci.yml

@@ -43,7 +43,6 @@ before_script:
     name: "${CI_PROJECT_NAME}_Supported_Devices_${CI_COMMIT_SHORT_SHA}"
     paths:
     - ./*.md
-    - Supported Devices.csv
     exclude:
     - README.md
     - CONTRIBUTING.md
@@ -109,10 +108,9 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
   stage: build
   script:
-  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage --target-arch i386 -us -B
-  - rm -v ../openrgb-dbgsym*.*deb
+  - rm -v ../openrgb-dbgsym*.deb
   - mv -v ../openrgb*.deb ./
 
   artifacts:
@@ -120,7 +118,7 @@ before_script:
     paths:
     - openrgb*.deb
     exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
     expire_in: 30 days
 
   rules:
@@ -138,10 +136,9 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
   stage: build
   script:
-  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.*deb
+  - rm -v ../openrgb-dbgsym*.deb
   - mv -v ../openrgb*.deb ./
 
   artifacts:
@@ -149,7 +146,7 @@ before_script:
     paths:
     - openrgb*.deb
     exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
     expire_in: 30 days
 
   rules:
@@ -167,10 +164,9 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
   stage: build
   script:
-  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage --target-arch i386 -us -B
-  - rm -v ../openrgb-dbgsym*.*deb
+  - rm -v ../openrgb-dbgsym*.deb
   - mv -v ../openrgb*.deb ./
 
   artifacts:
@@ -178,7 +174,7 @@ before_script:
     paths:
     - openrgb*.deb
     exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
     expire_in: 30 days
 
   rules:
@@ -196,10 +192,9 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
   stage: build
   script:
-  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.*deb
+  - rm -v ../openrgb-dbgsym*.deb
   - mv -v ../openrgb*.deb ./
 
   artifacts:
@@ -207,7 +202,7 @@ before_script:
     paths:
     - openrgb*.deb
     exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
     expire_in: 30 days
 
   rules:
@@ -225,7 +220,6 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
   stage: build
   script:
-  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage --target-arch i386 -us -B
   - rm -v ../openrgb-dbgsym*.deb
@@ -254,7 +248,6 @@ before_script:
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
   stage: build
   script:
-  - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
   - rm -v ../openrgb-dbgsym*.deb
@@ -284,7 +277,6 @@ before_script:
   script:
   - dnf install rpmdevtools dnf-plugins-core -y
   - rpmdev-setuptree
-  - ./scripts/build-package-files.sh fedora/OpenRGB.spec
   - ls /root/
   - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
   - cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
@@ -317,9 +309,8 @@ before_script:
   image: fedora:36
   stage: build
   script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel -y
+  - dnf install rpmdevtools dnf-plugins-core libcurl-devel -y
   - rpmdev-setuptree
-  - ./scripts/build-package-files.sh fedora/OpenRGB.spec
   - ls /root/
   - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
   - cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
@@ -355,6 +346,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 32 .deb (Debian Buster)"
@@ -371,6 +363,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Buster)"
@@ -387,6 +380,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 32 .deb (Debian Bullseye)"
@@ -403,6 +397,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Bullseye)"
@@ -419,6 +414,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 32 .deb (Debian Bookworm)"
@@ -435,6 +431,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Bookworm)"
@@ -451,6 +448,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Buster)"
@@ -467,6 +465,7 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
+  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Bookworm)"
@@ -482,6 +481,7 @@ before_script:
   script:
   - yum -y localinstall ./openrgb*64.rpm
   - openrgb --version
+  - openrgb -l
   - yum -y remove openrgb
   dependencies:
   - "Linux 64 f35 rpm"
@@ -497,6 +497,7 @@ before_script:
   script:
   - yum -y localinstall ./openrgb*64.rpm
   - openrgb --version
+  - openrgb -l
   - yum -y remove openrgb
   dependencies:
   - "Linux 64 f36 rpm"
@@ -528,9 +529,9 @@ before_script:
   - mkdir _qt
   - mkdir _qt_download
   - Push-Location _qt_download
-  - curl.exe -LJ -o qt-base.7z  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610076/download'
-  - curl.exe -LJ -o qt-tools.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610097/download'
-  - curl.exe -LJ -o qt-jom.zip  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610138/download'
+  - curl.exe -LJ -o qt-base.7z  'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
+  - curl.exe -LJ -o qt-tools.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
+  - curl.exe -LJ -o qt-jom.zip  'https://qt-mirror.dannhauer.de/official_releases/jom/jom.zip'
   - _fold_final_
 
   - _fold_start_ 'extracting the downloaded qt binaries'
@@ -546,6 +547,10 @@ before_script:
   - Pop-Location
   - _fold_final_
 
+  - _fold_start_ 'Generate qm files'
+  - .\_qt\5.15.0\msvc2019\bin\lrelease OpenRGB.pro
+  - _fold_final_
+
   - _fold_start_ 'run qmake and generate the msvc nmake makefile'
   - mkdir _build; cd _build
   - ..\_qt\5.15.0\msvc2019\bin\qmake ..\OpenRGB.pro
@@ -604,9 +609,9 @@ before_script:
   - mkdir _qt
   - mkdir _qt_download
   - Push-Location _qt_download
-  - curl.exe -LJ -o qt-base.7z  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610116/download'
-  - curl.exe -LJ -o qt-tools.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610131/download'
-  - curl.exe -LJ -o qt-jom.zip  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610138/download'
+  - curl.exe -LJ -o qt-base.7z  'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
+  - curl.exe -LJ -o qt-tools.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
+  - curl.exe -LJ -o qt-jom.zip  'https://qt-mirror.dannhauer.de/official_releases/jom/jom.zip'
   - _fold_final_
 
   - _fold_start_ 'extracting the downloaded qt binaries'
@@ -622,6 +627,10 @@ before_script:
   - Pop-Location
   - _fold_final_
 
+  - _fold_start_ 'Generate qm files'
+  - .\_qt\5.15.0\msvc2019_64\bin\lrelease OpenRGB.pro
+  - _fold_final_
+
   - _fold_start_ 'run qmake and generate the msvc nmake makefile'
   - mkdir _build; cd _build
   - ..\_qt\5.15.0\msvc2019_64\bin\qmake ..\OpenRGB.pro

.vscode/extensions.json

@@ -1,10 +0,0 @@
-{
-    // See http://go.microsoft.com/fwlink/?LinkId=827846
-    // for the documentation about the extensions.json format
-    "recommendations": [
-        "EditorConfig.EditorConfig"
-    ],
-    "unwantedRecommendations": [
-        "ms-vscode.cpptools-extension-pack"
-    ]
-}

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -17,6 +17,8 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
     dev         = dev_handle;
     location    = path;
 
+    strcpy(device_name, "AMD Wraith Prism");
+
     current_fan_mode            = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
     current_fan_speed           = 0xFF;
     current_fan_random_color    = false;
@@ -31,6 +33,8 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
     current_ring_speed          = 0xFF;
     current_ring_direction      = false;
     current_ring_brightness     = 0xFF;
+
+    SendEnableCommand();
 }
 
 AMDWraithPrismController::~AMDWraithPrismController()
@@ -43,6 +47,11 @@ std::string AMDWraithPrismController::GetLocationString()
     return("HID: " + location);
 }
 
+char* AMDWraithPrismController::GetDeviceName()
+{
+    return device_name;
+}
+
 std::string AMDWraithPrismController::GetSerialString()
 {
     wchar_t serial_string[128];
@@ -59,6 +68,41 @@ std::string AMDWraithPrismController::GetSerialString()
     return(return_string);
 }
 
+std::string AMDWraithPrismController::GetEffectChannelString(unsigned char channel)
+{
+    std::string ret_string = "";
+
+    unsigned char usb_buf[] =
+    {
+        0x00,
+        0x40, 0x21, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+    };
+
+    usb_buf[0x03] = channel;
+
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
+
+    ret_string.append((char *)&usb_buf[0x08]);
+
+    return(ret_string);
+}
+
 std::string AMDWraithPrismController::GetFirmwareVersionString()
 {
     std::string ret_string = "";
@@ -188,7 +232,7 @@ void AMDWraithPrismController::SetRingEffectChannel(unsigned char channel)
     SendChannelRemap(channel, AMD_WRAITH_PRISM_EFFECT_CHANNEL_LOGO_LED, AMD_WRAITH_PRISM_EFFECT_CHANNEL_FAN_LED);
 }
 
-void AMDWraithPrismController::SendEnableCommand(bool direct)
+void AMDWraithPrismController::SendEnableCommand()
 {
     unsigned char usb_buf[] =
     {
@@ -211,11 +255,6 @@ void AMDWraithPrismController::SendEnableCommand(bool direct)
         0x00, 0x00, 0x00, 0x00,
     };
 
-    if(direct)
-    {
-        usb_buf[0x02]   = 0x03;
-    }
-
     hid_write(dev, usb_buf, 65);
     hid_read(dev, usb_buf, 64);
 }
@@ -247,48 +286,6 @@ void AMDWraithPrismController::SendApplyCommand()
     hid_read(dev, usb_buf, 64);
 }
 
-void AMDWraithPrismController::SendDirectPacket
-    (
-    unsigned char   size,
-    unsigned char * led_ids,
-    RGBColor *      colors
-    )
-{
-    unsigned char usb_buf[] =
-    {
-        0x00,
-        0xC0, 0x01, size, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-    };
-
-    for(unsigned int led_idx = 0; led_idx < size; led_idx++)
-    {
-        unsigned int index  = led_idx * 4;
-
-        usb_buf[index + 5]  = led_ids[led_idx];
-        usb_buf[index + 6]  = RGBGetRValue(colors[led_idx]);
-        usb_buf[index + 7]  = RGBGetGValue(colors[led_idx]);
-        usb_buf[index + 8]  = RGBGetBValue(colors[led_idx]);
-    }
-
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
-}
-
 void AMDWraithPrismController::SendEffectChannelUpdate
     (
     unsigned char effect_channel,

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

@@ -10,8 +10,6 @@
 #include <string>
 #include <hidapi/hidapi.h>
 
-#include "RGBController.h"
-
 #pragma once
 
 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX     0xFF
@@ -76,7 +74,6 @@ enum
     AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE       = 0x09, /* Chase effect channel         */
     AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL       = 0x0A, /* Swirl effect channel         */
     AMD_WRAITH_PRISM_EFFECT_CHANNEL_MORSE       = 0x0B, /* Morse code effect channel    */
-    AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT      = 0xFF, /* Value for direct mode        */
 };
 
 enum
@@ -94,11 +91,29 @@ public:
     AMDWraithPrismController(hid_device* dev_handle, const char* path);
     ~AMDWraithPrismController();
 
+    char* GetDeviceName();
+
     std::string GetEffectChannelString(unsigned char channel);
     std::string GetFirmwareVersionString();
     std::string GetLocationString();
     std::string GetSerialString();
 
+    void SetRingEffectChannel(unsigned char channel);
+
+    void SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
+    void SetFanColor(unsigned char red, unsigned char green, unsigned char blue);
+
+    void SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
+    void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);
+
+    void SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color);
+    void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);
+
+private:
+    char                    device_name[32];
+    hid_device*             dev;
+    std::string             location;
+
     unsigned char           current_fan_mode;
     unsigned char           current_fan_speed;
     unsigned char           current_fan_brightness;
@@ -115,30 +130,10 @@ public:
     bool                    current_ring_direction;
     bool                    current_ring_random_color;
 
-    void SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
-    void SetFanColor(unsigned char red, unsigned char green, unsigned char blue);
-    void SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
-    void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);
-    void SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color);
-    void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);
-
-    void SendDirectPacket
-        (
-        unsigned char   size,
-        unsigned char * led_ids,
-        RGBColor *      colors
-        );
-
-    void SendEnableCommand(bool direct);
+    void SendEnableCommand();
 
     void SendApplyCommand();
 
-private:
-    hid_device*             dev;
-    std::string             location;
-
-    void SetRingEffectChannel(unsigned char channel);
-
     void SendEffectChannelUpdate
         (
         unsigned char effect_channel,

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -33,29 +33,33 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
     description = "AMD Wraith Prism Device";
     version     = controller->GetFirmwareVersionString();
     location    = controller->GetLocationString();
+    /*-----------------------------------------------------*\
+    | Don't use HID serial string, it is inconsistent on my |
+    | Wraith Prism                                          |
+    \*-----------------------------------------------------*/
+    serial      = "";//controller->GetSerialString();
 
     mode Direct;
     Direct.name                 = "Direct";
-    Direct.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT;
+    Direct.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
     Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Direct.brightness_min       = 0;
-    Direct.brightness_max       = 0;
-    Direct.brightness           = 0;
+    Direct.brightness_max       = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Direct.brightness           = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
     Direct.color_mode           = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Breathing;
     Breathing.name              = "Breathing";
     Breathing.value             = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Breathing.speed_min         = AMD_WRAITH_PRISM_SPEED_SLOWEST;
     Breathing.speed_max         = AMD_WRAITH_PRISM_SPEED_FASTEST;
     Breathing.brightness_min    = 0;
     Breathing.brightness_max    = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
     Breathing.brightness        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.color_mode        = MODE_COLORS_PER_LED;
     Breathing.speed             = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    Breathing.colors.resize(3);
     modes.push_back(Breathing);
 
     mode ColorCycle;
@@ -100,29 +104,27 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
     mode Chase;
     Chase.name                  = "Chase";
     Chase.value                 = AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE;
-    Chase.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Chase.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Chase.speed_min             = AMD_WRAITH_PRISM_SPEED_SLOWEST;
     Chase.speed_max             = AMD_WRAITH_PRISM_SPEED_FASTEST;
     Chase.brightness_min        = 0;
     Chase.brightness_max        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
     Chase.brightness            = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Chase.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Chase.color_mode            = MODE_COLORS_PER_LED;
     Chase.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    Chase.colors.resize(3);
     modes.push_back(Chase);
 
     mode Swirl;
     Swirl.name                  = "Swirl";
     Swirl.value                 = AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL;
-    Swirl.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Swirl.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Swirl.speed_min             = AMD_WRAITH_PRISM_SPEED_SLOWEST;
     Swirl.speed_max             = AMD_WRAITH_PRISM_SPEED_FASTEST;
     Swirl.brightness_min        = 0;
     Swirl.brightness_max        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
     Swirl.brightness            = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Swirl.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Swirl.color_mode            = MODE_COLORS_PER_LED;
     Swirl.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    Swirl.colors.resize(3);
     modes.push_back(Swirl);
 
     SetupZones();
@@ -135,14 +137,6 @@ RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
 
 void RGBController_AMDWraithPrism::SetupZones()
 {
-    /*---------------------------------------------------------*\
-    | LED maps                                                  |
-    \*---------------------------------------------------------*/
-    const unsigned int logo_leds[1] =   { 0x00 };
-    const unsigned int fan_leds[1] =    { 0x01 };
-    const unsigned int ring_leds[14] =  { 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x10, 0x0F,
-                                          0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09 };
-
     /*---------------------------------------------------------*\
     | Set up zones                                              |
     \*---------------------------------------------------------*/
@@ -166,39 +160,27 @@ void RGBController_AMDWraithPrism::SetupZones()
 
     zone ring_zone;
     ring_zone.name          = "Ring";
-    ring_zone.type          = ZONE_TYPE_LINEAR;
-    ring_zone.leds_min      = 14;
-    ring_zone.leds_max      = 14;
-    ring_zone.leds_count    = 14;
+    ring_zone.type          = ZONE_TYPE_SINGLE;
+    ring_zone.leds_min      = 1;
+    ring_zone.leds_max      = 1;
+    ring_zone.leds_count    = 1;
     ring_zone.matrix_map    = NULL;
     zones.push_back(ring_zone);
 
     /*---------------------------------------------------------*\
     | Set up LEDs                                               |
     \*---------------------------------------------------------*/
-    for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
-    {
-        led logo_led;
-        logo_led.name = "Logo LED";
-        logo_led.value = logo_leds[led_idx];
-        leds.push_back(logo_led);
-    }
+    led logo_led;
+    logo_led.name = "Logo LED";
+    leds.push_back(logo_led);
 
-    for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
-    {
-        led fan_led;
-        fan_led.name = "Fan LED";
-        fan_led.value = fan_leds[led_idx];
-        leds.push_back(fan_led);
-    }
+    led fan_led;
+    fan_led.name = "Fan LED";
+    leds.push_back(fan_led);
 
-    for(unsigned int led_idx = 0; led_idx < 14; led_idx++)
-    {
-        led ring_led;
-        ring_led.name = "Ring LED";
-        ring_led.value = ring_leds[led_idx];
-        leds.push_back(ring_led);
-    }
+    led ring_led;
+    ring_led.name = "Ring LED";
+    leds.push_back(ring_led);
 
     SetupColors();
 }
@@ -212,95 +194,68 @@ void RGBController_AMDWraithPrism::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
 {
-    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+    controller->SetLogoColor(red, grn, blu);
+
+    red = RGBGetRValue(colors[1]);
+    grn = RGBGetGValue(colors[1]);
+    blu = RGBGetBValue(colors[1]);
+    controller->SetFanColor(red, grn, blu);
+
+    red = RGBGetRValue(colors[2]);
+    grn = RGBGetGValue(colors[2]);
+    blu = RGBGetBValue(colors[2]);
+    controller->SetRingColor(red, grn, blu);
+}
+
+void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
+{
+    RGBColor      color = colors[zone];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
+
+    if(zone == 0)
     {
-        unsigned char   led_ids[15];
-        RGBColor        color_buf[15];
-        unsigned int    leds_count = 0;
-
-        for(unsigned int led_idx = 0; led_idx < colors.size(); led_idx++)
-        {
-            led_ids[leds_count]     = (unsigned char)leds[led_idx].value;
-            color_buf[leds_count]   = colors[led_idx];
-
-            leds_count++;
-
-            if(leds_count >= 15)
-            {
-                controller->SendDirectPacket(15, led_ids, color_buf);
-                leds_count = 0;
-            }
-        }
-
-        if(leds_count > 0)
-        {
-            controller->SendDirectPacket(leds_count, led_ids, color_buf);
-        }
-    }
-    else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        unsigned char red = RGBGetRValue(modes[active_mode].colors[0]);
-        unsigned char grn = RGBGetGValue(modes[active_mode].colors[0]);
-        unsigned char blu = RGBGetBValue(modes[active_mode].colors[0]);
         controller->SetLogoColor(red, grn, blu);
-
-        red = RGBGetRValue(modes[active_mode].colors[1]);
-        grn = RGBGetGValue(modes[active_mode].colors[1]);
-        blu = RGBGetBValue(modes[active_mode].colors[1]);
+    }
+    else if(zone == 1)
+    {
         controller->SetFanColor(red, grn, blu);
-
-        red = RGBGetRValue(modes[active_mode].colors[2]);
-        grn = RGBGetGValue(modes[active_mode].colors[2]);
-        blu = RGBGetBValue(modes[active_mode].colors[2]);
+    }
+    else if(zone == 2)
+    {
         controller->SetRingColor(red, grn, blu);
     }
-    else
-    {
-        controller->SetLogoColor(0, 0, 0);
-        controller->SetFanColor(0, 0, 0);
-        controller->SetRingColor(0, 0, 0);
-    }
 }
 
-void RGBController_AMDWraithPrism::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AMDWraithPrism::UpdateSingleLED(int led)
 {
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AMDWraithPrism::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
+    UpdateZoneLEDs(led);
 }
 
 void RGBController_AMDWraithPrism::DeviceUpdateMode()
 {
     bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
 
+    controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
+
     switch(modes[active_mode].value)
     {
-        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT:
-            controller->SendEnableCommand(true);
-            controller->SendApplyCommand();
-            break;
-
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE:
-            controller->SendEnableCommand(false);
-            controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
             controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
             controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
             break;
 
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW:
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE:
-            controller->SendEnableCommand(false);
-            controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
             controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
             controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
             break;
 
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
-            controller->SendEnableCommand(false);
-            controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
             controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
             controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
             break;
@@ -308,15 +263,11 @@ void RGBController_AMDWraithPrism::DeviceUpdateMode()
         default:
             if(random)
             {
-                controller->SendEnableCommand(false);
-                controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
                 controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
                 controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
             }
             else
             {
-                controller->SendEnableCommand(false);
-                controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
                 controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
                 controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
             }

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -5,22 +5,18 @@
 |  lighting controller                      |
 |                                           |
 |  Ed Kambulow (dredvard) 12/20/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/
-#include <cstring>
-#include <stdio.h>
 
 #include "RGBController.h"
-#include "ResourceManager.h"
 #include "ASRockPolychromeUSBController.h"
+#include <cstring>
+#include <stdio.h>
 #include "dependencies/dmiinfo.h"
 
 #define POLYCHROME_USB_READ_ZONE_CONFIG 0x11
 #define POLYCHROME_USB_READ_HEADER      0x14
 #define POLYCHROME_USB_WRITE_HEADER     0x15
 #define POLYCHROME_USB_SET_ZONE         0x10
-#define POLYCHROME_USB_INITIAL_CHUNK    0xE3
-#define POLYCHROME_USB_SEND_CHUNK       0xE4
 #define POLYCHROME_USB_INIT             0xA4
 #define POLYCHROME_USB_COMMIT           0x12
 
@@ -33,7 +29,7 @@ const char* polychrome_USB_zone_names[] =
     "PCH",
     "IO Cover",
     "PCB",
-    "Addressable Header 3/Audio",
+    "Audio",
 };
 
 PolychromeUSBController::PolychromeUSBController(hid_device* dev_handle, const char* path)
@@ -86,64 +82,19 @@ std::string PolychromeUSBController::GetSerialString()
 void PolychromeUSBController::SetDeviceInfo()
 {
     PolychromeDeviceInfo newdev_info;
-
     ReadConfigTables();
 
-    /*--------------------------------------------------*\
-    | Read settings to check for configured RGSwap       |
-    \*--------------------------------------------------*/
-    const std::string detector_name     = "ASRock Polychrome USB";
-    const std::string json_rgswap       = "RGSwap";
-    SettingsManager* settings_manager   = ResourceManager::get()->GetSettingsManager();
-    json device_settings                = settings_manager->GetSettings(detector_name);
-
-    /*---------------------------------------------------------*\
-    | Get RGSwap settings from the settings manager             |
-    | If RGSwap settings are not found then write them out      |
-    | Onboard leds are set to their existing values,            |
-    | Addressable RGB and RGB headers are set to false          |
-    \*---------------------------------------------------------*/
-    if(!device_settings.contains(json_rgswap))
-    {
-        device_settings[json_rgswap][polychrome_USB_zone_names[0]] = false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[1]] = false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[2]] = false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[3]] = false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[4]] = ((configtable[8] >> 4) & 1) ? true : false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[5]] = ((configtable[8] >> 5) & 1) ? true : false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[6]] = ((configtable[8] >> 6) & 1) ? true : false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[7]] = false;
-
-        settings_manager->SetSettings(detector_name, device_settings);
-        settings_manager->SaveSettings();
-    }
-    else
-    {
-        for(std::size_t idx = 0; idx < 8; idx++)
-        {
-            if(device_settings[json_rgswap].contains(polychrome_USB_zone_names[idx]))
-            {
-                rgswapconfig[idx] = device_settings[json_rgswap][polychrome_USB_zone_names[idx]];
-            }
-        }
-    }
-
-    bool rgswap_final[8] = {0};
-
     for (unsigned int zonecnt = 0; zonecnt < POLYCHROME_USB_ZONE_MAX_NUM; zonecnt++)
     {
-        if(configtable[zonecnt] == 0x1E || !((configtable[9] >> zonecnt) & 1))
+        if(configtable[zonecnt] == 0x1E)
         {
 			/*-----------------------------------------------------------------------*\
 			| If we don't have this device type (0x1E) we will skip it and continue.  |
-            | Or if the device is not available we skip it and continue               |
 			\*-----------------------------------------------------------------------*/
             continue;
         }
 
         newdev_info.num_leds = configtable[zonecnt];
-        newdev_info.rgswap = ((configtable[8] >> zonecnt) & 1) || rgswapconfig[zonecnt];
-        rgswap_final[zonecnt] = newdev_info.rgswap;
 
 		/*--------------------------------------------------------------------------------------------------*\
 		| We will need to know what zone type this is, so that we can look up the name and make calls later. |
@@ -157,11 +108,6 @@ void PolychromeUSBController::SetDeviceInfo()
             \*-----------------------------------------*/
             case POLYCHROME_USB_ZONE_ARGB1:
             case POLYCHROME_USB_ZONE_ARGB2:
-            /*---------------------------------------------*\
-            | The last led channel is allocated to a       |
-            | third ARGB header on some newer motherboards |
-            \*---------------------------------------------*/
-            case POLYCHROME_USB_ZONE_AUDIO:
                 newdev_info.device_type = PolychromeDeviceType::ADDRESSABLE;
                 break;
 
@@ -171,9 +117,10 @@ void PolychromeUSBController::SetDeviceInfo()
             case POLYCHROME_USB_ZONE_PCH:
             case POLYCHROME_USB_ZONE_IOCOVER:
             case POLYCHROME_USB_ZONE_PCB:
+            case POLYCHROME_USB_ZONE_AUDIO:
                 newdev_info.device_type = PolychromeDeviceType::FIXED;
                 break;
-
+            
             /*-----------------------------------------*\
             | Type: Fixed                               |
             \*-----------------------------------------*/
@@ -186,26 +133,6 @@ void PolychromeUSBController::SetDeviceInfo()
 
         device_info.push_back(newdev_info);
     }
-
-    // set rgswap to match our settings
-    WriteRGSwap(rgswap_final[0], rgswap_final[1], rgswap_final[2], rgswap_final[3], rgswap_final[4], rgswap_final[5], rgswap_final[6], rgswap_final[7]);
-}
-
-void PolychromeUSBController::ResizeZone(int zone, int new_size)
-{
-    unsigned char zonecfg[POLYCHROME_USB_ZONE_MAX_NUM];
-
-    memset(zonecfg, POLYCHROME_USB_ZONE_UNAVAILABLE, POLYCHROME_USB_ZONE_MAX_NUM);
-
-    configtable[zone] = new_size;
-
-    for(unsigned int i = 0; i < POLYCHROME_USB_ZONE_MAX_NUM; i++)
-    {
-        zonecfg[i] = configtable[i];
-    }
-
-    unsigned char zonecmd = POLYCHROME_USB_LEDCOUNT_CFG;
-    WriteHeader(zonecmd, zonecfg, sizeof(zonecfg));
 }
 
 void PolychromeUSBController::WriteZone
@@ -236,18 +163,8 @@ void PolychromeUSBController::WriteZone
 	usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
     usb_buf[0x03] = device_info.zone_type; 
 	usb_buf[0x04] = mode;
-
-    if(device_info.rgswap)
-    {
-        usb_buf[0x05] = RGBGetRValue(rgb);
-        usb_buf[0x06] = RGBGetGValue(rgb);
-    }
-    else
-    {
-        usb_buf[0x05] = RGBGetGValue(rgb);
-        usb_buf[0x06] = RGBGetRValue(rgb);
-    }
-
+	usb_buf[0x05] = RGBGetRValue(rgb);
+	usb_buf[0x06] = RGBGetGValue(rgb);
 	usb_buf[0x07] = RGBGetBValue(rgb);
 	usb_buf[0x08] = speed;
 	usb_buf[0x09] = 0xFF;
@@ -266,122 +183,63 @@ void PolychromeUSBController::WriteAllZones
     const std::vector<zone>&                zones
     )
 {
-    std::vector<unsigned char> combined_leds_rgb;
-    std::size_t max_led_count = 0;
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++){
-        PolychromeDeviceInfo device_info = GetPolychromeDevices()[zone_idx];
-
-        for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
-        {
-            if(device_info.rgswap)
-            {
-                combined_leds_rgb.push_back(RGBGetRValue(zones[zone_idx].colors[led_idx]));
-                combined_leds_rgb.push_back(RGBGetGValue(zones[zone_idx].colors[led_idx]));
-            }
-            else
-            {
-                combined_leds_rgb.push_back(RGBGetGValue(zones[zone_idx].colors[led_idx]));
-                combined_leds_rgb.push_back(RGBGetRValue(zones[zone_idx].colors[led_idx]));
-            }
-            combined_leds_rgb.push_back(RGBGetBValue(zones[zone_idx].colors[led_idx]));
-        }
-        max_led_count += zones[zone_idx].leds_max;
-    }
-    combined_leds_rgb.resize((max_led_count + 8) * 3, 0);
-
     unsigned char usb_buf[65];
+
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
     \*-----------------------------------------------------*/
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
     /*-----------------------------------------------------*\
-    | Set up initial message packet with leading 00         |
+    | Set up message packet with leading 00                  |
     \*-----------------------------------------------------*/
     usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
-    usb_buf[0x03] = 0xFF;
-    usb_buf[0x04] = POLYCHROME_USB_INITIAL_CHUNK;
-    usb_buf[0x07] = 0xFF;
-    usb_buf[0x40] = 0x65;
+    usb_buf[0x03] = 0x07;
+    usb_buf[0x04] = zones_info[0].mode;
+    usb_buf[0x04] = 0xE2;
 
-    std::size_t initial_led_offset = 9;
-    std::size_t message_byte_capacity = 54;           // 18 leds * 3 bytes
-
-    std::size_t led_byte_idx = 0;
-
-    while(led_byte_idx < combined_leds_rgb.size())
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
-        for(std::size_t byte_idx = 0; byte_idx < message_byte_capacity; byte_idx++)
-        {
-            usb_buf[initial_led_offset + byte_idx] = combined_leds_rgb[led_byte_idx++];
-            if(led_byte_idx >= combined_leds_rgb.size())
-            {
-                break;
-            }
-        }
-
-        /*-----------------------------------------------------*\
-        | Send packet                                           |
-        \*-----------------------------------------------------*/
-        hid_write(dev, usb_buf, 65);
-
-        /*-----------------------------------------------------*\
-        | Zero out buffer                                       |
-        \*-----------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        /*-----------------------------------------------------*\
-        | Set up message packet with leading 00                  |
-        \*-----------------------------------------------------*/
-        usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
-        usb_buf[0x03] = 0xFF;
-        usb_buf[0x04] = POLYCHROME_USB_SEND_CHUNK;
-        usb_buf[0x40] = 0x65;
-
-        initial_led_offset = 5;
-        message_byte_capacity = 57;                 // 19 leds * 3 bytes
-    }
-}
-
-/*-----------------------------------------------------*\
-| If reset is true, rgswap is set to the values         |
-| specified in the settings file, otherwise set to off  |
-\*-----------------------------------------------------*/
-void PolychromeUSBController::SetRGSwap(bool reset)
-{
-    if(reset)
-    {
-        bool rg[8] = {0};
-        std::vector<PolychromeDeviceInfo> devices_info = GetPolychromeDevices();
-        for (PolychromeDeviceInfo device : devices_info)
-        {
-            rg[device.zone_type] = device.rgswap;
-        }
-        WriteRGSwap(rg[0], rg[1], rg[2], rg[3], rg[4], rg[5], rg[6], rg[7]);
-    }
-    else
-    {
-        /*-----------------------------------------------------------------*\
-        | Disable RGSwap as it causes flashing on each update in direct mode|
-        \*-----------------------------------------------------------------*/
-        WriteRGSwap(0, 0, 0, 0, 0, 0, 0, 0);
+        usb_buf[0x05 + (3 * zone_idx)    ] = RGBGetRValue(zones[zone_idx].colors[0]);
+        usb_buf[0x05 + (3 * zone_idx) + 1] = RGBGetGValue(zones[zone_idx].colors[0]);
+        usb_buf[0x05 + (3 * zone_idx) + 2] = RGBGetBValue(zones[zone_idx].colors[0]);
     }
+    
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
 }
 
 void PolychromeUSBController::WriteRGSwap
     (
-    bool hdr0,
-    bool hdr1,
-    bool ahdr0,
     bool ahdr1,
-    bool pch,
-    bool io,
-    bool pcb,
-    bool chnl8
+    bool ahdr0,
+    bool hdr1,
+    bool hdr0
     )
 {
-    unsigned char rgconfig[1] = {static_cast<unsigned char>(((chnl8 << 7) | (pcb << 6) | (io << 5) | (pch << 4) | (ahdr1 << 3) | (ahdr0 << 2) | (hdr1 << 1) | hdr0))};
-    WriteHeader(POLYCHROME_USB_RGSWAP_CFG, rgconfig, 1);
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00                 |
+    \*-----------------------------------------------------*/
+	usb_buf[0x01] = POLYCHROME_USB_WRITE_HEADER;
+
+    usb_buf[0x04] = POLYCHROME_USB_RGSWAP_CFG;
+	usb_buf[0x05] = ((ahdr1 << 3) & (ahdr0 << 2) & (hdr1 << 1) & hdr0) & 0x40;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
 }
 
 void PolychromeUSBController::WriteHeader
@@ -451,23 +309,8 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
     g   = usb_buf[0x06];
     b   = usb_buf[0x07];
 
-    /*------------------------------------------------------*\
-    | Set Chroma mode (0xE2) & Per-Led mode (0xE3) as Direct |
-    \*------------------------------------------------------*/
-    zoneinfo.mode   = usb_buf[0x04] != 0xE2 && usb_buf[0x04] != 0xE3 && usb_buf[0x04] < 0x0F ? usb_buf[0x04] : 0x0F;
-
-    /*------------------------------------------------------*\
-    | G & R are swapped since RGSwap is disabled on init,    |
-    | Unless overwritten in settings                         |
-    \*------------------------------------------------------*/
-    if(device_info.rgswap)
-    {
-        zoneinfo.color  = ToRGBColor(r,g,b);
-    }
-    else
-    {
-        zoneinfo.color  = ToRGBColor(g,r,b);
-    }
+    zoneinfo.mode   = usb_buf[0x04] != 0xE2 ? usb_buf[0x04] : 0x0F;
+    zoneinfo.color  = ToRGBColor(r,g,b);  
     zoneinfo.speed  = usb_buf[0x08];
     zoneinfo.zone   = usb_buf[0x03];
 
@@ -478,7 +321,7 @@ void PolychromeUSBController::ReadConfigTables()
 {
     unsigned char usb_buf[65];
     unsigned char maxzoneleds[8];
-    unsigned char rgswap;
+    unsigned char rgbswap;
     unsigned char header1;
 
     /*-----------------------------------------------------*\
@@ -505,7 +348,7 @@ void PolychromeUSBController::ReadConfigTables()
 
     /*-----------------------------------------------------*\
     | Reads in format: RGB1, RGB2, ARGB1, ARGB2, PCH, IO,   |
-    | PCB, AUDIO/ARGB3                                      |
+    | PCB, AUDIO                                            |
     \*-----------------------------------------------------*/
     memcpy(&maxzoneleds,&usb_buf[0x04],8);
 
@@ -525,10 +368,10 @@ void PolychromeUSBController::ReadConfigTables()
     hid_read(dev, usb_buf, 64);
 
     /*-----------------------------------------------------*\
-    | Reads bitwise in format: AUDIO/ARGB3, PCB, IO, PCH,   |
-    | ARGB2,ARGB1, RGB2, RGB1 if available                  |
+    | Reads bitwise in format: AUDIO, PCB, IO, PCH, ARGB2,  |
+    | ARGB1, RGB2, RGB1 if available                        |
     \*-----------------------------------------------------*/
-    rgswap=usb_buf[4];
+    rgbswap=usb_buf[4];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -544,15 +387,10 @@ void PolychromeUSBController::ReadConfigTables()
     hid_write(dev, usb_buf, 64);
     memset(usb_buf, 0x00, sizeof(usb_buf));
     hid_read(dev, usb_buf, 64);
-
-    /*-----------------------------------------------------*\
-    | Reads bitwise in format: AUDIO/ARGB3, PCB, IO, PCH,   |
-    | ARGB2,ARGB1, RGB2, RGB1 if available                  |
-    \*-----------------------------------------------------*/
     header1=usb_buf[4];
 
     memcpy(configtable,&maxzoneleds,8);
-    configtable[8]=rgswap;
+    configtable[8]=rgbswap;
     configtable[9]=header1;
     return;
 }

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

@@ -5,7 +5,6 @@
 |  lighting controller                      |
 |                                           |
 |  Ed Kambulow (dredvard) 12/20/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/
 
 #include "RGBController.h"
@@ -70,7 +69,7 @@ enum
     POLYCHROME_USB_ZONE_PCH          = 0X04,  // PCH
     POLYCHROME_USB_ZONE_IOCOVER      = 0X05,  // IOCOVER
     POLYCHROME_USB_ZONE_PCB          = 0X06,  // PCB - Could be mixed swapped with 0x07
-    POLYCHROME_USB_ZONE_AUDIO        = 0X07   // AUDIO/ARGB Header 3
+    POLYCHROME_USB_ZONE_AUDIO        = 0X07   // AUDIO
 };
 
 enum class PolychromeDeviceType
@@ -92,7 +91,6 @@ struct PolychromeDeviceInfo
     unsigned char           effect_channel;
     unsigned char           num_leds;
 	unsigned char			zone_type;
-    bool        			rgswap;
     PolychromeDeviceType    device_type;
 };
 
@@ -133,31 +131,17 @@ public:
                                                     unsigned int    configsize
                                                     );
 
-    void                                        ResizeZone(int zone, int new_size);
-    void                                        SetRGSwap(bool reset);
-
 protected:
     hid_device*                         dev;
     std::vector<PolychromeDeviceInfo>   device_info;
     std::string                         location;
 
-    void WriteRGSwap
-        (
-        bool hdr0,
-        bool hdr1,
-        bool ahdr0,
-        bool ahdr1,
-        bool pch,
-        bool io,
-        bool pcb,
-        bool chnl8
-        );
+    void WriteRGSwap(bool ahdr1, bool ahdr0, bool hdr1, bool hdr0);
 
 private:
     unsigned int  led_count;
     std::string   device_name;
     unsigned char configtable[12];
-    bool          rgswapconfig[8] = { 0 };
 
     void SetDeviceInfo();    
     void ReadConfigTables();

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -5,7 +5,6 @@
 |  ASRock Polychrome USB Driver             |
 |                                           |
 |  Ed Kambulow (Dredvard) 12/26/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/
 
 #include "RGBController_ASRockPolychromeUSB.h"
@@ -23,6 +22,7 @@
     @effects :white_check_mark:
     @detectors DetectPolychromeUSBControllers
     @comment ASRock Polychrome controllers will save with each update.
+        Per ARGB LED support is not possible with these devices.
 \*-------------------------------------------------------------------*/
 
 RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr)
@@ -181,6 +181,11 @@ RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController
     modes.push_back(Direct);
 
     SetupZones();
+
+    /*-------------------------------------------------*\
+    | Initialize active mode                            |
+    \*-------------------------------------------------*/
+    active_mode = GetDeviceMode(1);
 }
 
 void RGBController_PolychromeUSB::SetupZones()
@@ -233,6 +238,16 @@ void RGBController_PolychromeUSB::SetupZones()
 
     SetupColors();
 
+    /*---------------------------------------------------------*\
+    | Initialize colors for each LED                            |
+    \*---------------------------------------------------------*/
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        unsigned char led = (unsigned char)leds[led_idx].value;
+
+        colors[led_idx] = controller->GetZoneConfig(led).color;     // TODO Get addressable instead of zone idx
+    }
+
     /*---------------------------------------------------------*\
     | Initialize zone info to track zone, speed, mode           |
     | B550 Boards have modes, speed for each zone               |
@@ -244,37 +259,26 @@ void RGBController_PolychromeUSB::SetupZones()
         zones_info.push_back(zoneinfo);
     }
 
-     /*---------------------------------------------------------*\
-     | Initialize colors for each LED                            |
-     | We cannot currently get the individual led color so       |
-     | we use the zone color in each zone to set all leds        |
-     | !!TODO: in Per-Led mode, zone color is always black       |
-     \*---------------------------------------------------------*/
-     for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
-     {
-         unsigned char led = (unsigned char)leds[led_idx].value;
-
-         colors[led_idx] = zones_info[led].color;
-     }
-
-     /*-------------------------------------------------*\
-     | Initialize active mode                            |
-     \*-------------------------------------------------*/
-     active_mode = zones_info.size() > 1 ? zones_info[0].mode : 0x0;
-
-     /*-----------------------------------------------------*\
-     | If in Direct mode, reset all Leds to match interface  |
-     \*-----------------------------------------------------*/
-     if(active_mode == 0x0F)
-     {
-        controller->WriteAllZones(zones_info, zones);
-     }
 }
 
 void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
 {
+     unsigned char zonecfg[ASROCK_USB_MAX_ZONES];
+
+    /*---------------------------------------------------------*\
+    | This device does not currently support resizing zones     |
+    \*---------------------------------------------------------*/
     zones[zone].leds_count = (unsigned char) new_size;
-    controller->ResizeZone(zones_info[zone].zone, new_size);
+
+    memset(zonecfg, POLYCHROME_USB_ZONE_UNAVAILABLE, ASROCK_USB_MAX_ZONES);
+
+    for(unsigned int i = 0; i < zones.size(); i++)
+    {
+        zonecfg[i]=zones[i].leds_count;
+    }
+
+    // unsigned char zonecmd = POLYCHROME_USB_LEDCOUNT_CFG;
+    // WriteHeader(zonecmd, zonecfg, sizeof(zonecfg));
 }
 
 void RGBController_PolychromeUSB::DeviceUpdateLEDs()
@@ -334,12 +338,6 @@ unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)
 
 void RGBController_PolychromeUSB::DeviceUpdateMode()
 {
-    /*-----------------------------------------------------------------*\
-    | Disable RGSwap as it causes flashing on each update in direct mode|
-    | Otherwise, reset to values specified in settings.json             |
-    \*-----------------------------------------------------------------*/
-    controller->SetRGSwap(modes[active_mode].name != "Direct");
-
     for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
         if(zones[zone_idx].leds_count > 0)

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -5,7 +5,6 @@
 |  ASRock Polychrome USB Driver             |
 |                                           |
 |  Ed Kambulow (Dredvard) 12/26/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/
 
 #pragma once

Controllers/AlienwareController/AlienwareController.cpp

@@ -592,14 +592,13 @@ void AlienwareController::SetColor(uint8_t zone, RGBColor color)
 
 void AlienwareController::SetColor(uint8_t zone, RGBColor color1, RGBColor color2)
 {
-    if ((color1 == zones[zone].color[0]) && (color2 == zones[zone].color[1]))
-    {
-        return;
-    }
+    dirty = ((color1 != zones[zone].color[0]) || (color2 != zones[zone].color[1]));
 
-    zones[zone].color[0] = color1;
-    zones[zone].color[1] = color2;
-    dirty = true;
+	if(dirty)
+	{
+		zones[zone].color[0] = color1;
+        zones[zone].color[1] = color2;
+	}
 }
 
 void AlienwareController::SetPeriod(uint8_t zone, uint16_t period)

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -65,12 +65,7 @@ void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
     }
 } /* DetectAsusAuraGPUControllers() */
 
-/*-----------------------------------------*\
-|  NVidia GPUs                              |
-\*-----------------------------------------*/
-
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 O2G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI 4G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1060 Strix 6G Gaming"             , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX_6G_GAMING,               0x29);
@@ -91,45 +86,38 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650S OC 4G"            , DetectAs
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660S O6G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1660 Ti OC 6G"                , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_GTX1660TI_OC,                      0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming 6G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G EVO Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S 8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G EVO Gaming"   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S 8G Gaming 8G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G EVO Gaming 8G", DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S O8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming 8G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming 8G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S 8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G V2 Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G White"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C,   0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060 Ti 8G Gaming OC"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A);
-
-/*-----------------------------------------*\
-|  AMD GPUs                                 |
-\*-----------------------------------------*/
-
 REGISTER_I2C_PCI_DETECTOR("ASUS AREZ Strix RX Vega 56 O8G"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS Vega 64 Strix"                        , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 5600XT Strix O6G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix 08G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING,             0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX470 O4G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 6800 TUF Gaming OC"                , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_RX6800_TUF_GAMING_OC,                  0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX480 Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX560 Gaming"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O4G Gaming OC"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming OC"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_OC,                 0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming TOP"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 6900XT TUF Gaming OC"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_TUF_RX6900XT_O16G_GAMING,              0x2A);

Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp

@@ -67,17 +67,15 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
             break;
 
         case 1:
-        case 2:
             {
                 char version[9];
-                int wireless_offset = (protocol == 2 ? 14 : 13);
-                int offset = (wireless ? wireless_offset : 4);
+                int offset = (wireless ? 13 : 4);
                 snprintf(version, 9, "%2X.%02X.%02X", usb_buf_out[offset + 2], usb_buf_out[offset + 1], usb_buf_out[offset]);
                 str = std::string(version);
             }
             break;
 
-        case 3:
+        case 2:
             {
                 unsigned char* offset = usb_buf_out + (wireless ? 13 : 4);
                 str = std::string(offset, offset + 4);
@@ -85,7 +83,7 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
             }
             break;
 
-        case 4:
+        case 3:
             {
                 char version[16];
                 int offset = (wireless ? 13 : 4);

Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h

@@ -18,15 +18,12 @@
 #define AURA_ROG_GLADIUS_II_ORIGIN_COD_PID          0x18B1
 #define AURA_ROG_GLADIUS_II_WIRELESS_1_PID          0x189E
 #define AURA_ROG_GLADIUS_II_WIRELESS_2_PID          0x18A0
-#define AURA_ROG_GLADIUS_III_PID                    0x197B
 #define AURA_ROG_GLADIUS_III_WIRELESS_USB_PID       0x197D
 #define AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID       0x197F
 #define AURA_ROG_GLADIUS_III_WIRELESS_BT_PID        0x1981
 #define AURA_ROG_CHAKRAM_WIRELESS_PID               0x18E5
 #define AURA_ROG_CHAKRAM_WIRED_1_PID                0x18E3
 #define AURA_ROG_CHAKRAM_CORE_PID                   0x1958
-#define AURA_ROG_CHAKRAM_X_USB_PID                  0x1A18
-#define AURA_ROG_CHAKRAM_X_2_4_PID                  0x1A1A
 #define AURA_ROG_PUGIO_PID                          0x1846
 #define AURA_ROG_PUGIO_II_WIRED_PID                 0x1906
 #define AURA_ROG_PUGIO_II_WIRELESS_PID              0x1908
@@ -177,19 +174,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
     },
-    {
-        AURA_ROG_GLADIUS_III_PID, // ROG Gladius III
-        {
-            255,
-            1,
-            0,
-            64,
-            false,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
     {
         AURA_ROG_GLADIUS_III_WIRELESS_USB_PID, // ROG Gladius III Wireless USB
         {
@@ -268,32 +252,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
     },
-    {
-        AURA_ROG_CHAKRAM_X_USB_PID, // ROG Chakram X USB
-        {
-            0,
-            0,
-            0,
-            4,
-            false,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_CHAKRAM_X_2_4_PID, // ROG Chakram X 2.4GHz Dongle
-        {
-            255,
-            1,
-            0,
-            64,
-            true,
-            2,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
     {
         AURA_ROG_PUGIO_PID, // ROG Pugio
         {
@@ -341,7 +299,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             0,
             4,
             false,
-            4,
+            3,
             { AURA_MOUSE_ZONE_LOGO },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM }
         }
@@ -497,7 +455,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             0,
             4,
             false,
-            3,
+            2,
             { AURA_MOUSE_ZONE_LOGO },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp

@@ -17,12 +17,11 @@
 #include <string.h>
 #include <cmath>
 
-AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short rev_version)
+AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid)
 {
     dev         = dev_handle;
     location    = path;
     device_pid  = pid;
-    version     = rev_version;
 }
 
 AuraTUFKeyboardController::~AuraTUFKeyboardController()
@@ -52,162 +51,58 @@ std::string AuraTUFKeyboardController::GetSerialString()
 }
 
 std::string AuraTUFKeyboardController::GetVersion()
-{
-    if(device_pid != AURA_ROG_CLAYMORE_PID)
-    {
-        unsigned char usb_buf[65];
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        usb_buf[0x00]   = 0x00;
-        usb_buf[0x01]   = 0x12;
-        usb_buf[0x02]   = 0x00;
-
-        ClearResponses();
-
-        hid_write(dev, usb_buf, 65);
-
-        unsigned char usb_buf_out[65];
-        hid_read(dev, usb_buf_out, 65);
-
-        char version[9];
-        if(device_pid == AURA_TUF_K3_GAMING_PID)
-        {
-            snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
-        }
-        else
-        {
-            snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
-        }
-
-        return std::string(version);
-    }
-    else
-    {
-        unsigned char usb_buf[65];
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-        usb_buf[0x00]   = 0x00;
-        usb_buf[0x01]   = 0x10;
-        usb_buf[0x02]   = 0x01;
-        usb_buf[0x03]   = 0x00;
-        usb_buf[0x04]   = 0x00;
-        usb_buf[0x05]   = 0x00; // set to 1 to get firmware version of numpad
-
-        ClearResponses();
-        hid_write(dev, usb_buf, 65);
-        AwaitResponse(20);
-
-        unsigned char usb_buf1[65];
-        memset(usb_buf1, 0x00, sizeof(usb_buf1));
-        usb_buf1[0x00]   = 0x00;
-        usb_buf1[0x01]   = 0x12;
-        usb_buf1[0x02]   = 0x22;
-
-        ClearResponses();
-        hid_write(dev, usb_buf1, 65);
-
-        unsigned char usb_buf_out[65];
-        hid_read(dev, usb_buf_out, 65);
-
-        char version[9];
-        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[8], usb_buf_out[9], usb_buf_out[10]);
-
-        return std::string(version);
-    }
-}
-
-int AuraTUFKeyboardController::GetLayout()
-{
-    if(device_pid != AURA_ROG_CLAYMORE_PID)
-    {
-        unsigned char usb_buf[65];
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        usb_buf[0x00]   = 0x00;
-        usb_buf[0x01]   = 0x12;
-        usb_buf[0x02]   = 0x12;
-
-        ClearResponses();
-        hid_write(dev, usb_buf, 65);
-
-        unsigned char usb_buf_out[65];
-        hid_read(dev, usb_buf_out, 65);
-
-        return(usb_buf_out[4] * 100 + usb_buf_out[5]);
-    }
-    else
-    {
-        char layout[4];
-
-        sprintf(layout, "%X", version);
-
-        int layoutnum = std::stoi(std::string(layout, 1));
-
-        switch(layoutnum)
-        {
-            case 1:
-                return 117;
-            case 2:
-                return 204;
-            case 3:
-                return 221;
-            case 4:
-                return 117;
-            default:
-                return 117;
-        }
-    }
-}
-
-/*---------------------------------------------------------*\
-| only needed for Claymore                                  |
-\*---------------------------------------------------------*/
-int AuraTUFKeyboardController::GetNumpadLocation()
 {
     unsigned char usb_buf[65];
     memset(usb_buf, 0x00, sizeof(usb_buf));
-
     usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x40;
-    usb_buf[0x02]   = 0x60;
+    usb_buf[0x01]   = 0x12;
+    usb_buf[0x02]   = 0x00;
 
-    ClearResponses();
     hid_write(dev, usb_buf, 65);
 
     unsigned char usb_buf_out[65];
     hid_read(dev, usb_buf_out, 65);
 
-    return(usb_buf_out[5] * 2 + usb_buf_out[4]);
+    char version[9];
+    if (device_pid == AURA_TUF_K3_GAMING_PID)
+    {
+        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
+    }
+    else
+    {
+        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
+    }
+    
+    return std::string(version);
+}
+
+int AuraTUFKeyboardController::GetLayout()
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x12;
+    usb_buf[0x02]   = 0x12;
+
+    hid_write(dev, usb_buf, 65);
+
+    unsigned char usb_buf_out[65];
+    hid_read(dev, usb_buf_out, 65);
+
+    return(usb_buf_out[4] * 100 + usb_buf_out[5]);
 }
 
 void AuraTUFKeyboardController::SaveMode()
 {
     unsigned char usb_save_buf[65];
+
     memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
 
     usb_save_buf[0x00]   = 0x00;
     usb_save_buf[0x01]   = 0x50;
     usb_save_buf[0x02]   = 0x55;
 
-    ClearResponses();
     hid_write(dev, usb_save_buf, 65);
-    AwaitResponse(60);
-}
-
-/*---------------------------------------------------------*\
-| only needed for Claymore                                  |
-\*---------------------------------------------------------*/
-void AuraTUFKeyboardController::AllowRemoteControl(unsigned char type)
-{
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x41;
-    usb_buf[0x02]   = type;
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
 }
 
 void AuraTUFKeyboardController::UpdateSingleLed
@@ -222,10 +117,11 @@ void AuraTUFKeyboardController::UpdateSingleLed
     | Set up message packet for single LED                  |
     \*-----------------------------------------------------*/
     unsigned char usb_buf[65];
+
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
     usb_buf[0] = 0x00;
-    usb_buf[1] = 0xC0;
+    usb_buf[1] = 0xc0;
     usb_buf[2] = 0x81;
     usb_buf[3] = 0x01;
     usb_buf[4] = 0x00;
@@ -233,48 +129,70 @@ void AuraTUFKeyboardController::UpdateSingleLed
     /*-----------------------------------------------------*\
     | Convert LED index                                     |
     \*-----------------------------------------------------*/
-    usb_buf[5] = led;
+    usb_buf[5] = floor(led/6)*8 + led%6;
     usb_buf[6] = red;
     usb_buf[7] = green;
     usb_buf[8] = blue;
 
-    ClearResponses();
     hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
 }
 
 void AuraTUFKeyboardController::UpdateLeds
     (
-    std::vector<led_color>    colors
+    std::vector<RGBColor>    colors
     )
 {
-    int packets = ceil((float) colors.size() / 15);
-
-    for(int i = 0; i < packets; i++)
+    /*-----------------------------------------------------*\
+    | Loop over every column (optimisation needed)          |
+    \*-----------------------------------------------------*/
+    for(unsigned int i = 0; i < 192; i += 16)
     {
-        unsigned char usb_buf[65];
+        unsigned char usb_buf[69];
+
         memset(usb_buf, 0x00, sizeof(usb_buf));
 
-        int remaining = colors.size() - i * 15;
-
-        int leds = (remaining > 0x0F) ? 0x0F : remaining;
-
         usb_buf[0] = 0x00;
-        usb_buf[1] = 0xC0;
+        usb_buf[1] = 0xc0;
         usb_buf[2] = 0x81;
-        usb_buf[3] = leds;
+        usb_buf[3] = (138 - i / 16 * 12);
         usb_buf[4] = 0x00;
 
-        for(int j = 0; j < leds; j++)
+        for(unsigned int n = 0; n < 6; n++)
         {
-            usb_buf[j * 4 + 5] = colors[i * 15 + j].value;
-            usb_buf[j * 4 + 6] = RGBGetRValue(colors[i * 15 + j].color);
-            usb_buf[j * 4 + 7] = RGBGetGValue(colors[i * 15 + j].color);
-            usb_buf[j * 4 + 8] = RGBGetBValue(colors[i * 15 + j].color);
+            usb_buf[n * 4 + 5] = i + n;
+            usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n]);
+            usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n]);
+            usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n]);
         }
-        ClearResponses();
-        hid_write(dev, usb_buf, 65);
-        AwaitResponse(20);
+
+        for(unsigned int n = 6; n < 8; n++)
+        {
+            usb_buf[n * 4 + 5] = i + n;
+            usb_buf[n * 4 + 6] = 0;
+            usb_buf[n * 4 + 7] = 0;
+            usb_buf[n * 4 + 8] = 0;
+        }
+
+        if(i != 176)
+        {
+            for(unsigned int n = 8; n < 14; n++)
+            {
+                usb_buf[n * 4 + 5] = i + n;
+                usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n-2]);
+                usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n-2]);
+                usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n-2]);
+            }
+
+            for(unsigned int n = 14; n < 16; n++)
+            {
+                usb_buf[n * 4 + 5] = i + n;
+                usb_buf[n * 4 + 6] = 0;
+                usb_buf[n * 4 + 7] = 0;
+                usb_buf[n * 4 + 8] = 0;
+            }
+        }
+
+        hid_write(dev, usb_buf, 69);
     }
 }
 
@@ -282,168 +200,75 @@ void AuraTUFKeyboardController::UpdateDevice
     (
     unsigned char           mode,
     std::vector<RGBColor>   colors,
-    unsigned char           direction,
+    unsigned char           dir,
     unsigned char           color_mode,
     unsigned char           speed,
     unsigned char           brightness
     )
 {
     unsigned char usb_buf[65];
+
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
     usb_buf[0x00]   = 0x00;
     usb_buf[0x01]   = 0x51;
     usb_buf[0x02]   = 0x2C;
+    usb_buf[0x03]   = mode;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = brightness;
+    usb_buf[0x07]   = color_mode;
+    usb_buf[0x08]   = dir;
+    usb_buf[0x09]   = 0x02;
 
-    if(device_pid != AURA_ROG_CLAYMORE_PID)
+    if(mode == 4 || mode == 5)
     {
-        usb_buf[0x03]   = mode;
-        usb_buf[0x04]   = 0x00;
-        usb_buf[0x05]   = speed;
-        usb_buf[0x06]   = brightness;
-        usb_buf[0x07]   = color_mode;
-        usb_buf[0x08]   = direction;
-        usb_buf[0x09]   = 0x02;
+        /*-----------------------------------------------------*\
+        | If mode is Rainbow or Ripple                          |
+        \*-----------------------------------------------------*/
+        usb_buf[0x0A]   = colors.size();
 
-        if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
+        /*-----------------------------------------------------*\
+        | Loop over every color given                           |
+        \*-----------------------------------------------------*/
+        for(unsigned int i = 0; i / 4 < colors.size(); i += 4)
         {
-            usb_buf[0x0A]   = colors.size();
-
-            /*-----------------------------------------------------*\
-            | Loop over every color given                           |
-            \*-----------------------------------------------------*/
-            for(unsigned int i = 0; i < colors.size(); i ++)
+            if(colors[i / 4])
             {
-                if(colors[i])
-                {
-                    usb_buf[11 + i * 4] = 100/(double)colors.size()*(i+1);
-                    usb_buf[12 + i * 4] = RGBGetRValue(colors[i]);
-                    usb_buf[13 + i * 4] = RGBGetGValue(colors[i]);
-                    usb_buf[14 + i * 4] = RGBGetBValue(colors[i]);
-                }
+                usb_buf[11 + i] = 100/(double)colors.size()*(i/4+1);
+                usb_buf[12 + i] = RGBGetRValue(colors[i/4]);
+                usb_buf[13 + i] = RGBGetGValue(colors[i/4]);
+                usb_buf[14 + i] = RGBGetBValue(colors[i/4]);
             }
         }
-        else
-        {
-            /*-----------------------------------------------------*\
-            | Loop over Color1, Color2 and Background if there      |
-            \*-----------------------------------------------------*/
-            for(unsigned int i = 0; i != colors.size(); i++)
-            {
-                if(colors[i])
-                {
-                    usb_buf[10 + i * 3] = RGBGetRValue(colors[i]);
-                    usb_buf[11 + i * 3] = RGBGetGValue(colors[i]);
-                    usb_buf[12 + i * 3] = RGBGetBValue(colors[i]);
-                }
-            }
-
-        }
     }
     else
     {
-        usb_buf[0x03]   = 0x00;
-        usb_buf[0x04]   = 0x00;
-        usb_buf[0x05]   = mode;
-        usb_buf[0x06]   = speed;
-
-        bool random     = (color_mode == 1);
-        bool pattern    = (color_mode == 2);
-
-        usb_buf[0x07]   = random * 128 + pattern * 32 + direction;
-        usb_buf[0x08]   = 0xFF; // "byteExt1" unknown usage
-        usb_buf[0x09]   = 0xFF; // "byteExt2" unknown usage
-        usb_buf[0x0A]   = (mode == 2) ? 0x80 : 0xFF; // "Lightness" (not Brightness)
-
-        if(mode == 7)
+        /*-----------------------------------------------------*\
+        | Loop over Color1, Color2 and Background if there      |
+        \*-----------------------------------------------------*/
+        for(unsigned int i = 0; i / 3 != colors.size(); i += 3)
         {
-            UpdateQuicksandColors(colors);
-        }
-        else
-        {
-            if(mode == 4 && color_mode == 0)
+            if(colors[i / 3])
             {
-                usb_buf[11] = 0xFF;
-                usb_buf[12] = 0xFF;
-                usb_buf[13] = 0xFF;
-            }
-
-            for(unsigned int i = 0; i < colors.size(); i ++)
-            {
-                if(colors[i])
-                {
-                    usb_buf[11 + i * 3] = RGBGetRValue(colors[i]);
-                    usb_buf[12 + i * 3] = RGBGetGValue(colors[i]);
-                    usb_buf[13 + i * 3] = RGBGetBValue(colors[i]);
-                }
+                usb_buf[10 + i] = RGBGetRValue(colors[i/3]);
+                usb_buf[11 + i] = RGBGetGValue(colors[i/3]);
+                usb_buf[12 + i] = RGBGetBValue(colors[i/3]);
             }
         }
-
-        for(int i = 1; i < 5; i++)
-        {
-            usb_buf[5 + i * 12] = 0xFF;
-        }
+            
     }
 
-    ClearResponses();
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
 }
 
-/*---------------------------------------------------------*\
-| only needed for Claymore                                  |
-\*---------------------------------------------------------*/
-void AuraTUFKeyboardController::UpdateQuicksandColors
-    (
-    std::vector<RGBColor>   colors
-    )
-{
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x51;
-    usb_buf[0x02]   = 0x91;
-
-    for(unsigned int i = 0; i < 6; i++)
-    {
-        if(colors[i])
-        {
-            usb_buf[5 + i * 3] = RGBGetRValue(colors[i]);
-            usb_buf[6 + i * 3] = RGBGetGValue(colors[i]);
-            usb_buf[7 + i * 3] = RGBGetBValue(colors[i]);
-        }
-    }
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-}
-
-/*---------------------------------------------------------*\
-| only needed for Claymore                                  |
-\*---------------------------------------------------------*/
-void AuraTUFKeyboardController::UpdateMode(unsigned char mode)
-{
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x51;
-    usb_buf[0x02]   = 0x28;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = mode;
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-}
-
-void AuraTUFKeyboardController::AwaitResponse(int ms)
+void AuraTUFKeyboardController::AwaitResponse()
 {
     unsigned char usb_buf_out[65];
-    hid_read_timeout(dev, usb_buf_out, 65, ms);
+    hid_read(dev, usb_buf_out, 65);
 }
 
 void AuraTUFKeyboardController::ClearResponses()
@@ -452,7 +277,7 @@ void AuraTUFKeyboardController::ClearResponses()
     unsigned char usb_buf_flush[65];
     while(result > 0)
     {
-        result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
+      result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
     }
 }
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h

@@ -16,6 +16,14 @@
 
 #pragma once
 
+enum
+{
+    AURA_KEYBOARD_ZONE_LOGO         = 0,
+    AURA_KEYBOARD_ZONE_SCROLL       = 1,
+    AURA_KEYBOARD_ZONE_UNDERGLOW    = 2,
+    AURA_KEYBOARD_ZONE_ALL          = 3,
+};
+
 enum
 {
     AURA_KEYBOARD_MODE_STATIC       =  0,
@@ -33,32 +41,22 @@ enum
 
 enum
 {
-    AURA_ROG_FALCHION_WIRED_PID     = 0x193C,
-    AURA_ROG_FALCHION_WIRELESS_PID  = 0x193E,
     AURA_TUF_K7_GAMING_PID          = 0x18AA,
     AURA_TUF_K3_GAMING_PID          = 0x194B,
-    AURA_ROG_CLAYMORE_PID           = 0x184D,
 };
 
-struct led_color
-{
-    unsigned int    value;
-    RGBColor        color;
-};
 
 class AuraTUFKeyboardController
 {
 public:
-    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short rev_version);
+    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid);
     ~AuraTUFKeyboardController();
 
     std::string GetDeviceLocation();
     std::string GetSerialString();
     std::string GetVersion();
     int         GetLayout();
-    int         GetNumpadLocation();
     void        SaveMode();
-    void        AllowRemoteControl(unsigned char type);
 
     void UpdateSingleLed
         (
@@ -70,7 +68,7 @@ public:
 
     void UpdateLeds
         (
-        std::vector<led_color>    colors
+        std::vector<RGBColor>    colors
         );
 
     void UpdateDevice
@@ -82,9 +80,7 @@ public:
         unsigned char           speed,
         unsigned char           brightness
         );
-    void UpdateQuicksandColors(std::vector<RGBColor> colors);
-    void UpdateMode(unsigned char mode);
-    void AwaitResponse(int ms);
+    void AwaitResponse();
     void ClearResponses();
 
     uint16_t                    device_pid;
@@ -92,6 +88,5 @@ public:
 private:
     hid_device*                 dev;
     std::string                 location;
-    unsigned short              version;
 };
 

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -44,12 +44,9 @@
 #define AURA_ROG_FALCHION_WIRELESS_PID          0x193E
 #define AURA_ROG_STRIX_FLARE_PID                0x1875
 #define AURA_ROG_STRIX_FLARE_PNK_LTD_PID        0x18CF
-#define AURA_ROG_STRIX_FLARE_COD_BO4_PID        0x18AF
 #define AURA_ROG_STRIX_SCOPE_PID                0x18F8
 #define AURA_ROG_STRIX_SCOPE_RX_PID             0x1951
 #define AURA_ROG_STRIX_SCOPE_TKL_PID            0x190C
-#define AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID    0x1954
-#define AURA_ROG_CLAYMORE_PID                   0x184D
 #define AURA_TUF_K7_GAMING_PID                  0x18AA
 #define AURA_TUF_K3_GAMING_PID                  0x194B
 
@@ -70,7 +67,6 @@
 \*-----------------------------------------------------------------*/
 
 #define AURA_ROG_STRIX_XG27AQ_PID               0x198C
-#define AURA_ROG_STRIX_XG27AQM_PID              0x19BB
 #define AURA_ROG_STRIX_XG27W_PID                0x1933
 #define AURA_ROG_PG32UQ_PID                     0x19B9
 
@@ -95,7 +91,6 @@ AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
     {
         case AURA_ROG_STRIX_FLARE_PID:
         case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
-        case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
             return FLARE_LAYOUT;
 
         case AURA_ROG_STRIX_SCOPE_PID:
@@ -105,9 +100,12 @@ AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
             return SCOPE_RX_LAYOUT;
 
         case AURA_ROG_STRIX_SCOPE_TKL_PID:
-        case AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID:
             return SCOPE_TKL_LAYOUT;
 
+        case AURA_ROG_FALCHION_WIRED_PID:
+        case AURA_ROG_FALCHION_WIRELESS_PID:
+            return FALCHION_LAYOUT;
+
         default:
             return FLARE_LAYOUT;
     }
@@ -260,7 +258,7 @@ void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name
 
     if(dev)
     {
-        AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number);
+        AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id);
         RGBController_AuraTUFKeyboard* rgb_controller       = new RGBController_AuraTUFKeyboard(controller);
         rgb_controller->name                                = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -294,16 +292,13 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAs
 /*-----------------------------------------------------------------*\
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",                   DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,                  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,               1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                     1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,             1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare CoD Black Ops 4 Edition",DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_COD_BO4_PID,             1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                     1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",                     DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,                  1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL",                    DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID,                 1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL PNK LTD",            DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID,         1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Claymore",                           DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_CLAYMORE_PID,                        1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",                   DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,                  1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",                DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,               1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                       1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                       1,  0xFF00);
 
@@ -317,15 +312,12 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",          DetectAs
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID,           2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,           1,  0xFF13);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,           2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III",                        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_PID,                     0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless USB",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_USB_PID,        0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless 2.4Ghz",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID,        0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth",     DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_BT_PID,         0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,                0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,                 0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram Core",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID,                    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X USB",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_X_USB_PID,                   0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X 2.4GHz",                   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_X_2_4_PID,                   0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio",                              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_PID,                           2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",                   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,                  0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,               0,  0xFF01);
@@ -355,7 +347,6 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus Qi",                         DetectAs
 | MONITORS                                                          |
 \*-----------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQ",                       DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27AQ_PID,                    0xFFA0, 1);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQM",                      DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27AQM_PID,                   0xFFA0, 1);
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27W",                        DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27W_PID,                     0xFFA0, 1);
 REGISTER_HID_DETECTOR_PU("ASUS ROG PG32UQ",                             DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_PG32UQ_PID,                          0xFFA0, 1);
 

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp

@@ -29,9 +29,9 @@ static std::string aura_mouse_zone_names[3]
 
 RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller_ptr)
 {
-    controller = controller_ptr;
+    controller              = controller_ptr;
 
-    pid = controller->device_pid;
+    uint16_t pid            = controller->device_pid;
 
     name                    = "ASUS Aura Mouse";
     vendor                  = "ASUS";
@@ -168,6 +168,8 @@ RGBController_AuraMouse::~RGBController_AuraMouse()
 
 void RGBController_AuraMouse::SetupZones()
 {
+    uint16_t pid                = controller->device_pid;
+
     for(std::vector<uint8_t>::iterator zone_it = aura_mouse_devices[pid].mouse_zones.begin(); zone_it != aura_mouse_devices[pid].mouse_zones.end(); zone_it++)
     {
         zone mouse_zone;
@@ -207,7 +209,7 @@ void RGBController_AuraMouse::DeviceUpdateLEDs()
 
 void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
 {
-    DeviceUpdateLEDs();
+    UpdateSingleLED(zone);
 }
 
 void RGBController_AuraMouse::UpdateSingleLED(int led)

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.h

@@ -30,5 +30,4 @@ public:
 
 private:
     AuraMouseController*  controller;
-    uint16_t              pid;
 };

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -24,314 +24,178 @@
 
 RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr)
 {
-    controller = controller_ptr;
+    controller  = controller_ptr;
 
-    pid = controller->device_pid;
+    name        = "ASUS Aura Keyboard";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "ASUS Aura Keyboard Device";
+    version     = controller->GetVersion();
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
 
-    const unsigned char AURA_KEYBOARD_SPEED_MIN = (pid == AURA_ROG_FALCHION_WIRED_PID || pid == AURA_ROG_FALCHION_WIRELESS_PID) ? 255 : 15;
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
 
-    if(pid != AURA_ROG_CLAYMORE_PID)
-    {
-        name        = "ASUS Aura Keyboard";
-        vendor      = "ASUS";
-        type        = DEVICE_TYPE_KEYBOARD;
-        description = "ASUS Aura Keyboard Device";
-        version     = controller->GetVersion();
-        location    = controller->GetDeviceLocation();
-        serial      = controller->GetSerialString();
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = AURA_KEYBOARD_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Static.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Static.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(1);
+    modes.push_back(Static);
 
-        mode Direct;
-        Direct.name                 = "Direct";
-        Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
-        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-        Direct.color_mode           = MODE_COLORS_PER_LED;
-        modes.push_back(Direct);
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+    Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+    Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+    Breathing.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Breathing.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 2;
+    Breathing.colors.resize(1);
+    modes.push_back(Breathing);
 
-        mode Static;
-        Static.name                 = "Static";
-        Static.value                = AURA_KEYBOARD_MODE_STATIC;
-        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Static.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Static.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Static.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Static.colors_min           = 1;
-        Static.colors_max           = 1;
-        Static.colors.resize(1);
-        modes.push_back(Static);
+    mode Color_Cycle;
+    Color_Cycle.name            = "Spectrum Cycle";
+    Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
+    Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Color_Cycle.speed_min       = AURA_KEYBOARD_SPEED_MIN;
+    Color_Cycle.speed_max       = AURA_KEYBOARD_SPEED_MAX;
+    Color_Cycle.speed           = AURA_KEYBOARD_SPEED_DEFAULT;
+    Color_Cycle.brightness_min  = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Color_Cycle.brightness_max  = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Color_Cycle.brightness      = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Color_Cycle.color_mode      = MODE_COLORS_NONE;
+    modes.push_back(Color_Cycle);
 
-        mode Breathing;
-        Breathing.name              = "Breathing";
-        Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
-        Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Breathing.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-        Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-        Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-        Breathing.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Breathing.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Breathing.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Breathing.colors_min        = 1;
-        Breathing.colors_max        = 2;
-        Breathing.colors.resize(1);
-        modes.push_back(Breathing);
+    mode Wave;
+    Wave.name                   = "Rainbow Wave";
+    Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
+    Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Wave.speed_min              = AURA_KEYBOARD_SPEED_MIN;
+    Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
+    Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
+    Wave.brightness_min         = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Wave.brightness_max         = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Wave.brightness             = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Wave.direction              = MODE_DIRECTION_LEFT;
+    Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Wave.colors_min             = 1;
+    Wave.colors_max             = 7;
+    Wave.colors.resize(7);
+    modes.push_back(Wave);
 
-        mode Color_Cycle;
-        Color_Cycle.name            = "Spectrum Cycle";
-        Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
-        Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Color_Cycle.speed_min       = AURA_KEYBOARD_SPEED_MIN;
-        Color_Cycle.speed_max       = AURA_KEYBOARD_SPEED_MAX;
-        Color_Cycle.speed           = AURA_KEYBOARD_SPEED_DEFAULT;
-        Color_Cycle.brightness_min  = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Color_Cycle.brightness_max  = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Color_Cycle.brightness      = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Color_Cycle.color_mode      = MODE_COLORS_NONE;
-        modes.push_back(Color_Cycle);
+    mode Ripple;
+    Ripple.name                 = "Ripple";
+    Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
+    Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Ripple.speed_min            = AURA_KEYBOARD_SPEED_MIN;
+    Ripple.speed_max            = AURA_KEYBOARD_SPEED_MAX;
+    Ripple.speed                = AURA_KEYBOARD_SPEED_DEFAULT;
+    Ripple.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Ripple.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Ripple.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Ripple.colors_min           = 1;
+    Ripple.colors_max           = 8;
+    Ripple.colors.resize(7);
+    modes.push_back(Ripple);
 
-        mode Wave;
-        Wave.name                   = "Rainbow Wave";
-        Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
-        Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Wave.speed_min              = AURA_KEYBOARD_SPEED_MIN;
-        Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
-        Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
-        Wave.brightness_min         = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Wave.brightness_max         = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Wave.brightness             = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Wave.direction              = MODE_DIRECTION_LEFT;
-        Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-        Wave.colors_min             = 1;
-        Wave.colors_max             = 7;
-        Wave.colors.resize(7);
-        modes.push_back(Wave);
+    mode Reactive;
+    Reactive.name               = "Reactive";
+    Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
+    Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Reactive.speed_min          = AURA_KEYBOARD_SPEED_MIN;
+    Reactive.speed_max          = AURA_KEYBOARD_SPEED_MAX;
+    Reactive.speed              = AURA_KEYBOARD_SPEED_DEFAULT;
+    Reactive.brightness_min     = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Reactive.brightness_max     = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Reactive.brightness         = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Reactive.colors_min         = 1;
+    Reactive.colors_max         = 2;
+    Reactive.colors.resize(1);
+    modes.push_back(Reactive);
 
-        mode Ripple;
-        Ripple.name                 = "Ripple";
-        Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
-        Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Ripple.speed_min            = AURA_KEYBOARD_SPEED_MIN;
-        Ripple.speed_max            = AURA_KEYBOARD_SPEED_MAX;
-        Ripple.speed                = AURA_KEYBOARD_SPEED_DEFAULT;
-        Ripple.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Ripple.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Ripple.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Ripple.colors_min           = 1;
-        Ripple.colors_max           = 8;
-        Ripple.colors.resize(7);
-        modes.push_back(Ripple);
+    mode Starry_Night;
+    Starry_Night.name           = "Starry Night";
+    Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
+    Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Starry_Night.speed_min      = AURA_KEYBOARD_SPEED_MIN;
+    Starry_Night.speed_max      = AURA_KEYBOARD_SPEED_MAX;
+    Starry_Night.speed          = AURA_KEYBOARD_SPEED_DEFAULT;
+    Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Starry_Night.brightness     = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Starry_Night.colors_min     = 1;
+    Starry_Night.colors_max     = 3;
+    Starry_Night.colors.resize(1);
+    modes.push_back(Starry_Night);
 
-        mode Reactive;
-        Reactive.name               = "Reactive";
-        Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
-        Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Reactive.speed_min          = AURA_KEYBOARD_SPEED_MIN;
-        Reactive.speed_max          = AURA_KEYBOARD_SPEED_MAX;
-        Reactive.speed              = AURA_KEYBOARD_SPEED_DEFAULT;
-        Reactive.brightness_min     = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Reactive.brightness_max     = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Reactive.brightness         = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-        Reactive.colors_min         = 1;
-        Reactive.colors_max         = 2;
-        Reactive.colors.resize(1);
-        modes.push_back(Reactive);
+    mode Quicksand;
+    Quicksand.name              = "Quicksand";
+    Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
+    Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Quicksand.direction         = MODE_DIRECTION_DOWN;
+    Quicksand.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+    Quicksand.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+    Quicksand.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+    Quicksand.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Quicksand.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Quicksand.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Quicksand.colors_min        = 6;
+    Quicksand.colors_max        = 6;
+    Quicksand.colors.resize(6);
+    modes.push_back(Quicksand);
 
-        mode Starry_Night;
-        Starry_Night.name           = "Starry Night";
-        Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
-        Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Starry_Night.speed_min      = AURA_KEYBOARD_SPEED_MIN;
-        Starry_Night.speed_max      = AURA_KEYBOARD_SPEED_MAX;
-        Starry_Night.speed          = AURA_KEYBOARD_SPEED_DEFAULT;
-        Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Starry_Night.brightness     = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-        Starry_Night.colors_min     = 1;
-        Starry_Night.colors_max     = 3;
-        Starry_Night.colors.resize(1);
-        modes.push_back(Starry_Night);
+    mode Current;
+    Current.name                = "Current";
+    Current.value               = AURA_KEYBOARD_MODE_CURRENT;
+    Current.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Current.speed_min           = AURA_KEYBOARD_SPEED_MIN;
+    Current.speed_max           = AURA_KEYBOARD_SPEED_MAX;
+    Current.speed               = AURA_KEYBOARD_SPEED_DEFAULT;
+    Current.brightness_min      = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Current.brightness_max      = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Current.brightness          = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Current.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+    Current.colors_min          = 1;
+    Current.colors_max          = 3;
+    Current.colors.resize(1);
+    modes.push_back(Current);
 
-        mode Quicksand;
-        Quicksand.name              = "Quicksand";
-        Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
-        Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Quicksand.direction         = MODE_DIRECTION_DOWN;
-        Quicksand.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-        Quicksand.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-        Quicksand.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-        Quicksand.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Quicksand.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Quicksand.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Quicksand.colors_min        = 6;
-        Quicksand.colors_max        = 6;
-        Quicksand.colors.resize(6);
-        modes.push_back(Quicksand);
-
-        mode Current;
-        Current.name                = "Current";
-        Current.value               = AURA_KEYBOARD_MODE_CURRENT;
-        Current.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Current.speed_min           = AURA_KEYBOARD_SPEED_MIN;
-        Current.speed_max           = AURA_KEYBOARD_SPEED_MAX;
-        Current.speed               = AURA_KEYBOARD_SPEED_DEFAULT;
-        Current.brightness_min      = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Current.brightness_max      = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Current.brightness          = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Current.color_mode          = MODE_COLORS_MODE_SPECIFIC;
-        Current.colors_min          = 1;
-        Current.colors_max          = 3;
-        Current.colors.resize(1);
-        modes.push_back(Current);
-
-        mode Rain_Drop;
-        Rain_Drop.name              = "Rain Drop";
-        Rain_Drop.value             = AURA_KEYBOARD_MODE_RAIN_DROP;
-        Rain_Drop.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Rain_Drop.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-        Rain_Drop.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-        Rain_Drop.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-        Rain_Drop.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Rain_Drop.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Rain_Drop.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Rain_Drop.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Rain_Drop.colors_min        = 1;
-        Rain_Drop.colors_max        = 3;
-        Rain_Drop.colors.resize(1);
-        modes.push_back(Rain_Drop);
-    }
-    else
-    {
-
-        name        = "ASUS ROG Claymore";
-        vendor      = "ASUS";
-        type        = DEVICE_TYPE_KEYBOARD;
-        description = "ASUS Aura Keyboard Device";
-        version     = controller->GetVersion();
-        location    = controller->GetDeviceLocation();
-        serial      = controller->GetSerialString();
-
-        mode Direct;
-        Direct.name                 = "Direct";
-        Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
-        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-        Direct.color_mode           = MODE_COLORS_PER_LED;
-        modes.push_back(Direct);
-
-        mode Static;
-        Static.name                 = "Static";
-        Static.value                = AURA_KEYBOARD_MODE_STATIC;
-        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Static.colors_min           = 1;
-        Static.colors_max           = 1;
-        Static.colors.resize(1);
-        modes.push_back(Static);
-
-        mode Breathing;
-        Breathing.name              = "Breathing";
-        Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
-        Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Breathing.speed_min         = AURA_CLAYMORE_SPEED_MIN;
-        Breathing.speed_max         = AURA_CLAYMORE_SPEED_MAX;
-        Breathing.speed             = AURA_CLAYMORE_SPEED_DEFAULT_BREATHING;
-        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Breathing.colors_min        = 1;
-        Breathing.colors_max        = 2;
-        Breathing.colors.resize(2);
-        modes.push_back(Breathing);
-
-        mode Color_Cycle;
-        Color_Cycle.name            = "Spectrum Cycle";
-        Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
-        Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Color_Cycle.speed_min       = AURA_CLAYMORE_SPEED_MIN;
-        Color_Cycle.speed_max       = AURA_CLAYMORE_SPEED_MAX;
-        Color_Cycle.speed           = AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE;
-        Color_Cycle.color_mode      = MODE_COLORS_NONE;
-        modes.push_back(Color_Cycle);
-
-        mode Reactive;
-        Reactive.name               = "Reactive";
-        Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
-        Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Reactive.speed_min          = AURA_CLAYMORE_SPEED_MIN;
-        Reactive.speed_max          = AURA_CLAYMORE_SPEED_MAX;
-        Reactive.speed              = AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE;
-        Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-        Reactive.colors_min         = 1;
-        Reactive.colors_max         = 2;
-        Reactive.colors.resize(2);
-        modes.push_back(Reactive);
-
-        mode Wave;
-        Wave.name                   = "Rainbow Wave";
-        Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
-        Wave.flags                  = MODE_COLORS_NONE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
-        Wave.speed_min              = AURA_CLAYMORE_SPEED_MIN;
-        Wave.speed_max              = AURA_CLAYMORE_SPEED_MAX;
-        Wave.speed                  = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
-        Wave.direction              = MODE_DIRECTION_LEFT;
-        Wave.color_mode             = MODE_COLORS_NONE;
-        modes.push_back(Wave);
-
-        mode Color_Wave;
-        Color_Wave.name             = "Color Wave";
-        Color_Wave.value            = AURA_KEYBOARD_MODE_WAVE;
-        Color_Wave.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
-        Color_Wave.speed_min        = AURA_CLAYMORE_SPEED_MIN;
-        Color_Wave.speed_max        = AURA_CLAYMORE_SPEED_MAX;
-        Color_Wave.speed            = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
-        Color_Wave.direction        = MODE_DIRECTION_LEFT;
-        Color_Wave.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Color_Wave.colors_min       = 1;
-        Color_Wave.colors_max       = 2;
-        Color_Wave.colors.resize(2);
-        modes.push_back(Color_Wave);
-
-        mode Ripple;
-        Ripple.name                 = "Ripple";
-        Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
-        Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Ripple.speed_min            = AURA_CLAYMORE_SPEED_MIN;
-        Ripple.speed_max            = AURA_CLAYMORE_SPEED_MAX;
-        Ripple.speed                = AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE;
-        Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Ripple.colors_min           = 1;
-        Ripple.colors_max           = 2;
-        Ripple.colors.resize(2);
-        modes.push_back(Ripple);
-
-        mode Starry_Night;
-        Starry_Night.name           = "Starry Night";
-        Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
-        Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Starry_Night.speed_min      = AURA_CLAYMORE_SPEED_MIN;
-        Starry_Night.speed_max      = AURA_CLAYMORE_SPEED_MAX;
-        Starry_Night.speed          = AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT;
-        Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-        Starry_Night.colors_min     = 1;
-        Starry_Night.colors_max     = 2;
-        Starry_Night.colors.resize(2);
-        modes.push_back(Starry_Night);
-
-        mode Quicksand;
-        Quicksand.name              = "Quicksand";
-        Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
-        Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Quicksand.direction         = MODE_DIRECTION_DOWN;
-        Quicksand.speed_min         = AURA_CLAYMORE_SPEED_MIN;
-        Quicksand.speed_max         = AURA_CLAYMORE_SPEED_MAX;
-        Quicksand.speed             = AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND;
-        Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Quicksand.colors_min        = 6;
-        Quicksand.colors_max        = 6;
-        Quicksand.colors.resize(6);
-        modes.push_back(Quicksand);
-    }
+    mode Rain_Drop;
+    Rain_Drop.name              = "Rain Drop";
+    Rain_Drop.value             = AURA_KEYBOARD_MODE_RAIN_DROP;
+    Rain_Drop.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Rain_Drop.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+    Rain_Drop.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+    Rain_Drop.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+    Rain_Drop.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Rain_Drop.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Rain_Drop.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Rain_Drop.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Rain_Drop.colors_min        = 1;
+    Rain_Drop.colors_max        = 3;
+    Rain_Drop.colors.resize(1);
+    modes.push_back(Rain_Drop);
 
     SetupZones();
 }
@@ -343,48 +207,10 @@ RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
 
 void RGBController_AuraTUFKeyboard::SetupZones()
 {
-    unsigned char layout = controller->GetLayout();
+    int layout = controller->GetLayout();
 
-    std::map<int,layout_info> * keyboard_ptr;
-
-    switch(pid)
+    if(AsusTUFK7Layouts.find(layout % 100) == AsusTUFK7Layouts.end())
     {
-        case AURA_TUF_K7_GAMING_PID:
-            keyboard_ptr = &AsusTUFK7Layouts;
-            break;
-        case AURA_ROG_FALCHION_WIRED_PID:
-        case AURA_ROG_FALCHION_WIRELESS_PID:
-            keyboard_ptr = &AsusFalchionLayouts;
-            break;
-        case AURA_ROG_CLAYMORE_PID:
-            unsigned char numpad;
-            numpad = controller->GetNumpadLocation();
-            switch(numpad)
-            {
-                case 0:
-                    keyboard_ptr = &AsusClaymoreNoNumpadLayouts;
-                    break;
-                case 2:
-                    keyboard_ptr = &AsusClaymoreNumpadRightLayouts;
-                    break;
-                case 3:
-                    keyboard_ptr = &AsusClaymoreNumpadLeftLayouts;
-                    break;
-                default:
-                    keyboard_ptr = &AsusClaymoreNoNumpadLayouts;
-            }
-            break;
-        default:
-            keyboard_ptr = &AsusTUFK7Layouts;
-    }
-
-    std::map<int,layout_info> & keyboard = *keyboard_ptr;
-
-    if(keyboard.find(layout % 100) == keyboard.end())
-    {
-        /*---------------------------------------------------------*\
-        | If Layout not found, take uk or us                        |
-        \*---------------------------------------------------------*/
         layout = std::floor(layout/100) == 2 ? ASUS_TUF_K7_LAYOUT_UK : ASUS_TUF_K7_LAYOUT_US;
     }
     else
@@ -392,32 +218,33 @@ void RGBController_AuraTUFKeyboard::SetupZones()
         layout = layout % 100;
     }
 
-    zone keyboard_zone;
-    keyboard_zone.name               = "Keyboard";
-    keyboard_zone.type               = ZONE_TYPE_MATRIX;
-    keyboard_zone.leds_min           = keyboard[layout].size;
-    keyboard_zone.leds_max           = keyboard[layout].size;
-    keyboard_zone.leds_count         = keyboard[layout].size;
-    keyboard_zone.matrix_map         = new matrix_map_type;
-    keyboard_zone.matrix_map->height = keyboard[layout].rows;
-    keyboard_zone.matrix_map->width  = keyboard[layout].cols;
-    keyboard_zone.matrix_map->map    = keyboard[layout].matrix_map;
-    zones.push_back(keyboard_zone);
+    unsigned int total_led_count = 0;
 
-    for(int led_id = 0; led_id < keyboard[layout].size; led_id++)
+    int zone_size = 138;
+
+    zone keyboard;
+    keyboard.name               = ZONE_EN_KEYBOARD;
+    keyboard.type               = ZONE_TYPE_MATRIX;
+    keyboard.leds_min           = zone_size;
+    keyboard.leds_max           = zone_size;
+    keyboard.leds_count         = zone_size;
+    keyboard.matrix_map         = new matrix_map_type;
+    keyboard.matrix_map->height = 6;
+    keyboard.matrix_map->width  = 23;
+    keyboard.matrix_map->map    = AsusTUFK7Layouts[layout].matrix_map;
+    zones.push_back(keyboard);
+
+    total_led_count += zone_size;
+
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
     {
         led new_led;
-        new_led.name  = keyboard[layout].led_names[led_id].name;
-        new_led.value = keyboard[layout].led_names[led_id].id;
+        new_led.name = AsusTUFK7Layouts[layout].led_names[led_idx];
         leds.push_back(new_led);
     }
 
     SetupColors();
-
-    /*---------------------------------------------------------*\
-    | sends the init packet for the default mode (direct)       |
-    \*---------------------------------------------------------*/
-    DeviceUpdateMode();
 }
 
 void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
@@ -427,19 +254,12 @@ void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
 {
-    std::vector<led_color> led_color_list = {};
-
-    for(int i = 0; i < colors.size(); i++)
-    {
-        led_color_list.push_back({ leds[i].value, colors[i] });
-    }
-
-    controller->UpdateLeds(led_color_list);
+    DeviceUpdateMode();
 }
 
 void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
 {
-    DeviceUpdateLEDs();
+    controller->UpdateLeds(colors);
 }
 
 void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
@@ -448,100 +268,72 @@ void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
     unsigned char green = RGBGetGValue(colors[led]);
     unsigned char blue  = RGBGetBValue(colors[led]);
 
-    controller->UpdateSingleLed(leds[led].value, red, green, blue);
+    controller->UpdateSingleLed(led, red, green, blue);
 }
 
-static const uint8_t direction_map[2][6] =
-{
-    { 4,  0,  6,  2,  8,  1 },          // Default directions Left, Right, Up, Down, Horizontal, Vertical
-    { 0,  4,  6,  2,  0xFF,  0xFF },    // AURA_ROG_CLAYMORE directions Left, Right, Up, Down
-};
-
 void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
 {
-    if(pid == AURA_ROG_CLAYMORE_PID)
-    {
-        controller->AllowRemoteControl(1);
-    }
-
-    unsigned char color_mode    = 0;
-    unsigned char direction     = 0;
-    unsigned char brightness    = 0;
+    unsigned char color_mode;
+    std::vector<RGBColor> mode_colors;
 
     if(modes[active_mode].value == AURA_KEYBOARD_MODE_DIRECT)
     {
-        if(pid == AURA_ROG_CLAYMORE_PID) controller->AllowRemoteControl(3);
-        return;
-    };
-
-    if(pid != AURA_ROG_CLAYMORE_PID)
-    {
-        brightness = modes[active_mode].brightness * 25;
-
-        switch(modes[active_mode].value)
-        {
-            case AURA_KEYBOARD_MODE_BREATHING:
-            case AURA_KEYBOARD_MODE_REACTIVE:
-            case AURA_KEYBOARD_MODE_STARRY_NIGHT:
-            case AURA_KEYBOARD_MODE_CURRENT:
-            case AURA_KEYBOARD_MODE_RAIN_DROP:
-                bool color_is_black = (modes[active_mode].colors.size() > 1 && modes[active_mode].colors[1] == 000);
-
-                if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && !color_is_black)
-                {
-                    color_mode = 16;
-                }
-                break;
-        }
-
-        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
-        {
-            color_mode = 1;
-        }
-
-        if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE)
-        {
-            /*----------------------------------------------------------*\
-            | converting openrgb direction value to keyboard directions  |
-            \*----------------------------------------------------------*/
-            direction  = direction_map[0][modes[active_mode].direction];
-        }
+        controller->UpdateLeds(colors);
     }
     else
     {
-        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
+        bool mode_with_double = (modes[active_mode].value == 1 || modes[active_mode].value == 3 || modes[active_mode].value == 6 || modes[active_mode].value == 8 || modes[active_mode].value == 9);
+
+        if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && mode_with_double && modes[active_mode].colors.size() > 1)
         {
-            color_mode = 1;
+            if(modes[active_mode].colors[1] == 000)
+            {
+                color_mode = 0;
+            }
+            else
+            {
+                color_mode = 16;
+            }
+        }
+        else
+        {
+            color_mode = modes[active_mode].color_mode == MODE_COLORS_RANDOM ? 1 : 0;
         }
 
-        if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE) {
-            if (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) color_mode = 2;
+        int direction = 0;
 
-            /*----------------------------------------------------------*\
-            | converting openrgb direction value to keyboard directions  |
-            \*----------------------------------------------------------*/
-            direction = direction_map[1][modes[active_mode].direction];
+        switch (modes[active_mode].direction)
+        {
+            case MODE_DIRECTION_LEFT:
+                direction = 0;
+                break;
+            case MODE_DIRECTION_RIGHT:
+                direction = 4;
+                break;
+            case MODE_DIRECTION_UP:
+                direction = 6;
+                break;
+            case MODE_DIRECTION_DOWN:
+                direction = 2;
+                break;
+            case MODE_DIRECTION_HORIZONTAL:
+                direction = 8;
+                break;
+            case MODE_DIRECTION_VERTICAL:
+                direction = 1;
+                break;
         }
-    }
 
-    controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), direction, color_mode, modes[active_mode].speed, brightness);
+        mode_colors = modes[active_mode].color_mode == MODE_COLORS_PER_LED ? std::vector<RGBColor>(colors) : std::vector<RGBColor>(modes[active_mode].colors);
 
-    if(pid == AURA_ROG_CLAYMORE_PID)
-    {
-        controller->UpdateMode(modes[active_mode].value);
-        controller->SaveMode();
-        controller->AllowRemoteControl(0);
+        controller->UpdateDevice(modes[active_mode].value, mode_colors, direction, color_mode, (15 - modes[active_mode].speed), modes[active_mode].brightness * 25);
     }
 }
 
 void RGBController_AuraTUFKeyboard::DeviceSaveMode()
 {
-    /*----------------------------------------------------------*\
-    | not available for Claymore                                 |
-    \*----------------------------------------------------------*/
-    if(pid != AURA_ROG_CLAYMORE_PID)
-    {
-        DeviceUpdateMode();
-        controller->SaveMode();
-    }
+    controller->ClearResponses();
+    DeviceUpdateMode();
+    controller->AwaitResponse();
+    controller->SaveMode();
 }

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h

@@ -13,26 +13,12 @@
 
 enum
 {
-    AURA_KEYBOARD_SPEED_MAX          = 0,
+    AURA_KEYBOARD_SPEED_MIN          = 0,
+    AURA_KEYBOARD_SPEED_MAX          = 15,
     AURA_KEYBOARD_SPEED_DEFAULT      = 8,
     AURA_KEYBOARD_BRIGHTNESS_MIN     = 0,
     AURA_KEYBOARD_BRIGHTNESS_MAX     = 4,
-    AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4,
-};
-
-enum
-{
-    AURA_CLAYMORE_SPEED_MIN                    = 254,
-    AURA_CLAYMORE_SPEED_MAX                    = 0,
-    AURA_CLAYMORE_SPEED_DEFAULT_STATIC         = 0,
-    AURA_CLAYMORE_SPEED_DEFAULT_BREATHING      = 107,
-    AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE    = 121,
-    AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE       = 56,
-    AURA_CLAYMORE_SPEED_DEFAULT_WAVE           = 50,
-    AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE         = 108,
-    AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT   = 54,
-    AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND      = 103,
-
+    AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4
 };
 
 class RGBController_AuraTUFKeyboard : public RGBController
@@ -54,5 +40,4 @@ public:
 
 private:
     AuraTUFKeyboardController*  controller;
-    uint16_t                    pid;
 };

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.cpp

@@ -1,198 +0,0 @@
-/*-----------------------------------------*\
-|  AsusCerberusKeyboardController.cpp       |
-|                                           |
-|  Driver for ASUS Cerberus USB lighting    |
-|  controller                               |
-|                                           |
-|  Mola19 05/28/2022                        |
-\*-----------------------------------------*/
-
-#include "AsusCerberusKeyboardController.h"
-
-#include <cstring>
-#include <string>
-#include <vector>
-#include <math.h>
-#include <stdio.h>
-#include <string.h>
-#include <cmath>
-
-#define ASUS_CERBERUS_KB_PACKET_SIZE 8
-
-AsusCerberusKeyboardController::AsusCerberusKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version)
-{
-    dev         = dev_handle;
-    location    = path;
-    version     = rev_version;
-}
-
-AsusCerberusKeyboardController::~AsusCerberusKeyboardController()
-{
-    hid_close(dev);
-}
-
-std::string AsusCerberusKeyboardController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AsusCerberusKeyboardController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-std::string AsusCerberusKeyboardController::GetVersion()
-{
-    char versionstr[5];
-    snprintf(versionstr, 3, "%X", version);
-    return(std::string(versionstr, 3));
-}
-
-void AsusCerberusKeyboardController::SetProfile
-    (
-    uint8_t           profile
-    )
-{
-    uint8_t usb_buf[ASUS_CERBERUS_KB_PACKET_SIZE];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00] = 0x07;
-    usb_buf[0x01] = 0x03;
-    usb_buf[0x02] = profile;
-
-    hid_send_feature_report(dev, usb_buf, ASUS_CERBERUS_KB_PACKET_SIZE);
-}
-
-void AsusCerberusKeyboardController::SetPerLEDColor
-    (
-    uint8_t           key,
-    uint8_t           red,
-    uint8_t           green,
-    uint8_t           blue
-    )
-{
-    uint8_t profile = 1;
-
-    uint8_t usb_buf[ASUS_CERBERUS_KB_PACKET_SIZE];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00] = 0x07;
-    usb_buf[0x01] = 0x0D;
-    usb_buf[0x02] = profile;
-    usb_buf[0x03] = key;
-    usb_buf[0x04] = red;
-    usb_buf[0x05] = green;
-    usb_buf[0x06] = blue;
-
-    hid_send_feature_report(dev, usb_buf, ASUS_CERBERUS_KB_PACKET_SIZE);
-}
-
-void AsusCerberusKeyboardController::SendPerLEDColorEnd()
-{
-    SetPerLEDColor(255, 0, 0, 0);
-}
-
-void AsusCerberusKeyboardController::SetPerLEDMode
-    (
-    uint8_t           mode
-    )
-{
-    /*------------------------------------------------------------------------------------------------------*\
-    | this device has 6 different profiles, but there is no way to fetch them from the device,               |
-    | hence this device always sends to the first profile until a better solution is implemented in OpenRGB  |
-    \*------------------------------------------------------------------------------------------------------*/
-    uint8_t profile = 1;
-
-    /*--------------------------------------------------------------------------------*\
-    | 8 booleans per byte, each boolean controls one key                               |
-    | 0 = static, 1 = breathing                                                        |
-    | since openrgb doesn't support per led modes, either all static or all breathing  |
-    \*--------------------------------------------------------------------------------*/
-
-    uint8_t modebyte = (mode == 1) ? 0xFF : 0x00;
-
-    for(int i = 0; i < 4; i++)
-    {
-        uint8_t usb_buf[ASUS_CERBERUS_KB_PACKET_SIZE];
-
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        usb_buf[0x00] = 0x07;
-        usb_buf[0x01] = 0x0E;
-        usb_buf[0x02] = profile;
-        usb_buf[0x03] = i;
-        usb_buf[0x04] = modebyte;
-        usb_buf[0x05] = modebyte;
-        usb_buf[0x06] = modebyte;
-        usb_buf[0x07] = modebyte;
-
-        hid_send_feature_report(dev, usb_buf, ASUS_CERBERUS_KB_PACKET_SIZE);
-    }
-}
-
-void AsusCerberusKeyboardController::SetMode
-    (
-    uint8_t           mode,
-    uint8_t           red,
-    uint8_t           green,
-    uint8_t           blue,
-    uint8_t           direction,
-    uint8_t           brightness
-    )
-{
-    /*------------------------------------------------------------------------------------------------------*\
-    | this device has 6 different profiles, but there is no way to fetch them from the device,               |
-    | hence this device always sends to the first profile until a better solution is implemented in OpenRGB  |
-    \*------------------------------------------------------------------------------------------------------*/
-    uint8_t profile = 1;
-
-    uint8_t usb_buf_1[ASUS_CERBERUS_KB_PACKET_SIZE];
-
-    memset(usb_buf_1, 0x00, sizeof(usb_buf_1));
-
-    usb_buf_1[0x00] = 0x07;
-    usb_buf_1[0x01] = 0x0A;
-    usb_buf_1[0x02] = profile;
-    usb_buf_1[0x03] = mode;
-    usb_buf_1[0x04] = direction;
-
-    hid_send_feature_report(dev, usb_buf_1, ASUS_CERBERUS_KB_PACKET_SIZE);
-
-    uint8_t usb_buf_2[ASUS_CERBERUS_KB_PACKET_SIZE];
-
-    memset(usb_buf_2, 0x00, sizeof(usb_buf_2));
-
-    usb_buf_2[0x00] = 0x07;
-    usb_buf_2[0x01] = 0x0B;
-    usb_buf_2[0x02] = profile;
-    usb_buf_2[0x03] = mode;
-    usb_buf_2[0x04] = red;
-    usb_buf_2[0x05] = green;
-    usb_buf_2[0x06] = blue;
-
-    hid_send_feature_report(dev, usb_buf_2, ASUS_CERBERUS_KB_PACKET_SIZE);
-
-    uint8_t usb_buf_3[ASUS_CERBERUS_KB_PACKET_SIZE];
-
-    memset(usb_buf_3, 0x00, sizeof(usb_buf_3));
-
-    usb_buf_3[0x00] = 0x07;
-    usb_buf_3[0x01] = 0x0C;
-    usb_buf_3[0x02] = profile;
-    usb_buf_3[0x03] = brightness;
-
-    hid_send_feature_report(dev, usb_buf_3, ASUS_CERBERUS_KB_PACKET_SIZE);
-}

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.h

@@ -1,51 +0,0 @@
-/*-----------------------------------------*\
-|  AsusCerberusKeyboardController.h         |
-|                                           |
-|  Definitions and types for ASUS Cerberus  |
-|  USB RGB lighting controller              |
-|                                           |
-|  Mola19 03/03/2021                        |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    CERBERUS_KEYBOARD_MODE_STATIC       = 0,
-    CERBERUS_KEYBOARD_MODE_BREATHING    = 1,
-    CERBERUS_KEYBOARD_MODE_REACTIVE     = 2,
-    CERBERUS_KEYBOARD_MODE_EXPLOSION    = 3,
-    CERBERUS_KEYBOARD_MODE_COLOR_CYCLE  = 4,
-    CERBERUS_KEYBOARD_MODE_WAVE         = 6,
-    CERBERUS_KEYBOARD_MODE_CUSTOM       = 7,
-};
-
-
-class AsusCerberusKeyboardController
-{
-public:
-    AsusCerberusKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version);
-    ~AsusCerberusKeyboardController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-    std::string GetVersion();
-
-    void SetProfile(uint8_t profile);
-    void SetPerLEDColor(uint8_t key, uint8_t red, uint8_t green, uint8_t blue);
-    void SendPerLEDColorEnd();
-    void SetPerLEDMode(uint8_t mode);
-    void SetMode(uint8_t mode, uint8_t red, uint8_t green, uint8_t blue, uint8_t direction, uint8_t brightness);
-
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-    unsigned short              version;
-};

Controllers/AsusLegacyUSBController/AsusLegacyUSBControllerDetect.cpp

@@ -1,8 +1,6 @@
 #include "Detector.h"
-#include "AsusCerberusKeyboardController.h"
 #include "AsusStrixClawController.h"
 #include "RGBController.h"
-#include "RGBController_AsusCerberusKeyboard.h"
 #include "RGBController_AsusStrixClaw.h"
 #include <stdexcept>
 #include <hidapi/hidapi.h>
@@ -10,22 +8,8 @@
 
 #define ASUS_LEGACY_USB_VID         0x195D
 
-#define ASUS_CERBERUS_MECH_PID      0x2047
 #define ASUS_ROG_STRIX_CLAW_PID     0x1016
 
-void DetectAsusCerberusMech(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AsusCerberusKeyboardController*     controller          = new AsusCerberusKeyboardController(dev, info->path, info->release_number);
-        RGBController_AsusCerberusKeyboard* rgb_controller      = new RGBController_AsusCerberusKeyboard(controller);
-        rgb_controller->name                                = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
 void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -39,6 +23,4 @@ void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
     }
 }
 
-REGISTER_HID_DETECTOR_IPU("ASUS Cerberus Mech",  DetectAsusCerberusMech,  ASUS_LEGACY_USB_VID, ASUS_CERBERUS_MECH_PID,  1, 0xFF01, 1);
-
-REGISTER_HID_DETECTOR_IPU("ASUS ROG Strix Claw", DetectAsusStrixClaw,     ASUS_LEGACY_USB_VID, ASUS_ROG_STRIX_CLAW_PID, 0, 0xFF01, 1);
+REGISTER_HID_DETECTOR_IPU("ASUS ROG Strix Claw", DetectAsusStrixClaw,  ASUS_LEGACY_USB_VID, ASUS_ROG_STRIX_CLAW_PID, 0, 0xFF01, 1);

Controllers/AsusLegacyUSBController/RGBController_AsusCerberusKeyboard.cpp

@@ -1,391 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusCerberusKeyboard.cpp   |
-|                                           |
-|  Generic RGB Interface for Asus Cerberus  |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 05/28/2022                        |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusCerberusKeyboard.h"
-#include <vector>
-#include <cmath>
-#include "RGBControllerKeyNames.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus Cerberus Mech Keyboard
-    @category Keyboard
-    @type USB
-    @save :robot:
-    @direct :x:
-    @effects :white_check_mark:
-    @detectors DetectAsusCerberusMech
-    @comment
-\*-------------------------------------------------------------------*/
-
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-
-static unsigned int matrix_map[6][24] = {
-    {   0,  NA,   9,  15,  20,  25,  NA,  35,  40,  45,  50,  56,  62,  67,  72,  NA,  75,  79,  84,  NA,  NA,  NA,  NA,  NA },
-    {   1,   6,  10,  16,  21,  26,  30,  36,  41,  46,  51,  57,  63,  68,  NA,  NA,  76,  80,  85,  NA,  88,  93,  97, 102 },
-    {   2,  NA,  11,  17,  22,  27,  31,  37,  42,  47,  52,  58,  64,  69,  NA,  NA,  77,  81,  86,  NA,  89,  94,  98, 103 },
-    {   3,  NA,  12,  18,  23,  28,  32,  38,  43,  48,  53,  59,  65,  70,  73,  NA,  NA,  NA,  NA,  NA,  90,  95,  99,  NA },
-    {   4,   7,  13,  19,  24,  29,  33,  39,  44,  49,  54,  60,  NA,  71,  NA,  NA,  NA,  82,  NA,  NA,  91,  96, 100, 104 },
-    {   5,   8,  14,  NA,  NA,  NA,  34,  NA,  NA,  NA,  55,  61,  66,  NA,  74,  NA,  78,  83,  87,  NA,  92,  NA, 101,  NA }
-};
-
-struct led_value
-{
-    const char*     name;
-    uint8_t         id;
-};
-
-static const std::vector<led_value> led_names =
-{
-    { KEY_EN_ESCAPE,              0x0B },
-    { KEY_EN_BACK_TICK,           0x0E },
-    { KEY_EN_TAB,                 0x09 },
-    { KEY_EN_CAPS_LOCK,           0x11 },
-    { KEY_EN_LEFT_SHIFT,          0x79 },
-    { KEY_EN_LEFT_CONTROL,        0x06 },
-
-    { KEY_EN_1,                   0x0F },
-    { KEY_EN_ISO_BACK_SLASH,      0x13 },
-    { KEY_EN_LEFT_WINDOWS,        0x7C },
-
-    { KEY_EN_F1,                  0x16 },
-    { KEY_EN_2,                   0x17 },
-    { KEY_EN_Q,                   0x08 },
-    { KEY_EN_A,                   0x0A },
-    { KEY_EN_Z,                   0x0C },
-    { KEY_EN_LEFT_ALT,            0x4B },
-
-    { KEY_EN_F2,                  0x1E },
-    { KEY_EN_3,                   0x1F },
-    { KEY_EN_W,                   0x10 },
-    { KEY_EN_S,                   0x12 },
-    { KEY_EN_X,                   0x14 },
-
-    { KEY_EN_F3,                  0x19 },
-    { KEY_EN_4,                   0x27 },
-    { KEY_EN_E,                   0x18 },
-    { KEY_EN_D,                   0x1A },
-    { KEY_EN_C,                   0x1C },
-
-    { KEY_EN_F4,                  0x1B },
-    { KEY_EN_5,                   0x26 },
-    { KEY_EN_R,                   0x20 },
-    { KEY_EN_F,                   0x22 },
-    { KEY_EN_V,                   0x24 },
-
-    { KEY_EN_6,                   0x2E },
-    { KEY_EN_T,                   0x21 },
-    { KEY_EN_G,                   0x23 },
-    { KEY_EN_B,                   0x25 },
-    { KEY_EN_SPACE,               0x5B },
-
-    { KEY_EN_F5,                  0x07 },
-    { KEY_EN_7,                   0x2F },
-    { KEY_EN_Y,                   0x29 },
-    { KEY_EN_H,                   0x2B },
-    { KEY_EN_N,                   0x2D },
-
-    { KEY_EN_F6,                  0x33 },
-    { KEY_EN_8,                   0x37 },
-    { KEY_EN_U,                   0x28 },
-    { KEY_EN_J,                   0x2A },
-    { KEY_EN_M,                   0x2C },
-
-    { KEY_EN_F7,                  0x39 },
-    { KEY_EN_9,                   0x3F },
-    { KEY_EN_I,                   0x30 },
-    { KEY_EN_K,                   0x32 },
-    { KEY_EN_COMMA,               0x34 },
-
-    { KEY_EN_F8,                  0x3E },
-    { KEY_EN_0,                   0x47 },
-    { KEY_EN_O,                   0x38 },
-    { KEY_EN_L,                   0x3A },
-    { KEY_EN_PERIOD,              0x3C },
-    { KEY_EN_RIGHT_ALT,           0x4D },
-
-    { KEY_EN_F9,                  0x56 },
-    { KEY_EN_MINUS,               0x46 },
-    { KEY_EN_P,                   0x40 },
-    { KEY_EN_SEMICOLON,           0x42 },
-    { KEY_EN_FORWARD_SLASH,       0x45 },
-    { KEY_EN_RIGHT_FUNCTION,      0x7D },
-
-    { KEY_EN_F10,                 0x57 },
-    { KEY_EN_EQUALS,              0x36 },
-    { KEY_EN_LEFT_BRACKET,        0x41 },
-    { KEY_EN_QUOTE,               0x43 },
-    { KEY_EN_MENU,                0x3D },
-
-    { KEY_EN_F11,                 0x53 },
-    { KEY_EN_BACKSPACE,           0x51 },
-    { KEY_EN_RIGHT_BRACKET,       0x31 },
-    { KEY_EN_POUND,               0x44 },
-    { KEY_EN_RIGHT_SHIFT,         0x7A },
-
-    { KEY_EN_F12,                 0x55 },
-    { KEY_EN_ISO_ENTER,           0x54 },
-    { KEY_EN_RIGHT_CONTROL,       0x04 },
-    { KEY_EN_PRINT_SCREEN,        0x4F },
-
-    { KEY_EN_INSERT,              0x66 },
-    { KEY_EN_DELETE,              0x5E },
-    { KEY_EN_LEFT_ARROW,          0x75 },
-
-    { KEY_EN_SCROLL_LOCK,         0x48 },
-    { KEY_EN_HOME,                0x76 },
-    { KEY_EN_END,                 0x77 },
-    { KEY_EN_UP_ARROW,            0x73 },
-    { KEY_EN_DOWN_ARROW,          0x5D },
-
-    { KEY_EN_PAUSE_BREAK,         0x00 },
-    { KEY_EN_PAGE_UP,             0x6E },
-    { KEY_EN_PAGE_DOWN,           0x6F },
-    { KEY_EN_RIGHT_ARROW,         0x65 },
-
-    { KEY_EN_NUMPAD_LOCK,         0x5C },
-    { KEY_EN_NUMPAD_7,            0x58 },
-    { KEY_EN_NUMPAD_4,            0x59 },
-    { KEY_EN_NUMPAD_1,            0x5A },
-    { KEY_EN_NUMPAD_0,            0x63 },
-
-    { KEY_EN_NUMPAD_DIVIDE,       0x64 },
-    { KEY_EN_NUMPAD_8,            0x60 },
-    { KEY_EN_NUMPAD_5,            0x61 },
-    { KEY_EN_NUMPAD_2,            0x62 },
-
-    { KEY_EN_NUMPAD_TIMES,        0x6C },
-    { KEY_EN_NUMPAD_9,            0x68 },
-    { KEY_EN_NUMPAD_6,            0x69 },
-    { KEY_EN_NUMPAD_3,            0x6A },
-    { KEY_EN_NUMPAD_PERIOD,       0x6B },
-
-    { KEY_EN_NUMPAD_MINUS,        0x6D },
-    { KEY_EN_NUMPAD_PLUS,         0x70 },
-    { KEY_EN_NUMPAD_ENTER,        0x72 }
-};
-
-RGBController_AsusCerberusKeyboard::RGBController_AsusCerberusKeyboard(AsusCerberusKeyboardController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    /*------------------------------------------------------------------------------------------------------*\
-    | this device has 6 different profiles, but there is no way to fetch them from the device,               |
-    | hence this device always sends to the first profile until a better solution is implemented in OpenRGB  |
-    \*------------------------------------------------------------------------------------------------------*/
-
-    controller->SetProfile(1);
-
-    name        = "ASUS Cerberus Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "ASUS Cerberus Keyboard Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-    version     = controller->GetVersion();
-
-    mode Custom;
-    Custom.name                     = "Custom";
-    Custom.value                    = CERBERUS_KEYBOARD_MODE_STATIC;
-    Custom.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Custom.brightness_min           = CERBERUS_MECH_BRIGHTNESS_MIN;
-    Custom.brightness_max           = CERBERUS_MECH_BRIGHTNESS_MAX;
-    Custom.brightness               = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
-    Custom.color_mode               = MODE_COLORS_PER_LED;
-    modes.push_back(Custom);
-
-    mode Static;
-    Static.name                     = "Static";
-    Static.value                    = CERBERUS_KEYBOARD_MODE_STATIC;
-    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.brightness_min           = CERBERUS_MECH_BRIGHTNESS_MIN;
-    Static.brightness_max           = CERBERUS_MECH_BRIGHTNESS_MAX;
-    Static.brightness               = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
-    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min               = 1;
-    Static.colors_max               = 1;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = CERBERUS_KEYBOARD_MODE_BREATHING;
-    Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.brightness_min        = CERBERUS_MECH_BRIGHTNESS_MIN;
-    Breathing.brightness_max        = CERBERUS_MECH_BRIGHTNESS_MAX;
-    Breathing.brightness            = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
-    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors_min            = 1;
-    Breathing.colors_max            = 1;
-    Breathing.colors.resize(1);
-    modes.push_back(Breathing);
-
-    mode Reactive;
-    Reactive.name                   = "Reactive";
-    Reactive.value                  = CERBERUS_KEYBOARD_MODE_REACTIVE;
-    Reactive.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Reactive.brightness_min         = CERBERUS_MECH_BRIGHTNESS_MIN;
-    Reactive.brightness_max         = CERBERUS_MECH_BRIGHTNESS_MAX;
-    Reactive.brightness             = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
-    Reactive.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-    Reactive.colors_min             = 1;
-    Reactive.colors_max             = 1;
-    Reactive.colors.resize(1);
-    modes.push_back(Reactive);
-
-    mode Explosion;
-    Explosion.name                  = "Explosion";
-    Explosion.value                 = CERBERUS_KEYBOARD_MODE_EXPLOSION;
-    Explosion.flags                 = MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Explosion.brightness_min        = CERBERUS_MECH_BRIGHTNESS_MIN;
-    Explosion.brightness_max        = CERBERUS_MECH_BRIGHTNESS_MAX;
-    Explosion.brightness            = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
-    Explosion.direction             = MODE_DIRECTION_VERTICAL;
-    Explosion.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Explosion.colors_min            = 1;
-    Explosion.colors_max            = 1;
-    Explosion.colors.resize(1);
-    modes.push_back(Explosion);
-
-    mode Color_Cycle;
-    Color_Cycle.name                = "Spectrum Cycle";
-    Color_Cycle.value               = CERBERUS_KEYBOARD_MODE_COLOR_CYCLE;
-    Color_Cycle.flags               = MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Color_Cycle.brightness_min      = CERBERUS_MECH_BRIGHTNESS_MIN;
-    Color_Cycle.brightness_max      = CERBERUS_MECH_BRIGHTNESS_MAX;
-    Color_Cycle.brightness          = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
-    Color_Cycle.direction           = MODE_DIRECTION_HORIZONTAL;
-    Color_Cycle.color_mode          = MODE_COLORS_NONE;
-    modes.push_back(Color_Cycle);
-
-    mode Wave;
-    Wave.name                       = "Rainbow Wave";
-    Wave.value                      = CERBERUS_KEYBOARD_MODE_WAVE;
-    Wave.flags                      = MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Wave.brightness_min             = CERBERUS_MECH_BRIGHTNESS_MIN;
-    Wave.brightness_max             = CERBERUS_MECH_BRIGHTNESS_MAX;
-    Wave.brightness                 = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
-    Wave.direction                  = MODE_DIRECTION_LEFT;
-    Wave.color_mode                 = MODE_COLORS_NONE;
-    modes.push_back(Wave);
-
-    SetupZones();
-}
-
-RGBController_AsusCerberusKeyboard::~RGBController_AsusCerberusKeyboard()
-{
-    delete controller;
-}
-
-void RGBController_AsusCerberusKeyboard::SetupZones()
-{
-    int zone_size = 105;
-
-    zone keyboard;
-    keyboard.name               = "Keyboard";
-    keyboard.type               = ZONE_TYPE_MATRIX;
-    keyboard.leds_min           = zone_size;
-    keyboard.leds_max           = zone_size;
-    keyboard.leds_count         = zone_size;
-    keyboard.matrix_map         = new matrix_map_type;
-    keyboard.matrix_map->height = 6;
-    keyboard.matrix_map->width  = 24;
-    keyboard.matrix_map->map    = *matrix_map;
-    zones.push_back(keyboard);
-
-    for(int led_id = 0; led_id < zone_size; led_id++)
-    {
-        led new_led;
-        new_led.name  = led_names[led_id].name;
-        new_led.value = led_names[led_id].id;
-
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AsusCerberusKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
-void RGBController_AsusCerberusKeyboard::DeviceUpdateLEDs()
-{
-    for(unsigned int i = 0; i < colors.size(); i++)
-    {
-        uint8_t red   = RGBGetRValue(colors[i]);
-        uint8_t green = RGBGetGValue(colors[i]);
-        uint8_t blue  = RGBGetBValue(colors[i]);
-
-        controller->SetPerLEDColor(led_names[i].id, red, green, blue);
-    }
-    controller->SendPerLEDColorEnd();
-}
-
-void RGBController_AsusCerberusKeyboard::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AsusCerberusKeyboard::UpdateSingleLED(int led)
-{
-    uint8_t red   = RGBGetRValue(colors[led]);
-    uint8_t green = RGBGetGValue(colors[led]);
-    uint8_t blue  = RGBGetBValue(colors[led]);
-
-
-    controller->SetPerLEDColor(led_names[led].id, red, green, blue);
-    controller->SendPerLEDColorEnd();
-}
-
-void RGBController_AsusCerberusKeyboard::DeviceUpdateMode()
-{
-    uint8_t direction   = 0;
-    uint8_t red         = 0;
-    uint8_t green       = 0;
-    uint8_t blue        = 0;
-
-    uint8_t mode        = modes[active_mode].value;
-
-
-    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
-    {
-        mode        = CERBERUS_KEYBOARD_MODE_CUSTOM;
-        direction   = 1;
-
-        controller->SetPerLEDMode(modes[active_mode].value);
-    }
-
-    switch(modes[active_mode].value)
-    {
-        case CERBERUS_KEYBOARD_MODE_EXPLOSION:
-            direction = (modes[active_mode].direction == MODE_DIRECTION_HORIZONTAL) ? 1 : 0;
-            break;
-
-        case CERBERUS_KEYBOARD_MODE_COLOR_CYCLE:
-            direction = (modes[active_mode].direction == MODE_DIRECTION_HORIZONTAL) ? 0 : 1;
-            break;
-
-        case CERBERUS_KEYBOARD_MODE_WAVE:
-            direction = modes[active_mode].direction;
-            break;
-    }
-
-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        red     = RGBGetRValue(modes[active_mode].colors[0]);
-        green   = RGBGetGValue(modes[active_mode].colors[0]);
-        blue    = RGBGetBValue(modes[active_mode].colors[0]);
-    }
-
-    controller->SetMode(mode, red, green, blue, direction, modes[active_mode].brightness);
-}

Controllers/AsusLegacyUSBController/RGBController_AsusCerberusKeyboard.h

@@ -1,39 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusCerberusKeyboard.h     |
-|                                           |
-|  Generic RGB Interface for Asus Cerberus  |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 03/03/2021                        |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusCerberusKeyboardController.h"
-
-enum
-{
-    CERBERUS_MECH_BRIGHTNESS_MIN     = 0,
-    CERBERUS_MECH_BRIGHTNESS_MAX     = 4,
-    CERBERUS_MECH_BRIGHTNESS_DEFAULT = 4
-};
-
-class RGBController_AsusCerberusKeyboard : public RGBController
-{
-public:
-    RGBController_AsusCerberusKeyboard(AsusCerberusKeyboardController* controller_ptr);
-    ~RGBController_AsusCerberusKeyboard();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AsusCerberusKeyboardController*  controller;
-};

Controllers/AsusTUFLaptopController/AsusTUFLaptopWMIDetect.cpp

@@ -7,7 +7,7 @@
 #include "wmi.h"
 #include <string>
 
-static void DetectAsusTUFLaptopWMIControllers()
+static void DetectAsusTUFLaptopWMIControllers(std::vector<RGBController*>&)
 {
     // Try to retrieve ProductID / Device name from WMI; Possibly can be rewritten to use wmi.cpp
     // IF you encounter false detection ( e.g. if your laptop keyboard backlight uses USB interface

Controllers/AsusTUFLaptopLinuxController/AsusTUFLaptopLinuxController.cpp

@@ -1,51 +0,0 @@
-#include "AsusTUFLaptopLinuxController.h"
-
-#include <string>
-
-void AsusTUFLaptopLinuxController::SendUpdate
-(
-    unsigned char   mode,
-    unsigned char   speed,
-    unsigned char   save,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-)
-{
-    std::string s = "";
-    s.append(ASUS_KBD_BACKLIGHT_BASE_PATH);
-    s.append(ASUS_KBD_BACKLIGHT_MODE_PATH);
-    FILE *controller = fopen(s.c_str(), "w");
-
-    s = "";
-    s.append(std::to_string(save));
-    s.append(" ");
-    s.append(std::to_string(mode));
-    s.append(" ");
-    s.append(std::to_string(red));
-    s.append(" ");
-    s.append(std::to_string(green));
-    s.append(" ");
-    s.append(std::to_string(blue));
-    s.append(" ");
-    s.append(std::to_string(speed));
-
-    fputs(s.c_str(), controller);
-
-    fclose(controller);
-}
-
-void AsusTUFLaptopLinuxController::SendBrightness
-(
-    unsigned char   brightness
-)
-{
-    std::string s = "";
-    s.append(ASUS_KBD_BACKLIGHT_BASE_PATH);
-    s.append(ASUS_KBD_BACKLIGHT_BRIGHTNESS_PATH);
-    FILE *controller = fopen(s.c_str(), "w");
-
-    fputs(std::to_string(brightness).c_str(), controller);
-
-    fclose(controller);
-}

Controllers/AsusTUFLaptopLinuxController/AsusTUFLaptopLinuxController.h

@@ -1,37 +0,0 @@
-#ifndef ASUSTUFLAPTOPLINUXCONTROLLER_H
-#define ASUSTUFLAPTOPLINUXCONTROLLER_H
-
-#include "RGBController.h"
-
-#define ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN   0
-#define ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX   3
-#define ASUS_KBD_BACKLIGHT_BRIGHTNESS       3
-
-#define ASUS_KBD_BACKLIGHT_SPEED_MIN        0
-#define ASUS_KBD_BACKLIGHT_SPEED_MAX        2
-#define ASUS_KBD_BACKLIGHT_SPEED            1
-
-#define ASUS_KBD_BACKLIGHT_BASE_PATH        "/sys/devices/platform/asus-nb-wmi/leds/asus::kbd_backlight"
-#define ASUS_KBD_BACKLIGHT_MODE_PATH        "/kbd_rgb_mode"
-#define ASUS_KBD_BACKLIGHT_BRIGHTNESS_PATH  "/brightness"
-
-class AsusTUFLaptopLinuxController
-{
-public:
-    void    SendBrightness
-            (
-            unsigned char   brightness
-            );
-
-    void    SendUpdate
-            (
-            unsigned char   mode,
-            unsigned char   speed,
-            unsigned char   save,
-            unsigned char   red,
-            unsigned char   green,
-            unsigned char   blue
-            );
-};
-
-#endif // ASUSTUFLAPTOPLINUXCONTROLLER_H

Controllers/AsusTUFLaptopLinuxController/AsusTUFLaptopLinuxDetect.cpp

@@ -1,28 +0,0 @@
-#include "RGBController_AsusTUFLaptopLinux.h"
-#include "AsusTUFLaptopLinuxController.h"
-
-#include <string>
-#include "Detector.h"
-#include <unistd.h>
-
-static void DetectAsusTUFLaptopLinuxControllers()
-{
-    /*-------------------------------------------------------------------------------------*\
-    | If /sys/devices/platform/asus-nb-wmi/leds/asus::kbd_backlight/kbd_rgb_mode exists,    |
-    |   the kernel support TUF Laptop keyboard LED controlling.                             |
-    \*-------------------------------------------------------------------------------------*/
-
-    std::string s = "";
-    s.append(ASUS_KBD_BACKLIGHT_BASE_PATH);
-    s.append(ASUS_KBD_BACKLIGHT_MODE_PATH);
-
-    if(!access(s.c_str(), F_OK))
-    {
-        AsusTUFLaptopLinuxController*       controller     = new AsusTUFLaptopLinuxController();
-        RGBController_AsusTUFLaptopLinux*   rgb_controller = new RGBController_AsusTUFLaptopLinux(controller);
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-    return;
-}
-
-REGISTER_DETECTOR("ASUS TUF Laptop Linux WMI", DetectAsusTUFLaptopLinuxControllers);

Controllers/AsusTUFLaptopLinuxController/RGBController_AsusTUFLaptopLinux.cpp

@@ -1,150 +0,0 @@
-#include "RGBController_AsusTUFLaptopLinux.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus TUF Laptop Linux WMI
-    @category Keyboard
-    @type File Stream
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusTUFLaptopLinuxControllers
-    @comment Tested on ASUS TUF Gaming A15 2022
-    PLEASE UPDATE YOUR KERNEL TO A VERSION NEWER THAN 6.1.0
-
-    Every devices supported by asus-wmi would work technically.
-\*-------------------------------------------------------------------*/
-
-RGBController_AsusTUFLaptopLinux::RGBController_AsusTUFLaptopLinux(AsusTUFLaptopLinuxController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "ASUS TUF Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "Asus TUF Device";
-    location    = ASUS_KBD_BACKLIGHT_BASE_PATH;
-
-    mode Direct;
-    Direct.name                     = "Direct";
-    Direct.value                    = 4;
-    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.brightness_min           = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
-    Direct.brightness_max           = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
-    Direct.brightness               = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name                     = "Static";
-    Static.value                    = 0;
-    Static.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.brightness_min           = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
-    Static.brightness_max           = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
-    Static.brightness               = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
-    Static.color_mode               = MODE_COLORS_PER_LED;
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = 1;
-    Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.speed_min             = ASUS_KBD_BACKLIGHT_SPEED_MIN;
-    Breathing.speed_max             = ASUS_KBD_BACKLIGHT_SPEED_MAX;
-    Breathing.brightness_min        = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
-    Breathing.brightness_max        = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
-    Breathing.brightness            = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
-    Breathing.color_mode            = MODE_COLORS_PER_LED;
-    Breathing.speed                 = ASUS_KBD_BACKLIGHT_SPEED;
-    modes.push_back(Breathing);
-
-    mode Cycle;
-    Cycle.name                      = "Spectrum Cycle";
-    Cycle.value                     = 2;
-    Cycle.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Cycle.speed_min                 = ASUS_KBD_BACKLIGHT_SPEED_MIN;
-    Cycle.speed_max                 = ASUS_KBD_BACKLIGHT_SPEED_MAX;
-    Cycle.brightness_min            = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
-    Cycle.brightness_max            = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
-    Cycle.brightness                = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
-    Cycle.color_mode                = MODE_COLORS_NONE;
-    Cycle.speed                     = ASUS_KBD_BACKLIGHT_SPEED;
-    modes.push_back(Cycle);
-
-    mode Flashing;
-    Flashing.name                   = "Flashing";
-    Flashing.value                  = 0x0A;
-    Flashing.flags                  = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Flashing.brightness_min         = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
-    Flashing.brightness_max         = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
-    Flashing.brightness             = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
-    Flashing.color_mode             = MODE_COLORS_PER_LED;
-    modes.push_back(Flashing);
-
-    SetupZones();
-}
-
-void RGBController_AsusTUFLaptopLinux::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zone                                               |
-    \*---------------------------------------------------------*/
-    zones.resize(1);
-    zones[0].type           = ZONE_TYPE_SINGLE;
-    zones[0].name           = "Keyboard Backlight zone";
-    zones[0].leds_min       = 1;
-    zones[0].leds_max       = 1;
-    zones[0].leds_count     = 1;
-    zones[0].matrix_map     = NULL;
-
-    /*---------------------------------------------------------*\
-    | Set up LED                                                |
-    \*---------------------------------------------------------*/
-    leds.resize(1);
-    leds[0].name = "Keyboard Backlight LED";
-
-    SetupColors();
-}
-
-void RGBController_AsusTUFLaptopLinux::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AsusTUFLaptopLinux::DeviceUpdateLEDs()
-{
-    uint8_t red   = RGBGetRValue(colors[0]);
-    uint8_t green = RGBGetGValue(colors[0]);
-    uint8_t blue  = RGBGetBValue(colors[0]);
-    uint8_t speed = 0;
-    uint8_t mode  = modes[active_mode].value;
-    uint8_t save  = 1;
-    if(mode == 4)
-    {
-        mode = 0;
-        save = 0;
-    }
-    if(mode == 1 || mode == 2)
-    {
-        speed = modes[active_mode].speed;
-    }
-
-    controller->SendUpdate(mode, speed, save, red, green, blue);
-    controller->SendBrightness(modes[active_mode].brightness);
-}
-
-void RGBController_AsusTUFLaptopLinux::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AsusTUFLaptopLinux::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AsusTUFLaptopLinux::DeviceUpdateMode()
-{
-    DeviceUpdateLEDs();
-}

Controllers/AsusTUFLaptopLinuxController/RGBController_AsusTUFLaptopLinux.h

@@ -1,27 +0,0 @@
-#ifndef RGBCONTROLLER_ASUSTUFLAPTOPLINUX_H
-#define RGBCONTROLLER_ASUSTUFLAPTOPLINUX_H
-
-#include "RGBController.h"
-#include "AsusTUFLaptopLinuxController.h"
-
-
-class RGBController_AsusTUFLaptopLinux : public RGBController
-{
-public:
-    RGBController_AsusTUFLaptopLinux(AsusTUFLaptopLinuxController* controller_ptr);
-
-    void SetupZones() override;
-
-    void ResizeZone(int zone, int new_size) override;
-
-    void DeviceUpdateLEDs() override;
-    void UpdateZoneLEDs(int zone) override;
-    void UpdateSingleLED(int led) override;
-
-    void DeviceUpdateMode() override;
-
-private:
-    AsusTUFLaptopLinuxController* controller;
-};
-
-#endif // RGBCONTROLLER_ASUSTUFLAPTOPLINUX_H

Controllers/BlinkyTapeController/BlinkyTapeControllerDetect.cpp

@@ -19,7 +19,7 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectBlinkyTapeControllers()
+void DetectBlinkyTapeControllers(std::vector<RGBController*> &rgb_controllers)
 {
     std::vector<std::string *> device_locations = find_usb_serial_port(BLINKINLABS_VID, BLINKYTAPE_PID);
 
@@ -29,7 +29,7 @@ void DetectBlinkyTapeControllers()
         controller->Initialize(*device_locations[device_idx]);
 
         RGBController_BlinkyTape* rgb_controller = new RGBController_BlinkyTape(controller);
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        rgb_controllers.push_back(rgb_controller);
     }
 }
 

Controllers/ColorfulGPUController/ColorfulGPUController.cpp

@@ -1,44 +0,0 @@
-#include "ColorfulGPUController.h"
-#include <cstring>
-
-ColorfulGPUController::ColorfulGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-}
-
-ColorfulGPUController::~ColorfulGPUController()
-{
-
-}
-
-std::string ColorfulGPUController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-void ColorfulGPUController::SetDirect(RGBColor color)
-{
-    uint8_t r = RGBGetRValue(color);
-    uint8_t g = RGBGetGValue(color);
-    uint8_t b = RGBGetBValue(color);
-
-    uint8_t data_pkt[COLORFUL_PACKET_LENGTH] = { 0xAA, 0xEF, 0x12, 0x03, 0x01, 0xFF, r, g, b};
-
-    int crc = 0;
-
-    for (int i = 0; i < COLORFUL_PACKET_LENGTH - 2; ++i)
-    {
-        crc += data_pkt[i];
-    }
-
-    data_pkt[COLORFUL_PACKET_LENGTH - 2] = crc & 0xFF;
-    data_pkt[COLORFUL_PACKET_LENGTH - 1] = crc >> 8;
-
-    bus->i2c_write_block(dev, COLORFUL_PACKET_LENGTH, data_pkt);
-}

Controllers/ColorfulGPUController/ColorfulGPUController.h

@@ -1,24 +0,0 @@
-#include <string>
-#include "i2c_smbus.h"
-#include "RGBController.h"
-
-#pragma once
-
-typedef unsigned char colorful_gpu_dev_id;
-
-#define COLORFUL_PACKET_LENGTH 11
-
-class ColorfulGPUController
-{
-public:
-    ColorfulGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev);
-    ~ColorfulGPUController();
-
-    std::string GetDeviceLocation();
-    void        SetDirect(RGBColor color);
-
-
-private:
-    i2c_smbus_interface *   bus;
-    colorful_gpu_dev_id     dev;
-};

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -1,47 +0,0 @@
-#include "Detector.h"
-#include "ColorfulGPUController.h"
-#include "RGBController.h"
-#include "RGBController_ColorfulGPU.h"
-#include "i2c_smbus.h"
-#include "pci_ids.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-bool TestForColorfulGPU(i2c_smbus_interface* bus, uint8_t i2c_addr)
-{
-    int pktsz;
-    const int read_sz  = 0x40;
-    const int write_sz = 6;
-
-    uint8_t data_pkt[write_sz] = { 0xAA, 0xEF, 0x81, 0x02, 0x1C, 0x02};
-    bus->i2c_write_block(i2c_addr, write_sz, data_pkt);
-
-    uint8_t read_pkt[read_sz] = {};
-    pktsz = read_sz;
-
-    int res = bus->i2c_read_block(i2c_addr, &pktsz, read_pkt);
-
-    return res == 0 && (read_pkt[0] == 0xAA && read_pkt[1] == 0xEF && read_pkt[2] == 0x81);
-}
-
-void DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
-{
-    if(TestForColorfulGPU(bus, i2c_addr))
-    {
-        ColorfulGPUController*     controller     = new ColorfulGPUController(bus, i2c_addr);
-        RGBController_ColorfulGPU* rgb_controller = new RGBController_ColorfulGPU(controller);
-        rgb_controller->name                      = name;
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-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_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_2,    0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,       0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV2,      0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC LHR",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ULTRAW_OC,          0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Advanced OC-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_TI_ADVANCED_OCV2,   0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2,        0x61);

Controllers/ColorfulGPUController/RGBController_ColorfulGPU.cpp

@@ -1,82 +0,0 @@
-#include "RGBController_ColorfulGPU.h"
-#include <array>
-
-/**------------------------------------------------------------------*\
-    @name Colorful GPU
-    @category GPU
-    @type I2C
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectColorfulGPUControllers
-    @comment This card only supports direct mode
-\*-------------------------------------------------------------------*/
-
-RGBController_ColorfulGPU::RGBController_ColorfulGPU(ColorfulGPUController * colorful_gpu_ptr)
-{
-    controller  = colorful_gpu_ptr;
-    name        = "Colorful GPU Device";
-    vendor      = "Colorful";
-    type        = DEVICE_TYPE_GPU;
-    description = name;
-    location    = controller->GetDeviceLocation();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-
-}
-
-RGBController_ColorfulGPU::~RGBController_ColorfulGPU()
-{
-    delete controller;
-}
-
-void RGBController_ColorfulGPU::SetupZones()
-{
-    zone new_zone;
-
-    new_zone.name       = "GPU";
-    new_zone.type       = ZONE_TYPE_LINEAR;
-    new_zone.leds_min   = 1;
-    new_zone.leds_max   = 1;
-    new_zone.leds_count = 1;
-    new_zone.matrix_map = nullptr;
-
-    zones.emplace_back(new_zone);
-
-    leds.resize(new_zone.leds_count);
-    leds[0].name = "GPU LED";
-
-    SetupColors();
-}
-
-void RGBController_ColorfulGPU::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
-void RGBController_ColorfulGPU::DeviceUpdateLEDs()
-{
-    controller->SetDirect(colors[0]);
-}
-
-void RGBController_ColorfulGPU::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_ColorfulGPU::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_ColorfulGPU::DeviceUpdateMode()
-{
-    DeviceUpdateLEDs();
-}

Controllers/ColorfulGPUController/RGBController_ColorfulGPU.h

@@ -1,26 +0,0 @@
-#pragma once
-
-#include "RGBController.h"
-#include "ColorfulGPUController.h"
-
-class RGBController_ColorfulGPU : public RGBController
-{
-public:
-    RGBController_ColorfulGPU(ColorfulGPUController* colorful_gpu_ptr);
-    ~RGBController_ColorfulGPU();
-
-    void        SetupZones();
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    ColorfulGPUController* controller;
-
-};
-
-

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -44,7 +44,6 @@
 \*-----------------------------------------------------*/
 #define COOLERMASTER_ARGB_PID                       0x1011
 #define COOLERMASTER_ARGB_GEN2_A1_PID               0x0173
-#define COOLERMASTER_ARGB_GEN2_A1_V2_PID            0x01C9
 #define COOLERMASTER_SMALL_ARGB_PID                 0x1000
 #define COOLERMASTER_RGB_PID                        0x004F
 
@@ -94,7 +93,7 @@ void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
     }
 }
 
-void DetectCoolerMasterARGBGen2A1(hid_device_info* info, const std::string& name)
+void DetectCoolerMasterARGBGen2A1(hid_device_info* info, const std::string&)
 {
     hid_device* dev = hid_open_path(info->path);
 
@@ -102,7 +101,7 @@ void DetectCoolerMasterARGBGen2A1(hid_device_info* info, const std::string& name
     {
         CMARGBGen2A1controller*               controller     = new CMARGBGen2A1controller(dev, *info);
         RGBController_CMARGBGen2A1Controller* rgb_controller = new RGBController_CMARGBGen2A1Controller(controller);
-        rgb_controller->name                                 = name;
+        // Constructor sets the name
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -213,7 +212,7 @@ void DetectCoolerMasterSmallARGB(hid_device_info* info, const std::string&)
 REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_PID,          1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L White",   DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID,    1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro S",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_S_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MK750",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_MK750_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MK570",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_MK750_PID,          1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master SK630",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_SK630_PID,          1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master SK650",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_SK650_PID,          1,      0xFF00, 1);
 
@@ -222,7 +221,6 @@ REGISTER_HID_DETECTOR_IPU("Cooler Master SK650",                    DetectCooler
 \*-----------------------------------------------------*/
 REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB",                     DetectCoolerMasterARGB,         COOLERMASTER_VID,   COOLERMASTER_ARGB_PID,                      0,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB Gen 2 A1",            DetectCoolerMasterARGBGen2A1,   COOLERMASTER_VID,   COOLERMASTER_ARGB_GEN2_A1_PID,              1,      0xFF01, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB Gen 2 A1 V2",         DetectCoolerMasterARGBGen2A1,   COOLERMASTER_VID,   COOLERMASTER_ARGB_GEN2_A1_V2_PID,           1,      0xFF01, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master RGB",                      DetectCoolerMasterRGB,          COOLERMASTER_VID,   COOLERMASTER_RGB_PID,                       1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master Small ARGB",               DetectCoolerMasterSmallARGB,    COOLERMASTER_VID,   COOLERMASTER_SMALL_ARGB_PID,                0,      0xFF00, 1);
 

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumControllerDetect.cpp

@@ -72,17 +72,6 @@ void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *
                 }
                 std::this_thread::sleep_for(10ms);
             }
-            for(unsigned char addr = 0x18; addr <= 0x1F; addr++)
-            {
-                if(TestForCorsairDominatorPlatinumController(busses[bus], addr))
-                {
-                    CorsairDominatorPlatinumController*     new_controller    = new CorsairDominatorPlatinumController(busses[bus], addr);
-                    RGBController_CorsairDominatorPlatinum* new_rgbcontroller = new RGBController_CorsairDominatorPlatinum(new_controller);
-                    
-                    ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
-                }
-                std::this_thread::sleep_for(10ms);
-            }
         }
         else
         {

Controllers/CorsairHydro2Controller/CorsairHydro2Controller.cpp

@@ -1,91 +0,0 @@
-/*-----------------------------------------*\
-|  CorsairHydro2Controller.cpp              |
-|                                           |
-|  Controller for Corsair H100i v2          |
-|                                           |
-|  Tim Demand (tim.dmd) 1/10/2023           |
-\*-----------------------------------------*/
-
-#include "CorsairHydro2Controller.h"
-#include <cstring>
-#include <iomanip>
-#include <sstream>
-
-CorsairHydro2Controller::CorsairHydro2Controller(libusb_device_handle* dev_handle)
-{
-    dev = dev_handle;
-
-    libusb_device_descriptor descriptor;
-    libusb_get_device_descriptor(libusb_get_device(dev_handle), &descriptor);
-
-    std::stringstream location_stream;
-    location_stream << std::hex << std::setfill('0') << std::setw(4) << descriptor.idVendor << ":" << std::hex << std::setfill('0') << std::setw(4) << descriptor.idProduct;
-    location = location_stream.str();
-
-    SendInit();
-}
-
-CorsairHydro2Controller::~CorsairHydro2Controller()
-{
-    if(dev)
-    {
-        libusb_close(dev);
-    }
-}
-
-std::string CorsairHydro2Controller::GetLocation()
-{
-    return("USB: " + location);
-}
-
-void CorsairHydro2Controller::SetLED(std::vector<RGBColor>& colors)
-{
-    unsigned char usb_buf[32];
-    memset(usb_buf, 0, sizeof(usb_buf));
-    int actual;
-
-    unsigned char led_enable = 0x01;
-
-    unsigned char rr = RGBGetRValue(colors[0]);
-    unsigned char gg = RGBGetBValue(colors[0]);
-    unsigned char bb = RGBGetGValue(colors[0]);
-
-    if((rr + gg + bb) == 0)
-    {
-        led_enable = 0x00; // needed because leds won't turn off completely if color is 00 00 00
-    }
-
-    usb_buf[0]  = 0x10;
-    usb_buf[1]  = rr;
-    usb_buf[2]  = bb;
-    usb_buf[3]  = gg;
-    usb_buf[4]  = 0x00;
-    usb_buf[5]  = 0xFF;
-    usb_buf[6]  = 0xFF;
-    usb_buf[7]  = 0xFF;
-    usb_buf[8]  = 0xFF;
-    usb_buf[9]  = 0xFF;
-    usb_buf[10] = 0x00;
-    usb_buf[11] = 0x0A;
-    usb_buf[12] = 0x05;
-    usb_buf[13] = led_enable;
-    usb_buf[14] = 0x00;
-    usb_buf[15] = 0x00;
-    usb_buf[16] = 0x00;
-    usb_buf[17] = 0x00;
-    usb_buf[18] = 0x01;
-
-    libusb_bulk_transfer(dev, 0x02, usb_buf, 19, &actual, 1000);
-    libusb_bulk_transfer(dev, 0x82, usb_buf, 32, &actual, 1000);
-    if(actual != 32) SendInit(); // reinitialization after sleep
-}
-
-void CorsairHydro2Controller::SendInit()
-{
-    libusb_reset_device(dev); // needed for reinitialization after sleep
-
-    libusb_control_transfer(dev, 0x40, 0, 0xffff, 0x0000, NULL, 0, 0);
-    libusb_control_transfer(dev, 0x40, 2, 0x0002, 0x0000, NULL, 0, 0);
-    libusb_control_transfer(dev, 0x40, 1, 0x0002, 0x0000, NULL, 0, 0);
-    libusb_control_transfer(dev, 0x40, 4, 0x0002, 0x0000, NULL, 0, 0);
-}

Controllers/CorsairHydro2Controller/CorsairHydro2Controller.h

@@ -1,35 +0,0 @@
-/*-----------------------------------------*\
-|  CorsairHydro2Controller.h                |
-|                                           |
-|  Controller for Corsair H100i v2          |
-|                                           |
-|  Tim Demand (tim.dmd) 1/10/2023           |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <vector>
-#ifdef __FreeBSD__
-#include <libusb.h>
-#else
-#include <libusb-1.0/libusb.h>
-#endif
-
-#pragma once
-
-class CorsairHydro2Controller
-{
-public:
-    CorsairHydro2Controller(libusb_device_handle* dev_handle);
-    ~CorsairHydro2Controller();
-
-    std::string GetLocation();
-
-    void SetLED(std::vector<RGBColor>& colors);
-
-private:
-    libusb_device_handle* dev;
-    std::string firmware_version;
-    std::string location;
-
-    void SendInit();
-};

Controllers/CorsairHydro2Controller/CorsairHydro2ControllerDetect.cpp

@@ -1,51 +0,0 @@
-/*-----------------------------------------*\
-|  CorsairHydro2ControllerDetect.cpp        |
-|                                           |
-|  Detector for Corsair H100i v2            |
-|                                           |
-|  Tim Demand (tim.dmd) 1/10/2023           |
-\*-----------------------------------------*/
-
-#include "Detector.h"
-#include "CorsairHydro2Controller.h"
-#include "RGBController.h"
-#include "RGBController_CorsairHydro2.h"
-#include <vector>
-#ifdef __FreeBSD__
-#include <libusb.h>
-#else
-#include <libusb-1.0/libusb.h>
-#endif
-
-#define CORSAIR_VID     0x1B1C
-#define H100I_V2_PID    0x0C09
-
-void DetectCorsairHydro2Controllers()
-{
-    libusb_init(NULL);
-
-    #ifdef _WIN32
-    libusb_set_option(NULL, LIBUSB_OPTION_USE_USBDK);
-    #endif
-
-    libusb_device_handle* dev = libusb_open_device_with_vid_pid(NULL, CORSAIR_VID, H100I_V2_PID);
-
-    if(dev)
-    {
-        libusb_detach_kernel_driver(dev, 0);
-        libusb_claim_interface(dev, 0);
-
-        CorsairHydro2Controller*     controller     = new CorsairHydro2Controller(dev);
-        RGBController_CorsairHydro2* rgb_controller = new RGBController_CorsairHydro2(controller);
-        rgb_controller->name                        = "Corsair H100i v2";
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_DETECTOR("Corsair H100i v2", DetectCorsairHydro2Controllers);
-/*---------------------------------------------------------------------------------------------------------*\
-| Entries for dynamic UDEV rules                                                                            |
-|                                                                                                           |
-| DUMMY_DEVICE_DETECTOR("Corsair H100i v2", DetectCorsairHydro2Controllers, 0x1B1C, 0x0C09 )                |
-\*---------------------------------------------------------------------------------------------------------*/

Controllers/CorsairHydro2Controller/RGBController_CorsairHydro2.cpp

@@ -1,91 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_CorsairHydro2.cpp          |
-|                                           |
-|  RGB Controller for Corsair H100i v2      |
-|                                           |
-|  Tim Demand (tim.dmd) 1/10/2023           |
-\*-----------------------------------------*/
-
-#include "RGBController_CorsairHydro2.h"
-
-/**------------------------------------------------------------------*\
-    @name Corsair Hydro Series H100i v2 AIO
-    @category Cooler
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectCorsairHydro2Controllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_CorsairHydro2::RGBController_CorsairHydro2(CorsairHydro2Controller* controller_ptr)
-{
-    controller = controller_ptr;
-
-    vendor      = "Corsair";
-    description = "Corsair H100i v2";
-    type        = DEVICE_TYPE_COOLER;
-    location    = controller->GetLocation();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-}
-
-RGBController_CorsairHydro2::~RGBController_CorsairHydro2()
-{
-    delete controller;
-}
-
-void RGBController_CorsairHydro2::SetupZones()
-{
-    zone new_zone;
-
-    new_zone.name       = "Pump Zone";
-    new_zone.type       = ZONE_TYPE_SINGLE;
-    new_zone.leds_min   = 1;
-    new_zone.leds_max   = 1;
-    new_zone.leds_count = 1;
-    new_zone.matrix_map = NULL;
-    zones.push_back(new_zone);
-
-    led new_led;
-
-    new_led.name = "Pump LED";
-    leds.push_back(new_led);
-
-    SetupColors();
-}
-
-void RGBController_CorsairHydro2::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_CorsairHydro2::DeviceUpdateLEDs()
-{
-    controller->SetLED(colors);
-}
-
-void RGBController_CorsairHydro2::UpdateZoneLEDs(int /*zone*/)
-{
-    controller->SetLED(colors);
-}
-
-void RGBController_CorsairHydro2::UpdateSingleLED(int /*led*/)
-{
-    controller->SetLED(colors);
-}
-
-void RGBController_CorsairHydro2::DeviceUpdateMode()
-{
-
-}

Controllers/CorsairHydro2Controller/RGBController_CorsairHydro2.h

@@ -1,31 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_CorsairHydro2.h            |
-|                                           |
-|  RGB Controller for Corsair H100i v2      |
-|                                           |
-|  Tim Demand (tim.dmd) 1/10/2023           |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "CorsairHydro2Controller.h"
-
-class RGBController_CorsairHydro2 : public RGBController
-{
-public:
-    RGBController_CorsairHydro2(CorsairHydro2Controller* controller_ptr);
-    ~RGBController_CorsairHydro2();
-
-    void SetupZones();
-
-    void ResizeZone(int zone, int new_size);
-
-    void DeviceUpdateLEDs();
-    void UpdateZoneLEDs(int zone);
-    void UpdateSingleLED(int led);
-
-    void DeviceUpdateMode();
-
-private:
-    CorsairHydro2Controller* controller;
-};

Controllers/CorsairHydroController/CorsairHydroControllerDetect.cpp

@@ -49,7 +49,7 @@ static const corsair_hydro_device device_list[] =
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectCorsairHydroControllers()
+void DetectCorsairHydroControllers(std::vector<RGBController*>& rgb_controllers)
 {
     libusb_init(NULL);
 
@@ -69,9 +69,10 @@ void DetectCorsairHydroControllers()
 
             CorsairHydroController*     controller     = new CorsairHydroController(dev);
             RGBController_CorsairHydro* rgb_controller = new RGBController_CorsairHydro(controller);
-            rgb_controller->name                       = device_list[device_idx].name;
 
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
+            rgb_controller->name = device_list[device_idx].name;
+
+            rgb_controllers.push_back(rgb_controller);
         }
     }
 }   /* DetectCorsairHydroControllers() */

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -50,11 +50,6 @@
 #define CORSAIR_STRAFE_RED_PID          0x1B44
 #define CORSAIR_STRAFE_MK2_PID          0x1B48
 
-/*-----------------------------------------------------*\
-| Non-RGB Keyboard product IDs                          |
-\*-----------------------------------------------------*/
-#define CORSAIR_K70_LUX_PID             0x1B36
-
 /*-----------------------------------------------------*\
 | Mouse product IDs                                     |
 |   List taken from ckb-next                            |
@@ -89,8 +84,7 @@
 | Corsair K100 Keyboard product ID                      |
 | This keyboard uses a separate driver                  |
 \*-----------------------------------------------------*/
-#define CORSAIR_K100_OPTICAL_PID                0x1B7C
-#define CORSAIR_K100_MXRED_PID                  0x1B7D
+#define CORSAIR_K100_PID                0x1B7C
 
 /*-----------------------------------------------------*\
 | Corsair K55 RGB PRO XT Keyboard product ID            |
@@ -208,75 +202,73 @@ void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string
 /*-----------------------------------------------------------------------------------------------------*\
 | Keyboards                                                                                             |
 \*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID,            1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K65 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_PID,            1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K65 LUX RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_LUX_RGB_PID,        1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K65 RGB RAPIDFIRE",       DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_RAPIDFIRE_PID,  1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K68 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K68_RGB,                1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_PID,            1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 LUX",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_LUX_PID,            1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 LUX RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_LUX_RGB_PID,        1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB RAPIDFIRE",       DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_RAPIDFIRE_PID,  1, 0xFFC2);
-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 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 Strafe",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_PID,             1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Strafe Red",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_RED_PID,         1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Strafe MK.2",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_MK2_PID,         1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID,           1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K65 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_PID,           1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K65 LUX RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_LUX_RGB_PID,       1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K65 RGB RAPIDFIRE",       DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_RAPIDFIRE_PID, 1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K68 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K68_RGB,               1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_PID,           1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 LUX RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_LUX_RGB_PID,       1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB RAPIDFIRE",       DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_RAPIDFIRE_PID, 1, 0xFFC2);
+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 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 Strafe",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_PID,            1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Strafe Red",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_RED_PID,        1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Strafe MK.2",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_MK2_PID,        1, 0xFFC2);
 /*-----------------------------------------------------------------------------------------------------*\
 | Mice                                                                                                  |
 \*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PID,         1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB PRO",          DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PRO_PID,     1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PID,        1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB PRO",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PRO_PID,    1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Ironclaw RGB",            DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_IRONCLAW_RGB_PID,       1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair M65",                     DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_PID,                1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair M65 PRO",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_PRO_PID,            1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair M65 RGB Elite",           DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_RGB_ELITE_PID,      1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Nightsword",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_NIGHTSWORD_PID,         1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Scimitar RGB",            DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_RGB_PID,       1, 0xFFC2);
-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 Glaive RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PID,        1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB PRO",          DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PRO_PID,    1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PID,       1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB PRO",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PRO_PID,   1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Ironclaw RGB",            DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_IRONCLAW_RGB_PID,      1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair M65",                     DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_PID,               1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair M65 PRO",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_PRO_PID,           1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair M65 RGB Elite",           DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_RGB_ELITE_PID,     1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Nightsword",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_NIGHTSWORD_PID,        1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Scimitar RGB",            DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_RGB_PID,      1, 0xFFC2);
+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);
 
 /*-----------------------------------------------------------------------------------------------------*\
 | Mousemats                                                                                             |
 \*-----------------------------------------------------------------------------------------------------*/
 #ifdef USE_HID_USAGE
-REGISTER_HID_DETECTOR_P("Corsair MM800 RGB Polaris",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_MM800_RGB_POLARIS_PID,  0xFFC2);
+REGISTER_HID_DETECTOR_P("Corsair MM800 RGB Polaris",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_MM800_RGB_POLARIS_PID, 0xFFC2);
 #else
-REGISTER_HID_DETECTOR_I("Corsair MM800 RGB Polaris",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_MM800_RGB_POLARIS_PID,  0);
+REGISTER_HID_DETECTOR_I("Corsair MM800 RGB Polaris",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_MM800_RGB_POLARIS_PID, 0);
 #endif
 /*-----------------------------------------------------------------------------------------------------*\
 | Headset Stands                                                                                        |
 \*-----------------------------------------------------------------------------------------------------*/
 #ifdef USE_HID_USAGE
-REGISTER_HID_DETECTOR_P("Corsair ST100 RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID,              0xFFC2);
+REGISTER_HID_DETECTOR_P("Corsair ST100 RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID,             0xFFC2);
 #else
-REGISTER_HID_DETECTOR_I("Corsair ST100 RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID,              0);
+REGISTER_HID_DETECTOR_I("Corsair ST100 RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID,             0);
 #endif
 
 /*-----------------------------------------------------------------------------------------------------*\
 | Corsair K100 Keyboard                                                                                 |
 \*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair K100",                    DetectCorsairK100Controllers,       CORSAIR_VID, CORSAIR_K100_OPTICAL_PID,       1, 0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair K100",                    DetectCorsairK100Controllers,       CORSAIR_VID, CORSAIR_K100_MXRED_PID,         1, 0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K100",                    DetectCorsairK100Controllers,       CORSAIR_VID, CORSAIR_K100_PID,              1, 0xFF42);
 
 /*-----------------------------------------------------------------------------------------------------*\
 | Corsair K65 Mini Keyboard                                                                             |
 \*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_I("Corsair K65 Mini",                 DetectCorsairK65MiniControllers,    CORSAIR_VID, CORSAIR_K65_MINI_PID,           1);
+REGISTER_HID_DETECTOR_I("Corsair K65 Mini",                 DetectCorsairK65MiniControllers,    CORSAIR_VID, CORSAIR_K65_MINI_PID,         1);
 
 /*-----------------------------------------------------------------------------------------------------*\
 | Corsair K55 RGB PRO XT Keyboard                                                                       |
 \*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO XT",          DetectCorsairK55RGBPROXTControllers, CORSAIR_VID, CORSAIR_K55_RGB_PRO_XT_PID,    1, 0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO XT",          DetectCorsairK55RGBPROXTControllers, CORSAIR_VID, CORSAIR_K55_RGB_PRO_XT_PID,   1, 0xFF42);
 
 
 /*-----------------------------------------------------------------------------------------------------*\
 | Corsair K95 Platinum XT Keyboard                                                                      |
 \*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair K95 RGB PLATINUM XT",     DetectCorsairK95PlatinumXTControllers, CORSAIR_VID, CORSAIR_K95_PLATINUM_XT_PID, 1, 0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K95 RGB PLATINUM XT",     DetectCorsairK95PlatinumXTControllers, CORSAIR_VID, CORSAIR_K95_PLATINUM_XT_PID,   1, 0xFF42);

Controllers/CorsairPeripheralController/RGBController_CorsairK55RGBPROXT.cpp

@@ -356,7 +356,7 @@ RGBController_CorsairK55RGBPROXT::~RGBController_CorsairK55RGBPROXT()
     keepalive_thread_run = false;
     keepalive_thread->join();
     delete keepalive_thread;
-    delete[] zones[0].matrix_map;
+    delete[] zones[0].matrix_map->map;
 
     delete controller;
 }

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.cpp

@@ -202,7 +202,7 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
     /*---------------------------------------------------------*\
     | Check if the data needs more than 1 packet                |
     \*---------------------------------------------------------*/
-    uint16_t copy_bytes     = CORSAIR_V2_WRITE_SIZE - offset1;
+    uint8_t copy_bytes      = CORSAIR_V2_WRITE_SIZE - offset1;
     if(remaining < copy_bytes)
     {
         copy_bytes          = remaining;
@@ -221,7 +221,7 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
     \*---------------------------------------------------------*/
     while(remaining)
     {
-        uint16_t index      = data_size - remaining;
+        uint8_t index       = data_size - remaining;
         if(remaining < copy_bytes)
         {
             memset(&buffer[offset2], 0, copy_bytes);

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.h

@@ -79,7 +79,7 @@ public:
     void                            UpdateHWMode(uint16_t mode, corsair_v2_color color_mode, uint8_t speed,
                                                  uint8_t direction, uint8_t brightness, std::vector<RGBColor> colors);
 
-    virtual void                    SetLedsDirect(std::vector<RGBColor *> colors)                   = 0;
+    virtual void                    SetLedsDirect(std::vector<RGBColor> colors)                     = 0;
 private:
     void                            GetAddress(uint8_t address);
     void                            StartTransaction(uint8_t opt1);

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2ControllerDetect.cpp

@@ -37,8 +37,6 @@ void DetectCorsairV2SoftwareControllers(hid_device_info* info, const std::string
 | Keyboards                                                                                             |
 \*-----------------------------------------------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO",             DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_K55_RGB_PRO_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 Low Profile", DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_K60_RGB_PRO_LP_PID,    1, 0xFF42);
 
 /*-----------------------------------------------------------------------------------------------------*\
 | Mousemat                                                                                              |

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.cpp

@@ -1,127 +1,5 @@
 #include "CorsairPeripheralV2Devices.h"
 
-/*-------------------------------------------------------------------------*\
-|  KEYMAPS                                                                  |
-\*-------------------------------------------------------------------------*/
-#define K60_KEYMAP_SIZE (sizeof(K60_keymap) / sizeof(K60_keymap[0]))
-
-static const corsair_v2_led K60_keymap[] =
-{
-    /*---------------------------------------------------------------------*\
-    |   Zone,   Row,    Column,     Index,      Name                        |
-    \*---------------------------------------------------------------------*/
-    {   0,      0,       0,          41,        KEY_EN_ESCAPE               },
-    {   0,      0,       2,          58,        KEY_EN_F1                   },
-    {   0,      0,       3,          59,        KEY_EN_F2                   },
-    {   0,      0,       4,          60,        KEY_EN_F3                   },
-    {   0,      0,       5,          61,        KEY_EN_F4                   },
-    {   0,      0,       6,          62,        KEY_EN_F5                   },
-    {   0,      0,       7,          63,        KEY_EN_F6                   },
-    {   0,      0,       8,          64,        KEY_EN_F7                   },
-    {   0,      0,       9,          65,        KEY_EN_F8                   },
-    {   0,      0,      10,          66,        KEY_EN_F9                   },
-    {   0,      0,      11,          67,        KEY_EN_F10                  },
-    {   0,      0,      12,          68,        KEY_EN_F11                  },
-    {   0,      0,      13,          69,        KEY_EN_F12                  },
-    {   0,      0,      14,          70,        KEY_EN_PRINT_SCREEN         },
-    {   0,      0,      15,          71,        KEY_EN_SCROLL_LOCK          },
-    {   0,      0,      16,          72,        KEY_EN_PAUSE_BREAK          },
-    {   0,      1,       0,          53,        KEY_EN_BACK_TICK            },
-    {   0,      1,       1,          30,        KEY_EN_1                    },
-    {   0,      1,       2,          31,        KEY_EN_2                    },
-    {   0,      1,       3,          32,        KEY_EN_3                    },
-    {   0,      1,       4,          33,        KEY_EN_4                    },
-    {   0,      1,       5,          34,        KEY_EN_5                    },
-    {   0,      1,       6,          35,        KEY_EN_6                    },
-    {   0,      1,       7,          36,        KEY_EN_7                    },
-    {   0,      1,       8,          37,        KEY_EN_8                    },
-    {   0,      1,       9,          38,        KEY_EN_9                    },
-    {   0,      1,      10,          39,        KEY_EN_0                    },
-    {   0,      1,      11,          45,        KEY_EN_MINUS                },
-    {   0,      1,      12,          46,        KEY_EN_EQUALS               },
-    {   0,      1,      13,          42,        KEY_EN_BACKSPACE            },
-    {   0,      1,      14,          73,        KEY_EN_INSERT               },
-    {   0,      1,      15,          74,        KEY_EN_HOME                 },
-    {   0,      1,      16,          75,        KEY_EN_PAGE_UP              },
-    {   0,      1,      17,          83,        KEY_EN_NUMPAD_LOCK          },
-    {   0,      1,      18,          84,        KEY_EN_NUMPAD_DIVIDE        },
-    {   0,      1,      19,          85,        KEY_EN_NUMPAD_TIMES         },
-    {   0,      1,      20,          86,        KEY_EN_NUMPAD_MINUS         },
-    {   0,      2,       0,          43,        KEY_EN_TAB                  },
-    {   0,      2,       1,          20,        KEY_EN_Q                    },
-    {   0,      2,       2,          26,        KEY_EN_W                    },
-    {   0,      2,       3,           8,        KEY_EN_E                    },
-    {   0,      2,       4,          21,        KEY_EN_R                    },
-    {   0,      2,       5,          23,        KEY_EN_T                    },
-    {   0,      2,       6,          28,        KEY_EN_Y                    },
-    {   0,      2,       7,          24,        KEY_EN_U                    },
-    {   0,      2,       8,          12,        KEY_EN_I                    },
-    {   0,      2,       9,          18,        KEY_EN_O                    },
-    {   0,      2,      10,          19,        KEY_EN_P                    },
-    {   0,      2,      11,          47,        KEY_EN_LEFT_BRACKET         },
-    {   0,      2,      12,          48,        KEY_EN_RIGHT_BRACKET        },
-    {   0,      2,      13,          49,        KEY_EN_ANSI_BACK_SLASH      },
-    {   0,      2,      14,          76,        KEY_EN_DELETE               },
-    {   0,      2,      15,          77,        KEY_EN_END                  },
-    {   0,      2,      16,          78,        KEY_EN_PAGE_DOWN            },
-    {   0,      2,      17,          95,        KEY_EN_NUMPAD_7             },
-    {   0,      2,      18,          96,        KEY_EN_NUMPAD_8             },
-    {   0,      2,      19,          97,        KEY_EN_NUMPAD_9             },
-    {   0,      2,      20,          87,        KEY_EN_NUMPAD_PLUS          },
-    {   0,      3,       0,          57,        KEY_EN_CAPS_LOCK            },
-    {   0,      3,       1,           4,        KEY_EN_A                    },
-    {   0,      3,       2,          22,        KEY_EN_S                    },
-    {   0,      3,       3,           7,        KEY_EN_D                    },
-    {   0,      3,       4,           9,        KEY_EN_F                    },
-    {   0,      3,       5,          10,        KEY_EN_G                    },
-    {   0,      3,       6,          11,        KEY_EN_H                    },
-    {   0,      3,       7,          13,        KEY_EN_J                    },
-    {   0,      3,       8,          14,        KEY_EN_K                    },
-    {   0,      3,       9,          15,        KEY_EN_L                    },
-    {   0,      3,      10,          51,        KEY_EN_SEMICOLON            },
-    {   0,      3,      11,          52,        KEY_EN_QUOTE                },
-    {   0,      3,      12,          50,        KEY_EN_POUND                },
-    {   0,      3,      13,          40,        KEY_EN_ANSI_ENTER           },
-    {   0,      3,      17,          92,        KEY_EN_NUMPAD_4             },
-    {   0,      3,      18,          93,        KEY_EN_NUMPAD_5             },
-    {   0,      3,      19,          94,        KEY_EN_NUMPAD_6             },
-    {   0,      4,       0,         106,        KEY_EN_LEFT_SHIFT           },
-    {   0,      4,       1,         100,        KEY_EN_ISO_BACK_SLASH       },
-    {   0,      4,       2,          29,        KEY_EN_Z                    },
-    {   0,      4,       3,          27,        KEY_EN_X                    },
-    {   0,      4,       4,           6,        KEY_EN_C                    },
-    {   0,      4,       5,          25,        KEY_EN_V                    },
-    {   0,      4,       6,           5,        KEY_EN_B                    },
-    {   0,      4,       7,          17,        KEY_EN_N                    },
-    {   0,      4,       8,          16,        KEY_EN_M                    },
-    {   0,      4,       9,          54,        KEY_EN_COMMA                },
-    {   0,      4,      10,          55,        KEY_EN_PERIOD               },
-    {   0,      4,      11,          56,        KEY_EN_FORWARD_SLASH        },
-    {   0,      4,      13,         110,        KEY_EN_RIGHT_SHIFT          },
-    {   0,      4,      15,          82,        KEY_EN_UP_ARROW             },
-    {   0,      4,      17,          89,        KEY_EN_NUMPAD_1             },
-    {   0,      4,      18,          90,        KEY_EN_NUMPAD_2             },
-    {   0,      4,      19,          91,        KEY_EN_NUMPAD_3             },
-    {   0,      4,      20,          88,        KEY_EN_NUMPAD_ENTER         },
-    {   0,      5,       0,         105,        KEY_EN_LEFT_CONTROL         },
-    {   0,      5,       1,         108,        KEY_EN_LEFT_WINDOWS         },
-    {   0,      5,       2,         107,        KEY_EN_LEFT_ALT             },
-    {   0,      5,       6,          44,        KEY_EN_SPACE                },
-    {   0,      5,      10,         111,        KEY_EN_RIGHT_ALT            },
-    {   0,      5,      11,         122,        KEY_EN_RIGHT_FUNCTION       },
-    {   0,      5,      12,         101,        KEY_EN_MENU                 },
-    {   0,      5,      13,         109,        KEY_EN_RIGHT_CONTROL        },
-    {   0,      5,      14,          80,        KEY_EN_LEFT_ARROW           },
-    {   0,      5,      15,          81,        KEY_EN_DOWN_ARROW           },
-    {   0,      5,      16,          79,        KEY_EN_RIGHT_ARROW          },
-    {   0,      5,      18,          98,        KEY_EN_NUMPAD_0             },
-    {   0,      5,      19,          99,        KEY_EN_NUMPAD_PERIOD        },
-};
-
-/*-------------------------------------------------------------------------*\
-|  CORSAIR DEVICES                                                          |
-\*-------------------------------------------------------------------------*/
-
 /*-------------------------------------------------------------*\
 |  Corsair K55 RGB Pro 1B1C:1BA4                                |
 |                                                               |
@@ -150,83 +28,12 @@ static const corsair_v2_device k55_rgb_pro_device =
         nullptr,
         nullptr,
         nullptr,
-        nullptr,
         nullptr
     },
     nullptr,
     0
 };
 
-/*-------------------------------------------------------------*\
-|  Corsair K60 RGB Pro 1B1C:1BA0                                |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       6 Rows, 21 Columns                                      |
-\*-------------------------------------------------------------*/
-static const corsair_v2_zone k60_rgb_pro_zone =
-{
-    ZONE_EN_KEYBOARD,
-    ZONE_TYPE_MATRIX,
-    6,
-    21
-};
-
-static const corsair_v2_device k60_rgb_pro_device =
-{
-    CORSAIR_K60_RGB_PRO_PID,
-    false,
-    DEVICE_TYPE_KEYBOARD,
-    CORSAIR_V2_MODE_SW,
-    6,
-    21,
-    {
-        &k60_rgb_pro_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    },
-    K60_keymap,
-    K60_KEYMAP_SIZE
-};
-
-/*-------------------------------------------------------------*\
-|  Corsair K60 RGB Pro Low Profile 1B1C:1BAD                    |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       6 Rows, 21 Columns                                      |
-\*-------------------------------------------------------------*/
-static const corsair_v2_zone k60_rgb_pro_lp_zone =
-{
-    ZONE_EN_KEYBOARD,
-    ZONE_TYPE_MATRIX,
-    6,
-    21
-};
-
-static const corsair_v2_device k60_rgb_pro_lp_device =
-{
-    CORSAIR_K60_RGB_PRO_LP_PID,
-    false,
-    DEVICE_TYPE_KEYBOARD,
-    CORSAIR_V2_MODE_SW,
-    6,
-    21,
-    {
-        &k60_rgb_pro_lp_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    },
-    K60_keymap,
-    K60_KEYMAP_SIZE
-};
-
 /*-------------------------------------------------------------*\
 |  Corsair MM700 1B1C:1B9B                                      |
 |                                                               |
@@ -274,7 +81,6 @@ static const corsair_v2_device mm700_device =
         &mm700_right_zone,
         &mm700_logo_zone,
         nullptr,
-        nullptr,
         nullptr
     },
     nullptr,
@@ -290,8 +96,6 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
     &k55_rgb_pro_device,
-    &k60_rgb_pro_device,
-    &k60_rgb_pro_lp_device,
 
 /*-----------------------------------------------------------------*\
 |  MOUSEMATS                                                        |
@@ -300,4 +104,4 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
 };
 
 const unsigned int CORSAIR_V2_DEVICE_COUNT = (sizeof(corsair_v2_device_list_data) / sizeof(corsair_v2_device_list_data[ 0 ]));
-const corsair_v2_device** corsair_v2_device_list = corsair_v2_device_list_data;
+const corsair_v2_device** corsair_v2_device_list = corsair_v2_device_list_data;

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.h

@@ -4,7 +4,7 @@
 #include "RGBController.h"
 #include "RGBControllerKeyNames.h"
 
-#define CORSAIR_ZONES_MAX   6
+#define CORSAIR_ZONES_MAX   5
 
 enum corsair_v2_device_mode
 {
@@ -25,7 +25,6 @@ typedef struct
     uint8_t                 zone;
     uint8_t                 row;
     uint8_t                 col;
-    uint8_t                 index;
     const char*             name;
 }   corsair_v2_led;
 
@@ -46,8 +45,6 @@ typedef struct
 | Corsair V2 Protocol Keyboards                         |
 \*-----------------------------------------------------*/
 #define CORSAIR_K55_RGB_PRO_PID                     0x1BA4
-#define CORSAIR_K60_RGB_PRO_PID                     0x1BA0
-#define CORSAIR_K60_RGB_PRO_LP_PID                  0x1BAD
 
 /*-----------------------------------------------------*\
 | Corsair V2 Protocol Mousemats                         |

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2SoftwareController.cpp

@@ -21,7 +21,7 @@ CorsairPeripheralV2SWController::~CorsairPeripheralV2SWController()
 
 }
 
-void CorsairPeripheralV2SWController::SetLedsDirect(std::vector<RGBColor *>colors)
+void CorsairPeripheralV2SWController::SetLedsDirect(std::vector<RGBColor>colors)
 {
     uint16_t count          = colors.size();
     uint16_t green          = count;
@@ -33,7 +33,7 @@ void CorsairPeripheralV2SWController::SetLedsDirect(std::vector<RGBColor *>color
 
     for(std::size_t i = 0; i < count; i++)
     {
-        RGBColor color      = *colors[i];
+        RGBColor color = colors[i];
 
         buffer[i]           = RGBGetRValue(color);
         buffer[green + i]   = RGBGetGValue(color);

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2SoftwareController.h

@@ -20,7 +20,7 @@ public:
     CorsairPeripheralV2SWController(hid_device* dev_handle, const char* path, std::string name, uint16_t pid);
     ~CorsairPeripheralV2SWController();
 
-    void    SetLedsDirect(std::vector<RGBColor *> colors);
+    void                    SetLedsDirect(std::vector<RGBColor> colors);
 
 private:
 

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Software.cpp

@@ -97,7 +97,6 @@ RGBController_CorsairV2SW::~RGBController_CorsairV2SW()
 
 void RGBController_CorsairV2SW::SetupZones()
 {
-    unsigned int max_led_value              = 0;
     const corsair_v2_device* corsair        = controller->GetDeviceData();
 
     /*---------------------------------------------------------*\
@@ -115,10 +114,10 @@ void RGBController_CorsairV2SW::SetupZones()
 
             new_zone.name                   = corsair->zones[i]->name;
             new_zone.type                   = corsair->zones[i]->type;
+            new_zone.leds_count             = corsair->zones[i]->rows * corsair->zones[i]->cols;
 
             if(new_zone.type == ZONE_TYPE_MATRIX)
             {
-                new_zone.leds_count         = corsair->layout_size;
                 matrix_map_type * new_map   = new matrix_map_type;
                 new_zone.matrix_map         = new_map;
 
@@ -127,44 +126,58 @@ void RGBController_CorsairV2SW::SetupZones()
 
                 new_map->map = new unsigned int[new_map->height * new_map->width];
 
-                /*---------------------------------------------------------*\
-                | Create an empty matrix                                    |
-                \*---------------------------------------------------------*/
                 for(unsigned int y = 0; y < new_map->height; y++)
                 {
                     for(unsigned int x = 0; x < new_map->width; x++)
                     {
-                        new_map->map[(y * new_map->width) + x] = NA;
+                        new_map->map[(y * new_map->width) + x] = (y * new_map->width) + x;
                     }
                 }
 
                 /*---------------------------------------------------------*\
                 | Create LEDs for the Matrix zone                           |
-                |   Place keys in the layout to populate the matrix         |
                 \*---------------------------------------------------------*/
+                uint8_t blanks              = 0;
                 for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
                 {
-                    led new_led;
+                    led  new_led;
+                    bool not_found = true;
 
-                    new_led.name                = corsair->layout[led_idx].name;
-                    new_led.value               = corsair->layout[led_idx].index;
-                    max_led_value               = std::max(max_led_value, new_led.value);
-                    leds.push_back(new_led);
+                    for(size_t layout_index = 0; layout_index < corsair->layout_size; layout_index++)
+                    {
+                        uint8_t row         = layout_index / new_map->width;
+                        uint8_t col         = layout_index % new_map->width;
 
-                    uint8_t layout_index        = (corsair->layout[led_idx].row * new_map->width)
-                                                +  corsair->layout[led_idx].col;
-                    new_map->map[layout_index]  = led_idx;
+                        if(  i == corsair->layout[layout_index].zone    &&
+                           row == corsair->layout[layout_index].row     &&
+                           col == corsair->layout[layout_index].col     )
+                        {
+                            new_led.name    = corsair->layout[layout_index].name;
+                            not_found       = false;
+                            break;
+                        }
+                    }
+
+                    /*-----------------------------------------------------------------*\
+                    | If this is the "Keyboard" zone and key was not found in the map   |
+                    |   then change the value of the key to hide it from view           |
+                    \*-----------------------------------------------------------------*/
+                    if(not_found && new_zone.name == ZONE_EN_KEYBOARD)
+                    {
+                        new_zone.matrix_map->map[led_idx] = NA;
+                        blanks++;
+                    }
+                    else
+                    {
+                        leds.push_back(new_led);
+                    }
                 }
 
-                /*---------------------------------------------------------*\
-                | Add 1 the max_led_value to account for the 0th index      |
-                \*---------------------------------------------------------*/
-                max_led_value++;
+                new_zone.leds_count        -= blanks;
             }
             else
             {
-                new_zone.leds_count             = corsair->zones[i]->rows * corsair->zones[i]->cols;
-                new_zone.matrix_map             = NULL;
+                new_zone.matrix_map         = NULL;
 
                 /*---------------------------------------------------------*\
                 | Create LEDs for the Linear / Single zone                  |
@@ -173,40 +186,24 @@ void RGBController_CorsairV2SW::SetupZones()
                 {
                     led new_led;
 
-                    new_led.name                = new_zone.name + " ";
+                    new_led.name            = new_zone.name + " ";
                     new_led.name.append(std::to_string( led_idx ));
-                    new_led.value               = leds.size();
+                    new_led.value           = leds.size();
 
                     leds.push_back(new_led);
                 }
-
-                max_led_value                   = std::max(max_led_value, (unsigned int)leds.size());
             }
 
             LOG_DEBUG("[%s] Creating a %s zone: %s with %d LEDs", name.c_str(),
                       ((new_zone.type == ZONE_TYPE_MATRIX) ? "matrix": "linear"),
                       new_zone.name.c_str(), new_zone.leds_count);
-            new_zone.leds_min                   = new_zone.leds_count;
-            new_zone.leds_max                   = new_zone.leds_count;
+            new_zone.leds_min               = new_zone.leds_count;
+            new_zone.leds_max               = new_zone.leds_count;
             zones.push_back(new_zone);
         }
     }
 
     SetupColors();
-
-    /*---------------------------------------------------------*\
-    | Create a buffer map of pointers which contains the        |
-    |   layout order of colors the device expects.              |
-    \*---------------------------------------------------------*/
-    for(size_t led_idx = 0; led_idx < max_led_value; led_idx++)
-    {
-        buffer_map.push_back(&null_color);
-    }
-
-    for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
-    {
-        buffer_map[leds[led_idx].value] = &colors[led_idx];
-    }
 }
 
 void RGBController_CorsairV2SW::ResizeZone(int /*zone*/, int /*new_size*/)
@@ -220,17 +217,17 @@ void RGBController_CorsairV2SW::DeviceUpdateLEDs()
 {
     last_update_time = std::chrono::steady_clock::now();
 
-    controller->SetLedsDirect(buffer_map);
+    controller->SetLedsDirect(colors);
 }
 
 void RGBController_CorsairV2SW::UpdateZoneLEDs(int /*zone*/)
 {
-    controller->SetLedsDirect(buffer_map);
+    controller->SetLedsDirect(colors);
 }
 
 void RGBController_CorsairV2SW::UpdateSingleLED(int /*led*/)
 {
-    controller->SetLedsDirect(buffer_map);
+    controller->SetLedsDirect(colors);
 }
 
 void RGBController_CorsairV2SW::DeviceUpdateMode()

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Software.h

@@ -31,9 +31,6 @@ public:
 private:
     CorsairPeripheralV2Controller*          controller;
 
-    RGBColor                                null_color              = 0;
-    std::vector<RGBColor *>                 buffer_map;
-
     std::thread*                            keepalive_thread;
     std::atomic<bool>                       keepalive_thread_run;
     std::chrono::time_point

Controllers/CorsairVengeanceController/CorsairVengeanceControllerDetect.cpp

@@ -65,16 +65,6 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
                     CorsairVengeanceController*     new_controller    = new CorsairVengeanceController(busses[bus], addr);
                     RGBController_CorsairVengeance* new_rgbcontroller = new RGBController_CorsairVengeance(new_controller);
                     
-                    ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
-                }
-            }
-            for(unsigned char addr = 0x18; addr <= 0x1F; addr++)
-            {
-                if(TestForCorsairVengeanceController(busses[bus], addr))
-                {
-                    CorsairVengeanceController*     new_controller    = new CorsairVengeanceController(busses[bus], addr);
-                    RGBController_CorsairVengeance* new_rgbcontroller = new RGBController_CorsairVengeance(new_controller);
-                    
                     ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
                 }
             }

Controllers/DasKeyboardController/DasKeyboardControllerDetect.cpp

@@ -14,7 +14,6 @@
 \*-----------------------------------------------------*/
 #define DAS_KEYBOARD_Q4_PID             0x2037
 #define DAS_KEYBOARD_Q5_PID             0x2020
-#define DAS_KEYBOARD_Q5S_PID            0x209A
 
 /******************************************************************************************\
 *                                                                                          *
@@ -33,8 +32,7 @@ void DetectDasKeyboardControllers(hid_device_info *info_in, const std::string &n
     {
         if(info->vendor_id        == DAS_KEYBOARD_VID     &&
           (info->product_id       == DAS_KEYBOARD_Q4_PID  ||
-           info->product_id       == DAS_KEYBOARD_Q5_PID  ||
-           info->product_id       == DAS_KEYBOARD_Q5S_PID) &&
+           info->product_id       == DAS_KEYBOARD_Q5_PID) &&
            info->interface_number == 1)
         {
             break;
@@ -91,6 +89,5 @@ void DetectDas4QKeyboard(hid_device_info *info, const std::string &name)
     }
 }   /* DetectDas4QKeyboard() */
 
-REGISTER_HID_DETECTOR_IPU("Das Keyboard Q4 RGB",  DetectDas4QKeyboard,          DAS_KEYBOARD_VID, DAS_KEYBOARD_Q4_PID,  1,    0x01,   0x80);
-REGISTER_HID_DETECTOR_I  ("Das Keyboard Q5 RGB",  DetectDasKeyboardControllers, DAS_KEYBOARD_VID, DAS_KEYBOARD_Q5_PID,  1);
-REGISTER_HID_DETECTOR_I  ("Das Keyboard Q5S RGB", DetectDasKeyboardControllers, DAS_KEYBOARD_VID, DAS_KEYBOARD_Q5S_PID, 1);
+REGISTER_HID_DETECTOR_IPU("Das Keyboard Q4 RGB", DetectDas4QKeyboard,           DAS_KEYBOARD_VID, DAS_KEYBOARD_Q4_PID, 1,    0x01,   0x80);
+REGISTER_HID_DETECTOR_I  ("Das Keyboard Q5 RGB", DetectDasKeyboardControllers,  DAS_KEYBOARD_VID, DAS_KEYBOARD_Q5_PID, 1);

Controllers/DebugController/DebugControllerDetect.cpp

@@ -201,7 +201,7 @@ static const char *led_names[] =
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectDebugControllers()
+void DetectDebugControllers(std::vector<RGBController*> &rgb_controllers)
 {
     json            debug_settings;
 
@@ -298,7 +298,7 @@ void DetectDebugControllers()
                 /*---------------------------------------------------------*\
                 | Push the dummy motherboard onto the controller list       |
                 \*---------------------------------------------------------*/
-                ResourceManager::get()->RegisterRGBController(dummy_motherboard);
+                rgb_controllers.push_back(dummy_motherboard);
             }
             else if(type == "dram")
             {
@@ -374,7 +374,7 @@ void DetectDebugControllers()
                 /*---------------------------------------------------------*\
                 | Push the dummy DRAM onto the controller list              |
                 \*---------------------------------------------------------*/
-                ResourceManager::get()->RegisterRGBController(dummy_dram);
+                rgb_controllers.push_back(dummy_dram);
             }
             else if(type == "gpu")
             {
@@ -450,7 +450,7 @@ void DetectDebugControllers()
                 /*---------------------------------------------------------*\
                 | Push the dummy GPU onto the controller list               |
                 \*---------------------------------------------------------*/
-                ResourceManager::get()->RegisterRGBController(dummy_gpu);
+                rgb_controllers.push_back(dummy_gpu);
             }
             else if(type == "keyboard")
             {
@@ -538,7 +538,7 @@ void DetectDebugControllers()
                 /*---------------------------------------------------------*\
                 | Push the dummy Keyboard onto the controller list          |
                 \*---------------------------------------------------------*/
-                ResourceManager::get()->RegisterRGBController(dummy_keyboard);
+                rgb_controllers.push_back(dummy_keyboard);
             }
             else if(type == "argb")
             {
@@ -586,7 +586,7 @@ void DetectDebugControllers()
                 /*---------------------------------------------------------*\
                 | Push the dummy ARGB onto the controller list              |
                 \*---------------------------------------------------------*/
-                ResourceManager::get()->RegisterRGBController(dummy_argb);
+                rgb_controllers.push_back(dummy_argb);
             }
         }
     }
@@ -800,7 +800,7 @@ void DetectDebugControllers()
 
             dummy_custom->SetupColors();
 
-            ResourceManager::get()->RegisterRGBController(dummy_custom);
+            rgb_controllers.push_back(dummy_custom);
         }
     }
 

Controllers/DygmaRaiseController/DygmaRaiseControllerDetect.cpp

@@ -19,7 +19,7 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectDygmaRaiseControllers()
+void DetectDygmaRaiseControllers(std::vector<RGBController*> &rgb_controllers)
 {
     std::vector<std::string *> ports = find_usb_serial_port(DYGMA_RAISE_VID, DYGMA_RAISE_PID);
 
@@ -31,7 +31,7 @@ void DetectDygmaRaiseControllers()
             controller->Initialize((char *)ports[i]->c_str());
 
             RGBController_DygmaRaise* rgb_controller = new RGBController_DygmaRaise(controller);
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
+            rgb_controllers.push_back(rgb_controller);
         }
     }
 }

Controllers/E131Controller/E131ControllerDetect.cpp

@@ -20,7 +20,7 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectE131Controllers()
+void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers)
 {
     json                e131_settings;
 
@@ -176,12 +176,12 @@ void DetectE131Controllers()
             {
                 dev.matrix_height = e131_settings["devices"][device_idx]["matrix_height"];
             }
-
+            
             if(e131_settings["devices"][device_idx].contains("universe_size"))
             {
                 dev.universe_size = e131_settings["devices"][device_idx]["universe_size"];
             }
-
+            
             if(e131_settings["devices"][device_idx].contains("type"))
             {
                 if(e131_settings["devices"][device_idx]["type"].is_string())
@@ -275,7 +275,7 @@ void DetectE131Controllers()
         {
             RGBController_E131* rgb_controller;
             rgb_controller = new RGBController_E131(device_lists[list_idx]);
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
+            rgb_controllers.push_back(rgb_controller);
         }
     }
 

Controllers/ENESMBusController/ENESMBusController.cpp

@@ -132,17 +132,6 @@ ENESMBusController::ENESMBusController(ENESMBusInterface* interface, ene_dev_id
         // Read LED count from configuration table
         led_count = config_table[ENE_CONFIG_LED_COUNT_0107];
     }
-    // AUMA0-E6K5-1110 - Third generation GPU controller?
-    // found an ASUS ROG Strix 4080 OC, seems to be equal to AUMA0-E6K5-0107
-    else if (strcmp(device_name, "AUMA0-E6K5-1110") == 0)
-    {
-        direct_reg  = ENE_REG_COLORS_DIRECT_V2;
-        effect_reg  = ENE_REG_COLORS_EFFECT_V2;
-        channel_cfg = ENE_CONFIG_CHANNEL_V2;
-
-        // Read LED count from configuration table
-        led_count = config_table[ENE_CONFIG_LED_COUNT_1110];
-    }
     // Assume first generation controller if string does not match
     else
     {
@@ -224,20 +213,6 @@ const char * ENESMBusController::GetChannelName(unsigned int led)
         return(ene_channels[9]);
         break;
 
-    /*---------------------------------------------*\
-    | If the config table entry is zero, this LED   |
-    | is part of the previous zone.  Search         |
-    | backwards until finding a non-zero entry.     |
-    \*---------------------------------------------*/
-    case 0:
-        for(int id = led; led >= 0; id--)
-        {
-            if(config_table[channel_cfg + id] != 0)
-            {
-                return(GetChannelName(id));
-            }
-        }
-
     default:
         return(ene_channels[10]);
         break;

Controllers/ENESMBusController/ENESMBusController.h

@@ -90,7 +90,6 @@ enum
 {
     ENE_CONFIG_LED_COUNT                = 0x02,     /* LED Count configuration offset       */
     ENE_CONFIG_LED_COUNT_0107           = 0x03,     /* LED Count configuration offset       */
-    ENE_CONFIG_LED_COUNT_1110           = 0x03,     /* LED Count configuration offset       */
     ENE_CONFIG_CHANNEL_V1               = 0x13,     /* LED Channel configuration offset     */
     ENE_CONFIG_CHANNEL_V2               = 0x1B,     /* LED Channel V2 configuration offset  */
 };

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -332,80 +332,47 @@ void DetectENESMBusGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
 REGISTER_I2C_DETECTOR("ENE SMBus DRAM",                 DetectENESMBusDRAMControllers);
 REGISTER_I2C_DETECTOR("ASUS Aura SMBus Motherboard",    DetectENESMBusMotherboardControllers);
 
-/*-----------------------------------------*\
-|  NVidia GPUs                              |
-\*-----------------------------------------*/
-
-REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060 OC O12G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_KO_RTX_3060_OC_O12G_GAMING,            0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF 3060 O12G GAMING",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_O12G_GAMING,              0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF 3060 O12G V2 GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_GA104_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_O12G_V2_GAMING,           0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF 3060 O12G V2 GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_O12G_LHR_GAMING,          0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060 12G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060_12G_GAMING,         0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060 O12G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060_O12G_GAMING,        0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060 O12G V2 GAMING",         DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060_O12G_LHR_GAMING,    0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060 O12G V2 GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,   ASUS_KO_RTX_3060_O12G_V2_GAMING,            0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060Ti O8G V2 GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_KO_RTX3060TI_O8G_V2_GAMING,            0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060Ti O8G GAMING",              DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_KO_RTX3060TI_O8G_GAMING,               0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060Ti O8G OC",                 DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060Ti O8G OC",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_3060_TI_O8G_OC,              0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060Ti O8G OC",                 DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC_V2,             0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060Ti O8G V2",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060TI_O8G_V2_GAMING,    0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 OC",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_OC,                 0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_GAMING,         0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G White",              DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_WHITE,          0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G V2 GAMING",          DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_V2_GAMING,      0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G V2 White",           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_V2_WHITE,       0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070 8G GAMING",                DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3070_8G_GAMING,                0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070 O8G GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3070_O8G_GAMING,               0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3070 O8G V2 GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_KO_RTX_3070_O8G_GAMING,                0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070 O8G V2 GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3070_O8G_V2_GAMING,            0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070Ti O8G GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070TI_O8G_GAMING,       0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070Ti O8G V2 GAMING",          DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3070TI_O8G_V2_GAMING,          0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070Ti O8G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3070TI_O8G_GAMING,             0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 10G GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_10G_GAMING_PD,            0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 10G GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_10G_GAMING,               0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RTX 3080 10G GUNDAM EDITION",       DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_10G_GUNDAM_EDITION,       0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O10G OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_O10G_OC,                  0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 10G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_10G_GAMING,         0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 O10G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O10G_GAMING,        0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 O10G WHITE",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O10G_WHITE,         0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 10G V2 GAMING",          DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_10G_V2_GAMING,      0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 O10G V2 GAMING",         DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O10G_V2_GAMING,     0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 O10G V2 WHITE",          DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O10G_V2_WHITE,      0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O10G V2 GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_O10G_V2_GAMING_8822,      0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O10G V2 GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_O10G_V2_GAMING,           0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O12G GAMING",              DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_12G_LHR_DEV, ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_O12G_GAMING,              0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 3080 12G",                DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_12G_LHR_DEV, ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_12G,                0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 3080 O12G",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080_12G_LHR_DEV, ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O12G_OC,            0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080Ti 12G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3080TI_12G_GAMING,             0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080Ti O12G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3080TI_O12G_GAMING,            0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080Ti O12G GAMING",          DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080TI_O12G_GAMING,      0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX LC 3080Ti O12G GAMING",       DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080TI_O12G_GAMING_LC,   0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3090 24G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3090_24G_GAMING,         0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3090 O24G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3090_O24G_GAMING,        0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3090 O24G GAMING White OC",   DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3090_O24G_GAMING_WHITE,  0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3090 O24G",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3090_O24G,                     0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3090 O24G OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3090_O24G_OC,                  0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3090Ti O24G OC GAMING",         DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3090TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3090TI_O24G_OC_GAMING,         0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4070 Ti 12G Gaming",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_4070TI_12G_GAMING,             0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4070 Ti O12G Gaming",           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_4070TI_O12G_GAMING,            0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 4080 O16G GAMING",        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4080_O16G_GAMING,        0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4090 O24G OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_4090_O24G_OC_GAMING,           0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4090 O24G",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_4090_O24G_GAMING,              0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 4090 O24G GAMING",        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4090_O24G_GAMING,        0x67);
-
-/*-----------------------------------------*\
-|  AMD GPUs                                 |
-\*-----------------------------------------*/
-
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RX 6700XT O12G GAMING",             DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI22_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_6700XT_O12G_GAMING,             0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 6700XT O12G GAMING",       DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI22_DEV,             ASUS_SUB_VEN,   ASUS_ROG_STRIX_RX_6700XT_O12G_GAMING,       0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 6750XT O12G GAMING",       DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI22_DEV,             ASUS_SUB_VEN,   ASUS_ROG_STRIX_RX_6750XT_O12G_GAMING,       0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 6800 TUF Gaming OC",                 DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_RX6800_TUF_GAMING_OC,                  0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 6800 O16G Gaming",         DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_ROG_STRIX_RX_6800_O16G_GAMING,         0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RX 6800XT O16G GAMING",             DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_TUF_RX_6800XT_O16G_GAMING,             0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX LC RX 6800XT O16G GAMING",    DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_ROG_STRIX_LC_RX6800XT_O16G_GAMING,     0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RX 6900XT O16G GAMING",             DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_TUF_RX_6900XT_O16G_GAMING,             0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RX 6900XT T16G GAMING",             DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV2,            ASUS_SUB_VEN,   ASUS_TUF_RX_6900XT_T16G_GAMING,             0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RX 6950XT O16G GAMING",             DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV3,            ASUS_SUB_VEN,   ASUS_TUF_RX_6950XT_016G_GAMING,             0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX LC RX 6950XT O16G GAMING",    DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV3,            ASUS_SUB_VEN,   ASUS_ROG_STRIX_LC_RX_6950XT_O16G_GAMING,    0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060 OC O12G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_KO_RTX_3060_OC_O12G_GAMING,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF 3060 O12G GAMING",                  DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_O12G_GAMING,              0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF 3060 O12G V2 GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_GA104_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_O12G_V2_GAMING,           0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF 3060 O12G V2 GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_O12G_LHR_GAMING,          0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060 O12G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060_O12G_GAMING,        0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060 O12G V2 GAMING",         DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060_O12G_LHR_GAMING,    0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060 O12G V2 GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,   ASUS_KO_RTX_3060_O12G_V2_GAMING,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060Ti O8G V2 GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_KO_RTX3060TI_O8G_V2_GAMING,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060Ti O8G OC",                 DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060Ti O8G OC",               DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_3060_TI_O8G_OC,              0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060Ti O8G OC",                 DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC_V2,             0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060Ti O8G V2",               DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060TI_O8G_V2_GAMING,    0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 OC",                     DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_OC,                 0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_GAMING,      0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G White",              DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_WHITE,          0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G V2 GAMING",          DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_V2_GAMING,      0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G V2 White",           DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_V2_WHITE,       0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070 O8G GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3070_O8G_GAMING,               0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3070 O8G V2 GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_KO_RTX_3070_O8G_GAMING,                0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070 O8G V2 GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3070_O8G_V2_GAMING,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070Ti O8G GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070TI_O8G_GAMING,       0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070Ti O8G V2 GAMING",          DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3070TI_O8G_V2_GAMING,          0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070Ti O8G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3070TI_O8G_GAMING,             0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 10G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_10G_GAMING,         0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 O10G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O10G_GAMING,        0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 O10G WHITE",             DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O10G_WHITE,         0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 O10G V2 WHITE",          DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O10G_V2_WHITE,      0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 10G GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_10G_GAMING_PD,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 10G GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_10G_GAMING,               0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O10G OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_O10G_OC,                  0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O10G V2 GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_O10G_V2_GAMING_8822,      0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O10G V2 GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_O10G_V2_GAMING,           0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O12G GAMING",              DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_12G_LHR_DEV, ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_O12G_GAMING,              0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 3080 O12G OC",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_12G_LHR_DEV, ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O12G_OC,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 3080 O10G V2 GAMING",     DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O10G_V2_GAMING,     0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080Ti 12G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3080TI_12G_GAMING,             0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080Ti O12G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3080TI_O12G_GAMING,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080Ti O12G GAMING",          DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080TI_O12G_GAMING,      0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX LC 3080Ti O12G GAMING",       DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080TI_O12G_GAMING_LC,   0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3090 24G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3090_24G_GAMING,         0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3090 O24G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3090_O24G_GAMING,        0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3090 O24G GAMING White OC",   DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3090_O24G_GAMING_WHITE,  0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3090 O24G",                     DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3090_O24G,                     0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3090 O24G OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3090_O24G_OC,                  0x67);

Controllers/ENESMBusController/RGBController_ENESMBus.cpp

@@ -373,17 +373,16 @@ void RGBController_ENESMBus::SetupZones()
     /*---------------------------------------------------------*\
     | Create LED entries for each zone                          |
     \*---------------------------------------------------------*/
-    std::size_t led_idx = 0;
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
-        for(std::size_t zone_led_idx = 0; zone_led_idx < zones[zone_idx].leds_count; zone_led_idx++)
+        for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
         {
             led* new_led = new led();
 
             new_led->name = zones[zone_idx].name + " LED ";
-            new_led->name.append(std::to_string(zone_led_idx + 1));
+            new_led->name.append(std::to_string(led_idx + 1));
 
-            new_led->value = led_map[led_idx++];
+            new_led->value = led_map[led_idx];
 
             leds.push_back(*new_led);
         }

Controllers/ENESMBusController/XPGSpectrixS40GDetect.cpp

@@ -20,7 +20,7 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectSpectrixS40GControllers()
+void DetectSpectrixS40GControllers(std::vector<RGBController*>& rgb_controllers)
 {
     /*---------------------------------------------------------------------*\
     | Search for /dev/nvmeX nodes with model matching "XPG SPECTRIX S40G"   |
@@ -56,7 +56,7 @@ void DetectSpectrixS40GControllers()
         {
             LOG_DEBUG("[XPG Spectrix S40G] Probing %d, model: %s", nvme_idx, nvme_dev_buf);
         }
-
+        
         close(nvme_model_fd);
 
         /*-------------------------------------------------*\
@@ -70,15 +70,15 @@ void DetectSpectrixS40GControllers()
 
             if(nvme_fd > 0)
             {
-                ENESMBusInterface_SpectrixS40G* interface      = new ENESMBusInterface_SpectrixS40G(nvme_fd, nvme_dev_buf);
+                ENESMBusInterface_SpectrixS40G* interface = new ENESMBusInterface_SpectrixS40G(nvme_fd, nvme_dev_buf);
                 ENESMBusController*             controller     = new ENESMBusController(interface, 0x67);
                 RGBController_ENESMBus*         rgb_controller = new RGBController_ENESMBus(controller);
+                
+                rgb_controller->name   = "XPG Spectrix S40G";
+                rgb_controller->type   = DEVICE_TYPE_STORAGE;
+                rgb_controller->vendor = "XPG";
 
-                rgb_controller->name                           = "XPG Spectrix S40G";
-                rgb_controller->type                           = DEVICE_TYPE_STORAGE;
-                rgb_controller->vendor                         = "XPG";
-
-                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                rgb_controllers.push_back(rgb_controller);
             }
         }
 
@@ -86,4 +86,4 @@ void DetectSpectrixS40GControllers()
     }
 }   /* DetectSpectrixS40GControllers() */
 
-REGISTER_DETECTOR(    "XPG Spectrix S40G",              DetectSpectrixS40GControllers);
+REGISTER_DETECTOR(    "XPG Spectrix S40G",              DetectSpectrixS40GControllers);

Controllers/ENESMBusController/XPGSpectrixS40GDetect_Windows.cpp

@@ -92,13 +92,13 @@ HANDLE OpenDevice(wchar_t buff[MAX_PATH])
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectSpectrixS40GControllers()
+void DetectSpectrixS40GControllers(std::vector<RGBController*>& rgb_controllers)
 {
     /*-------------------------------------------------------------------------------------------------*\
     | https://docs.microsoft.com/en-us/windows-hardware/drivers/install/identifiers-for-scsi-devices    |
     \*-------------------------------------------------------------------------------------------------*/
     wchar_t dev_name[MAX_PATH];
-
+    
     if(Search(dev_name))
     {
         HANDLE nvme_fd = OpenDevice(dev_name);
@@ -108,12 +108,12 @@ void DetectSpectrixS40GControllers()
             ENESMBusInterface_SpectrixS40G* interface      = new ENESMBusInterface_SpectrixS40G(nvme_fd, dev_name);
             ENESMBusController*             controller     = new ENESMBusController(interface, 0x67);
             RGBController_ENESMBus*         rgb_controller = new RGBController_ENESMBus(controller);
+            
+            rgb_controller->name   = "XPG Spectrix S40G";
+            rgb_controller->type   = DEVICE_TYPE_STORAGE;
+            rgb_controller->vendor = "XPG";
 
-            rgb_controller->name                           = "XPG Spectrix S40G";
-            rgb_controller->type                           = DEVICE_TYPE_STORAGE;
-            rgb_controller->vendor                         = "XPG";
-
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
+            rgb_controllers.push_back(rgb_controller);
         }
     }
 }   /* DetectSpectrixS40GControllers() */

Controllers/EVGAAmpereGPUController/EVGAAmpereGPUControllerDetect.cpp

@@ -55,9 +55,7 @@ REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 FTW3 Ultra"
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 FTW3 Ultra LHR"                , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3070_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3070_FTW3_ULTRA_LHR_SUB_DEV,            0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070Ti XC3 Gaming"                  , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3070TI_XC3_GAMING_SUB_DEV,              0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070Ti XC3 Ultra"                   , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3070TI_XC3_ULTRA_SUB_DEV,               0x2D);
-REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070Ti XC3 Ultra v2"                , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3070TI_XC3_ULTRA_V2_SUB_DEV,            0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070Ti FTW3 Ultra"                  , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3070TI_FTW3_ULTRA_SUB_DEV,              0x2D);
-REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070Ti FTW3 Ultra v2"               , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3070TI_FTW3_ULTRA_V2_SUB_DEV,           0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Black"                     , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_XC3_BLACK_SUB_DEV,                 0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Black LHR"                 , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_XC3_BLACK_LHR_SUB_DEV,             0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Gaming"                    , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_XC3_GAMING_SUB_DEV,                0x2D);
@@ -69,15 +67,13 @@ REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Ultra Hybrid LHR"
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Ultra Hydro Copper"        , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_XC3_ULTRA_HC_SUB_DEV,              0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Gaming"                   , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_GAMING_SUB_DEV,               0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra"                    , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_SUB_DEV,                0x2D);
-REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra v2 LHR"             , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_LHR_V2_SUB_DEV,         0x2D);
+REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra 12GB"               , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_12G_SUB_DEV,            0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra LHR"                , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_LHR_SUB_DEV,            0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hybrid"             , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_HYBRID_SUB_DEV,         0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hybrid LHR"         , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_HYBRID_LHR_SUB_DEV,     0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hybrid Gaming LHR"  , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_HYBRID_GAMING_SUB_DEV,  0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hydro Copper"       , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_HC_SUB_DEV,             0x2D);
-REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Ultra 12G"                 , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN,   EVGA_RTX3080_12G_XC3_ULTRA_SUB_DEV,             0x2D);
-REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra 12GB"               , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN,   EVGA_RTX3080_12G_FTW3_ULTRA_SUB_DEV,            0x2D);
-REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hydro Copper 12G"   , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN,   EVGA_RTX3080_12G_FTW3_ULTRA_HC_SUB_DEV,         0x2D);
+REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hydro Copper 12G"   , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_HC_12G_SUB_DEV,         0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080Ti XC3 Gaming"                  , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3080TI_XC3_GAMING_SUB_DEV,              0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080Ti XC3 Ultra Gaming"            , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3080TI_XC3_ULTRA_GAMING_SUB_DEV,        0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080Ti XC3 Gaming Hybrid"           , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3080TI_XC3_GAMING_HYBRID_SUB_DEV,       0x2D);

Controllers/EVGAGP102GPUController/EVGAGP102GPUControllerDetect.cpp

@@ -25,8 +25,7 @@ static const gpu_pci_device device_list[] =
 {
     
     { NVIDIA_VEN,   NVIDIA_GTX1070_DEV,         EVGA_SUB_VEN,   EVGA_GTX1070_FTW2_SUB_DEV,              "EVGA GeForce GTX 1070 FTW2 Gaming"                     },
-    { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,         EVGA_SUB_VEN,   EVGA_GTX1080_FTW2_SUB_DEV,              "EVGA GeForce GTX 1080 FTW2 Gaming"                     },
-    { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,         EVGA_SUB_VEN,   EVGA_GTX1080_FTW2_11G_SUB_DEV,          "EVGA GeForce GTX 1080 FTW2 11G"                        },
+    { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,         EVGA_SUB_VEN,   EVGA_GTX1080_FTW2_SUB_DEV,              "EVGA GeForce GTX 1080 FTW2"                            },
     { NVIDIA_VEN,   NVIDIA_GTX1080TI_DEV,       EVGA_SUB_VEN,   EVGA_GTX1080TI_SC2_GAMING_SUB_DEV,      "EVGA GTX 1080 Ti SC2 Gaming"                           },
     { NVIDIA_VEN,   NVIDIA_GTX1080TI_DEV,       EVGA_SUB_VEN,   EVGA_GTX1080TI_FTW3_SUB_DEV,            "EVGA GTX 1080 Ti FTW3"                                 },
     { NVIDIA_VEN,   NVIDIA_GTX1080TI_DEV,       EVGA_SUB_VEN,   EVGA_GTX1080TI_FTW3_HYBRID_SUB_DEV,     "EVGA 1080Ti FTW3 Hybrid"                               },

Controllers/EVGATuringGPUController/EVGATuringGPUControllerDetect.cpp

@@ -33,7 +33,6 @@ void DetectEVGATuringGPUControllers(i2c_smbus_interface* bus, uint8_t address, c
     }
 }   /* DetectEVGATuringGPUControllers() */
 
-REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 XC Black"                        , DetectEVGATuringGPUControllers, NVIDIA_VEN,     NVIDIA_RTX2070_DEV,     EVGA_SUB_VEN,   EVGA_RTX2070_XC_BLACK_SUB_DEV,             0x49);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 XC Gaming"                       , DetectEVGATuringGPUControllers, NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,  EVGA_SUB_VEN,   EVGA_RTX2070_XC_GAMING_SUB_DEV,            0x49);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 XC OC"                           , DetectEVGATuringGPUControllers, NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,  EVGA_SUB_VEN,   EVGA_RTX2070_XC_OC_SUB_DEV,                0x49);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 SUPER XC Ultra"                  , DetectEVGATuringGPUControllers, NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV, EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_SUB_DEV,            0x49);

Controllers/EVGAUSBController/RGBController_EVGAMouse.cpp

@@ -9,17 +9,6 @@
 #include "RGBController_EVGAMouse.h"
 #include "Colors.h"
 
-/**------------------------------------------------------------------*\
-    @name EVGA USB X20 Mouse
-    @category Mouse
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectWiredEVGAMouse,DetectWirelessEVGAMouse
-    @comment The EVGA USB mouse currently supports the X20 (both wired
-        and wireless, but not bluetooth).
-\*-------------------------------------------------------------------*/
 RGBController_EVGAMouse::RGBController_EVGAMouse(EVGAMouseController* controller_ptr)
 {
     controller                  = controller_ptr;

Controllers/ElgatoKeyLightController/ElgatoKeyLightController.cpp

@@ -1,110 +0,0 @@
-/*---------------------------------------------------------*\
-|  Driver for Elgato Key Light                              |
-|                                                           |
-|  Monks ([email protected]),   11/03/2021       |
-\*---------------------------------------------------------*/
-
-#include "ElgatoKeyLightController.h"
-#include "json.hpp"
-#include <iostream>
-
-using json = nlohmann::json;
-
-ElgatoKeyLightController::ElgatoKeyLightController(std::string ip)
-{
-    /*-----------------------------------------------------------------*\
-    | Fill in location string with device's IP address                  |
-    \*-----------------------------------------------------------------*/
-    location    = "IP: " + ip;
-
-    /*-----------------------------------------------------------------*\
-    | Open a TCP client sending to the device's IP, port 9123          |
-    \*-----------------------------------------------------------------*/
-    port.tcp_client(ip.c_str(), "9123");
-}
-
-ElgatoKeyLightController::~ElgatoKeyLightController()
-{
-}
-
-std::string ElgatoKeyLightController::GetLocation()
-{
-    return(location);
-}
-
-std::string ElgatoKeyLightController::GetName()
-{
-    return("Elgato KeyLight");
-}
-
-std::string ElgatoKeyLightController::GetVersion()
-{
-    return("");
-}
-
-std::string ElgatoKeyLightController::GetManufacturer()
-{
-    return("Elgato");
-}
-
-std::string ElgatoKeyLightController::GetUniqueID()
-{
-    return("");
-}
-
-void ElgatoKeyLightController::SetColor(hsv_t hsv_color)
-{
-    // Weird elgato color format
-    int k_value = HSVToK(hsv_color.hue);
-
-    port.tcp_client_connect();
-    std::string buf = GetRequest(hsv_color.value, k_value);
-    port.tcp_client_write((char *)buf.c_str(), buf.length() + 1);
-
-    port.tcp_close();
-}
-
-std::string ElgatoKeyLightController::GetRequest(int brightness, int temperature)
-{
-    json command;
-
-    command["numberOfLights"] = 1;
-
-    auto lights = json::array();
-    lights.push_back(json::object({ {"on", 1}, {"temperature", temperature}, {"brightness", brightness}}));
-    command["lights"] = lights;
-
-    std::string command_str = command.dump();
-    std::string buf = "PUT /elgato/lights HTTP/1.1\r\nContent-Type: application/json\r\nContent-Length: " +
-                      std::to_string(command_str.length()) +
-                      "\r\nConnection: close\r\n\r\n" + command_str + "\r\n\r\n";
-    return(buf);
-}
-
-int ElgatoKeyLightController::HSVToK(int hue)
-{
-    int k_value;
-
-    if(hue <= 60 && hue >= 0)
-    {
-        k_value = 2900;
-    }
-    else if(hue >= 61 && hue <= 120)
-    {
-        k_value = 4000;
-    }
-    else if(hue >= 121 && hue <= 180)
-    {
-        k_value = 5000;
-    }
-    else if(hue >= 181 && hue <= 240)
-    {
-        k_value = 6000;
-    }
-    else
-    {
-        k_value = 7000;
-    }
-
-    return k_value;
-}

Controllers/ElgatoKeyLightController/ElgatoKeyLightController.h

@@ -1,37 +0,0 @@
-/*---------------------------------------------------------*\
-|  Definitions for Elgato Key Light                         |
-|                                                           |
-|  Monks ([email protected]), 11/11/2021         |
-\*---------------------------------------------------------*/
-
-#include "RGBController.h"
-#include "net_port.h"
-#include "hsv.h"
-
-#include <cmath>
-#include <string>
-#include <thread>
-#include <vector>
-
-#pragma once
-
-class ElgatoKeyLightController
-{
-public:
-    ElgatoKeyLightController(std::string ip);
-    ~ElgatoKeyLightController();
-
-    std::string GetLocation();
-    std::string GetName();
-    std::string GetVersion();
-    std::string GetManufacturer();
-    std::string GetUniqueID();
-
-    void SetColor(hsv_t hsv_color);
-
-private:
-    std::string GetRequest(int brightness, int temperature);
-    int HSVToK(int hue);
-    std::string         location;
-    net_port            port;
-};

Controllers/ElgatoKeyLightController/ElgatoKeyLightControllerDetect.cpp

@@ -1,48 +0,0 @@
-#include "Detector.h"
-#include "ElgatoKeyLightController.h"
-#include "RGBController.h"
-#include "RGBController_ElgatoKeyLight.h"
-#include "SettingsManager.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectElgatoKeyLightControllers                                                        *
-*                                                                                          *
-*       Detect Elgato KeyLight devices                                                     *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectElgatoKeyLightControllers()
-{
-    json                    elgato_keylight_settings;
-
-    /*-------------------------------------------------*\
-    | Get KeyLight settings from settings manager      |
-    \*-------------------------------------------------*/
-    elgato_keylight_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("ElgatoKeyLightDevices");
-
-    /*----------------------------------------------------------*\
-    | If the Elgato Key Light settings contains devices, process|
-    \*----------------------------------------------------------*/
-    if(elgato_keylight_settings.contains("devices"))
-    {
-        for(unsigned int device_idx = 0; device_idx < elgato_keylight_settings["devices"].size(); device_idx++)
-        {
-            if(elgato_keylight_settings["devices"][device_idx].contains("ip"))
-            {
-                std::string elgato_keylight_ip = elgato_keylight_settings["devices"][device_idx]["ip"];
-
-                ElgatoKeyLightController*     controller     = new ElgatoKeyLightController(elgato_keylight_ip);
-                RGBController_ElgatoKeyLight* rgb_controller = new RGBController_ElgatoKeyLight(controller);
-
-                ResourceManager::get()->RegisterRGBController(rgb_controller);
-            }
-        }
-    }
-
-}   /* DetectElgatoKeyLightControllers() */
-
-REGISTER_DETECTOR("ElgatoKeyLight", DetectElgatoKeyLightControllers);

Controllers/ElgatoKeyLightController/RGBController_ElgatoKeyLight.cpp

@@ -1,86 +0,0 @@
-/*------------------------------------------------*\
-|  RGBController_ElgatoKeyLight.cpp               |
-|                                                 |
-|  Generic RGB Interface for ElgatoKeyLight       |
-|                                                 |
-|  Monks (@iamtherealestmonkey) 11/03/2021        |
-\*------------------------------------------------*/
-
-#include "RGBController_ElgatoKeyLight.h"
-#include "hsv.h"
-
-RGBController_ElgatoKeyLight::RGBController_ElgatoKeyLight(ElgatoKeyLightController* controller_ptr)
-{
-    controller          = controller_ptr;
-
-    name                = controller->GetName();
-    vendor              = controller->GetManufacturer();
-    type                = DEVICE_TYPE_LIGHT;
-    version             = controller->GetVersion();
-    description         = "Elgato KeyLight Device";
-    serial              = controller->GetUniqueID();
-    location            = controller->GetLocation();
-
-    mode Static;
-    Static.name         = "Static";
-    Static.value        = 0;
-    Static.flags        = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.color_mode   = MODE_COLORS_PER_LED;
-    modes.push_back(Static);
-
-    SetupZones();
-}
-
-RGBController_ElgatoKeyLight::~RGBController_ElgatoKeyLight()
-{
-    delete controller;
-}
-
-void RGBController_ElgatoKeyLight::SetupZones()
-{
-    zone led_zone;
-    led_zone.name       = "Keylight";
-    led_zone.type       = ZONE_TYPE_SINGLE;
-    led_zone.leds_min   = 1;
-    led_zone.leds_max   = 1;
-    led_zone.leds_count = 1;
-    led_zone.matrix_map = NULL;
-    zones.push_back(led_zone);
-
-    led new_led;
-    new_led.name = "Keylight";
-
-    leds.push_back(new_led);
-
-    SetupColors();
-}
-
-void RGBController_ElgatoKeyLight::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_ElgatoKeyLight::DeviceUpdateLEDs()
-{
-    RGBColor rgb_color = colors[0];
-    hsv_t hsv_color;
-    rgb2hsv(rgb_color, &hsv_color);
-    controller->SetColor(hsv_color);
-}
-
-void RGBController_ElgatoKeyLight::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_ElgatoKeyLight::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_ElgatoKeyLight::DeviceUpdateMode()
-{
-
-}

Controllers/ElgatoKeyLightController/RGBController_ElgatoKeyLight.h

@@ -1,31 +0,0 @@
-/*--------------------------------------------------*\
-|  RGBController_ElgatoKeyLight.h                   |
-|                                                   |
-|  Generic RGB Interface for Elgato KeyLight        |
-|                                                   |
-|  Monks ([email protected]) 11/1/2021   |
-\*--------------------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "ElgatoKeyLightController.h"
-
-class RGBController_ElgatoKeyLight : public RGBController
-{
-public:
-    RGBController_ElgatoKeyLight(ElgatoKeyLightController* controller_ptr);
-    ~RGBController_ElgatoKeyLight();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    ElgatoKeyLightController* controller;
-};

Controllers/EspurnaController/EspurnaControllerDetect.cpp

@@ -15,7 +15,7 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectEspurnaControllers()
+void DetectEspurnaControllers(std::vector<RGBController*> &rgb_controllers)
 {
     json espurna_settings;
 
@@ -64,7 +64,7 @@ void DetectEspurnaControllers()
 
             RGBController_Espurna* rgb_controller = new RGBController_Espurna(controller);
 
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
+            rgb_controllers.push_back(rgb_controller);
         }
     }
 

Controllers/FanBusController/FanBusControllerDetect.cpp

@@ -2,7 +2,7 @@
 #include "FanBusController.h"
 #include "RGBController_FanBus.h"
 
-void DetectFanBusControllers()
+void DetectFanBusControllers(std::vector<RGBController*> &rgb_controllers)
 {
     FanBusInterface*    new_interface;
     json                fanbus_settings;
@@ -29,10 +29,10 @@ void DetectFanBusControllers()
 
                 for(unsigned int controller_idx = 0; controller_idx < detected_controllers.size(); controller_idx++)
                 {
-                    FanBusController*     controller     = new FanBusController(new_interface, detected_controllers[controller_idx]);
-                    RGBController_FanBus* rgb_controller = new RGBController_FanBus(controller);
+                        FanBusController*     controller     = new FanBusController(new_interface, detected_controllers[controller_idx]);
+                        RGBController_FanBus* rgb_controller = new RGBController_FanBus(controller);
 
-                    ResourceManager::get()->RegisterRGBController(rgb_controller);
+                    rgb_controllers.push_back(rgb_controller);
                 }
             }
         }

Controllers/FaustusController/RGBController_Faustus.cpp

@@ -153,24 +153,14 @@ void RGBController_Faustus::DeviceUpdateMode()
     DeviceUpdateLEDs();
 }
 
-void DetectFaustusControllers()
+void DetectFaustusControllers(std::vector<RGBController*> &rgb_controllers)
 {
     const char* base_path = "/sys/devices/platform/faustus/kbbl";
     DIR* dir = opendir(base_path);
-
-    if(!dir)
-    {
-        return;
-    }
-
+    if(!dir) return;
     // Directory is present - we pretty much have a driver confirmation already, but double check for all files required just in case
     struct dirent* dent = readdir(dir);
-
-    if(!dent)
-    {
-        return;
-    }
-
+    if(!dent) return;
     int found = 0;
     while(dent)
     {
@@ -181,15 +171,9 @@ void DetectFaustusControllers()
         }
         dent = readdir(dir);
     }
-
     closedir(dir);
-
-    if(found != 6)
-    {
-        return;
-    }
-
-    ResourceManager::get()->RegisterRGBController(new RGBController_Faustus(base_path));
+    if(found != 6) return;
+    rgb_controllers.push_back(new RGBController_Faustus(base_path));
 }   /* DetectFaustusControllers() */
 
 REGISTER_DETECTOR("Faustus", DetectFaustusControllers);

Controllers/GalaxGPUController/GalaxGPUControllerDetect.cpp

@@ -65,5 +65,4 @@ void DetectGalaxGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const
 REGISTER_I2C_PCI_DETECTOR("KFA2 RTX 2070 EX",                       DetectGalaxGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070_DEV,     NVIDIA_SUB_VEN, KFA2_RTX_2070_EX_SUB_DEV,               0x23);
 REGISTER_I2C_PCI_DETECTOR("GALAX RTX 2070 Super EX Gamer Black",    DetectGalaxGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, NVIDIA_SUB_VEN, GALAX_RTX_2070S_EX_GAMER_BLACK_SUB_DEV, 0x23);
 REGISTER_I2C_PCI_DETECTOR("KFA2 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 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 RTX 2080 TI EX OC",                 DetectGalaxGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2080TI_DEV,   NVIDIA_SUB_VEN, KFA2_RTX_2080_TI_EX_OC_SUB_DEV,         0x23);

Controllers/GigabyteAorusMouseController/GigabyteAorusMouseController.cpp

@@ -1,80 +0,0 @@
-/*-----------------------------------------*\
-|  GigabyteAorusMouseController.cpp         |
-|                                           |
-|  Driver for Gigabyte Aorus Mouse lighting |
-|  controller                               |
-|                                           |
-|  Guimard Morgan (morg) 12/29/2022         |
-\*-----------------------------------------*/
-#include "GigabyteAorusMouseController.h"
-#include <string.h>
-
-GigabyteAorusMouseController::GigabyteAorusMouseController(hid_device* dev_handle, const hid_device_info& info)
-{
-    dev                 = dev_handle;
-    location            = info.path;
-    version             = "";
-
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        serial_number = "";
-    }
-    else
-    {
-        std::wstring return_wstring = serial_string;
-        serial_number = std::string(return_wstring.begin(), return_wstring.end());
-    }
-}
-
-GigabyteAorusMouseController::~GigabyteAorusMouseController()
-{
-    hid_close(dev);
-}
-
-std::string GigabyteAorusMouseController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string GigabyteAorusMouseController::GetSerialString()
-{
-    return(serial_number);
-}
-
-std::string GigabyteAorusMouseController::GetFirmwareVersion()
-{
-    return(version);
-}
-
-void GigabyteAorusMouseController::SetMode(RGBColor color, uint8_t mode_value, uint8_t brightness, uint8_t speed)
-{
-    uint8_t usb_buf[GIGABYTE_AORUS_MOUSE_REPORT_SIZE];
-
-    usb_buf[0] = GIGABYTE_AORUS_MOUSE_HARDWARE_CMD;
-    usb_buf[1] = mode_value;
-    usb_buf[2] = brightness;
-    usb_buf[3] = RGBGetRValue(color);
-    usb_buf[4] = RGBGetGValue(color);
-    usb_buf[5] = RGBGetBValue(color);
-    usb_buf[6] = speed;
-    usb_buf[7] = 0x00;
-
-    hid_send_feature_report(dev, usb_buf, GIGABYTE_AORUS_MOUSE_REPORT_SIZE);
-}
-
-void GigabyteAorusMouseController::SendDirect(RGBColor color)
-{
-    uint8_t usb_buf[8];
-
-    memset(usb_buf, 0x00, GIGABYTE_AORUS_MOUSE_REPORT_SIZE);
-
-    usb_buf[0] = GIGABYTE_AORUS_MOUSE_DIRECT_CMD;
-    usb_buf[2] = RGBGetRValue(color);
-    usb_buf[3] = RGBGetGValue(color);
-    usb_buf[4] = RGBGetBValue(color);
-
-    hid_send_feature_report(dev, usb_buf, GIGABYTE_AORUS_MOUSE_REPORT_SIZE);
-}

Controllers/GigabyteAorusMouseController/GigabyteAorusMouseController.h

@@ -1,56 +0,0 @@
-/*-----------------------------------------*\
-|  GigabyteAorusMouseController.h           |
-|                                           |
-|  Driver for Gigabyte Aorus Mouse lighting |
-|  controller - header file                 |
-|                                           |
-|  Guimard Morgan (morg) 12/29/2022         |
-\*-----------------------------------------*/
-#pragma once
-
-#include "RGBController.h"
-#include <string>
-#include <hidapi/hidapi.h>
-
-#define GIGABYTE_AORUS_MOUSE_REPORT_SIZE    8
-#define GIGABYTE_AORUS_MOUSE_DIRECT_CMD     0xCD
-#define GIGABYTE_AORUS_MOUSE_HARDWARE_CMD   0xCC
-
-enum
-{
-    GIGABYTE_AORUS_MOUSE_DIRECT_MODE_VALUE          = 0x00,
-    GIGABYTE_AORUS_MOUSE_STATIC_MODE_VALUE          = 0x01,
-    GIGABYTE_AORUS_MOUSE_PULSE_MODE_VALUE           = 0x02,
-    GIGABYTE_AORUS_MOUSE_COLOR_CYCLE_MODE_VALUE     = 0x03,
-    GIGABYTE_AORUS_MOUSE_FLASH_MODE_VALUE           = 0x04,
-    GIGABYTE_AORUS_MOUSE_DOUBLE_FLASH_MODE_VALUE    = 0x05,
-};
-
-enum
-{
-    GIGABYTE_AORUS_MOUSE_SPEED_MIN          = 0x16,
-    GIGABYTE_AORUS_MOUSE_SPEED_MAX          = 0x00,
-    GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MIN     = 0x00,
-    GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MAX     = 0x64
-};
-
-class GigabyteAorusMouseController
-{
-public:
-    GigabyteAorusMouseController(hid_device* dev_handle, const hid_device_info& info);
-    ~GigabyteAorusMouseController();
-
-    std::string GetSerialString();
-    std::string GetDeviceLocation();
-    std::string GetFirmwareVersion();
-
-    void        SetMode(RGBColor color, uint8_t mode_value, uint8_t brightness, uint8_t speed);
-    void        SendDirect(RGBColor color);
-
-private:
-    hid_device* dev;
-
-    std::string location;
-    std::string serial_number;
-    std::string version;
-};

Controllers/GigabyteAorusMouseController/GigabyteAorusMouseControllerDetect.cpp

@@ -1,31 +0,0 @@
-#include "Detector.h"
-#include "RGBController.h"
-#include "hidapi/hidapi.h"
-#include "GigabyteAorusMouseController.h"
-#include "RGBController_GigabyteAorusMouse.h"
-
-/*-----------------------------------------------------*\
-| Vendor ID                                             |
-\*-----------------------------------------------------*/
-#define HOLTEK_VID                                 0x1044
-
-/*-----------------------------------------------------*\
-| Controller product ids                                |
-\*-----------------------------------------------------*/
-#define AORUS_M2_PID                               0x7A40
-
-void DetectGigabyteAorusMouseControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        GigabyteAorusMouseController*     controller         = new GigabyteAorusMouseController(dev, *info);
-        RGBController_GigabyteAorusMouse* rgb_controller     = new RGBController_GigabyteAorusMouse(controller);
-        rgb_controller->name                     = name;
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR_IPU("Gigabyte Aorus M2", DetectGigabyteAorusMouseControllers, HOLTEK_VID, AORUS_M2_PID, 3, 0xFF01, 0x01);

Controllers/GigabyteAorusMouseController/RGBController_GigabyteAorusMouse.cpp

@@ -1,185 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_GigabyteAorusMouse.cpp     |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  Gigabyte Aorus Mouse lighting            |
-|  USB Driver                               |
-|                                           |
-|  Guimard Morgan (morg) 12/29/2022         |
-\*-----------------------------------------*/
-
-#include "RGBController_GigabyteAorusMouse.h"
-
-#include <thread>
-#include <chrono>
-
-/**------------------------------------------------------------------*\
-    @name Gigabyte Aorus mouse
-    @category Mouse
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectGigabyteAorusMouseControllers
-    @comment
-\*-------------------------------------------------------------------*/
-RGBController_GigabyteAorusMouse::RGBController_GigabyteAorusMouse(GigabyteAorusMouseController* controller_ptr)
-{
-    controller                          = controller_ptr;
-    name                                = "Gigabyte Aorus";
-    vendor                              = "Gigabyte";
-    type                                = DEVICE_TYPE_MOUSE;
-    description                         = name;
-    location                            = controller->GetDeviceLocation();
-    serial                              = controller->GetSerialString();
-    version                             = controller->GetFirmwareVersion();
-
-    mode Direct;
-    Direct.name                         = "Direct";
-    Direct.value                        = GIGABYTE_AORUS_MOUSE_DIRECT_MODE_VALUE;
-    Direct.flags                        = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.color_mode                   = MODE_COLORS_PER_LED;
-    Direct.brightness_min               = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MIN;
-    Direct.brightness_max               = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MAX;
-    Direct.brightness                   = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MAX;
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name                         = "Static";
-    Static.value                        = GIGABYTE_AORUS_MOUSE_STATIC_MODE_VALUE;
-    Static.flags                        = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.color_mode                   = MODE_COLORS_MODE_SPECIFIC;
-    Static.brightness_min               = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MIN;
-    Static.brightness_max               = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MAX;
-    Static.brightness                   = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MAX;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Pulse;
-    Pulse.name                          = "Breathing";
-    Pulse.value                         = GIGABYTE_AORUS_MOUSE_PULSE_MODE_VALUE;
-    Pulse.flags                         = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Pulse.color_mode                    = MODE_COLORS_MODE_SPECIFIC;
-    Pulse.brightness_min                = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MIN;
-    Pulse.brightness_max                = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MAX;
-    Pulse.brightness                    = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MAX;
-    Pulse.speed_min                     = GIGABYTE_AORUS_MOUSE_SPEED_MIN;
-    Pulse.speed_max                     = GIGABYTE_AORUS_MOUSE_SPEED_MAX;
-    Pulse.speed                         = GIGABYTE_AORUS_MOUSE_SPEED_MIN / 2;
-    Pulse.colors.resize(1);
-    modes.push_back(Pulse);
-
-    mode ColorCycle;
-    ColorCycle.name                     = "Spectrum Cycle";
-    ColorCycle.value                    = GIGABYTE_AORUS_MOUSE_COLOR_CYCLE_MODE_VALUE;
-    ColorCycle.flags                    = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    ColorCycle.color_mode               = MODE_COLORS_NONE;
-    ColorCycle.brightness_min           = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MIN;
-    ColorCycle.brightness_max           = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MAX;
-    ColorCycle.brightness               = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MAX;
-    ColorCycle.speed_min                = GIGABYTE_AORUS_MOUSE_SPEED_MIN;
-    ColorCycle.speed_max                = GIGABYTE_AORUS_MOUSE_SPEED_MAX;
-    ColorCycle.speed                    = GIGABYTE_AORUS_MOUSE_SPEED_MIN / 2;
-    modes.push_back(ColorCycle);
-
-    mode Flash;
-    Flash.name                          = "Flashing";
-    Flash.value                         = GIGABYTE_AORUS_MOUSE_FLASH_MODE_VALUE;
-    Flash.flags                         = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Flash.color_mode                    = MODE_COLORS_MODE_SPECIFIC;
-    Flash.brightness_min                = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MIN;
-    Flash.brightness_max                = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MAX;
-    Flash.brightness                    = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MAX;
-    Flash.speed_min                     = GIGABYTE_AORUS_MOUSE_SPEED_MIN;
-    Flash.speed_max                     = GIGABYTE_AORUS_MOUSE_SPEED_MAX;
-    Flash.speed                         = GIGABYTE_AORUS_MOUSE_SPEED_MIN / 2;
-    Flash.colors.resize(1);
-    modes.push_back(Flash);
-
-    mode DoubleFlash;
-    DoubleFlash.name                    = "Double Flash";
-    DoubleFlash.value                   = GIGABYTE_AORUS_MOUSE_DOUBLE_FLASH_MODE_VALUE;
-    DoubleFlash.flags                   = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    DoubleFlash.color_mode              = MODE_COLORS_MODE_SPECIFIC;
-    DoubleFlash.brightness_min          = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MIN;
-    DoubleFlash.brightness_max          = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MAX;
-    DoubleFlash.brightness              = GIGABYTE_AORUS_MOUSE_BRIGHTNESS_MAX;
-    DoubleFlash.speed_min               = GIGABYTE_AORUS_MOUSE_SPEED_MIN;
-    DoubleFlash.speed_max               = GIGABYTE_AORUS_MOUSE_SPEED_MAX;
-    DoubleFlash.speed                   = GIGABYTE_AORUS_MOUSE_SPEED_MIN / 2;
-    DoubleFlash.colors.resize(1);
-    modes.push_back(DoubleFlash);
-
-    mode Off;
-    Off.name                            = "Off";
-    Off.value                           = GIGABYTE_AORUS_MOUSE_STATIC_MODE_VALUE;
-    Off.color_mode                      = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    SetupZones();
-}
-
-RGBController_GigabyteAorusMouse::~RGBController_GigabyteAorusMouse()
-{
-    delete controller;
-}
-
-void RGBController_GigabyteAorusMouse::SetupZones()
-{
-    zone new_zone;
-
-    new_zone.name       = "Mouse";
-    new_zone.type       = ZONE_TYPE_LINEAR;
-    new_zone.leds_min   = 1;
-    new_zone.leds_max   = 1;
-    new_zone.leds_count = 1;
-    new_zone.matrix_map = nullptr;
-
-    zones.emplace_back(new_zone);
-
-    leds.resize(1);
-    leds[0].name = "LED 1";
-
-    SetupColors();
-}
-
-void RGBController_GigabyteAorusMouse::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_GigabyteAorusMouse::DeviceUpdateLEDs()
-{
-    controller->SendDirect(colors[0]);
-}
-
-void RGBController_GigabyteAorusMouse::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_GigabyteAorusMouse::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_GigabyteAorusMouse::DeviceUpdateMode()
-{    
-    /*---------------------------------------------------------*\
-    | Brightness cannot be updated in the direct mode packet    |
-    \*---------------------------------------------------------*/
-    if(modes[active_mode].value == GIGABYTE_AORUS_MOUSE_DIRECT_MODE_VALUE)
-    {
-        controller->SetMode(colors[0], GIGABYTE_AORUS_MOUSE_STATIC_MODE_VALUE, modes[active_mode].brightness, 0);
-    }
-    else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        controller->SetMode(modes[active_mode].colors[0], modes[active_mode].value, modes[active_mode].brightness, modes[active_mode].speed);
-    }
-    else
-    {
-        controller->SetMode(0, modes[active_mode].value, modes[active_mode].brightness, modes[active_mode].speed);
-    }
-}

Controllers/GigabyteAorusMouseController/RGBController_GigabyteAorusMouse.h

@@ -1,33 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_GigabyteAorusMouse.h       |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  Gigabyte Aorus Mouse lighting            |
-|  USB Driver                               |
-|                                           |
-|  Guimard Morgan (morg) 12/29/2022         |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "GigabyteAorusMouseController.h"
-
-class RGBController_GigabyteAorusMouse : public RGBController
-{
-public:
-    RGBController_GigabyteAorusMouse(GigabyteAorusMouseController* controller_ptr);
-    ~RGBController_GigabyteAorusMouse();
-
-    void SetupZones();
-    void ResizeZone(int zone, int new_size);
-
-    void DeviceUpdateLEDs();
-    void UpdateZoneLEDs(int zone);
-    void UpdateSingleLED(int led);
-
-    void DeviceUpdateMode();
-
-private:
-    GigabyteAorusMouseController* controller;
-};

Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp

@@ -37,26 +37,14 @@ bool TestForGigabyteRGBFusion2GPUController(i2c_smbus_interface* bus, unsigned c
     res = bus->i2c_read_block(address, &pktsz, data_readpkt);
 
     //What we have seen returned so far...
-    //GeForce RTX 3070 AORUS MASTER 8G                      0xAB 0x11 0x52 0x03
-    //GeForce RTX 3060 Ti GAMING OC PRO 8G                  0xAB 0x10 0x01 0x02
-    //GeForce RTX 3070 AORUS ELITE 12G                      0xAB 0x11 0x52 0x03
-    //GeForce RTX 3080 Ti AORUS XTREME WATERFORCE 12G       0xAB 0x11 0x01 0x00
-    //GeForce RTX 3080 Ti AORUS XTREME WATERFORCE 12G LHS   0xAB 0x11 0x52 0x00
-    //GeForce RTX 3080 AORUS XTREME WATERFORCE WB 10G       0xAB 0x10 0x01 0x00
-    //GeForce RTX 4080 Gigabyte AORUS MASTER 16G            0xAB 0x10 0x52 0x07
-    //Note that GeForce RTX 3080 Ti AORUS XTREME WATERFORCE 12G LHS exposes three i2c buses but only one returns a 0xAB
-    //response and controls the RGB lighting. The other buses return 0x00 0x00 0x00 0x00.
-    //Note that GeForce RTX 4080 Gigabyte AORUS MASTER 16G exposes two i2c bus with writable address 0x71 but on 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)
+    //GeForce RTX 3070 AORUS MASTER 8G                  0xAB 0x11 0x52 0x03
+    //GeForce RTX 3060 Ti GAMING OC PRO 8G              0xAB 0x10 0x01 0x02
+    //GeForce RTX 3070 AORUS ELITE 12G                  0xAB 0x11 0x52 0x03
+    //GeForce RTX 3080 Ti AORUS XTREME WATERFORCE 12G   0xAB 0x11 0x01 0x00
+    //GeForce RTX 3080 AORUS XTREME WATERFORCE WB 10G   0xAB 0x10 0x01 0x00
+    if(res < 0)
     {
-        // Assemble C-string with respons for debugging
-        char str[32];
-        for(int idx = 0; idx < read_sz; ++idx)
-            sprintf(&str[5*idx], " 0x%02X", data_readpkt[idx]);
-        LOG_DEBUG("[%s] at address 0x%02X invalid. Expected 0xAB [0x*] but received:%s", GIGABYTEGPU_CONTROLLER_NAME2, address, str);
+        LOG_DEBUG("[%s] at 0x%02X address expected 0x04 but received: 0x%02X", GIGABYTEGPU_CONTROLLER_NAME2, address, res);
         pass = false;
     }
 
@@ -89,21 +77,15 @@ void DetectGigabyteRGBFusion2GPUControllers(i2c_smbus_interface* bus, uint8_t i2
 
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX2060 SUPER 8G V1",                     DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2060S_V1_SUB_DEV,             0x50);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX2070 XTREME 8G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2070_XTREME_SUB_DEV,          0x50);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX2070 XTREME 8G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2070_XTREME_SUB_DEV2,          0x50);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX2070 SUPER 8G",                        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_SUB_DEV2,           0x50);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX2070 SUPER 8G",                        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2070S_8G_SUB_DEV,             0x50);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX2080 8G",                              DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_A_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080_SUB_DEV,                 0x50);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX2080 XTREME 8G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_A_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080_XTREME_SUB_DEV,          0x50);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX2080 SUPER 8G",                        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_SUB_DEV,                0x50);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX2080 SUPER 8G Rev 1.0",                DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_SUB_DEV_V1,             0x50);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX2080 SUPER Waterforce WB 8G",          DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_WATERFORCE_WB_SUB_DEV,  0x51);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX2080 Ti XTREME 11G",                   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080TI_EXTREME_SUB_DEV,       0x50);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX3060 ELITE 12G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3060_GA104_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_ELITE_12GB_SUB_DEV,            0x70);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX3060 ELITE 12G Rev a1",                DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3060_GA106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_ELITE_12GB_SUB_DEV,            0x70);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX3060 ELITE 12G LHR",                   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_ELITE_12GB_SUB_DEV,            0x70);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX3060 ELITE 12G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_ELITE_12GB_SUB_DEV,            0x70);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX3060 Ti ELITE 8G LHR",                 DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_ELITE_8GB_SUB_DEV,           0x70);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 Ti GAMING OC 8G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3060TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_GAMING_OC_SUB_DEV,           0x62);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 Ti GAMING OC LHR 8G",                   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_GAMING_OC_SUB_DEV,           0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 Ti GAMING OC PRO 8G",                   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3060TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_GAMING_OC_PRO_SUB_DEV,       0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 Ti Gaming OC PRO 8G LHR",               DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_GAMING_OC_PRO_SUB_DEV,       0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 MASTER 8G",                             DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_MASTER_OC_SUB_DEV,             0x66);
@@ -111,15 +93,8 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 MASTER 8G LHR",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX3070 Ti MASTER 8G",                    DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX3070TI_MASTER_8G_SUB_DEV,     0x70);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX3080 XTREME WATERFORCE WB 10G",        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080_XTREME_WATERFORCE_SUB_DEV,     0x64);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX3080 XTREME WATERFORCE WB 10G",        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080_XTREME_WATERFORCE_SUB_DEV,     0x64);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX3080 XTREME WATERFORCE WB 12G LHR",    DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_12G_LHR_DEV, GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080_XTREME_WATERFORCE_12G_SUB_DEV, 0x64);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX3080 XTREME WATERFORCE 10G Rev 2.0",   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080_XTREME_WATERFORCE_V2_SUB_DEV,  0x65);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3080 Ti Vision OC 12G",                      DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080TI_VISION_OC_SUB_DEV,           0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX3080 Ti XTREME WATERFORCE 12G",        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080TI_XTREME_WATERFORCE_SUB_DEV,   0x65);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3090 VISION OC 24G ",                        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3090_VISION_OC_24G_SUB_DEV,         0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX3090 XTREME WATERFORCE 24G",           DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3090_XTREME_WATERFORCE_SUB_DEV,     0x65);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX3090 XTREME WATERFORCE WB 24G",        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3090_XTREME_WATERFORCE_WB_SUB_DEV,  0x64);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX4080 Gaming OC 16G",                         DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4080_GAMING_OC_SUB_DEV,             0x71);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX4080 MASTER 16G",                      DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX4080_MASTER_16G_SUB_DEV,      0x71);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX4090 GAMING OC 24G",                         DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4090_GAMING_OC_24G_SUB_DEV,         0x71);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX4090 MASTER 24G",                      DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX4090_MASTER_24G_SUB_DEV,      0x71);
-

Controllers/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusControllerDetect.cpp

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

Controllers/GigabyteRGBFusion2USBController/RGBController_GigabyteRGBFusion2USB.cpp

@@ -30,17 +30,15 @@ static FwdLedHeaders LedLookup
 \*-------------------------------------------------*/
 static MBName MBName2LayoutLookup
 {
-    {"B550 AORUS ELITE",            "STD_ATX"   },
-    {"B550 AORUS PRO",              "STD_ATX"   },
-    {"B550I AORUS PRO AX",          "ITX"       },
-    {"X570 AORUS ELITE",            "STD_ATX"   },
-    {"X570 AORUS MASTER",           "MSTR_ATX_3"},
-    {"X570 AORUS ELITE WIFI",       "STD_ATX"   },
-    {"X570 AORUS PRO WIFI",         "STD_ATX"   },
-    {"X570 AORUS ULTRA",            "STD_ATX"   },
-    {"X570 I AORUS PRO WIFI",       "ITX"       },
-    {"X670E AORUS MASTER",          "MSTR_ATX_2"},
-    {"Z390 AORUS MASTER-CF",        "MSTR_ATX"  },
+    {"B550 AORUS ELITE",        "STD_ATX"},
+    {"B550 AORUS PRO",          "STD_ATX"},
+    {"B550I AORUS PRO AX",      "ITX"},
+    {"X570 AORUS ELITE",        "STD_ATX"},
+    {"X570 AORUS ELITE WIFI",   "STD_ATX"},
+    {"X570 AORUS PRO WIFI",     "STD_ATX"},
+    {"X570 AORUS ULTRA",        "STD_ATX"},
+    {"X570 I AORUS PRO WIFI",   "ITX"},
+    {"Z390 AORUS MASTER-CF",    "MSTR_ATX"}
 };
 
 /*-------------------------------------------------*\
@@ -188,57 +186,6 @@ static KnownLayout knownLayoutsLookup
             }
         }
     },
-    {
-        "MSTR_ATX_2",
-        {
-            {
-                "D_LED1 Bottom",
-                {
-                    { "D_LED1 Bottom", HDR_D_LED2, 0},
-                }
-            },
-            {
-                "D_LED2 Top",
-                {
-                    { "D_LED2 Top",  HDR_D_LED1, 0},
-                }
-            },
-            {
-                "Motherboard",
-                {
-                    { "LED C1",         LED2, 1},
-                    { "LED C2",         LED5, 1},
-                    { "CPU Header",     LED3, 1},
-                    { "Cover Left",     LED4, 1},
-                    { "Cover Right",    LED1, 1},
-                }
-            }
-        }
-    },
-    {
-        "MSTR_ATX_3",
-        {
-            {
-                "Digital Headers",
-                {
-                    { "D_LED1 / D_LED2", HDR_D_LED1, 0},
-                }
-            },
-            {
-                "ARGB Strip",
-                {
-                    { "LED C1/C2",  LED5, 1},
-                }
-            },
-            {
-                "Motherboard",
-                {
-                    { "Aorus Logo", LED7, 1},
-                    { "ESS Logo",   LED4, 1},
-                }
-            }
-        }
-    },
 };
 
 /**------------------------------------------------------------------*\

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUControllerDetect.cpp

@@ -126,7 +126,6 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2060 SUPER Gaming OC",               Dete
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2060 SUPER Gaming OC 3X White 8G",   DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_OC_WHITE_SUB_DEV,      0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2060 SUPER Gaming OC 3X 8G V2",      DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_OC_3X_V2_SUB_DEV,      0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2070 Gaming OC 8G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070_GAMING_OC_SUB_DEV,             0x47);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2070 Gaming OC 8GC",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070_GAMING_OC_8GC_SUB_DEV,         0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2070 Windforce 8G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070_WINDFORCE_SUB_DEV,             0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2070S Gaming OC",                    DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_SUB_DEV,            0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2070S Gaming OC 3X",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_3X_SUB_DEV,         0x47);
@@ -134,13 +133,10 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2070S Gaming OC 3X",                 Dete
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2070S Gaming OC 3X White",           DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_3X_WHITE_SUB_DEV,   0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2080 Gaming OC 8G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080_GAMING_OC_SUB_DEV,             0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2080 Gaming OC 8G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2080_A_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080_A_GAMING_OC_SUB_DEV,           0x47);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2080 Ti GAMING OC 11G",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080_TI_GAMING_OC_SUB_DEV,          0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2080S Gaming OC 8G",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080S_GAMING_OC_SUB_DEV,            0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3050 Gaming OC 8G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3050_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3050_GAMING_OC_8GB_SUB_DEV,         0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 EAGLE OC 12G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_EAGLE_OC_12GB_SUB_DEV,         0x63);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 EAGLE OC 12G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060_GA104_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_EAGLE_OC_12GB_SUB_DEV,         0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 EAGLE OC 12G V2",               DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_EAGLE_OC_12GB_SUB_DEV,         0x63);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 EAGLE 12G LHR V2",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_EAGLE_12GB_V2_SUB_DEV,         0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 Vision OC 12G",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_VISION_OC_12GB_SUB_DEV,        0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 Vision OC 12G LHR",             DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_VISION_OC_12GB_SUB_DEV,        0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 Vision OC 12G v3.0",            DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060_GA104_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_VISION_OC_12GB_SUB_DEV,        0x63);
@@ -150,13 +146,13 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 Gaming OC 12G",                 Dete
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 Ti EAGLE OC 8G",                DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_EAGLE_OC_SUB_DEV,            0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 Ti EAGLE OC 8G V2.0 LHR",       DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_EAGLE_OC_SUB_DEV,            0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 Ti EAGLE OC 8G V2.0 LHR",       DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_EAGLE_OC_LHR_SUB_DEV,        0x63);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 Ti Gaming OC 8G",               DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_GAMING_OC_SUB_DEV,           0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 Ti Vision OC 8G",               DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_VISION_OC_8G_SUB_DEV,        0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Gaming OC 8G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_GAMING_OC_SUB_DEV,             0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Gaming OC 8G v3.0 LHR",         DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_GAMING_OC_SUB_DEV,             0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Vision 8G",                     DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_VISION_OC_SUB_DEV,             0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Vision 8G V2.0 LHR",            DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_VISION_OC_SUB_DEV,             0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Eagle OC 8G",                   DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_EAGLE_OC_SUB_DEV,              0x63);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Eagle OC 8G V2.0 LHR",          DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_EAGLE_OC_SUB_DEV,              0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Ti Gaming OC 8G",               DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070TI_GAMING_OC_SUB_DEV,           0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Ti EAGLE 8G",                   DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070TI_EAGLE_SUB_DEV,               0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Ti Vision OC 8G",               DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070TI_VISION_OC_SUB_DEV,           0x63);
@@ -167,5 +163,4 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3080 Vision OC 10G (REV 2.0)",       Dete
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3080 Vision OC 10G",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080_VISION_OC_SUB_DEV,             0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3080 Ti Gaming OC 12G",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080TI_GAMING_OC_SUB_DEV,           0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3080 Ti EAGLE 12G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080TI_EAGLE_SUB_DEV,               0x63);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3080 Ti EAGLE OC 12G",               DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080TI_EAGLE_OC_SUB_DEV,            0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3090 Gaming OC 24G",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3090_GAMING_OC_24GB_SUB_DEV,        0x62);

Controllers/GigabyteSuperIORGBController/GigabyteSuperIORGBControllerDetect.cpp

@@ -28,7 +28,7 @@ static gig_device compatible_devices[] =
     {"X570 UD"}
 };
 
-void DetectGigabyteSuperIORGBControllers()
+void DetectGigabyteSuperIORGBControllers(std::vector<RGBController*> &rgb_controllers)
 {
     int sio_addrs[2] = {0x2E, 0x4E};
 
@@ -49,22 +49,21 @@ void DetectGigabyteSuperIORGBControllers()
 
         int val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8) | superio_inb(sioaddr, SIO_REG_DEVID + 1);
 
-        switch(val & SIO_ID_MASK)
+        switch (val & SIO_ID_MASK)
         {
-            case SIO_ITE688_ID:
-                for(unsigned int i = 0; i < NUM_COMPATIBLE_DEVICES; i++)
+        case SIO_ITE688_ID:
+            for(unsigned int i = 0; i < NUM_COMPATIBLE_DEVICES; i++)
+            {
+                if (board_dmi.find(std::string(compatible_devices[i].name)) != std::string::npos)
                 {
-                    if (board_dmi.find(std::string(compatible_devices[i].name)) != std::string::npos)
-                    {
-                        GigabyteSuperIORGBController*     controller     = new GigabyteSuperIORGBController(sioaddr);
-                        RGBController_GigabyteSuperIORGB* rgb_controller = new RGBController_GigabyteSuperIORGB(controller);
-                        rgb_controller->name                             = "Gigabyte " + board_dmi;
-
-                        ResourceManager::get()->RegisterRGBController(rgb_controller);
-                        break;
-                    }
+                    GigabyteSuperIORGBController*     controller = new GigabyteSuperIORGBController(sioaddr);
+                    RGBController_GigabyteSuperIORGB* rgb_controller = new RGBController_GigabyteSuperIORGB(controller);
+                    rgb_controller->name = "Gigabyte " + board_dmi;
+                    rgb_controllers.push_back(rgb_controller);
+                    break;
                 }
-                break;
+            }
+            break;
         }
     }
 }   /* DetectGigabyteSuperIORGBControllers() */

Controllers/HyperXKeyboardController/HyperXAlloyOrigins60Controller.cpp

@@ -1,143 +0,0 @@
-/*-----------------------------------------*\
-|  HyperXAlloyOrigins60Controller.cpp       |
-|                                           |
-|  Driver for HyperX Alloy Origins 60 RGB   |
-|  Keyboard lighting controller             |
-|                                           |
-|  Derek Huber 10/24/2022                   |
-\*-----------------------------------------*/
-
-#include "HyperXAlloyOrigins60Controller.h"
-
-#include <cstring>
-
-HyperXAlloyOrigins60Controller::HyperXAlloyOrigins60Controller(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-HyperXAlloyOrigins60Controller::~HyperXAlloyOrigins60Controller()
-{
-    hid_close(dev);
-}
-
-std::string HyperXAlloyOrigins60Controller::GetDeviceLocation()
-{
-    return("HID " + location);
-}
-
-std::string HyperXAlloyOrigins60Controller::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-void HyperXAlloyOrigins60Controller::SetLEDsDirect(std::vector<RGBColor> colors)
-{
-    /*-----------------------------------------------------*\
-    | Set up variables to track progress of color transmit  |
-    | Do this after inserting blanks                        |
-    \*-----------------------------------------------------*/
-    int colors_to_send = colors.size();
-    int colors_sent    = 0;
-
-    SendDirectInitialization();
-
-    for(int pkt_idx = 0; pkt_idx < 5; pkt_idx++)
-    {
-        if(colors_to_send > 16)
-        {
-            SendDirectColorPacket(&colors[colors_sent], 16);
-            colors_sent    += 16;
-            colors_to_send -= 16;
-        }
-        else if(colors_to_send > 0)
-        {
-            SendDirectColorPacket(&colors[colors_sent], colors_to_send);
-            colors_sent    += colors_to_send;
-            colors_to_send -= colors_to_send;
-        }
-        else
-        {
-            RGBColor temp = 0x00000000;
-            SendDirectColorPacket(&temp, 1);
-        }
-    }
-}
-
-void HyperXAlloyOrigins60Controller::SendDirectInitialization()
-{
-    unsigned char buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Direct Initialization packet                   |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x00;
-    buf[0x01]   = 0x04;
-    buf[0x02]   = 0xF2;
-    buf[0x09]   = 0x05;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 65);
-}
-
-void HyperXAlloyOrigins60Controller::SendDirectColorPacket
-    (
-    RGBColor*       color_data,
-    unsigned int    color_count
-    )
-{
-    unsigned char buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Direct Initialization packet                   |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x00;
-
-    /*-----------------------------------------------------*\
-    | The maximum number of colors per packet is 16         |
-    \*-----------------------------------------------------*/
-    if(color_count > 16)
-    {
-        color_count = 16;
-    }
-
-    /*-----------------------------------------------------*\
-    | Copy in color data                                    |
-    \*-----------------------------------------------------*/
-    for(unsigned int color_idx = 0; color_idx < color_count; color_idx++)
-    {
-        buf[(color_idx * 4) + 1] = 0x81;
-        buf[(color_idx * 4) + 2] = RGBGetRValue(color_data[color_idx]);
-        buf[(color_idx * 4) + 3] = RGBGetGValue(color_data[color_idx]);
-        buf[(color_idx * 4) + 4] = RGBGetBValue(color_data[color_idx]);
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 65);
-}

Controllers/HyperXKeyboardController/HyperXAlloyOrigins60Controller.h

@@ -1,39 +0,0 @@
-/*-----------------------------------------*\
-|  HyperXAlloyOrigins60Controller.h         |
-|                                           |
-|  Definitions and types for HyperX Alloy   |
-|  Origins 60 RGB Keyboard lighting         |
-|  controller                               |
-|                                           |
-|  Derek Huber 10/24/2022                   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-class HyperXAlloyOrigins60Controller
-{
-public:
-    HyperXAlloyOrigins60Controller(hid_device* dev_handle, const char* path);
-    ~HyperXAlloyOrigins60Controller();
-
-    std::string     GetDeviceLocation();
-    std::string     GetSerialString();
-
-    void SetLEDsDirect(std::vector<RGBColor> colors);
-
-private:
-    hid_device*             dev;
-    std::string             location;
-
-    void    SendDirectInitialization();
-    void    SendDirectColorPacket
-                (
-                RGBColor*       color_data,
-                unsigned int    color_count
-                );
-};

Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.cpp

@@ -102,7 +102,6 @@ void HyperXAlloyOriginsController::SendDirectInitialization()
     buf[0x00]   = 0x00;
     buf[0x01]   = 0x04;
     buf[0x02]   = 0xF2;
-    buf[0x09]   = 0x09;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |

Controllers/HyperXKeyboardController/HyperXAlloyOriginsCoreController.cpp

@@ -63,19 +63,6 @@ std::string HyperXAlloyOriginsCoreController::GetFirmwareVersion()
     return(firmware_version);
 }
 
-void HyperXAlloyOriginsCoreController::SetBrightness(unsigned int brightness)
-{
-    unsigned char packet[65];
-    memset(packet, 0x00, sizeof(packet));
-
-    packet[1] = 0xA7;
-    packet[4] = 0x01;
-    packet[5] = brightness;
-
-    hid_write(dev, packet, 65);
-}
-
-
 void HyperXAlloyOriginsCoreController::SetLEDsDirect(std::vector<RGBColor> colors)
 {
     for(unsigned int skip_cnt = 0; skip_cnt < (sizeof(skip_idx) / sizeof(skip_idx[0])); skip_cnt++)

Controllers/HyperXKeyboardController/HyperXAlloyOriginsCoreController.h

@@ -26,7 +26,6 @@ public:
     std::string     GetFirmwareVersion();
 
     void SetLEDsDirect(std::vector<RGBColor> colors);
-    void SetBrightness(unsigned int brightness);
 
 private:
     hid_device*     dev;

Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp

@@ -4,38 +4,26 @@
 #include "HyperXAlloyFPSController.h"
 #include "HyperXAlloyOriginsController.h"
 #include "HyperXAlloyOriginsCoreController.h"
-#include "HyperXAlloyOrigins60Controller.h"
 #include "RGBController.h"
 #include "RGBController_HyperXAlloyElite.h"
 #include "RGBController_HyperXAlloyElite2.h"
 #include "RGBController_HyperXAlloyFPS.h"
 #include "RGBController_HyperXAlloyOrigins.h"
 #include "RGBController_HyperXAlloyOriginsCore.h"
-#include "RGBController_HyperXAlloyOrigins60.h"
 #include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
-| HyperX keyboard vendor and product IDs                |
+| HyperX keyboard vendor IDs                            |
 \*-----------------------------------------------------*/
-#define HYPERX_KEYBOARD_VID                        0x0951
-
-#define HYPERX_ALLOY_ELITE_PID                     0x16BE
-#define HYPERX_ALLOY_ELITE_2_PID                   0x1711
-#define HYPERX_ALLOY_FPS_RGB_PID                   0x16DC
-#define HYPERX_ALLOY_ORIGINS_PID                   0x16E5
-#define HYPERX_ALLOY_ORIGINS_CORE_PID              0x16E6
-#define HYPERX_ALLOY_ORIGINS_60_PID                0x1734
-
-/*-----------------------------------------------------*\
-| HyperX keyboard vendor and product IDs (HP)               |
-\*-----------------------------------------------------*/
-#define HP_KEYBOARD_VID                            0x03F0
-
-#define HYPERX_ALLOY_ELITE_2_HP_PID                0x058F
-#define HYPERX_ALLOY_ORIGINS_60_HP_PID             0x0C8E
-#define HYPERX_ALLOY_ORIGINS_CORE_HP_PID           0x098F
-#define HYPERX_ALLOY_ORIGINS_HP_PID                0x0591
+#define HYPERX_KEYBOARD_VID             0x0951
+#define HYPERX_ALLOY_ELITE_PID          0x16BE
+#define HYPERX_ALLOY_ELITE_2_PID        0x1711
+#define HYPERX_ALLOY_FPS_RGB_PID        0x16DC
+#define HYPERX_ALLOY_ORIGINS_PID        0x16E5
+#define HYPERX_ALLOY_ORIGINS_CORE_PID   0x16E6
 
+#define HP_KEYBOARD_VID                 0x03F0
+#define HYPERX_ALLOY_ELITE_2_HP_PID     0x058F
 
 void DetectHyperXAlloyElite(hid_device_info* info, const std::string& name)
 {
@@ -82,7 +70,7 @@ void DetectHyperXAlloyFPS(hid_device_info* info, const std::string& name)
 void DetectHyperXAlloyOrigins(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
-
+    
     if(dev)
     {
         HyperXAlloyOriginsController*     controller     = new HyperXAlloyOriginsController(dev, info->path);
@@ -102,45 +90,21 @@ void DetectHyperXAlloyOriginsCore(hid_device_info* info, const std::string& name
         HyperXAlloyOriginsCoreController*     controller     = new HyperXAlloyOriginsCoreController(dev, info);
         RGBController_HyperXAlloyOriginsCore* rgb_controller = new RGBController_HyperXAlloyOriginsCore(controller);
         rgb_controller->name                                 = name;
-
+        
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
 
-void DetectHyperXAlloyOrigins60(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        HyperXAlloyOrigins60Controller*     controller     = new HyperXAlloyOrigins60Controller(dev, info->path);
-        RGBController_HyperXAlloyOrigins60* rgb_controller = new RGBController_HyperXAlloyOrigins60(controller);
-        rgb_controller->name                             = name;
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite RGB",          DetectHyperXAlloyElite,       HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID,           2, 0xFF01);
-REGISTER_HID_DETECTOR_IP("HyperX Alloy FPS RGB",            DetectHyperXAlloyFPS,         HYPERX_KEYBOARD_VID, HYPERX_ALLOY_FPS_RGB_PID,         2, 0xFF01);
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core",        DetectHyperXAlloyOriginsCore, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_CORE_PID,    2);
-
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core (HP)",   DetectHyperXAlloyOriginsCore, HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_CORE_HP_PID, 2);
+REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite RGB",      DetectHyperXAlloyElite,       HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID,          2, 0xFF01);
+REGISTER_HID_DETECTOR_IP("HyperX Alloy FPS RGB",        DetectHyperXAlloyFPS,         HYPERX_KEYBOARD_VID, HYPERX_ALLOY_FPS_RGB_PID,        2, 0xFF01);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core",    DetectHyperXAlloyOriginsCore, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_CORE_PID,   2);
 
 #ifdef _WIN32
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",             DetectHyperXAlloyOrigins,     HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,         3);
-REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2",            DetectHyperXAlloyElite2,      HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,         3, 0xFF90);
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60",          DetectHyperXAlloyOrigins60,   HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_60_PID,      3);
-
-REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2 (HP)",       DetectHyperXAlloyElite2,      HP_KEYBOARD_VID,     HYPERX_ALLOY_ELITE_2_HP_PID,      3, 0xFF90);
-REGISTER_HID_DETECTOR_IP("HyperX Alloy Origins (HP)",       DetectHyperXAlloyOrigins,     HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_HP_PID,      3, 0xFF90);
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60 (HP)",     DetectHyperXAlloyOrigins60,   HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_60_HP_PID,   3);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",         DetectHyperXAlloyOrigins,     HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,        3);
+REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2",        DetectHyperXAlloyElite2,      HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,        3, 0xFF90);
+REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2 (HP)",   DetectHyperXAlloyElite2,      HP_KEYBOARD_VID,     HYPERX_ALLOY_ELITE_2_HP_PID,     3, 0xFF90);
 #else
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",             DetectHyperXAlloyOrigins,     HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,         0);
-REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2",             DetectHyperXAlloyElite2,      HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,         0);
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60",          DetectHyperXAlloyOrigins60,   HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_60_PID,      0);
-
-REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2 (HP)",        DetectHyperXAlloyElite2,      HP_KEYBOARD_VID,     HYPERX_ALLOY_ELITE_2_HP_PID,      0);
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins (HP)",        DetectHyperXAlloyOrigins,     HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_HP_PID,      0);
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60 (HP)",     DetectHyperXAlloyOrigins60,   HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_60_HP_PID,   0);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",         DetectHyperXAlloyOrigins,     HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,        0);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2",         DetectHyperXAlloyElite2,      HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,        0);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2 (HP)",    DetectHyperXAlloyElite2,      HP_KEYBOARD_VID,     HYPERX_ALLOY_ELITE_2_HP_PID,     0);
 #endif

Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOrigins60.cpp

@@ -1,262 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_HyperXAlloyOrigins60.cpp   |
-|                                           |
-|  Generic RGB Interface for HyperX Alloy   |
-|  Origins 60 RGB Keyboard                  |
-|                                           |
-|  Derek Huber 10/24/2022                   |
-\*-----------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include "RGBController_HyperXAlloyOrigins60.h"
-
-using namespace std::chrono_literals;
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-static unsigned int matrix_map[5][14] =
-    { {   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  15 },
-      {  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29 },
-      {  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  NA,  43 },
-      {  44,  NA,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  NA,  57 },
-      {  58,  59,  60,  61,  NA,  NA,  62,  NA,  NA,  63,  64,  65,  66,  70 } };
-
-
-static const char* zone_names[] =
-{
-    ZONE_EN_KEYBOARD
-};
-
-static zone_type zone_types[] =
-{
-    ZONE_TYPE_MATRIX
-};
-
-static const unsigned int zone_sizes[] =
-{
-    71
-};
-
-static const char *led_names[] =
-{
-    // First row
-    KEY_EN_UNUSED,
-    KEY_EN_ESCAPE,
-    KEY_EN_1,
-    KEY_EN_2,
-    KEY_EN_3,
-    KEY_EN_4,
-    KEY_EN_5,
-    KEY_EN_6,
-    KEY_EN_7,
-    KEY_EN_8,
-    KEY_EN_9,
-    KEY_EN_0,
-    KEY_EN_MINUS,
-    KEY_EN_EQUALS,
-    KEY_EN_UNUSED,
-    KEY_EN_BACKSPACE,
-
-    // Second row
-    KEY_EN_TAB,
-    KEY_EN_Q,
-    KEY_EN_W,
-    KEY_EN_E,
-    KEY_EN_R,
-    KEY_EN_T,
-    KEY_EN_Y,
-    KEY_EN_U,
-    KEY_EN_I,
-    KEY_EN_O,
-    KEY_EN_P,
-    KEY_EN_LEFT_BRACKET,
-    KEY_EN_RIGHT_BRACKET,
-    KEY_EN_ANSI_BACK_SLASH,
-
-    // Third row
-    KEY_EN_CAPS_LOCK,
-    KEY_EN_A,
-    KEY_EN_S,
-    KEY_EN_D,
-    KEY_EN_F,
-    KEY_EN_G,
-    KEY_EN_H,
-    KEY_EN_J,
-    KEY_EN_K,
-    KEY_EN_L,
-    KEY_EN_SEMICOLON,
-    KEY_EN_QUOTE,
-    KEY_EN_UNUSED,
-    KEY_EN_ANSI_ENTER,
-
-    // Fourth row
-    KEY_EN_LEFT_SHIFT,
-    KEY_EN_UNUSED,
-    KEY_EN_Z,
-    KEY_EN_X,
-    KEY_EN_C,
-    KEY_EN_V,
-    KEY_EN_B,
-    KEY_EN_N,
-    KEY_EN_M,
-    KEY_EN_COMMA,
-    KEY_EN_PERIOD,
-    KEY_EN_FORWARD_SLASH,
-    KEY_EN_UNUSED,
-    KEY_EN_RIGHT_SHIFT,
-
-    // Fifth row
-    KEY_EN_LEFT_CONTROL,
-    KEY_EN_LEFT_WINDOWS,
-    KEY_EN_LEFT_ALT,
-    KEY_EN_UNUSED,
-    KEY_EN_SPACE,
-    KEY_EN_UNUSED,
-    KEY_EN_RIGHT_ALT,
-    KEY_EN_MENU,
-    KEY_EN_RIGHT_CONTROL,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_RIGHT_FUNCTION
-};
-
-/**------------------------------------------------------------------*\
-    @name HyperX Alloy Origins 60
-    @category Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectHyperXAlloyOrigins60
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_HyperXAlloyOrigins60::RGBController_HyperXAlloyOrigins60(HyperXAlloyOrigins60Controller* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "HyperX Alloy Origins 60 Keyboard Device";
-    vendor      = "HyperX";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "HyperX Alloy Origins 60 Keyboard Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0xFFFF;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-
-    keepalive_thread_run = 1;
-    keepalive_thread = new std::thread(&RGBController_HyperXAlloyOrigins60::KeepaliveThread, this);
-}
-
-RGBController_HyperXAlloyOrigins60::~RGBController_HyperXAlloyOrigins60()
-{
-    keepalive_thread_run = 0;
-    keepalive_thread->join();
-    delete keepalive_thread;
-
-    /*---------------------------------------------------------*\
-    | Delete the matrix map                                     |
-    \*---------------------------------------------------------*/
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        if(zones[zone_index].matrix_map != NULL)
-        {
-            delete zones[zone_index].matrix_map;
-        }
-    }
-
-    delete controller;
-}
-
-void RGBController_HyperXAlloyOrigins60::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    unsigned int total_led_count = 0;
-    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
-    {
-        zone new_zone;
-        new_zone.name                   = zone_names[zone_idx];
-        new_zone.type                   = zone_types[zone_idx];
-        new_zone.leds_min               = zone_sizes[zone_idx];
-        new_zone.leds_max               = zone_sizes[zone_idx];
-        new_zone.leds_count             = zone_sizes[zone_idx];
-
-        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
-        {
-            new_zone.matrix_map         = new matrix_map_type;
-            new_zone.matrix_map->height = 5;
-            new_zone.matrix_map->width  = 14;
-            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
-        }
-        else
-        {
-            new_zone.matrix_map         = NULL;
-        }
-
-        zones.push_back(new_zone);
-
-        total_led_count += zone_sizes[zone_idx];
-    }
-
-    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
-    {
-        led new_led;
-        new_led.name = led_names[led_idx];
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_HyperXAlloyOrigins60::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_HyperXAlloyOrigins60::DeviceUpdateLEDs()
-{
-    controller->SetLEDsDirect(colors);
-}
-
-void RGBController_HyperXAlloyOrigins60::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_HyperXAlloyOrigins60::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_HyperXAlloyOrigins60::DeviceUpdateMode()
-{
-
-}
-
-void RGBController_HyperXAlloyOrigins60::KeepaliveThread()
-{
-    while(keepalive_thread_run.load())
-    {
-        if(active_mode == 0)
-        {
-            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50))
-            {
-                UpdateLEDs();
-            }
-        }
-        std::this_thread::sleep_for(10ms);;
-    }
-}

Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOrigins60.h

@@ -1,39 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_HyperXAlloyOrigins60.h     |
-|                                           |
-|  Generic RGB Interface for HyperX Alloy   |
-|  Origins 60 RGB Keyboard                  |
-|                                           |
-|  Derek Huber 10/24/2022                   |
-\*-----------------------------------------*/
-
-#pragma once
-#include <chrono>
-
-#include "RGBController.h"
-#include "HyperXAlloyOrigins60Controller.h"
-
-class RGBController_HyperXAlloyOrigins60 : public RGBController
-{
-public:
-    RGBController_HyperXAlloyOrigins60(HyperXAlloyOrigins60Controller* controller_ptr);
-    ~RGBController_HyperXAlloyOrigins60();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-    void        KeepaliveThread();
-
-private:
-    HyperXAlloyOrigins60Controller*                     controller;
-    std::thread*                                        keepalive_thread;
-    std::atomic<bool>                                   keepalive_thread_run;
-    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
-};