Handle zero in ENE config table

add support for Asus ROG STRIX RTX3080 GUNDAM EDITION
Updating Debian version to conform with expected numbering for upgrades
2023-02-16 19:27:06 -08:00 · 2023-02-15 22:29:17 +00:00 · 2023-02-15 02:58:33 +00:00 · 2023-02-14 01:23:55 +00:00 · 2023-02-11 21:25:54 +00:00 · 2023-02-08 22:30:28 +11:00
409 changed files with 38826 additions and 11480 deletions
@@ -6,6 +6,8 @@ OpenRGB
 openrgb
 OpenRGB-x86_64.AppImage
 60-openrgb.rules
+debian/changelog
+fedora/OpenRGB.spec

 # Directories
 .build/
@@ -43,6 +43,7 @@ before_script:
    name: "${CI_PROJECT_NAME}_Supported_Devices_${CI_COMMIT_SHORT_SHA}"
    paths:
    - ./*.md
+    - Supported Devices.csv
    exclude:
    - README.md
    - CONTRIBUTING.md
@@ -108,9 +109,10 @@ 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:
@@ -118,7 +120,7 @@ before_script:
    paths:
    - openrgb*.deb
    exclude:
-    - openrgb-dbgsym*.deb
+    - openrgb-dbgsym*.*deb
    expire_in: 30 days

  rules:
@@ -136,9 +138,10 @@ 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:
@@ -146,7 +149,7 @@ before_script:
    paths:
    - openrgb*.deb
    exclude:
-    - openrgb-dbgsym*.deb
+    - openrgb-dbgsym*.*deb
    expire_in: 30 days

  rules:
@@ -164,9 +167,10 @@ 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:
@@ -174,7 +178,7 @@ before_script:
    paths:
    - openrgb*.deb
    exclude:
-    - openrgb-dbgsym*.deb
+    - openrgb-dbgsym*.*deb
    expire_in: 30 days

  rules:
@@ -192,9 +196,10 @@ 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:
@@ -202,7 +207,7 @@ before_script:
    paths:
    - openrgb*.deb
    exclude:
-    - openrgb-dbgsym*.deb
+    - openrgb-dbgsym*.*deb
    expire_in: 30 days

  rules:
@@ -220,6 +225,7 @@ 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
@@ -248,6 +254,7 @@ 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
@@ -277,6 +284,7 @@ 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
@@ -309,8 +317,9 @@ before_script:
  image: fedora:36
  stage: build
  script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel -y
+  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-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
@@ -346,7 +355,6 @@ 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)"
@@ -363,7 +371,6 @@ 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)"
@@ -380,7 +387,6 @@ 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)"
@@ -397,7 +403,6 @@ 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)"
@@ -414,7 +419,6 @@ 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)"
@@ -431,7 +435,6 @@ 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)"
@@ -448,7 +451,6 @@ 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)"
@@ -465,7 +467,6 @@ 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)"
@@ -481,7 +482,6 @@ before_script:
  script:
  - yum -y localinstall ./openrgb*64.rpm
  - openrgb --version
-  - openrgb -l
  - yum -y remove openrgb
  dependencies:
  - "Linux 64 f35 rpm"
@@ -497,7 +497,6 @@ before_script:
  script:
  - yum -y localinstall ./openrgb*64.rpm
  - openrgb --version
-  - openrgb -l
  - yum -y remove openrgb
  dependencies:
  - "Linux 64 f36 rpm"
@@ -529,9 +528,9 @@ before_script:
  - mkdir _qt
  - mkdir _qt_download
  - Push-Location _qt_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'
+  - 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'
  - _fold_final_

  - _fold_start_ 'extracting the downloaded qt binaries'
@@ -547,10 +546,6 @@ 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
@@ -609,9 +604,9 @@ before_script:
  - mkdir _qt
  - mkdir _qt_download
  - Push-Location _qt_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'
+  - 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'
  - _fold_final_

  - _fold_start_ 'extracting the downloaded qt binaries'
@@ -627,10 +622,6 @@ 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
@@ -0,0 +1,10 @@
+{
+    // 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"
+    ]
+}
@@ -17,8 +17,6 @@ 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;
@@ -33,8 +31,6 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
    current_ring_speed          = 0xFF;
    current_ring_direction      = false;
    current_ring_brightness     = 0xFF;
-
-    SendEnableCommand();
 }

 AMDWraithPrismController::~AMDWraithPrismController()
@@ -47,11 +43,6 @@ std::string AMDWraithPrismController::GetLocationString()
    return("HID: " + location);
 }

-char* AMDWraithPrismController::GetDeviceName()
-{
-    return device_name;
-}
-
 std::string AMDWraithPrismController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -68,41 +59,6 @@ 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 = "";
@@ -232,7 +188,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()
+void AMDWraithPrismController::SendEnableCommand(bool direct)
 {
    unsigned char usb_buf[] =
    {
@@ -255,6 +211,11 @@ void AMDWraithPrismController::SendEnableCommand()
        0x00, 0x00, 0x00, 0x00,
    };

+    if(direct)
+    {
+        usb_buf[0x02]   = 0x03;
+    }
+
    hid_write(dev, usb_buf, 65);
    hid_read(dev, usb_buf, 64);
 }
@@ -286,6 +247,48 @@ 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,
@@ -10,6 +10,8 @@
 #include <string>
 #include <hidapi/hidapi.h>

+#include "RGBController.h"
+
 #pragma once

 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX     0xFF
@@ -74,6 +76,7 @@ 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
@@ -91,29 +94,11 @@ 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;
@@ -130,10 +115,30 @@ private:
    bool                    current_ring_direction;
    bool                    current_ring_random_color;

-    void SendEnableCommand();
+    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 SendApplyCommand();

+private:
+    hid_device*             dev;
+    std::string             location;
+
+    void SetRingEffectChannel(unsigned char channel);
+
    void SendEffectChannelUpdate
        (
        unsigned char effect_channel,
@@ -33,33 +33,29 @@ 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_STATIC;
+    Direct.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT;
    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
    Direct.brightness_min       = 0;
-    Direct.brightness_max       = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Direct.brightness           = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Direct.brightness_max       = 0;
+    Direct.brightness           = 0;
    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_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_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_PER_LED;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
    Breathing.speed             = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Breathing.colors.resize(3);
    modes.push_back(Breathing);

    mode ColorCycle;
@@ -104,27 +100,29 @@ 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_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Chase.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_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_PER_LED;
+    Chase.color_mode            = MODE_COLORS_MODE_SPECIFIC;
    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_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Swirl.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_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_PER_LED;
+    Swirl.color_mode            = MODE_COLORS_MODE_SPECIFIC;
    Swirl.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Swirl.colors.resize(3);
    modes.push_back(Swirl);

    SetupZones();
@@ -137,6 +135,14 @@ 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                                              |
    \*---------------------------------------------------------*/
@@ -160,27 +166,39 @@ void RGBController_AMDWraithPrism::SetupZones()

    zone ring_zone;
    ring_zone.name          = "Ring";
-    ring_zone.type          = ZONE_TYPE_SINGLE;
-    ring_zone.leds_min      = 1;
-    ring_zone.leds_max      = 1;
-    ring_zone.leds_count    = 1;
+    ring_zone.type          = ZONE_TYPE_LINEAR;
+    ring_zone.leds_min      = 14;
+    ring_zone.leds_max      = 14;
+    ring_zone.leds_count    = 14;
    ring_zone.matrix_map    = NULL;
    zones.push_back(ring_zone);

    /*---------------------------------------------------------*\
    | Set up LEDs                                               |
    \*---------------------------------------------------------*/
-    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 logo_led;
+        logo_led.name = "Logo LED";
+        logo_led.value = logo_leds[led_idx];
+        leds.push_back(logo_led);
+    }

-    led fan_led;
-    fan_led.name = "Fan LED";
-    leds.push_back(fan_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 ring_led;
-    ring_led.name = "Ring LED";
-    leds.push_back(ring_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);
+    }

    SetupColors();
 }
@@ -194,68 +212,95 @@ void RGBController_AMDWraithPrism::ResizeZone(int /*zone*/, int /*new_size*/)

 void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
 {
-    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)
+    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
    {
+        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);
-    }
-    else if(zone == 1)
-    {
+
+        red = RGBGetRValue(modes[active_mode].colors[1]);
+        grn = RGBGetGValue(modes[active_mode].colors[1]);
+        blu = RGBGetBValue(modes[active_mode].colors[1]);
        controller->SetFanColor(red, grn, blu);
-    }
-    else if(zone == 2)
-    {
+
+        red = RGBGetRValue(modes[active_mode].colors[2]);
+        grn = RGBGetGValue(modes[active_mode].colors[2]);
+        blu = RGBGetBValue(modes[active_mode].colors[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::UpdateSingleLED(int led)
+void RGBController_AMDWraithPrism::UpdateZoneLEDs(int /*zone*/)
 {
-    UpdateZoneLEDs(led);
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AMDWraithPrism::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
 }

 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;
@@ -263,11 +308,15 @@ 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);
            }
@@ -5,18 +5,22 @@
 |  lighting controller                      |
 |                                           |
 |  Ed Kambulow (dredvard) 12/20/2020        |
+|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/
-
-#include "RGBController.h"
-#include "ASRockPolychromeUSBController.h"
 #include <cstring>
 #include <stdio.h>
+
+#include "RGBController.h"
+#include "ResourceManager.h"
+#include "ASRockPolychromeUSBController.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

@@ -29,7 +33,7 @@ const char* polychrome_USB_zone_names[] =
    "PCH",
    "IO Cover",
    "PCB",
-    "Audio",
+    "Addressable Header 3/Audio",
 };

 PolychromeUSBController::PolychromeUSBController(hid_device* dev_handle, const char* path)
@@ -82,19 +86,64 @@ 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)
+        if(configtable[zonecnt] == 0x1E || !((configtable[9] >> zonecnt) & 1))
        {
 			/*-----------------------------------------------------------------------*\
 			| 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. |
@@ -108,6 +157,11 @@ 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;

@@ -117,10 +171,9 @@ 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                               |
            \*-----------------------------------------*/
@@ -133,6 +186,26 @@ 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
@@ -163,8 +236,18 @@ void PolychromeUSBController::WriteZone
 	usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
    usb_buf[0x03] = device_info.zone_type; 
 	usb_buf[0x04] = mode;
-	usb_buf[0x05] = RGBGetRValue(rgb);
-	usb_buf[0x06] = RGBGetGValue(rgb);
+
+    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[0x07] = RGBGetBValue(rgb);
 	usb_buf[0x08] = speed;
 	usb_buf[0x09] = 0xFF;
@@ -183,63 +266,122 @@ void PolychromeUSBController::WriteAllZones
    const std::vector<zone>&                zones
    )
 {
-    unsigned char usb_buf[65];
+    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 message packet with leading 00                  |
+    | Set up initial message packet with leading 00         |
    \*-----------------------------------------------------*/
    usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
-    usb_buf[0x03] = 0x07;
-    usb_buf[0x04] = zones_info[0].mode;
-    usb_buf[0x04] = 0xE2;
+    usb_buf[0x03] = 0xFF;
+    usb_buf[0x04] = POLYCHROME_USB_INITIAL_CHUNK;
+    usb_buf[0x07] = 0xFF;
+    usb_buf[0x40] = 0x65;

-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    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())
    {
-        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]);
+        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);
    }
-    
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
 }

 void PolychromeUSBController::WriteRGSwap
    (
-    bool ahdr1,
-    bool ahdr0,
+    bool hdr0,
    bool hdr1,
-    bool hdr0
+    bool ahdr0,
+    bool ahdr1,
+    bool pch,
+    bool io,
+    bool pcb,
+    bool chnl8
    )
 {
-    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);
+    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);
 }

 void PolychromeUSBController::WriteHeader
@@ -309,8 +451,23 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
    g   = usb_buf[0x06];
    b   = usb_buf[0x07];

-    zoneinfo.mode   = usb_buf[0x04] != 0xE2 ? usb_buf[0x04] : 0x0F;
-    zoneinfo.color  = ToRGBColor(r,g,b);  
+    /*------------------------------------------------------*\
+    | 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.speed  = usb_buf[0x08];
    zoneinfo.zone   = usb_buf[0x03];

@@ -321,7 +478,7 @@ void PolychromeUSBController::ReadConfigTables()
 {
    unsigned char usb_buf[65];
    unsigned char maxzoneleds[8];
-    unsigned char rgbswap;
+    unsigned char rgswap;
    unsigned char header1;

    /*-----------------------------------------------------*\
@@ -348,7 +505,7 @@ void PolychromeUSBController::ReadConfigTables()

    /*-----------------------------------------------------*\
    | Reads in format: RGB1, RGB2, ARGB1, ARGB2, PCH, IO,   |
-    | PCB, AUDIO                                            |
+    | PCB, AUDIO/ARGB3                                      |
    \*-----------------------------------------------------*/
    memcpy(&maxzoneleds,&usb_buf[0x04],8);

@@ -368,10 +525,10 @@ void PolychromeUSBController::ReadConfigTables()
    hid_read(dev, usb_buf, 64);

    /*-----------------------------------------------------*\
-    | Reads bitwise in format: AUDIO, PCB, IO, PCH, ARGB2,  |
-    | ARGB1, RGB2, RGB1 if available                        |
+    | Reads bitwise in format: AUDIO/ARGB3, PCB, IO, PCH,   |
+    | ARGB2,ARGB1, RGB2, RGB1 if available                  |
    \*-----------------------------------------------------*/
-    rgbswap=usb_buf[4];
+    rgswap=usb_buf[4];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -387,10 +544,15 @@ 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]=rgbswap;
+    configtable[8]=rgswap;
    configtable[9]=header1;
    return;
 }
@@ -5,6 +5,7 @@
 |  lighting controller                      |
 |                                           |
 |  Ed Kambulow (dredvard) 12/20/2020        |
+|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/

 #include "RGBController.h"
@@ -69,7 +70,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
+    POLYCHROME_USB_ZONE_AUDIO        = 0X07   // AUDIO/ARGB Header 3
 };

 enum class PolychromeDeviceType
@@ -91,6 +92,7 @@ struct PolychromeDeviceInfo
    unsigned char           effect_channel;
    unsigned char           num_leds;
 	unsigned char			zone_type;
+    bool        			rgswap;
    PolychromeDeviceType    device_type;
 };

@@ -131,17 +133,31 @@ 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 ahdr1, bool ahdr0, bool hdr1, bool hdr0);
+    void WriteRGSwap
+        (
+        bool hdr0,
+        bool hdr1,
+        bool ahdr0,
+        bool ahdr1,
+        bool pch,
+        bool io,
+        bool pcb,
+        bool chnl8
+        );

 private:
    unsigned int  led_count;
    std::string   device_name;
    unsigned char configtable[12];
+    bool          rgswapconfig[8] = { 0 };

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

 #include "RGBController_ASRockPolychromeUSB.h"
@@ -22,7 +23,6 @@
    @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,11 +181,6 @@ RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController
    modes.push_back(Direct);

    SetupZones();
-
-    /*-------------------------------------------------*\
-    | Initialize active mode                            |
-    \*-------------------------------------------------*/
-    active_mode = GetDeviceMode(1);
 }

 void RGBController_PolychromeUSB::SetupZones()
@@ -238,16 +233,6 @@ 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               |
@@ -259,26 +244,37 @@ 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;
-
-    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));
+    controller->ResizeZone(zones_info[zone].zone, new_size);
 }

 void RGBController_PolychromeUSB::DeviceUpdateLEDs()
@@ -338,6 +334,12 @@ 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)
@@ -5,6 +5,7 @@
 |  ASRock Polychrome USB Driver             |
 |                                           |
 |  Ed Kambulow (Dredvard) 12/26/2020        |
+|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/

 #pragma once
@@ -592,13 +592,14 @@ void AlienwareController::SetColor(uint8_t zone, RGBColor color)

 void AlienwareController::SetColor(uint8_t zone, RGBColor color1, RGBColor color2)
 {
-    dirty = ((color1 != zones[zone].color[0]) || (color2 != zones[zone].color[1]));
+    if ((color1 == zones[zone].color[0]) && (color2 == zones[zone].color[1]))
+    {
+        return;
+    }

-	if(dirty)
-	{
-		zones[zone].color[0] = color1;
-        zones[zone].color[1] = color2;
-	}
+    zones[zone].color[0] = color1;
+    zones[zone].color[1] = color2;
+    dirty = true;
 }

 void AlienwareController::SetPeriod(uint8_t zone, uint16_t period)
@@ -65,7 +65,12 @@ 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);
@@ -86,38 +91,45 @@ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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);
@@ -67,15 +67,17 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
            break;

        case 1:
+        case 2:
            {
                char version[9];
-                int offset = (wireless ? 13 : 4);
+                int wireless_offset = (protocol == 2 ? 14 : 13);
+                int offset = (wireless ? wireless_offset : 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 2:
+        case 3:
            {
                unsigned char* offset = usb_buf_out + (wireless ? 13 : 4);
                str = std::string(offset, offset + 4);
@@ -83,7 +85,7 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
            }
            break;

-        case 3:
+        case 4:
            {
                char version[16];
                int offset = (wireless ? 13 : 4);
@@ -18,12 +18,15 @@
 #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
@@ -174,6 +177,19 @@ 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
        {
@@ -252,6 +268,32 @@ 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
        {
@@ -299,7 +341,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
            0,
            4,
            false,
-            3,
+            4,
            { AURA_MOUSE_ZONE_LOGO },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM }
        }
@@ -455,7 +497,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
            0,
            4,
            false,
-            2,
+            3,
            { AURA_MOUSE_ZONE_LOGO },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
        }
@@ -17,11 +17,12 @@
 #include <string.h>
 #include <cmath>

-AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid)
+AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short rev_version)
 {
    dev         = dev_handle;
    location    = path;
    device_pid  = pid;
+    version     = rev_version;
 }

 AuraTUFKeyboardController::~AuraTUFKeyboardController()
@@ -52,57 +53,161 @@ std::string AuraTUFKeyboardController::GetSerialString()

 std::string AuraTUFKeyboardController::GetVersion()
 {
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x12;
-    usb_buf[0x02]   = 0x00;
-
-    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)
+    if(device_pid != AURA_ROG_CLAYMORE_PID)
    {
-        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
+        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
    {
-        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
+        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);
    }
-    
-    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]   = 0x12;
-    usb_buf[0x02]   = 0x12;

+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x40;
+    usb_buf[0x02]   = 0x60;
+
+    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]);
+    return(usb_buf_out[5] * 2 + usb_buf_out[4]);
 }

 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
@@ -117,11 +222,10 @@ 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;
@@ -129,70 +233,48 @@ void AuraTUFKeyboardController::UpdateSingleLed
    /*-----------------------------------------------------*\
    | Convert LED index                                     |
    \*-----------------------------------------------------*/
-    usb_buf[5] = floor(led/6)*8 + led%6;
+    usb_buf[5] = led;
    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<RGBColor>    colors
+    std::vector<led_color>    colors
    )
 {
-    /*-----------------------------------------------------*\
-    | Loop over every column (optimisation needed)          |
-    \*-----------------------------------------------------*/
-    for(unsigned int i = 0; i < 192; i += 16)
-    {
-        unsigned char usb_buf[69];
+    int packets = ceil((float) colors.size() / 15);

+    for(int i = 0; i < packets; i++)
+    {
+        unsigned char usb_buf[65];
        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] = (138 - i / 16 * 12);
+        usb_buf[3] = leds;
        usb_buf[4] = 0x00;

-        for(unsigned int n = 0; n < 6; n++)
+        for(int j = 0; j < leds; j++)
        {
-            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]);
+            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);
        }
-
-        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);
+        ClearResponses();
+        hid_write(dev, usb_buf, 65);
+        AwaitResponse(20);
    }
 }

@@ -200,75 +282,168 @@ void AuraTUFKeyboardController::UpdateDevice
    (
    unsigned char           mode,
    std::vector<RGBColor>   colors,
-    unsigned char           dir,
+    unsigned char           direction,
    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(mode == 4 || mode == 5)
+    if(device_pid != AURA_ROG_CLAYMORE_PID)
    {
-        /*-----------------------------------------------------*\
-        | If mode is Rainbow or Ripple                          |
-        \*-----------------------------------------------------*/
-        usb_buf[0x0A]   = colors.size();
+        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;

-        /*-----------------------------------------------------*\
-        | Loop over every color given                           |
-        \*-----------------------------------------------------*/
-        for(unsigned int i = 0; i / 4 < colors.size(); i += 4)
+        if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
        {
-            if(colors[i / 4])
+            usb_buf[0x0A]   = colors.size();
+
+            /*-----------------------------------------------------*\
+            | Loop over every color given                           |
+            \*-----------------------------------------------------*/
+            for(unsigned int i = 0; i < colors.size(); 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]);
+                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]);
+                }
            }
        }
+        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
    {
-        /*-----------------------------------------------------*\
-        | Loop over Color1, Color2 and Background if there      |
-        \*-----------------------------------------------------*/
-        for(unsigned int i = 0; i / 3 != colors.size(); i += 3)
+        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)
        {
-            if(colors[i / 3])
+            UpdateQuicksandColors(colors);
+        }
+        else
+        {
+            if(mode == 4 && color_mode == 0)
            {
-                usb_buf[10 + i] = RGBGetRValue(colors[i/3]);
-                usb_buf[11 + i] = RGBGetGValue(colors[i/3]);
-                usb_buf[12 + i] = RGBGetBValue(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]);
+                }
            }
        }
-            
+
+        for(int i = 1; i < 5; i++)
+        {
+            usb_buf[5 + i * 12] = 0xFF;
+        }
    }

-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
+    ClearResponses();
    hid_write(dev, usb_buf, 65);
+    AwaitResponse(20);
 }

-void AuraTUFKeyboardController::AwaitResponse()
+/*---------------------------------------------------------*\
+| 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)
 {
    unsigned char usb_buf_out[65];
-    hid_read(dev, usb_buf_out, 65);
+    hid_read_timeout(dev, usb_buf_out, 65, ms);
 }

 void AuraTUFKeyboardController::ClearResponses()
@@ -277,7 +452,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);
    }
 }

@@ -16,14 +16,6 @@

 #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,
@@ -41,22 +33,32 @@ 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);
+    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short rev_version);
    ~AuraTUFKeyboardController();

    std::string GetDeviceLocation();
    std::string GetSerialString();
    std::string GetVersion();
    int         GetLayout();
+    int         GetNumpadLocation();
    void        SaveMode();
+    void        AllowRemoteControl(unsigned char type);

    void UpdateSingleLed
        (
@@ -68,7 +70,7 @@ public:

    void UpdateLeds
        (
-        std::vector<RGBColor>    colors
+        std::vector<led_color>    colors
        );

    void UpdateDevice
@@ -80,7 +82,9 @@ public:
        unsigned char           speed,
        unsigned char           brightness
        );
-    void AwaitResponse();
+    void UpdateQuicksandColors(std::vector<RGBColor> colors);
+    void UpdateMode(unsigned char mode);
+    void AwaitResponse(int ms);
    void ClearResponses();

    uint16_t                    device_pid;
@@ -88,5 +92,6 @@ public:
 private:
    hid_device*                 dev;
    std::string                 location;
+    unsigned short              version;
 };

@@ -44,9 +44,12 @@
 #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

@@ -67,6 +70,7 @@
 \*-----------------------------------------------------------------*/

 #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

@@ -91,6 +95,7 @@ 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:
@@ -100,12 +105,9 @@ 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;
    }
@@ -258,7 +260,7 @@ void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name

    if(dev)
    {
-        AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id);
+        AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number);
        RGBController_AuraTUFKeyboard* rgb_controller       = new RGBController_AuraTUFKeyboard(controller);
        rgb_controller->name                                = name;
        ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -292,13 +294,16 @@ 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);

@@ -312,12 +317,15 @@ 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);
@@ -347,6 +355,7 @@ 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);

@@ -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;

-    uint16_t pid            = controller->device_pid;
+    pid = controller->device_pid;

    name                    = "ASUS Aura Mouse";
    vendor                  = "ASUS";
@@ -168,8 +168,6 @@ 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;
@@ -209,7 +207,7 @@ void RGBController_AuraMouse::DeviceUpdateLEDs()

 void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
 {
-    UpdateSingleLED(zone);
+    DeviceUpdateLEDs();
 }

 void RGBController_AuraMouse::UpdateSingleLED(int led)
@@ -30,4 +30,5 @@ public:

 private:
    AuraMouseController*  controller;
+    uint16_t              pid;
 };
@@ -24,178 +24,314 @@

 RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr)
 {
-    controller  = controller_ptr;
+    controller = controller_ptr;

-    name        = "ASUS Aura Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "ASUS Aura Keyboard Device";
-    version     = controller->GetVersion();
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
+    pid = controller->device_pid;

-    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);
+    const unsigned char AURA_KEYBOARD_SPEED_MIN = (pid == AURA_ROG_FALCHION_WIRED_PID || pid == AURA_ROG_FALCHION_WIRELESS_PID) ? 255 : 15;

-    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);
+    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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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);
+        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);
+    }

    SetupZones();
 }
@@ -207,10 +343,48 @@ RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()

 void RGBController_AuraTUFKeyboard::SetupZones()
 {
-    int layout = controller->GetLayout();
+    unsigned char layout = controller->GetLayout();

-    if(AsusTUFK7Layouts.find(layout % 100) == AsusTUFK7Layouts.end())
+    std::map<int,layout_info> * keyboard_ptr;
+
+    switch(pid)
    {
+        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
@@ -218,33 +392,32 @@ void RGBController_AuraTUFKeyboard::SetupZones()
        layout = layout % 100;
    }

-    unsigned int total_led_count = 0;
+    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);

-    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++)
+    for(int led_id = 0; led_id < keyboard[layout].size; led_id++)
    {
        led new_led;
-        new_led.name = AsusTUFK7Layouts[layout].led_names[led_idx];
+        new_led.name  = keyboard[layout].led_names[led_id].name;
+        new_led.value = keyboard[layout].led_names[led_id].id;
        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*/)
@@ -254,12 +427,19 @@ void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)

 void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
 {
-    DeviceUpdateMode();
+    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);
 }

 void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
 {
-    controller->UpdateLeds(colors);
+    DeviceUpdateLEDs();
 }

 void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
@@ -268,72 +448,100 @@ void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
    unsigned char green = RGBGetGValue(colors[led]);
    unsigned char blue  = RGBGetBValue(colors[led]);

-    controller->UpdateSingleLed(led, red, green, blue);
+    controller->UpdateSingleLed(leds[led].value, 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()
 {
-    unsigned char color_mode;
-    std::vector<RGBColor> mode_colors;
+    if(pid == AURA_ROG_CLAYMORE_PID)
+    {
+        controller->AllowRemoteControl(1);
+    }
+
+    unsigned char color_mode    = 0;
+    unsigned char direction     = 0;
+    unsigned char brightness    = 0;

    if(modes[active_mode].value == AURA_KEYBOARD_MODE_DIRECT)
    {
-        controller->UpdateLeds(colors);
+        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];
+        }
    }
    else
    {
-        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)
+        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
        {
-            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;
+            color_mode = 1;
        }

-        int direction = 0;
+        if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE) {
+            if (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) color_mode = 2;

-        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;
+            /*----------------------------------------------------------*\
+            | converting openrgb direction value to keyboard directions  |
+            \*----------------------------------------------------------*/
+            direction = direction_map[1][modes[active_mode].direction];
        }
+    }

-        mode_colors = modes[active_mode].color_mode == MODE_COLORS_PER_LED ? std::vector<RGBColor>(colors) : std::vector<RGBColor>(modes[active_mode].colors);
+    controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), direction, color_mode, modes[active_mode].speed, brightness);

-        controller->UpdateDevice(modes[active_mode].value, mode_colors, direction, color_mode, (15 - modes[active_mode].speed), modes[active_mode].brightness * 25);
+    if(pid == AURA_ROG_CLAYMORE_PID)
+    {
+        controller->UpdateMode(modes[active_mode].value);
+        controller->SaveMode();
+        controller->AllowRemoteControl(0);
    }
 }

 void RGBController_AuraTUFKeyboard::DeviceSaveMode()
 {
-    controller->ClearResponses();
-    DeviceUpdateMode();
-    controller->AwaitResponse();
-    controller->SaveMode();
+    /*----------------------------------------------------------*\
+    | not available for Claymore                                 |
+    \*----------------------------------------------------------*/
+    if(pid != AURA_ROG_CLAYMORE_PID)
+    {
+        DeviceUpdateMode();
+        controller->SaveMode();
+    }
 }
@@ -13,12 +13,26 @@

 enum
 {
-    AURA_KEYBOARD_SPEED_MIN          = 0,
-    AURA_KEYBOARD_SPEED_MAX          = 15,
+    AURA_KEYBOARD_SPEED_MAX          = 0,
    AURA_KEYBOARD_SPEED_DEFAULT      = 8,
    AURA_KEYBOARD_BRIGHTNESS_MIN     = 0,
    AURA_KEYBOARD_BRIGHTNESS_MAX     = 4,
-    AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 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,
+
 };

 class RGBController_AuraTUFKeyboard : public RGBController
@@ -40,4 +54,5 @@ public:

 private:
    AuraTUFKeyboardController*  controller;
+    uint16_t                    pid;
 };
@@ -0,0 +1,198 @@
+/*-----------------------------------------*\
+|  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);
+}
@@ -0,0 +1,51 @@
+/*-----------------------------------------*\
+|  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;
+};
@@ -1,6 +1,8 @@
 #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>
@@ -8,8 +10,22 @@

 #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);
@@ -23,4 +39,6 @@ void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
    }
 }

-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 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);
@@ -0,0 +1,391 @@
+/*-----------------------------------------*\
+|  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);
+}
@@ -0,0 +1,39 @@
+/*-----------------------------------------*\
+|  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;
+};
@@ -7,7 +7,7 @@
 #include "wmi.h"
 #include <string>

-static void DetectAsusTUFLaptopWMIControllers(std::vector<RGBController*>&)
+static void DetectAsusTUFLaptopWMIControllers()
 {
    // 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
@@ -0,0 +1,51 @@
+#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);
+}
@@ -0,0 +1,37 @@
+#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
@@ -0,0 +1,28 @@
+#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);
@@ -0,0 +1,150 @@
+#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();
+}
@@ -0,0 +1,27 @@
+#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
@@ -19,7 +19,7 @@
 *                                                                                          *
 \******************************************************************************************/

-void DetectBlinkyTapeControllers(std::vector<RGBController*> &rgb_controllers)
+void DetectBlinkyTapeControllers()
 {
    std::vector<std::string *> device_locations = find_usb_serial_port(BLINKINLABS_VID, BLINKYTAPE_PID);

@@ -29,7 +29,7 @@ void DetectBlinkyTapeControllers(std::vector<RGBController*> &rgb_controllers)
        controller->Initialize(*device_locations[device_idx]);

        RGBController_BlinkyTape* rgb_controller = new RGBController_BlinkyTape(controller);
-        rgb_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
 }

@@ -0,0 +1,44 @@
+#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);
+}
@@ -0,0 +1,24 @@
+#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;
+};
@@ -0,0 +1,47 @@
+#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);
@@ -0,0 +1,82 @@
+#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();
+}
@@ -0,0 +1,26 @@
+#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;
+
+};
+
+
@@ -44,6 +44,7 @@
 \*-----------------------------------------------------*/
 #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

@@ -93,7 +94,7 @@ void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
    }
 }

-void DetectCoolerMasterARGBGen2A1(hid_device_info* info, const std::string&)
+void DetectCoolerMasterARGBGen2A1(hid_device_info* info, const std::string& name)
 {
    hid_device* dev = hid_open_path(info->path);

@@ -101,7 +102,7 @@ void DetectCoolerMasterARGBGen2A1(hid_device_info* info, const std::string&)
    {
        CMARGBGen2A1controller*               controller     = new CMARGBGen2A1controller(dev, *info);
        RGBController_CMARGBGen2A1Controller* rgb_controller = new RGBController_CMARGBGen2A1Controller(controller);
-        // Constructor sets the name
+        rgb_controller->name                                 = name;
        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
 }
@@ -212,7 +213,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 MK570",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_MK750_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 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);

@@ -221,6 +222,7 @@ 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);

@@ -72,6 +72,17 @@ 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
        {
@@ -0,0 +1,91 @@
+/*-----------------------------------------*\
+|  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);
+}
@@ -0,0 +1,35 @@
+/*-----------------------------------------*\
+|  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();
+};
@@ -0,0 +1,51 @@
+/*-----------------------------------------*\
+|  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 )                |
+\*---------------------------------------------------------------------------------------------------------*/
@@ -0,0 +1,91 @@
+/*-----------------------------------------*\
+|  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()
+{
+
+}
@@ -0,0 +1,31 @@
+/*-----------------------------------------*\
+|  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;
+};
@@ -49,7 +49,7 @@ static const corsair_hydro_device device_list[] =
 *                                                                                          *
 \******************************************************************************************/

-void DetectCorsairHydroControllers(std::vector<RGBController*>& rgb_controllers)
+void DetectCorsairHydroControllers()
 {
    libusb_init(NULL);

@@ -69,10 +69,9 @@ void DetectCorsairHydroControllers(std::vector<RGBController*>& rgb_controllers)

            CorsairHydroController*     controller     = new CorsairHydroController(dev);
            RGBController_CorsairHydro* rgb_controller = new RGBController_CorsairHydro(controller);
+            rgb_controller->name                       = device_list[device_idx].name;

-            rgb_controller->name = device_list[device_idx].name;
-
-            rgb_controllers.push_back(rgb_controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
        }
    }
 }   /* DetectCorsairHydroControllers() */
@@ -50,6 +50,11 @@
 #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                            |
@@ -84,7 +89,8 @@
 | Corsair K100 Keyboard product ID                      |
 | This keyboard uses a separate driver                  |
 \*-----------------------------------------------------*/
-#define CORSAIR_K100_PID                0x1B7C
+#define CORSAIR_K100_OPTICAL_PID                0x1B7C
+#define CORSAIR_K100_MXRED_PID                  0x1B7D

 /*-----------------------------------------------------*\
 | Corsair K55 RGB PRO XT Keyboard product ID            |
@@ -202,73 +208,75 @@ 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 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",                 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);
 /*-----------------------------------------------------------------------------------------------------*\
 | 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_PID,              1, 0xFF42);
+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);

 /*-----------------------------------------------------------------------------------------------------*\
 | 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);
@@ -356,7 +356,7 @@ RGBController_CorsairK55RGBPROXT::~RGBController_CorsairK55RGBPROXT()
    keepalive_thread_run = false;
    keepalive_thread->join();
    delete keepalive_thread;
-    delete[] zones[0].matrix_map->map;
+    delete[] zones[0].matrix_map;

    delete controller;
 }
@@ -202,7 +202,7 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
    /*---------------------------------------------------------*\
    | Check if the data needs more than 1 packet                |
    \*---------------------------------------------------------*/
-    uint8_t copy_bytes      = CORSAIR_V2_WRITE_SIZE - offset1;
+    uint16_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)
    {
-        uint8_t index       = data_size - remaining;
+        uint16_t index      = data_size - remaining;
        if(remaining < copy_bytes)
        {
            memset(&buffer[offset2], 0, copy_bytes);
@@ -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);
@@ -37,6 +37,8 @@ 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                                                                                              |
@@ -1,5 +1,127 @@
 #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                                |
 |                                                               |
@@ -28,12 +150,83 @@ 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                                      |
 |                                                               |
@@ -81,6 +274,7 @@ static const corsair_v2_device mm700_device =
        &mm700_right_zone,
        &mm700_logo_zone,
        nullptr,
+        nullptr,
        nullptr
    },
    nullptr,
@@ -96,6 +290,8 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
    &k55_rgb_pro_device,
+    &k60_rgb_pro_device,
+    &k60_rgb_pro_lp_device,

 /*-----------------------------------------------------------------*\
 |  MOUSEMATS                                                        |
@@ -104,4 +300,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;
@@ -4,7 +4,7 @@
 #include "RGBController.h"
 #include "RGBControllerKeyNames.h"

-#define CORSAIR_ZONES_MAX   5
+#define CORSAIR_ZONES_MAX   6

 enum corsair_v2_device_mode
 {
@@ -25,6 +25,7 @@ typedef struct
    uint8_t                 zone;
    uint8_t                 row;
    uint8_t                 col;
+    uint8_t                 index;
    const char*             name;
 }   corsair_v2_led;

@@ -45,6 +46,8 @@ 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                         |
@@ -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>colors)

    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);
@@ -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:

@@ -97,6 +97,7 @@ RGBController_CorsairV2SW::~RGBController_CorsairV2SW()

 void RGBController_CorsairV2SW::SetupZones()
 {
+    unsigned int max_led_value              = 0;
    const corsair_v2_device* corsair        = controller->GetDeviceData();

    /*---------------------------------------------------------*\
@@ -114,10 +115,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;

@@ -126,58 +127,44 @@ 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] = (y * new_map->width) + x;
+                        new_map->map[(y * new_map->width) + x] = NA;
                    }
                }

                /*---------------------------------------------------------*\
                | 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;
-                    bool not_found = true;
+                    led 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;
+                    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);

-                        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);
-                    }
+                    uint8_t layout_index        = (corsair->layout[led_idx].row * new_map->width)
+                                                +  corsair->layout[led_idx].col;
+                    new_map->map[layout_index]  = led_idx;
                }

-                new_zone.leds_count        -= blanks;
+                /*---------------------------------------------------------*\
+                | Add 1 the max_led_value to account for the 0th index      |
+                \*---------------------------------------------------------*/
+                max_led_value++;
            }
            else
            {
-                new_zone.matrix_map         = NULL;
+                new_zone.leds_count             = corsair->zones[i]->rows * corsair->zones[i]->cols;
+                new_zone.matrix_map             = NULL;

                /*---------------------------------------------------------*\
                | Create LEDs for the Linear / Single zone                  |
@@ -186,24 +173,40 @@ 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*/)
@@ -217,17 +220,17 @@ void RGBController_CorsairV2SW::DeviceUpdateLEDs()
 {
    last_update_time = std::chrono::steady_clock::now();

-    controller->SetLedsDirect(colors);
+    controller->SetLedsDirect(buffer_map);
 }

 void RGBController_CorsairV2SW::UpdateZoneLEDs(int /*zone*/)
 {
-    controller->SetLedsDirect(colors);
+    controller->SetLedsDirect(buffer_map);
 }

 void RGBController_CorsairV2SW::UpdateSingleLED(int /*led*/)
 {
-    controller->SetLedsDirect(colors);
+    controller->SetLedsDirect(buffer_map);
 }

 void RGBController_CorsairV2SW::DeviceUpdateMode()
@@ -31,6 +31,9 @@ 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
@@ -65,6 +65,16 @@ 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);
                }
            }
@@ -14,6 +14,7 @@
 \*-----------------------------------------------------*/
 #define DAS_KEYBOARD_Q4_PID             0x2037
 #define DAS_KEYBOARD_Q5_PID             0x2020
+#define DAS_KEYBOARD_Q5S_PID            0x209A

 /******************************************************************************************\
 *                                                                                          *
@@ -32,7 +33,8 @@ 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_Q5_PID  ||
+           info->product_id       == DAS_KEYBOARD_Q5S_PID) &&
           info->interface_number == 1)
        {
            break;
@@ -89,5 +91,6 @@ 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_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);
@@ -201,7 +201,7 @@ static const char *led_names[] =
 *                                                                                          *
 \******************************************************************************************/

-void DetectDebugControllers(std::vector<RGBController*> &rgb_controllers)
+void DetectDebugControllers()
 {
    json            debug_settings;

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

            dummy_custom->SetupColors();

-            rgb_controllers.push_back(dummy_custom);
+            ResourceManager::get()->RegisterRGBController(dummy_custom);
        }
    }

@@ -19,7 +19,7 @@
 *                                                                                          *
 \******************************************************************************************/

-void DetectDygmaRaiseControllers(std::vector<RGBController*> &rgb_controllers)
+void DetectDygmaRaiseControllers()
 {
    std::vector<std::string *> ports = find_usb_serial_port(DYGMA_RAISE_VID, DYGMA_RAISE_PID);

@@ -31,7 +31,7 @@ void DetectDygmaRaiseControllers(std::vector<RGBController*> &rgb_controllers)
            controller->Initialize((char *)ports[i]->c_str());

            RGBController_DygmaRaise* rgb_controller = new RGBController_DygmaRaise(controller);
-            rgb_controllers.push_back(rgb_controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
        }
    }
 }
@@ -20,7 +20,7 @@
 *                                                                                          *
 \******************************************************************************************/

-void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers)
+void DetectE131Controllers()
 {
    json                e131_settings;

@@ -176,12 +176,12 @@ void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers)
            {
                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(std::vector<RGBController*> &rgb_controllers)
        {
            RGBController_E131* rgb_controller;
            rgb_controller = new RGBController_E131(device_lists[list_idx]);
-            rgb_controllers.push_back(rgb_controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
        }
    }

@@ -132,6 +132,17 @@ 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
    {
@@ -213,6 +224,20 @@ 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;
@@ -90,6 +90,7 @@ 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  */
 };
@@ -332,47 +332,80 @@ 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);

-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);
+/*-----------------------------------------*\
+|  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);
@@ -373,16 +373,17 @@ 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 led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
+        for(std::size_t zone_led_idx = 0; zone_led_idx < zones[zone_idx].leds_count; zone_led_idx++)
        {
            led* new_led = new led();

            new_led->name = zones[zone_idx].name + " LED ";
-            new_led->name.append(std::to_string(led_idx + 1));
+            new_led->name.append(std::to_string(zone_led_idx + 1));

-            new_led->value = led_map[led_idx];
+            new_led->value = led_map[led_idx++];

            leds.push_back(*new_led);
        }
@@ -20,7 +20,7 @@
 *                                                                                          *
 \******************************************************************************************/

-void DetectSpectrixS40GControllers(std::vector<RGBController*>& rgb_controllers)
+void DetectSpectrixS40GControllers()
 {
    /*---------------------------------------------------------------------*\
    | Search for /dev/nvmeX nodes with model matching "XPG SPECTRIX S40G"   |
@@ -56,7 +56,7 @@ void DetectSpectrixS40GControllers(std::vector<RGBController*>& rgb_controllers)
        {
            LOG_DEBUG("[XPG Spectrix S40G] Probing %d, model: %s", nvme_idx, nvme_dev_buf);
        }
-        
+
        close(nvme_model_fd);

        /*-------------------------------------------------*\
@@ -70,15 +70,15 @@ void DetectSpectrixS40GControllers(std::vector<RGBController*>& rgb_controllers)

            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_controllers.push_back(rgb_controller);
+                rgb_controller->name                           = "XPG Spectrix S40G";
+                rgb_controller->type                           = DEVICE_TYPE_STORAGE;
+                rgb_controller->vendor                         = "XPG";
+
+                ResourceManager::get()->RegisterRGBController(rgb_controller);
            }
        }

@@ -86,4 +86,4 @@ void DetectSpectrixS40GControllers(std::vector<RGBController*>& rgb_controllers)
    }
 }   /* DetectSpectrixS40GControllers() */

-REGISTER_DETECTOR(    "XPG Spectrix S40G",              DetectSpectrixS40GControllers);
+REGISTER_DETECTOR(    "XPG Spectrix S40G",              DetectSpectrixS40GControllers);
@@ -92,13 +92,13 @@ HANDLE OpenDevice(wchar_t buff[MAX_PATH])
 *                                                                                          *
 \******************************************************************************************/

-void DetectSpectrixS40GControllers(std::vector<RGBController*>& rgb_controllers)
+void DetectSpectrixS40GControllers()
 {
    /*-------------------------------------------------------------------------------------------------*\
    | 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(std::vector<RGBController*>& rgb_controllers)
            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_controllers.push_back(rgb_controller);
+            rgb_controller->name                           = "XPG Spectrix S40G";
+            rgb_controller->type                           = DEVICE_TYPE_STORAGE;
+            rgb_controller->vendor                         = "XPG";
+
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
        }
    }
 }   /* DetectSpectrixS40GControllers() */
@@ -55,7 +55,9 @@ 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);
@@ -67,13 +69,15 @@ 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 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 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 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 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 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 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);
@@ -25,7 +25,8 @@ 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"                            },
+    { 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_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"                               },
@@ -33,6 +33,7 @@ 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);
@@ -9,6 +9,17 @@
 #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;
@@ -0,0 +1,110 @@
+/*---------------------------------------------------------*\
+|  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;
+}
@@ -0,0 +1,37 @@
+/*---------------------------------------------------------*\
+|  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;
+};
@@ -0,0 +1,48 @@
+#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);
@@ -0,0 +1,86 @@
+/*------------------------------------------------*\
+|  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()
+{
+
+}
@@ -0,0 +1,31 @@
+/*--------------------------------------------------*\
+|  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;
+};
@@ -15,7 +15,7 @@
 *                                                                                          *
 \******************************************************************************************/

-void DetectEspurnaControllers(std::vector<RGBController*> &rgb_controllers)
+void DetectEspurnaControllers()
 {
    json espurna_settings;

@@ -64,7 +64,7 @@ void DetectEspurnaControllers(std::vector<RGBController*> &rgb_controllers)

            RGBController_Espurna* rgb_controller = new RGBController_Espurna(controller);

-            rgb_controllers.push_back(rgb_controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
        }
    }

@@ -2,7 +2,7 @@
 #include "FanBusController.h"
 #include "RGBController_FanBus.h"

-void DetectFanBusControllers(std::vector<RGBController*> &rgb_controllers)
+void DetectFanBusControllers()
 {
    FanBusInterface*    new_interface;
    json                fanbus_settings;
@@ -29,10 +29,10 @@ void DetectFanBusControllers(std::vector<RGBController*> &rgb_controllers)

                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);

-                    rgb_controllers.push_back(rgb_controller);
+                    ResourceManager::get()->RegisterRGBController(rgb_controller);
                }
            }
        }
@@ -153,14 +153,24 @@ void RGBController_Faustus::DeviceUpdateMode()
    DeviceUpdateLEDs();
 }

-void DetectFaustusControllers(std::vector<RGBController*> &rgb_controllers)
+void DetectFaustusControllers()
 {
    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)
    {
@@ -171,9 +181,15 @@ void DetectFaustusControllers(std::vector<RGBController*> &rgb_controllers)
        }
        dent = readdir(dir);
    }
+
    closedir(dir);
-    if(found != 6) return;
-    rgb_controllers.push_back(new RGBController_Faustus(base_path));
+
+    if(found != 6)
+    {
+        return;
+    }
+
+    ResourceManager::get()->RegisterRGBController(new RGBController_Faustus(base_path));
 }   /* DetectFaustusControllers() */

 REGISTER_DETECTOR("Faustus", DetectFaustusControllers);
@@ -65,4 +65,5 @@ 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);
@@ -0,0 +1,80 @@
+/*-----------------------------------------*\
+|  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);
+}
@@ -0,0 +1,56 @@
+/*-----------------------------------------*\
+|  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;
+};
@@ -0,0 +1,31 @@
+#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);
@@ -0,0 +1,185 @@
+/*-----------------------------------------*\
+|  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);
+    }
+}
@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  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;
+};
@@ -37,14 +37,26 @@ 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 AORUS XTREME WATERFORCE WB 10G   0xAB 0x10 0x01 0x00
-    if(res < 0)
+    //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)
    {
-        LOG_DEBUG("[%s] at 0x%02X address expected 0x04 but received: 0x%02X", GIGABYTEGPU_CONTROLLER_NAME2, address, res);
+        // 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);
        pass = false;
    }

@@ -77,15 +89,21 @@ 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_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_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 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);
@@ -93,8 +111,15 @@ 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);
+
@@ -43,7 +43,8 @@ json rgb_fusion_2_smbus_motherboards[] =
    "X470 AORUS GAMING 7 WIFI-50-CF",
    "X470 AORUS ULTRA GAMING",
    "X470 AORUS ULTRA GAMING-CF",
-    "Z370 AORUS Gaming 5-CF"
+    "B360M AORUS Gaming 3-CF",
+    "Z370 AORUS Gaming 5-CF",
    "Z370 AORUS Ultra Gaming-CF"
 };

@@ -30,15 +30,17 @@ 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 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"}
+    {"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"  },
 };

 /*-------------------------------------------------*\
@@ -186,6 +188,57 @@ 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},
+                }
+            }
+        }
+    },
 };

 /**------------------------------------------------------------------*\
@@ -126,6 +126,7 @@ 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);
@@ -133,10 +134,13 @@ 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);
@@ -146,13 +150,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);
@@ -163,4 +167,5 @@ 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);
@@ -28,7 +28,7 @@ static gig_device compatible_devices[] =
    {"X570 UD"}
 };

-void DetectGigabyteSuperIORGBControllers(std::vector<RGBController*> &rgb_controllers)
+void DetectGigabyteSuperIORGBControllers()
 {
    int sio_addrs[2] = {0x2E, 0x4E};

@@ -49,21 +49,22 @@ void DetectGigabyteSuperIORGBControllers(std::vector<RGBController*> &rgb_contro

        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++)
-            {
-                if (board_dmi.find(std::string(compatible_devices[i].name)) != std::string::npos)
+            case SIO_ITE688_ID:
+                for(unsigned int i = 0; i < NUM_COMPATIBLE_DEVICES; i++)
                {
-                    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;
+                    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;
+                    }
                }
-            }
-            break;
+                break;
        }
    }
 }   /* DetectGigabyteSuperIORGBControllers() */
@@ -0,0 +1,143 @@
+/*-----------------------------------------*\
+|  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);
+}
@@ -0,0 +1,39 @@
+/*-----------------------------------------*\
+|  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
+                );
+};
@@ -102,6 +102,7 @@ void HyperXAlloyOriginsController::SendDirectInitialization()
    buf[0x00]   = 0x00;
    buf[0x01]   = 0x04;
    buf[0x02]   = 0xF2;
+    buf[0x09]   = 0x09;

    /*-----------------------------------------------------*\
    | Send packet                                           |
@@ -63,6 +63,19 @@ 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++)
@@ -26,6 +26,7 @@ public:
    std::string     GetFirmwareVersion();

    void SetLEDsDirect(std::vector<RGBColor> colors);
+    void SetBrightness(unsigned int brightness);

 private:
    hid_device*     dev;
@@ -4,26 +4,38 @@
 #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 IDs                            |
+| HyperX keyboard vendor and product 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_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 HP_KEYBOARD_VID                 0x03F0
-#define HYPERX_ALLOY_ELITE_2_HP_PID     0x058F

 void DetectHyperXAlloyElite(hid_device_info* info, const std::string& name)
 {
@@ -70,7 +82,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);
@@ -90,21 +102,45 @@ 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);
    }
 }

-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);
+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);

 #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_IP("HyperX Alloy Elite 2 (HP)",   DetectHyperXAlloyElite2,      HP_KEYBOARD_VID,     HYPERX_ALLOY_ELITE_2_HP_PID,     3, 0xFF90);
+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);
 #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 Elite 2 (HP)",    DetectHyperXAlloyElite2,      HP_KEYBOARD_VID,     HYPERX_ALLOY_ELITE_2_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 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);
 #endif
@@ -0,0 +1,262 @@
+/*-----------------------------------------*\
+|  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);;
+    }
+}
@@ -0,0 +1,39 @@
+/*-----------------------------------------*\
+|  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;
+};
--- a/Show More
+++ b/Show More