OpenRGB version 0.8

* Fixes crash when `language` not present in config

.gitlab-ci.yml

@@ -110,7 +110,7 @@ before_script:
   script:
   - 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 +118,7 @@ before_script:
     paths:
     - openrgb*.deb
     exclude:
-    - openrgb-dbgsym*.deb
+    - openrgb-dbgsym*.*deb
     expire_in: 30 days
 
   rules:
@@ -138,7 +138,7 @@ before_script:
   script:
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.deb
+  - rm -v ../openrgb-dbgsym*.*deb
   - mv -v ../openrgb*.deb ./
 
   artifacts:
@@ -146,7 +146,7 @@ before_script:
     paths:
     - openrgb*.deb
     exclude:
-    - openrgb-dbgsym*.deb
+    - openrgb-dbgsym*.*deb
     expire_in: 30 days
 
   rules:
@@ -166,7 +166,7 @@ before_script:
   script:
   - 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 +174,7 @@ before_script:
     paths:
     - openrgb*.deb
     exclude:
-    - openrgb-dbgsym*.deb
+    - openrgb-dbgsym*.*deb
     expire_in: 30 days
 
   rules:
@@ -194,7 +194,7 @@ before_script:
   script:
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.deb
+  - rm -v ../openrgb-dbgsym*.*deb
   - mv -v ../openrgb*.deb ./
 
   artifacts:
@@ -202,7 +202,7 @@ before_script:
     paths:
     - openrgb*.deb
     exclude:
-    - openrgb-dbgsym*.deb
+    - openrgb-dbgsym*.*deb
     expire_in: 30 days
 
   rules:
@@ -529,9 +529,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 +547,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 +605,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 +623,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

.vscode/extensions.json

@@ -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"
+    ]
+}

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

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

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

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

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

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

Controllers/AlienwareController/AlienwareController.cpp

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

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -66,6 +66,7 @@ void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
 } /* DetectAsusAuraGPUControllers() */
 
 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 +87,40 @@ 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);
 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 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);

Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h

@@ -18,6 +18,7 @@
 #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
@@ -174,6 +175,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
         {

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp

@@ -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,44 +53,131 @@ 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[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()
@@ -102,7 +190,31 @@ void AuraTUFKeyboardController::SaveMode()
     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
@@ -121,7 +233,7 @@ void AuraTUFKeyboardController::UpdateSingleLed
     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 +241,54 @@ 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)
+    int packets = ceil((float) colors.size() / 15);
+
+    for(int i = 0; i < packets; i++)
     {
-        unsigned char usb_buf[69];
+        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;
-        }
+        ClearResponses();
 
-        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]);
-            }
+        hid_write(dev, usb_buf, 65);
 
-            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);
+        AwaitResponse(20);
     }
 }
 
@@ -200,7 +296,7 @@ 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
@@ -213,62 +309,167 @@ void AuraTUFKeyboardController::UpdateDevice
     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;
+        }
     }
 
+    ClearResponses();
+
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
     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 +478,7 @@ void AuraTUFKeyboardController::ClearResponses()
     unsigned char usb_buf_flush[65];
     while(result > 0)
     {
-      result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
+        result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
     }
 }
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h

@@ -16,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,
@@ -43,20 +35,28 @@ enum
 {
     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 +68,7 @@ public:
 
     void UpdateLeds
         (
-        std::vector<RGBColor>    colors
+        std::vector<led_color>    colors
         );
 
     void UpdateDevice
@@ -80,7 +80,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 +90,6 @@ public:
 private:
     hid_device*                 dev;
     std::string                 location;
+    unsigned short              version;
 };
 

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -47,6 +47,8 @@
 #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 +69,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
 
@@ -100,6 +103,7 @@ 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:
@@ -258,7 +262,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);
@@ -299,6 +303,8 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",                DetectAs
 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 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,6 +318,7 @@ 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);
@@ -347,6 +354,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);
 

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -24,178 +24,312 @@
 
 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);
+    if(pid != AURA_ROG_CLAYMORE_PID)
+    {
+        name        = "ASUS Aura Keyboard";
+        vendor      = "ASUS";
+        type        = DEVICE_TYPE_KEYBOARD;
+        description = "ASUS Aura Keyboard Device";
+        version     = controller->GetVersion();
+        location    = controller->GetDeviceLocation();
+        serial      = controller->GetSerialString();
 
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = AURA_KEYBOARD_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Static.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Static.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min           = 1;
-    Static.colors_max           = 1;
-    Static.colors.resize(1);
-    modes.push_back(Static);
+        mode Direct;
+        Direct.name                 = "Direct";
+        Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
+        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+        Direct.color_mode           = MODE_COLORS_PER_LED;
+        modes.push_back(Direct);
 
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-    Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-    Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-    Breathing.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Breathing.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Breathing.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors_min        = 1;
-    Breathing.colors_max        = 2;
-    Breathing.colors.resize(1);
-    modes.push_back(Breathing);
+        mode Static;
+        Static.name                 = "Static";
+        Static.value                = AURA_KEYBOARD_MODE_STATIC;
+        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        Static.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Static.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Static.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Static.colors_min           = 1;
+        Static.colors_max           = 1;
+        Static.colors.resize(1);
+        modes.push_back(Static);
 
-    mode Color_Cycle;
-    Color_Cycle.name            = "Spectrum Cycle";
-    Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
-    Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Color_Cycle.speed_min       = AURA_KEYBOARD_SPEED_MIN;
-    Color_Cycle.speed_max       = AURA_KEYBOARD_SPEED_MAX;
-    Color_Cycle.speed           = AURA_KEYBOARD_SPEED_DEFAULT;
-    Color_Cycle.brightness_min  = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Color_Cycle.brightness_max  = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Color_Cycle.brightness      = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Color_Cycle.color_mode      = MODE_COLORS_NONE;
-    modes.push_back(Color_Cycle);
+        mode Breathing;
+        Breathing.name              = "Breathing";
+        Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
+        Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        Breathing.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+        Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+        Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+        Breathing.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Breathing.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Breathing.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+        Breathing.colors_min        = 1;
+        Breathing.colors_max        = 2;
+        Breathing.colors.resize(1);
+        modes.push_back(Breathing);
 
-    mode Wave;
-    Wave.name                   = "Rainbow Wave";
-    Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
-    Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Wave.speed_min              = AURA_KEYBOARD_SPEED_MIN;
-    Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
-    Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
-    Wave.brightness_min         = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Wave.brightness_max         = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Wave.brightness             = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Wave.direction              = MODE_DIRECTION_LEFT;
-    Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-    Wave.colors_min             = 1;
-    Wave.colors_max             = 7;
-    Wave.colors.resize(7);
-    modes.push_back(Wave);
+        mode Color_Cycle;
+        Color_Cycle.name            = "Spectrum Cycle";
+        Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
+        Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        Color_Cycle.speed_min       = AURA_KEYBOARD_SPEED_MIN;
+        Color_Cycle.speed_max       = AURA_KEYBOARD_SPEED_MAX;
+        Color_Cycle.speed           = AURA_KEYBOARD_SPEED_DEFAULT;
+        Color_Cycle.brightness_min  = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Color_Cycle.brightness_max  = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Color_Cycle.brightness      = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Color_Cycle.color_mode      = MODE_COLORS_NONE;
+        modes.push_back(Color_Cycle);
 
-    mode Ripple;
-    Ripple.name                 = "Ripple";
-    Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
-    Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Ripple.speed_min            = AURA_KEYBOARD_SPEED_MIN;
-    Ripple.speed_max            = AURA_KEYBOARD_SPEED_MAX;
-    Ripple.speed                = AURA_KEYBOARD_SPEED_DEFAULT;
-    Ripple.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Ripple.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Ripple.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Ripple.colors_min           = 1;
-    Ripple.colors_max           = 8;
-    Ripple.colors.resize(7);
-    modes.push_back(Ripple);
+        mode Wave;
+        Wave.name                   = "Rainbow Wave";
+        Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
+        Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        Wave.speed_min              = AURA_KEYBOARD_SPEED_MIN;
+        Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
+        Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
+        Wave.brightness_min         = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Wave.brightness_max         = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Wave.brightness             = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Wave.direction              = MODE_DIRECTION_LEFT;
+        Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+        Wave.colors_min             = 1;
+        Wave.colors_max             = 7;
+        Wave.colors.resize(7);
+        modes.push_back(Wave);
 
-    mode Reactive;
-    Reactive.name               = "Reactive";
-    Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
-    Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Reactive.speed_min          = AURA_KEYBOARD_SPEED_MIN;
-    Reactive.speed_max          = AURA_KEYBOARD_SPEED_MAX;
-    Reactive.speed              = AURA_KEYBOARD_SPEED_DEFAULT;
-    Reactive.brightness_min     = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Reactive.brightness_max     = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Reactive.brightness         = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-    Reactive.colors_min         = 1;
-    Reactive.colors_max         = 2;
-    Reactive.colors.resize(1);
-    modes.push_back(Reactive);
+        mode Ripple;
+        Ripple.name                 = "Ripple";
+        Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
+        Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        Ripple.speed_min            = AURA_KEYBOARD_SPEED_MIN;
+        Ripple.speed_max            = AURA_KEYBOARD_SPEED_MAX;
+        Ripple.speed                = AURA_KEYBOARD_SPEED_DEFAULT;
+        Ripple.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Ripple.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Ripple.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Ripple.colors_min           = 1;
+        Ripple.colors_max           = 8;
+        Ripple.colors.resize(7);
+        modes.push_back(Ripple);
 
-    mode Starry_Night;
-    Starry_Night.name           = "Starry Night";
-    Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
-    Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Starry_Night.speed_min      = AURA_KEYBOARD_SPEED_MIN;
-    Starry_Night.speed_max      = AURA_KEYBOARD_SPEED_MAX;
-    Starry_Night.speed          = AURA_KEYBOARD_SPEED_DEFAULT;
-    Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Starry_Night.brightness     = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-    Starry_Night.colors_min     = 1;
-    Starry_Night.colors_max     = 3;
-    Starry_Night.colors.resize(1);
-    modes.push_back(Starry_Night);
+        mode Reactive;
+        Reactive.name               = "Reactive";
+        Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
+        Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        Reactive.speed_min          = AURA_KEYBOARD_SPEED_MIN;
+        Reactive.speed_max          = AURA_KEYBOARD_SPEED_MAX;
+        Reactive.speed              = AURA_KEYBOARD_SPEED_DEFAULT;
+        Reactive.brightness_min     = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Reactive.brightness_max     = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Reactive.brightness         = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+        Reactive.colors_min         = 1;
+        Reactive.colors_max         = 2;
+        Reactive.colors.resize(1);
+        modes.push_back(Reactive);
 
-    mode Quicksand;
-    Quicksand.name              = "Quicksand";
-    Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
-    Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Quicksand.direction         = MODE_DIRECTION_DOWN;
-    Quicksand.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-    Quicksand.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-    Quicksand.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-    Quicksand.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Quicksand.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Quicksand.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Quicksand.colors_min        = 6;
-    Quicksand.colors_max        = 6;
-    Quicksand.colors.resize(6);
-    modes.push_back(Quicksand);
+        mode Starry_Night;
+        Starry_Night.name           = "Starry Night";
+        Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
+        Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        Starry_Night.speed_min      = AURA_KEYBOARD_SPEED_MIN;
+        Starry_Night.speed_max      = AURA_KEYBOARD_SPEED_MAX;
+        Starry_Night.speed          = AURA_KEYBOARD_SPEED_DEFAULT;
+        Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Starry_Night.brightness     = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+        Starry_Night.colors_min     = 1;
+        Starry_Night.colors_max     = 3;
+        Starry_Night.colors.resize(1);
+        modes.push_back(Starry_Night);
 
-    mode Current;
-    Current.name                = "Current";
-    Current.value               = AURA_KEYBOARD_MODE_CURRENT;
-    Current.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Current.speed_min           = AURA_KEYBOARD_SPEED_MIN;
-    Current.speed_max           = AURA_KEYBOARD_SPEED_MAX;
-    Current.speed               = AURA_KEYBOARD_SPEED_DEFAULT;
-    Current.brightness_min      = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Current.brightness_max      = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Current.brightness          = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Current.color_mode          = MODE_COLORS_MODE_SPECIFIC;
-    Current.colors_min          = 1;
-    Current.colors_max          = 3;
-    Current.colors.resize(1);
-    modes.push_back(Current);
+        mode Quicksand;
+        Quicksand.name              = "Quicksand";
+        Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
+        Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+        Quicksand.direction         = MODE_DIRECTION_DOWN;
+        Quicksand.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+        Quicksand.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+        Quicksand.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+        Quicksand.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+        Quicksand.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+        Quicksand.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+        Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+        Quicksand.colors_min        = 6;
+        Quicksand.colors_max        = 6;
+        Quicksand.colors.resize(6);
+        modes.push_back(Quicksand);
 
-    mode 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 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 +341,44 @@ 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_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;
+        case AURA_TUF_K7_GAMING_PID:
+            keyboard_ptr = &AsusTUFK7Layouts;
+            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 +386,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 +421,20 @@ void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
 {
-    DeviceUpdateMode();
+    std::vector<led_color> led_color_list = {};
+
+    for(unsigned 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 +443,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();
+    }
 }

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h

@@ -13,12 +13,27 @@
 
 enum
 {
-    AURA_KEYBOARD_SPEED_MIN          = 0,
-    AURA_KEYBOARD_SPEED_MAX          = 15,
+    AURA_KEYBOARD_SPEED_MIN          = 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 +55,5 @@ public:
 
 private:
     AuraTUFKeyboardController*  controller;
+    uint16_t                    pid;
 };

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.cpp

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

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.h

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

Controllers/AsusLegacyUSBController/AsusLegacyUSBControllerDetect.cpp

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

Controllers/AsusLegacyUSBController/RGBController_AsusCerberusKeyboard.cpp

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

Controllers/AsusLegacyUSBController/RGBController_AsusCerberusKeyboard.h

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

Controllers/ColorfulGPUController/ColorfulGPUController.cpp

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

Controllers/ColorfulGPUController/ColorfulGPUController.h

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

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -0,0 +1,43 @@
+#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 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 Ti Advanced OC-V",   DetectColorfulGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,   COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3070_TI_ADVANCED_OCV2,  0x61);

Controllers/ColorfulGPUController/RGBController_ColorfulGPU.cpp

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

Controllers/ColorfulGPUController/RGBController_ColorfulGPU.h

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

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

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

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

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

Controllers/CorsairPeripheralController/RGBController_CorsairK55RGBPROXT.cpp

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

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.cpp

@@ -202,7 +202,7 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
     /*---------------------------------------------------------*\
     | Check if the data needs more than 1 packet                |
     \*---------------------------------------------------------*/
-    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);

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.h

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

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2ControllerDetect.cpp

@@ -37,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                                                                                              |

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.cpp

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

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.h

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

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2SoftwareController.cpp

@@ -21,7 +21,7 @@ CorsairPeripheralV2SWController::~CorsairPeripheralV2SWController()
 
 }
 
-void CorsairPeripheralV2SWController::SetLedsDirect(std::vector<RGBColor>colors)
+void CorsairPeripheralV2SWController::SetLedsDirect(std::vector<RGBColor *>colors)
 {
     uint16_t count          = colors.size();
     uint16_t green          = count;
@@ -33,7 +33,7 @@ void CorsairPeripheralV2SWController::SetLedsDirect(std::vector<RGBColor>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);

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2SoftwareController.h

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

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Software.cpp

@@ -97,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()

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Software.h

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

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -332,47 +332,55 @@ 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);
+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 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 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 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 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 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 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);

Controllers/EVGAAmpereGPUController/EVGAAmpereGPUControllerDetect.cpp

@@ -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,6 +69,7 @@ REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Ultra Hybrid LHR"
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Ultra Hydro Copper"        , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_XC3_ULTRA_HC_SUB_DEV,              0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Gaming"                   , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_GAMING_SUB_DEV,               0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra"                    , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_SUB_DEV,                0x2D);
+REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra v2 LHR"             , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_LHR_V2_SUB_DEV,         0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra 12GB"               , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_12G_SUB_DEV,            0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra LHR"                , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_LHR_SUB_DEV,            0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hybrid"             , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_HYBRID_SUB_DEV,         0x2D);

Controllers/EVGAGP102GPUController/EVGAGP102GPUControllerDetect.cpp

@@ -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"                               },

Controllers/ElgatoKeyLightController/ElgatoKeyLightController.cpp

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

Controllers/ElgatoKeyLightController/ElgatoKeyLightController.h

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

Controllers/ElgatoKeyLightController/ElgatoKeyLightControllerDetect.cpp

@@ -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(std::vector<RGBController*> &rgb_controllers)
+{
+    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);
+
+                rgb_controllers.push_back(rgb_controller);
+            }
+        }
+    }
+
+}   /* DetectElgatoKeyLightControllers() */
+
+REGISTER_DETECTOR("ElgatoKeyLight", DetectElgatoKeyLightControllers);

Controllers/ElgatoKeyLightController/RGBController_ElgatoKeyLight.cpp

@@ -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()
+{
+
+}

Controllers/ElgatoKeyLightController/RGBController_ElgatoKeyLight.h

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

Controllers/GalaxGPUController/GalaxGPUControllerDetect.cpp

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

Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp

@@ -82,10 +82,12 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX2070 SUPER 8G",
 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 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 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);

Controllers/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusControllerDetect.cpp

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

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUControllerDetect.cpp

@@ -133,10 +133,12 @@ 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 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,7 +148,6 @@ 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);

Controllers/HyperXKeyboardController/HyperXAlloyOrigins60Controller.cpp

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

Controllers/HyperXKeyboardController/HyperXAlloyOrigins60Controller.h

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

Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.cpp

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

Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp

@@ -4,26 +4,31 @@
 #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                            |
 \*-----------------------------------------------------*/
-#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_V2_PID                0x0591
+#define HYPERX_ALLOY_ORIGINS_CORE_PID              0x16E6
+#define HYPERX_ALLOY_ORIGINS_CORE_PID_V2           0x098F
+#define HYPERX_ALLOY_ORIGINS_60_PID                0x1734
 
-#define HP_KEYBOARD_VID                 0x03F0
-#define HYPERX_ALLOY_ELITE_2_HP_PID     0x058F
+#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 +75,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 +95,39 @@ 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",    DetectHyperXAlloyOriginsCore, HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_CORE_PID_V2, 2);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60",      DetectHyperXAlloyOrigins60,   HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_60_PID,      3);
 
 #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_IP("HyperX Alloy Origins",        DetectHyperXAlloyOrigins,     HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_V2_PID,     3, 0xFF90);
 #else
 REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",         DetectHyperXAlloyOrigins,     HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,        0);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",         DetectHyperXAlloyOrigins,     HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_V2_PID,     0);
 REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2",         DetectHyperXAlloyElite2,      HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,        0);
 REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2 (HP)",    DetectHyperXAlloyElite2,      HP_KEYBOARD_VID,     HYPERX_ALLOY_ELITE_2_HP_PID,     0);
 #endif

Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOrigins60.cpp

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

Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOrigins60.h

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

Controllers/HyperXMouseController/RGBController_HyperXPulsefireDart.cpp

@@ -10,7 +10,7 @@
 #include "RGBController_HyperXPulsefireDart.h"
 
 /**------------------------------------------------------------------*\
-    @name HyoerX Pulsefire Dart
+    @name HyperX Pulsefire Dart
     @category Mouse
     @type USB
     @save :white_check_mark:

Controllers/HyperXMouseController/RGBController_HyperXPulsefireRaid.cpp

@@ -10,7 +10,7 @@
 #include "RGBController_HyperXPulsefireRaid.h"
 
 /**------------------------------------------------------------------*\
-    @name HyoerX Pulsefire Raid
+    @name HyperX Pulsefire Raid
     @category Mouse
     @type USB
     @save :x:

Controllers/HyperXMousematController/HyperXMousematControllerDetect.cpp

@@ -11,6 +11,9 @@
 #define HYPERX_VID                  0x0951
 #define HYPERX_FURY_ULTRA_PID       0x1705
 
+#define HYPERX_VID_2                0x03F0
+#define HYPERX_PULSEFIRE_PID         0x0F8D
+
 /******************************************************************************************\
 *                                                                                          *
 *   DetectHyperXMousematControllers                                                        *
@@ -34,3 +37,4 @@ void DetectHyperXMousematControllers(hid_device_info* info, const std::string& n
 }   /* DetectHyperXMousematControllers() */
 
 REGISTER_HID_DETECTOR_I("HyperX Fury Ultra", DetectHyperXMousematControllers, HYPERX_VID, HYPERX_FURY_ULTRA_PID, 0);
+REGISTER_HID_DETECTOR_IPU("HyperX Pulsefire Mat", DetectHyperXMousematControllers, HYPERX_VID_2, HYPERX_PULSEFIRE_PID, 1, 0xFF90, 0xFF00);

Controllers/IntelArcA770LEController/IntelArcA770LEController.cpp

@@ -0,0 +1,205 @@
+/*-----------------------------------------*\
+|  IntelArcA770LEController.cpp             |
+|                                           |
+|  Driver for Intel Arc A770 LE RGB lighting|
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 11/1/2022   |
+\*-----------------------------------------*/
+
+#include "IntelArcA770LEController.h"
+#include <algorithm>
+#include <cstring>
+#include <stdio.h>
+#include <stdlib.h>
+
+IntelArcA770LEController::IntelArcA770LEController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+IntelArcA770LEController::~IntelArcA770LEController()
+{
+    hid_close(dev);
+}
+
+std::string IntelArcA770LEController::GetLocationString()
+{
+    return("HID: " + location);
+}
+
+std::string IntelArcA770LEController::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 IntelArcA770LEController::GetFirmwareVersionString()
+{
+    std::string ret_string = "";
+
+    unsigned char usb_buf[] =
+    {
+        0x00,
+        0x12, 0x20, 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,
+    };
+
+    unsigned char   fw_buf[16] = {0x00};
+
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
+
+    for(int char_idx = 0; char_idx < 16; char_idx+=2)
+    {
+        if(usb_buf[char_idx + 0x08] != 0)
+        {
+            fw_buf[char_idx / 2] = usb_buf[char_idx + 0x08];
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    ret_string.append((char *)fw_buf);
+
+    return(ret_string);
+}
+
+void IntelArcA770LEController::SendEnableCommand()
+{
+    unsigned char usb_buf[] =
+    {
+        0x00,
+        0x41, 0x03, 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,
+    };
+
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
+}
+
+void IntelArcA770LEController::SendApplyCommand()
+{
+    unsigned char usb_buf[] =
+    {
+        0x00,
+        0x51, 0x28, 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,
+    };
+
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
+}
+
+void IntelArcA770LEController::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;
+
+        /*-----------------------------------------*\
+        | Special handling for Logo LED (0x96)      |
+        | Use the maximum channel value as this is  |
+        | a white LED using the red channel         |
+        \*-----------------------------------------*/
+        if(led_ids[led_idx] == 0x96)
+        {
+            usb_buf[index + 5]  = led_ids[led_idx];
+
+            usb_buf[index + 6]  = std::max(RGBGetRValue(colors[led_idx]), std::max(RGBGetGValue(colors[led_idx]), RGBGetBValue(colors[led_idx])));
+            usb_buf[index + 7]  = 0;
+            usb_buf[index + 8]  = 0;
+        }
+        else
+        {
+            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);
+}

Controllers/IntelArcA770LEController/IntelArcA770LEController.h

@@ -0,0 +1,42 @@
+/*-----------------------------------------*\
+|  IntelArcA770LEController.h               |
+|                                           |
+|  Definitions and types for Intel Arc A770 |
+|  LE lighting controller                   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 11/1/2022   |
+\*-----------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#include "RGBController.h"
+
+#pragma once
+
+class IntelArcA770LEController
+{
+public:
+    IntelArcA770LEController(hid_device* dev_handle, const char* path);
+    ~IntelArcA770LEController();
+
+    std::string GetEffectChannelString(unsigned char channel);
+    std::string GetFirmwareVersionString();
+    std::string GetLocationString();
+    std::string GetSerialString();
+
+    void SendDirectPacket
+        (
+        unsigned char   size,
+        unsigned char * led_ids,
+        RGBColor *      colors
+        );
+
+    void SendEnableCommand();
+
+    void SendApplyCommand();
+
+private:
+    hid_device*             dev;
+    std::string             location;
+};

Controllers/IntelArcA770LEController/IntelArcA770LEControllerDetect.cpp

@@ -0,0 +1,30 @@
+#include "Detector.h"
+#include "IntelArcA770LEController.h"
+#include "RGBController.h"
+#include "RGBController_IntelArcA770LE.h"
+#include <hidapi/hidapi.h>
+
+#define INTEL_ARC_A770_LIMITED_EDITION_VID  0x2516
+#define INTEL_ARC_A770_LIMITED_EDITION_PID  0x01B5
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectIntelArcA770LEControllers                                                        *
+*                                                                                          *
+*       Tests the USB address to see if an Intel Arc A770 LE controller exists there.      *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectIntelArcA770LEControllers(hid_device_info* info, const std::string&)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
+    {
+        IntelArcA770LEController*     controller     = new IntelArcA770LEController(dev, info->path);
+        RGBController_IntelArcA770LE* rgb_controller = new RGBController_IntelArcA770LE(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_IP("Intel Arc A770 Limited Edition", DetectIntelArcA770LEControllers, INTEL_ARC_A770_LIMITED_EDITION_VID, INTEL_ARC_A770_LIMITED_EDITION_PID, 1, 0xFF00);

Controllers/IntelArcA770LEController/RGBController_IntelArcA770LE.cpp

@@ -0,0 +1,202 @@
+/*-----------------------------------------*\
+|  RGBController_IntelArcA770LE.cpp         |
+|                                           |
+|  Generic RGB Interface for Intel Arc A770 |
+|  LE                                       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 11/2/2022   |
+\*-----------------------------------------*/
+
+#include "RGBController_IntelArcA770LE.h"
+
+/**------------------------------------------------------------------*\
+    @name Intel Arc A770 Limited Edition
+    @category GPU
+    @type USB
+    @save :o:
+    @direct :white_check_mark:
+    @effects :tools:
+    @detectors DetectIntelArcA770LEControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_IntelArcA770LE::RGBController_IntelArcA770LE(IntelArcA770LEController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "Intel Arc A770 Limited Edition";
+    vendor      = "Cooler Master";
+    type        = DEVICE_TYPE_GPU;
+    description = "Intel Arc A770 Limited Edition";
+    version     = controller->GetFirmwareVersionString();
+    location    = controller->GetLocationString();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = 0;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.brightness_min       = 0;
+    Direct.brightness_max       = 0;
+    Direct.brightness           = 0;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    controller->SendEnableCommand();
+    controller->SendApplyCommand();
+
+    SetupZones();
+}
+
+RGBController_IntelArcA770LE::~RGBController_IntelArcA770LE()
+{
+    delete controller;
+}
+
+void RGBController_IntelArcA770LE::SetupZones()
+{
+    const unsigned int fan_1_leds[16] = { 0x01, 0x04, 0x07, 0x0A, 0x0D, 0x10, 0x13, 0x16,
+                                          0x19, 0x1C, 0x1F, 0x22, 0x25, 0x28, 0x2B, 0x2E };
+    const unsigned int fan_2_leds[16] = { 0x31, 0x34, 0x37, 0x3A, 0x3D, 0x40, 0x43, 0x46,
+                                          0x49, 0x4C, 0x4F, 0x52, 0x55, 0x58, 0x5B, 0x5E };
+    const unsigned int back_leds[8] =   { 0x02, 0x05, 0x08, 0x0B, 0x0E, 0x11, 0x14, 0x17 };
+    const unsigned int ring_leds[50] =  { 0x00, 0x03, 0x06, 0x09, 0x0C, 0x0F, 0x12, 0x15,
+                                          0x18, 0x1B, 0x1E, 0x21, 0x24, 0x27, 0x2A, 0x2D,
+                                          0x30, 0x33, 0x36, 0x39, 0x3C, 0x3F, 0x42, 0x45,
+                                          0x48, 0x4B, 0x4E, 0x51, 0x54, 0x57, 0x5A, 0x5D,
+                                          0x60, 0x63, 0x66, 0x69, 0x6C, 0x6F, 0x72, 0x75,
+                                          0x78, 0x7B, 0x7E, 0x81, 0x84, 0x87, 0x8A, 0x8D,
+                                          0x90, 0x93 };
+    const unsigned int logo_leds[1] =   { 0x96 };
+
+    zone fan_1_zone;
+    fan_1_zone.name         = "Fan 1";
+    fan_1_zone.type         = ZONE_TYPE_LINEAR;
+    fan_1_zone.leds_min     = 16;
+    fan_1_zone.leds_max     = 16;
+    fan_1_zone.leds_count   = 16;
+    fan_1_zone.matrix_map   = NULL;
+    zones.push_back(fan_1_zone);
+
+    zone fan_2_zone;
+    fan_2_zone.name         = "Fan 2";
+    fan_2_zone.type         = ZONE_TYPE_LINEAR;
+    fan_2_zone.leds_min     = 16;
+    fan_2_zone.leds_max     = 16;
+    fan_2_zone.leds_count   = 16;
+    fan_2_zone.matrix_map   = NULL;
+    zones.push_back(fan_2_zone);
+
+    zone back;
+    back.name               = "Back";
+    back.type               = ZONE_TYPE_LINEAR;
+    back.leds_min           = 8;
+    back.leds_max           = 8;
+    back.leds_count         = 8;
+    back.matrix_map         = NULL;
+    zones.push_back(back);
+
+    zone ring;
+    ring.name               = "Ring";
+    ring.type               = ZONE_TYPE_LINEAR;
+    ring.leds_min           = 50;
+    ring.leds_max           = 50;
+    ring.leds_count         = 50;
+    ring.matrix_map         = NULL;
+    zones.push_back(ring);
+
+    zone logo;
+    logo.name               = "Logo";
+    logo.type               = ZONE_TYPE_SINGLE;
+    logo.leds_min           = 1;
+    logo.leds_max           = 1;
+    logo.leds_count         = 1;
+    zones.push_back(logo);
+
+    for(unsigned int led_idx = 0; led_idx < 16; led_idx++)
+    {
+        led fan_1_led;
+        fan_1_led.name = "Fan 1 LED";
+        fan_1_led.value = fan_1_leds[led_idx];
+        leds.push_back(fan_1_led);
+    }
+
+    for(unsigned int led_idx = 0; led_idx < 16; led_idx++)
+    {
+        led fan_2_led;
+        fan_2_led.name = "Fan 2 LED";
+        fan_2_led.value = fan_2_leds[led_idx];
+        leds.push_back(fan_2_led);
+    }
+
+    for(unsigned int led_idx = 0; led_idx < 8; led_idx++)
+    {
+        led back_led;
+        back_led.name = "Back LED";
+        back_led.value = back_leds[led_idx];
+        leds.push_back(back_led);
+    }
+
+    for(unsigned int led_idx = 0; led_idx < 50; led_idx++)
+    {
+        led ring_led;
+        ring_led.name = "Ring LED";
+        ring_led.value = ring_leds[led_idx];
+        leds.push_back(ring_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);
+    }
+
+    SetupColors();
+}
+
+void RGBController_IntelArcA770LE::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_IntelArcA770LE::DeviceUpdateLEDs()
+{
+    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);
+    }
+}
+
+void RGBController_IntelArcA770LE::UpdateZoneLEDs(int /*zone*/)
+{
+
+}
+
+void RGBController_IntelArcA770LE::UpdateSingleLED(int /*led*/)
+{
+}
+
+void RGBController_IntelArcA770LE::DeviceUpdateMode()
+{
+}

Controllers/IntelArcA770LEController/RGBController_IntelArcA770LE.h

@@ -0,0 +1,32 @@
+/*-----------------------------------------*\
+|  RGBController_IntelArcA770LE.h           |
+|                                           |
+|  Generic RGB Interface for Intel Arc A770 |
+|  LE                                       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 11/2/2022   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "IntelArcA770LEController.h"
+
+class RGBController_IntelArcA770LE : public RGBController
+{
+public:
+    RGBController_IntelArcA770LE(IntelArcA770LEController* controller_ptr);
+    ~RGBController_IntelArcA770LE();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    IntelArcA770LEController*   controller;
+};

Controllers/LEDStripController/LEDStripController.cpp

@@ -5,6 +5,7 @@
 \*---------------------------------------------------------*/
 
 #include "LEDStripController.h"
+#include "ResourceManager.h"
 
 #include <fstream>
 #include <iostream>
@@ -26,13 +27,16 @@ void LEDStripController::Initialize(char* ledstring, led_protocol proto)
     LPSTR   source = NULL;
     LPSTR   udpport_baud = NULL;
     LPSTR   next = NULL;
-    
+
     //Set the protocol
     protocol = proto;
 
     //Assume serial device unless a different protocol is specified
     bool    serial = TRUE;
-    
+
+    //Default i2c address out of range
+    i2c_addr = 255;
+
     source = strtok_s(ledstring, ",", &next);
 
     //Check if we are setting up a Keyboard Visualizer UDP protocol device
@@ -41,7 +45,7 @@ void LEDStripController::Initialize(char* ledstring, led_protocol proto)
         source = source + 4;
         serial = FALSE;
     }
-    
+
     //Check for either the UDP port or the serial baud rate
     if (strlen(next))
     {
@@ -56,7 +60,13 @@ void LEDStripController::Initialize(char* ledstring, led_protocol proto)
 
     if (serial)
     {
-        if (udpport_baud == NULL)
+        if (protocol == LED_PROTOCOL_BASIC_I2C)
+        {
+            //I2C uses the baud field for address
+            i2c_addr = atoi(udpport_baud);
+            InitializeI2C(source);
+        }
+        else if (udpport_baud == NULL)
         {
             //Initialize with default baud rate
             InitializeSerial(source, 115200);
@@ -86,6 +96,24 @@ void LEDStripController::Initialize(char* ledstring, led_protocol proto)
     }
 }
 
+void LEDStripController::InitializeI2C(char* i2cname)
+{
+    for(unsigned int i2c_idx = 0; i2c_idx < ResourceManager::get()->GetI2CBusses().size(); i2c_idx++)
+    {
+        if(ResourceManager::get()->GetI2CBusses()[i2c_idx]->device_name == std::string(i2cname))
+        {
+            if(i2c_addr < 128)
+            {
+                i2cport = ResourceManager::get()->GetI2CBusses()[i2c_idx];
+                break;
+            }
+        }
+    }
+
+    serialport = NULL;
+    udpport = NULL;
+}
+
 void LEDStripController::InitializeSerial(char* portname, int baud)
 {
     portname = strtok(portname, "\r");
@@ -93,6 +121,7 @@ void LEDStripController::InitializeSerial(char* portname, int baud)
     baud_rate = baud;
     serialport = new serial_port(port_name.c_str(), baud_rate);
     udpport = NULL;
+    i2cport = NULL;
 }
 
 void LEDStripController::InitializeUDP(char * clientname, char * port)
@@ -102,6 +131,7 @@ void LEDStripController::InitializeUDP(char * clientname, char * port)
 
     udpport = new net_port(client_name.c_str(), port_name.c_str());
     serialport = NULL;
+    i2cport = NULL;
 }
 
 std::string LEDStripController::GetLocation()
@@ -114,6 +144,10 @@ std::string LEDStripController::GetLocation()
     {
         return("UDP: " + client_name + ":" + port_name);
     }
+    else if(i2cport != NULL)
+    {
+        return("I2C: " + std::string(i2cport->device_name) + ", Address " + std::to_string(i2c_addr));
+    }
     else
     {
         return("");
@@ -140,6 +174,10 @@ void LEDStripController::SetLEDs(std::vector<RGBColor> colors)
         case LED_PROTOCOL_TPM2:
             SetLEDsTPM2(colors);
             break;
+
+        case LED_PROTOCOL_BASIC_I2C:
+            SetLEDsBasicI2C(colors);
+            break;
     }
 }
 
@@ -318,3 +356,51 @@ void LEDStripController::SetLEDsTPM2(std::vector<RGBColor> colors)
 
     delete[] serial_buf;
 }
+
+void LEDStripController::SetLEDsBasicI2C(std::vector<RGBColor> colors)
+{
+    unsigned char serial_buf[30];
+
+    /*-------------------------------------------------------------*\
+    | Basic I2C Protocol                                            |
+    |                                                               |
+    |   Packet size: At most 32 bytes (SMBus block size)            |
+    |                                                               |
+    |   Packet is in RGBRGBRGB... format, also provide start index  |
+    \*-------------------------------------------------------------*/
+
+    unsigned char index  = 0;
+    unsigned char offset = 0;
+
+    for(unsigned int color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        serial_buf[index + 0] = RGBGetRValue(colors[color_idx]);
+        serial_buf[index + 1] = RGBGetGValue(colors[color_idx]);
+        serial_buf[index + 2] = RGBGetBValue(colors[color_idx]);
+
+        index += 3;
+
+        if(index >= 30)
+        {
+            if(i2cport != NULL)
+            {
+                i2cport->i2c_smbus_write_i2c_block_data(i2c_addr, offset, 30, serial_buf);
+                offset += 30;
+                index = 0;
+            }
+        }
+    }
+
+    if(index > 0)
+    {
+        if(i2cport != NULL)
+        {
+            i2cport->i2c_smbus_write_i2c_block_data(i2c_addr, offset, index, serial_buf);
+        }
+    }
+
+    if(i2cport != NULL)
+    {
+        i2cport->i2c_smbus_write_byte(i2c_addr, 0xFF);
+    }
+}

Controllers/LEDStripController/LEDStripController.h

@@ -8,6 +8,7 @@
 #define LED_STRIP_H
 
 #include "RGBController.h"
+#include "i2c_smbus.h"
 #include "serial_port.h"
 #include "net_port.h"
 #include <vector>
@@ -29,7 +30,8 @@ enum
 {
     LED_PROTOCOL_KEYBOARD_VISUALIZER,
     LED_PROTOCOL_ADALIGHT,
-    LED_PROTOCOL_TPM2
+    LED_PROTOCOL_TPM2,
+    LED_PROTOCOL_BASIC_I2C
 };
 
 struct LEDStripDevice
@@ -49,6 +51,7 @@ public:
 
     void        Initialize(char* ledstring, led_protocol proto);
 
+    void        InitializeI2C(char* i2cname);
     void        InitializeSerial(char* portname, int baud);
     void        InitializeUDP(char* clientname, char* port);
 
@@ -60,6 +63,7 @@ public:
     void        SetLEDsKeyboardVisualizer(std::vector<RGBColor> colors);
     void        SetLEDsAdalight(std::vector<RGBColor> colors);
     void        SetLEDsTPM2(std::vector<RGBColor> colors);
+    void        SetLEDsBasicI2C(std::vector<RGBColor> colors);
 
     int num_leds;
 
@@ -71,6 +75,8 @@ private:
     std::string client_name;
     serial_port *serialport;
     net_port *udpport;
+    i2c_smbus_interface *i2cport;
+    unsigned char i2c_addr;
     led_protocol protocol;
 };
 

Controllers/LEDStripController/LEDStripControllerDetect.cpp

@@ -74,6 +74,10 @@ void DetectLEDStripControllers(std::vector<RGBController*> &rgb_controllers)
                 {
                     dev.protocol = LED_PROTOCOL_TPM2;
                 }
+                else if(protocol_string == "basic_i2c")
+                {
+                    dev.protocol = LED_PROTOCOL_BASIC_I2C;
+                }
             }
 
             std::string value = dev.port + "," + std::to_string(dev.baud) + "," + std::to_string(dev.num_leds);

Controllers/LenovoControllers/LenovoDevices.h

@@ -63,40 +63,49 @@ struct lenovo_zone
 \*---------*/
 
 static const unsigned int legion_Y760_ansi_leds_map[] =
-    {  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  NA,  NA,  16,  17,  18,  19,
-      20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  NA,  NA,  NA,  NA,  53,  33,  34,  35,  36,
-      37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  NA,  NA,  68,  69,  70,  NA,
-      54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  90,  65,  91,  66,  92,  67,  NA,  93,  94,  95,  71,
-      72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  85,  84,  87,  86,  88,  89, 111, 113, 114,  96,
-      97,  98,  99, 100, 101, 102, 103, 104, 105, 116, 106, 117, 107, 118, 108, 109, 110,  NA, 112,  NA, 115,  NA,
-     126, 127, 128, 129, 130,  NA,  NA,  NA,  NA, 131, 132, 133,  NA,  NA,  NA, 136,  NA,  NA, 119, 121, 123, 125,
-      NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 135,  NA,  NA, 120, 122, 124, 144,
-      NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 134, 137, 139,  NA, 140, 141, 143,  NA,
-      NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 138,  NA,  NA,  NA,  NA, 142,  NA };
+    {    0,  NA,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,
+        20,  NA,  21,  22,  23,  24,  25,  26,  27,  28,  29,  NA,  30,  31,  32,  NA,  52,  33,  34,  35,  36,
+        37,  NA,  38,  39,  40,  41,  42,  43,  44,  45,  46,  NA,  47,  48,  49,  50,  51,  53,  NA,  NA,  NA,
+        54,  NA,  55,  56,  57,  NA,  58,  59,  60,  61,  62,  63,  64,  65,  66,  NA,  67,  68,  69,  70,  NA,
+        72,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  90,  91,  NA,  92,  93,  94,  95,  71,
+        73,  74,  75,  NA,  76,  77,  78,  79,  80,  81,  82,  83,  84,  NA,  86,  88,  89, 111, 113, 114,  96,
+        NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  85,  NA,  87,  NA,  NA, 112,  NA, 115,  NA,
+        97,  98,  NA,  99, 100, 101,  NA, 102, 103, 104, 105, 106, 107, 108,  NA, 109, 110, 119, 121, 123,  NA,
+        NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 116, 117, 118,  NA,  NA,  NA, 120, 122, 124, 125,
+       126,  NA, 127, 128, 129, 130,  NA,  NA,  NA,  NA, 131, 132, 133,  NA, 135,  NA,  NA, 140,  NA, 142, 144,
+        NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 136,  NA,  NA,  NA, 141, 143,  NA,
+        NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 134, 137,  NA, 139,  NA,  NA,  NA,  NA,
+        NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 138,  NA,  NA,  NA,  NA,  NA,  NA };
 
 static const unsigned int legion_Y760_iso_leds_map[] =
-    {  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  NA,  NA,  16,  17,  18,  19,
-      20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  NA,  NA,  NA,  NA,  51,  33,  34,  35,  36,
-      37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  NA,  NA,  50,  NA,  NA,  66,  67,  68,  NA,
-      52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  88,  63,  89,  64,  NA,  NA,  65,  90,  91,  92,  69,
-      70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  83,  82,  85,  84,  87,  86, 109, 111, 112,  93,
-      94,  96,  95,  97,  98,  99, 100, 101, 102, 103, 114, 104, 115, 105, 116, 106, 107, 108, 110,  NA, 113,  NA,
-     124, 125, 126, 127, 128,  NA,  NA,  NA,  NA, 129, 130, 131,  NA,  NA,  NA, 134,  NA,  NA, 117, 119, 121, 123,
-      NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 133,  NA,  NA, 118, 120, 122, 142,
-      NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 132, 135, 137,  NA, 138, 139, 141,  NA,
-      NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 136,  NA,  NA,  NA,  NA, 140,  NA };
+    {   0,  NA,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,
+       20,  NA,  21,  22,  23,  24,  25,  26,  27,  28,  29,  NA,  30,  31,  32,  NA,  NA,  33,  34,  35,  36,
+       37,  NA,  38,  39,  40,  41,  42,  43,  44,  45,  46,  NA,  47,  48,  49,  NA,  50,  51,  NA,  NA,  NA,
+       52,  NA,  53,  54,  55,  NA,  56,  57,  58,  59,  60,  61,  62,  63,  64,  NA,  65,  66,  67,  68,  NA,
+       70,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  88,  89,  NA,  NA,  90,  91,  92,  69,
+       71,  72,  73,  NA,  74,  75,  76,  77,  78,  79,  80,  81,  82,  NA,  84,  86,  NA, 109, 111, 112,  93,
+       NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  83,  NA,  85,  87,  NA, 110,  NA, 113,  NA,
+       94,  NA,  95,  97,  98,  99,  NA, 100, 101, 102, 103, 104, 105, 106,  NA, 107, 108, 117, 119, 121,  NA,
+       NA,  NA,  96,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 114, 115, 116,  NA,  NA,  NA, 118, 120, 122, 123,
+       124, NA, 125, 126, 127, 128,  NA,  NA,  NA,  NA, 129, 130, 131,  NA, 133,  NA,  NA, 138,  NA, 140, 142,
+       NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 134,  NA,  NA,  NA, 139, 141,  NA,
+       NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 132, 135,  NA, 137,  NA,  NA,  NA,  NA,
+       NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 136,  NA,  NA,  NA,  NA,  NA,  NA };
 
 static const unsigned int legion_Y760_jp_leds_map[] =
-    {  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  NA,  NA,  16,  17,  18,  19,
-      20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  NA,  NA,  NA,  54,  34,  35,  36,  37,
-      38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  NA,  NA,  71,  72,  73,  NA,
-      55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,  NA,  91,  70,  94,  95,  96,  74,
-      75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  92,  93, 116, 118, 119,  97,
-      98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 117,  NA, 120,  NA,
-     128, 129, 130, 131, 132, 133,  NA,  NA, 134, 135, 136, 137,  NA,  NA,  NA, 139,  NA,  NA, 121, 123, 125, 127,
-      NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 140,  NA,  NA, 122, 124, 126, 148,
-      NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 138, 141, 143,  NA, 144, 145, 146,  NA,
-      NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 142,  NA,  NA,  NA,  NA, 147,  NA };
+    {   0,  NA,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,
+       20,  NA,  21,  22,  23,  24,  25,  26,  27,  28,  29,  NA,  30,  31,  32,  33,  53,  34,  35,  36,  37,
+       38,  NA,  39,  40,  41,  42,  43,  44,  45,  46,  47,  NA,  48,  49,  50,  51,  52,  54,  NA,  NA,  NA,
+       55,  NA,  56,  57,  58,  NA,  59,  60,  61,  62,  63,  64,  65,  66,  68,  NA,  70,  71,  72,  73,  NA,
+       75,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  67,  69,  NA,  93,  94,  95,  96,  74,
+       76,  77,  78,  NA,  79,  80,  81,  82,  83,  84,  85,  86,  87,  NA,  89,  91,  NA, 116, 118, 119,  97,
+       NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  88,  NA,  90,  92,  NA, 117,  NA, 120,  NA,
+       98,  99,  NA, 100, 101, 102,  NA, 103, 104, 105, 106, 107, 109, 111, 113, 114, 115, 121, 123, 125,  NA,
+       NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 108, 110, 112,  NA,  NA,  NA, 122, 124, 126, 127,
+      128,  NA, 129, 130, 131, 132, 133,  NA,  NA, 134, 135, 136, 137,  NA, 139,  NA,  NA, 144,  NA, 146, 148,
+       NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 140,  NA,  NA,  NA, 145, 147,  NA,
+       NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 138, 141,  NA, 143,  NA,  NA,  NA,  NA,
+       NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 142,  NA,  NA,  NA,  NA,  NA,  NA };
 
 static const unsigned int legion_Y740_17_ansi_leds_map[] =
     {   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  NA,  14,  15,  16,  17,
@@ -164,7 +173,7 @@ const lenovo_led legion_Y760_ansi_leds[]
     {0x16, "Key: ~"},//20
     {0x17, "Key: !"},//21
     {0x18, "Key: @"},//22
-    {0x19, "Key: #"},//23
+    {0x19, KEY_EN_POUND},//23
     {0x1A, "Key: $"},//24
     {0x1B, "Key: %"},//25
     {0x1C, "Key: ^"},//26
@@ -329,7 +338,7 @@ const lenovo_led legion_Y760_iso_leds[]
     {0x14, KEY_EN_PAGE_DOWN},//19
 
     //row 2
-    {0x17, "Key: ¬"},//20
+    {0x16, "Key: ¬"},//20
     {0x17, "Key: !"},//21
     {0x18, "Key: \""},//22
     {0x19, "Key: £"},//23
@@ -495,10 +504,10 @@ const lenovo_led legion_Y760_jp_leds[]
     {0x14, KEY_EN_PAGE_DOWN}, //19
 
     //row 2
-    {0x16, "Key: halfwidth"}, //20
+    {0x16, KEY_JP_ZENKAKU}, //20
     {0x17, "Key: !"}, //21
     {0x18, "Key: \""}, //22
-    {0x19, "Key: #"}, //23
+    {0x19, KEY_EN_POUND}, //23
     {0x1A, "Key: $"}, //24
     {0x1B, "Key: %"}, //25
     {0x1C, "Key: &"}, //26
@@ -515,7 +524,7 @@ const lenovo_led legion_Y760_jp_leds[]
     {0x29, KEY_EN_NUMPAD_MINUS}, //37
 
     //row 3
-    {0x2B, "Key: fullwidth"}, //38
+    {0x2B, "Key: kanji"}, //38
     {0x2C, KEY_EN_1}, //39
     {0x2D, KEY_EN_2}, //40
     {0x2E, KEY_EN_3}, //41
@@ -527,8 +536,8 @@ const lenovo_led legion_Y760_jp_leds[]
     {0x34, KEY_EN_9}, //47
     {0x35, KEY_EN_0}, //48
     {0x36, KEY_EN_MINUS}, //49
-    {0x37, "Key: ~"}, //50
-    {0x38, "Key: Yen"}, //51
+    {0x37, KEY_JP_CHEVRON}, //50
+    {0x38, KEY_JP_YEN}, //51
     {0x25, KEY_EN_BACKSPACE}, //52
     {0x3A, KEY_EN_BACKSPACE}, //53
     {0x3B, KEY_EN_NUMPAD_LOCK}, //54
@@ -546,7 +555,7 @@ const lenovo_led legion_Y760_jp_leds[]
     {0x4A, KEY_EN_O}, //64
     {0x4B, KEY_EN_P}, //65
     {0x4C, KEY_EN_BACK_TICK}, //66
-    {0x61, "Key: @"}, //67
+    {0x61, KEY_JP_AT}, //67
     {0x4D, "Key: {"}, //68
     {0x62, KEY_EN_LEFT_BRACKET}, //69
     {0x4E, KEY_EN_ISO_ENTER}, //70
@@ -571,7 +580,7 @@ const lenovo_led legion_Y760_jp_leds[]
     {0x5D, "Key: +"}, //87
     {0x5E, KEY_EN_SEMICOLON}, //88
     {0x5F, "Key: *"}, //89
-    {0x60, "Key: :"}, //90
+    {0x60, KEY_JP_COLON}, //90
     {0x77, "Key: }"}, //91
     {0x78, KEY_EN_RIGHT_BRACKET}, //92
     {0x63, KEY_EN_ISO_ENTER}, //93
@@ -596,7 +605,7 @@ const lenovo_led legion_Y760_jp_leds[]
     {0x8A, KEY_EN_PERIOD}, //110
     {0x76, "Key: ?"}, //111
     {0x8B, KEY_EN_FORWARD_SLASH}, //112
-    {0x8C, KEY_EN_ANSI_BACK_SLASH}, //113
+    {0x8C, KEY_JP_RO}, //113
     {0x8D, KEY_EN_RIGHT_SHIFT}, //114
     {0xa2, KEY_EN_RIGHT_SHIFT}, //115
     {0x79, KEY_EN_NUMPAD_4}, //116
@@ -619,11 +628,11 @@ const lenovo_led legion_Y760_jp_leds[]
     {0x80, KEY_EN_LEFT_FUNCTION}, //129
     {0x96, KEY_EN_LEFT_WINDOWS}, //130
     {0x97, KEY_EN_LEFT_ALT}, //131
-    {0x98, "Key: Muhenkan"}, //132
+    {0x98, KEY_JP_MUHENKAN}, //132
     {0x85, KEY_EN_SPACE}, //133
     {0x86, KEY_EN_SPACE}, //134
-    {0x99, "Key: Henkan"}, //135
-    {0x9A, "Key: Katakana/Hiragana/Rōmaji"}, //136
+    {0x99, KEY_JP_HENKAN}, //135
+    {0x9A, KEY_JP_KANA}, //136
     {0x9B, KEY_EN_RIGHT_CONTROL}, //137
     {0x9C, KEY_EN_LEFT_ARROW}, //138
     {0x9D, KEY_EN_UP_ARROW}, //139
@@ -1020,13 +1029,6 @@ const lenovo_led legion_Y740_17_ansi_leds[]
     {0x4F, KEY_EN_LEFT_ARROW},       //101
     {0x54, KEY_EN_DOWN_ARROW},       //102
     {0x59, KEY_EN_RIGHT_ARROW},      //103
-
-    //Other LEDs
-    {0x97, "Power button"},          //104
-    {0x99, "Fans"},                  //105
-    {0x98, "USB ports"},             //106
-    {0x96, "Legion Y Logo"}          //107
-
 };
 
 const lenovo_led legion_Y740_17_iso_leds[]
@@ -1145,13 +1147,6 @@ const lenovo_led legion_Y740_17_iso_leds[]
     {0x4F, KEY_EN_LEFT_ARROW},       //100
     {0x54, KEY_EN_DOWN_ARROW},       //101
     {0x59, KEY_EN_RIGHT_ARROW},      //102
-
-    //Other LEDs
-    {0x97, "Power button"},          //103
-    {0x99, "Fans"},                  //104
-    {0x98, "USB ports"},             //105
-    {0x96, "Legion Y Logo"}          //106
-
 };
 
 /*--------------------------------------------------------*\
@@ -1264,13 +1259,6 @@ const lenovo_led legion_Y740_15_ansi_leds[]
     {0x81, "Key: M2"},               //87
     {0x53, "Key: Kb Brightness Up"}, //88
     {0x54, "Key: Kb Brightness Down"}, //89
-
-    //Other LEDs
-    {0x97, "Power button"},          //90
-    {0x99, "Fans"},                  //91
-    {0x98, "USB ports"},             //92
-    {0x96, "Legion Y Logo"}          //93
-
 };
 
 const lenovo_led legion_Y740_15_iso_leds[]
@@ -1378,15 +1366,20 @@ const lenovo_led legion_Y740_15_iso_leds[]
     {0x81, "Key: M2"},               //86
     {0x53, "Key: Kb Brightness Up"}, //87
     {0x54, "Key: Kb Brightness Down"}, //88
-
-    //Other LEDs
-    {0x97, "Power button"},         //89
-    {0x99, "Fans"},                 //90
-    {0x98, "USB ports"},            //91
-    {0x96, "Legion Y Logo"}         //92
-
 };
 
+/*--------------------------------------------------------*\
+| Additional LEDs for Legion Y740                          |
+\*--------------------------------------------------------*/
+const lenovo_led legion_legion_Y740_additional_leds[]
+{
+    {0x97, "Power button"},          //104
+    {0x99, "Vents"},                 //105
+    {0x98, "USB ports"},             //106
+    {0x96, "Legion Y Logo"}          //107
+};
+
+
 /*--------------------------------------------------------*\
 | Legion 7 gen 6: 7 zones                                  |
 |                                                          |
@@ -1403,8 +1396,8 @@ static lenovo_zone lenovo_legion_Y760_kbd_ansi
     "Keyboard",
     ZONE_TYPE_MATRIX,
     1,
-    10,
-    22,
+    13,
+    21,
     legion_Y760_ansi_leds_map,
     legion_Y760_ansi_leds,
     0,
@@ -1416,8 +1409,8 @@ static lenovo_zone lenovo_legion_Y760_kbd_iso
     "Keyboard",
     ZONE_TYPE_MATRIX,
     1,
-    10,
-    22,
+    13,
+    21,
     legion_Y760_iso_leds_map,
     legion_Y760_iso_leds,
     0,
@@ -1429,8 +1422,8 @@ static lenovo_zone lenovo_legion_Y760_kbd_jp
     "Keyboard",
     ZONE_TYPE_MATRIX,
     1,
-    10,
-    22,
+    13,
+    21,
     legion_Y760_jp_leds_map,
     legion_Y760_jp_leds,
     0,
@@ -1528,47 +1521,11 @@ static lenovo_zone lenovo_legion_Y760_neon
 | Legion Y750, Y750S and Y760S: 4 zones                    |
 \*--------------------------------------------------------*/
 
-/*------*\
-|keyboard|
-\*------*/
-static lenovo_zone lenovo_legion_Y750_kbd_ansi
-{
-    "Keyboard",
-    ZONE_TYPE_MATRIX,
-    1,
-    10,
-    22,
-    legion_Y760_ansi_leds_map,
-    legion_Y760_ansi_leds,
-    0,
-    144,
-};
-
-static lenovo_zone lenovo_legion_Y750_kbd_iso
-{
-    "Keyboard",
-    ZONE_TYPE_MATRIX,
-    1,
-    10,
-    22,
-    legion_Y760_iso_leds_map,
-    legion_Y760_iso_leds,
-    0,
-    144,
-};
-
-static lenovo_zone lenovo_legion_Y750_kbd_jp
-{
-    "Keyboard",
-    ZONE_TYPE_MATRIX,
-    1,
-    10,
-    22,
-    legion_Y760_jp_leds_map,
-    legion_Y760_jp_leds,
-    0,
-    148,
-};
+/*----------------------------------*\
+|keyboard                            |
+|                                    |
+| Note: keyboard is shared with Y760 |
+\*----------------------------------*/
 
 /*------*\
 |logo    |
@@ -1648,13 +1605,13 @@ static lenovo_zone lenovo_legion_Y740_17_kbd_iso
     legion_Y740_17_iso_leds_map,
     legion_Y740_17_iso_leds,
     0,
-    103,
+    102,
 };
 
-/*-----------*\
-|Power button |
-\*-----------*/
-static lenovo_zone lenovo_legion_Y740_17_logo
+/*------*\
+|logo    |
+\*------*/
+static lenovo_zone lenovo_legion_Y740_logo
 {
     "Logo",
     ZONE_TYPE_SINGLE,
@@ -1662,15 +1619,15 @@ static lenovo_zone lenovo_legion_Y740_17_logo
     1,
     1,
     NULL,
-    legion_Y740_17_ansi_leds,
-    107,
-    107,
+    legion_legion_Y740_additional_leds,
+    3,
+    3,
 };
 
-/*------*\
-|logo    |
-\*------*/
-static lenovo_zone lenovo_legion_Y740_17_pwrbtn
+/*-----------*\
+|Power button |
+\*-----------*/
+static lenovo_zone lenovo_legion_Y740_pwrbtn
 {
     "Power Button",
     ZONE_TYPE_SINGLE,
@@ -1678,15 +1635,15 @@ static lenovo_zone lenovo_legion_Y740_17_pwrbtn
     1,
     1,
     NULL,
-    legion_Y740_17_ansi_leds,
-    104,
-    104,
+    legion_legion_Y740_additional_leds,
+    0,
+    0,
 };
 
 /*------*\
 |vents   |
 \*------*/
-static lenovo_zone lenovo_legion_Y740_17_vents
+static lenovo_zone lenovo_legion_Y740_vents
 {
     "Vents",
     ZONE_TYPE_SINGLE,
@@ -1694,28 +1651,27 @@ static lenovo_zone lenovo_legion_Y740_17_vents
     1,
     1,
     NULL,
-    legion_Y740_17_ansi_leds,
-    105,
-    105,
+    legion_legion_Y740_additional_leds,
+    1,
+    1,
 };
 
 /*--------*\
 |USB Ports |
 \*--------*/
-static lenovo_zone lenovo_legion_Y740_17_ports
+static lenovo_zone lenovo_legion_Y740_ports
 {
-    "Neon",
+    "USB Ports",
     ZONE_TYPE_SINGLE,
     1,
     1,
     1,
     NULL,
-    legion_Y740_17_ansi_leds,
-    106,
-    106,
+    legion_legion_Y740_additional_leds,
+    2,
+    2,
 };
 
-
 /*--------------------------------------------------------*\
 | Legion Y740 15": 5 zones                                 |
 \*--------------------------------------------------------*/
@@ -1746,72 +1702,7 @@ static lenovo_zone lenovo_legion_Y740_15_kbd_iso
     legion_Y740_15_iso_leds_map,
     legion_Y740_15_iso_leds,
     0,
-    89,
+    88,
 };
 
-/*-----------*\
-|Power button |
-\*-----------*/
-static lenovo_zone lenovo_legion_Y740_15_logo
-{
-    "Logo",
-    ZONE_TYPE_SINGLE,
-    1,
-    1,
-    1,
-    NULL,
-    legion_Y740_15_ansi_leds,
-    93,
-    93,
-};
-
-/*------*\
-|logo    |
-\*------*/
-static lenovo_zone lenovo_legion_Y740_15_pwrbtn
-{
-    "Power Button",
-    ZONE_TYPE_SINGLE,
-    1,
-    1,
-    1,
-    NULL,
-    legion_Y740_15_ansi_leds,
-    90,
-    90,
-};
-
-/*------*\
-|vents   |
-\*------*/
-static lenovo_zone lenovo_legion_Y740_15_vents
-{
-    "Vents",
-    ZONE_TYPE_SINGLE,
-    1,
-    1,
-    1,
-    NULL,
-    legion_Y740_15_ansi_leds,
-    91,
-    91,
-};
-
-/*--------*\
-|USB Ports |
-\*--------*/
-static lenovo_zone lenovo_legion_Y740_15_ports
-{
-    "Neon",
-    ZONE_TYPE_SINGLE,
-    1,
-    1,
-    1,
-    NULL,
-    legion_Y740_15_ansi_leds,
-    92,
-    92,
-};
-
-
 #endif

Controllers/LenovoControllers/LenovoUSBController.cpp

@@ -105,7 +105,7 @@ vector<uint8_t> LenovoUSBController::getInformation(uint8_t information_id)
     int num_bytes = hid_get_feature_report(dev, read_buffer, LENOVO_HID_PACKET_SIZE);
     if(num_bytes > 0)
     {
-        vector<uint8_t> response(&read_buffer[0], &read_buffer[num_bytes - 1]);
+        vector<uint8_t> response(&read_buffer[0], &read_buffer[num_bytes]);
         return response;
     }
     return vector<uint8_t>();

Controllers/LenovoControllers/RGBController_LenovoUSB.cpp

@@ -69,6 +69,12 @@ RGBController_LenovoUSB::RGBController_LenovoUSB(LenovoUSBController* controller
     }
 
     std::vector<uint8_t> response;
+
+    /*-----------------------*\
+    |Default to ANSI keyboard |
+    \*-----------------------*/
+    keyboard_type = ANSI;
+
     switch(controller->getPid())
     {
         case LEGION_Y740:
@@ -89,10 +95,6 @@ RGBController_LenovoUSB::RGBController_LenovoUSB(LenovoUSBController* controller
                 {
                     keyboard_type = ISO;
                 }
-                else
-                {
-                    keyboard_type = ANSI;
-                }
             }
 
             description = "Lenovo Y740 " + sizeToString(chasis_size) + " " + keyboardToString(keyboard_type);
@@ -111,10 +113,6 @@ RGBController_LenovoUSB::RGBController_LenovoUSB(LenovoUSBController* controller
                 {
                     keyboard_type = ISO;
                 }
-                else
-                {
-                    keyboard_type = ANSI;
-                }
             }
 
             description = "Lenovo Y750 " + keyboardToString(keyboard_type);
@@ -133,10 +131,6 @@ RGBController_LenovoUSB::RGBController_LenovoUSB(LenovoUSBController* controller
                 {
                     keyboard_type = ISO;
                 }
-                else
-                {
-                    keyboard_type = ANSI;
-                }
             }
 
             description = "Lenovo Y750S " + keyboardToString(keyboard_type);
@@ -155,10 +149,6 @@ RGBController_LenovoUSB::RGBController_LenovoUSB(LenovoUSBController* controller
                 {
                     keyboard_type = ISO;
                 }
-                else
-                {
-                    keyboard_type = ANSI;
-                }
             }
 
             description = "Lenovo Y760 " + keyboardToString(keyboard_type);
@@ -177,15 +167,13 @@ RGBController_LenovoUSB::RGBController_LenovoUSB(LenovoUSBController* controller
                 {
                     keyboard_type = ISO;
                 }
-                else
-                {
-                    keyboard_type = ANSI;
-                }
             }
 
             description = "Lenovo Y760S " + keyboardToString(keyboard_type);
     }
 
+    LOG_DEBUG("[Lenovo Controller] detected: %s", description.c_str());
+
     SetupZones();
 }
 
@@ -220,10 +208,6 @@ void RGBController_LenovoUSB::SetupZones()
                             lenovo_zones.push_back(lenovo_legion_Y740_15_kbd_ansi);
                             break;
                     }
-                    lenovo_zones.push_back(lenovo_legion_Y740_15_logo);
-                    lenovo_zones.push_back(lenovo_legion_Y740_15_pwrbtn);
-                    lenovo_zones.push_back(lenovo_legion_Y740_15_vents);
-                    lenovo_zones.push_back(lenovo_legion_Y740_15_ports);
                     break;
 
                 case SEVENTEEN:
@@ -238,27 +222,27 @@ void RGBController_LenovoUSB::SetupZones()
                             lenovo_zones.push_back(lenovo_legion_Y740_17_kbd_ansi);
                             break;
                     }
-                    lenovo_zones.push_back(lenovo_legion_Y740_17_logo);
-                    lenovo_zones.push_back(lenovo_legion_Y740_17_pwrbtn);
-                    lenovo_zones.push_back(lenovo_legion_Y740_17_vents);
-                    lenovo_zones.push_back(lenovo_legion_Y740_17_ports);
                     break;
             }
+            lenovo_zones.push_back(lenovo_legion_Y740_logo);
+            lenovo_zones.push_back(lenovo_legion_Y740_pwrbtn);
+            lenovo_zones.push_back(lenovo_legion_Y740_vents);
+            lenovo_zones.push_back(lenovo_legion_Y740_ports);
             break;
 
         case LEGION_Y750:
             switch(keyboard_type)
             {
                 case JAPAN:
-                    lenovo_zones.push_back(lenovo_legion_Y750_kbd_jp);
+                    lenovo_zones.push_back(lenovo_legion_Y760_kbd_jp);
                     break;
 
                 case ISO:
-                    lenovo_zones.push_back(lenovo_legion_Y750_kbd_iso);
+                    lenovo_zones.push_back(lenovo_legion_Y760_kbd_iso);
                     break;
 
                 default:
-                    lenovo_zones.push_back(lenovo_legion_Y750_kbd_ansi);
+                    lenovo_zones.push_back(lenovo_legion_Y760_kbd_ansi);
                     break;
             }
             lenovo_zones.push_back(lenovo_legion_Y750_logo);
@@ -270,15 +254,15 @@ void RGBController_LenovoUSB::SetupZones()
             switch(keyboard_type)
             {
                 case JAPAN:
-                    lenovo_zones.push_back(lenovo_legion_Y750_kbd_jp);
+                    lenovo_zones.push_back(lenovo_legion_Y760_kbd_jp);
                     break;
 
                 case ISO:
-                    lenovo_zones.push_back(lenovo_legion_Y750_kbd_iso);
+                    lenovo_zones.push_back(lenovo_legion_Y760_kbd_iso);
                     break;
 
                 default:
-                    lenovo_zones.push_back(lenovo_legion_Y750_kbd_ansi);
+                    lenovo_zones.push_back(lenovo_legion_Y760_kbd_ansi);
                     break;
             }
             break;
@@ -315,6 +299,8 @@ void RGBController_LenovoUSB::SetupZones()
         new_zone.leds_max   = new_zone.leds_count;
         new_zone.leds_min   = new_zone.leds_count;
 
+        LOG_DEBUG("[Lenovo Controller] adding zone: %s with %u LEDs", new_zone.name.c_str(), new_zone.leds_count);
+
         if(lenovo_zones[i].type == ZONE_TYPE_MATRIX)
         {
             new_zone.matrix_map         = new matrix_map_type;

Controllers/LianLiController/LianLiControllerDetect.cpp

@@ -7,10 +7,9 @@
 |  Luca Lovisa 2/20/2021                    |
 \*-----------------------------------------*/
 
-/*-----------------------------------------------------*\
-| OpenRGB includes                                      |
-\*-----------------------------------------------------*/
-#include <hidapi/hidapi.h>
+#include <string>
+#include <vector>
+
 #include "Detector.h"
 #include "ResourceManager.h"
 
@@ -25,6 +24,12 @@
 \*-----------------------------------------------------*/
 #include "RGBController_LianLiUniHub.h"
 #include "RGBController_StrimerLConnect.h"
+#include "LianLiUniHubController.h"
+#include "RGBController_LianLiUniHub.h"
+#include "LianLiUniHubALController.h"
+#include "RGBController_LianLiUniHubAL.h"
+#include "LianLiUniHub_AL10Controller.h"
+#include "RGBController_LianLiUniHub_AL10.h"
 
 /*-----------------------------------------------------*\
 | ENE USB vendor ID                                     |
@@ -40,6 +45,7 @@
 | Fan controller product IDs                            |
 \*-----------------------------------------------------*/
 #define UNI_HUB_PID                                 0x7750
+#define UNI_HUB_AL_PID                              0XA101
 
 /*----------------------------------------------------------------------------*\
 | The Uni Hub is controlled by sending control transfers to various wIndex     |
@@ -73,7 +79,7 @@ void DetectLianLiUniHub(std::vector<RGBController*>&)
         libusb_device_descriptor descriptor;
         ret = libusb_get_device_descriptor(device, &descriptor);
 
-        if (ret < 0)
+        if(ret < 0)
         {
             continue;
         }
@@ -93,6 +99,81 @@ void DetectLianLiUniHub(std::vector<RGBController*>&)
     }
 }
 
+void DetectLianLiUniHub_AL10(std::vector<RGBController*>&)
+{
+    libusb_device** devices = nullptr;
+
+    int ret;
+
+    ret = libusb_init(NULL);
+    if(ret < 0)
+    {
+        return;
+    }
+
+    ret = libusb_get_device_list(NULL, &devices);
+    if(ret < 0)
+    {
+        return;
+    }
+
+    int deviceCount = ret;
+
+    for(int i = 0; i < deviceCount; i++)
+    {
+        libusb_device* device = devices[i];
+        libusb_device_descriptor descriptor;
+        ret = libusb_get_device_descriptor(device, &descriptor);
+
+        if(ret < 0)
+        {
+            continue;
+        }
+
+        if( descriptor.idVendor  == ENE_USB_VID
+         && descriptor.idProduct == UNI_HUB_AL_PID)
+        {
+            LianLiUniHub_AL10Controller*     controller     = new LianLiUniHub_AL10Controller(device, &descriptor);
+            RGBController_LianLiUniHub_AL10* rgb_controller = new RGBController_LianLiUniHub_AL10(controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+    }
+
+    if(devices != nullptr)
+    {
+        libusb_free_device_list(devices, 1);
+    }
+}   /* DetectLianLiUniHub_AL10() */
+
+void DetectLianLiUniHubAL(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        LianLiUniHubALController* controller = new LianLiUniHubALController(dev, info->path, info->product_id, name);
+
+        std::string firmwareVersion = controller->GetFirmwareVersionString();
+
+        if(firmwareVersion == "v1.7")
+        {
+            RGBController_LianLiUniHubAL* rgb_controller = new RGBController_LianLiUniHubAL(controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+        else if(firmwareVersion == "v1.0")
+        {
+            delete controller;
+            REGISTER_DETECTOR("Lian Li Uni Hub - AL", DetectLianLiUniHub_AL10);
+        }
+        else
+        {
+            delete controller;
+            return;
+        }
+
+    }
+}   /* DetectLianLiUniHubAL() */
+
 void DetectStrimerControllers(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -108,6 +189,7 @@ void DetectStrimerControllers(hid_device_info* info, const std::string& name)
 }
 
 REGISTER_DETECTOR("Lian Li Uni Hub", DetectLianLiUniHub);
+REGISTER_HID_DETECTOR_IPU("Lian Li Uni Hub - AL", DetectLianLiUniHubAL,    ENE_USB_VID,  UNI_HUB_AL_PID,           0x01,  0xFF72, 0xA1);
 /*---------------------------------------------------------------------------------------------------------*\
 | Entries for dynamic UDEV rules                                                                            |
 |                                                                                                           |

Controllers/LianLiController/LianLiUniHubALController.cpp

@@ -0,0 +1,402 @@
+/*-----------------------------------------*\
+|  LianLiUniHubALController.cpp             |
+|                                           |
+|  Driver for Lian Li Uni Hub AL USB        |
+|  lighting controller                      |
+|                                           |
+|  Oliver P 04/26/2022                      |
+|  Credit to Luca Lovisa for original work. |
+\*-----------------------------------------*/
+
+#include "LianLiUniHubALController.h"
+
+#include <string.h>
+
+using namespace std::chrono_literals;
+
+LianLiUniHubALController::LianLiUniHubALController(hid_device* dev_handle, const char* path, unsigned short pid, std::string dev_name)
+{
+    dev             = dev_handle;
+    dev_pid         = pid;
+    location        = path;
+    name            = dev_name;
+}
+
+LianLiUniHubALController::~LianLiUniHubALController()
+{
+    hid_close(dev);
+}
+
+std::string LianLiUniHubALController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string LianLiUniHubALController::GetFirmwareVersionString()
+{
+    wchar_t product_string[40];
+    int ret = hid_get_product_string(dev, product_string, 40);
+
+    if (ret != 0)
+    {
+        return ("");
+    }
+
+    std::wstring return_wstring = product_string;
+    std::string return_string(return_wstring.begin(),return_wstring.end());
+
+    return(return_string.substr(return_string.find_last_of("-")+1,4).c_str());
+}
+
+std::string LianLiUniHubALController::GetName()
+{
+    return(name);
+}
+
+std::string LianLiUniHubALController::GetSerialString()
+{
+    wchar_t serial_string[20];
+    int ret = hid_get_serial_number_string(dev, serial_string, 20);
+
+    if (ret != 0)
+    {
+        return ("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+
+}
+
+void LianLiUniHubALController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors, float brightness)
+{
+    unsigned char   fan_led_data[96];
+    unsigned char   edge_led_data[144];
+    int             fan_idx = 0;
+    int             mod_led_idx;
+    int             cur_led_idx;
+
+    if(num_colors == 0)
+    {
+        return;     // Do nothing, channel isn't in use
+    }
+
+    for(unsigned int led_idx = 0; led_idx < num_colors; led_idx++)
+    {
+        mod_led_idx = (led_idx % 20);
+
+        if((mod_led_idx == 0) && (led_idx != 0))
+        {
+            fan_idx++;
+        }
+
+        /*---------------------------------------------------------*\
+        | Limiter to protect LEDs                                   |
+        \*---------------------------------------------------------*/
+        if(UNIHUB_AL_LED_LIMITER && RGBGetRValue(colors[led_idx]) > 153 && (RGBGetRValue(colors[led_idx]) == RGBGetBValue(colors[led_idx])) && (RGBGetRValue(colors[led_idx]) == RGBGetGValue(colors[led_idx])) )
+        {
+            colors[led_idx] = ToRGBColor(153,153,153);
+        }
+
+        if(mod_led_idx < 8)         // Fan LEDs, 8 LEDs per fan
+        {
+            //Determine current position of led_data array from colors array
+            cur_led_idx = ((mod_led_idx + (fan_idx * 8)) * 3);
+
+            fan_led_data[cur_led_idx + 0] = RGBGetRValue(colors[led_idx]) * brightness;
+            fan_led_data[cur_led_idx + 1] = RGBGetBValue(colors[led_idx]) * brightness;
+            fan_led_data[cur_led_idx + 2] = RGBGetGValue(colors[led_idx]) * brightness;
+        }
+        else                        // Edge LEDs, 12 LEDs per fan
+        {
+            //Determine current position of led_data array from colors array
+            cur_led_idx = (((mod_led_idx - 8) + (fan_idx * 12)) * 3);
+
+            edge_led_data[cur_led_idx + 0]  = RGBGetRValue(colors[led_idx]) * brightness;
+            edge_led_data[cur_led_idx + 1]  = RGBGetBValue(colors[led_idx]) * brightness;
+            edge_led_data[cur_led_idx + 2]  = RGBGetGValue(colors[led_idx]) * brightness;
+        }
+    }
+
+    /*---------------------------------------------------------*\
+    | Send fan LED data                                         |
+    \*---------------------------------------------------------*/
+
+    SendStartAction
+    (
+        channel,            // Current channel
+        (fan_idx + 1)       // Number of fans
+    );
+
+    SendColorData
+    (
+        channel,            // Channel
+        0,                  // 0 = Fan, 1 = Edge
+        (fan_idx + 1)*8,
+        fan_led_data
+    );
+
+    SendCommitAction
+    (
+        channel,                                // Channel
+        0,                                      // 0 = Fan, 1 = Edge
+        UNIHUB_AL_LED_MODE_STATIC_COLOR,        // Effect
+        UNIHUB_AL_LED_SPEED_000,                // Speed
+        UNIHUB_AL_LED_DIRECTION_LTR,            // Direction
+        UNIHUB_AL_LED_BRIGHTNESS_100            // Brightness
+    );
+
+    /*---------------------------------------------------------*\
+    | Send edge LED data                                        |
+    \*---------------------------------------------------------*/
+    SendStartAction
+    (
+        channel,            // Current channel
+        (fan_idx + 1)       // Number of fans
+    );
+
+    SendColorData
+    (
+        channel,            // Channel
+        1,                  // 0 = Fan, 1 = Edge
+        (fan_idx + 1)*12,
+        edge_led_data
+    );
+
+    SendCommitAction
+    (
+        channel,                                // Channel
+        1,                                      // 0 = Fan, 1 = Edge
+        UNIHUB_AL_LED_MODE_STATIC_COLOR,        // Effect
+        UNIHUB_AL_LED_SPEED_000,                // Speed
+        UNIHUB_AL_LED_DIRECTION_LTR,            // Direction
+        UNIHUB_AL_LED_BRIGHTNESS_100            // Brightness
+    );
+
+}
+
+void LianLiUniHubALController::SetChannelMode(unsigned char channel, unsigned int mode_value, std::vector<RGBColor> colors, unsigned int num_colors, unsigned int num_fans, bool upd_both_fan_edge, unsigned int brightness, unsigned int speed, unsigned int direction)
+{
+    static unsigned int brightness_code[5] =
+    {
+        UNIHUB_AL_LED_BRIGHTNESS_000,
+        UNIHUB_AL_LED_BRIGHTNESS_025,
+        UNIHUB_AL_LED_BRIGHTNESS_050,
+        UNIHUB_AL_LED_BRIGHTNESS_075,
+        UNIHUB_AL_LED_BRIGHTNESS_100
+    };
+
+    static unsigned int speed_code[5] =
+    {
+        UNIHUB_AL_LED_SPEED_000,
+        UNIHUB_AL_LED_SPEED_025,
+        UNIHUB_AL_LED_SPEED_050,
+        UNIHUB_AL_LED_SPEED_075,
+        UNIHUB_AL_LED_SPEED_100
+    };
+
+    unsigned char   fan_led_data[96];
+    unsigned char   edge_led_data[144];
+    int             cur_led_idx;
+    float           brightness_scale;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(fan_led_data, 0x00, sizeof(fan_led_data));
+    memset(edge_led_data, 0x00, sizeof(edge_led_data));
+
+    if(num_colors)                                          // Update led_data if there's colors
+    {
+        switch(mode_value)
+        {
+            case UNIHUB_AL_LED_MODE_STATIC_COLOR:           // Static mode requires a full data array
+            case UNIHUB_AL_LED_MODE_BREATHING:
+                brightness_scale = static_cast<float>(brightness)/4;
+                for(unsigned int i = 0; i < 4; i++)
+                {
+                    /*---------------------------------------------------------*\
+                    | Limiter to protect LEDs                                   |
+                    \*---------------------------------------------------------*/
+                    if(UNIHUB_AL_LED_LIMITER && RGBGetRValue(colors[i]) > 153 && (RGBGetRValue(colors[i]) == RGBGetBValue(colors[i])) && (RGBGetRValue(colors[i]) == RGBGetGValue(colors[i])) )
+                    {
+                        colors[i] = ToRGBColor(153,153,153);
+                    }
+
+                    for(unsigned int led_idx = 0; led_idx < 22; led_idx += 3)
+                    {
+                        cur_led_idx = (i * 8 * 3) + led_idx;
+                        fan_led_data[cur_led_idx + 0] = (RGBGetRValue(colors[i]) * brightness_scale);
+                        fan_led_data[cur_led_idx + 1] = (RGBGetBValue(colors[i]) * brightness_scale);
+                        fan_led_data[cur_led_idx + 2] = (RGBGetGValue(colors[i]) * brightness_scale);
+                    }
+
+                    for(unsigned int led_idx = 0; led_idx < 34; led_idx += 3)
+                    {
+                        cur_led_idx = (i * 12 * 3) + led_idx;
+                        edge_led_data[cur_led_idx + 0] = (RGBGetRValue(colors[i]) * brightness_scale);
+                        edge_led_data[cur_led_idx + 1] = (RGBGetBValue(colors[i]) * brightness_scale);
+                        edge_led_data[cur_led_idx + 2] = (RGBGetGValue(colors[i]) * brightness_scale);
+                    }
+                }
+                break;
+
+            default:
+                colors.resize(4);
+                for(unsigned int i = num_colors; i < 4; i++)
+                {
+                    colors[i] = 0x00;
+                }
+
+                // needs a 48 length array of 4 colors, even if less are defined
+                for(unsigned int i = 0; i < 4; i++)
+                {
+                    for(unsigned int j = 0; j < 4; j++)
+                    {
+                        cur_led_idx = (i * 12) + (j * 3);
+                        fan_led_data[cur_led_idx + 0] = RGBGetRValue(colors[j]);
+                        fan_led_data[cur_led_idx + 1] = RGBGetBValue(colors[j]);
+                        fan_led_data[cur_led_idx + 2] = RGBGetGValue(colors[j]);
+                    }
+                }
+                break;
+       }
+
+    }
+
+    SendStartAction
+    (
+        channel,                        // Current channel
+        (num_fans + 1)                  // Number of fans
+    );
+
+    SendColorData
+    (
+        channel,                        // Channel
+        0,                              // 0 = Fan, 1 = Edge
+        (num_fans + 1)*8,
+        fan_led_data                        // Data
+    );
+
+    SendCommitAction
+    (
+        channel,                        // Channel
+        0,                              // 0 = Fan, 1 = Edge
+        mode_value,                     // Effect
+        speed_code[speed],              // Speed
+        direction,                      // Direction
+        brightness_code[brightness]     // Brightness
+    );
+
+    if(upd_both_fan_edge)
+    {
+        SendStartAction
+        (
+            channel,                    // Current channel
+            (num_fans + 1)              // Number of fans
+        );
+
+        SendColorData
+        (
+            channel,                    // Channel
+            1,                          // 0 = Fan, 1 = Edge
+            (num_fans + 1)*12,
+            edge_led_data
+        );
+
+        SendCommitAction
+        (
+            channel,                    // Channel
+            1,                          // 0 = Fan, 1 = Edge
+            mode_value,                 // Effect
+            speed_code[speed],          // Speed
+            direction,                  // Direction
+            brightness_code[brightness] // Brightness
+        );
+    }
+}
+
+void LianLiUniHubALController::SendStartAction(unsigned char channel, unsigned int num_fans)
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = UNIHUB_AL_TRANSACTION_ID;
+    usb_buf[0x01]   = 0x10;
+    usb_buf[0x02]   = 0x40;
+    usb_buf[0x03]   = channel + 1;
+    usb_buf[0x04]   = num_fans;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    std::this_thread::sleep_for(5ms);
+
+}
+
+void LianLiUniHubALController::SendColorData(unsigned char   channel, unsigned int fan_or_edge, unsigned int    num_leds, unsigned char*  led_data)
+{
+    /*---------------------------------------------------------*\
+    | Send edge LED data                                        |
+    \*---------------------------------------------------------*/
+
+    unsigned char usb_buf[146];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = UNIHUB_AL_TRANSACTION_ID;
+    usb_buf[0x01]   = 0x30 + fan_or_edge + (channel * 2); // Channel+device (30 = channel 1 edge, 31 = channel 1 edge, 32 = channel 2 fan, 33 = channel 2 edge, etc.)
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x02], led_data, num_leds * 3);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 146);
+    std::this_thread::sleep_for(5ms);
+}
+
+void LianLiUniHubALController::SendCommitAction(unsigned char channel, unsigned int fan_or_edge, unsigned char effect, unsigned char speed, unsigned int direction, unsigned int brightness)
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = UNIHUB_AL_TRANSACTION_ID;
+    usb_buf[0x01]   = 0x10 + fan_or_edge + (channel*2); // Channel+device (10 = channel 1 fan, 11 = channel 1 edge, 12 = channel 2 fan, 13 = chanell 2 edge, etc.)
+    usb_buf[0x02]   = effect;                           // Effect
+    usb_buf[0x03]   = speed;                            // Speed, 02=0%, 01=25%, 00=50%, ff=75%, fe=100%
+    usb_buf[0x04]   = direction;                        // Direction, right=00, left=01
+    usb_buf[0x05]   = brightness;                       // Brightness, 0=100%, 1= 75%, 2 = 50%, 3 = 25%, 8 = 0%
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    std::this_thread::sleep_for(5ms);
+}

Controllers/LianLiController/LianLiUniHubALController.h

@@ -0,0 +1,229 @@
+/*-----------------------------------------*\
+|  LianLiHubALController.h                  |
+|                                           |
+|  Definitions and types for Lian Li AL120  |
+|                                           |
+|  Oliver P 04/26/2022                      |
+|  Credit to Luca Lovisa for original work. |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+/*----------------------------------------------------------------------------*\
+| Global definitions.                                                          |
+\*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*\
+| Definitions related to zone Sizes                                            |
+\*----------------------------------------------------------------------------*/
+
+
+enum
+{
+    UNIHUB_AL_CHANNEL_COUNT              = 0x04,   /* Channel count                   */
+    UNIHUB_AL_CHAN_FANLED_COUNT          = 0x20,   /* Max-LED per channel count - 32  */
+    UNIHUB_AL_CHAN_EDGELED_COUNT         = 0x30,   /* Max-LED per channel count - 48  */
+    UNIHUB_AL_CHAN_LED_COUNT             = 0x50,   /* Max-LED per channel count - 80  */
+};
+
+/*----------------------------------------------------------------------------*\
+| Definitions related to LED configuration.                                    |
+\*----------------------------------------------------------------------------*/
+
+// Used for sync'd mode between Fan and Edge
+
+enum
+{
+    UNIHUB_AL_LED_MODE_RAINBOW           = 0x28,   /* Rainbow mode           - Calls Fan only */
+    UNIHUB_AL_LED_MODE_RAINBOW_MORPH     = 0x35,   /* Rainbow Morph mode     - Calls Fan only */
+    UNIHUB_AL_LED_MODE_STATIC_COLOR      = 0x01,   /* Static Color mode       */
+    UNIHUB_AL_LED_MODE_BREATHING         = 0x02,   /* Breathing mode          */
+    UNIHUB_AL_LED_MODE_TAICHI            = 0x2C,   /* Neon mode              - Calls Fan only */
+    UNIHUB_AL_LED_MODE_COLOR_CYCLE       = 0x2B,   /* Color Cycle mode       - Calls Fan only */
+    UNIHUB_AL_LED_MODE_RUNWAY            = 0x1A,   /* Runway mode             */
+    UNIHUB_AL_LED_MODE_METEOR            = 0x19,   /* Meteor mode             */
+    UNIHUB_AL_LED_MODE_WARNING           = 0x2D,   /* Warning mode           - Calls Fan only */
+    UNIHUB_AL_LED_MODE_VOICE             = 0x2E,   /* Voice mode             - Calls Fan only */
+    UNIHUB_AL_LED_MODE_SPINNING_TEACUP   = 0x38,   /* Spinning Teacup mode   - Calls Fan only */
+    UNIHUB_AL_LED_MODE_TORNADO           = 0x36,   /* Tornado mode           - Calls Fan only */
+    UNIHUB_AL_LED_MODE_MIXING            = 0x2F,   /* Mixing mode            - Calls Fan only */
+    UNIHUB_AL_LED_MODE_STACK             = 0x30,   /* Stack mode             - Calls Fan only */
+    UNIHUB_AL_LED_MODE_STAGGGERED        = 0x37,   /* Stagggered mode        - Calls Fan only */
+    UNIHUB_AL_LED_MODE_TIDE              = 0x31,   /* Tide mode              - Calls Fan only */
+    UNIHUB_AL_LED_MODE_SCAN              = 0x32,   /* Scan mode              - Calls Fan only */
+    UNIHUB_AL_LED_MODE_CONTEST           = 0x33,   /* Contest mode           - Calls Fan only */
+
+};
+
+enum
+{
+    UNIHUB_AL_LED_SPEED_000              = 0x02,   /* Very slow speed         */
+    UNIHUB_AL_LED_SPEED_025              = 0x01,   /* Rather slow speed       */
+    UNIHUB_AL_LED_SPEED_050              = 0x00,   /* Medium speed            */
+    UNIHUB_AL_LED_SPEED_075              = 0xFF,   /* Rather fast speed       */
+    UNIHUB_AL_LED_SPEED_100              = 0xFE,   /* Very fast speed         */
+};
+
+enum
+{
+    UNIHUB_AL_LED_DIRECTION_LTR          = 0x00,   /* Left-to-Right direction */
+    UNIHUB_AL_LED_DIRECTION_RTL          = 0x01,   /* Right-to-Left direction */
+};
+
+enum
+{
+    UNIHUB_AL_LED_BRIGHTNESS_000         = 0x08,   /* Very dark (off)         */
+    UNIHUB_AL_LED_BRIGHTNESS_025         = 0x03,   /* Rather dark             */
+    UNIHUB_AL_LED_BRIGHTNESS_050         = 0x02,   /* Medium bright           */
+    UNIHUB_AL_LED_BRIGHTNESS_075         = 0x01,   /* Rather bright           */
+    UNIHUB_AL_LED_BRIGHTNESS_100         = 0x00,   /* Very bright             */
+};
+
+enum
+{
+    UNIHUB_AL_LED_LIMITER                = 0x01    /* Limit the color white to 999999 as per manufacturer limits */
+};
+
+
+/*----------------------------------------------------------------------------*\
+| Definitions related to packet configuration.                                 |
+\*----------------------------------------------------------------------------*/
+
+enum
+{
+    UNIHUB_AL_TRANSACTION_ID            = 0xE0, /* Command value to start all packets */
+};
+
+/*----------------------------------------------------------------------------*\
+| Uni Hub AL controller.                                                       |
+\*----------------------------------------------------------------------------*/
+
+class LianLiUniHubALController
+{
+
+
+public:
+    LianLiUniHubALController(hid_device* dev_handle, const char* path, unsigned short pid, std::string dev_name);
+    ~LianLiUniHubALController();
+
+    std::string                 GetDeviceLocation();
+    std::string                 GetFirmwareVersionString();
+    std::string                 GetName();
+    std::string                 GetSerialString();
+
+    void                SetChannelMode
+                                (
+                                unsigned char   channel,
+                                unsigned int    mode_value,
+                                std::vector<RGBColor>        colors,    // Not a pointer because the copy gets resized
+                                unsigned int    num_colors,
+                                unsigned int    num_fans,
+                                bool            upd_both_fan_edge,
+                                unsigned int    brightness,
+                                unsigned int    speed,
+                                unsigned int    direction
+                                );
+
+    void                SetChannelLEDs
+                                (
+                                unsigned char   channel,
+                                RGBColor *      colors,
+                                unsigned int    num_colors,
+                                float           brightness
+                                );
+
+    void                SendStartAction
+                                (
+                                unsigned char   channel,
+                                unsigned int    num_fans
+                                );
+
+    void                SendColorData
+                                (
+                                unsigned char   channel,            // Zone index
+                                unsigned int    fan_or_edge,        // 1 (Fan) or 0 (Edge) modifer to channel
+                                unsigned int    num_leds,
+                                unsigned char*  led_data            // Color data payload
+                                );
+
+    void                SendCommitAction
+                                (
+                                unsigned char   channel,            // Zone index
+                                unsigned int    fan_or_edge,        // 1 (Fan) or 0 (Edge) modifer to channel
+                                unsigned char   effect,
+                                unsigned char   speed,
+                                unsigned int    direction,
+                                unsigned int    brightness
+                                );
+
+private:
+    /* The Uni Hub requires colors in RBG order */
+    struct Color
+    {
+        uint8_t r;
+        uint8_t b;
+        uint8_t g;
+    };
+
+    /* The values correspond to the definitions above */
+    struct Channel
+    {
+        uint8_t  index;
+
+        uint8_t  anyFanCountOffset;
+        uint8_t  anyFanCount;
+
+        uint16_t ledActionAddress;
+        uint16_t ledCommitAddress;
+        uint16_t ledModeAddress;
+        uint16_t ledSpeedAddress;
+        uint16_t ledDirectionAddress;
+        uint16_t ledBrightnessAddress;
+
+        Color    colors[UNIHUB_AL_CHAN_FANLED_COUNT];
+
+        uint8_t  ledMode;
+        uint8_t  ledSpeed;
+        uint8_t  ledDirection;
+        uint8_t  ledBrightness;
+
+        uint16_t fanHubActionAddress;
+        uint16_t fanHubCommitAddress;
+
+        uint16_t fanPwmActionAddress;
+        uint16_t fanPwmCommitAddress;
+        uint16_t fanRpmActionAddress;
+
+        uint16_t fanSpeed;
+    };
+
+private:
+    hid_device*             dev;
+    unsigned short          dev_pid;
+
+    /*---------------------------------------------------------*\
+    | Device-specific protocol settings                         |
+    \*---------------------------------------------------------*/
+    unsigned char           dev_transaction_id;
+    unsigned char           dev_led_id;
+
+    /*---------------------------------------------------------*\
+    | Device information strings                                |
+    \*---------------------------------------------------------*/
+    std::string             firmware_version;
+    std::string             location;
+    std::string             name;
+    device_type             type;
+
+    /*---------------------------------------------------------*\
+    | HID report index for request and response                 |
+    \*---------------------------------------------------------*/
+    unsigned char           report_index;
+    unsigned char           response_index;
+
+};

Controllers/LianLiController/LianLiUniHub_AL10Controller.cpp

@@ -0,0 +1,788 @@
+/*-----------------------------------------*\
+|  LianLiUniHub_AL10Controller.cpp          |
+|                                           |
+|  Driver for Lian Li Uni Hub USB           |
+|  lighting controller                      |
+|                                           |
+|  Oliver P 05/05/2022                      |
+|  Credit to Luca Lovisa for original work. |
+\*-----------------------------------------*/
+
+#include "LianLiUniHub_AL10Controller.h"
+
+#include <cstring>
+
+using namespace std::chrono_literals;
+
+/*----------------------------------------------------------------------------*\
+| The Uni Hub is controlled by sending control transfers to various wIndex     |
+| addresses, allthough it announces some kind of hid interface. Hence it       |
+| requires libusb as hidapi provides no wIndex customization.                  |
+\*----------------------------------------------------------------------------*/
+
+LianLiUniHub_AL10Controller::LianLiUniHub_AL10Controller
+    (
+    libusb_device*              device,
+    libusb_device_descriptor*   descriptor
+    )
+{
+    int ret;
+
+    /*--------------------------------------------------------------------*\
+    | Open the libusb device.                                              |
+    \*--------------------------------------------------------------------*/
+    ret = libusb_open(device, &handle);
+
+    if(ret < 0)
+    {
+        return;
+    }
+
+    /*--------------------------------------------------------------------*\
+    | Fill in the location string from USB port numbers.                   |
+    \*--------------------------------------------------------------------*/
+    uint8_t ports[7];
+
+    ret = libusb_get_port_numbers(device, ports, sizeof(ports));
+
+    if(ret > 0)
+    {
+        location = "USB: ";
+
+        for (int i = 0; i < ret; i ++)
+        {
+            location += std::to_string(ports[i]);
+            location.push_back(':');
+        }
+
+        location.pop_back();
+    }
+
+    /*--------------------------------------------------------------------*\
+    | Fill in the serial string from the string descriptor                 |
+    \*--------------------------------------------------------------------*/
+    char serialStr[64];
+
+    ret = libusb_get_string_descriptor_ascii(handle, descriptor->iSerialNumber, reinterpret_cast<unsigned char*>(serialStr), sizeof(serialStr));
+
+    if(ret > 0)
+    {
+        serial = std::string(serialStr, ret);
+    }
+
+    /*--------------------------------------------------------------------*\
+    | Fill in the version string by reading version from device.           |
+    \*--------------------------------------------------------------------*/
+    version = ReadVersion();
+
+    /*--------------------------------------------------------------------*\
+    | Create channels with their static configuration and "sane" defaults. |
+    \*--------------------------------------------------------------------*/
+    Channel channel1;
+    channel1.index                = 0;
+    channel1.anyFanCountOffset    = UNIHUB_AL10_ANY_C1_FAN_COUNT_OFFSET;
+    channel1.anyFanCount          = UNIHUB_AL10_ANY_FAN_COUNT_001;
+    channel1.ledActionAddress     = UNIHUB_AL10_LED_C1_ACTION_ADDRESS;
+    channel1.ledCommitAddress     = UNIHUB_AL10_LED_C1_COMMIT_ADDRESS;
+    channel1.ledModeAddress       = UNIHUB_AL10_LED_C1_MODE_ADDRESS;
+    channel1.ledSpeedAddress      = UNIHUB_AL10_LED_C1_SPEED_ADDRESS;
+    channel1.ledDirectionAddress  = UNIHUB_AL10_LED_C1_DIRECTION_ADDRESS;
+    channel1.ledBrightnessAddress = UNIHUB_AL10_LED_C1_BRIGHTNESS_ADDRESS;
+    channel1.ledMode              = UNIHUB_AL10_LED_MODE_RAINBOW;
+    channel1.ledSpeed             = UNIHUB_AL10_LED_SPEED_100;
+    channel1.ledDirection         = UNIHUB_AL10_LED_DIRECTION_LTR;
+    channel1.ledBrightness        = UNIHUB_AL10_LED_BRIGHTNESS_100;
+    channel1.fanHubActionAddress  = UNIHUB_AL10_FAN_C1_HUB_ACTION_ADDRESS;
+    channel1.fanHubCommitAddress  = UNIHUB_AL10_FAN_C1_HUB_COMMIT_ADDRESS;
+    channel1.fanPwmActionAddress  = UNIHUB_AL10_FAN_C1_PWM_ACTION_ADDRESS;
+    channel1.fanPwmCommitAddress  = UNIHUB_AL10_FAN_C1_PWM_COMMIT_ADDRESS;
+    channel1.fanRpmActionAddress  = UNIHUB_AL10_FAN_C1_RPM_ACTION_ADDRESS;
+    channel1.fanSpeed             = UNIHUB_AL10_FAN_SPEED_QUIET;
+    channels[0] = channel1;
+
+    Channel channel2;
+    channel2.index                = 1;
+    channel2.anyFanCountOffset    = UNIHUB_AL10_ANY_C2_FAN_COUNT_OFFSET;
+    channel2.anyFanCount          = UNIHUB_AL10_ANY_FAN_COUNT_001;
+    channel2.ledActionAddress     = UNIHUB_AL10_LED_C2_ACTION_ADDRESS;
+    channel2.ledCommitAddress     = UNIHUB_AL10_LED_C2_COMMIT_ADDRESS;
+    channel2.ledModeAddress       = UNIHUB_AL10_LED_C2_MODE_ADDRESS;
+    channel2.ledSpeedAddress      = UNIHUB_AL10_LED_C2_SPEED_ADDRESS;
+    channel2.ledDirectionAddress  = UNIHUB_AL10_LED_C2_DIRECTION_ADDRESS;
+    channel2.ledBrightnessAddress = UNIHUB_AL10_LED_C2_BRIGHTNESS_ADDRESS;
+    channel2.ledMode              = UNIHUB_AL10_LED_MODE_RAINBOW;
+    channel2.ledSpeed             = UNIHUB_AL10_LED_SPEED_100;
+    channel2.ledDirection         = UNIHUB_AL10_LED_DIRECTION_LTR;
+    channel2.ledBrightness        = UNIHUB_AL10_LED_BRIGHTNESS_100;
+    channel2.fanHubActionAddress  = UNIHUB_AL10_FAN_C2_HUB_ACTION_ADDRESS;
+    channel2.fanHubCommitAddress  = UNIHUB_AL10_FAN_C2_HUB_COMMIT_ADDRESS;
+    channel2.fanPwmActionAddress  = UNIHUB_AL10_FAN_C2_PWM_ACTION_ADDRESS;
+    channel2.fanPwmCommitAddress  = UNIHUB_AL10_FAN_C2_PWM_COMMIT_ADDRESS;
+    channel2.fanRpmActionAddress  = UNIHUB_AL10_FAN_C2_RPM_ACTION_ADDRESS;
+    channel2.fanSpeed             = UNIHUB_AL10_FAN_SPEED_QUIET;
+    channels[1] = channel2;
+
+    Channel channel3;
+    channel3.index                = 2;
+    channel3.anyFanCountOffset    = UNIHUB_AL10_ANY_C3_FAN_COUNT_OFFSET;
+    channel3.anyFanCount          = UNIHUB_AL10_ANY_FAN_COUNT_001;
+    channel3.ledActionAddress     = UNIHUB_AL10_LED_C3_ACTION_ADDRESS;
+    channel3.ledCommitAddress     = UNIHUB_AL10_LED_C3_COMMIT_ADDRESS;
+    channel3.ledModeAddress       = UNIHUB_AL10_LED_C3_MODE_ADDRESS;
+    channel3.ledSpeedAddress      = UNIHUB_AL10_LED_C3_SPEED_ADDRESS;
+    channel3.ledDirectionAddress  = UNIHUB_AL10_LED_C3_DIRECTION_ADDRESS;
+    channel3.ledBrightnessAddress = UNIHUB_AL10_LED_C3_BRIGHTNESS_ADDRESS;
+    channel3.ledMode              = UNIHUB_AL10_LED_MODE_RAINBOW;
+    channel3.ledSpeed             = UNIHUB_AL10_LED_SPEED_100;
+    channel3.ledDirection         = UNIHUB_AL10_LED_DIRECTION_LTR;
+    channel3.ledBrightness        = UNIHUB_AL10_LED_BRIGHTNESS_100;
+    channel3.fanHubActionAddress  = UNIHUB_AL10_FAN_C3_HUB_ACTION_ADDRESS;
+    channel3.fanHubCommitAddress  = UNIHUB_AL10_FAN_C3_HUB_COMMIT_ADDRESS;
+    channel3.fanPwmActionAddress  = UNIHUB_AL10_FAN_C3_PWM_ACTION_ADDRESS;
+    channel3.fanPwmCommitAddress  = UNIHUB_AL10_FAN_C3_PWM_COMMIT_ADDRESS;
+    channel3.fanRpmActionAddress  = UNIHUB_AL10_FAN_C3_RPM_ACTION_ADDRESS;
+    channel3.fanSpeed             = UNIHUB_AL10_FAN_SPEED_QUIET;
+    channels[2] = channel3;
+
+    Channel channel4;
+    channel4.index                = 3;
+    channel4.anyFanCountOffset    = UNIHUB_AL10_ANY_C4_FAN_COUNT_OFFSET;
+    channel4.anyFanCount          = UNIHUB_AL10_ANY_FAN_COUNT_001;
+    channel4.ledActionAddress     = UNIHUB_AL10_LED_C4_ACTION_ADDRESS;
+    channel4.ledCommitAddress     = UNIHUB_AL10_LED_C4_COMMIT_ADDRESS;
+    channel4.ledModeAddress       = UNIHUB_AL10_LED_C4_MODE_ADDRESS;
+    channel4.ledSpeedAddress      = UNIHUB_AL10_LED_C4_SPEED_ADDRESS;
+    channel4.ledDirectionAddress  = UNIHUB_AL10_LED_C4_DIRECTION_ADDRESS;
+    channel4.ledBrightnessAddress = UNIHUB_AL10_LED_C4_BRIGHTNESS_ADDRESS;
+    channel4.ledMode              = UNIHUB_AL10_LED_MODE_RAINBOW;
+    channel4.ledSpeed             = UNIHUB_AL10_LED_SPEED_100;
+    channel4.ledDirection         = UNIHUB_AL10_LED_DIRECTION_LTR;
+    channel4.ledBrightness        = UNIHUB_AL10_LED_BRIGHTNESS_100;
+    channel4.fanHubActionAddress  = UNIHUB_AL10_FAN_C4_HUB_ACTION_ADDRESS;
+    channel4.fanHubCommitAddress  = UNIHUB_AL10_FAN_C4_HUB_COMMIT_ADDRESS;
+    channel4.fanPwmActionAddress  = UNIHUB_AL10_FAN_C4_PWM_ACTION_ADDRESS;
+    channel4.fanPwmCommitAddress  = UNIHUB_AL10_FAN_C4_PWM_COMMIT_ADDRESS;
+    channel4.fanRpmActionAddress  = UNIHUB_AL10_FAN_C4_RPM_ACTION_ADDRESS;
+    channel4.fanSpeed             = UNIHUB_AL10_FAN_SPEED_QUIET;
+    channels[3] = channel4;
+}
+
+LianLiUniHub_AL10Controller::~LianLiUniHub_AL10Controller()
+{
+    CloseLibusb();
+}
+
+std::string LianLiUniHub_AL10Controller::GetVersion()
+{
+    return version;
+}
+
+std::string LianLiUniHub_AL10Controller::GetLocation()
+{
+    return location;
+}
+
+std::string LianLiUniHub_AL10Controller::GetSerial()
+{
+    return serial;
+}
+
+void LianLiUniHub_AL10Controller::SetAnyFanCount(size_t channel, uint8_t count)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
+    {
+        return;
+    }
+
+    channels[channel].anyFanCount = count;
+}
+
+void LianLiUniHub_AL10Controller::SetLedColors(size_t channel, RGBColor* colors, size_t count)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
+    {
+        return;
+    }
+
+    /*-------------------------------------*\
+    | Check for invalid count               |
+    \*-------------------------------------*/
+    if(count > UNIHUB_AL10_CHANLED_COUNT)
+    {
+        count = UNIHUB_AL10_CHANLED_COUNT;
+    }
+
+    /*-------------------------------------*\
+    | Check for mode colors                 |
+    \*-------------------------------------*/
+    size_t i = 0;
+    switch(channels[channel].ledMode)
+    {
+        case UNIHUB_AL10_LED_MODE_RAINBOW:
+            channels[channel].colors[0].r = 0xFC;
+            channels[channel].colors[0].b = 0xFC;
+            channels[channel].colors[0].g = 0xFC;
+            i = 1;
+            break;
+        case UNIHUB_AL10_LED_MODE_BREATHING:
+            for(unsigned int color_idx = 0; color_idx < count; color_idx++)
+            {
+                for(unsigned int led_idx = 0; led_idx < 20; led_idx++)
+                {
+                    channels[channel].colors[led_idx + (color_idx * 20)].r = RGBGetRValue(colors[color_idx]);
+                    channels[channel].colors[led_idx + (color_idx * 20)].b = RGBGetBValue(colors[color_idx]);
+                    channels[channel].colors[led_idx + (color_idx * 20)].g = RGBGetGValue(colors[color_idx]);
+                    i++;
+                }
+            }
+            break;
+        case UNIHUB_AL10_LED_MODE_SCAN:
+            for(; i < 20; i++)
+            {
+                channels[channel].colors[i].r = 0x00;
+                channels[channel].colors[i].b = 0x00;
+                channels[channel].colors[i].g = 0x00;
+            }
+
+            channels[channel].colors[0x00].r = RGBGetRValue(colors[0]);
+            channels[channel].colors[0x00].b = RGBGetBValue(colors[0]);
+            channels[channel].colors[0x00].g = RGBGetGValue(colors[0]);
+
+            channels[channel].colors[0x08].r = RGBGetRValue(colors[1]);
+            channels[channel].colors[0x08].b = RGBGetBValue(colors[1]);
+            channels[channel].colors[0x08].g = RGBGetGValue(colors[1]);
+
+            break;
+        default:
+            for(; i < count; i++)
+            {
+                channels[channel].colors[i].r = (RGBGetRValue(colors[i]));
+                channels[channel].colors[i].b = (RGBGetBValue(colors[i]));
+                channels[channel].colors[i].g = (RGBGetGValue(colors[i]));
+
+                // Limiter to protect LEDs
+                if(UNIHUB_AL10_LED_LIMITER && (channels[channel].colors[i].r > 153) && (channels[channel].colors[i].r == channels[channel].colors[i].b) && (channels[channel].colors[i].r == channels[channel].colors[i].g))
+                {
+                    channels[channel].colors[i].r = 153;
+                    channels[channel].colors[i].b = 153;
+                    channels[channel].colors[i].g = 153;
+                }
+            }
+    }
+    /* Set all remaining leds to black */
+    for(; i < UNIHUB_AL10_CHANLED_COUNT; i++)
+    {
+        channels[channel].colors[i].r = 0x00;
+        channels[channel].colors[i].b = 0x00;
+        channels[channel].colors[i].g = 0x00;
+    }
+
+
+
+}
+
+void LianLiUniHub_AL10Controller::SetLedMode(size_t channel, uint8_t mode)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
+    {
+        return;
+    }
+
+    channels[channel].ledMode = mode;
+}
+
+void LianLiUniHub_AL10Controller::SetLedSpeed(size_t channel, uint8_t speed)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
+    {
+        return;
+    }
+
+    channels[channel].ledSpeed = speed;
+}
+
+void LianLiUniHub_AL10Controller::SetLedDirection(size_t channel, uint8_t direction)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
+    {
+        return;
+    }
+
+    channels[channel].ledDirection = direction;
+}
+
+void LianLiUniHub_AL10Controller::SetLedBrightness(size_t channel, uint8_t brightness)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
+    {
+        return;
+    }
+
+    channels[channel].ledBrightness = brightness;
+}
+
+uint16_t LianLiUniHub_AL10Controller::GetFanSpeed(size_t channel)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
+    {
+        return 0;
+    }
+
+    return channels[channel].fanSpeed;
+}
+
+void LianLiUniHub_AL10Controller::SetFanSpeed(size_t channel, uint16_t speed)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
+    {
+        return;
+    }
+
+    channels[channel].fanSpeed = speed;
+}
+
+void LianLiUniHub_AL10Controller::EnableRgbhMode()
+{
+    rgbhModeEnabled = true;
+}
+
+void LianLiUniHub_AL10Controller::DisableRgbhMode()
+{
+    rgbhModeEnabled = false;
+}
+
+void LianLiUniHub_AL10Controller::EnableSyncMode()
+{
+    syncModeEnabled = true;
+}
+
+void LianLiUniHub_AL10Controller::DisableSyncMode()
+{
+    syncModeEnabled = false;
+}
+
+/*----------------------------------------------------------------------------*\
+| The Uni Hub is a PWM and LED controller designed specifically for the Lian   |
+| Li Uni Fans. It can control them by itself using the built-in effect engine  |
+| can also be connected to the mainboard via 4-pin PWM and 3-pin RGB cables    |
+| and forward these signals. The protocol implementation below was build as    |
+| close a possible to the Lian Li L-Connect software.                          |
+|                                                                              |
+| The commands to control the fan speeds and to switch between controller and  |
+| mainboard control is already included, but currently deactivated as OpenRGB  |
+| had no fan control module or controller specific configuration at the time   |
+| of writing.                                                                  |
+\*----------------------------------------------------------------------------*/
+void LianLiUniHub_AL10Controller::Synchronize()
+{
+    /*---------------------------------------------------------------------*\
+    | Configure common settings.                                            |
+    \*---------------------------------------------------------------------*/
+
+    /*---------------------------------------------------------------------*\
+    | Still unsure about this. Probably some sort of configuration          |
+    | initialization                                                        |
+    \*---------------------------------------------------------------------*/
+    uint8_t config_initialization[16];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(config_initialization, 0x00, sizeof(config_initialization));
+
+    config_initialization[0x0F]     = 0x43;                 // Control data
+    config_initialization[0x0F]     = 0x01;                 // Ending data
+
+    SendConfig(UNIHUB_AL10_ACTION_ADDRESS, config_initialization, sizeof(config_initialization));
+
+    for(const Channel& channel : channels)
+    {
+        /*-------------------------------------*\
+        | The Uni Hub doesn't know zero fans    |
+        \*-------------------------------------*/
+        uint8_t anyFanCount = channel.anyFanCount;
+
+        if(anyFanCount == UNIHUB_AL10_ANY_FAN_COUNT_000)
+        {
+            anyFanCount =  UNIHUB_AL10_ANY_FAN_COUNT_001;
+        }
+
+        /*-------------------------------------*\
+        | Configure the physical fan count      |
+        \*-------------------------------------*/
+        uint8_t config_fan_count[16];
+
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(config_fan_count, 0x00, sizeof(config_fan_count));
+
+        config_fan_count[0x01]      = 0x40;                 // Control data
+        config_fan_count[0x02]      = channel.index + 1;    // Channel
+        config_fan_count[0x03]      = anyFanCount + 1;      // Number of fans
+        config_fan_count[0x0F]      = 0x01;                 // Ending data
+
+        SendConfig(UNIHUB_AL10_ACTION_ADDRESS, config_fan_count, sizeof(config_fan_count));
+        //SendCommit(UNIHUB_AL10_COMMIT_ADDRESS);
+    }
+
+    /*--------------------------------------------------------------------*\
+    | Configure channels for sync effects                                  |
+    \*--------------------------------------------------------------------*/
+
+    /*
+    if(syncModeEnabled)
+    {
+        uint8_t config_sync[6];
+        uint8_t config_sync_index = 0;
+
+        config_sync[config_sync_index++] = 0x33;
+
+        for(const Channel& channel : channels)
+        {
+            if(channel.anyFanCount != UNIHUB_AL10_ANY_FAN_COUNT_000)
+            {
+                config_sync[config_sync_index++] = channel.index;
+            }
+        }
+
+        config_sync[config_sync_index++] = 0x08;
+
+        SendConfig(UNIHUB_AL10_ACTION_ADDRESS, config_sync, config_sync_index);
+        SendCommit(UNIHUB_AL10_COMMIT_ADDRESS);
+    }
+
+    */
+
+    /*--------------------------------------------------------------------*\
+    | Configure led settings.                                              |
+    \*--------------------------------------------------------------------*/
+    for(const Channel& channel : channels)
+    {
+        if(channel.anyFanCount != UNIHUB_AL10_ANY_FAN_COUNT_000)
+        {
+            for(unsigned int fan_idx = 0; fan_idx <= UNIHUB_AL10_ANY_FAN_COUNT_004; fan_idx++)
+            {
+                /*-----------------------------*\
+                | Configure fan colors          |
+                \*-----------------------------*/
+                uint8_t fan_config_colors[24];
+                memcpy(fan_config_colors, channel.colors + (fan_idx * 20), sizeof(fan_config_colors));
+
+                SendConfig(channel.ledActionAddress + (60 * fan_idx), fan_config_colors, sizeof(fan_config_colors));
+            }
+
+            /*-----------------------------*\
+            | Configure led mode            |
+            \*-----------------------------*/
+            uint8_t led_config[16];
+
+            /*-----------------------------------------------------*\
+            | Zero out buffer                                       |
+            \*-----------------------------------------------------*/
+            memset(led_config, 0x00, sizeof(led_config));
+
+            led_config[0x01]      = channel.ledMode;       // Effect
+            led_config[0x02]      = channel.ledSpeed;      // Speed
+            led_config[0x03]      = channel.ledDirection;  // Direction
+            led_config[0x09]      = channel.ledBrightness; // Brightness?
+            led_config[0x0F]      = 0x01;                  // Ending data
+
+            SendConfig(UNIHUB_AL10_ACTION_ADDRESS + (channel.index * 32 ), led_config, sizeof(led_config));
+
+            for(unsigned int fan_idx = 0; fan_idx <= UNIHUB_AL10_ANY_FAN_COUNT_004; fan_idx++)
+            {
+                /*-----------------------------*\
+                | Configure rim colors          |
+                \*-----------------------------*/
+                uint8_t rim_config_colors[36];
+                memcpy(rim_config_colors, channel.colors + (fan_idx * 20) + 8, sizeof(rim_config_colors));
+
+                SendConfig(channel.ledActionAddress + 24 + (60 * fan_idx), rim_config_colors, sizeof(rim_config_colors));
+            }
+
+            SendConfig(UNIHUB_AL10_ACTION_ADDRESS + 16 + (channel.index * 32 ), led_config, sizeof(led_config));
+        }
+        /*-----------------------------------------------------------------*\
+        | The Uni Hub doesn't know zero fans so we set them to black        |
+        \*-----------------------------------------------------------------*/
+        else
+        {
+            for(unsigned int fan_idx = 0; fan_idx <= UNIHUB_AL10_ANY_FAN_COUNT_004; fan_idx++)
+            {
+                /*-----------------------------*\
+                | Configure fan colors          |
+                \*-----------------------------*/
+                uint8_t fan_config_colors[24];
+                memset(fan_config_colors, 0x00, sizeof(fan_config_colors));
+
+                SendConfig(channel.ledActionAddress + (60 * fan_idx), fan_config_colors, sizeof(fan_config_colors));
+            }
+
+            /*-----------------------------*\
+            | Configure led mode            |
+            \*-----------------------------*/
+            uint8_t led_config[16];
+
+            /*-----------------------------------------------------*\
+            | Zero out buffer                                       |
+            \*-----------------------------------------------------*/
+            memset(led_config, 0x00, sizeof(led_config));
+
+            led_config[0x01]      = UNIHUB_AL10_LED_MODE_STATIC_COLOR;       // Effect
+            led_config[0x02]      = channel.ledSpeed;      // Speed?
+            led_config[0x03]      = channel.ledDirection;  // direction
+            led_config[0x0F]      = 0x01;                  // Ending data
+
+            SendConfig(UNIHUB_AL10_ACTION_ADDRESS + (channel.index * 32 ), led_config, sizeof(led_config));
+
+            for(unsigned int fan_idx = 0; fan_idx <= UNIHUB_AL10_ANY_FAN_COUNT_004; fan_idx++)
+            {
+                /*-----------------------------*\
+                | Configure rim colors          |
+                \*-----------------------------*/
+                uint8_t rim_config_colors[36];
+                memset(rim_config_colors, 0x00, sizeof(rim_config_colors));
+
+                SendConfig(channel.ledActionAddress + 24 + (60 * fan_idx), rim_config_colors, sizeof(rim_config_colors));
+            }
+
+            SendConfig(UNIHUB_AL10_ACTION_ADDRESS + 16 + (channel.index * 32 ), led_config, sizeof(led_config));
+        }
+    }
+
+    /*--------------------------------------------------------------------*\
+    | Configure fan settings. Comment out until enabling fan control       |
+    \*--------------------------------------------------------------------*/
+//    uint8_t control = 0;
+
+//    /*-------------------------------------*\
+//    | Configure fan settings                |
+//    \*-------------------------------------*/
+//    for(const Channel& channel : channels)
+//    {
+//        if(channel.fanSpeed == UNIHUB_AL10_FAN_SPEED_PWM)
+//        {
+//            /*-----------------------------*\
+//            | Configure the fan to pwm      |
+//            | control                       |
+//            \*-----------------------------*/
+//            uint8_t config_pwm[1] = { 0x00 };
+
+//            control |= (0x01 << channel.index);
+
+//            SendConfig(channel.fanPwmActionAddress, config_pwm, sizeof(config_pwm));
+//            SendCommit(channel.fanPwmCommitAddress);
+//        }
+//        else
+//        {
+//            /*-----------------------------*\
+//            | Configure the fan to hub      |
+//            | control and set speed         |
+//            \*-----------------------------*/
+//            uint8_t config_hub[2] = { (uint8_t)(channel.fanSpeed >> 0x08), (uint8_t)(channel.fanSpeed &  0xFF) };
+
+//            SendConfig(channel.fanHubActionAddress, config_hub, sizeof(config_hub));
+//            SendCommit(channel.fanHubCommitAddress);
+//        }
+//    }
+
+//    /*-------------------------------------*\
+//    | Configure fan control modes           |
+//    \*-------------------------------------*/
+//    uint8_t config_fan_mode[2] = { 0x31, (uint8_t)(0xF0 | control) };
+
+//    SendConfig(UNIHUB_AL10_ACTION_ADDRESS, config_fan_mode, sizeof(config_fan_mode));
+//    SendCommit(UNIHUB_AL10_COMMIT_ADDRESS);
+
+    /*--------------------------------------------------------------------*\
+    | Configure led settings.                                              |
+    \*--------------------------------------------------------------------*/
+//    if(rgbhModeEnabled)
+//    {
+        /*-------------------------------------*\
+        | Configure the leds to hdr control.    |
+        \*-------------------------------------*/
+//        uint8_t config_hdr[2] = { 0x30, 0x01 };
+
+//        SendConfig(UNIHUB_AL10_ACTION_ADDRESS, config_hdr, sizeof(config_hdr));
+//        SendCommit(UNIHUB_AL10_COMMIT_ADDRESS);
+//    }
+//    else
+//    {
+        /*-------------------------------------*\
+        | Configure the leds to hub control     |
+        \*-------------------------------------*/
+//        uint8_t config_hub[2] = { 0x30, 0x00 };
+
+//        SendConfig(UNIHUB_AL10_ACTION_ADDRESS, config_hub, sizeof(config_hub));
+//        SendCommit(UNIHUB_AL10_COMMIT_ADDRESS);
+//    }
+}
+
+uint16_t LianLiUniHub_AL10Controller::ReadFanSpeed(size_t channel)
+{
+    /*-------------------------------------*\
+    | Check for invalid handle              |
+    \*-------------------------------------*/
+    if(handle == nullptr)
+    {
+        return(0);
+    }
+
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel > UNIHUB_AL10_CHANNEL_COUNT)
+    {
+        return(0);
+    }
+
+    uint8_t buffer[2];
+    uint8_t length = sizeof(buffer);
+
+    uint16_t wIndex = channels[channel].fanRpmActionAddress;
+
+    /*-------------------------------------*\
+    | Send packet                           |
+    \*-------------------------------------*/
+    size_t ret = libusb_control_transfer(handle,    /* dev_handle       */
+                                         0xC0,      /* bmRequestType    */
+                                         0x81,      /* bRequest         */
+                                         0x00,      /* wValue           */
+                                         wIndex,    /* wIndex           */
+                                         buffer,    /* data             */
+                                         length,    /* wLength          */
+                                         1000);     /* timeout          */
+
+    /*-------------------------------------*\
+    | Check for communication error         |
+    \*-------------------------------------*/
+    if(ret != length)
+    {
+        return(0);
+    }
+
+    return(*(uint16_t*)buffer);
+}
+
+void LianLiUniHub_AL10Controller::CloseLibusb()
+{
+    if (handle != nullptr)
+    {
+        libusb_close(handle);
+        handle = nullptr;
+    }
+}
+
+std::string LianLiUniHub_AL10Controller::ReadVersion()
+{
+    /*-------------------------------------*\
+    | Check for invalid handle              |
+    \*-------------------------------------*/
+    if(handle == nullptr)
+    {
+        return("");
+    }
+
+    uint8_t buffer[5];
+    uint8_t length = sizeof(buffer);
+
+    /*-------------------------------------*\
+    | Send packet                           |
+    \*-------------------------------------*/
+    size_t ret = libusb_control_transfer(handle,    /* dev_handle       */
+                                         0xC0,      /* bmRequestType    */
+                                         0x81,      /* bRequest         */
+                                         0x00,      /* wValue           */
+                                         0xB500,    /* wIndex           */
+                                         buffer,    /* data             */
+                                         length,    /* wLength          */
+                                         1000);     /* timeout          */
+
+    /*-------------------------------------*\
+    | Check for communication error         |
+    \*-------------------------------------*/
+    if(ret != length)
+    {
+        return("");
+    }
+
+    /*-------------------------------------*\
+    | Format version string                 |
+    \*-------------------------------------*/
+    char version[14];
+    int  vlength = std::snprintf(version, sizeof(version), "%x.%x.%x.%x.%x", buffer[0], buffer[1], buffer[2], buffer[3], buffer[4]);
+
+    return(std::string(version, vlength));
+}
+
+void LianLiUniHub_AL10Controller::SendConfig(uint16_t wIndex, uint8_t  *config, size_t length)
+{
+    /*-------------------------------------*\
+    | Check for invalid handle              |
+    \*-------------------------------------*/
+    if(handle == nullptr)
+    {
+        return;
+    }
+
+    /*-------------------------------------*\
+    | Send packet                           |
+    \*-------------------------------------*/
+    size_t ret = libusb_control_transfer(handle,    /* dev_handle       */
+                                         0x40,      /* bmRequestType    */
+                                         0x80,      /* bRequest         */
+                                         0x00,      /* wValue           */
+                                         wIndex,    /* wIndex           */
+                                         config,    /* data             */
+                                         length,    /* wLength          */
+                                         1000);     /* timeout          */
+    std::this_thread::sleep_for(5ms);
+    /*-------------------------------------*\
+    | Check for communication error         |
+    \*-------------------------------------*/
+    if(ret != length)
+    {
+        return;
+    }
+}
+
+void LianLiUniHub_AL10Controller::SendCommit(uint16_t wIndex)
+{
+    /*-------------------------------------*\
+    | Set up config packet                  |
+    \*-------------------------------------*/
+    uint8_t config[1] = { 0x01 };
+
+    /*-------------------------------------*\
+    | Send packet                           |
+    \*-------------------------------------*/
+    SendConfig(wIndex, config, sizeof(config));
+
+    std::this_thread::sleep_for(5ms);
+}

Controllers/LianLiController/LianLiUniHub_AL10Controller.h

@@ -0,0 +1,273 @@
+/*-----------------------------------------*\
+|  LianLiUniHub_AL10Controller.h            |
+|                                           |
+|  Definitions and types for Lian Li Uni    |
+|  Hub USB RGB lighting controller          |
+|                                           |
+|  Oliver P 05/05/2022                      |
+|  Credit to Luca Lovisa for original work. |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include <cstdint>
+#include <mutex>
+#include <string>
+
+#include "RGBController.h"
+
+#include <libusb-1.0/libusb.h>
+
+/*----------------------------------------------------------------------------*\
+| Global definitions.                                                          |
+\*----------------------------------------------------------------------------*/
+
+enum
+{
+    UNIHUB_AL10_CHANNEL_COUNT              = 0x04,   /* Channel count              */
+    UNIHUB_AL10_CHANLED_COUNT              = 0x50,   /* Max-LED per channel count  */
+};
+
+enum
+{
+    UNIHUB_AL10_ACTION_ADDRESS             = 0xE020, /* Global action address      */
+    UNIHUB_AL10_COMMIT_ADDRESS             = 0xE02F, /* Global commit address      */
+};
+
+enum
+{
+    UNIHUB_AL10_ANY_C1_FAN_COUNT_OFFSET    = 0x00,   /* Channel 1 fan count offset */
+    UNIHUB_AL10_ANY_C2_FAN_COUNT_OFFSET    = 0x14,   /* Channel 2 fan count offset */
+    UNIHUB_AL10_ANY_C3_FAN_COUNT_OFFSET    = 0x28,   /* Channel 3 fan count offset */
+    UNIHUB_AL10_ANY_C4_FAN_COUNT_OFFSET    = 0x3C,   /* Channel 4 fan count offset */
+};
+
+enum
+{
+    UNIHUB_AL10_ANY_FAN_COUNT_000          = 0xFF,   /* Fan count for 0 fans (dummy value) */
+    UNIHUB_AL10_ANY_FAN_COUNT_001          = 0x00,   /* Fan count for 1 fan        */
+    UNIHUB_AL10_ANY_FAN_COUNT_002          = 0x01,   /* Fan count for 2 fans       */
+    UNIHUB_AL10_ANY_FAN_COUNT_003          = 0x02,   /* Fan count for 3 fans       */
+    UNIHUB_AL10_ANY_FAN_COUNT_004          = 0x03,   /* Fan count for 4 fans       */
+};
+
+enum
+{
+    UNIHUB_AL10_LED_LIMITER                = 1,      /* Limit the color white to 999999 as per manufacturer limits in v1.7 */
+};
+
+/*----------------------------------------------------------------------------*\
+| Definitions related to led configuration.                                    |
+\*----------------------------------------------------------------------------*/
+
+enum
+{
+    UNIHUB_AL10_LED_C1_ACTION_ADDRESS      = 0xE500, /* Channel 1 led action address     */
+    UNIHUB_AL10_LED_C1_COMMIT_ADDRESS      = 0xE02F, /* Channel 1 led commit address     */
+    UNIHUB_AL10_LED_C1_MODE_ADDRESS        = 0xE021, /* Channel 1 led mode address       */
+    UNIHUB_AL10_LED_C1_SPEED_ADDRESS       = 0xE022, /* Channel 1 led speed address      */
+    UNIHUB_AL10_LED_C1_DIRECTION_ADDRESS   = 0xE023, /* Channel 1 led direction address  */
+    UNIHUB_AL10_LED_C1_BRIGHTNESS_ADDRESS  = 0xE029, /* Channel 1 led brightness address */
+
+    UNIHUB_AL10_LED_C2_ACTION_ADDRESS      = 0xE5F0, /* Channel 2 led action address     */
+    UNIHUB_AL10_LED_C2_COMMIT_ADDRESS      = 0xE03F, /* Channel 2 led commit address     */
+    UNIHUB_AL10_LED_C2_MODE_ADDRESS        = 0xE031, /* Channel 2 led mode address       */
+    UNIHUB_AL10_LED_C2_SPEED_ADDRESS       = 0xE032, /* Channel 2 led speed address      */
+    UNIHUB_AL10_LED_C2_DIRECTION_ADDRESS   = 0xE033, /* Channel 2 led direction address  */
+    UNIHUB_AL10_LED_C2_BRIGHTNESS_ADDRESS  = 0xE039, /* Channel 2 led brightness address */
+
+    UNIHUB_AL10_LED_C3_ACTION_ADDRESS      = 0xE6E0, /* Channel 3 led action address     */
+    UNIHUB_AL10_LED_C3_COMMIT_ADDRESS      = 0xE04F, /* Channel 3 led commit address     */
+    UNIHUB_AL10_LED_C3_MODE_ADDRESS        = 0xE041, /* Channel 3 led mode address       */
+    UNIHUB_AL10_LED_C3_SPEED_ADDRESS       = 0xE042, /* Channel 3 led speed address      */
+    UNIHUB_AL10_LED_C3_DIRECTION_ADDRESS   = 0xE043, /* Channel 3 led direction address  */
+    UNIHUB_AL10_LED_C3_BRIGHTNESS_ADDRESS  = 0xE049, /* Channel 3 led brightness address */
+
+    UNIHUB_AL10_LED_C4_ACTION_ADDRESS      = 0xE7D0, /* Channel 4 led action address     */
+    UNIHUB_AL10_LED_C4_COMMIT_ADDRESS      = 0xE05F, /* Channel 4 led commit address     */
+    UNIHUB_AL10_LED_C4_MODE_ADDRESS        = 0xE051, /* Channel 4 led mode address       */
+    UNIHUB_AL10_LED_C4_SPEED_ADDRESS       = 0xE052, /* Channel 4 led speed address      */
+    UNIHUB_AL10_LED_C4_DIRECTION_ADDRESS   = 0xE053, /* Channel 4 led direction address  */
+    UNIHUB_AL10_LED_C4_BRIGHTNESS_ADDRESS  = 0xE059, /* Channel 4 led brightness address */
+};
+
+enum
+{
+    UNIHUB_AL10_LED_MODE_RAINBOW           = 0x05,   /* Rainbow mode            */
+    UNIHUB_AL10_LED_MODE_RAINBOW_MORPH     = 0xFF,   /* Runway mode            - Needs updated code */
+    UNIHUB_AL10_LED_MODE_STATIC_COLOR      = 0x01,   /* Static Color mode       */
+    UNIHUB_AL10_LED_MODE_BREATHING         = 0x02,   /* Breathing mode          */
+    UNIHUB_AL10_LED_MODE_TAICHI            = 0x2C,   /* Neon mode               */
+    UNIHUB_AL10_LED_MODE_COLOR_CYCLE       = 0x2B,   /* Color Cycle mode        */
+    UNIHUB_AL10_LED_MODE_RUNWAY            = 0xFF,   /* Runway mode            - Needs updated code */
+    UNIHUB_AL10_LED_MODE_METEOR            = 0xFF,   /* Meteor mode            - Needs updated code */
+    UNIHUB_AL10_LED_MODE_WARNING           = 0x2D,   /* Warning mode            */
+    UNIHUB_AL10_LED_MODE_VOICE             = 0x22,   /* Voice mode              */
+    UNIHUB_AL10_LED_MODE_SPINNING_TEACUP   = 0x36,   /* Spinning Teacup mode    */
+    UNIHUB_AL10_LED_MODE_TORNADO           = 0x34,   /* Tornado mode            */
+    UNIHUB_AL10_LED_MODE_MIXING            = 0x23,   /* Mixing mode             */
+    UNIHUB_AL10_LED_MODE_STACK             = 0xFF,   /* Stack mode             - Needs updated code */
+    UNIHUB_AL10_LED_MODE_STAGGGERED        = 0x35,   /* Stagggered mode         */
+    UNIHUB_AL10_LED_MODE_TIDE              = 0x25,   /* Tide mode               */
+    UNIHUB_AL10_LED_MODE_SCAN              = 0x26,   /* Scan mode               */
+    UNIHUB_AL10_LED_MODE_CONTEST           = 0x33,   /* Contest mode            */
+};
+
+enum
+{
+    UNIHUB_AL10_LED_SPEED_000              = 0x02,   /* Very slow speed         */
+    UNIHUB_AL10_LED_SPEED_025              = 0x01,   /* Rather slow speed       */
+    UNIHUB_AL10_LED_SPEED_050              = 0x00,   /* Medium speed            */
+    UNIHUB_AL10_LED_SPEED_075              = 0xFF,   /* Rather fast speed       */
+    UNIHUB_AL10_LED_SPEED_100              = 0xFE,   /* Very fast speed         */
+};
+
+enum
+{
+    UNIHUB_AL10_LED_DIRECTION_LTR          = 0x00,   /* Left-to-Right direction */
+    UNIHUB_AL10_LED_DIRECTION_RTL          = 0x01,   /* Right-to-Left direction */
+};
+
+enum
+{
+    UNIHUB_AL10_LED_BRIGHTNESS_000         = 0x08,   /* Very dark (off)         */
+    UNIHUB_AL10_LED_BRIGHTNESS_025         = 0x03,   /* Rather dark             */
+    UNIHUB_AL10_LED_BRIGHTNESS_050         = 0x02,   /* Medium bright           */
+    UNIHUB_AL10_LED_BRIGHTNESS_075         = 0x01,   /* Rather bright           */
+    UNIHUB_AL10_LED_BRIGHTNESS_100         = 0x00,   /* Very bright             */
+};
+
+/*----------------------------------------------------------------------------*\
+| Definitions related to fan configuration.                                    |
+\*----------------------------------------------------------------------------*/
+
+enum
+{
+    UNIHUB_AL10_FAN_C1_HUB_ACTION_ADDRESS  = 0xE8A0, /* Channel 1 fan action address for hub control */
+    UNIHUB_AL10_FAN_C1_HUB_COMMIT_ADDRESS  = 0xE890, /* Channel 1 fan commit address for hub control */
+    UNIHUB_AL10_FAN_C1_PWM_ACTION_ADDRESS  = 0xE890, /* Channel 1 fan action address for pwm control */
+    UNIHUB_AL10_FAN_C1_PWM_COMMIT_ADDRESS  = 0xE818, /* Channel 1 fan commit address for pwm control */
+    UNIHUB_AL10_FAN_C1_RPM_ACTION_ADDRESS  = 0xE800, /* Channel 1 fan pwm read address               */
+
+    UNIHUB_AL10_FAN_C2_HUB_ACTION_ADDRESS  = 0xE8A2, /* Channel 2 fan action address for hub control */
+    UNIHUB_AL10_FAN_C2_HUB_COMMIT_ADDRESS  = 0xE891, /* Channel 2 fan commit address for hub control */
+    UNIHUB_AL10_FAN_C2_PWM_ACTION_ADDRESS  = 0xE891, /* Channel 2 fan action address for pwm control */
+    UNIHUB_AL10_FAN_C2_PWM_COMMIT_ADDRESS  = 0xE81A, /* Channel 2 fan commit address for pwm control */
+    UNIHUB_AL10_FAN_C2_RPM_ACTION_ADDRESS  = 0xE802, /* Channel 1 fan pwm read address               */
+
+    UNIHUB_AL10_FAN_C3_HUB_ACTION_ADDRESS  = 0xE8A4, /* Channel 3 fan action address for hub control */
+    UNIHUB_AL10_FAN_C3_HUB_COMMIT_ADDRESS  = 0xE892, /* Channel 3 fan commit address for hub control */
+    UNIHUB_AL10_FAN_C3_PWM_ACTION_ADDRESS  = 0xE892, /* Channel 3 fan action address for pwm control */
+    UNIHUB_AL10_FAN_C3_PWM_COMMIT_ADDRESS  = 0xE81C, /* Channel 3 fan commit address for pwm control */
+    UNIHUB_AL10_FAN_C3_RPM_ACTION_ADDRESS  = 0xE804, /* Channel 1 fan pwm read address               */
+
+    UNIHUB_AL10_FAN_C4_HUB_ACTION_ADDRESS  = 0xE8A6, /* Channel 4 fan action address for hub control */
+    UNIHUB_AL10_FAN_C4_HUB_COMMIT_ADDRESS  = 0xE893, /* Channel 4 fan commit address for hub control */
+    UNIHUB_AL10_FAN_C4_PWM_ACTION_ADDRESS  = 0xE893, /* Channel 4 fan action address for pwm control */
+    UNIHUB_AL10_FAN_C4_PWM_COMMIT_ADDRESS  = 0xE81E, /* Channel 4 fan commit address for pwm control */
+    UNIHUB_AL10_FAN_C4_RPM_ACTION_ADDRESS  = 0xE806, /* Channel 1 fan pwm read address               */
+};
+
+enum
+{
+    UNIHUB_AL10_FAN_SPEED_QUIET            = 0x2003, /* Rather slow */
+    UNIHUB_AL10_FAN_SPEED_HIGH_SPEED       = 0x2206, /* Rather fast */
+    UNIHUB_AL10_FAN_SPEED_FULL_SPEED       = 0x6C07, /* BRRRRRRRRRR */
+    UNIHUB_AL10_FAN_SPEED_PWM              = 0xFFFF, /* PWM Control */
+};
+
+/*----------------------------------------------------------------------------*\
+| Uni Hub controller.                                                          |
+\*----------------------------------------------------------------------------*/
+
+class LianLiUniHub_AL10Controller
+{
+private:
+    /* The Uni Hub requires colors in RBG order */
+    struct Color
+    {
+        uint8_t r;
+        uint8_t b;
+        uint8_t g;
+    };
+
+    /* The values correspond to the definitions above */
+    struct Channel
+    {
+        uint8_t  index;
+
+        uint8_t  anyFanCountOffset;
+        uint8_t  anyFanCount;
+
+        uint16_t ledActionAddress;
+        uint16_t ledCommitAddress;
+        uint16_t ledModeAddress;
+        uint16_t ledSpeedAddress;
+        uint16_t ledDirectionAddress;
+        uint16_t ledBrightnessAddress;
+
+        Color    colors[UNIHUB_AL10_CHANLED_COUNT];
+
+        uint8_t  ledMode;
+        uint8_t  ledSpeed;
+        uint8_t  ledDirection;
+        uint8_t  ledBrightness;
+
+        uint16_t fanHubActionAddress;
+        uint16_t fanHubCommitAddress;
+
+        uint16_t fanPwmActionAddress;
+        uint16_t fanPwmCommitAddress;
+        uint16_t fanRpmActionAddress;
+
+        uint16_t fanSpeed;
+    };
+
+public:
+    LianLiUniHub_AL10Controller
+        (
+        libusb_device*              device,
+        libusb_device_descriptor*   descriptor
+        );
+    ~LianLiUniHub_AL10Controller();
+
+    std::string GetVersion();
+    std::string GetLocation();
+    std::string GetSerial();
+
+    void        SetAnyFanCount(size_t channel, uint8_t count);
+    void        SetLedColors(size_t channel, RGBColor* colors, size_t count);
+    void        SetLedMode(size_t channel, uint8_t mode);
+    void        SetLedSpeed(size_t channel, uint8_t speed);
+    void        SetLedDirection(size_t channel, uint8_t direction);
+    void        SetLedBrightness(size_t channel, uint8_t brightness);
+    uint16_t    GetFanSpeed(size_t channel);
+    void        SetFanSpeed(size_t channel, uint16_t speed);
+    void        EnableRgbhMode();
+    void        DisableRgbhMode();
+    void        EnableSyncMode();
+    void        DisableSyncMode();
+    uint16_t    ReadFanSpeed(size_t channel);
+
+    /*-----------------------------------------------------*\
+    | Synchronize the current configuration to the Uni Hub. |
+    \*-----------------------------------------------------*/
+    void        Synchronize();
+
+private:
+    libusb_device_handle* handle = nullptr;
+
+    std::string version;
+    std::string location;
+    std::string serial;
+
+    bool rgbhModeEnabled = false;
+    bool syncModeEnabled = false;
+
+    Channel channels[UNIHUB_AL10_CHANNEL_COUNT];
+
+    void        CloseLibusb();
+    std::string ReadVersion();
+    void        SendConfig(uint16_t wIndex, uint8_t  *config, size_t length);
+    void        SendCommit(uint16_t wIndex);
+};

Controllers/LianLiController/RGBController_LianLiUniHubAL.cpp

@@ -0,0 +1,533 @@
+/*-----------------------------------------*\
+|  RGBController_LianLiUniHubAL.cpp         |
+|                                           |
+|  Generic RGB Interface for Lian Li Uni    |
+|  Hub AL USB controller driver             |
+|                                           |
+|  Oliver P 04/26/2022                      |
+|  Credit to Luca Lovisa for original work. |
+\*-----------------------------------------*/
+
+#include "RGBController_LianLiUniHubAL.h"
+
+#include <string>
+
+//0xFFFFFFFF indicates an unused entry in matrix
+#define NA  0xFFFFFFFF
+
+static unsigned int matrix_map[8][35] =
+    { {  NA,  NA,  10,  NA,  NA,  11,  NA,  NA,  NA,  NA,  NA,  30,  NA,  NA,  31,  NA,  NA,  NA,  NA,  NA,  50,  NA,  NA,  51,  NA,  NA,  NA,  NA,  NA,  70,  NA,  NA,  71,  NA,  NA},
+      {  NA,   9,  NA,  NA,  NA,  NA,  12,  NA,  NA,  NA,  29,  NA,  NA,  NA,  NA,  32,  NA,  NA,  NA,  49,  NA,  NA,  NA,  NA,  52,  NA,  NA,  NA,  69,  NA,  NA,  NA,  NA,  72,  NA},
+      {   8,  NA,  NA,   1,   2,  NA,  NA,  13,  NA,  28,  NA,  NA,  21,  22,  NA,  NA,  33,  NA,  48,  NA,  NA,  41,  42,  NA,  NA,  53,  NA,  68,  NA,  NA,  61,  62,  NA,  NA,  73},
+      {  NA,  NA,   0,  NA,  NA,   3,  NA,  NA,  NA,  NA,  NA,  20,  NA,  NA,  23,  NA,  NA,  NA,  NA,  NA,  40,  NA,  NA,  43,  NA,  NA,  NA,  NA,  NA,  60,  NA,  NA,  63,  NA,  NA},
+      {  NA,  NA,   7,  NA,  NA,   4,  NA,  NA,  NA,  NA,  NA,  27,  NA,  NA,  24,  NA,  NA,  NA,  NA,  NA,  47,  NA,  NA,  44,  NA,  NA,  NA,  NA,  NA,  67,  NA,  NA,  64,  NA,  NA},
+      {  19,  NA,  NA,   6,   5,  NA,  NA,  14,  NA,  39,  NA,  NA,  26,  25,  NA,  NA,  34,  NA,  59,  NA,  NA,  46,  45,  NA,  NA,  54,  NA,  79,  NA,  NA,  66,  65,  NA,  NA,  74},
+      {  NA,  18,  NA,  NA,  NA,  NA,  15,  NA,  NA,  NA,  38,  NA,  NA,  NA,  NA,  35,  NA,  NA,  NA,  58,  NA,  NA,  NA,  NA,  55,  NA,  NA,  NA,  78,  NA,  NA,  NA,  NA,  75,  NA},
+      {  NA,  NA,  17,  NA,  NA,  16,  NA,  NA,  NA,  NA,  NA,  37,  NA,  NA,  36,  NA,  NA,  NA,  NA,  NA,  57,  NA,  NA,  56,  NA,  NA,  NA,  NA,  NA,  77,  NA,  NA,  76,  NA,  NA}
+    };
+
+/**------------------------------------------------------------------*\
+    @name Lian Li Uni Hub AL
+    @type USB
+    @save :x:
+    @direct :warning:
+    @effects :white_check_mark:
+    @detectors DetectLianLiUniHubAL
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_LianLiUniHubAL::RGBController_LianLiUniHubAL(LianLiUniHubALController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = controller->GetName();
+    vendor      = "Lian Li";
+    type        = DEVICE_TYPE_COOLER;
+    description = "Lian Li Uni Hub - AL";
+    version     = controller->GetFirmwareVersionString();
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+
+
+    initializedMode = false;
+
+    mode Custom;
+    Custom.name                 = "Custom";
+    Custom.value                = UNIHUB_AL_LED_MODE_STATIC_COLOR;
+    Custom.flags                = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
+    Custom.brightness_min       = 0;
+    Custom.brightness_max       = 50;
+    Custom.brightness           = 37;
+    Custom.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Custom);
+
+    mode RainbowWave;
+    RainbowWave.name            = "Rainbow Wave";
+    RainbowWave.value           = UNIHUB_AL_LED_MODE_RAINBOW;
+    RainbowWave.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
+    RainbowWave.speed_min       = 0;
+    RainbowWave.speed_max       = 4;
+    RainbowWave.brightness_min  = 0;
+    RainbowWave.brightness_max  = 4;
+    RainbowWave.speed           = 3;
+    RainbowWave.brightness      = 3;
+    RainbowWave.direction       = UNIHUB_AL_LED_DIRECTION_LTR;
+    RainbowWave.color_mode      = MODE_COLORS_NONE;
+    modes.push_back(RainbowWave);
+
+    mode RainbowMorph;
+    RainbowMorph.name           = "Rainbow Morph";
+    RainbowMorph.value          = UNIHUB_AL_LED_MODE_RAINBOW_MORPH;
+    RainbowMorph.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    RainbowMorph.speed_min      = 0;
+    RainbowMorph.speed_max      = 4;
+    RainbowMorph.brightness_min = 0;
+    RainbowMorph.brightness_max = 4;
+    RainbowMorph.speed          = 3;
+    RainbowMorph.brightness     = 3;
+    RainbowMorph.color_mode     = MODE_COLORS_NONE;
+    modes.push_back(RainbowMorph);
+
+    mode StaticColor;
+    StaticColor.name            = "Static Color";
+    StaticColor.value           = UNIHUB_AL_LED_MODE_STATIC_COLOR;
+    StaticColor.flags           = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    StaticColor.brightness_min  = 0;
+    StaticColor.brightness_max  = 4;
+    StaticColor.colors_min      = 0;
+    StaticColor.colors_max      = 4;
+    StaticColor.brightness      = 3;
+    StaticColor.color_mode      = MODE_COLORS_MODE_SPECIFIC;
+    StaticColor.colors.resize(4);
+    modes.push_back(StaticColor);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = UNIHUB_AL_LED_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Breathing.speed_min         = 0;
+    Breathing.speed_max         = 4;
+    Breathing.brightness_min    = 0;
+    Breathing.brightness_max    = 4;
+    Breathing.colors_min        = 0;
+    Breathing.colors_max        = 4;
+    Breathing.speed             = 3;
+    Breathing.brightness        = 3;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(4);
+    modes.push_back(Breathing);
+
+    mode Taichi;
+    Taichi.name                 = "Taichi";
+    Taichi.value                = UNIHUB_AL_LED_MODE_TAICHI;
+    Taichi.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Taichi.speed_min            = 0;
+    Taichi.speed_max            = 4;
+    Taichi.brightness_min       = 0;
+    Taichi.brightness_max       = 4;
+    Taichi.colors_min           = 0;
+    Taichi.colors_max           = 2;
+    Taichi.speed                = 3;
+    Taichi.brightness           = 3;
+    Taichi.direction            = UNIHUB_AL_LED_DIRECTION_LTR;
+    Taichi.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Taichi.colors.resize(2);
+    modes.push_back(Taichi);
+
+    mode ColorCycle;
+    ColorCycle.name             = "ColorCycle";
+    ColorCycle.value            = UNIHUB_AL_LED_MODE_COLOR_CYCLE;
+    ColorCycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    ColorCycle.speed_min        = 0;
+    ColorCycle.speed_max        = 4;
+    ColorCycle.brightness_min   = 0;
+    ColorCycle.brightness_max   = 4;
+    ColorCycle.colors_min       = 0;
+    ColorCycle.colors_max       = 4;
+    ColorCycle.speed            = 3;
+    ColorCycle.brightness       = 3;
+    ColorCycle.direction        = UNIHUB_AL_LED_DIRECTION_LTR;
+    ColorCycle.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    ColorCycle.colors.resize(4);
+    modes.push_back(ColorCycle);
+
+    mode Runway;
+    Runway.name                 = "Runway";
+    Runway.value                = UNIHUB_AL_LED_MODE_RUNWAY;
+    Runway.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Runway.speed_min            = 0;
+    Runway.speed_max            = 4;
+    Runway.brightness_min       = 0;
+    Runway.brightness_max       = 4;
+    Runway.colors_min           = 0;
+    Runway.colors_max           = 2;
+    Runway.speed                = 3;
+    Runway.brightness           = 3;
+    Runway.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Runway.colors.resize(2);
+    modes.push_back(Runway);
+
+    mode Meteor;
+    Meteor.name                 = "Meteor";
+    Meteor.value                = UNIHUB_AL_LED_MODE_METEOR;
+    Meteor.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Meteor.speed_min            = 0;
+    Meteor.speed_max            = 4;
+    Meteor.brightness_min       = 0;
+    Meteor.brightness_max       = 4;
+    Meteor.colors_min           = 0;
+    Meteor.colors_max           = 4;
+    Meteor.speed                = 3;
+    Meteor.brightness           = 3;
+    Meteor.direction            = UNIHUB_AL_LED_DIRECTION_LTR;
+    Meteor.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Meteor.colors.resize(4);
+    modes.push_back(Meteor);
+
+    mode Warning;
+    Warning.name                = "Warning";
+    Warning.value               = UNIHUB_AL_LED_MODE_WARNING;
+    Warning.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Warning.speed_min           = 0;
+    Warning.speed_max           = 4;
+    Warning.brightness_min      = 0;
+    Warning.brightness_max      = 4;
+    Warning.colors_min          = 0;
+    Warning.colors_max          = 4;
+    Warning.speed               = 3;
+    Warning.brightness          = 3;
+    Warning.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+    Warning.colors.resize(4);
+    modes.push_back(Warning);
+
+    mode Voice;
+    Voice.name                  = "Voice";
+    Voice.value                 = UNIHUB_AL_LED_MODE_VOICE;
+    Voice.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Voice.speed_min             = 0;
+    Voice.speed_max             = 4;
+    Voice.brightness_min        = 0;
+    Voice.brightness_max        = 4;
+    Voice.colors_min            = 0;
+    Voice.colors_max            = 4;
+    Voice.speed                 = 3;
+    Voice.brightness            = 3;
+    Voice.direction             = UNIHUB_AL_LED_DIRECTION_LTR;
+    Voice.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Voice.colors.resize(4);
+    modes.push_back(Voice);
+
+    mode SpinningTeacup;
+    SpinningTeacup.name             = "SpinningTeacup";
+    SpinningTeacup.value            = UNIHUB_AL_LED_MODE_SPINNING_TEACUP;
+    SpinningTeacup.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    SpinningTeacup.speed_min        = 0;
+    SpinningTeacup.speed_max        = 4;
+    SpinningTeacup.brightness_min   = 0;
+    SpinningTeacup.brightness_max   = 4;
+    SpinningTeacup.colors_min       = 0;
+    SpinningTeacup.colors_max       = 4;
+    SpinningTeacup.speed            = 3;
+    SpinningTeacup.brightness       = 3;
+    SpinningTeacup.direction        = UNIHUB_AL_LED_DIRECTION_LTR;
+    SpinningTeacup.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    SpinningTeacup.colors.resize(4);
+    modes.push_back(SpinningTeacup);
+
+    mode Tornado;
+    Tornado.name                = "Tornado";
+    Tornado.value               = UNIHUB_AL_LED_MODE_TORNADO;
+    Tornado.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Tornado.speed_min           = 0;
+    Tornado.speed_max           = 4;
+    Tornado.brightness_min      = 0;
+    Tornado.brightness_max      = 4;
+    Tornado.colors_min          = 0;
+    Tornado.colors_max          = 4;
+    Tornado.speed               = 3;
+    Tornado.brightness          = 3;
+    Tornado.direction           = UNIHUB_AL_LED_DIRECTION_LTR;
+    Tornado.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+    Tornado.colors.resize(4);
+    modes.push_back(Tornado);
+
+    mode Mixing;
+    Mixing.name                 = "Mixing";
+    Mixing.value                = UNIHUB_AL_LED_MODE_MIXING;
+    Mixing.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Mixing.speed_min            = 0;
+    Mixing.speed_max            = 4;
+    Mixing.brightness_min       = 0;
+    Mixing.brightness_max       = 4;
+    Mixing.colors_min           = 0;
+    Mixing.colors_max           = 2;
+    Mixing.speed                = 3;
+    Mixing.brightness           = 3;
+    Mixing.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Mixing.colors.resize(2);
+    modes.push_back(Mixing);
+
+    mode Stack;
+    Stack.name                  = "Stack";
+    Stack.value                 = UNIHUB_AL_LED_MODE_STACK;
+    Stack.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Stack.speed_min             = 0;
+    Stack.speed_max             = 4;
+    Stack.brightness_min        = 0;
+    Stack.brightness_max        = 4;
+    Stack.colors_min            = 0;
+    Stack.colors_max            = 2;
+    Stack.speed                 = 3;
+    Stack.brightness            = 3;
+    Stack.direction             = UNIHUB_AL_LED_DIRECTION_LTR;
+    Stack.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Stack.colors.resize(2);
+    modes.push_back(Stack);
+
+    mode Staggered;
+    Staggered.name              = "Staggered";
+    Staggered.value             = UNIHUB_AL_LED_MODE_STAGGGERED;
+    Staggered.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Staggered.speed_min         = 0;
+    Staggered.speed_max         = 4;
+    Staggered.brightness_min    = 0;
+    Staggered.brightness_max    = 4;
+    Staggered.colors_min        = 0;
+    Staggered.colors_max        = 4;
+    Staggered.speed             = 3;
+    Staggered.brightness        = 3;
+    Staggered.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Staggered.colors.resize(4);
+    modes.push_back(Staggered);
+
+    mode Tide;
+    Tide.name                   = "Tide";
+    Tide.value                  = UNIHUB_AL_LED_MODE_TIDE;
+    Tide.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Tide.speed_min              = 0;
+    Tide.speed_max              = 4;
+    Tide.brightness_min         = 0;
+    Tide.brightness_max         = 4;
+    Tide.colors_min             = 0;
+    Tide.colors_max             = 4;
+    Tide.speed                  = 3;
+    Tide.brightness             = 3;
+    Tide.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Tide.colors.resize(4);
+    modes.push_back(Tide);
+
+    mode Scan;
+    Scan.name                   = "Scan";
+    Scan.value                  = UNIHUB_AL_LED_MODE_SCAN;
+    Scan.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Scan.speed_min              = 0;
+    Scan.speed_max              = 4;
+    Scan.brightness_min         = 0;
+    Scan.brightness_max         = 4;
+    Scan.colors_min             = 0;
+    Scan.colors_max             = 2;
+    Scan.speed                  = 3;
+    Scan.brightness             = 3;
+    Scan.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Scan.colors.resize(2);
+    modes.push_back(Scan);
+
+    mode Contest;
+    Contest.name                = "Contest";
+    Contest.value               = UNIHUB_AL_LED_MODE_CONTEST;
+    Contest.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Contest.speed_min           = 0;
+    Contest.speed_max           = 4;
+    Contest.brightness_min      = 0;
+    Contest.brightness_max      = 4;
+    Contest.colors_min          = 0;
+    Contest.colors_max          = 2;
+    Contest.speed               = 3;
+    Contest.brightness          = 3;
+    Contest.direction           = UNIHUB_AL_LED_DIRECTION_LTR;
+    Contest.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+    Contest.colors.resize(3);
+    modes.push_back(Contest);
+
+    RGBController_LianLiUniHubAL::SetupZones();
+}
+
+RGBController_LianLiUniHubAL::~RGBController_LianLiUniHubAL()
+{
+    /*---------------------------------------------------------*\
+    | 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_LianLiUniHubAL::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Only set LED count on the first run               |
+    \*-------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
+    {
+        first_run = true;
+        zones.resize(UNIHUB_AL_CHANNEL_COUNT);
+    }
+
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    {
+        zones[channel_idx].name                 = "Channel ";
+        zones[channel_idx].name.append(std::to_string(channel_idx + 1));
+
+        // Note:    Matrix types won't get loaded from the sizes.ors as the default zone type in this RGBController is ZONE_TYPE_LINEAR
+        //          This will require augmentation on the ProfileManager.cpp to be able to override zone types but this is probably not wanted in general
+        if (zones[channel_idx].leds_count == 60 || zones[channel_idx].leds_count == 40 || zones[channel_idx].leds_count == 20 || zones[channel_idx].leds_count == 80) // Assume they're AL120 Fans
+        {
+            zones[channel_idx].type                 = ZONE_TYPE_MATRIX;
+            zones[channel_idx].leds_min             = 0;
+            zones[channel_idx].leds_max             = UNIHUB_AL_CHAN_LED_COUNT;
+            zones[channel_idx].matrix_map           = new matrix_map_type;
+            zones[channel_idx].matrix_map->height   = 8;
+            zones[channel_idx].matrix_map->width    = 35;
+            zones[channel_idx].matrix_map->map      = (unsigned int *)&matrix_map;
+        }
+        else   // Treat as regular LED strip
+        {
+            zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
+            zones[channel_idx].leds_min             = 0;
+            zones[channel_idx].leds_max             = UNIHUB_AL_CHAN_LED_COUNT;
+        }
+
+        if(first_run)
+        {
+            zones[channel_idx].leds_count = zones[channel_idx].leds_min;
+        }
+
+        for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
+        {
+            led new_led;
+            new_led.name = zones[channel_idx].name;
+            new_led.name.append(", LED ");
+            new_led.name.append(std::to_string(led_ch_idx + 1));
+            new_led.value = channel_idx;
+
+            leds.push_back(new_led);
+        }
+
+    }
+
+    SetupColors();
+}
+
+void RGBController_LianLiUniHubAL::ResizeZone(int zone, int new_size)
+{
+    if((size_t) zone >= zones.size())
+    {
+        return;
+    }
+
+    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    {
+        zones[zone].leds_count = new_size;
+
+        SetupZones();
+    }
+}
+
+void RGBController_LianLiUniHubAL::DeviceUpdateLEDs()
+{
+
+    if(!initializedMode)
+    {
+        DeviceUpdateMode();
+    }
+
+    float brightness_scale = static_cast<float>(modes[active_mode].brightness)/modes[active_mode].brightness_max;
+
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        controller->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count, brightness_scale);
+    }
+}
+
+void RGBController_LianLiUniHubAL::UpdateZoneLEDs(int zone)
+{
+    if(!initializedMode)
+    {
+        DeviceUpdateMode();
+    }
+
+    float brightness_scale = static_cast<float>(modes[active_mode].brightness)/modes[active_mode].brightness_max;
+
+    controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count, brightness_scale);
+}
+
+void RGBController_LianLiUniHubAL::UpdateSingleLED(int /* led */)
+{
+    DeviceUpdateMode();
+
+}
+
+void RGBController_LianLiUniHubAL::DeviceUpdateMode()
+{
+    if(!active_mode)
+    {
+        return;                 // Do nothing, custom mode should go through DeviceUpdateLEDs() to avoid flooding controller
+    }
+
+    initializedMode   = true;
+
+    int                 fan_idx = 0;
+    bool                upd_both_fan_edge      = false;
+
+    /*-----------------------------------------------------*\
+    | Check modes that requires updating both arrays        |
+    \*-----------------------------------------------------*/
+
+    switch(modes[active_mode].value)
+    {
+        case UNIHUB_AL_LED_MODE_STATIC_COLOR:
+        case UNIHUB_AL_LED_MODE_BREATHING:
+        case UNIHUB_AL_LED_MODE_RUNWAY:
+        case UNIHUB_AL_LED_MODE_METEOR:
+            upd_both_fan_edge = true;
+            break;
+    }
+
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        if(zones[zone_idx].leds_count == 0)
+        {
+            return;     // Do nothing, channel isn't in use
+        }
+        fan_idx = ((zones[zone_idx].leds_count / 20) - 1);        // Indexes start at 0
+
+        controller->SetChannelMode(zone_idx, modes[active_mode].value,modes[active_mode].colors, modes[active_mode].colors.size(), (fan_idx >= 0 ? fan_idx : 0), upd_both_fan_edge, modes[active_mode].brightness, modes[active_mode].speed, modes[active_mode].direction);
+
+    }
+}
+
+void RGBController_LianLiUniHubAL::SetCustomMode()
+{
+    /*-------------------------------------------------*\
+    | Set mode to Static Color                          |
+    \*-------------------------------------------------*/
+    active_mode = 0;
+}
+

Controllers/LianLiController/RGBController_LianLiUniHubAL.h

@@ -0,0 +1,40 @@
+/*-----------------------------------------*\
+|  RGBController_LianLiUniHubAL.h           |
+|                                           |
+|  Generic RGB Interface for Lian Li Uni    |
+|  Hub AL USB controller driver             |
+|                                           |
+|  Oliver P 04/26/2022                      |
+|  Credit to Luca Lovisa for original work. |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "LianLiUniHubALController.h"
+#include "RGBController.h"
+
+class RGBController_LianLiUniHubAL : public RGBController
+{
+public:
+    RGBController_LianLiUniHubAL(LianLiUniHubALController* controller_ptr);
+    ~RGBController_LianLiUniHubAL();
+
+    void SetupZones();
+
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
+
+    void DeviceUpdateMode();
+
+    void SetCustomMode();
+
+private:
+    LianLiUniHubALController* controller;
+    bool                    initializedMode;
+};

Controllers/LianLiController/RGBController_LianLiUniHub_AL10.cpp

@@ -0,0 +1,668 @@
+/*-----------------------------------------*\
+|  RGBController_LianLiUniHub_AL10.cpp      |
+|                                           |
+|  Generic RGB Interface for Lian Li Uni    |
+|  Hub USB controller driver                |
+|                                           |
+|  Oliver P 05/05/2022                      |
+|  Credit to Luca Lovisa for original work. |
+\*-----------------------------------------*/
+
+#include "RGBController_LianLiUniHub_AL10.h"
+
+#include <string>
+
+/**------------------------------------------------------------------*\
+    @name Lian Li Uni Hub
+    @type USB
+    @save :x:
+    @direct :warning:
+    @effects :white_check_mark:
+    @detectors DetectLianLiUniHub
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_LianLiUniHub_AL10::RGBController_LianLiUniHub_AL10(LianLiUniHub_AL10Controller* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "Lian Li Uni Hub - AL";
+    vendor      = "Lian Li";
+    version     = controller->GetVersion();
+    type        = DEVICE_TYPE_COOLER;
+    description = "Lian Li Uni Hub - AL v1.0";
+    location    = controller->GetLocation();
+    serial      = controller->GetSerial();
+
+    initializedMode = false;
+
+    mode Custom;
+    Custom.name                 = "Custom";
+    Custom.value                = UNIHUB_AL10_LED_MODE_STATIC_COLOR;
+    Custom.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Custom.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Custom);
+
+    mode RainbowWave;
+    RainbowWave.name            = "Rainbow Wave";
+    RainbowWave.value           = UNIHUB_AL10_LED_MODE_RAINBOW;
+    RainbowWave.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
+    RainbowWave.speed_min       = 0;
+    RainbowWave.speed_max       = 4;
+    RainbowWave.brightness_min  = 0;
+    RainbowWave.brightness_max  = 4;
+    RainbowWave.speed           = 3;
+    RainbowWave.brightness      = 3;
+    RainbowWave.direction       = UNIHUB_AL10_LED_DIRECTION_LTR;
+    RainbowWave.color_mode      = MODE_COLORS_NONE;
+    //RainbowWave.colors[0]       = ToRGBColor(253,253,253);
+    modes.push_back(RainbowWave);
+
+    /*  Needs updated code
+    mode RainbowMorph;
+    RainbowMorph.name           = "Rainbow Morph";
+    RainbowMorph.value          = UNIHUB_AL10_LED_MODE_RAINBOW_MORPH;
+    RainbowMorph.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    RainbowMorph.speed_min      = 0;
+    RainbowMorph.speed_max      = 4;
+    RainbowMorph.brightness_min = 0;
+    RainbowMorph.brightness_max = 4;
+    RainbowMorph.speed          = 3;
+    RainbowMorph.brightness     = 3;
+    RainbowMorph.color_mode     = MODE_COLORS_NONE;
+    modes.push_back(RainbowMorph);
+    */
+
+    mode StaticColor;
+    StaticColor.name            = "Static Color";
+    StaticColor.value           = UNIHUB_AL10_LED_MODE_STATIC_COLOR;
+    StaticColor.flags           = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    StaticColor.brightness_min  = 0;
+    StaticColor.brightness_max  = 4;
+    StaticColor.colors_min      = 0;
+    StaticColor.colors_max      = 4;
+    StaticColor.brightness      = 3;
+    StaticColor.color_mode      = MODE_COLORS_MODE_SPECIFIC;
+    StaticColor.colors.resize(4);
+    modes.push_back(StaticColor);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = UNIHUB_AL10_LED_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Breathing.speed_min         = 0;
+    Breathing.speed_max         = 4;
+    Breathing.brightness_min    = 0;
+    Breathing.brightness_max    = 4;
+    Breathing.colors_min        = 0;
+    Breathing.colors_max        = 4;
+    Breathing.speed             = 3;
+    Breathing.brightness        = 3;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(4);
+    modes.push_back(Breathing);
+
+    mode Taichi;
+    Taichi.name                 = "Taichi";
+    Taichi.value                = UNIHUB_AL10_LED_MODE_TAICHI;
+    Taichi.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Taichi.speed_min            = 0;
+    Taichi.speed_max            = 4;
+    Taichi.brightness_min       = 0;
+    Taichi.brightness_max       = 4;
+    Taichi.colors_min           = 0;
+    Taichi.colors_max           = 2;
+    Taichi.speed                = 3;
+    Taichi.brightness           = 3;
+    Taichi.direction            = UNIHUB_AL10_LED_DIRECTION_LTR;
+    Taichi.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Taichi.colors.resize(2);
+    modes.push_back(Taichi);
+
+    mode ColorCycle;
+    ColorCycle.name             = "ColorCycle";
+    ColorCycle.value            = UNIHUB_AL10_LED_MODE_COLOR_CYCLE;
+    ColorCycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    ColorCycle.speed_min        = 0;
+    ColorCycle.speed_max        = 4;
+    ColorCycle.brightness_min   = 0;
+    ColorCycle.brightness_max   = 4;
+    ColorCycle.colors_min       = 0;
+    ColorCycle.colors_max       = 4;
+    ColorCycle.speed            = 3;
+    ColorCycle.brightness       = 3;
+    ColorCycle.direction        = UNIHUB_AL10_LED_DIRECTION_LTR;
+    ColorCycle.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    ColorCycle.colors.resize(4);
+    modes.push_back(ColorCycle);
+
+   /*  Needs updated code
+    mode Runway;
+    Runway.name                 = "Runway";
+    Runway.value                = UNIHUB_AL10_LED_MODE_RUNWAY;
+    Runway.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Runway.speed_min            = 0;
+    Runway.speed_max            = 4;
+    Runway.brightness_min       = 0;
+    Runway.brightness_max       = 4;
+    Runway.colors_min           = 0;
+    Runway.colors_max           = 2;
+    Runway.speed                = 3;
+    Runway.brightness           = 3;
+    Runway.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Runway.colors.resize(2);
+    modes.push_back(Runway);
+    */
+
+    /*  Needs updated code
+    mode Meteor;
+    Meteor.name                 = "Meteor";
+    Meteor.value                = UNIHUB_AL10_LED_MODE_METEOR;
+    Meteor.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Meteor.speed_min            = 0;
+    Meteor.speed_max            = 4;
+    Meteor.brightness_min       = 0;
+    Meteor.brightness_max       = 4;
+    Meteor.colors_min           = 0;
+    Meteor.colors_max           = 4;
+    Meteor.speed                = 3;
+    Meteor.brightness           = 3;
+    Meteor.direction            = UNIHUB_AL10_LED_DIRECTION_LTR;
+    Meteor.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Meteor.colors.resize(4);
+    modes.push_back(Meteor);
+    */
+
+    mode Warning;
+    Warning.name                = "Warning";
+    Warning.value               = UNIHUB_AL10_LED_MODE_WARNING;
+    Warning.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Warning.speed_min           = 0;
+    Warning.speed_max           = 4;
+    Warning.brightness_min      = 0;
+    Warning.brightness_max      = 4;
+    Warning.colors_min          = 0;
+    Warning.colors_max          = 4;
+    Warning.speed               = 3;
+    Warning.brightness          = 3;
+    Warning.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+    Warning.colors.resize(4);
+    modes.push_back(Warning);
+
+    mode Voice;
+    Voice.name                  = "Voice";
+    Voice.value                 = UNIHUB_AL10_LED_MODE_VOICE;
+    Voice.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Voice.speed_min             = 0;
+    Voice.speed_max             = 4;
+    Voice.brightness_min        = 0;
+    Voice.brightness_max        = 4;
+    Voice.colors_min            = 0;
+    Voice.colors_max            = 4;
+    Voice.speed                 = 3;
+    Voice.brightness            = 3;
+    Voice.direction             = UNIHUB_AL10_LED_DIRECTION_LTR;
+    Voice.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Voice.colors.resize(4);
+    modes.push_back(Voice);
+
+    mode SpinningTeacup;
+    SpinningTeacup.name             = "SpinningTeacup";
+    SpinningTeacup.value            = UNIHUB_AL10_LED_MODE_SPINNING_TEACUP;
+    SpinningTeacup.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    SpinningTeacup.speed_min        = 0;
+    SpinningTeacup.speed_max        = 4;
+    SpinningTeacup.brightness_min   = 0;
+    SpinningTeacup.brightness_max   = 4;
+    SpinningTeacup.colors_min       = 0;
+    SpinningTeacup.colors_max       = 4;
+    SpinningTeacup.speed            = 3;
+    SpinningTeacup.brightness       = 3;
+    SpinningTeacup.direction        = UNIHUB_AL10_LED_DIRECTION_LTR;
+    SpinningTeacup.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    SpinningTeacup.colors.resize(4);
+    modes.push_back(SpinningTeacup);
+
+    mode Tornado;
+    Tornado.name                = "Tornado";
+    Tornado.value               = UNIHUB_AL10_LED_MODE_TORNADO;
+    Tornado.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Tornado.speed_min           = 0;
+    Tornado.speed_max           = 4;
+    Tornado.brightness_min      = 0;
+    Tornado.brightness_max      = 4;
+    Tornado.colors_min          = 0;
+    Tornado.colors_max          = 4;
+    Tornado.speed               = 3;
+    Tornado.brightness          = 3;
+    Tornado.direction           = UNIHUB_AL10_LED_DIRECTION_LTR;
+    Tornado.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+    Tornado.colors.resize(4);
+    modes.push_back(Tornado);
+
+    mode Mixing;
+    Mixing.name                 = "Mixing";
+    Mixing.value                = UNIHUB_AL10_LED_MODE_MIXING;
+    Mixing.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Mixing.speed_min            = 0;
+    Mixing.speed_max            = 4;
+    Mixing.brightness_min       = 0;
+    Mixing.brightness_max       = 4;
+    Mixing.colors_min           = 0;
+    Mixing.colors_max           = 2;
+    Mixing.speed                = 3;
+    Mixing.brightness           = 3;
+    Mixing.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Mixing.colors.resize(2);
+    modes.push_back(Mixing);
+
+    /*  Needs updated code
+    mode Stack;
+    Stack.name                  = "Stack";
+    Stack.value                 = UNIHUB_AL10_LED_MODE_STACK;
+    Stack.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Stack.speed_min             = 0;
+    Stack.speed_max             = 4;
+    Stack.brightness_min        = 0;
+    Stack.brightness_max        = 4;
+    Stack.colors_min            = 0;
+    Stack.colors_max            = 2;
+    Stack.speed                 = 3;
+    Stack.brightness            = 3;
+    Stack.direction             = UNIHUB_AL10_LED_DIRECTION_LTR;
+    Stack.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Stack.colors.resize(2);
+    modes.push_back(Stack);
+    */
+
+    mode Staggered;
+    Staggered.name              = "Staggered";
+    Staggered.value             = UNIHUB_AL10_LED_MODE_STAGGGERED;
+    Staggered.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Staggered.speed_min         = 0;
+    Staggered.speed_max         = 4;
+    Staggered.brightness_min    = 0;
+    Staggered.brightness_max    = 4;
+    Staggered.colors_min        = 0;
+    Staggered.colors_max        = 4;
+    Staggered.speed             = 3;
+    Staggered.brightness        = 3;
+    Staggered.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Staggered.colors.resize(4);
+    modes.push_back(Staggered);
+
+    mode Tide;
+    Tide.name                   = "Tide";
+    Tide.value                  = UNIHUB_AL10_LED_MODE_TIDE;
+    Tide.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Tide.speed_min              = 0;
+    Tide.speed_max              = 4;
+    Tide.brightness_min         = 0;
+    Tide.brightness_max         = 4;
+    Tide.colors_min             = 0;
+    Tide.colors_max             = 4;
+    Tide.speed                  = 3;
+    Tide.brightness             = 3;
+    Tide.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Tide.colors.resize(4);
+    modes.push_back(Tide);
+
+    mode Scan;
+    Scan.name                   = "Scan";
+    Scan.value                  = UNIHUB_AL10_LED_MODE_SCAN;
+    Scan.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Scan.speed_min              = 0;
+    Scan.speed_max              = 4;
+    Scan.brightness_min         = 0;
+    Scan.brightness_max         = 4;
+    Scan.colors_min             = 0;
+    Scan.colors_max             = 2;
+    Scan.speed                  = 3;
+    Scan.brightness             = 3;
+    Scan.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Scan.colors.resize(2);
+    modes.push_back(Scan);
+
+    mode Contest;
+    Contest.name                = "Contest";
+    Contest.value               = UNIHUB_AL10_LED_MODE_CONTEST;
+    Contest.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Contest.speed_min           = 0;
+    Contest.speed_max           = 4;
+    Contest.brightness_min      = 0;
+    Contest.brightness_max      = 4;
+    Contest.colors_min          = 0;
+    Contest.colors_max          = 2;
+    Contest.speed               = 3;
+    Contest.brightness          = 3;
+    Contest.direction           = UNIHUB_AL10_LED_DIRECTION_LTR;
+    Contest.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+    Contest.colors.resize(3);
+    modes.push_back(Contest);
+
+    /* Motherboard header mode? Not implemented yet
+    mode Rgbh       = makeModeAL();
+    Rgbh.name       = "RGB Header";
+    Rgbh.value      = UNIHUB_AL10_LED_MODE_STATIC_COLOR | 0x0200;
+    Rgbh.flags      = 0;
+    Rgbh.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Rgbh);
+    */
+
+    RGBController_LianLiUniHub_AL10::SetupZones();
+}
+
+void RGBController_LianLiUniHub_AL10::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Only set LED count on the first run               |
+    \*-------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
+    {
+        first_run = true;
+    }
+
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+    zones.resize(UNIHUB_AL10_CHANNEL_COUNT);
+
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    int addressableCounter = 1;
+    for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    {
+        zones[channel_idx].name       = "Channel ";
+        zones[channel_idx].name.append(std::to_string(addressableCounter));
+
+        addressableCounter++;
+
+        zones[channel_idx].type       = ZONE_TYPE_LINEAR;
+
+        zones[channel_idx].leds_min   = 0;
+        zones[channel_idx].leds_max   = UNIHUB_AL10_CHANLED_COUNT;
+
+        if(first_run)
+        {
+            zones[channel_idx].leds_count = zones[channel_idx].leds_min;
+        }
+
+        for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
+        {
+            led new_led;
+            new_led.name = zones[channel_idx].name;
+            new_led.name.append(", LED ");
+            new_led.name.append(std::to_string(led_ch_idx + 1));
+            new_led.value = channel_idx;
+
+            leds.push_back(new_led);
+        }
+
+        zones[channel_idx].matrix_map = NULL;
+    }
+
+    SetupColors();
+}
+
+void RGBController_LianLiUniHub_AL10::ResizeZone(int zone, int new_size)
+{
+    if((size_t) zone >= zones.size())
+    {
+        return;
+    }
+
+    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    {
+        zones[zone].leds_count = new_size;
+
+        SetupZones();
+    }
+}
+
+void RGBController_LianLiUniHub_AL10::DeviceUpdateLEDs()
+{
+    if(!initializedMode)
+    {
+        DeviceUpdateMode();
+    }
+    for(size_t channel = 0; channel < zones.size(); channel++)
+    {
+        uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
+        controller->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
+        controller->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
+    }
+
+    controller->Synchronize();
+}
+
+void RGBController_LianLiUniHub_AL10::UpdateZoneLEDs(int zone)
+{
+    if(!initializedMode)
+    {
+        DeviceUpdateMode();
+    }
+    unsigned int channel = zone;
+
+    uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
+    controller->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
+    controller->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
+
+    controller->Synchronize();
+}
+
+void RGBController_LianLiUniHub_AL10::UpdateSingleLED(int led)
+{
+    if(!initializedMode)
+    {
+        DeviceUpdateMode();
+    }
+    unsigned int channel = leds[led].value;
+
+    uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
+    controller->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
+    controller->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
+
+    controller->Synchronize();
+}
+
+void RGBController_LianLiUniHub_AL10::DeviceUpdateMode()
+{
+    initializedMode = true;
+
+    for (size_t channel = 0; channel < zones.size(); channel++)
+    {
+        uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
+        controller->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
+
+        switch (modes[active_mode].color_mode)
+        {
+            case MODE_COLORS_PER_LED:
+                controller->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
+                break;
+
+            case MODE_COLORS_MODE_SPECIFIC:
+                controller->SetLedColors(channel, modes[active_mode].colors.data(), modes[active_mode].colors.size());
+                break;
+
+            default:
+                controller->SetLedColors(channel, nullptr, 0);
+                break;
+        }
+
+        controller->SetLedMode(channel, modes[active_mode].value);
+
+        if(modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
+        {
+            controller->SetLedSpeed(channel, convertLedSpeed(modes[active_mode].speed));
+        }
+        else
+        {
+            controller->SetLedSpeed(channel, UNIHUB_AL10_LED_SPEED_075);
+        }
+
+        if(modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR)
+        {
+            controller->SetLedDirection(channel, convertLedDirection(modes[active_mode].direction));
+        }
+        else
+        {
+            controller->SetLedDirection(channel, UNIHUB_AL10_LED_DIRECTION_LTR);
+        }
+
+        if(modes[active_mode].flags & MODE_FLAG_HAS_BRIGHTNESS)
+        {
+            controller->SetLedBrightness(channel, convertLedBrightness(modes[active_mode].brightness));
+        }
+        else
+        {
+            controller->SetLedBrightness(channel, UNIHUB_AL10_LED_BRIGHTNESS_100);
+        }
+    }
+
+    if(modes[active_mode].value & 0x0200)
+    {
+        controller->EnableRgbhMode();
+        controller->DisableSyncMode();
+    }
+    else if (modes[active_mode].value & 0x0100)
+    {
+        controller->DisableRgbhMode();
+        controller->EnableSyncMode();
+    }
+    else
+    {
+        controller->DisableRgbhMode();
+        controller->DisableSyncMode();
+    }
+
+    controller->Synchronize();
+}
+
+void RGBController_LianLiUniHub_AL10::SetCustomMode()
+{
+    /*-------------------------------------------------*\
+    | Set mode to Static Color                          |
+    \*-------------------------------------------------*/
+    active_mode = 0;
+}
+
+uint8_t RGBController_LianLiUniHub_AL10::convertAnyFanCount(uint8_t count)
+{
+    switch (count)
+    {
+        case 0:
+            return UNIHUB_AL10_ANY_FAN_COUNT_000;
+
+        case 1:
+            return UNIHUB_AL10_ANY_FAN_COUNT_001;
+
+        case 2:
+            return UNIHUB_AL10_ANY_FAN_COUNT_002;
+
+        case 3:
+            return UNIHUB_AL10_ANY_FAN_COUNT_003;
+
+        case 4:
+            return UNIHUB_AL10_ANY_FAN_COUNT_004;
+
+        default:
+            return UNIHUB_AL10_ANY_FAN_COUNT_001;
+    }
+}
+
+uint8_t RGBController_LianLiUniHub_AL10::convertLedSpeed(uint8_t speed)
+{
+    switch (speed)
+    {
+        case 0:
+            return UNIHUB_AL10_LED_SPEED_000;
+
+        case 1:
+            return UNIHUB_AL10_LED_SPEED_025;
+
+        case 2:
+            return UNIHUB_AL10_LED_SPEED_050;
+
+        case 3:
+            return UNIHUB_AL10_LED_SPEED_075;
+
+        case 4:
+            return UNIHUB_AL10_LED_SPEED_100;
+
+        default:
+            return UNIHUB_AL10_LED_SPEED_050;
+    }
+}
+
+uint8_t RGBController_LianLiUniHub_AL10::convertLedDirection(uint8_t direction)
+{
+    switch (direction)
+    {
+        case 0:
+            return UNIHUB_AL10_LED_DIRECTION_LTR;
+
+        case 1:
+            return UNIHUB_AL10_LED_DIRECTION_RTL;
+
+        default:
+            return UNIHUB_AL10_LED_DIRECTION_LTR;
+    }
+}
+
+uint8_t RGBController_LianLiUniHub_AL10::convertLedBrightness(uint8_t brightness)
+{
+    switch (brightness)
+    {
+        case 0:
+            return UNIHUB_AL10_LED_BRIGHTNESS_000;
+
+        case 1:
+            return UNIHUB_AL10_LED_BRIGHTNESS_025;
+
+        case 2:
+            return UNIHUB_AL10_LED_BRIGHTNESS_050;
+
+        case 3:
+            return UNIHUB_AL10_LED_BRIGHTNESS_075;
+
+        case 4:
+            return UNIHUB_AL10_LED_BRIGHTNESS_100;
+
+        default:
+            return UNIHUB_AL10_LED_BRIGHTNESS_100;
+    }
+}
+uint8_t RGBController_LianLiUniHub_AL10::convertLedCountToFanCount(uint8_t count)
+{
+    /*-------------------------------------------------*\
+    | Converts <20 to 0, 20-39 to 1, 40-59 to 2, 60=79  |
+    | to 3  and 80+ to 4                                |
+    \*-------------------------------------------------*/
+    // Sets lower and upper limits
+    if (count == 0x00)
+    {
+        return 0x00;
+    }
+    if (count >= 0x50)
+    {
+        count = 0x50;
+    }
+
+    /*---------------------------------------------------------*\
+    | Returns regular count if it's not in multiples of 20s     |
+    | (AL120 has 20 LEDs per fan, LED strip scenario)           |
+    \*---------------------------------------------------------*/
+    if (count % 20)
+    {
+        return(count);
+    }
+    else
+    {
+        return(count / 20);
+    }
+}

Controllers/LianLiController/RGBController_LianLiUniHub_AL10.h

@@ -0,0 +1,47 @@
+/*-----------------------------------------*\
+|  RGBController_LianLiUniHub_AL10.h        |
+|                                           |
+|  Generic RGB Interface for Lian Li Uni    |
+|  Hub USB controller driver                |
+|                                           |
+|  Oliver P 05/05/2022                      |
+|  Credit to Luca Lovisa for original work. |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "LianLiUniHub_AL10Controller.h"
+#include "RGBController.h"
+
+class RGBController_LianLiUniHub_AL10 : public RGBController
+{
+public:
+    RGBController_LianLiUniHub_AL10(LianLiUniHub_AL10Controller* controller_ptr);
+
+    void SetupZones();
+
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
+
+    void DeviceUpdateMode();
+
+    void SetCustomMode();
+
+private:
+    uint8_t convertAnyFanCount(uint8_t count);
+    uint8_t convertLedSpeed(uint8_t speed);
+    uint8_t convertLedDirection(uint8_t direction);
+    uint8_t convertLedBrightness(uint8_t brightness);
+
+    uint8_t convertLedCountToFanCount(uint8_t count);
+
+private:
+    LianLiUniHub_AL10Controller* controller;
+    bool                    initializedMode;
+};

Controllers/LogitechController/LogitechControllerDetect.cpp

@@ -766,33 +766,30 @@ usages BundleLogitechUsages(hid_device_info* info)
     |   Grab all usages that you can open. For normal Logitech FAP      |
     |   devices this will be usage 1, 2 and 4                           |
     \*-----------------------------------------------------------------*/
+    usages temp_usages;
 
-    usages              temp_usages;
-    uint16_t            current_pid     = info->product_id;
-    hid_device_info*    temp_info       = info;
-
-    /*-----------------------------------------------------------------*\
-    | To avoid duplicate entries per device only look from usage 1      |
-    \*-----------------------------------------------------------------*/
-    if(temp_info->usage == 1)
+    hid_device_info* temp_info  = hid_enumerate(info->vendor_id, info->product_id);
+    while(temp_info)
     {
-        while(temp_info)
+        /*-----------------------------------------------------------------*\
+        | Only bundle the device that triggered this callback               |
+        \*-----------------------------------------------------------------*/
+        if(temp_info->interface_number == 2)
         {
-            /*-----------------------------------------------------------------*\
-            | Only bundle the device that triggered this callback               |
-            \*-----------------------------------------------------------------*/
-            if(temp_info->product_id == current_pid)
-            {
-                hid_device* dev = hid_open_path(temp_info->path);
+            LOG_DEBUG("Attempting to open dev path: %s", info->path);
+            hid_device* dev = hid_open_path(temp_info->path);
 
-                if(dev)
-                {
-                    LOG_DEBUG("Adding Usage %i for device @ path %s", temp_info->usage, temp_info->path);
-                    temp_usages.emplace((uint8_t)temp_info->usage, dev);
-                }
+            if(dev)
+            {
+                LOG_DEBUG("Success! Adding Usage %i for device @ path %s", temp_info->usage, temp_info->path);
+                temp_usages.emplace((uint8_t)temp_info->usage, dev);
+            }
+            else
+            {
+                LOG_INFO("FAILED! Can not add Usage %i for device @ path %s", temp_info->usage, temp_info->path);
             }
-            temp_info = temp_info->next;
         }
+        temp_info = temp_info->next;
     }
 
     return temp_usages;
@@ -833,8 +830,8 @@ void DetectLogitechLightspeedReceiver(hid_device_info* info, const std::string&
 /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
 | Lightspeed Receivers (Windows Wireless)                                                                                                           |
 \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Logitech Lightspeed Receiver",                        DetectLogitechLightspeedReceiver,   LOGITECH_VID, LOGITECH_G_LIGHTSPEED_RECEIVER_PID,   2, 0xFF00);
-REGISTER_HID_DETECTOR_IP("Logitech G Powerplay Mousepad",                       DetectLogitechLightspeedReceiver,   LOGITECH_VID, LOGITECH_G_LIGHTSPEED_POWERPLAY_PID,  2, 0xFF00);
+REGISTER_HID_DETECTOR_IPU("Logitech Lightspeed Receiver",                        DetectLogitechLightspeedReceiver,   LOGITECH_VID, LOGITECH_G_LIGHTSPEED_RECEIVER_PID,   2, 0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Logitech G Powerplay Mousepad",                       DetectLogitechLightspeedReceiver,   LOGITECH_VID, LOGITECH_G_LIGHTSPEED_POWERPLAY_PID,  2, 0xFF00, 1);
 
 #endif
 

Controllers/LogitechController/LogitechG213Controller.cpp

@@ -74,6 +74,7 @@ void LogitechG213Controller::SetDirect
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, (unsigned char *)usb_buf, 20);
+    hid_read(dev, (unsigned char *)usb_buf, 20);
 }
 
 void LogitechG213Controller::SetMode

Controllers/MSIGPUController/MSIGPUControllerDetect.cpp

@@ -54,6 +54,7 @@ REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2070 Gaming Z",                  Dete
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2070 Gaming",                    DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX2070_DEV,         MSI_SUB_VEN,    MSI_RTX2070_GAMING_SUB_DEV,             0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2070 ARMOR",                     DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX2070_DEV,         MSI_SUB_VEN,    MSI_RTX2070_ARMOR_SUB_DEV,              0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2070 ARMOR OC",                  DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      MSI_SUB_VEN,    MSI_RTX2070_ARMOR_SUB_DEV,              0x68);
+REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2070 SUPER ARMOR OC",            DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     MSI_SUB_VEN,    MSI_RTX2070S_ARMOR_OC_SUB_DEV,          0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2070 Super Gaming",              DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     MSI_SUB_VEN,    MSI_RTX2070S_GAMING_SUB_DEV,            0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2070 Super Gaming Trio",         DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     MSI_SUB_VEN,    MSI_RTX2070S_GAMING_TRIO_SUB_DEV,       0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2070 Super Gaming X",            DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     MSI_SUB_VEN,    MSI_RTX2070S_GAMING_X_SUB_DEV,          0x68);
@@ -65,9 +66,11 @@ REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2080 Sea Hawk EK X",             Dete
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2080 Duke 8G OC",                DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       MSI_SUB_VEN,    MSI_RTX2080_DUKE_OC_SUB_DEV,            0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2080 Super Gaming X Trio",       DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        MSI_SUB_VEN,    MSI_RTX2080S_GAMING_X_TRIO_SUB_DEV,     0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2080Ti Gaming X Trio",           DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     MSI_SUB_VEN,    MSI_RTX2080TI_GAMING_X_TRIO_SUB_DEV,    0x68);
+REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2080Ti Gaming Z Trio",           DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     MSI_SUB_VEN,    MSI_RTX2080TI_GAMING_Z_TRIO_SUB_DEV,    0X68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2080Ti 11G Gaming X Trio",       DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     MSI_SUB_VEN,    MSI_RTX2080TI_11G_GAMING_X_TRIO_SUB_DEV,0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 2080Ti Sea Hawk EK X",           DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     MSI_SUB_VEN,    MSI_RTX2080TI_SEA_HAWK_EK_X_SUB_DEV,    0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 3060 Gaming X 12G",              DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX3060_DEV,         MSI_SUB_VEN,    MSI_RTX3060_GAMING_X_12G_SUB_DEV,       0x68);
+REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 3060 Gaming X 12G LHR",          DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX3060_LHR_DEV,     MSI_SUB_VEN,    MSI_RTX3060_GAMING_X_12G_SUB_DEV,       0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 3060 Gaming X 12G (GA104)",      DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX3060_GA104_DEV,   MSI_SUB_VEN,    MSI_RTX3060_GAMING_X_12G_SUB_DEV,       0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 3060 12G Gaming X Trio LHR",     DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX3060_LHR_DEV,     MSI_SUB_VEN,    MSI_RTX3070_GAMING_X_TRIO_SUB_DEV,      0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 3060 12GB Gaming X Trio",        DetectMSIGPUControllers,    NVIDIA_VEN,     NVIDIA_RTX3060_DEV,         MSI_SUB_VEN,    MSI_RTX3070_GAMING_X_TRIO_SUB_DEV,      0x68);
@@ -99,4 +102,6 @@ REGISTER_I2C_PCI_DETECTOR("MSI Radeon RX 6800 Gaming X Trio",               Dete
 REGISTER_I2C_PCI_DETECTOR("MSI Radeon RX 6800 XT Gaming X Trio",            DetectMSIGPUControllers,    AMD_GPU_VEN,    AMD_NAVI21_DEV1,            MSI_SUB_VEN,    MSI_RX6800XT_GAMING_X_TRIO_SUB_DEV,     0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI Radeon RX 6800 XT Gaming Z Trio",            DetectMSIGPUControllers,    AMD_GPU_VEN,    AMD_NAVI21_DEV1,            MSI_SUB_VEN,    MSI_RX6800XT_GAMING_Z_TRIO_SUB_DEV,     0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI Radeon RX 6900 XT Gaming X Trio",            DetectMSIGPUControllers,    AMD_GPU_VEN,    AMD_NAVI21_DEV1,            MSI_SUB_VEN,    MSI_RX6900XT_GAMING_X_TRIO_SUB_DEV,     0x68);
+REGISTER_I2C_PCI_DETECTOR("MSI Radeon RX 6900 XT Gaming Z Trio",            DetectMSIGPUControllers,    AMD_GPU_VEN,    AMD_NAVI21_DEV2,            MSI_SUB_VEN,    MSI_RX6950XT_GAMING_X_TRIO_SUB_DEV,     0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI Radeon RX 6950 XT Gaming X Trio",            DetectMSIGPUControllers,    AMD_GPU_VEN,    AMD_NAVI21_DEV1,            MSI_SUB_VEN,    MSI_RX6950XT_GAMING_X_TRIO_SUB_DEV,     0x68);
+REGISTER_I2C_PCI_DETECTOR("MSI Radeon RX 6950 XT Gaming X Trio",            DetectMSIGPUControllers,    AMD_GPU_VEN,    AMD_NAVI21_DEV3,            MSI_SUB_VEN,    MSI_RX6950XT_GAMING_X_TRIO_SUB_DEV,     0x68);

Controllers/MSIMysticLightController/MSIMysticLight162Controller.cpp

@@ -65,9 +65,9 @@ static const Config board_configs[] =
     { 0x1720, 10, &zones_set0 },        // MPG Z390 GAMING EDGE AC
     { 0x7B12, 10, &zones_set0 },        // MEG Z390 ACE
     { 0x7B17, 10, &zones_set0 },        // MPG Z390 GAMING PRO CARBON
-    { 0x7B18, 6,  &zones_set1 },        // MAG Z390 TOMAHAWK            verified
-    { 0x7B50, 6,  &zones_set2 },        // MPG Z390M GAMING EDGE AC	    verified
-    { 0x7B85, 7,  &zones_set0 },        // B450 GAMING PRO CARBON       verified
+    { 0x7B18, 6,  &zones_set1 },        // MAG Z390 TOMAHAWK
+    { 0x7B50, 6,  &zones_set2 },        // MPG Z390M GAMING EDGE AC
+    { 0x7B85, 7,  &zones_set0 },        // B450 GAMING PRO CARBON
 };
 
 
@@ -501,13 +501,19 @@ void MSIMysticLight162Controller::ReadName()
     name.append(" ").append(std::string(wname.begin(), wname.end()));
 }
 
+MSI_MODE MSIMysticLight162Controller::GetMode()
+{
+    return (MSI_MODE)data.on_board_led.effect;
+}
+
 void MSIMysticLight162Controller::GetMode
     (
     MSI_ZONE        zone,
     MSI_MODE        &mode,
     MSI_SPEED       &speed,
     MSI_BRIGHTNESS  &brightness,
-    bool            &rainbow_color
+    bool            &rainbow_color,
+    unsigned int    &color
     )
 {
     /*-----------------------------------------------------*\
@@ -529,7 +535,8 @@ void MSIMysticLight162Controller::GetMode
     mode            = (MSI_MODE)zone_data->effect;
     speed           = (MSI_SPEED)(zone_data->speedAndBrightnessFlags & 0x03);
     brightness      = (MSI_BRIGHTNESS)((zone_data->speedAndBrightnessFlags >> 2) & 0x1F);
-    rainbow_color   = (zone_data->colorFlags & 0x80) >> 7;
+    rainbow_color   = (zone_data->colorFlags & 0x80) == 0 ? true : false;
+    color           = ToRGBColor(zone_data->color.R, zone_data->color.G, zone_data->color.B);
 }
 
 void MSIMysticLight162Controller::SetDirectMode

Controllers/MSIMysticLightController/MSIMysticLight162Controller.h

@@ -36,13 +36,16 @@ public:
                         bool            rainbow_color
                         );
 
+    MSI_MODE        GetMode();
+
     void            GetMode
                         (
                         MSI_ZONE        zone,
                         MSI_MODE        &mode,
                         MSI_SPEED       &speed,
                         MSI_BRIGHTNESS  &brightness,
-                        bool            &rainbow_color
+                        bool            &rainbow_color,
+                        unsigned int    &color
                         );
 
     void            SetZoneColor

Controllers/MSIMysticLightController/MSIMysticLight185Controller.cpp

@@ -29,6 +29,7 @@ using namespace std::chrono_literals;
 #define JRAINBOW2_MAX_LED_COUNT                 240
 #define JCORSAIR_MAX_LED_COUNT                  240
 
+#define MSI_DIRECT_MODE                         0x25
 #define PER_LED_BASIC_SYNC_MODE                 (0x80 | SYNC_SETTING_ONBOARD | SYNC_SETTING_JPIPE1 | SYNC_SETTING_JPIPE2)
 #define PER_LED_FULL_SYNC_MODE                  (PER_LED_BASIC_SYNC_MODE | SYNC_SETTING_JRAINBOW1 | SYNC_SETTING_JRAINBOW2 | SYNC_SETTING_JCORSAIR)
 
@@ -166,6 +167,30 @@ const std::vector<MSI_ZONE> zones_set12 =
     MSI_ZONE_ON_BOARD_LED_0
 };
 
+const std::vector<MSI_ZONE> zones_set13 =
+{
+    MSI_ZONE_J_RGB_1,
+    MSI_ZONE_J_RGB_2,
+    MSI_ZONE_J_RAINBOW_1,
+    MSI_ZONE_J_RAINBOW_2
+};
+
+const std::vector<MSI_ZONE> zones_set14 =
+{
+    MSI_ZONE_J_RAINBOW_1,
+    MSI_ZONE_J_RAINBOW_2
+};
+
+const std::vector<MSI_ZONE> zones_set15 =
+{
+    MSI_ZONE_J_RGB_1,
+    MSI_ZONE_J_RAINBOW_1,
+    MSI_ZONE_J_RAINBOW_2,
+    MSI_ZONE_J_RAINBOW_3,
+    MSI_ZONE_J_PIPE_1,
+    MSI_ZONE_J_PIPE_2,
+    MSI_ZONE_ON_BOARD_LED_0
+};
 
 
 /*---------------------------------------------------------------------------------------------------------------------------------*\
@@ -180,56 +205,64 @@ const std::vector<MSI_ZONE> zones_set12 =
 
 static const Config board_configs[] =
 {
-    { 0x7B93, 6,  1, 0, 1, &zones_set4,  MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED },     // MPG X570 GAMING PRO CARBON WIFI  verified
-    { 0x7C34, 0,  1, 1, 1, &zones_set8,  MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED },     // MEG X570 GODLIKE                 verified
-    { 0x7C35, 0,  1, 0, 1, &zones_set9,  MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED },     // MEG X570 ACE                     verified
+    { 0x7B93, 6,  1, 0, 1, &zones_set4,  MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED },     // MPG X570 GAMING PRO CARBON WIFI
+    { 0x7C34, 0,  1, 1, 1, &zones_set8,  MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED },     // MEG X570 GODLIKE
+    { 0x7C35, 0,  1, 0, 1, &zones_set9,  MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED },     // MEG X570 ACE
     { 0x7C36, 6,  1, 0, 1, &zones_set4,  MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED },     // PRESTIGE X570 CREATION
-    { 0x7C37, 1,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },       // MPG X570 GAMING PLUS             verified
-    { 0x7C56, 6,  0, 0, 1, &zones_set2,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG B550 GAMING PLUS             verified
+    { 0x7C37, 1,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },       // MPG X570 GAMING PLUS
+    { 0x7C56, 6,  0, 0, 1, &zones_set2,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG B550 GAMING PLUS
     { 0x7C59, 0,  8, 0, 1, &zones_set9,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },       // CREATOR TRX40
-    { 0x7C67, 6,  0, 0, 1, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },       // MAG B365M MORTAR                 verified
-    { 0x7C71, 6,  6, 0, 1, &zones_set3,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MEG Z490 ACE                     verified
-    { 0x7C73, 6,  4, 0, 1, &zones_set3,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG Z490 GAMING CARBON WIFI      verified
-    { 0x7C75, 6,  0, 0, 1, &zones_set2,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG Z490 GAMING PLUS             verified
+    { 0x7C60, 6,  0, 0, 1, &zones_set1,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       	// TRX40-A PRO
+    { 0x7C67, 6,  0, 0, 1, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },       // MAG B365M MORTAR
+    { 0x7C71, 6,  6, 0, 1, &zones_set3,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MEG Z490 ACE
+    { 0x7C73, 6,  4, 0, 1, &zones_set3,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG Z490 GAMING CARBON WIFI
+    { 0x7C75, 6,  0, 0, 1, &zones_set2,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG Z490 GAMING PLUS
     { 0x7C76, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },       // MPG Z490M GAMING EDGE
-    { 0x7C79, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG Z490 GAMING EDGE WIFI        verified
-    { 0x7C80, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG Z490 TOMAHAWK                verified
-    { 0x7C81, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },       // MAG B460 TOMAHAWK
+    { 0x7C77, 0,  0, 0, 0, &zones_set14, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MEG Z490I UNIFY
+    { 0x7C79, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG Z490 GAMING EDGE WIFI
+    { 0x7C80, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG Z490 TOMAHAWK
+    { 0x7C81, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B460 TOMAHAWK
     { 0x7C83, 6,  0, 0, 1, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },       // B460M PRO-VDH WIFI
-    { 0x7C84, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED },     // MAG X570 TOMAHAWK WIFI           verified
+    { 0x7C84, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED },     // MAG X570 TOMAHAWK WIFI
     { 0x7C86, 6,  0, 0, 1, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },       // MPG B460I GAMING EDGE
-    { 0x7C90, 6,  4, 0, 1, &zones_set3,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG B550 GAMING CARBON WIFI      verified
-    { 0x7C91, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B550 TOMAHAWK                verified
+    { 0x7C90, 6,  4, 0, 1, &zones_set3,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG B550 GAMING CARBON WIFI
+    { 0x7C91, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B550 TOMAHAWK
     { 0x7C92, 6,  0, 0, 0, &zones_set6,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },       // MPG B550I GAMING EDGE WIFI
-    { 0x7C94, 6,  0, 0, 1, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B550M MORTAR                 verified
-    { 0x7C95, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // B550M PRO-VDH WIFI               verified
-    { 0x7C98, 6,  0, 0, 1, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // Z490 PLUS                        verified
+    { 0x7C94, 6,  0, 0, 1, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B550M MORTAR
+    { 0x7C95, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // B550M PRO-VDH WIFI
+    { 0x7C98, 6,  0, 0, 1, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // Z490 PLUS
     { 0x7D06, 4,  4, 0, 1, &zones_set3,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },       // MPG Z590 GAMING FORCE
-    { 0x7D07, 4,  5, 0, 2, &zones_set7,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG Z590 GAMING EDGE WIFI        verified
+    { 0x7D07, 4,  5, 0, 2, &zones_set7,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG Z590 GAMING EDGE WIFI
     { 0x7D08, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG Z590 TOMAHAWK
-    { 0x7D09, 6,  0, 0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // Z590-A PRO WIFI                  verified
+    { 0x7D09, 6,  0, 0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // Z590-A PRO WIFI
     { 0x7D13, 6,  0, 0, 1, &zones_set1,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },       // MEG B550 UNIFY
-    { 0x7D15, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B560 TOMAHAWK WIFI           verified
-    { 0x7D17, 6,  0, 0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B560M MORTAR                 verified
-    { 0x7D18, 6,  0, 0, 2, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B560M PRO-VDH                verified
-    { 0x7D19, 6,  0, 0, 2, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG B560I GAMIING EDGE WIFI		verified
-    { 0x7D20, 6,  0, 0, 2, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B560M PRO                    verified
-    { 0x7D25, 6,  0, 0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // PRO Z690-A WIFI DDR4             verified
+    { 0x7D15, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B560 TOMAHAWK WIFI
+    { 0x7D17, 6,  0, 0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B560M MORTAR
+    { 0x7D18, 6,  0, 0, 2, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B560M PRO-VDH
+    { 0x7D19, 6,  0, 0, 2, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG B560I GAMIING EDGE WIFI
+    { 0x7D20, 6,  0, 0, 2, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B560M PRO
+    { 0x7D25, 6,  0, 0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // PRO Z690-A WIFI DDR4
     { 0x7D27, 6,  0, 0, 2, &zones_set1,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MEG Z690 ACE
-    { 0x7D28, 6,  0, 0, 1, &zones_set1,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MEG Z690 UNIFY-X                 verified
+    { 0x7D28, 6,  0, 0, 1, &zones_set1,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MEG Z690 UNIFY-X
     { 0x7D29, 6,  0, 0, 0, &zones_set6,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },       // MEG Z690I UNIFY
-    { 0x7D30, 6,  6, 0, 2, &zones_set3,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG Z690 CARBON WIFI             verified
-    { 0x7D31, 4,  8, 0, 2, &zones_set12, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG EDGE WIFI DDR4               verified
-    { 0x7D32, 1,  0, 0, 1, &zones_set10, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG Z690 TOMAHAWK WIFI DDR4      verified
-    { 0x7D36, 6,  0, 0, 2, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // PRO Z690-P DDR4                  verified
-    { 0x7D42, 6,  0, 0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B660 MORTAR WIFI DDR4        verified
-    { 0x7D43, 0,  0, 0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // PRO B660M-A WIFI DDR4            verified
-    { 0x7D50, 6, 12, 0, 1, &zones_set4,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MEG X570S ACE MAX                verified
-    { 0x7D51, 6,  0, 0, 2, &zones_set1,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MEG X570S UNIFY-X MAX            verified
-    { 0x7D52, 6, 14, 0, 1, &zones_set4,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG X570S CARBON EK X            verified
-    { 0x7D53, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG X570S EDGE MAX WIFI          verified
-    { 0x7D54, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG X570S TOMAHAWK MAX WIFI      verified
-    { 0x7D59, 0,  0, 0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // PRO B660-A DDR4                  verified
+    { 0x7D30, 6,  6, 0, 2, &zones_set3,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG Z690 CARBON WIFI
+    { 0x7D31, 4,  8, 0, 2, &zones_set12, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG EDGE WIFI DDR4
+    { 0x7D32, 1,  0, 0, 1, &zones_set10, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG Z690 TOMAHAWK WIFI DDR4
+    { 0x7D36, 6,  0, 0, 2, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // PRO Z690-P DDR4
+    { 0x7D38, 0,  0, 0, 1, &zones_set1,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MEG Z590 UNIFY-X
+    { 0x7D41, 6,  0, 0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B660M TOMAHAWK WIFI DDR4
+    { 0x7D42, 6,  0, 0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG B660 MORTAR WIFI DDR4
+    { 0x7D43, 0,  0, 0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // PRO B660M-A WIFI DDR4
+    { 0x7D50, 6, 12, 0, 1, &zones_set4,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MEG X570S ACE MAX
+    { 0x7D51, 6,  0, 0, 2, &zones_set1,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MEG X570S UNIFY-X MAX
+    { 0x7D52, 6, 14, 0, 1, &zones_set4,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG X570S CARBON EK X
+    { 0x7D53, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MPG X570S EDGE MAX WIFI
+    { 0x7D54, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG X570S TOMAHAWK MAX WIFI
+    { 0x7D59, 0,  0, 0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // PRO B660-A DDR4
+    { 0x7D69, 9,  2, 4, 1, &zones_set15, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MEG X670E ACE
+    { 0x7D91, 1,  0, 0, 1, &zones_set10, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // MAG Z790 TOMAHAWK WIFI
+    { 0x7E06, 0,  0, 0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // PRO Z790-P WIFI DDR4
+    { 0x7D77, 6,  0, 0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },        // PRO B650M-A WIFI                 
 };
 
 
@@ -372,7 +405,7 @@ MSIMysticLight185Controller::MSIMysticLight185Controller
     enable_per_led_msg.j_corsair.is_individual = 0x78;
     enable_per_led_msg.j_corsair_outerll120.speedAndBrightnessFlags = 0x28;
     enable_per_led_msg.j_corsair_outerll120.colorFlags = 0x80;
-    enable_per_led_msg.on_board_led.effect = 0x25;
+    enable_per_led_msg.on_board_led.effect = MSI_DIRECT_MODE;
     enable_per_led_msg.on_board_led.speedAndBrightnessFlags = 0x29 | SYNC_SETTING_JRGB;
     enable_per_led_msg.on_board_led.colorFlags = PER_LED_FULL_SYNC_MODE;
     enable_per_led_msg.on_board_led_1.speedAndBrightnessFlags = 0x28;
@@ -965,21 +998,38 @@ void MSIMysticLight185Controller::ReadName()
     name.append(" ").append(std::string(wname.begin(), wname.end()));
 }
 
-void MSIMysticLight185Controller::GetMode(MSI_ZONE zone,
-                                          MSI_MODE &mode,
-                                          MSI_SPEED &speed,
-                                          MSI_BRIGHTNESS &brightness,
-                                          bool &rainbow_color)
+MSI_MODE MSIMysticLight185Controller::GetMode()
+{
+    if(data.on_board_led.effect == MSI_DIRECT_MODE)
+    {
+        direct_mode = true;
+        return MSI_MODE_DIRECT_DUMMY;
+    }
+    else
+    {
+        return (MSI_MODE)data.j_rainbow_1.effect;
+    }
+}
+
+void MSIMysticLight185Controller::GetMode
+    (
+    MSI_ZONE zone,
+    MSI_MODE &mode,
+    MSI_SPEED &speed,
+    MSI_BRIGHTNESS &brightness,
+    bool &rainbow_color,
+    unsigned int &color
+    )
 {
     /*-----------------------------------------------------*\
     | Get data for given zone                               |
     \*-----------------------------------------------------*/
-    ZoneData *zoneData = GetZoneData(data, zone);
+    ZoneData *zone_data = GetZoneData(data, zone);
 
     /*-----------------------------------------------------*\
     | Return if zone is invalid                             |
     \*-----------------------------------------------------*/
-    if(!zoneData)
+    if(!zone_data)
     {
         return;
     }
@@ -987,10 +1037,11 @@ void MSIMysticLight185Controller::GetMode(MSI_ZONE zone,
     /*-----------------------------------------------------*\
     | Update pointers with data                             |
     \*-----------------------------------------------------*/
-    mode            = (MSI_MODE)zoneData->effect;
-    speed           = (MSI_SPEED)(zoneData->speedAndBrightnessFlags & 0x03);
-    brightness      = (MSI_BRIGHTNESS)((zoneData->speedAndBrightnessFlags >> 2) & 0x1F);
-    rainbow_color   = (zoneData->colorFlags & 0x80) >> 7;
+    mode            = (MSI_MODE)zone_data->effect;
+    speed           = (MSI_SPEED)(zone_data->speedAndBrightnessFlags & 0x03);
+    brightness      = (MSI_BRIGHTNESS)((zone_data->speedAndBrightnessFlags >> 2) & 0x1F);
+    rainbow_color   = (zone_data->colorFlags & 0x80) == 0 ? true : false;
+    color           = ToRGBColor(zone_data->color.R, zone_data->color.G, zone_data->color.B);
 }
 
 void MSIMysticLight185Controller::SetCycleCount
@@ -1125,17 +1176,17 @@ void MSIMysticLight185Controller::SelectPerLedProtocol()
     {
         if(!no_jrainbow1)
         {
-            enable_per_led_msg.j_rainbow_1.effect = 0x25;
+            enable_per_led_msg.j_rainbow_1.effect = MSI_DIRECT_MODE;
             enable_per_led_msg.j_rainbow_1.cycle_or_led_num = JRAINBOW1_MAX_LED_COUNT;
         }
         if(!no_jrainbow2)
         {
-            enable_per_led_msg.j_rainbow_2.effect = 0x25;
+            enable_per_led_msg.j_rainbow_2.effect = MSI_DIRECT_MODE;
             enable_per_led_msg.j_rainbow_2.cycle_or_led_num = JRAINBOW2_MAX_LED_COUNT;
         }
         if(!no_jcorsair)
         {
-            enable_per_led_msg.j_corsair.effect = 0x25;
+            enable_per_led_msg.j_corsair.effect = MSI_DIRECT_MODE;
             enable_per_led_msg.j_corsair.is_individual = JCORSAIR_MAX_LED_COUNT;
         }
         enable_per_led_msg.on_board_led.colorFlags = PER_LED_BASIC_SYNC_MODE;

Controllers/MSIMysticLightController/MSIMysticLight185Controller.h

@@ -37,13 +37,16 @@ public:
                         bool            rainbow_color
                         );
 
+    MSI_MODE        GetMode();
+
     void            GetMode
                         (
                         MSI_ZONE        zone,
                         MSI_MODE        &mode,
                         MSI_SPEED       &speed,
                         MSI_BRIGHTNESS  &brightness,
-                        bool            &rainbow_color
+                        bool            &rainbow_color,
+                        unsigned int    &color
                         );
 
     void            SetZoneColor

Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp

@@ -20,7 +20,6 @@
 \*---------------------------------------------------------------------------------*/
 //#define ENABLE_UNTESTED_MYSTIC_LIGHT
 
-
 /*----------------------------------------------------------------------------------------*\
 |                                                                                          |
 |   DetectMSIMysticLightControllers                                                        |
@@ -56,12 +55,6 @@ void DetectMSIMysticLightControllers
             rgb_controller->name = "MSI " + dmi.getMainboard();
             ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
-        else if(packet_length == sizeof(FeaturePacket_64) )
-        {
-            MSIMysticLight64Controller*     controller     = new MSIMysticLight64Controller(dev, info->path);
-            RGBController_MSIMysticLight64* rgb_controller = new RGBController_MSIMysticLight64(controller);
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
-        }
         else    // no supported length returned
         {
             std::string name = "MSI " + dmi.getMainboard();
@@ -71,7 +64,26 @@ void DetectMSIMysticLightControllers
     }
 }
 
-REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_1563",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x1563,   0x00FF, 0x01);
+
+void DetectMSIMysticLight64Controllers
+    (
+    hid_device_info*    info,
+    const std::string&  /*name*/
+    )
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev != nullptr)
+    {
+        MSIMysticLight64Controller*     controller     = new MSIMysticLight64Controller(dev, info->path);
+        RGBController_MSIMysticLight64* rgb_controller = new RGBController_MSIMysticLight64(controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_1562",    DetectMSIMysticLight64Controllers, MSI_USB_VID,    0x1562,   0x00FF, 0x01);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_1563",    DetectMSIMysticLight64Controllers, MSI_USB_VID,    0x1563,   0x00FF, 0x01);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_1564",    DetectMSIMysticLight64Controllers, MSI_USB_VID,    0x1564,   0x00FF, 0x01);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_1720",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x1720,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B12",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7B12,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B16",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7B16,   0x0001, 0x00);
@@ -86,11 +98,13 @@ REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C36",    DetectMSIMysticLightCont
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C37",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C37,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C56",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C56,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C59",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C59,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C60",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C60,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C67",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C67,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C71",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C71,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C73",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C73,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C75",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C75,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C76",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C76,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C77",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C77,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C79",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C79,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C80",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C80,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C81",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C81,   0x0001, 0x00);
@@ -121,6 +135,8 @@ REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D30",    DetectMSIMysticLightCont
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D31",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D31,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D32",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D32,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D36",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D36,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D38",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D38,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D41",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D41,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D42",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D42,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D43",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D43,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D50",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D50,   0x0001, 0x00);
@@ -129,6 +145,10 @@ REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D52",    DetectMSIMysticLightCont
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D53",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D53,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D54",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D54,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D59",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D59,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D69",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D69,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D91",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D91,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E06",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7E06,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D77",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D77,   0x0001, 0x00);
 
 #ifdef ENABLE_UNTESTED_MYSTIC_LIGHT
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_3EA4",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x3EA4,   0x0001, 0x00);
@@ -137,9 +157,7 @@ REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B10",    DetectMSIMysticLightCont
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B94",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7B94,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7B96",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7B96,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C42",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C42,   0x0001, 0x00);
-REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C60",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C60,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C70",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C70,   0x0001, 0x00);
-REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C77",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C77,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C82",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C82,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C85",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C85,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C87",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7C87,   0x0001, 0x00);

Controllers/MSIMysticLightController/RGBController_MSIMysticLight162.cpp

@@ -76,6 +76,8 @@ RGBController_MSIMysticLight162::RGBController_MSIMysticLight162
     SetupModes();
     SetupZones();
     SetupColors();
+    active_mode = GetDeviceMode();
+    GetDeviceConfig();
 }
 
 RGBController_MSIMysticLight162::~RGBController_MSIMysticLight162()
@@ -84,6 +86,21 @@ RGBController_MSIMysticLight162::~RGBController_MSIMysticLight162()
     delete controller;
 }
 
+int RGBController_MSIMysticLight162::GetDeviceMode()
+{
+    MSI_MODE mode = controller->GetMode();
+
+    for(unsigned int i = 0; i < modes.size(); ++i)
+    {
+        if(mode == modes[i].value)
+        {
+            return i;
+        }
+    }
+
+    return 0;
+}
+
 void RGBController_MSIMysticLight162::SetupZones()
 {
     /*---------------------------------------------------------*\
@@ -339,3 +356,54 @@ void RGBController_MSIMysticLight162::SetupMode
 
     modes.push_back(Mode);
 }
+
+void RGBController_MSIMysticLight162::GetDeviceConfig()
+{
+    MSI_MODE       mode;
+    MSI_SPEED      speed;
+    MSI_BRIGHTNESS brightness;
+    bool           rainbow;
+    unsigned int   color;
+
+    for(size_t i = 0; i < zone_description.size(); ++i)
+    {
+        controller->GetMode(zone_description[i]->zone_type, mode, speed, brightness, rainbow, color);
+
+        for(size_t j = 0; j < zones[i].leds_count; ++j)
+        {
+            zones[i].colors[j] = color;
+        }
+    }
+
+    controller->GetMode(zone_description[0]->zone_type, mode, speed, brightness, rainbow, color);
+
+    for(size_t i = 0; i < modes.size(); ++i)
+    {
+        if(mode == modes[i].value)
+        {
+            if(modes[i].flags & MODE_FLAG_HAS_SPEED)
+            {
+                modes[i].speed = speed;
+            }
+            if(modes[i].flags & MODE_FLAG_HAS_BRIGHTNESS)
+            {
+                modes[i].brightness = brightness;
+            }
+            if(rainbow)
+            {
+                if(modes[i].flags & (MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR))
+                {
+                    if(rainbow)
+                    {
+                        modes[i].color_mode = MODE_COLORS_RANDOM;
+                    }
+                    else
+                    {
+                        modes[i].color_mode = MODE_COLORS_PER_LED;
+                    }
+                 }
+            }
+            break;
+        }
+    }
+}

Controllers/MSIMysticLightController/RGBController_MSIMysticLight162.h

@@ -41,6 +41,8 @@ private:
                     MSI_MODE        mode,
                     unsigned int    flags
                     );
+    int         GetDeviceMode();
+    void        GetDeviceConfig();
 
     MSIMysticLight162Controller*    controller;
 };

Controllers/MSIMysticLightController/RGBController_MSIMysticLight185.cpp

@@ -40,7 +40,7 @@ static std::vector<const ZoneDescription*> zone_description;
 | Returns the index of the zone_description in led_zones which has zone_type equal to the given zone_type.  |
 | Returns -1 if no such zone_description exists.                                                            |
 \*---------------------------------------------------------------------------------------------------------*/
-int IndexOfZoneForType(MSI_ZONE zone_type)
+static int IndexOfZoneForType(MSI_ZONE zone_type)
 {
     for(size_t i = 0; i < zone_description.size(); ++i)
 	{
@@ -94,8 +94,10 @@ RGBController_MSIMysticLight185::RGBController_MSIMysticLight185
         }
     }
 
+    last_resizable_zone = MSI_ZONE_NONE;
     SetupModes();
     SetupZones();
+    active_mode         = GetDeviceMode();
 }
 
 RGBController_MSIMysticLight185::~RGBController_MSIMysticLight185()
@@ -104,6 +106,21 @@ RGBController_MSIMysticLight185::~RGBController_MSIMysticLight185()
     delete controller;
 }
 
+int RGBController_MSIMysticLight185::GetDeviceMode()
+{
+    MSI_MODE mode = controller->GetMode();
+
+    for(unsigned int i = 0; i < modes.size(); ++i)
+    {
+        if(mode == modes[i].value)
+        {
+            return i;
+        }
+    }
+
+    return 0;
+}
+
 void RGBController_MSIMysticLight185::SetupZones()
 {
     /*-------------------------------------------------*\
@@ -112,14 +129,14 @@ void RGBController_MSIMysticLight185::SetupZones()
     leds.clear();
     colors.clear();
 
-    bool firstRun = false;
+    bool first_run = false;
 
     if(zones.size() == 0)
     {
-        firstRun = true;
+        first_run = true;
     }
 
-    if(firstRun)
+    if(first_run)
     {
         /*---------------------------------------------------------*\
         | Set up zones                                              |
@@ -143,7 +160,7 @@ void RGBController_MSIMysticLight185::SetupZones()
             || ((zd->zone_type != MSI_ZONE_J_RAINBOW_1) && (zd->zone_type != MSI_ZONE_J_RAINBOW_2) && (zd->zone_type != MSI_ZONE_J_RAINBOW_3) && (zd->zone_type != MSI_ZONE_J_CORSAIR)))
             {
                 new_zone.leds_min   = maxLeds;
-                new_zone.leds_min   = maxLeds;
+                new_zone.leds_max   = maxLeds;
                 new_zone.leds_count = maxLeds;
             }
             /*--------------------------------------------------\
@@ -154,6 +171,7 @@ void RGBController_MSIMysticLight185::SetupZones()
                 new_zone.leds_min   = 0;
                 new_zone.leds_max   = maxLeds;
                 new_zone.leds_count = 0;
+                last_resizable_zone = zd->zone_type;
             }
 
             /*-------------------------------------------------*\
@@ -216,6 +234,12 @@ void RGBController_MSIMysticLight185::ResizeZone
     {
         zones[zone].leds_count = new_size;
         SetupZones();
+
+        if(zone_description[zone]->zone_type == last_resizable_zone)
+        {
+            GetDeviceConfig();
+            last_resizable_zone = MSI_ZONE_NONE;
+        }
     }
 }
 
@@ -412,3 +436,60 @@ void RGBController_MSIMysticLight185::SetupMode
 
     modes.push_back(Mode);
 }
+
+void RGBController_MSIMysticLight185::GetDeviceConfig()
+{
+    if(controller->GetMode() != MSI_MODE_DIRECT_DUMMY)
+    {
+        MSI_MODE       mode;
+        MSI_SPEED      speed;
+        MSI_BRIGHTNESS brightness;
+        bool           rainbow;
+        unsigned int   color;
+
+        for(size_t i = 0; i < zone_description.size(); ++i)
+        {
+            controller->GetMode(zone_description[i]->zone_type, mode, speed, brightness, rainbow, color);
+
+            if(zones[i].colors != nullptr)
+            {
+                for(size_t j = 0; j < zones[i].leds_count; ++j)
+                {
+                    zones[i].colors[j] = color;
+                }
+            }
+        }
+
+        controller->GetMode(zone_description[0]->zone_type, mode, speed, brightness, rainbow, color);
+
+        for(size_t i = 0; i < modes.size(); ++i)
+        {
+            if(mode == modes[i].value)
+            {
+                if(modes[i].flags & MODE_FLAG_HAS_SPEED)
+                {
+                    modes[i].speed = speed;
+                }
+                if(modes[i].flags & MODE_FLAG_HAS_BRIGHTNESS)
+                {
+                   modes[i].brightness = brightness;
+                }
+                if(rainbow)
+                {
+                    if(modes[i].flags & (MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR))
+                    {
+                        if(rainbow)
+                        {
+                            modes[i].color_mode = MODE_COLORS_RANDOM;
+                        }
+                        else
+                        {
+                            modes[i].color_mode = MODE_COLORS_PER_LED;
+                        }
+                    }
+                }
+                break;
+            }
+        }
+    }
+}

Controllers/MSIMysticLightController/RGBController_MSIMysticLight185.h

@@ -42,6 +42,9 @@ private:
                     MSI_MODE        mode,
                     unsigned int    flags
                     );
+    int         GetDeviceMode();
+    void        GetDeviceConfig();
 
     MSIMysticLight185Controller*    controller;
+    MSI_ZONE                        last_resizable_zone;
 };

Controllers/MSIMysticLightController/RGBController_MSIMysticLight64.cpp

@@ -6,7 +6,7 @@
     @type USB
     @save :robot:
     @effects :white_check_mark:
-    @detectors DetectMSIMysticLightControllers
+    @detectors DetectMSIMysticLight64Controllers
     @comment
 \*-------------------------------------------------------------------*/
 

Controllers/MSIRGBController/MSIRGBControllerDetect.cpp

@@ -80,9 +80,9 @@ static msi_device compatible_devices[] =
 void DetectMSIRGBControllers(std::vector<RGBController*> &rgb_controllers)
 {
     int sio_addrs[2] = {0x2E, 0x4E};
-    
+
     DMIInfo board;
-    std::string board_dmi = board.getMainboard(); 
+    std::string board_dmi = board.getMainboard();
     std::string manufacturer = board.getManufacturer();
 
     if (manufacturer != "Micro-Star International Co., Ltd." && manufacturer != "Micro-Star International Co., Ltd" && manufacturer != "MSI")

Controllers/NVIDIAIlluminationController/NVIDIAIlluminationControllerDetect.cpp

@@ -57,6 +57,7 @@ static const gpu_pci_device device_list[] =
     {NVIDIA_VEN,    NVIDIA_RTX3080TI_DEV,           NVIDIA_VEN,     NVIDIA_RTX3080TI_FE_SUB_DEV,                NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA 3080TI FE"              },
     {NVIDIA_VEN,    NVIDIA_RTX3090_DEV,             NVIDIA_VEN,     NVIDIA_RTX3090_FE_SUB_DEV,                  NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA 3090 FE"                },
     {NVIDIA_VEN,    NVIDIA_RTX3090TI_DEV,           NVIDIA_VEN,     NVIDIA_RTX3090TI_FE_SUB_DEV,                NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA 3090TI FE"              },
+    {NVIDIA_VEN,    NVIDIA_RTX4090_DEV,             NVIDIA_VEN,     NVIDIA_RTX4090_FE_SUB_DEV,                  NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA 4090 FE"                },
 };
 
 void DetectNVIDIAIllumGPUs(std::vector<RGBController*> &rgb_controllers)

Controllers/PNYGPUController/PNYGPUControllerDetect.cpp

@@ -37,6 +37,7 @@ void DetectPNYGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const s
 
 REGISTER_I2C_PCI_DETECTOR("PNY XLR8 Revel EPIC-X RTX 3080",     DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3080_DEV,         PNY_SUB_VEN,    PNY_RTX_3080_XLR8_REVEL_EPIC_X_SUB_DEV, 0x49);
 REGISTER_I2C_PCI_DETECTOR("PNY XLR8 Revel EPIC-X RTX 3090",     DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3090_DEV,         PNY_SUB_VEN,    PNY_RTX_3090_XLR8_REVEL_EPIC_X_SUB_DEV, 0x49);
+REGISTER_I2C_PCI_DETECTOR("PNY XLR8 OC EDITION RTX 2060",       DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX2060_TU104_DEV,   PNY_SUB_VEN,    PNY_RTX_2060_XLR8_OC_SUB_DEV,           0x49);
 REGISTER_I2C_PCI_DETECTOR("Palit 3060",                         DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3060_DEV,         PALIT_SUB_VEN,  PALIT_RTX3060_SUB_DEV,                  0x49);
 REGISTER_I2C_PCI_DETECTOR("Palit 3060 LHR",                     DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     PALIT_SUB_VEN,  PALIT_RTX3060_LHR_SUB_DEV,              0x49);
 REGISTER_I2C_PCI_DETECTOR("Palit 3060Ti",                       DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3060TI_DEV,       PALIT_SUB_VEN,  PALIT_RTX3060TI_SUB_DEV,                0x49);
@@ -52,3 +53,4 @@ REGISTER_I2C_PCI_DETECTOR("Palit 3080Ti Gamerock",              DetectPNYGPUCont
 REGISTER_I2C_PCI_DETECTOR("Palit 3090",                         DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3090_DEV,         PALIT_SUB_VEN,  PALIT_RTX3090_SUB_DEV,                  0x49);
 REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3060 Ti Dual",     DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3060TI_DEV,       NVIDIA_SUB_VEN, PALIT_RTX3060TI_SUB_DEV,                0x49);
 REGISTER_I2C_PCI_DETECTOR("NVIDIA RTX2080S",                    DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        NVIDIA_SUB_VEN, NVIDIA_RTX2080S_DEV,                    0x49);
+REGISTER_I2C_PCI_DETECTOR("NVIDIA RTX2060S",                    DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX2060_TU106_DEV,        NVIDIA_SUB_VEN, NVIDIA_RTX2060_TU106_DEV,                    0x49);

Controllers/RazerController/RGBController_Razer.cpp

@@ -25,6 +25,18 @@ RGBController_Razer::RGBController_Razer(RazerController* controller_ptr)
     serial                  = controller->GetSerialString();
     uint8_t max_brightness  = controller->GetMaxBrightness();
 
+    if(type == DEVICE_TYPE_KEYBOARD)
+    {
+        std::string layout = controller->GetKeyboardLayoutName();
+
+        description.append(", ");
+        description.append(layout);
+    }
+
+    std::string variant = controller->GetVariantName();
+    description.append(", ");
+    description.append(variant);
+
     mode Direct;
     Direct.name             = "Direct";
     Direct.value            = RAZER_MODE_DIRECT;
@@ -122,6 +134,7 @@ RGBController_Razer::~RGBController_Razer()
 void RGBController_Razer::SetupZones()
 {
     unsigned int device_index = controller->GetDeviceIndex();
+    unsigned char layout_type = controller->GetKeyboardLayoutType();
 
     /*---------------------------------------------------------*\
     | Fill in zone information based on device table            |
@@ -153,7 +166,46 @@ void RGBController_Razer::SetupZones()
                 {
                     for(unsigned int x = 0; x < new_map->width; x++)
                     {
-                        new_map->map[(y * new_map->width) + x] = (y * new_map->width) + x;
+                        bool exists_in_keymap = false;
+
+                        if(new_zone.name != ZONE_EN_KEYBOARD)
+                        {
+                            /*---------------------------------------------------------*\
+                            | For zones other than the actual keyboard, we want all     |
+                            | entries in the matrix visible in the LED view (such as    |
+                            | underglow)                                                |
+                            \*---------------------------------------------------------*/
+                            exists_in_keymap = true;
+                        }
+                        else if(device_list[device_index]->keymap != NULL)
+                        {
+                            for(unsigned int i = 0; i < device_list[device_index]->keymap_size; i++)
+                            {
+                                razer_key key = device_list[device_index]->keymap[i];
+                                if(zone_id == key.zone && y  == key.row  && x  == key.col && (key.layout & layout_type))
+                                {
+                                    exists_in_keymap = true;
+                                    break;
+                                }
+                            }   
+                        }
+                        else
+                        {
+                            /*---------------------------------------------------------*\
+                            | If the device has no keymap defined we want all entries in|
+                            | the matrix to be visible in the LED view                  |
+                            \*---------------------------------------------------------*/
+                            exists_in_keymap = true;
+                        }
+
+                        if (exists_in_keymap)
+                        {
+                            new_map->map[(y * new_map->width) + x] = (y * new_map->width) + x;
+                        }
+                        else
+                        {
+                            new_map->map[(y * new_map->width) + x] = -1;
+                        }
                     }
                 }
             }

Controllers/RazerController/RazerController.cpp

@@ -54,7 +54,9 @@ RazerController::RazerController(hid_device* dev_handle, hid_device* dev_argb_ha
         case RAZER_BLADE_2021_BASE_V2_PID:
         case RAZER_CYNOSA_V2_PID:
         case RAZER_ORNATA_CHROMA_V2_PID:
+        case RAZER_ORNATA_V3_PID:
         case RAZER_TARTARUS_CHROMA_PID:
+        case RAZER_TARTARUS_PRO_PID:
         case RAZER_TARTARUS_V2_PID:
         case RAZER_DEATHADDER_CHROMA_PID:
         case RAZER_DEATHADDER_ESSENTIAL_V2_PID:
@@ -106,6 +108,7 @@ RazerController::RazerController(hid_device* dev_handle, hid_device* dev_argb_ha
         case RAZER_FIREFLY_V2_PID:
         case RAZER_NOMMO_CHROMA_PID:
         case RAZER_NOMMO_PRO_PID:
+        case RAZER_STRIDER_CHROMA_PID:
         default:
             dev_transaction_id = 0x3F;
             break;
@@ -135,6 +138,8 @@ RazerController::RazerController(hid_device* dev_handle, hid_device* dev_argb_ha
         case RAZER_NAGA_CLASSIC_PID:
         case RAZER_NAGA_LEFT_HANDED_PID:
         case RAZER_O11_DYNAMIC_PID:
+        case RAZER_STRIDER_CHROMA_PID:
+        case RAZER_TARTARUS_PRO_PID:
         case RAZER_TARTARUS_V2_PID:
             dev_led_id = RAZER_LED_ID_ZERO;
             break;
@@ -162,6 +167,7 @@ RazerController::RazerController(hid_device* dev_handle, hid_device* dev_argb_ha
         case RAZER_HUNTSMAN_V2_PID:
         case RAZER_ORNATA_CHROMA_PID:
         case RAZER_ORNATA_CHROMA_V2_PID:
+        case RAZER_ORNATA_V3_PID:
         case RAZER_CORE_PID:
         case RAZER_FIREFLY_PID:
         default:
@@ -283,7 +289,10 @@ RazerController::RazerController(hid_device* dev_handle, hid_device* dev_argb_ha
         case RAZER_O11_DYNAMIC_PID:
         case RAZER_ORNATA_CHROMA_PID:
         case RAZER_ORNATA_CHROMA_V2_PID:
+        case RAZER_ORNATA_V3_PID:
         case RAZER_SEIREN_EMOTE_PID:
+        case RAZER_STRIDER_CHROMA_PID:
+        case RAZER_TARTARUS_PRO_PID:
         case RAZER_TARTARUS_V2_PID:
         case RAZER_TIAMAT_71_V2_PID:
         case RAZER_VIPER_8KHZ_PID:
@@ -569,6 +578,7 @@ bool RazerController::SupportsWave()
         case RAZER_DEATHSTALKER_CHROMA_PID:
         case RAZER_ORNATA_CHROMA_PID:
         case RAZER_ORNATA_CHROMA_V2_PID:
+        case RAZER_ORNATA_V3_PID:
         case RAZER_HUNTSMAN_PID:
         case RAZER_HUNTSMAN_ELITE_PID:
         case RAZER_HUNTSMAN_MINI_PID:
@@ -577,6 +587,7 @@ bool RazerController::SupportsWave()
         case RAZER_HUNTSMAN_V2_TKL_PID:
         case RAZER_HUNTSMAN_V2_PID:
         case RAZER_ORBWEAVER_CHROMA_PID:
+        case RAZER_TARTARUS_PRO_PID:
         case RAZER_TARTARUS_V2_PID:
 
         /*-----------------------------------------------------*\
@@ -588,6 +599,7 @@ bool RazerController::SupportsWave()
         case RAZER_DIAMONDBACK_CHROMA_PID:
         case RAZER_MAMBA_2015_WIRED_PID:
         case RAZER_MAMBA_2015_WIRELESS_PID:
+        case RAZER_MAMBA_ELITE_PID:
         case RAZER_MAMBA_TE_PID:
         case RAZER_NAGA_LEFT_HANDED_PID:
 
@@ -616,6 +628,7 @@ bool RazerController::SupportsWave()
         case RAZER_NOMMO_CHROMA_PID:
         case RAZER_NOMMO_PRO_PID:
         case RAZER_O11_DYNAMIC_PID:
+        case RAZER_STRIDER_CHROMA_PID:
 
             supports_wave = true;
             break;
@@ -1148,6 +1161,108 @@ std::string RazerController::razer_get_serial()
     return ret_string;
 }
 
+void RazerController::razer_get_keyboard_info(unsigned char* layout, unsigned char* variant)
+{
+    struct razer_report report              = razer_create_report(0x00, RAZER_COMMAND_ID_GET_KEYBOARD_INFO, 0x00);
+    struct razer_report response_report     = razer_create_response();
+
+    std::this_thread::sleep_for(1ms);
+    razer_usb_send(&report);
+    std::this_thread::sleep_for(1ms);
+    razer_usb_receive(&response_report);
+
+    *layout = response_report.arguments[0];
+    *variant = response_report.arguments[1];
+}
+
+unsigned char RazerController::GetKeyboardLayoutType()
+{
+    unsigned char layout;
+    unsigned char variant;
+
+    RazerController::razer_get_keyboard_info(&layout, &variant);
+
+    switch(layout)
+    {
+        case RAZER_KEYBOARD_LAYOUT_US:
+        case RAZER_KEYBOARD_LAYOUT_RUSSIAN:                // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_CHT:                    // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_TURKISH:                // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_THAILAND:               // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_ARABIC:                 // Unconfirmed
+            return RAZER_LAYOUT_TYPE_ANSI;
+
+        case RAZER_KEYBOARD_LAYOUT_GREEK:                  // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_GERMAN:                 // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_FRENCH:
+        case RAZER_KEYBOARD_LAYOUT_UK:
+        case RAZER_KEYBOARD_LAYOUT_NORDIC:
+        case RAZER_KEYBOARD_LAYOUT_KOREAN:                 // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_PORTUGESE_BRAZIL:       // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_SPANISH_LATIN_AMERICAN: // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_SWISS:                  // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_SPANISH_EUR:            // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_ITALIAN:                // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_PORTUGESE_PORTUGA:      // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_HEBREW:                 // Unconfirmed
+            return RAZER_LAYOUT_TYPE_ISO;
+
+        case RAZER_KEYBOARD_LAYOUT_JAPAN:                  // Unconfirmed
+            return RAZER_LAYOUT_TYPE_JIS;
+
+        default:
+            return RAZER_LAYOUT_TYPE_ALL;
+    }
+}
+
+std::string RazerController::GetKeyboardLayoutName()
+{
+    unsigned char layout;
+    unsigned char variant;
+
+    RazerController::razer_get_keyboard_info(&layout, &variant);
+
+    switch(layout)
+    {
+        case RAZER_KEYBOARD_LAYOUT_US:                     return "US (ANSI)";
+        case RAZER_KEYBOARD_LAYOUT_GERMAN:                 return "German (ISO)";                  // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_GREEK:                  return "Greek (ISO)";                   // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_FRENCH:                 return "French (ISO)";
+        case RAZER_KEYBOARD_LAYOUT_RUSSIAN:                return "Russian (ANSI)";                // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_UK:                     return "UK (ISO)";
+        case RAZER_KEYBOARD_LAYOUT_NORDIC:                 return "Nordic (ISO)";
+        case RAZER_KEYBOARD_LAYOUT_CHT:                    return "Chinese Traditional (ANSI)";    // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_KOREAN:                 return "Korean (ISO)";                  // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_TURKISH:                return "Turkish (ANSI)";                // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_THAILAND:               return "Thai (ANSI)";                   // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_JAPAN:                  return "Japanese (JIS)";                // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_PORTUGESE_BRAZIL:       return "Portugese (Brazil) (ISO)";      // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_SPANISH_LATIN_AMERICAN: return "Spanish (Latin america) (ISO)"; // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_SWISS:                  return "Swiss (ISO)";                   // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_SPANISH_EUR:            return "Spanish (Europe) (ISO)";        // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_ITALIAN:                return "Italian (ISO)";                 // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_PORTUGESE_PORTUGA:      return "Portugese (Portugal) (ISO)";    // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_HEBREW:                 return "Hebrew (ISO)";                  // Unconfirmed
+        case RAZER_KEYBOARD_LAYOUT_ARABIC:                 return "Arabic (ANSI)";                 // Unconfirmed
+        default:                                           return "Unknown";
+    }
+}
+
+std::string RazerController::GetVariantName()
+{
+    unsigned char layout;
+    unsigned char variant;
+
+    RazerController::razer_get_keyboard_info(&layout, &variant);
+
+    switch(variant)
+    {
+        case RAZER_KEYBOARD_VARIANT_BLACK:   return "Black";
+        case RAZER_KEYBOARD_VARIANT_MERCURY: return "Mercury";
+        default:                             return "Unkown Variant";
+    }
+}
+
 /*---------------------------------------------------------------------------------*\
 | Set functions (send information to device)                                        |
 \*---------------------------------------------------------------------------------*/

Controllers/RazerController/RazerController.h

@@ -51,6 +51,7 @@ enum
     RAZER_COMMAND_ID_GET_FIRMWARE_VERSION       = 0x81,
     RAZER_COMMAND_ID_GET_SERIAL_STRING          = 0x82,
     RAZER_COMMAND_ID_GET_DEVICE_MODE            = 0x84,
+    RAZER_COMMAND_ID_GET_KEYBOARD_INFO          = 0x86,
 };
 
 /*---------------------------------------------------------*\
@@ -99,6 +100,56 @@ enum
     RAZER_MATRIX_TYPE_CUSTOM                    = 4,
 };
 
+/*---------------------------------------------------------*\
+| Razer Keyboard Layout                                     |
+\*---------------------------------------------------------*/
+enum
+{
+    RAZER_KEYBOARD_LAYOUT_NONE                     = 0,
+    RAZER_KEYBOARD_LAYOUT_US                       = 1,
+    RAZER_KEYBOARD_LAYOUT_GREEK                    = 2,
+    RAZER_KEYBOARD_LAYOUT_GERMAN                   = 3,
+    RAZER_KEYBOARD_LAYOUT_FRENCH                   = 4,
+    RAZER_KEYBOARD_LAYOUT_RUSSIAN                  = 5,
+    RAZER_KEYBOARD_LAYOUT_UK                       = 6,
+    RAZER_KEYBOARD_LAYOUT_NORDIC                   = 7,
+    RAZER_KEYBOARD_LAYOUT_CHT                      = 8,
+    RAZER_KEYBOARD_LAYOUT_KOREAN                   = 9,
+    RAZER_KEYBOARD_LAYOUT_TURKISH                  = 10,
+    RAZER_KEYBOARD_LAYOUT_THAILAND                 = 11,
+    RAZER_KEYBOARD_LAYOUT_JAPAN                    = 12,
+    RAZER_KEYBOARD_LAYOUT_PORTUGESE_BRAZIL         = 13,
+    RAZER_KEYBOARD_LAYOUT_SPANISH_LATIN_AMERICAN   = 14,
+    RAZER_KEYBOARD_LAYOUT_SWISS                    = 15,
+    RAZER_KEYBOARD_LAYOUT_SPANISH_EUR              = 16,
+    RAZER_KEYBOARD_LAYOUT_ITALIAN                  = 17,
+    RAZER_KEYBOARD_LAYOUT_PORTUGESE_PORTUGA        = 18,
+    RAZER_KEYBOARD_LAYOUT_HEBREW                   = 19,
+    RAZER_KEYBOARD_LAYOUT_ARABIC                   = 20,
+};
+
+/*---------------------------------------------------------*\
+| Razer Layout Type                                         |
+\*---------------------------------------------------------*/
+enum
+{
+    RAZER_LAYOUT_TYPE_NONE                      = 0x00,
+    RAZER_LAYOUT_TYPE_ANSI                      = 0x01,
+    RAZER_LAYOUT_TYPE_ISO                       = 0x02,
+    RAZER_LAYOUT_TYPE_JIS                       = 0x04,
+
+    RAZER_LAYOUT_TYPE_ALL                        = RAZER_LAYOUT_TYPE_ANSI | RAZER_LAYOUT_TYPE_ISO | RAZER_LAYOUT_TYPE_JIS
+};
+
+/*---------------------------------------------------------*\
+| Razer Keyboard Variant                                    |
+\*---------------------------------------------------------*/
+enum
+{
+    RAZER_KEYBOARD_VARIANT_BLACK                = 0x00,
+    RAZER_KEYBOARD_VARIANT_MERCURY              = 0x82,
+};
+
 /*---------------------------------------------------------*\
 | Razer Report Type (taken from OpenRazer)                  |
 \*---------------------------------------------------------*/
@@ -170,6 +221,10 @@ public:
     std::string             GetSerialString();
     unsigned char           GetMaxBrightness();
 
+    unsigned char           GetKeyboardLayoutType();
+    std::string             GetKeyboardLayoutName();
+    std::string             GetVariantName();
+
     void                    SetBrightness(unsigned char brightness);
 
     void                    SetLEDs(RGBColor* colors);
@@ -259,6 +314,7 @@ private:
 
     std::string             razer_get_firmware();
     std::string             razer_get_serial();
+    void                    razer_get_keyboard_info(unsigned char* layout, unsigned char* variant);
 
     void                    razer_set_brightness(unsigned char brightness);
     void                    razer_set_custom_frame(unsigned char row_index, unsigned char start_col, unsigned char stop_col, unsigned char* rgb_data);

Controllers/RazerController/RazerControllerDetect.cpp

@@ -269,7 +269,7 @@ REGISTER_HID_DETECTOR_IPU("Razer Huntsman V2 TKL",                           Det
 REGISTER_HID_DETECTOR_IPU("Razer Huntsman V2",                               DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_V2_PID,                          0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Ornata Chroma",                             DetectRazerControllers,        RAZER_VID,  RAZER_ORNATA_CHROMA_PID,                        0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Ornata Chroma V2",                          DetectRazerControllers,        RAZER_VID,  RAZER_ORNATA_CHROMA_V2_PID,                     0x02,   0x01,   0x02);
-
+REGISTER_HID_DETECTOR_IPU("Razer Ornata V3",                                 DetectRazerControllers,        RAZER_VID,  RAZER_ORNATA_V3_PID,                            0x02,   0x01,   0x02);
 /*-----------------------------------------------------------------------------------------------------*\
 | Laptops                                                                                               |
 \*-----------------------------------------------------------------------------------------------------*/
@@ -359,6 +359,7 @@ REGISTER_HID_DETECTOR_IPU("Razer Viper Ultimate (Wireless)",                 Det
 \*-----------------------------------------------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IPU("Razer Orbweaver Chroma",                          DetectRazerControllers,        RAZER_VID,  RAZER_ORBWEAVER_CHROMA_PID,                     0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Tartarus Chroma",                           DetectRazerControllers,        RAZER_VID,  RAZER_TARTARUS_CHROMA_PID,                      0x02,   0x01,   0x02);
+REGISTER_HID_DETECTOR_IPU("Razer Tartarus Pro",                              DetectRazerControllers,        RAZER_VID,  RAZER_TARTARUS_PRO_PID,                         0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Tartarus V2",                               DetectRazerControllers,        RAZER_VID,  RAZER_TARTARUS_V2_PID,                          0x02,   0x01,   0x02);
 
 /*-----------------------------------------------------------------------------------------------------*\
@@ -381,6 +382,7 @@ REGISTER_HID_DETECTOR_IPU("Razer Firefly V2",                                Det
 REGISTER_HID_DETECTOR_IPU("Razer Firefly Hyperflux",                         DetectRazerControllers,        RAZER_VID,  RAZER_FIREFLY_HYPERFLUX_PID,                    0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Goliathus",                                 DetectRazerControllers,        RAZER_VID,  RAZER_GOLIATHUS_CHROMA_PID,                     0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Goliathus Extended",                        DetectRazerControllers,        RAZER_VID,  RAZER_GOLIATHUS_CHROMA_EXTENDED_PID,            0x00,   0x01,   0x02);
+REGISTER_HID_DETECTOR_IPU("Razer Strider Chroma",                            DetectRazerControllers,        RAZER_VID,  RAZER_STRIDER_CHROMA_PID,                       0x00,   0x01,   0x02);
 
 /*-----------------------------------------------------------------------------------------------------*\
 | Accessories                                                                                           |

Controllers/RazerController/RazerDevices.h

@@ -9,6 +9,7 @@
 #include <string>
 #include "RGBController.h"
 #include "RGBControllerKeyNames.h"
+#include "RazerController.h"
 
 /*-----------------------------------------------------*\
 | Razer vendor ID                                       |
@@ -96,7 +97,9 @@
 #define RAZER_ORBWEAVER_CHROMA_PID                      0x0207
 #define RAZER_ORNATA_CHROMA_PID                         0x021E
 #define RAZER_ORNATA_CHROMA_V2_PID                      0x025D
+#define RAZER_ORNATA_V3_PID                             0x028F
 #define RAZER_TARTARUS_CHROMA_PID                       0x0208
+#define RAZER_TARTARUS_PRO_PID                          0x0244
 #define RAZER_TARTARUS_V2_PID                           0x022B
 
 /*-----------------------------------------------------*\
@@ -208,6 +211,7 @@
 #define RAZER_NOMMO_PRO_PID                             0x0518
 #define RAZER_O11_DYNAMIC_PID                           0x0F13
 #define RAZER_SEIREN_EMOTE_PID                          0x0F1B
+#define RAZER_STRIDER_CHROMA_PID                        0x0C05
 
 typedef struct
 {
@@ -223,6 +227,7 @@ typedef struct
     unsigned int row;
     unsigned int col;
     const char* name;
+    unsigned char layout = RAZER_LAYOUT_TYPE_ALL;
 } razer_key;
 
 typedef struct
@@ -242,4 +247,4 @@ typedef struct
 | These constant values are defined in RazerDevices.cpp |
 \*-----------------------------------------------------*/
 extern const unsigned int RAZER_NUM_DEVICES;
-extern const razer_device** device_list;
+extern const razer_device** device_list;

Controllers/RedSquareKeyroxController/RGBController_RedSquareKeyrox.cpp

@@ -0,0 +1,373 @@
+/*-------------------------------------------------------*\
+|  RGBController_RedSquareKeyrox.cpp                      |
+|                                                         |
+|  Driver for Red Square Keyrox USB Controller            |
+|  Based on Keychron Controller by Guimard Morgan (morg)  |
+|                                                         |
+|  cafeed28          3 Nov 2022                           |
+\*-------------------------------------------------------*/
+#include "RGBControllerKeyNames.h"
+#include "RGBController_RedSquareKeyrox.h"
+
+#define NA 0xFFFFFFFF
+
+/*-----------------------------------*\
+|  TODO: Other Keyrox boards support  |
+|  (but I have only TKL)              |
+\*-----------------------------------*/
+typedef struct
+{
+    const unsigned int                      width;                  /* matrix width         */
+    const unsigned int                      height;                 /* matrix height        */
+    std::vector<std::vector<unsigned int>>  matrix_map;             /* matrix map           */
+    std::vector<std::string>                led_names;              /* led names            */
+    std::vector<unsigned int>               led_sequence_positions; /* position in buffers  */
+} keyrox;
+
+/*------------*\
+|  Keyrox TKL  |
+\*------------*/
+static keyrox keyrox_tkl =
+{
+    18,
+    6,
+    {
+        {   0,  NA,   1,   2,   3,   4,   5,   6,   7,   8,  NA,   9,  10,  11,  12,  13,  14,  15 },
+        {  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  NA,  30,  31,  32 },
+        {  33,  NA,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49 },
+        {  50,  NA,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  NA,  62,  NA,  NA,  NA },
+        {  63,  NA,  64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  NA,  74,  NA,  NA,  75,  NA },
+        {  76,  77,  78,  NA,  NA,  NA,  79,  NA,  NA,  NA,  80,  81,  NA,  82,  83,  84,  85,  86 }
+    },
+    {
+        // 0
+        KEY_EN_ESCAPE,
+        KEY_EN_F1,
+        KEY_EN_F2,
+        KEY_EN_F3,
+        KEY_EN_F4,
+        KEY_EN_F5,
+        KEY_EN_F6,
+        KEY_EN_F7,
+        KEY_EN_F8,
+        KEY_EN_F9,
+        // 10
+        KEY_EN_F10,
+        KEY_EN_F11,
+        KEY_EN_F12,
+        KEY_EN_PRINT_SCREEN,
+        KEY_EN_SCROLL_LOCK,
+        KEY_EN_PAUSE_BREAK,
+        KEY_EN_BACK_TICK,
+        KEY_EN_1,
+        KEY_EN_2,
+        KEY_EN_3,
+        // 20
+        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_BACKSPACE,
+        // 30
+        KEY_EN_INSERT,
+        KEY_EN_HOME,
+        KEY_EN_PAGE_UP,
+        KEY_EN_TAB,
+        KEY_EN_Q,
+        KEY_EN_W,
+        KEY_EN_E,
+        KEY_EN_R,
+        KEY_EN_T,
+        KEY_EN_Y,
+        // 40
+        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,
+        KEY_EN_DELETE,
+        KEY_EN_END,
+        KEY_EN_PAGE_DOWN,
+        // 50
+        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,
+        // 60
+        KEY_EN_SEMICOLON,
+        KEY_EN_QUOTE,
+        KEY_EN_ANSI_ENTER,
+        KEY_EN_LEFT_SHIFT,
+        KEY_EN_Z,
+        KEY_EN_X,
+        KEY_EN_C,
+        KEY_EN_V,
+        KEY_EN_B,
+        KEY_EN_N,
+        // 70
+        KEY_EN_M,
+        KEY_EN_COMMA,
+        KEY_EN_PERIOD,
+        KEY_EN_FORWARD_SLASH,
+        KEY_EN_RIGHT_SHIFT,
+        KEY_EN_UP_ARROW,
+        KEY_EN_LEFT_CONTROL,
+        KEY_EN_LEFT_WINDOWS,
+        KEY_EN_LEFT_ALT,
+        KEY_EN_SPACE,
+        // 80
+        KEY_EN_RIGHT_ALT,
+        KEY_EN_RIGHT_FUNCTION,
+        KEY_EN_MENU,
+        KEY_EN_RIGHT_CONTROL,
+        KEY_EN_LEFT_ARROW,
+        KEY_EN_DOWN_ARROW,
+        KEY_EN_RIGHT_ARROW,
+    },
+    {
+         0,        1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,       13,  14,  15,
+        16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,       30,  31,  32,
+        37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  70,       51,  52,  53,
+        58,       59,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,       50,
+        75,       77,  78,  79,  80,  81,  82,  83,  84,  85,  86,       88,            89,
+        94,  95,  96,                 98,                100, 101, 102, 103,      104, 105, 106
+    }
+};
+
+typedef struct
+{
+    std::string name;
+    int value;
+    int flags;
+} keyrox_effect;
+
+RGBController_RedSquareKeyrox::RGBController_RedSquareKeyrox(RedSquareKeyroxController* controller_ptr)
+{
+    controller      = controller_ptr;
+
+    name            = "Red Square Keyrox";
+    vendor          = "Red Square";
+    type            = DEVICE_TYPE_KEYBOARD;
+    description     = name;
+    location        = controller->GetDeviceLocation();
+    serial          = controller->GetSerialString();
+
+    keyrox_effect keyrox_effects[13] =
+    {
+        {
+            "Custom",
+            CUSTOM_MODE_VALUE,
+            MODE_FLAG_HAS_PER_LED_COLOR
+        },
+        {
+            "Wave",
+            WAVE_MODE_VALUE,
+            MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD
+        },
+        {
+            "Const",
+            CONST_MODE_VALUE,
+            MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS
+        },
+        {
+            "Breathe",
+            BREATHE_MODE_VALUE,
+            MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED
+        },
+        {
+            "Heartrate",
+            HEARTRATE_MODE_VALUE,
+            MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED
+        },
+        {
+            "Point",
+            POINT_MODE_VALUE,
+            MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED
+        },
+        {
+            "Winnower",
+            WINNOWER_MODE_VALUE,
+            MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD
+        },
+        {
+            "Stars",
+            STARS_MODE_VALUE,
+            MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED
+        },
+        {
+            "Spectrum",
+            SPECTRUM_MODE_VALUE,
+            MODE_FLAG_HAS_SPEED
+        },
+        {
+            "Plumflower",
+            PLUMFLOWER_MODE_VALUE,
+            MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED
+        },
+        {
+            "Shoot",
+            SHOOT_MODE_VALUE,
+            MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED
+        },
+        {
+            "Ambilight Rotate",
+            AMBILIGHT_ROTATE_MODE_VALUE,
+            MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD
+        },
+        {
+            "Ripple",
+            RIPPLE_MODE_VALUE,
+            MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED
+        },
+    };
+
+    for(const keyrox_effect& effect : keyrox_effects)
+    {
+        mode m;
+        m.name = effect.name;
+        m.value = effect.value;
+        m.flags = effect.flags | MODE_FLAG_HAS_BRIGHTNESS;
+
+        if(m.flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
+        {
+            m.color_mode = MODE_COLORS_MODE_SPECIFIC;
+            m.colors_min = 1;
+            m.colors_max = 1;
+
+            m.colors.resize(1);
+            m.colors.at(0) = ToRGBColor(255, 255, 255);
+        }
+        else if(m.flags & MODE_FLAG_HAS_PER_LED_COLOR)
+        {
+            m.color_mode = MODE_COLORS_PER_LED;
+        }
+        else
+        {
+            m.color_mode = MODE_COLORS_NONE;
+            m.colors_min = 0;
+            m.colors_max = 0;
+            m.colors.resize(0);
+        }
+
+        if(m.flags & MODE_FLAG_HAS_SPEED)
+        {
+            m.speed_min = KEYROX_SPEED_MIN;
+            m.speed_max = KEYROX_SPEED_MAX;
+            m.speed     = m.speed_max;
+        }
+
+        if(m.flags & MODE_FLAG_HAS_BRIGHTNESS)
+        {
+            m.brightness_min = KEYROX_BRIGHTNESS_MIN;
+            /*------------------------------------------*\
+            |  In Custom mode, Keyrox stores brightness  |
+            |  in A of RGBA and range is 0x00-0xFF       |
+            \*------------------------------------------*/
+            m.brightness_max = (m.flags & MODE_FLAG_HAS_PER_LED_COLOR) ? 0xFF : KEYROX_BRIGHTNESS_MAX;
+            m.brightness     = m.brightness_max;
+        }
+
+        modes.push_back(m);
+    }
+
+    SetupZones();
+}
+
+RGBController_RedSquareKeyrox::~RGBController_RedSquareKeyrox()
+{
+    delete controller;
+}
+
+void RGBController_RedSquareKeyrox::SetupZones()
+{
+    keyrox* keyboard;
+    switch(controller->GetVariant())
+    {
+    case KEYROX_VARIANT_TKL:
+        keyboard = &keyrox_tkl;
+        break;
+    }
+
+    controller->SetLedSequencePositions(keyboard->led_sequence_positions);
+
+    /*-----------------*\
+    |  Create the zone  |
+    \*-----------------*/
+    unsigned int zone_size = 0;
+
+    zone z;
+    z.name               = ZONE_EN_KEYBOARD;
+    z.type               = ZONE_TYPE_MATRIX;
+
+    z.matrix_map         = new matrix_map_type;
+    z.matrix_map->height = keyboard->height;
+    z.matrix_map->width  = keyboard->width;
+
+    z.matrix_map->map    = new unsigned int[keyboard->height * keyboard->width];
+
+    for(unsigned int h = 0; h < keyboard->height; h++)
+    {
+        for(unsigned int w = 0; w < keyboard->width; w++)
+        {
+            unsigned int key = keyboard->matrix_map[h][w];
+            z.matrix_map->map[h * keyboard->width + w] = key;
+
+            if(key != NA)
+            {
+                led l;
+                l.name = keyboard->led_names[key];
+                leds.push_back(l);
+                zone_size++;
+            }
+        }
+    }
+
+    z.leds_min   = zone_size;
+    z.leds_max   = zone_size;
+    z.leds_count = zone_size;
+
+    zones.push_back(z);
+
+    SetupColors();
+}
+
+void RGBController_RedSquareKeyrox::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_RedSquareKeyrox::DeviceUpdateLEDs()
+{
+    controller->SetLEDsData(modes, active_mode, colors);
+}
+
+void RGBController_RedSquareKeyrox::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_RedSquareKeyrox::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_RedSquareKeyrox::DeviceUpdateMode()
+{
+    controller->SetMode(modes, active_mode);
+    controller->SetModeData(modes, active_mode);
+}