Replace most instances of sprintf() with snprintf()

+ Added PID entry for the Mouse Dock Pro
+ Registered detectors
+ Added metadata to RazerDevices.cpp
+ Added capabilities to RazerController.cpp

.gitlab-ci.yml

@@ -43,6 +43,7 @@ before_script:
     name: "${CI_PROJECT_NAME}_Supported_Devices_${CI_COMMIT_SHORT_SHA}"
     paths:
     - ./*.md
+    - Supported Devices.csv
     exclude:
     - README.md
     - CONTRIBUTING.md
@@ -346,7 +347,6 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
   - openrgb --version
-  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 32 .deb (Debian Buster)"
@@ -363,7 +363,6 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
-  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Buster)"
@@ -380,7 +379,6 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
   - openrgb --version
-  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 32 .deb (Debian Bullseye)"
@@ -397,7 +395,6 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
-  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Bullseye)"
@@ -414,7 +411,6 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
   - openrgb --version
-  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 32 .deb (Debian Bookworm)"
@@ -431,7 +427,6 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
-  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Bookworm)"
@@ -448,7 +443,6 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
-  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Buster)"
@@ -465,7 +459,6 @@ before_script:
   - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
-  - openrgb -l
   - apt remove -y openrgb
   dependencies:
   - "Linux 64 .deb (Debian Bookworm)"
@@ -481,7 +474,6 @@ before_script:
   script:
   - yum -y localinstall ./openrgb*64.rpm
   - openrgb --version
-  - openrgb -l
   - yum -y remove openrgb
   dependencies:
   - "Linux 64 f35 rpm"
@@ -497,7 +489,6 @@ before_script:
   script:
   - yum -y localinstall ./openrgb*64.rpm
   - openrgb --version
-  - openrgb -l
   - yum -y remove openrgb
   dependencies:
   - "Linux 64 f36 rpm"

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

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

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

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

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

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

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

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

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -65,6 +65,10 @@ void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
     }
 } /* DetectAsusAuraGPUControllers() */
 
+/*-----------------------------------------*\
+|  NVidia GPUs                              |
+\*-----------------------------------------*/
+
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 O2G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI 4G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
@@ -113,12 +117,17 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAs
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060 Ti 8G Gaming OC"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A);
+
+/*-----------------------------------------*\
+|  AMD GPUs                                 |
+\*-----------------------------------------*/
+
 REGISTER_I2C_PCI_DETECTOR("ASUS AREZ Strix RX Vega 56 O8G"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS Vega 64 Strix"                        , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 5600XT Strix O6G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 6800 TUF Gaming OC"                , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_RX6800_TUF_GAMING_OC,                  0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX470 O4G GAMING"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix 08G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING,             0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX470 O4G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX480 Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX560 Gaming"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O4G Gaming OC"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);

Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp

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

Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h

@@ -25,6 +25,8 @@
 #define AURA_ROG_CHAKRAM_WIRELESS_PID               0x18E5
 #define AURA_ROG_CHAKRAM_WIRED_1_PID                0x18E3
 #define AURA_ROG_CHAKRAM_CORE_PID                   0x1958
+#define AURA_ROG_CHAKRAM_X_USB_PID                  0x1A18
+#define AURA_ROG_CHAKRAM_X_2_4_PID                  0x1A1A
 #define AURA_ROG_PUGIO_PID                          0x1846
 #define AURA_ROG_PUGIO_II_WIRED_PID                 0x1906
 #define AURA_ROG_PUGIO_II_WIRELESS_PID              0x1908
@@ -266,6 +268,32 @@ static std::map<int,mouse_type> aura_mouse_devices =
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
     },
+    {
+        AURA_ROG_CHAKRAM_X_USB_PID, // ROG Chakram X USB
+        {
+            0,
+            0,
+            0,
+            4,
+            false,
+            1,
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
+    {
+        AURA_ROG_CHAKRAM_X_2_4_PID, // ROG Chakram X 2.4GHz Dongle
+        {
+            255,
+            1,
+            0,
+            64,
+            true,
+            2,
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
     {
         AURA_ROG_PUGIO_PID, // ROG Pugio
         {
@@ -313,7 +341,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             0,
             4,
             false,
-            3,
+            4,
             { AURA_MOUSE_ZONE_LOGO },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM }
         }
@@ -469,7 +497,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
             0,
             4,
             false,
-            2,
+            3,
             { AURA_MOUSE_ZONE_LOGO },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp

@@ -57,6 +57,7 @@ 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;
@@ -92,9 +93,7 @@ std::string AuraTUFKeyboardController::GetVersion()
         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];
@@ -139,7 +138,7 @@ int AuraTUFKeyboardController::GetLayout()
     {
         char layout[4];
 
-        sprintf(layout, "%X", version);
+        snprintf(layout, 4, "%X", version);
 
         int layoutnum = std::stoi(std::string(layout, 1));
 
@@ -166,12 +165,12 @@ int AuraTUFKeyboardController::GetNumpadLocation()
 {
     unsigned char usb_buf[65];
     memset(usb_buf, 0x00, sizeof(usb_buf));
+
     usb_buf[0x00]   = 0x00;
     usb_buf[0x01]   = 0x40;
     usb_buf[0x02]   = 0x60;
 
     ClearResponses();
-
     hid_write(dev, usb_buf, 65);
 
     unsigned char usb_buf_out[65];
@@ -183,7 +182,6 @@ int AuraTUFKeyboardController::GetNumpadLocation()
 void AuraTUFKeyboardController::SaveMode()
 {
     unsigned char usb_save_buf[65];
-
     memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
 
     usb_save_buf[0x00]   = 0x00;
@@ -191,9 +189,7 @@ void AuraTUFKeyboardController::SaveMode()
     usb_save_buf[0x02]   = 0x55;
 
     ClearResponses();
-
     hid_write(dev, usb_save_buf, 65);
-
     AwaitResponse(60);
 }
 
@@ -203,7 +199,6 @@ void AuraTUFKeyboardController::SaveMode()
 void AuraTUFKeyboardController::AllowRemoteControl(unsigned char type)
 {
     unsigned char usb_buf[65];
-
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
     usb_buf[0x00]   = 0x00;
@@ -211,9 +206,7 @@ void AuraTUFKeyboardController::AllowRemoteControl(unsigned char type)
     usb_buf[0x02]   = type;
 
     ClearResponses();
-
     hid_write(dev, usb_buf, 65);
-
     AwaitResponse(20);
 }
 
@@ -229,7 +222,6 @@ void AuraTUFKeyboardController::UpdateSingleLed
     | Set up message packet for single LED                  |
     \*-----------------------------------------------------*/
     unsigned char usb_buf[65];
-
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
     usb_buf[0] = 0x00;
@@ -247,9 +239,7 @@ void AuraTUFKeyboardController::UpdateSingleLed
     usb_buf[8] = blue;
 
     ClearResponses();
-
     hid_write(dev, usb_buf, 65);
-
     AwaitResponse(20);
 }
 
@@ -263,7 +253,6 @@ void AuraTUFKeyboardController::UpdateLeds
     for(int i = 0; i < packets; i++)
     {
         unsigned char usb_buf[65];
-
         memset(usb_buf, 0x00, sizeof(usb_buf));
 
         int remaining = colors.size() - i * 15;
@@ -283,11 +272,8 @@ void AuraTUFKeyboardController::UpdateLeds
             usb_buf[j * 4 + 7] = RGBGetGValue(colors[i * 15 + j].color);
             usb_buf[j * 4 + 8] = RGBGetBValue(colors[i * 15 + j].color);
         }
-
         ClearResponses();
-
         hid_write(dev, usb_buf, 65);
-
         AwaitResponse(20);
     }
 }
@@ -303,7 +289,6 @@ void AuraTUFKeyboardController::UpdateDevice
     )
 {
     unsigned char usb_buf[65];
-
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
     usb_buf[0x00]   = 0x00;
@@ -401,12 +386,7 @@ void AuraTUFKeyboardController::UpdateDevice
     }
 
     ClearResponses();
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
-
     AwaitResponse(20);
 }
 
@@ -419,7 +399,6 @@ void AuraTUFKeyboardController::UpdateQuicksandColors
     )
 {
     unsigned char usb_buf[65];
-
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
     usb_buf[0x00]   = 0x00;
@@ -437,9 +416,7 @@ void AuraTUFKeyboardController::UpdateQuicksandColors
     }
 
     ClearResponses();
-
     hid_write(dev, usb_buf, 65);
-
     AwaitResponse(20);
 }
 
@@ -449,7 +426,6 @@ void AuraTUFKeyboardController::UpdateQuicksandColors
 void AuraTUFKeyboardController::UpdateMode(unsigned char mode)
 {
     unsigned char usb_buf[65];
-
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
     usb_buf[0x00]   = 0x00;
@@ -460,9 +436,7 @@ void AuraTUFKeyboardController::UpdateMode(unsigned char mode)
     usb_buf[0x05]   = mode;
 
     ClearResponses();
-
     hid_write(dev, usb_buf, 65);
-
     AwaitResponse(20);
 }
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h

@@ -33,6 +33,8 @@ enum
 
 enum
 {
+    AURA_ROG_FALCHION_WIRED_PID     = 0x193C,
+    AURA_ROG_FALCHION_WIRELESS_PID  = 0x193E,
     AURA_TUF_K7_GAMING_PID          = 0x18AA,
     AURA_TUF_K3_GAMING_PID          = 0x194B,
     AURA_ROG_CLAYMORE_PID           = 0x184D,

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardLayouts.h

@@ -79,6 +79,22 @@ static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_UK[6][24] = {
     {   5,   8,  14,  NA,  NA,  NA,  34,  NA,  NA,  NA,  55,  61,  66,  NA,  74,  NA,  78,  83,  87,  NA,  92,  NA, 101,  NA }
 };
 
+static unsigned int ASUS_FALCHION_LAYOUT_KEYS_US[5][16] = {
+    {   0,   5,   7,  12,  16,  20,  24,  29,  33,  37,  41,  46,  51,  56,  NA,  63 },
+    {   1,  NA,   8,  13,  17,  21,  25,  30,  34,  38,  42,  47,  52,  57,  59,  64 },
+    {   2,  NA,   9,  14,  18,  22,  26,  31,  35,  39,  43,  48,  53,  NA,  60,  65 }, 
+    {   3,  NA,  10,  15,  19,  23,  27,  32,  36,  40,  44,  49,  54,  NA,  61,  66 },
+    {   4,   6,  11,  NA,  NA,  NA,  28,  NA,  NA,  NA,  45,  50,  55,  58,  62,  67 }
+};
+
+static unsigned int ASUS_FALCHION_LAYOUT_KEYS_UK[5][16] = {
+    {   0,   5,   8,  13,  17,  21,  25,  30,  34,  38,  42,  47,  52,  57,  NA,  64 },
+    {   1,  NA,   9,  14,  18,  22,  26,  31,  35,  39,  43,  48,  53,  58,  61,  65 },
+    {   2,  NA,  10,  15,  19,  23,  27,  32,  36,  40,  44,  49,  54,  59,  NA,  66 }, 
+    {   3,   6,  11,  16,  20,  24,  28,  33,  37,  41,  45,  50,  55,  NA,  62,  67 },
+    {   4,   7,  12,  NA,  NA,  NA,  29,  NA,  NA,  NA,  46,  51,  56,  60,  63,  68 }
+};
+
 static unsigned int ASUS_CLAYMORE_NO_NUMPAD_LAYOUT_KEYS_US[7][19] = {
     {   0,  NA,   8,  14,  19,  24,  NA,  34,  39,  45,  50,  56,  62,  67,  71,  NA,  75,  79,  84 },
     {   1,   6,   9,  15,  20,  25,  29,  35,  40,  46,  51,  57,  63,  68,  NA,  NA,  76,  80,  85 },
@@ -416,6 +432,200 @@ static std::map<int,layout_info> AsusTUFK7Layouts =
     },
 };
 
+static std::map<int,layout_info> AsusFalchionLayouts =
+{
+    {
+        ASUS_TUF_K7_LAYOUT_UK,
+        {
+            *ASUS_FALCHION_LAYOUT_KEYS_UK,
+            69,
+            5,
+            16,
+            {
+                { KEY_EN_ESCAPE,            0x00    },
+                { KEY_EN_TAB,               0x01    },
+                { KEY_EN_CAPS_LOCK,         0x02    },
+                { KEY_EN_LEFT_SHIFT,        0x03    },
+                { KEY_EN_LEFT_CONTROL,      0x04    },
+
+                { KEY_EN_1,                 0x08    },
+                { KEY_EN_ISO_BACK_SLASH,    0x0B    },
+                { KEY_EN_LEFT_WINDOWS,      0x0C    },
+
+                { KEY_EN_2,                 0x10    },
+                { KEY_EN_Q,                 0x09    },
+                { KEY_EN_A,                 0x0A    },
+                { KEY_EN_Z,                 0x13    },
+                { KEY_EN_LEFT_ALT,          0x14    },
+
+                { KEY_EN_3,                 0x18    },
+                { KEY_EN_W,                 0x11    },
+                { KEY_EN_S,                 0x12    },
+                { KEY_EN_X,                 0x1B    },
+
+                { KEY_EN_4,                 0x20    },
+                { KEY_EN_E,                 0x19    },
+                { KEY_EN_D,                 0x1A    },
+                { KEY_EN_C,                 0x23    },
+
+                { KEY_EN_5,                 0x28    },
+                { KEY_EN_R,                 0x21    },
+                { KEY_EN_F,                 0x22    },
+                { KEY_EN_V,                 0x2B    },
+
+                { KEY_EN_6,                 0x30    },
+                { KEY_EN_T,                 0x29    },
+                { KEY_EN_G,                 0x2A    },
+                { KEY_EN_B,                 0x33    },
+                { KEY_EN_SPACE,             0x34    },
+
+                { KEY_EN_7,                 0x38    },
+                { KEY_EN_Y,                 0x31    },
+                { KEY_EN_H,                 0x32    },
+                { KEY_EN_N,                 0x3B    },
+
+                { KEY_EN_8,                 0x40    },
+                { KEY_EN_U,                 0x39    },
+                { KEY_EN_J,                 0x3A    },
+                { KEY_EN_M,                 0x43    },
+
+                { KEY_EN_9,                 0x48    },
+                { KEY_EN_I,                 0x41    },
+                { KEY_EN_K,                 0x42    },
+                { KEY_EN_COMMA,             0x4B    },
+
+                { KEY_EN_0,                 0x50    },
+                { KEY_EN_O,                 0x49    },
+                { KEY_EN_L,                 0x4A    },
+                { KEY_EN_PERIOD,            0x53    },
+                { KEY_EN_RIGHT_ALT,         0x4C    },
+
+                { KEY_EN_MINUS,             0x58    },
+                { KEY_EN_P,                 0x51    },
+                { KEY_EN_SEMICOLON,         0x52    },
+                { KEY_EN_FORWARD_SLASH,     0x5B    },
+                { KEY_EN_RIGHT_FUNCTION,    0x54    },
+
+                { KEY_EN_EQUALS,            0x60    },
+                { KEY_EN_LEFT_BRACKET,      0x59    },
+                { KEY_EN_QUOTE,             0x5A    },
+                { KEY_EN_RIGHT_SHIFT,       0x63    },
+                { KEY_EN_RIGHT_CONTROL,     0x5C    },
+
+                { KEY_EN_BACKSPACE,         0x68    },
+                { KEY_EN_RIGHT_BRACKET,     0x61    },
+                { KEY_EN_POUND,             0x62    },
+                { KEY_EN_LEFT_ARROW,        0x64    },
+
+                { KEY_EN_ISO_ENTER,         0x6A    },
+                { KEY_EN_UP_ARROW,          0x6B    },
+                { KEY_EN_DOWN_ARROW,        0x6C    },
+
+                { KEY_EN_INSERT,            0x70    },
+                { KEY_EN_DELETE,            0x71    },
+                { KEY_EN_PAGE_UP,           0x72    },
+                { KEY_EN_PAGE_DOWN,         0x73    },
+                { KEY_EN_RIGHT_ARROW,       0x74    },
+            }
+        }
+    },
+    {
+        ASUS_TUF_K7_LAYOUT_US,
+        {
+            *ASUS_FALCHION_LAYOUT_KEYS_US,
+            68,
+            5,
+            16,
+            {
+                { KEY_EN_ESCAPE,            0x00    },
+                { KEY_EN_TAB,               0x01    },
+                { KEY_EN_CAPS_LOCK,         0x02    },
+                { KEY_EN_LEFT_SHIFT,        0x03    },
+                { KEY_EN_LEFT_CONTROL,      0x04    },
+
+                { KEY_EN_1,                 0x08    },
+                { KEY_EN_LEFT_WINDOWS,      0x0C    },
+
+                { KEY_EN_2,                 0x10    },
+                { KEY_EN_Q,                 0x09    },
+                { KEY_EN_A,                 0x0A    },
+                { KEY_EN_Z,                 0x13    },
+                { KEY_EN_LEFT_ALT,          0x14    },
+
+                { KEY_EN_3,                 0x18    },
+                { KEY_EN_W,                 0x11    },
+                { KEY_EN_S,                 0x12    },
+                { KEY_EN_X,                 0x1B    },
+
+                { KEY_EN_4,                 0x20    },
+                { KEY_EN_E,                 0x19    },
+                { KEY_EN_D,                 0x1A    },
+                { KEY_EN_C,                 0x23    },
+
+                { KEY_EN_5,                 0x28    },
+                { KEY_EN_R,                 0x21    },
+                { KEY_EN_F,                 0x22    },
+                { KEY_EN_V,                 0x2B    },
+
+                { KEY_EN_6,                 0x30    },
+                { KEY_EN_T,                 0x29    },
+                { KEY_EN_G,                 0x2A    },
+                { KEY_EN_B,                 0x33    },
+                { KEY_EN_SPACE,             0x34    },
+
+                { KEY_EN_7,                 0x38    },
+                { KEY_EN_Y,                 0x31    },
+                { KEY_EN_H,                 0x32    },
+                { KEY_EN_N,                 0x3B    },
+
+                { KEY_EN_8,                 0x40    },
+                { KEY_EN_U,                 0x39    },
+                { KEY_EN_J,                 0x3A    },
+                { KEY_EN_M,                 0x43    },
+
+                { KEY_EN_9,                 0x48    },
+                { KEY_EN_I,                 0x41    },
+                { KEY_EN_K,                 0x42    },
+                { KEY_EN_COMMA,             0x4B    },
+
+                { KEY_EN_0,                 0x50    },
+                { KEY_EN_O,                 0x49    },
+                { KEY_EN_L,                 0x4A    },
+                { KEY_EN_PERIOD,            0x53    },
+                { KEY_EN_RIGHT_ALT,         0x4C    },
+
+                { KEY_EN_MINUS,             0x58    },
+                { KEY_EN_P,                 0x51    },
+                { KEY_EN_SEMICOLON,         0x52    },
+                { KEY_EN_FORWARD_SLASH,     0x5B    },
+                { KEY_EN_RIGHT_FUNCTION,    0x54    },
+
+                { KEY_EN_EQUALS,            0x60    },
+                { KEY_EN_LEFT_BRACKET,      0x59    },
+                { KEY_EN_QUOTE,             0x5A    },
+                { KEY_EN_RIGHT_SHIFT,       0x63    },
+                { KEY_EN_RIGHT_CONTROL,     0x5C    },
+
+                { KEY_EN_BACKSPACE,         0x68    },
+                { KEY_EN_RIGHT_BRACKET,     0x61    },
+                { KEY_EN_LEFT_ARROW,        0x64    },
+
+                { KEY_EN_ANSI_BACK_SLASH,   0x69    },
+                { KEY_EN_ANSI_ENTER,        0x6A    },
+                { KEY_EN_UP_ARROW,          0x6B    },
+                { KEY_EN_DOWN_ARROW,        0x6C    },
+
+                { KEY_EN_INSERT,            0x70    },
+                { KEY_EN_DELETE,            0x71    },
+                { KEY_EN_PAGE_UP,           0x72    },
+                { KEY_EN_PAGE_DOWN,         0x73    },
+                { KEY_EN_RIGHT_ARROW,       0x74    },
+            }
+        }
+    },
+};
+
+
 static std::map<int,layout_info> AsusClaymoreNoNumpadLayouts =
 {
     {

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -44,6 +44,7 @@
 #define AURA_ROG_FALCHION_WIRELESS_PID          0x193E
 #define AURA_ROG_STRIX_FLARE_PID                0x1875
 #define AURA_ROG_STRIX_FLARE_PNK_LTD_PID        0x18CF
+#define AURA_ROG_STRIX_FLARE_COD_BO4_PID        0x18AF
 #define AURA_ROG_STRIX_SCOPE_PID                0x18F8
 #define AURA_ROG_STRIX_SCOPE_RX_PID             0x1951
 #define AURA_ROG_STRIX_SCOPE_TKL_PID            0x190C
@@ -94,6 +95,7 @@ AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
     {
         case AURA_ROG_STRIX_FLARE_PID:
         case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
+        case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
             return FLARE_LAYOUT;
 
         case AURA_ROG_STRIX_SCOPE_PID:
@@ -106,10 +108,6 @@ AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
         case AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID:
             return SCOPE_TKL_LAYOUT;
 
-        case AURA_ROG_FALCHION_WIRED_PID:
-        case AURA_ROG_FALCHION_WIRELESS_PID:
-            return FALCHION_LAYOUT;
-
         default:
             return FLARE_LAYOUT;
     }
@@ -296,15 +294,16 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAs
 /*-----------------------------------------------------------------*\
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",                   DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,                  1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,               1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                     1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,             1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare CoD Black Ops 4 Edition",DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_COD_BO4_PID,             1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                     1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",                     DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,                  1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL",                    DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID,                 1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL PNK LTD",            DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID,         1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Claymore",                           DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_CLAYMORE_PID,                        1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",                   DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,                  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",                DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,               1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                       1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                       1,  0xFF00);
 
@@ -325,6 +324,8 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth",     DetectAs
 REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,                0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,                 0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram Core",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID,                    0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X USB",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_X_USB_PID,                   0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X 2.4GHz",                   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_X_2_4_PID,                   0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio",                              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_PID,                           2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",                   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,                  0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,               0,  0xFF01);

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp

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

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.h

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

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -28,6 +28,8 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
 
     pid = controller->device_pid;
 
+    const unsigned char AURA_KEYBOARD_SPEED_MIN = (pid == AURA_ROG_FALCHION_WIRED_PID || pid == AURA_ROG_FALCHION_WIRELESS_PID) ? 255 : 15;
+
     if(pid != AURA_ROG_CLAYMORE_PID)
     {
         name        = "ASUS Aura Keyboard";
@@ -347,6 +349,13 @@ void RGBController_AuraTUFKeyboard::SetupZones()
 
     switch(pid)
     {
+        case AURA_TUF_K7_GAMING_PID:
+            keyboard_ptr = &AsusTUFK7Layouts;
+            break;
+        case AURA_ROG_FALCHION_WIRED_PID:
+        case AURA_ROG_FALCHION_WIRELESS_PID:
+            keyboard_ptr = &AsusFalchionLayouts;
+            break;
         case AURA_ROG_CLAYMORE_PID:
             unsigned char numpad;
             numpad = controller->GetNumpadLocation();
@@ -365,9 +374,6 @@ void RGBController_AuraTUFKeyboard::SetupZones()
                     keyboard_ptr = &AsusClaymoreNoNumpadLayouts;
             }
             break;
-        case AURA_TUF_K7_GAMING_PID:
-            keyboard_ptr = &AsusTUFK7Layouts;
-            break;
         default:
             keyboard_ptr = &AsusTUFK7Layouts;
     }
@@ -423,13 +429,12 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
 {
     std::vector<led_color> led_color_list = {};
 
-    for(unsigned int i = 0; i < colors.size(); i++)
+    for(int i = 0; i < colors.size(); i++)
     {
         led_color_list.push_back({ leds[i].value, colors[i] });
     }
 
     controller->UpdateLeds(led_color_list);
-
 }
 
 void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h

@@ -13,7 +13,6 @@
 
 enum
 {
-    AURA_KEYBOARD_SPEED_MIN          = 15,
     AURA_KEYBOARD_SPEED_MAX          = 0,
     AURA_KEYBOARD_SPEED_DEFAULT      = 8,
     AURA_KEYBOARD_BRIGHTNESS_MIN     = 0,

Controllers/AsusTUFLaptopController/AsusTUFLaptopWMIDetect.cpp

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

Controllers/AsusTUFLaptopLinuxController/AsusTUFLaptopLinuxController.cpp

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

Controllers/AsusTUFLaptopLinuxController/AsusTUFLaptopLinuxController.h

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

Controllers/AsusTUFLaptopLinuxController/AsusTUFLaptopLinuxDetect.cpp

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

Controllers/AsusTUFLaptopLinuxController/RGBController_AsusTUFLaptopLinux.cpp

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

Controllers/AsusTUFLaptopLinuxController/RGBController_AsusTUFLaptopLinux.h

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

Controllers/BlinkyTapeController/BlinkyTapeControllerDetect.cpp

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

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -37,7 +37,10 @@ void DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
     }
 }
 
-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);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",  DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,      0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",  DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,    0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,       0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV2,      0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC LHR",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ULTRAW_OC,          0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Advanced OC-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_TI_ADVANCED_OCV2,   0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2,        0x61);

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumControllerDetect.cpp

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

Controllers/CorsairHydro2Controller/CorsairHydro2Controller.cpp

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

Controllers/CorsairHydro2Controller/CorsairHydro2Controller.h

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

Controllers/CorsairHydro2Controller/CorsairHydro2ControllerDetect.cpp

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

Controllers/CorsairHydro2Controller/RGBController_CorsairHydro2.cpp

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

Controllers/CorsairHydro2Controller/RGBController_CorsairHydro2.h

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

Controllers/CorsairHydroController/CorsairHydroControllerDetect.cpp

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

Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp

@@ -240,7 +240,7 @@ void RGBController_CorsairLightingNode::SetupZones()
     for (unsigned int channel_idx = 0; channel_idx < CORSAIR_LIGHTING_NODE_NUM_CHANNELS; channel_idx++)
     {
         char ch_idx_string[2];
-        sprintf(ch_idx_string, "%d", channel_idx + 1);
+        snprintf(ch_idx_string, 2, "%d", channel_idx + 1);
 
         zones[channel_idx].name     = "Corsair Channel ";
         zones[channel_idx].name.append(ch_idx_string);
@@ -264,7 +264,7 @@ void RGBController_CorsairLightingNode::SetupZones()
         for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
         {
             char led_idx_string[4];
-            sprintf(led_idx_string, "%d", led_ch_idx + 1);
+            snprintf(led_idx_string, 4, "%d", led_ch_idx + 1);
 
             led new_led;
             new_led.name = "Corsair Channel ";

Controllers/CorsairVengeanceController/CorsairVengeanceControllerDetect.cpp

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

Controllers/DasKeyboardController/DasKeyboardControllerDetect.cpp

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

Controllers/DebugController/DebugControllerDetect.cpp

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

Controllers/DygmaRaiseController/DygmaRaiseControllerDetect.cpp

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

Controllers/E131Controller/E131ControllerDetect.cpp

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

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -332,23 +332,30 @@ void DetectENESMBusGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
 REGISTER_I2C_DETECTOR("ENE SMBus DRAM",                 DetectENESMBusDRAMControllers);
 REGISTER_I2C_DETECTOR("ASUS Aura SMBus Motherboard",    DetectENESMBusMotherboardControllers);
 
+/*-----------------------------------------*\
+|  NVidia GPUs                              |
+\*-----------------------------------------*/
+
 REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060 OC O12G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_KO_RTX_3060_OC_O12G_GAMING,            0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF 3060 O12G GAMING",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_O12G_GAMING,              0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF 3060 O12G V2 GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_GA104_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_O12G_V2_GAMING,           0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF 3060 O12G V2 GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_O12G_LHR_GAMING,          0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060 12G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060_12G_GAMING,         0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060 O12G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060_O12G_GAMING,        0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060 O12G V2 GAMING",         DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060_O12G_LHR_GAMING,    0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060 O12G V2 GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,   ASUS_KO_RTX_3060_O12G_V2_GAMING,            0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060Ti O8G V2 GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_KO_RTX3060TI_O8G_V2_GAMING,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060Ti O8G GAMING",              DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_KO_RTX3060TI_O8G_GAMING,               0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060Ti O8G OC",                 DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060Ti O8G OC",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_3060_TI_O8G_OC,              0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060Ti O8G OC",                 DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC_V2,             0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060Ti O8G V2",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060TI_O8G_V2_GAMING,    0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 OC",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_OC,                 0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_GAMING,      0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_GAMING,         0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G White",              DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_WHITE,          0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G V2 GAMING",          DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_V2_GAMING,      0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G V2 White",           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_V2_WHITE,       0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070 8G GAMING",                DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3070_8G_GAMING,                0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070 O8G GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3070_O8G_GAMING,               0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3070 O8G V2 GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_KO_RTX_3070_O8G_GAMING,                0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070 O8G V2 GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3070_O8G_V2_GAMING,            0x67);
@@ -378,9 +385,24 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3090 O24G GAMING",            DetectEN
 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 3090Ti O24G OC GAMING",         DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3090TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3090TI_O24G_OC_GAMING,         0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4070 Ti 12G Gaming",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_4070TI_12G_GAMING,             0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4090 O24G OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_4090_O24G_OC_GAMING,           0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4090 O24G",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_4090_O24G_GAMING,              0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 4090 O24G GAMING",        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4090_O24G_GAMING,        0x67);
+
+/*-----------------------------------------*\
+|  AMD GPUs                                 |
+\*-----------------------------------------*/
+
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RX 6700XT O12G GAMING",             DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI22_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_6700XT_O12G_GAMING,             0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 6700XT O12G GAMING",       DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI22_DEV,             ASUS_SUB_VEN,   ASUS_ROG_STRIX_RX_6700XT_O12G_GAMING,       0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 6750XT O12G GAMING",       DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI22_DEV,             ASUS_SUB_VEN,   ASUS_ROG_STRIX_RX_6750XT_O12G_GAMING,       0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 6800 TUF Gaming OC",                 DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_RX6800_TUF_GAMING_OC,                  0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 6800 O16G Gaming",         DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_ROG_STRIX_RX_6800_O16G_GAMING,         0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RX 6800XT O16G GAMING",             DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_TUF_RX_6800XT_O16G_GAMING,             0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX LC RX 6800XT O16G GAMING",    DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_ROG_STRIX_LC_RX6800XT_O16G_GAMING,     0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RX 6900XT O16G GAMING",             DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV1,            ASUS_SUB_VEN,   ASUS_TUF_RX_6900XT_O16G_GAMING,             0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RX 6900XT T16G GAMING",             DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV2,            ASUS_SUB_VEN,   ASUS_TUF_RX_6900XT_T16G_GAMING,             0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RX 6950XT O16G GAMING",             DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV3,            ASUS_SUB_VEN,   ASUS_TUF_RX_6950XT_016G_GAMING,             0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX LC RX 6950XT O16G GAMING",    DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI21_DEV3,            ASUS_SUB_VEN,   ASUS_ROG_STRIX_LC_RX_6950XT_O16G_GAMING,    0x67);

Controllers/ENESMBusController/XPGSpectrixS40GDetect.cpp

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

Controllers/ENESMBusController/XPGSpectrixS40GDetect_Windows.cpp

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

Controllers/EVGAAmpereGPUController/EVGAAmpereGPUControllerDetect.cpp

@@ -70,13 +70,14 @@ REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Ultra Hydro Copper"
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Gaming"                   , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_GAMING_SUB_DEV,               0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra"                    , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_SUB_DEV,                0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra v2 LHR"             , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_LHR_V2_SUB_DEV,         0x2D);
-REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra 12GB"               , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_12G_SUB_DEV,            0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra LHR"                , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_LHR_SUB_DEV,            0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hybrid"             , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_HYBRID_SUB_DEV,         0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hybrid LHR"         , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_HYBRID_LHR_SUB_DEV,     0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hybrid Gaming LHR"  , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_HYBRID_GAMING_SUB_DEV,  0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hydro Copper"       , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_HC_SUB_DEV,             0x2D);
-REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hydro Copper 12G"   , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_HC_12G_SUB_DEV,         0x2D);
+REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Ultra 12G"                 , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN,   EVGA_RTX3080_12G_XC3_ULTRA_SUB_DEV,             0x2D);
+REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra 12GB"               , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN,   EVGA_RTX3080_12G_FTW3_ULTRA_SUB_DEV,            0x2D);
+REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hydro Copper 12G"   , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN,   EVGA_RTX3080_12G_FTW3_ULTRA_HC_SUB_DEV,         0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080Ti XC3 Gaming"                  , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3080TI_XC3_GAMING_SUB_DEV,              0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080Ti XC3 Ultra Gaming"            , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3080TI_XC3_ULTRA_GAMING_SUB_DEV,        0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080Ti XC3 Gaming Hybrid"           , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3080TI_XC3_GAMING_HYBRID_SUB_DEV,       0x2D);

Controllers/EVGATuringGPUController/EVGATuringGPUControllerDetect.cpp

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

Controllers/EVGAUSBController/RGBController_EVGAMouse.cpp

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

Controllers/ElgatoKeyLightController/ElgatoKeyLightControllerDetect.cpp

@@ -15,7 +15,7 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectElgatoKeyLightControllers(std::vector<RGBController*> &rgb_controllers)
+void DetectElgatoKeyLightControllers()
 {
     json                    elgato_keylight_settings;
 
@@ -38,7 +38,7 @@ void DetectElgatoKeyLightControllers(std::vector<RGBController*> &rgb_controller
                 ElgatoKeyLightController*     controller     = new ElgatoKeyLightController(elgato_keylight_ip);
                 RGBController_ElgatoKeyLight* rgb_controller = new RGBController_ElgatoKeyLight(controller);
 
-                rgb_controllers.push_back(rgb_controller);
+                ResourceManager::get()->RegisterRGBController(rgb_controller);
             }
         }
     }

Controllers/EspurnaController/EspurnaControllerDetect.cpp

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

Controllers/FanBusController/FanBusControllerDetect.cpp

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

Controllers/FaustusController/RGBController_Faustus.cpp

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

Controllers/GaiZongGaiKeyboardController/GaiZhongGaiKeyboardController.cpp

@@ -18,7 +18,7 @@ GaiZhongGaiKeyboardController::GaiZhongGaiKeyboardController(hid_device* dev_han
     | Obtaining the Firmware Version                        |
     \*-----------------------------------------------------*/
     char str[10];
-    sprintf(str, "Ver%04X", info->release_number);
+    snprintf(str, 10, "Ver%04X", info->release_number);
     version = str;
 }
 

Controllers/GigabyteAorusMouseController/GigabyteAorusMouseController.cpp

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

Controllers/GigabyteAorusMouseController/GigabyteAorusMouseController.h

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

Controllers/GigabyteAorusMouseController/GigabyteAorusMouseControllerDetect.cpp

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

Controllers/GigabyteAorusMouseController/RGBController_GigabyteAorusMouse.cpp

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

Controllers/GigabyteAorusMouseController/RGBController_GigabyteAorusMouse.h

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

Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp

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

Controllers/GigabyteRGBFusion2USBController/RGBController_GigabyteRGBFusion2USB.cpp

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

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUControllerDetect.cpp

@@ -126,6 +126,7 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2060 SUPER Gaming OC",               Dete
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2060 SUPER Gaming OC 3X White 8G",   DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_OC_WHITE_SUB_DEV,      0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2060 SUPER Gaming OC 3X 8G V2",      DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_OC_3X_V2_SUB_DEV,      0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2070 Gaming OC 8G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070_GAMING_OC_SUB_DEV,             0x47);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2070 Gaming OC 8GC",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070_GAMING_OC_8GC_SUB_DEV,         0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2070 Windforce 8G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070_WINDFORCE_SUB_DEV,             0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2070S Gaming OC",                    DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_SUB_DEV,            0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2070S Gaming OC 3X",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_3X_SUB_DEV,         0x47);
@@ -137,6 +138,7 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2080 Ti GAMING OC 11G",              Dete
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX2080S Gaming OC 8G",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080S_GAMING_OC_SUB_DEV,            0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3050 Gaming OC 8G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3050_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3050_GAMING_OC_8GB_SUB_DEV,         0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 EAGLE OC 12G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_EAGLE_OC_12GB_SUB_DEV,         0x63);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 EAGLE OC 12G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060_GA104_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_EAGLE_OC_12GB_SUB_DEV,         0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 EAGLE OC 12G V2",               DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_EAGLE_OC_12GB_SUB_DEV,         0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 EAGLE 12G LHR V2",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_EAGLE_12GB_V2_SUB_DEV,         0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3060 Vision OC 12G",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_VISION_OC_12GB_SUB_DEV,        0x63);
@@ -154,6 +156,7 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Gaming OC 8G v3.0 LHR",         Dete
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Vision 8G",                     DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_VISION_OC_SUB_DEV,             0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Vision 8G V2.0 LHR",            DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_VISION_OC_SUB_DEV,             0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Eagle OC 8G",                   DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_EAGLE_OC_SUB_DEV,              0x63);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Eagle OC 8G V2.0 LHR",          DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_EAGLE_OC_SUB_DEV,              0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Ti Gaming OC 8G",               DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070TI_GAMING_OC_SUB_DEV,           0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Ti EAGLE 8G",                   DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070TI_EAGLE_SUB_DEV,               0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3070 Ti Vision OC 8G",               DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070TI_VISION_OC_SUB_DEV,           0x63);
@@ -164,4 +167,5 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3080 Vision OC 10G (REV 2.0)",       Dete
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3080 Vision OC 10G",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080_VISION_OC_SUB_DEV,             0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3080 Ti Gaming OC 12G",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080TI_GAMING_OC_SUB_DEV,           0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3080 Ti EAGLE 12G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080TI_EAGLE_SUB_DEV,               0x63);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3080 Ti EAGLE OC 12G",               DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080TI_EAGLE_OC_SUB_DEV,            0x63);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX3090 Gaming OC 24G",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX3090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3090_GAMING_OC_24GB_SUB_DEV,        0x62);

Controllers/GigabyteSuperIORGBController/GigabyteSuperIORGBControllerDetect.cpp

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

Controllers/HyperXKeyboardController/HyperXAlloyOriginsCoreController.cpp

@@ -27,7 +27,7 @@ HyperXAlloyOriginsCoreController::HyperXAlloyOriginsCoreController(hid_device* d
     memset(fw_version_buf, '\0', sizeof(fw_version_buf));
 
     unsigned short version = dev_info->release_number;
-    sprintf(fw_version_buf, "%.2X.%.2X", (version & 0xFF00) >> 8, version & 0x00FF);
+    snprintf(fw_version_buf, 8, "%.2X.%.2X", (version & 0xFF00) >> 8, version & 0x00FF);
 
     firmware_version = fw_version_buf;
 }
@@ -63,6 +63,19 @@ std::string HyperXAlloyOriginsCoreController::GetFirmwareVersion()
     return(firmware_version);
 }
 
+void HyperXAlloyOriginsCoreController::SetBrightness(unsigned int brightness)
+{
+    unsigned char packet[65];
+    memset(packet, 0x00, sizeof(packet));
+
+    packet[1] = 0xA7;
+    packet[4] = 0x01;
+    packet[5] = brightness;
+
+    hid_write(dev, packet, 65);
+}
+
+
 void HyperXAlloyOriginsCoreController::SetLEDsDirect(std::vector<RGBColor> colors)
 {
     for(unsigned int skip_cnt = 0; skip_cnt < (sizeof(skip_idx) / sizeof(skip_idx[0])); skip_cnt++)

Controllers/HyperXKeyboardController/HyperXAlloyOriginsCoreController.h

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

Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp

@@ -15,20 +15,27 @@
 #include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
-| HyperX keyboard vendor IDs                            |
+| HyperX keyboard vendor and product IDs                |
 \*-----------------------------------------------------*/
 #define HYPERX_KEYBOARD_VID                        0x0951
+
 #define HYPERX_ALLOY_ELITE_PID                     0x16BE
 #define HYPERX_ALLOY_ELITE_2_PID                   0x1711
 #define HYPERX_ALLOY_FPS_RGB_PID                   0x16DC
 #define HYPERX_ALLOY_ORIGINS_PID                   0x16E5
-#define HYPERX_ALLOY_ORIGINS_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
 
+/*-----------------------------------------------------*\
+| HyperX keyboard vendor and product IDs (HP)               |
+\*-----------------------------------------------------*/
 #define HP_KEYBOARD_VID                            0x03F0
+
 #define HYPERX_ALLOY_ELITE_2_HP_PID                0x058F
+#define HYPERX_ALLOY_ORIGINS_60_HP_PID             0x0C8E
+#define HYPERX_ALLOY_ORIGINS_CORE_HP_PID           0x098F
+#define HYPERX_ALLOY_ORIGINS_HP_PID                0x0591
+
 
 void DetectHyperXAlloyElite(hid_device_info* info, const std::string& name)
 {
@@ -114,20 +121,26 @@ void DetectHyperXAlloyOrigins60(hid_device_info* info, const std::string& name)
     }
 }
 
-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);
+REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite RGB",          DetectHyperXAlloyElite,       HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID,           2, 0xFF01);
+REGISTER_HID_DETECTOR_IP("HyperX Alloy FPS RGB",            DetectHyperXAlloyFPS,         HYPERX_KEYBOARD_VID, HYPERX_ALLOY_FPS_RGB_PID,         2, 0xFF01);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core",        DetectHyperXAlloyOriginsCore, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_CORE_PID,    2);
+
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core (HP)",   DetectHyperXAlloyOriginsCore, HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_CORE_HP_PID, 2);
 
 #ifdef _WIN32
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",         DetectHyperXAlloyOrigins,     HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,        3);
-REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2",        DetectHyperXAlloyElite2,      HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,        3, 0xFF90);
-REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2 (HP)",   DetectHyperXAlloyElite2,      HP_KEYBOARD_VID,     HYPERX_ALLOY_ELITE_2_HP_PID,     3, 0xFF90);
-REGISTER_HID_DETECTOR_IP("HyperX Alloy Origins",        DetectHyperXAlloyOrigins,     HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_V2_PID,     3, 0xFF90);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",             DetectHyperXAlloyOrigins,     HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,         3);
+REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2",            DetectHyperXAlloyElite2,      HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,         3, 0xFF90);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60",          DetectHyperXAlloyOrigins60,   HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_60_PID,      3);
+
+REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2 (HP)",       DetectHyperXAlloyElite2,      HP_KEYBOARD_VID,     HYPERX_ALLOY_ELITE_2_HP_PID,      3, 0xFF90);
+REGISTER_HID_DETECTOR_IP("HyperX Alloy Origins (HP)",       DetectHyperXAlloyOrigins,     HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_HP_PID,      3, 0xFF90);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60 (HP)",     DetectHyperXAlloyOrigins60,   HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_60_HP_PID,   3);
 #else
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",         DetectHyperXAlloyOrigins,     HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,        0);
-REGISTER_HID_DETECTOR_I("HyperX Alloy 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);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",             DetectHyperXAlloyOrigins,     HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,         0);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2",             DetectHyperXAlloyElite2,      HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,         0);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60",          DetectHyperXAlloyOrigins60,   HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_60_PID,      0);
+
+REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2 (HP)",        DetectHyperXAlloyElite2,      HP_KEYBOARD_VID,     HYPERX_ALLOY_ELITE_2_HP_PID,      0);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins (HP)",        DetectHyperXAlloyOrigins,     HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_HP_PID,      0);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Origins 60 (HP)",     DetectHyperXAlloyOrigins60,   HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_60_HP_PID,   0);
 #endif

Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOriginsCore.cpp

@@ -12,6 +12,10 @@
 
 using namespace std::chrono_literals;
 
+
+#define HYPERX_MIN_BRIGHTNESS   0
+#define HYPERX_MAX_BRIGHTNESS 255
+
 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF
 
@@ -170,10 +174,13 @@ RGBController_HyperXAlloyOriginsCore::RGBController_HyperXAlloyOriginsCore(Hyper
     version     = controller->GetFirmwareVersion();
 
     mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0xFFFF;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name             = "Direct";
+    Direct.value            = 0xFFFF;
+    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.brightness_min   = HYPERX_MIN_BRIGHTNESS;
+    Direct.brightness_max   = HYPERX_MAX_BRIGHTNESS;
+    Direct.brightness       = HYPERX_MAX_BRIGHTNESS;
+    Direct.color_mode       = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     SetupZones();
@@ -271,7 +278,7 @@ void RGBController_HyperXAlloyOriginsCore::UpdateSingleLED(int /*led*/)
 
 void RGBController_HyperXAlloyOriginsCore::DeviceUpdateMode()
 {
-
+    controller->SetBrightness(modes[active_mode].brightness);
 }
 
 void RGBController_HyperXAlloyOriginsCore::KeepaliveThread()

Controllers/HyperXMouseController/HyperXMouseControllerDetect.cpp

@@ -14,14 +14,17 @@
 /*-----------------------------------------------------*\
 | HyperX mouse vendor IDs                               |
 \*-----------------------------------------------------*/
-#define HYPERX_VID                          0x0951
-#define HYPERX_PULSEFIRE_SURGE_PID          0x16D3
-#define HYPERX_PULSEFIRE_FPS_PRO_PID        0x16D7
-#define HYPERX_PULSEFIRE_CORE_PID           0x16DE
-#define HYPERX_PULSEFIRE_DART_WIRELESS_PID  0x16E1
-#define HYPERX_PULSEFIRE_DART_WIRED_PID     0x16E2
-#define HYPERX_PULSEFIRE_RAID_PID           0x16E4
-#define HYPERX_PULSEFIRE_HASTE_PID          0x1727
+#define HYPERX_VID                              0x0951
+#define HYPERX_VID_2                            0x03F0
+#define HYPERX_PULSEFIRE_SURGE_PID              0x16D3
+#define HYPERX_PULSEFIRE_FPS_PRO_PID            0x16D7
+#define HYPERX_PULSEFIRE_CORE_PID               0x16DE
+#define HYPERX_PULSEFIRE_DART_WIRELESS_PID      0x16E1
+#define HYPERX_PULSEFIRE_DART_WIRELESS_PID_2    0x068E
+#define HYPERX_PULSEFIRE_DART_WIRED_PID         0x16E2
+#define HYPERX_PULSEFIRE_DART_WIRED_PID_2       0x088E
+#define HYPERX_PULSEFIRE_RAID_PID               0x16E4
+#define HYPERX_PULSEFIRE_HASTE_PID              0x1727
 
 void DetectHyperXPulsefireSurgeControllers(hid_device_info* info, const std::string& name)
 {
@@ -93,16 +96,19 @@ void DetectHyperXPulsefireRaidControllers(hid_device_info* info, const std::stri
     }
 }   /* DetectHyperXPulsefireRaidControllers() */
 
-REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Surge",              DetectHyperXPulsefireSurgeControllers,  HYPERX_VID, HYPERX_PULSEFIRE_SURGE_PID,         1,      0xFF01);
-REGISTER_HID_DETECTOR_IP("HyperX Pulsefire FPS Pro",            DetectHyperXPulsefireFPSProControllers, HYPERX_VID, HYPERX_PULSEFIRE_FPS_PRO_PID,       1,      0xFF01);
-REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Core",               DetectHyperXPulsefireFPSProControllers, HYPERX_VID, HYPERX_PULSEFIRE_CORE_PID,          1,      0xFF01);
-REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Dart (Wireless)",    DetectHyperXPulsefireDartControllers,   HYPERX_VID, HYPERX_PULSEFIRE_DART_WIRELESS_PID, 2,      0xFF00);
-REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Dart (Wired)",       DetectHyperXPulsefireDartControllers,   HYPERX_VID, HYPERX_PULSEFIRE_DART_WIRED_PID,    1,      0xFF13);
+REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Surge",              DetectHyperXPulsefireSurgeControllers,  HYPERX_VID,     HYPERX_PULSEFIRE_SURGE_PID,             1,      0xFF01);
+REGISTER_HID_DETECTOR_IP("HyperX Pulsefire FPS Pro",            DetectHyperXPulsefireFPSProControllers, HYPERX_VID,     HYPERX_PULSEFIRE_FPS_PRO_PID,           1,      0xFF01);
+REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Core",               DetectHyperXPulsefireFPSProControllers, HYPERX_VID,     HYPERX_PULSEFIRE_CORE_PID,              1,      0xFF01);
+REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Dart (Wireless)",    DetectHyperXPulsefireDartControllers,   HYPERX_VID,     HYPERX_PULSEFIRE_DART_WIRELESS_PID,     2,      0xFF00);
+REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Dart (Wireless)",    DetectHyperXPulsefireDartControllers,   HYPERX_VID_2,   HYPERX_PULSEFIRE_DART_WIRELESS_PID_2,   2,      0xFF00);
+REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Dart (Wired)",       DetectHyperXPulsefireDartControllers,   HYPERX_VID,     HYPERX_PULSEFIRE_DART_WIRED_PID,        1,      0xFF13);
+REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Dart (Wired)",       DetectHyperXPulsefireDartControllers,   HYPERX_VID_2,   HYPERX_PULSEFIRE_DART_WIRED_PID_2,      1,      0xFF13);
 
-REGISTER_HID_DETECTOR_IPU("HyperX Pulsefire Raid",              DetectHyperXPulsefireRaidControllers,   HYPERX_VID, HYPERX_PULSEFIRE_RAID_PID,          1,      0xFF01, 0x01);
+REGISTER_HID_DETECTOR_IPU("HyperX Pulsefire Raid",              DetectHyperXPulsefireRaidControllers,   HYPERX_VID,     HYPERX_PULSEFIRE_RAID_PID,              1,      0xFF01, 0x01);
 
 #ifdef _WIN32
 REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Haste",              DetectHyperXPulsefireHasteControllers,  HYPERX_VID, HYPERX_PULSEFIRE_HASTE_PID,         3,      0xFF90);
 #else
 REGISTER_HID_DETECTOR_PU("HyperX Pulsefire Haste",              DetectHyperXPulsefireHasteControllers,  HYPERX_VID, HYPERX_PULSEFIRE_HASTE_PID,         1,      2);
 #endif
+

Controllers/HyperXMousematController/HyperXMousematController.cpp

@@ -11,15 +11,16 @@
 
 #include <cstring>
 
-HyperXMousematController::HyperXMousematController(hid_device* dev_handle, const char* path)
+HyperXMousematController::HyperXMousematController(hidapi_wrapper hid_wrapper, hid_device* dev_handle, const char* path)
 {
+    wrapper     = hid_wrapper;
     dev         = dev_handle;
     location    = path;
 }
 
 HyperXMousematController::~HyperXMousematController()
 {
-    hid_close(dev);
+    wrapper.hid_close(dev);
 }
 
 std::string HyperXMousematController::GetDeviceLocation()
@@ -30,7 +31,7 @@ std::string HyperXMousematController::GetDeviceLocation()
 std::string HyperXMousematController::GetSerialString()
 {
     wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+    int ret = wrapper.hid_get_serial_number_string(dev, serial_string, 128);
 
     if(ret != 0)
     {
@@ -71,7 +72,7 @@ void HyperXMousematController::SendDirect
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 65);
+    wrapper.hid_send_feature_report(dev, buf, 65);
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -94,7 +95,7 @@ void HyperXMousematController::SendDirect
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 65);
+    wrapper.hid_send_feature_report(dev, buf, 65);
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -114,5 +115,5 @@ void HyperXMousematController::SendDirect
         buf[(i * 4) + 4] = RGBGetBValue(color_data[16 + i]);
     }
 
-    hid_send_feature_report(dev, buf, 65);
+    wrapper.hid_send_feature_report(dev, buf, 65);
 }

Controllers/HyperXMousematController/HyperXMousematController.h

@@ -10,14 +10,15 @@
 #include "RGBController.h"
 
 #include <string>
-#include <hidapi/hidapi.h>
+
+#include "hidapi_wrapper.h"
 
 #pragma once
 
 class HyperXMousematController
 {
 public:
-    HyperXMousematController(hid_device* dev_handle, const char* path);
+    HyperXMousematController(hidapi_wrapper hid_wrapper, hid_device* dev_handle, const char* path);
     ~HyperXMousematController();
 
     std::string GetDeviceLocation();
@@ -29,6 +30,7 @@ public:
             );
 
 private:
+    hidapi_wrapper          wrapper;
     hid_device*             dev;
     std::string             location;
 };

Controllers/HyperXMousematController/HyperXMousematControllerDetect.cpp

@@ -3,7 +3,8 @@
 #include "RGBController.h"
 #include "RGBController_HyperXMousemat.h"
 #include <vector>
-#include <hidapi/hidapi.h>
+
+#include "hidapi_wrapper.h"
 
 /*-----------------------------------------------------*\
 | HyperX mousemat vendor IDs                            |
@@ -22,13 +23,13 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectHyperXMousematControllers(hid_device_info* info, const std::string& name)
+void DetectHyperXMousematControllers(hidapi_wrapper wrapper, hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    hid_device* dev = wrapper.hid_open_path(info->path);
 
     if(dev)
     {
-        HyperXMousematController*     controller     = new HyperXMousematController(dev, info->path);
+        HyperXMousematController*     controller     = new HyperXMousematController(wrapper, dev, info->path);
         RGBController_HyperXMousemat* rgb_controller = new RGBController_HyperXMousemat(controller);
         rgb_controller->name                         = name;
         
@@ -36,5 +37,5 @@ 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);
+REGISTER_HID_WRAPPED_DETECTOR_I("HyperX Fury Ultra", DetectHyperXMousematControllers, HYPERX_VID, HYPERX_FURY_ULTRA_PID, 0);
+REGISTER_HID_WRAPPED_DETECTOR_IPU("HyperX Pulsefire Mat", DetectHyperXMousematControllers, HYPERX_VID_2, HYPERX_PULSEFIRE_PID, 1, 0xFF90, 0xFF00);

Controllers/HyperXQuadcastController/HyperXQuadcastSController.cpp

@@ -0,0 +1,199 @@
+/*-----------------------------------------*\
+|  HyperXQuadcastSController.cpp            |
+|                                           |
+|  Implementation for the HyperX            |
+|  Quadcast S RGB microphone                |
+|                                           |
+|  Matt Silva (thesilvanator) 2022          |
+\*-----------------------------------------*/
+
+#include "HyperXQuadcastSController.h"
+
+using namespace std::chrono_literals;
+
+HyperXQuadcastSController::HyperXQuadcastSController(hidapi_wrapper hid_wrapper, hid_device* dev_handle, std::string path)
+{
+    wrapper     = hid_wrapper;
+    dev         = dev_handle;
+    location    = path;
+
+    wchar_t serial_string[128];
+    int ret = wrapper.hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        serial_number = "";
+    }
+    else
+    {
+        std::wstring return_wstring = serial_string;
+        serial_number = std::string(return_wstring.begin(), return_wstring.end());
+    }
+}
+
+HyperXQuadcastSController::~HyperXQuadcastSController()
+{
+    if(dev)
+    {
+        wrapper.hid_close(dev);
+    }
+}
+
+std::string HyperXQuadcastSController::GetDeviceLocation()
+{
+    return location;
+}
+
+std::string HyperXQuadcastSController::GetSerialString()
+{
+    return serial_number;
+}
+
+void HyperXQuadcastSController::SaveColors(std::vector<RGBColor> colors, unsigned int num_frames)
+{
+    unsigned int  num_color_packets                     = 0;
+    unsigned int  frame                                 = 0;
+    unsigned char color[HYPERX_QUADCAST_S_PACKET_SIZE]  = {0};
+    unsigned char empty[HYPERX_QUADCAST_S_PACKET_SIZE]  = {0};
+
+    num_color_packets = num_frames/8;
+    if(num_frames % 8)
+    {
+        num_color_packets++;
+    }
+
+    lock.lock();
+
+    /*---------------------------------------------------------*\
+    | Start Save Transaction                                    |
+    |   0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00          |
+    \*---------------------------------------------------------*/
+    SendToRegister(0x53, (uint8_t)num_color_packets, 0);
+
+    while(frame < num_frames)
+    {
+        memset(color, 0, HYPERX_QUADCAST_S_PACKET_SIZE);
+
+        unsigned int i = 0;
+        while(i < 8 && frame < num_frames)
+        {
+            int index           = HYPERX_QUADCAST_S_FRAME_SIZE * i;
+            RGBColor top        = colors[frame*2];
+            RGBColor bot        = colors[frame*2 + 1];
+
+            color[index + 1]    = 0x81;
+            color[index + 2]    = RGBGetRValue(top);
+            color[index + 3]    = RGBGetGValue(top);
+            color[index + 4]    = RGBGetBValue(top);
+            color[index + 5]    = 0x81;
+            color[index + 6]    = RGBGetRValue(bot);
+            color[index + 7]    = RGBGetGValue(bot);
+            color[index + 8]    = RGBGetBValue(bot);
+
+            i++;
+            frame++;
+        }
+
+        std::this_thread::sleep_for(15ms);
+        wrapper.hid_send_feature_report(dev, color, HYPERX_QUADCAST_S_PACKET_SIZE);
+    }
+
+    /*---------------------------------------------------------*\
+    | Post Save Transaction                                     |
+    |   0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00          |
+    \*---------------------------------------------------------*/
+    SendToRegister(0x02, 0, 0);
+
+    /*---------------------------------------------------------*\
+    | Stop Save Transaction                                     |
+    |   0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00          |
+    \*---------------------------------------------------------*/
+    SendToRegister(0x23, 1, 0);
+
+    SendEOT((uint8_t)num_frames);
+
+    /*---------------------------------------------------------*\
+    | Post Save Transaction                                     |
+    |   0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00          |
+    \*---------------------------------------------------------*/
+    SendToRegister(0x02, 0, 0);
+
+    lock.unlock();
+
+    /*---------------------------------------------------------*\
+    | Likes to have one temporary direct packet after the save  |
+    | for some reason                                           |
+    \*---------------------------------------------------------*/
+    SendDirect(colors);
+}
+
+void HyperXQuadcastSController::SendDirect(std::vector<RGBColor> colors)
+{
+    /*---------------------------------------------------------*\
+    | Verify colors size                                        |
+    \*---------------------------------------------------------*/
+    if(colors.size() != 2)
+    {
+        return;
+    }
+
+    int      res;
+    RGBColor c1 = colors[0];
+    RGBColor c2 = colors[1];
+    uint8_t  buffer[HYPERX_QUADCAST_S_PACKET_SIZE];
+
+    /*---------------------------------------------------------*\
+    | Colour packet                                             |
+    \*---------------------------------------------------------*/
+    memset(buffer, 0, HYPERX_QUADCAST_S_PACKET_SIZE);
+
+    buffer[0x01]    = 0x81;
+    buffer[0x02]    = RGBGetRValue(c1);
+    buffer[0x03]    = RGBGetGValue(c1);
+    buffer[0x04]    = RGBGetBValue(c1);
+    buffer[0x05]    = 0x81;
+    buffer[0x06]    = RGBGetRValue(c2);
+    buffer[0x07]    = RGBGetGValue(c2);
+    buffer[0x08]    = RGBGetBValue(c2);
+
+    lock.lock();
+
+    res = wrapper.hid_send_feature_report(dev, buffer, HYPERX_QUADCAST_S_PACKET_SIZE);
+    std::this_thread::sleep_for(15ms);
+
+    SendToRegister(0xF2, 0, 1);
+
+    lock.unlock();
+}
+
+void HyperXQuadcastSController::SendEOT(uint8_t frame_count)
+{
+    uint8_t buffer[HYPERX_QUADCAST_S_PACKET_SIZE];
+
+    memset(buffer, 0, HYPERX_QUADCAST_S_PACKET_SIZE);
+
+    buffer[0x01]    = 0x08;
+    buffer[0x3C]    = 0x28;
+    buffer[0x3D]    = frame_count;
+    buffer[0x3E]    = 0x00;
+    buffer[0x3F]    = 0xAA;
+    buffer[0x40]    = 0x55;
+
+    wrapper.hid_send_feature_report(dev, buffer, HYPERX_QUADCAST_S_PACKET_SIZE);
+    std::this_thread::sleep_for(15ms);
+}
+
+void HyperXQuadcastSController::SendToRegister(uint8_t reg, uint8_t param1, uint8_t param2)
+{
+    uint8_t buffer[HYPERX_QUADCAST_S_PACKET_SIZE];
+
+    memset(buffer, 0, HYPERX_QUADCAST_S_PACKET_SIZE);
+
+    buffer[0x01]    = 0x04;
+    buffer[0x02]    = reg;         // 0xF2 Apply, 0x53 Save
+    buffer[0x08]    = param1;
+    buffer[0x09]    = param2;
+
+    wrapper.hid_send_feature_report(dev, buffer, HYPERX_QUADCAST_S_PACKET_SIZE);
+    std::this_thread::sleep_for(15ms);
+}

Controllers/HyperXQuadcastController/HyperXQuadcastSController.h

@@ -0,0 +1,40 @@
+/*-----------------------------------------*\
+|  HyperXQuadcastSController.h              |
+|                                           |
+|  Implementation for the HyperX            |
+|  Quadcast S RGB microphone                |
+|                                           |
+|  Matt Silva (thesilvanator) 2022          |
+\*-----------------------------------------*/
+#pragma once
+
+#include <string>
+#include "hidapi_wrapper.h"
+#include "LogManager.h"
+#include "RGBController.h"
+
+#define HYPERX_QUADCAST_S_PACKET_SIZE 64 + 1
+#define HYPERX_QUADCAST_S_FRAME_SIZE  8
+
+class HyperXQuadcastSController
+{
+public:
+    HyperXQuadcastSController(hidapi_wrapper hid_wrapper, hid_device* dev, std::string path);
+    ~HyperXQuadcastSController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void SendDirect(std::vector<RGBColor> color_data);
+    void SaveColors(std::vector<RGBColor> colors, unsigned int num_frames);
+
+private:
+    hidapi_wrapper      wrapper;
+    hid_device*         dev;
+    std::string         location;
+    std::string         serial_number;
+    std::mutex          lock;
+
+    void                SendEOT(uint8_t frame_count);
+    void                SendToRegister(uint8_t reg, uint8_t param1, uint8_t param2);
+};

Controllers/HyperXQuadcastController/HyperXQuadcastSControllerDetect.cpp

@@ -0,0 +1,46 @@
+/*-----------------------------------------*\
+|  HyperXQuadcastSControllerDetect.cpp      |
+|                                           |
+|  Implementation for the HyperX            |
+|  Quadcast S RGB microphone                |
+|                                           |
+|  Matt Silva (thesilvanator) 2022          |
+\*-----------------------------------------*/
+
+#include "Detector.h"
+#include "HyperXQuadcastSController.h"
+#include "RGBController.h"
+#include "RGBController_HyperXQuadcastS.h"
+#include <vector>
+#include <LogManager.h>
+
+#include "hidapi_wrapper.h"
+
+/*-----------------------------------------------------*\
+| HyperX microphone vendor and product IDs              |
+\*-----------------------------------------------------*/
+#define HYPERX_VID          0x0951
+#define HYPERX_HP_VID       0x03F0
+
+#define HYPERX_QS_PID       0x171F
+
+#define HYPERX_QS_PID_HP_1  0x0F8B
+#define HYPERX_QS_PID_HP_2  0x068C
+
+void DetectHyperXQuadcastSControllers(hidapi_wrapper wrapper, hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = wrapper.hid_open_path(info->path);
+
+    if(dev)
+    {
+        HyperXQuadcastSController* controller         = new HyperXQuadcastSController(wrapper, dev, info->path);
+        RGBController_HyperXQuadcastS *rgb_controller = new RGBController_HyperXQuadcastS(controller);
+        rgb_controller->name                          = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_WRAPPED_DETECTOR_I("HyperX Quadcast S", DetectHyperXQuadcastSControllers, HYPERX_VID,    HYPERX_QS_PID,      0);//, 0xFF90, 0xFF00);
+REGISTER_HID_WRAPPED_DETECTOR_I("HyperX Quadcast S", DetectHyperXQuadcastSControllers, HYPERX_HP_VID, HYPERX_QS_PID_HP_1, 0);//, 0xFF90, 0xFF00);
+REGISTER_HID_WRAPPED_DETECTOR_I("HyperX Quadcast S", DetectHyperXQuadcastSControllers, HYPERX_HP_VID, HYPERX_QS_PID_HP_2, 0);//, 0xFF90, 0xFF00);

Controllers/HyperXQuadcastController/RGBController_HyperXQuadcastS.cpp

@@ -0,0 +1,152 @@
+/*-----------------------------------------*\
+|  RGBController_HyperXQuadcastS.cpp        |
+|                                           |
+|  Implementation for the HyperX            |
+|  Quadcast S RGB microphone                |
+|                                           |
+|  Matt Silva (thesilvanator) 2022          |
+\*-----------------------------------------*/
+
+/**------------------------------------------------------------------*\
+    @name HyperX Quadcast S
+    @type USB
+    @save :white_check_mark:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectHyperXQuadcastSControllers
+    @comment The HyperX Quadcast S has a manufacturer issue
+    with the interface it uses (0) for controlling its RGB.
+    HID requires that any HID interface have at least one
+    Interrupt IN endpoint; however, the HXQS does not,
+    even though its interface reports itelf as hid and
+    responds to hid requests. As such Linux doesn't bind
+    to the usbhid driver and it goes undetected by
+    hidapi-hidraw. Windows does detect it as hid and hidapi
+    finds and interacts with it just fine. To work around
+    the Linux issue, hidapi-libusb is loaded dynamically
+    using dlopen/dlsym as hidapi using a libusb backend is
+    able to find the device and interact with it. This
+    requires that you have support for dlopen/dlsym on your
+    Linux platform as well as hidapi-libusb (and libusb)
+    libraries installed in the standard dynamic library
+    path.
+
+    The controller for this device has a wrapper for hidapi
+    functions so that the controller can be the same across
+    all platforms, but call the correct underlying functions
+    that are defined in the detector under an #ifdef
+    for that platform.
+
+    Additionally, hidapi-libusb has an error that causes
+    hid_close() to hang on this device, see:
+    https://github.com/libusb/hidapi/issues/456
+    This will be fixed on newer versions of hidapi-libusb,
+    but until then, OpenRGB will hang/crash if you try to
+    rescan devices once a HXQS has been detected during
+    program session.
+\*-------------------------------------------------------------------*/
+
+#include "RGBController_HyperXQuadcastS.h"
+#include <LogManager.h>
+
+using namespace std::chrono_literals;
+
+RGBController_HyperXQuadcastS::RGBController_HyperXQuadcastS(HyperXQuadcastSController* controller_ptr)
+{
+    controller              = controller_ptr;
+
+    name                    = "HyperX QuadcastS Device";
+    vendor                  = "HyperX";
+    type                    = DEVICE_TYPE_MICROPHONE;
+    description             = "HyperX QuadcastS Device";
+    location                = controller->GetDeviceLocation();
+    serial                  = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name             = "Direct";
+    Direct.flags            = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Direct.color_mode       = MODE_COLORS_PER_LED;
+    Direct.brightness_min   = 0;
+    Direct.brightness_max   = 100;
+    modes.push_back(Direct);
+
+    SetupZones();
+
+    keepalive_thread_run    = 1;
+    keepalive_thread        = new std::thread(&RGBController_HyperXQuadcastS::KeepaliveThread, this);
+};
+
+RGBController_HyperXQuadcastS::~RGBController_HyperXQuadcastS()
+{
+    keepalive_thread_run = 0;
+    keepalive_thread->join();
+    delete keepalive_thread;
+
+    delete controller;
+}
+
+void RGBController_HyperXQuadcastS::SetupZones()
+{
+    led* Top        = new led();
+    led* Bot        = new led();
+    Top->name       = std::string("Top");
+    Top->value      = 0;
+    Bot->name       = std::string("Bottom");
+    Bot->value      = 1;
+    leds.push_back(*Top);
+    leds.push_back(*Bot);
+
+    zone* Mic       = new zone();
+    Mic->name       = std::string("Microphone");
+    Mic->type       = ZONE_TYPE_LINEAR;
+    Mic->leds_min   = 2;
+    Mic->leds_max   = 2;
+    Mic->leds_count = 2;
+    Mic->matrix_map = NULL;
+    zones.push_back(*Mic);
+
+    SetupColors();
+}
+
+void RGBController_HyperXQuadcastS::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_HyperXQuadcastS::DeviceUpdateLEDs()
+{
+    last_update_time = std::chrono::steady_clock::now();
+    controller->SendDirect(colors);
+}
+void RGBController_HyperXQuadcastS::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+void RGBController_HyperXQuadcastS::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+void RGBController_HyperXQuadcastS::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_HyperXQuadcastS::DeviceSaveMode()
+{
+    LOG_DEBUG("[%s] Saving current direct colors to device", name.c_str());
+    controller->SaveColors(colors,1);
+}
+
+void RGBController_HyperXQuadcastS::KeepaliveThread()
+{
+    while(keepalive_thread_run.load())
+    {
+        if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50))
+        {
+            UpdateLEDs();
+        }
+        std::this_thread::sleep_for(15ms);
+    }
+}

Controllers/HyperXQuadcastController/RGBController_HyperXQuadcastS.h

@@ -0,0 +1,40 @@
+/*-----------------------------------------*\
+|  RGBController_HyperXQuadcastS.h          |
+|                                           |
+|  Implementation for the HyperX            |
+|  Quadcast S RGB microphone                |
+|                                           |
+|  Matt Silva (thesilvanator) 2022          |
+\*-----------------------------------------*/
+
+#pragma once
+#include <chrono>
+
+#include "RGBController.h"
+#include "HyperXQuadcastSController.h"
+
+class RGBController_HyperXQuadcastS : public RGBController
+{
+public:
+    RGBController_HyperXQuadcastS(HyperXQuadcastSController* controller_ptr);
+    ~RGBController_HyperXQuadcastS();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+    void        KeepaliveThread();
+
+private:
+    HyperXQuadcastSController*                          controller;
+    std::thread*                                        keepalive_thread;
+    std::atomic<bool>                                   keepalive_thread_run;
+    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
+};

Controllers/IonicoController/IonicoController.cpp

@@ -0,0 +1,112 @@
+/*-----------------------------------------*\
+|  IonicoController.cpp                     |
+|                                           |
+|  Driver for the Ionico-II-17 lighting     |
+|  controller                               |
+|                                           |
+|  Lucas Strafe 31/12/2022                  |
+\*-----------------------------------------*/
+#include "IonicoController.h"
+#include <string.h>
+
+IonicoController::IonicoController(hid_device* dev_handle, const hid_device_info& info, const unsigned short pid)
+{
+    dev                 = dev_handle;
+    location            = info.path;
+    usb_pid             = pid;
+}
+
+IonicoController::~IonicoController()
+{
+    hid_close(dev);
+}
+
+std::string IonicoController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+uint16_t IonicoController::GetUSBPID()
+{
+    return(usb_pid);
+}
+
+void IonicoController::TurnOff()
+{
+    uint8_t usb_buf[IONICO_REPORT_SIZE];
+    memset(usb_buf, 0x00, IONICO_REPORT_SIZE);
+    usb_buf[1] = 0x09;
+    usb_buf[2] = 0x02;
+    hid_send_feature_report(dev, usb_buf, IONICO_REPORT_SIZE);
+}
+
+void IonicoController::SaveBios()
+{
+    uint8_t usb_buf[IONICO_REPORT_SIZE];
+    memset(usb_buf, 0x00, IONICO_REPORT_SIZE);
+    usb_buf[1] = 0x1A;
+    usb_buf[3] = 0x01;
+    usb_buf[4] = 0x04;
+    usb_buf[8] = 0x01;
+    hid_send_feature_report(dev, usb_buf, IONICO_REPORT_SIZE);
+}
+
+void IonicoController::SetMode(uint8_t mode_value, uint8_t brightness, uint8_t speed)
+{
+    uint8_t usb_buf[IONICO_REPORT_SIZE];
+    memset(usb_buf, 0x00, IONICO_REPORT_SIZE);
+    usb_buf[1] = 0x08;
+    usb_buf[2] = 0x02;
+    usb_buf[3] = mode_value;
+    usb_buf[4] = speed;
+    usb_buf[5] = brightness;
+    usb_buf[6] = 0x08;
+    hid_send_feature_report(dev, usb_buf, IONICO_REPORT_SIZE);
+}
+
+void IonicoController::SetColors(int device, std::vector<RGBColor> array_colors, bool is_mode)
+{
+    /*---------------------------------------------------------*\
+    |                   Direct mode and effects                 |
+    \*---------------------------------------------------------*/
+    if(device == DEVICE_TYPE_KEYBOARD || (device == DEVICE_TYPE_LEDSTRIP && is_mode))
+    {
+        uint8_t usb_buf[IONICO_REPORT_SIZE];
+        memset(usb_buf, 0x00, IONICO_REPORT_SIZE);
+        for(int i = 0; i < array_colors.size(); i++)
+        {
+            usb_buf[1] = IONICO_DIRECT_CMD;
+            usb_buf[3] = i+1;
+            usb_buf[4] = RGBGetRValue(array_colors[i]);
+            usb_buf[5] = RGBGetGValue(array_colors[i]);
+            usb_buf[6] = RGBGetBValue(array_colors[i]);
+            hid_send_feature_report(dev, usb_buf, IONICO_REPORT_SIZE);
+        }
+    }
+    /*---------------------------------------------------------*\
+    |                 LIGHT BAR LED PER LED                     |
+    \*---------------------------------------------------------*/
+    else if(device == DEVICE_TYPE_LEDSTRIP && !is_mode)
+    {
+        uint8_t usb_buf[IONICO_REPORT_SIZE];
+        memset(usb_buf, 0x00, IONICO_REPORT_SIZE);
+        usb_buf[1] = 0x12;
+        hid_send_feature_report(dev, usb_buf, IONICO_REPORT_SIZE);
+
+        uint8_t usb_buf_led[IONICO_DIRECT_REPORT_SIZE];
+        memset(usb_buf_led, 0x00, IONICO_DIRECT_REPORT_SIZE);
+
+        for(int i = 0; i < array_colors.size(); i++)
+        {
+           usb_buf_led[1 + 3 * i] = RGBGetRValue(array_colors[i]);
+           usb_buf_led[2 + 3 * i] = RGBGetBValue(array_colors[i]);
+           usb_buf_led[3 + 3 * i] = RGBGetGValue(array_colors[i]);
+        }
+        hid_write(dev, usb_buf_led, IONICO_DIRECT_REPORT_SIZE);
+
+        memset(usb_buf, 0x00, IONICO_REPORT_SIZE);
+        usb_buf[1] = 0x12;
+        usb_buf[3] = 0x01;
+        hid_send_feature_report(dev, usb_buf, IONICO_REPORT_SIZE);
+    }
+}

Controllers/IonicoController/IonicoController.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "RGBController.h"
+#include <string>
+#include <hidapi/hidapi.h>
+
+#define IONICO_REPORT_SIZE                9
+#define IONICO_DIRECT_REPORT_SIZE         65
+#define IONICO_DIRECT_CMD                 0x14
+#define IONICO_KEYBOARD_LED_COUNT         4
+#define IONICO_BAR_LED_COUNT              22
+#define IONICO_DIRECT_BRIGHTNESS_MIN      0
+#define IONICO_DIRECT_BRIGHTNESS_MAX      50
+#define IONICO_DIRECT_SPEED_MIN           0
+#define IONICO_DIRECT_SPEED_MAX           10
+#define IONICO_DIRECT_SPEED_DEFAULT       5
+
+enum
+{
+    IONICO_MODE_OFF             = 0,
+    IONICO_MODE_DIRECT          = 1,
+    IONICO_MODE_BREATHING       = 2,
+    IONICO_MODE_WAVE            = 3,
+    IONICO_MODE_RAIN            = 10,
+    IONICO_MODE_FLASH           = 18,
+    IONICO_FB_MODE_WAVE         = 32
+};
+
+
+class IonicoController
+{
+    public:
+        IonicoController(hid_device* dev_handle, const hid_device_info& info, const unsigned short pid);
+        ~IonicoController();
+
+        std::string GetDeviceLocation();
+
+        void        SetMode(uint8_t mode_value, uint8_t brightness, uint8_t speed);
+        void        SetColors(int device, std::vector<RGBColor> array_colors, bool is_mode);
+        void        SaveBios();
+        void        TurnOff();
+        uint16_t    GetUSBPID();
+
+    private:
+        hid_device* dev;
+        std::string location;
+        std::string serial_number;
+        std::string version;
+        uint16_t    usb_pid;
+};

Controllers/IonicoController/IonicoControllerDetect.cpp

@@ -0,0 +1,52 @@
+/*-----------------------------------------*\
+|  IonicoControllerDetect.cpp               |
+|                                           |
+|  Driver for the Ionico-II-17 lighting     |
+|  controller                               |
+|                                           |
+|  Lucas Strafe 31/12/2022                  |
+\*-----------------------------------------*/
+
+#include "Detector.h"
+#include "RGBController.h"
+#include "hidapi/hidapi.h"
+#include "IonicoController.h"
+#include "RGBController_Ionico.h"
+
+/*-----------------------------------------------------*\
+|                     FRONT BAR                         |
+\*-----------------------------------------------------*/
+#define IONICO_FB_VID        0x048D
+#define IONICO_FB_PID        0x6005
+
+/*-----------------------------------------------------*\
+|                     KEYBOARD                          |
+\*-----------------------------------------------------*/
+#define IONICO_KB_VID        0x048D
+#define IONICO_KB_PID        0xCE00
+
+
+void DetectIonicoControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        IonicoController*     controller         = new IonicoController(dev, *info, info->product_id);
+        RGBController_Ionico* rgb_controller     = new RGBController_Ionico(controller);
+        rgb_controller->name                     = name;
+
+        if(info->product_id == IONICO_KB_PID)
+        {
+            rgb_controller->type = DEVICE_TYPE_KEYBOARD;
+        }
+        else if(info->product_id == IONICO_FB_PID)
+        {
+            rgb_controller->type = DEVICE_TYPE_LEDSTRIP;
+        }
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_PU("Ionico Light Bar", DetectIonicoControllers, IONICO_FB_VID, IONICO_FB_PID,  0xFF03, 0x01);
+REGISTER_HID_DETECTOR_PU("Ionico Keyboard", DetectIonicoControllers, IONICO_KB_VID, IONICO_KB_PID,  0xFF12, 0x01);

Controllers/IonicoController/RGBController_Ionico.cpp

@@ -0,0 +1,222 @@
+/*-----------------------------------------*\
+|  RGBController_Ionico.cpp                 |
+|                                           |
+|  Driver for the Ionico-II-17 lighting     |
+|  controller                               |
+|                                           |
+|  Lucas Strafe 31/12/2022                  |
+\*-----------------------------------------*/
+
+#include "RGBController_Ionico.h"
+
+/**------------------------------------------------------------------*\
+    @name Ionico-II 17
+    @category Keyboard,LEDStrip
+    @type USB
+    @save :white_check_mark:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectIonicoControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+
+RGBController_Ionico::RGBController_Ionico(IonicoController* controller_ptr)
+{
+    controller                          = controller_ptr;
+    name                                = "Ionico";
+    vendor                              = "Pcspecialist";
+    description                         = name;
+    location                            = controller->GetDeviceLocation();
+
+    mode Direct;
+    Direct.name                         = "Direct";
+    Direct.value                        = IONICO_MODE_DIRECT;
+    Direct.flags                        = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Direct.color_mode                   = MODE_COLORS_PER_LED;
+    Direct.brightness_min               = IONICO_DIRECT_BRIGHTNESS_MIN;
+    Direct.brightness_max               = IONICO_DIRECT_BRIGHTNESS_MAX;
+    Direct.brightness                   = IONICO_DIRECT_BRIGHTNESS_MAX;
+    Direct.colors.resize(4);
+    modes.push_back(Direct);
+
+    mode Breathing;
+    Breathing.name                         = "Breathing";
+    Breathing.value                        = IONICO_MODE_BREATHING;
+    Breathing.flags                        = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Breathing.color_mode                   = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed_min                    = IONICO_DIRECT_SPEED_MIN;
+    Breathing.speed_max                    = IONICO_DIRECT_SPEED_MAX;
+    Breathing.speed                        = IONICO_DIRECT_SPEED_DEFAULT;
+    Breathing.brightness_min               = IONICO_DIRECT_BRIGHTNESS_MIN;
+    Breathing.brightness_max               = IONICO_DIRECT_BRIGHTNESS_MAX;
+    Breathing.brightness                   = IONICO_DIRECT_BRIGHTNESS_MAX;
+    Breathing.colors.resize(7);
+    modes.push_back(Breathing);
+
+    mode Wave;
+    Wave.name                         = "Wave";
+    if(controller->GetUSBPID() == IONICO_KB_PID)
+    {
+        Wave.value    = IONICO_MODE_WAVE;
+    }
+    else if(controller->GetUSBPID() == IONICO_FB_PID)
+    {
+        Wave.value    = IONICO_FB_MODE_WAVE;
+    }
+    Wave.flags                        = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Wave.color_mode                   = MODE_COLORS_MODE_SPECIFIC;
+    Wave.speed_min                    = IONICO_DIRECT_SPEED_MIN;
+    Wave.speed_max                    = IONICO_DIRECT_SPEED_MAX;
+    Wave.speed                        = IONICO_DIRECT_SPEED_DEFAULT;
+    Wave.brightness_min               = IONICO_DIRECT_BRIGHTNESS_MIN;
+    Wave.brightness_max               = IONICO_DIRECT_BRIGHTNESS_MAX;
+    Wave.brightness                   = IONICO_DIRECT_BRIGHTNESS_MAX;
+    Wave.colors.resize(7);
+    modes.push_back(Wave);
+
+    if(controller->GetUSBPID() == IONICO_KB_PID)
+    {
+        mode Flash;
+        Flash.name                         = "Flashing";
+        Flash.value                        = IONICO_MODE_FLASH;
+        Flash.flags                        = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+        Flash.color_mode                   = MODE_COLORS_MODE_SPECIFIC;
+        Flash.speed_min                    = IONICO_DIRECT_SPEED_MIN;
+        Flash.speed_max                    = IONICO_DIRECT_SPEED_MAX;
+        Flash.speed                        = IONICO_DIRECT_SPEED_DEFAULT;
+        Flash.brightness_min               = IONICO_DIRECT_BRIGHTNESS_MIN;
+        Flash.brightness_max               = IONICO_DIRECT_BRIGHTNESS_MAX;
+        Flash.brightness                   = IONICO_DIRECT_BRIGHTNESS_MAX;
+        Flash.colors.resize(7);
+        modes.push_back(Flash);
+    }
+
+    if(controller->GetUSBPID() == IONICO_FB_PID)
+    {
+        mode Raindrops;
+        Raindrops.name                         = "Raindrops";
+        Raindrops.value                        = IONICO_MODE_RAIN;
+        Raindrops.flags                        = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+        Raindrops.color_mode                   = MODE_COLORS_MODE_SPECIFIC;
+        Raindrops.speed_min                    = IONICO_DIRECT_SPEED_MIN;
+        Raindrops.speed_max                    = IONICO_DIRECT_SPEED_MAX;
+        Raindrops.speed                        = IONICO_DIRECT_SPEED_DEFAULT;
+        Raindrops.brightness_min               = IONICO_DIRECT_BRIGHTNESS_MIN;
+        Raindrops.brightness_max               = IONICO_DIRECT_BRIGHTNESS_MAX;
+        Raindrops.brightness                   = IONICO_DIRECT_BRIGHTNESS_MAX;
+        Raindrops.colors.resize(7);
+        modes.push_back(Raindrops);
+    }
+
+    mode Off;
+    Off.name                            = "Off";
+    modes.push_back(Off);
+
+    SetupZones();
+}
+
+RGBController_Ionico::~RGBController_Ionico()
+{
+    delete controller;
+}
+
+void RGBController_Ionico::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    if(controller->GetUSBPID() == IONICO_KB_PID)
+    {
+        leds.resize(IONICO_KEYBOARD_LED_COUNT);
+        zone zone_keyboard;
+        zone_keyboard.name       = "Keyboard";
+        zone_keyboard.type       = ZONE_TYPE_LINEAR;
+        zone_keyboard.leds_min   = leds.size();
+        zone_keyboard.leds_max   = leds.size();
+        zone_keyboard.leds_count = leds.size();
+        zone_keyboard.matrix_map = nullptr;
+        zones.emplace_back(zone_keyboard);
+        for(int i = 0; i < leds.size(); ++i)
+        {
+            leds[i].name = "Keyboard Zone " + std::to_string(i+1);
+        }
+    }
+    else if(controller->GetUSBPID() == IONICO_FB_PID)
+    {
+        leds.resize(IONICO_BAR_LED_COUNT);
+        zone zone_bar;
+        zone_bar.name       = "Front Bar";
+        zone_bar.type       = ZONE_TYPE_LINEAR;
+        zone_bar.leds_min   = leds.size();
+        zone_bar.leds_max   = leds.size();
+        zone_bar.leds_count = leds.size();
+        zone_bar.matrix_map = nullptr;
+        zones.emplace_back(zone_bar);
+        for(int i = 0; i < leds.size(); ++i)
+        {
+            leds[i].name = "Bar Led " + std::to_string(i+1);
+        }
+    }
+    SetupColors();
+}
+
+void RGBController_Ionico::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_Ionico::DeviceUpdateLEDs()
+{
+    /*---------------------------------------------------------*\
+    |                   MODE_COLORS_PER_LED                     |
+    \*---------------------------------------------------------*/
+    controller->SetColors(type, colors, false);
+}
+
+void RGBController_Ionico::DeviceSaveMode()
+{
+    controller->SaveBios();
+}
+
+void RGBController_Ionico::UpdateZoneLEDs(int zone)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_Ionico::UpdateSingleLED(int led)
+{
+    //
+}
+
+void RGBController_Ionico::DeviceUpdateMode()
+{
+    switch (modes[active_mode].value)
+    {
+    case IONICO_MODE_OFF:
+        controller->TurnOff();
+        break;
+    case IONICO_MODE_DIRECT:
+        if(type == DEVICE_TYPE_LEDSTRIP)
+        {
+            controller->SetMode(0x33, modes[active_mode].brightness, 0);
+        }
+        else
+        {
+            controller->SetMode(modes[active_mode].value, modes[active_mode].brightness, 0);
+        }
+        break;
+    default:
+        controller->SetMode(modes[active_mode].value, modes[active_mode].brightness, modes[active_mode].speed);
+        controller->SetColors(type, modes[active_mode].colors, true);
+        break;
+    }
+}

Controllers/IonicoController/RGBController_Ionico.h

@@ -0,0 +1,37 @@
+/*-----------------------------------------*\
+|  RGBController_Ionico.h                   |
+|                                           |
+|  Driver for the Ionico-II-17 lighting     |
+|  controller                               |
+|                                           |
+|  Lucas Strafe 31/12/2022                  |
+\*-----------------------------------------*/
+#pragma once
+
+#include "RGBController.h"
+#include "IonicoController.h"
+
+#define IONICO_KB_PID   0xCE00
+#define IONICO_FB_PID   0x6005
+
+class RGBController_Ionico : public RGBController
+{
+public:
+    RGBController_Ionico(IonicoController* controller_ptr);
+    ~RGBController_Ionico();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void SetSingleLED();
+    void UpdateSingleLED(int led);
+    void DeviceSaveMode();
+
+    void DeviceUpdateMode();
+
+
+private:
+    IonicoController* controller;
+};

Controllers/LEDStripController/LEDStripControllerDetect.cpp

@@ -15,7 +15,7 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectLEDStripControllers(std::vector<RGBController*> &rgb_controllers)
+void DetectLEDStripControllers()
 {
     json                    ledstrip_settings;
     LEDStripDevice          dev;
@@ -88,7 +88,7 @@ void DetectLEDStripControllers(std::vector<RGBController*> &rgb_controllers)
             RGBController_LEDStrip* rgb_controller = new RGBController_LEDStrip(controller);
             rgb_controller->name                   = dev.name;
 
-            rgb_controllers.push_back(rgb_controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
     }
 

Controllers/LIFXController/LIFXControllerDetect.cpp

@@ -15,7 +15,7 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectLIFXControllers(std::vector<RGBController*> &rgb_controllers)
+void DetectLIFXControllers()
 {
     json                    lifx_settings;
 
@@ -39,7 +39,7 @@ void DetectLIFXControllers(std::vector<RGBController*> &rgb_controllers)
                 LIFXController*     controller     = new LIFXController(lifx_ip, name);
                 RGBController_LIFX* rgb_controller = new RGBController_LIFX(controller);
 
-                rgb_controllers.push_back(rgb_controller);
+                ResourceManager::get()->RegisterRGBController(rgb_controller);
             }
         }
     }

Controllers/LenovoControllers/RGBController_LenovoUSB.cpp

@@ -156,14 +156,14 @@ RGBController_LenovoUSB::RGBController_LenovoUSB(LenovoUSBController* controller
             break;
 
         case LEGION_Y760S:
-            response = controller->getInformation(0x02);
+            response = controller->getInformation(0x01);
             if(response.size() > 4)
             {
-                if(response[4] == 41)
+                if(response[4] == 0x97)
                 {
                     keyboard_type = JAPAN;
                 }
-                else if(response[4] >= 16 && response[4] <=40)
+                else if(response[4] == 0x8F)
                 {
                     keyboard_type = ISO;
                 }
@@ -306,12 +306,7 @@ void RGBController_LenovoUSB::SetupZones()
             new_zone.matrix_map         = new matrix_map_type;
             new_zone.matrix_map->height = lenovo_zones[i].height;
             new_zone.matrix_map->width  = lenovo_zones[i].width;
-            new_zone.matrix_map->map    = new unsigned int[new_zone.matrix_map->height * new_zone.matrix_map->width];
-
-            if(lenovo_zones[i].matrix_map != NULL)
-            {
-                new_zone.matrix_map->map = (unsigned int *) lenovo_zones[i].matrix_map;
-            }
+            new_zone.matrix_map->map    = (unsigned int *) lenovo_zones[i].matrix_map;
         }
         else
         {

Controllers/LenovoMotherboardController/LenovoMotherboardController.cpp

@@ -0,0 +1,90 @@
+/*-----------------------------------------*\
+|  LenovoMotherboardController.cpp          |
+|                                           |
+|  Driver for Lenovo motherboards lighting  |
+|  controller                               |
+|                                           |
+|  Guimard Morgan (morg) 12/26/2022         |
+\*-----------------------------------------*/
+#include "LenovoMotherboardController.h"
+#include <string.h>
+
+LenovoMotherboardController::LenovoMotherboardController(hid_device* dev_handle, const hid_device_info& info)
+{
+    dev                 = dev_handle;
+    location            = info.path;
+    version             = "";
+
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        serial_number = "";
+    }
+    else
+    {
+        std::wstring return_wstring = serial_string;
+        serial_number = std::string(return_wstring.begin(), return_wstring.end());
+    }
+}
+
+LenovoMotherboardController::~LenovoMotherboardController()
+{
+    hid_close(dev);
+}
+
+std::string LenovoMotherboardController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string LenovoMotherboardController::GetSerialString()
+{
+    return(serial_number);
+}
+
+std::string LenovoMotherboardController::GetFirmwareVersion()
+{
+    return(version);
+}
+
+void LenovoMotherboardController::SetMode(uint8_t zone, uint8_t mode, uint8_t brightness, uint8_t speed, RGBColor color)
+{
+    uint8_t r = RGBGetRValue(color);
+    uint8_t g = RGBGetGValue(color);
+    uint8_t b = RGBGetBValue(color);
+
+    uint8_t buffer[LENOVO_MB_PACKET_LENGTH];
+    memset(buffer, 0x00, LENOVO_MB_PACKET_LENGTH);
+
+    buffer[0]   = LENOVO_MB_REPORT_ID;
+
+    buffer[1]   = zone;
+    buffer[2]   = mode;
+    buffer[3]   = speed;
+    buffer[4]   = brightness;
+
+    buffer[5]   = r;
+    buffer[6]   = g;
+    buffer[7]   = b;
+
+    hid_send_feature_report(dev, buffer, LENOVO_MB_PACKET_LENGTH);
+
+    memset(buffer, 0x00, LENOVO_MB_PACKET_LENGTH);
+
+    buffer[0]   = LENOVO_MB_REPORT_ID;
+    buffer[1]   = 0x28;
+    buffer[2]   = 0x06;
+
+    buffer[33]  = zone;
+    buffer[34]  = mode;
+    buffer[35]  = speed;
+    buffer[36]  = brightness;
+
+    buffer[37]  = r;
+    buffer[38]  = g;
+    buffer[39]  = b;
+
+    hid_send_feature_report(dev, buffer, LENOVO_MB_PACKET_LENGTH);
+}

Controllers/LenovoMotherboardController/LenovoMotherboardController.h

@@ -0,0 +1,57 @@
+/*-----------------------------------------*\
+|  LenovoMotherboardController.cpp          |
+|                                           |
+|  Driver for Lenovo motherboards lighting  |
+|  controller - header file                 |
+|                                           |
+|  Guimard Morgan (morg) 12/26/2022         |
+\*-----------------------------------------*/
+#pragma once
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
+#define LENOVO_MB_PACKET_LENGTH     64
+#define LENOVO_MB_REPORT_ID         0xCC
+#define LENOVO_MB_NUMBER_OF_LEDS    2
+#define LENOVO_MB_ZONE_1_VALUE      0x12
+#define LENOVO_MB_ZONE_2_VALUE      0x11
+
+enum
+{
+    LENOVO_MB_STATIC_MODE       = 0x01,
+    LENOVO_MB_SPARKLE_MODE      = 0x02,
+    LENOVO_MB_BREATHING_MODE    = 0x03,
+    LENOVO_MB_WAVE_MODE         = 0x04,
+    LENOVO_MB_SPECTER_MODE      = 0x06,
+    LENOVO_MB_RAINBOW_WAVE_MODE = 0x09,
+    LENOVO_MB_RANDOM_MODE       = 0x0A
+};
+
+enum
+{
+    LENOVO_MB_BRIGHTNESS_MIN    = 1,
+    LENOVO_MB_BRIGHTNESS_MAX    = 4,
+    LENOVO_MB_SPEED_MIN         = 1,
+    LENOVO_MB_SPEED_MAX         = 4,
+};
+
+class LenovoMotherboardController
+{
+public:
+    LenovoMotherboardController(hid_device* dev_handle, const hid_device_info& info);
+    ~LenovoMotherboardController();
+
+    std::string GetSerialString();
+    std::string GetDeviceLocation();
+    std::string GetFirmwareVersion();
+
+    void SetMode(uint8_t zone, uint8_t mode, uint8_t brightness, uint8_t speed, RGBColor color);
+
+private:
+    hid_device* dev;
+    std::string location;
+    std::string serial_number;
+    std::string version;
+};

Controllers/LenovoMotherboardController/LenovoMotherboardControllerDetect.cpp

@@ -0,0 +1,33 @@
+#include "Detector.h"
+#include "LenovoMotherboardController.h"
+#include "RGBController.h"
+#include "RGBController_LenovoMotherboard.h"
+#include "dependencies/dmiinfo.h"
+
+/*---------------------------------------------------------*\
+| vendor ID                                                 |
+\*---------------------------------------------------------*/
+#define LENOVO_MB_VID                                  0x17EF
+
+/*---------------------------------------------------------*\
+| Product ID                                                |
+\*---------------------------------------------------------*/
+#define LENOVO_MB_PID                                  0xC955
+
+void DetectLenovoMotherboardControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        DMIInfo dmi;
+
+        LenovoMotherboardController*     controller         = new LenovoMotherboardController(dev, *info);
+        RGBController_LenovoMotherboard* rgb_controller     = new RGBController_LenovoMotherboard(controller);
+        rgb_controller->name                                = name + " " + dmi.getMainboard();
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_PU("Lenovo", DetectLenovoMotherboardControllers, LENOVO_MB_VID, LENOVO_MB_PID, 0xFF89, 0xCC);

Controllers/LenovoMotherboardController/RGBController_LenovoMotherboard.cpp

@@ -0,0 +1,203 @@
+/*-----------------------------------------*\
+|  RGBController_LenovoMotherboard.h        |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Lenovo motherboards RGB USB Driver       |
+|                                           |
+|  Guimard Morgan (morg) 12/26/2022         |
+\*-----------------------------------------*/
+
+#include "RGBController_LenovoMotherboard.h"
+
+#include <thread>
+#include <chrono>
+
+/**------------------------------------------------------------------*\
+    @name LenovoMotherboard mouse
+    @category Motherboard
+    @type USB
+    @save :x:
+    @direct :x:
+    @effects :white_check_mark:
+    @detectors DetectLenovoMotherboardControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_LenovoMotherboard::RGBController_LenovoMotherboard(LenovoMotherboardController* controller_ptr)
+{
+    controller                  = controller_ptr;
+    name                        = "Lenovo motherboard";
+    vendor                      = "Lenovo";
+    type                        = DEVICE_TYPE_MOTHERBOARD;
+    description                 = name;
+    location                    = controller->GetDeviceLocation();
+    serial                      = controller->GetSerialString();
+    version                     = controller->GetFirmwareVersion();
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = LENOVO_MB_STATIC_MODE;
+    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Static.color_mode           = MODE_COLORS_PER_LED;
+    Static.brightness_min       = LENOVO_MB_BRIGHTNESS_MIN;
+    Static.brightness_max       = LENOVO_MB_BRIGHTNESS_MAX;
+    Static.brightness           = LENOVO_MB_BRIGHTNESS_MAX;
+    Static.speed                = LENOVO_MB_SPEED_MIN;
+    modes.push_back(Static);
+
+    mode Sparkle;
+    Sparkle.name                = "Sparkle";
+    Sparkle.value               = LENOVO_MB_SPARKLE_MODE;
+    Sparkle.flags               = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Sparkle.color_mode          = MODE_COLORS_PER_LED;
+    Sparkle.brightness_min      = LENOVO_MB_BRIGHTNESS_MIN;
+    Sparkle.brightness_max      = LENOVO_MB_BRIGHTNESS_MAX;
+    Sparkle.brightness          = LENOVO_MB_BRIGHTNESS_MAX;
+    Sparkle.speed               = LENOVO_MB_SPEED_MIN;
+    Sparkle.speed_max           = LENOVO_MB_SPEED_MAX;
+    Sparkle.speed_min           = LENOVO_MB_SPEED_MIN;
+    modes.push_back(Sparkle);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = LENOVO_MB_BREATHING_MODE;
+    Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Breathing.color_mode        = MODE_COLORS_PER_LED;
+    Breathing.brightness_min    = LENOVO_MB_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = LENOVO_MB_BRIGHTNESS_MAX;
+    Breathing.brightness        = LENOVO_MB_BRIGHTNESS_MAX;
+    Breathing.speed             = LENOVO_MB_SPEED_MIN;
+    Breathing.speed_max         = LENOVO_MB_SPEED_MAX;
+    Breathing.speed_min         = LENOVO_MB_SPEED_MIN;
+    modes.push_back(Breathing);
+
+    mode Wave;
+    Wave.name                   = "Wave";
+    Wave.value                  = LENOVO_MB_WAVE_MODE;
+    Wave.flags                  = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Wave.color_mode             = MODE_COLORS_NONE;
+    Wave.brightness_min         = LENOVO_MB_BRIGHTNESS_MIN;
+    Wave.brightness_max         = LENOVO_MB_BRIGHTNESS_MAX;
+    Wave.brightness             = LENOVO_MB_BRIGHTNESS_MAX;
+    Wave.speed                  = LENOVO_MB_SPEED_MIN;
+    Wave.speed_max              = LENOVO_MB_SPEED_MAX;
+    Wave.speed_min              = LENOVO_MB_SPEED_MIN;
+    modes.push_back(Wave);
+
+    mode Specter;
+    Specter.name                = "Specter";
+    Specter.value               = LENOVO_MB_SPECTER_MODE;
+    Specter.flags               = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Specter.color_mode          = MODE_COLORS_PER_LED;
+    Specter.brightness_min      = LENOVO_MB_BRIGHTNESS_MIN;
+    Specter.brightness_max      = LENOVO_MB_BRIGHTNESS_MAX;
+    Specter.brightness          = LENOVO_MB_BRIGHTNESS_MAX;
+    Specter.speed               = LENOVO_MB_SPEED_MIN;
+    Specter.speed_max           = LENOVO_MB_SPEED_MAX;
+    Specter.speed_min           = LENOVO_MB_SPEED_MIN;
+    modes.push_back(Specter);
+
+    mode Rainbow;
+    Rainbow.name                = "Rainbow wave";
+    Rainbow.value               = LENOVO_MB_RAINBOW_WAVE_MODE;
+    Rainbow.flags               = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    Rainbow.brightness_min      = LENOVO_MB_BRIGHTNESS_MIN;
+    Rainbow.brightness_max      = LENOVO_MB_BRIGHTNESS_MAX;
+    Rainbow.brightness          = LENOVO_MB_BRIGHTNESS_MAX;
+    Rainbow.speed               = LENOVO_MB_SPEED_MIN;
+    Rainbow.speed_max           = LENOVO_MB_SPEED_MAX;
+    Rainbow.speed_min           = LENOVO_MB_SPEED_MIN;
+    modes.push_back(Rainbow);
+
+    mode Random;
+    Random.name                 = "Random";
+    Random.value                = LENOVO_MB_RANDOM_MODE;
+    Random.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Random.color_mode           = MODE_COLORS_NONE;
+    Random.brightness_min       = LENOVO_MB_BRIGHTNESS_MIN;
+    Random.brightness_max       = LENOVO_MB_BRIGHTNESS_MAX;
+    Random.brightness           = LENOVO_MB_BRIGHTNESS_MAX;
+    Random.speed                = LENOVO_MB_SPEED_MIN;
+    Random.speed_max            = LENOVO_MB_SPEED_MAX;
+    Random.speed_min            = LENOVO_MB_SPEED_MIN;
+    modes.push_back(Random);
+
+    SetupZones();
+}
+
+RGBController_LenovoMotherboard::~RGBController_LenovoMotherboard()
+{
+    delete controller;
+}
+
+void RGBController_LenovoMotherboard::SetupZones()
+{
+    zone cpu_fan_zone;
+
+    cpu_fan_zone.name       = "CPU FAN Zone";
+    cpu_fan_zone.type       = ZONE_TYPE_SINGLE;
+    cpu_fan_zone.leds_min   = 1;
+    cpu_fan_zone.leds_max   = 1;
+    cpu_fan_zone.leds_count = 1;
+    cpu_fan_zone.matrix_map = nullptr;
+
+    zones.emplace_back(cpu_fan_zone);
+
+    zone rear_fan_zone;
+
+    rear_fan_zone.name       = "Rear FAN Zone";
+    rear_fan_zone.type       = ZONE_TYPE_SINGLE;
+    rear_fan_zone.leds_min   = 1;
+    rear_fan_zone.leds_max   = 1;
+    rear_fan_zone.leds_count = 1;
+    rear_fan_zone.matrix_map = nullptr;
+
+    zones.emplace_back(rear_fan_zone);
+
+    leds.resize(LENOVO_MB_NUMBER_OF_LEDS);
+
+    leds[0].name  = "LED 1";
+    leds[0].value = LENOVO_MB_ZONE_1_VALUE;
+
+    leds[1].name  = "LED 2";
+    leds[1].value = LENOVO_MB_ZONE_2_VALUE;
+
+    SetupColors();
+}
+
+void RGBController_LenovoMotherboard::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_LenovoMotherboard::DeviceUpdateLEDs()
+{
+    for(uint8_t i = 0; i < leds.size(); i++)
+    {
+        controller->SetMode(
+                    leds[i].value,
+                    modes[active_mode].value,
+                    modes[active_mode].brightness,
+                    modes[active_mode].speed,
+                    colors[i]
+                    );
+    }
+}
+
+void RGBController_LenovoMotherboard::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_LenovoMotherboard::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_LenovoMotherboard::DeviceUpdateMode()
+{    
+    DeviceUpdateLEDs();
+}

Controllers/LenovoMotherboardController/RGBController_LenovoMotherboard.h

@@ -0,0 +1,32 @@
+/*-----------------------------------------*\
+|  RGBController_LenovoMotherboard.h        |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Lenovo motherboards RGB USB Driver       |
+|                                           |
+|  Guimard Morgan (morg) 12/26/2022         |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "LenovoMotherboardController.h"
+
+class RGBController_LenovoMotherboard : public RGBController
+{
+public:
+    RGBController_LenovoMotherboard(LenovoMotherboardController* controller_ptr);
+    ~RGBController_LenovoMotherboard();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
+
+    void DeviceUpdateMode();
+
+private:
+    LenovoMotherboardController* controller;
+};

Controllers/LianLiController/LianLiControllerDetect.cpp

@@ -30,6 +30,8 @@
 #include "RGBController_LianLiUniHubAL.h"
 #include "LianLiUniHub_AL10Controller.h"
 #include "RGBController_LianLiUniHub_AL10.h"
+#include "LianLiUniHubSLV2Controller.h"
+#include "RGBController_LianLiUniHubSLV2.h"
 
 /*-----------------------------------------------------*\
 | ENE USB vendor ID                                     |
@@ -45,7 +47,8 @@
 | Fan controller product IDs                            |
 \*-----------------------------------------------------*/
 #define UNI_HUB_PID                                 0x7750
-#define UNI_HUB_AL_PID                              0XA101
+#define UNI_HUB_AL_PID                              0xA101
+#define UNI_HUB_SLV2_PID                            0xA103
 
 /*----------------------------------------------------------------------------*\
 | The Uni Hub is controlled by sending control transfers to various wIndex     |
@@ -53,7 +56,7 @@
 | requires libusb as hidapi provides no wIndex customization.                  |
 \*----------------------------------------------------------------------------*/
 
-void DetectLianLiUniHub(std::vector<RGBController*>&)
+void DetectLianLiUniHub()
 {
     libusb_device** devices = nullptr;
 
@@ -99,7 +102,7 @@ void DetectLianLiUniHub(std::vector<RGBController*>&)
     }
 }
 
-void DetectLianLiUniHub_AL10(std::vector<RGBController*>&)
+void DetectLianLiUniHub_AL10()
 {
     libusb_device** devices = nullptr;
 
@@ -174,6 +177,19 @@ void DetectLianLiUniHubAL(hid_device_info* info, const std::string& name)
     }
 }   /* DetectLianLiUniHubAL() */
 
+void DetectLianLiUniHubSLV2(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        LianLiUniHubSLV2Controller* controller = new LianLiUniHubSLV2Controller(dev, info->path, name);
+
+        RGBController_LianLiUniHubSLV2* rgb_controller = new RGBController_LianLiUniHubSLV2(controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}   /* DetectLianLiUniHubSLV2() */
+
 void DetectStrimerControllers(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -190,6 +206,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);
+REGISTER_HID_DETECTOR_IPU("Lian Li Uni Hub - SL V2", DetectLianLiUniHubSLV2,    ENE_USB_VID,  UNI_HUB_SLV2_PID,           0x01,  0xFF72, 0xA1);
 /*---------------------------------------------------------------------------------------------------------*\
 | Entries for dynamic UDEV rules                                                                            |
 |                                                                                                           |

Controllers/LianLiController/LianLiUniHubController.cpp

@@ -647,7 +647,7 @@ std::string LianLiUniHubController::ReadVersion()
     /*-------------------------------------*\
     | Format version string                 |
     \*-------------------------------------*/
-    char version[14];
+    char version[15];
     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));

Controllers/LianLiController/LianLiUniHubSLV2Controller.cpp

@@ -0,0 +1,320 @@
+/*-----------------------------------------*\
+|  LianLiUniHubSLV2Controller.cpp           |
+|                                           |
+|  Driver for Lian Li Uni Hub SLV2 USB      |
+|  lighting controller                      |
+|                                           |
+|  Will Kennedy 01/17/2023					|
+|  Oliver P 04/26/2022                      |
+|  Credit to Luca Lovisa for original work. |
+\*-----------------------------------------*/
+
+#include "LianLiUniHubSLV2Controller.h"
+
+#include <string.h>
+
+using namespace std::chrono_literals;
+
+LianLiUniHubSLV2Controller::LianLiUniHubSLV2Controller(hid_device* dev_handle, const char* path, std::string dev_name)
+{
+    dev             = dev_handle;
+    location        = path;
+    name            = dev_name;
+}
+
+LianLiUniHubSLV2Controller::~LianLiUniHubSLV2Controller()
+{
+    hid_close(dev);
+}
+
+std::string LianLiUniHubSLV2Controller::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string LianLiUniHubSLV2Controller::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 LianLiUniHubSLV2Controller::GetName()
+{
+    return(name);
+}
+
+std::string LianLiUniHubSLV2Controller::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);
+
+}
+
+float brightnessLimit(RGBColor color)
+{
+    /*---------------------------------------------------------*\
+    | Limiter to protect LEDs                                   |
+    \*---------------------------------------------------------*/
+    if(UNIHUB_SLV2_LED_LIMITER && (RGBGetRValue(color) + RGBGetBValue(color) + RGBGetGValue(color) > 460))
+    {
+        return 460.f / (RGBGetRValue(color) + RGBGetBValue(color) + RGBGetGValue(color));
+    }
+    return 1;
+}
+
+void LianLiUniHubSLV2Controller::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors, float brightness)
+{
+    unsigned char   led_data[16 * 6 * 3];
+    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 % 16);
+
+        if((mod_led_idx == 0) && (led_idx != 0))
+        {
+            fan_idx++;
+        }
+
+        float brightness_scale = brightness * brightnessLimit(colors[led_idx]);
+
+        //Determine current position of led_data array from colors array
+        cur_led_idx = ((mod_led_idx + (fan_idx * 16)) * 3);
+
+        led_data[cur_led_idx + 0] = RGBGetRValue(colors[led_idx]) * brightness_scale;
+        led_data[cur_led_idx + 1] = RGBGetBValue(colors[led_idx]) * brightness_scale;
+        led_data[cur_led_idx + 2] = RGBGetGValue(colors[led_idx]) * brightness_scale;
+    }
+
+    /*---------------------------------------------------------*\
+    | Send fan LED data                                         |
+    \*---------------------------------------------------------*/
+
+    SendStartAction
+    (
+        channel,            // Current channel
+        (fan_idx + 1)       // Number of fans
+    );
+
+    SendColorData
+    (
+        channel,            // Channel
+        (fan_idx + 1)*16,
+        led_data
+    );
+
+    SendCommitAction
+    (
+        channel,                                // Channel
+        UNIHUB_SLV2_LED_MODE_STATIC_COLOR,        // Effect
+        UNIHUB_SLV2_LED_SPEED_000,                // Speed
+        UNIHUB_SLV2_LED_DIRECTION_LTR,            // Direction
+        UNIHUB_SLV2_LED_BRIGHTNESS_100            // Brightness
+    );
+
+}
+
+void LianLiUniHubSLV2Controller::SetChannelMode(unsigned char channel, const mode active_mode, unsigned int num_fans)
+{
+    static unsigned int brightness_code[5] =
+    {
+        UNIHUB_SLV2_LED_BRIGHTNESS_000,
+        UNIHUB_SLV2_LED_BRIGHTNESS_025,
+        UNIHUB_SLV2_LED_BRIGHTNESS_050,
+        UNIHUB_SLV2_LED_BRIGHTNESS_075,
+        UNIHUB_SLV2_LED_BRIGHTNESS_100
+    };
+
+    static unsigned int speed_code[5] =
+    {
+        UNIHUB_SLV2_LED_SPEED_000,
+        UNIHUB_SLV2_LED_SPEED_025,
+        UNIHUB_SLV2_LED_SPEED_050,
+        UNIHUB_SLV2_LED_SPEED_075,
+        UNIHUB_SLV2_LED_SPEED_100
+    };
+
+    unsigned char   fan_led_data[16 * 6 * 3];
+    int             cur_led_idx;
+    float           brightness;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(fan_led_data, 0x00, sizeof(fan_led_data));
+
+    std::vector<RGBColor> colors = active_mode.colors;
+    unsigned int num_colors = colors.size();
+
+    if(!colors.empty())                                          // Update led_data if there's colors
+    {
+        brightness = static_cast<float>(active_mode.brightness)/4;
+        if (num_colors == 6)
+        {
+            for(unsigned int i = 0; i < 6; i++)
+            {
+                float brightness_scale = brightness * brightnessLimit(colors[i]);
+                for(unsigned int led_idx = 0; led_idx < 16 * 3; led_idx += 3)
+                {
+                    cur_led_idx = (i * 16 * 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);
+                }
+            }
+        }
+        else
+        {
+            colors.resize(4);
+            for(unsigned int i = num_colors; i < 4; i++)
+            {
+                colors[i] = 0x00;
+            }
+
+            // needs a 72 length array of 4 colors, even if less are defined
+            for(unsigned int j = 0; j < 4; j++)
+            {
+                float brightness_scale = brightness * brightnessLimit(colors[j]);
+                for(unsigned int i = 0; i < 6; i++)
+                {
+                    cur_led_idx = (i * 12) + (j * 3);
+                    fan_led_data[cur_led_idx + 0] = RGBGetRValue(colors[j]) * brightness_scale;
+                    fan_led_data[cur_led_idx + 1] = RGBGetBValue(colors[j]) * brightness_scale;
+                    fan_led_data[cur_led_idx + 2] = RGBGetGValue(colors[j]) * brightness_scale;
+                }
+            }
+        }
+
+    }
+
+    SendStartAction
+    (
+        channel,                        // Current channel
+        (num_fans + 1)                  // Number of fans
+    );
+
+    SendColorData
+    (
+        channel,                        // Channel
+        (num_fans + 1)*16,
+        fan_led_data                        // Data
+    );
+
+    SendCommitAction
+    (
+        channel,                        // Channel
+        active_mode.value,                     // Effect
+        speed_code[active_mode.speed],              // Speed
+        active_mode.direction,                      // Direction
+        brightness_code[active_mode.brightness]     // Brightness
+    );
+}
+
+void LianLiUniHubSLV2Controller::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_SLV2_TRANSACTION_ID;
+    usb_buf[0x01]   = 0x10;
+    usb_buf[0x02]   = 0x60;
+    usb_buf[0x03]   = (channel << 4) + num_fans;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, sizeof(usb_buf));
+    std::this_thread::sleep_for(5ms);
+
+}
+
+void LianLiUniHubSLV2Controller::SendColorData(unsigned char   channel, unsigned int    num_leds, unsigned char*  led_data)
+{
+    /*---------------------------------------------------------*\
+    | Send LED data                                        |
+    \*---------------------------------------------------------*/
+
+    unsigned char usb_buf[353];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = UNIHUB_SLV2_TRANSACTION_ID;
+    usb_buf[0x01]   = 0x30 + channel; // action + channel(30 = channel 1, 31 = channel 2, etc.)
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x02], led_data, num_leds * 3);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, sizeof(usb_buf));
+    std::this_thread::sleep_for(5ms);
+}
+
+void LianLiUniHubSLV2Controller::SendCommitAction(unsigned char channel, 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_SLV2_TRANSACTION_ID;
+    usb_buf[0x01]   = 0x10 + channel; // Channel+device (10 = channel 1, 11 = channel 2, 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, sizeof(usb_buf));
+    std::this_thread::sleep_for(5ms);
+}

Controllers/LianLiController/LianLiUniHubSLV2Controller.h

@@ -0,0 +1,224 @@
+/*-----------------------------------------*\
+|  LianLiHubSLV2Controller.h                |
+|                                           |
+|  Definitions and types for Lian Li SLV2120|
+|                                           |
+|  Will Kennedy 01/17/2023					|
+|  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_SLV2_CHANNEL_COUNT              = 0x04,   /* Channel count                   */
+    UNIHUB_SLV2_CHAN_LED_COUNT             = 0x10 * 6,   /* Max-LED per channel count - 96  */
+};
+
+/*----------------------------------------------------------------------------*\
+| Definitions related to LED configuration.                                    |
+\*----------------------------------------------------------------------------*/
+
+// Used for sync'd mode between Fan and Edge
+
+enum
+{
+    UNIHUB_SLV2_LED_MODE_STATIC_COLOR   = 0x01, // full data array
+    UNIHUB_SLV2_LED_MODE_BREATHING      = 0x02, // full data array
+    UNIHUB_SLV2_LED_MODE_RAINBOW_MORPH  = 0x04, // no array
+    UNIHUB_SLV2_LED_MODE_RAINBOW        = 0x05, // no array
+    UNIHUB_SLV2_LED_MODE_STAGGERED      = 0x18, // size 2
+    UNIHUB_SLV2_LED_MODE_TIDE           = 0x1A, // size 2
+    UNIHUB_SLV2_LED_MODE_RUNWAY         = 0x1C, // size 2
+    UNIHUB_SLV2_LED_MODE_MIXING         = 0x1E, // size 2
+    UNIHUB_SLV2_LED_MODE_STACK          = 0x20, // size 1
+    UNIHUB_SLV2_LED_MODE_STACK_MULTI_COLOR = 0x21, // no array
+    UNIHUB_SLV2_LED_MODE_NEON           = 0x22, // no array
+    UNIHUB_SLV2_LED_MODE_COLOR_CYCLE    = 0x23, // size 3
+    UNIHUB_SLV2_LED_MODE_METEOR         = 0x24, // size 2
+    UNIHUB_SLV2_LED_MODE_VOICE          = 0x26, // no array
+    UNIHUB_SLV2_LED_MODE_GROOVE         = 0x27, // size 2
+    UNIHUB_SLV2_LED_MODE_RENDER         = 0x28, // size 4
+    UNIHUB_SLV2_LED_MODE_TUNNEL         = 0x29, // size 4
+    // merged modes
+    UNIHUB_SLV2_LED_MODE_METEOR_MERGED  = 0x2A,
+    UNIHUB_SLV2_LED_MODE_RUNWAY_MERGED  = 0x2B,
+    UNIHUB_SLV2_LED_MODE_TIDE_MERGED    = 0x2C,
+    UNIHUB_SLV2_LED_MODE_MIXING_MERGED  = 0x2D,
+    UNIHUB_SLV2_LED_MODE_STACK_MULTI_COLOR_MERGED = 0x2E
+};
+
+enum
+{
+    UNIHUB_SLV2_LED_SPEED_000              = 0x02,   /* Very slow speed         */
+    UNIHUB_SLV2_LED_SPEED_025              = 0x01,   /* Rather slow speed       */
+    UNIHUB_SLV2_LED_SPEED_050              = 0x00,   /* Medium speed            */
+    UNIHUB_SLV2_LED_SPEED_075              = 0xFF,   /* Rather fast speed       */
+    UNIHUB_SLV2_LED_SPEED_100              = 0xFE,   /* Very fast speed         */
+};
+
+enum
+{
+    UNIHUB_SLV2_LED_DIRECTION_LTR          = 0x00,   /* Left-to-Right direction */
+    UNIHUB_SLV2_LED_DIRECTION_RTL          = 0x01,   /* Right-to-Left direction */
+};
+
+enum
+{
+    UNIHUB_SLV2_LED_BRIGHTNESS_000         = 0x08,   /* Very dark (off)         */
+    UNIHUB_SLV2_LED_BRIGHTNESS_025         = 0x03,   /* Rather dark             */
+    UNIHUB_SLV2_LED_BRIGHTNESS_050         = 0x02,   /* Medium bright           */
+    UNIHUB_SLV2_LED_BRIGHTNESS_075         = 0x01,   /* Rather bright           */
+    UNIHUB_SLV2_LED_BRIGHTNESS_100         = 0x00,   /* Very bright             */
+};
+
+enum
+{
+    UNIHUB_SLV2_LED_LIMITER                = 0x01    /* Limit the color white to 999999 as per manufacturer limits */
+};
+
+
+/*----------------------------------------------------------------------------*\
+| Definitions related to packet configuration.                                 |
+\*----------------------------------------------------------------------------*/
+
+enum
+{
+    UNIHUB_SLV2_TRANSACTION_ID            = 0xE0, /* Command value to start all packets */
+};
+
+/*----------------------------------------------------------------------------*\
+| Uni Hub SLV2 controller.                                                       |
+\*----------------------------------------------------------------------------*/
+
+class LianLiUniHubSLV2Controller
+{
+
+
+public:
+    LianLiUniHubSLV2Controller(hid_device* dev_handle, const char* path, std::string dev_name);
+    ~LianLiUniHubSLV2Controller();
+
+    std::string                 GetDeviceLocation();
+    std::string                 GetFirmwareVersionString();
+    std::string                 GetName();
+    std::string                 GetSerialString();
+
+    void                SetChannelMode
+                                (
+                                unsigned char   channel,
+                                const mode active_mode,
+                                unsigned int    num_fans
+                                );
+
+    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    num_leds,
+                                unsigned char*  led_data            // Color data payload
+                                );
+
+    void                SendCommitAction
+                                (
+                                unsigned char   channel,            // Zone index
+                                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_SLV2_CHAN_LED_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

@@ -735,7 +735,7 @@ std::string LianLiUniHub_AL10Controller::ReadVersion()
     /*-------------------------------------*\
     | Format version string                 |
     \*-------------------------------------*/
-    char version[14];
+    char version[15];
     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));

Controllers/LianLiController/RGBController_LianLiUniHubAL.cpp

@@ -30,7 +30,7 @@ static unsigned int matrix_map[8][35] =
     @name Lian Li Uni Hub AL
     @type USB
     @save :x:
-    @direct :warning:
+    @direct :rotating_light:
     @effects :white_check_mark:
     @detectors DetectLianLiUniHubAL
     @comment

Controllers/LianLiController/RGBController_LianLiUniHubSLV2.cpp

@@ -0,0 +1,452 @@
+/*-----------------------------------------*\
+|  RGBController_LianLiUniHubSLV2.cpp       |
+|                                           |
+|  Generic RGB Interface for Lian Li Uni    |
+|  Hub SLV2 USB controller driver           |
+|                                           |
+|  Will Kennedy 01/17/2023					|
+|  Oliver P 04/26/2022                      |
+|  Credit to Luca Lovisa for original work. |
+\*-----------------------------------------*/
+
+#include "RGBController_LianLiUniHubSLV2.h"
+
+#include <string>
+
+/**------------------------------------------------------------------*\
+    @name Lian Li Uni Hub SLV2
+    @type USB
+    @save :x:
+    @direct :rotating_light:
+    @effects :white_check_mark:
+    @detectors DetectLianLiUniHubSLV2
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_LianLiUniHubSLV2::RGBController_LianLiUniHubSLV2(LianLiUniHubSLV2Controller* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = controller->GetName();
+    vendor      = "Lian Li";
+    type        = DEVICE_TYPE_COOLER;
+    description = "Lian Li Uni Hub - SL V2";
+    version     = controller->GetFirmwareVersionString();
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+
+    initializedMode = false;
+
+    mode Custom;
+    Custom.name                 = "Custom";
+    Custom.value                = UNIHUB_SLV2_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 StaticColor;
+    StaticColor.name            = "Static";
+    StaticColor.value           = UNIHUB_SLV2_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      = 6;
+    StaticColor.brightness      = 4;
+    StaticColor.color_mode      = MODE_COLORS_MODE_SPECIFIC;
+    StaticColor.colors.resize(6);
+    modes.push_back(StaticColor);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = UNIHUB_SLV2_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        = 6;
+    Breathing.speed             = 2;
+    Breathing.brightness        = 4;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(6);
+    modes.push_back(Breathing);
+
+    mode RainbowMorph;
+    RainbowMorph.name           = "Spectrum Cycle";
+    RainbowMorph.value          = UNIHUB_SLV2_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          = 2;
+    RainbowMorph.brightness     = 4;
+    RainbowMorph.color_mode     = MODE_COLORS_NONE;
+    modes.push_back(RainbowMorph);
+
+    mode RainbowWave;
+    RainbowWave.name            = "Rainbow Wave";
+    RainbowWave.value           = UNIHUB_SLV2_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           = 2;
+    RainbowWave.brightness      = 4;
+    RainbowWave.direction       = UNIHUB_SLV2_LED_DIRECTION_LTR;
+    RainbowWave.color_mode      = MODE_COLORS_NONE;
+    modes.push_back(RainbowWave);
+
+    mode Staggered;
+    Staggered.name              = "Staggered";
+    Staggered.value             = UNIHUB_SLV2_LED_MODE_STAGGERED;
+    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        = 2;
+    Staggered.speed             = 2;
+    Staggered.brightness        = 4;
+    Staggered.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Staggered.colors.resize(2);
+    modes.push_back(Staggered);
+
+    mode Tide; // TODO: Has merge
+    Tide.name                   = "Tide";
+    Tide.value                  = UNIHUB_SLV2_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             = 2;
+    Tide.speed                  = 2;
+    Tide.brightness             = 4;
+    Tide.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Tide.colors.resize(2);
+    modes.push_back(Tide);
+
+    mode Runway; //TODO: Has merge
+    Runway.name                 = "Runway";
+    Runway.value                = UNIHUB_SLV2_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                = 2;
+    Runway.brightness           = 4;
+    Runway.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Runway.colors.resize(2);
+    modes.push_back(Runway);
+
+    mode Mixing; //TODO: Has merge
+    Mixing.name                 = "Mixing";
+    Mixing.value                = UNIHUB_SLV2_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                = 2;
+    Mixing.brightness           = 4;
+    Mixing.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Mixing.colors.resize(2);
+    modes.push_back(Mixing);
+
+    mode Stack;
+    Stack.name                  = "Stack";
+    Stack.value                 = UNIHUB_SLV2_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            = 1;
+    Stack.speed                 = 2;
+    Stack.brightness            = 4;
+    Stack.direction             = UNIHUB_SLV2_LED_DIRECTION_LTR;
+    Stack.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Stack.colors.resize(1);
+    modes.push_back(Stack);
+
+    mode StackMultiColor; //TODO: Has merge
+    Stack.name                  = "Stack Multi Color";
+    Stack.value                 = UNIHUB_SLV2_LED_MODE_STACK_MULTI_COLOR;
+    Stack.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
+    Stack.speed_min             = 0;
+    Stack.speed_max             = 4;
+    Stack.brightness_min        = 0;
+    Stack.brightness_max        = 4;
+    Stack.speed                 = 2;
+    Stack.brightness            = 4;
+    Stack.direction             = UNIHUB_SLV2_LED_DIRECTION_LTR;
+    Stack.color_mode            = MODE_COLORS_NONE;
+    modes.push_back(Stack);
+
+    mode Neon;
+    Neon.name                 = "Neon";
+    Neon.value                = UNIHUB_SLV2_LED_MODE_NEON;
+    Neon.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Neon.speed_min            = 0;
+    Neon.speed_max            = 4;
+    Neon.brightness_min       = 0;
+    Neon.brightness_max       = 4;
+    Neon.speed                = 2;
+    Neon.brightness           = 4;
+    Neon.color_mode           = MODE_COLORS_NONE;
+    modes.push_back(Neon);
+
+    mode ColorCycle;
+    ColorCycle.name             = "ColorCycle";
+    ColorCycle.value            = UNIHUB_SLV2_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       = 3;
+    ColorCycle.speed            = 2;
+    ColorCycle.brightness       = 4;
+    ColorCycle.direction        = UNIHUB_SLV2_LED_DIRECTION_LTR;
+    ColorCycle.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    ColorCycle.colors.resize(3);
+    modes.push_back(ColorCycle);
+
+    mode Meteor; //TODO: Has merge
+    Meteor.name                 = "Meteor";
+    Meteor.value                = UNIHUB_SLV2_LED_MODE_METEOR;
+    Meteor.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Meteor.speed_min            = 0;
+    Meteor.speed_max            = 4;
+    Meteor.brightness_min       = 0;
+    Meteor.brightness_max       = 4;
+    Meteor.colors_min           = 0;
+    Meteor.colors_max           = 2;
+    Meteor.speed                = 2;
+    Meteor.brightness           = 4;
+    Meteor.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Meteor.colors.resize(2);
+    modes.push_back(Meteor);
+
+    mode Voice;
+    Voice.name                  = "Voice";
+    Voice.value                 = UNIHUB_SLV2_LED_MODE_VOICE;
+    Voice.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Voice.speed_min             = 0;
+    Voice.speed_max             = 4;
+    Voice.brightness_min        = 0;
+    Voice.brightness_max        = 4;
+    Voice.speed                 = 2;
+    Voice.brightness            = 4;
+    modes.push_back(Voice);
+
+    mode Groove;
+    Groove.name             = "Groove";
+    Groove.value            = UNIHUB_SLV2_LED_MODE_GROOVE;
+    Groove.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Groove.speed_min        = 0;
+    Groove.speed_max        = 4;
+    Groove.brightness_min   = 0;
+    Groove.brightness_max   = 4;
+    Groove.colors_min       = 0;
+    Groove.colors_max       = 1;
+    Groove.speed            = 2;
+    Groove.brightness       = 4;
+    Groove.direction        = UNIHUB_SLV2_LED_DIRECTION_LTR;
+    Groove.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    Groove.colors.resize(1);
+    modes.push_back(Groove);
+
+    mode Render;
+    Render.name             = "Render";
+    Render.value            = UNIHUB_SLV2_LED_MODE_RENDER;
+    Render.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Render.speed_min        = 0;
+    Render.speed_max        = 4;
+    Render.brightness_min   = 0;
+    Render.brightness_max   = 4;
+    Render.colors_min       = 0;
+    Render.colors_max       = 4;
+    Render.speed            = 2;
+    Render.brightness       = 4;
+    Render.direction        = UNIHUB_SLV2_LED_DIRECTION_LTR;
+    Render.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    Render.colors.resize(4);
+    modes.push_back(Render);
+
+    mode Tunnel;
+    Tunnel.name             = "Tunnel";
+    Tunnel.value            = UNIHUB_SLV2_LED_MODE_TUNNEL;
+    Tunnel.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
+    Tunnel.speed_min        = 0;
+    Tunnel.speed_max        = 4;
+    Tunnel.brightness_min   = 0;
+    Tunnel.brightness_max   = 4;
+    Tunnel.colors_min       = 0;
+    Tunnel.colors_max       = 4;
+    Tunnel.speed            = 2;
+    Tunnel.brightness       = 4;
+    Tunnel.direction        = UNIHUB_SLV2_LED_DIRECTION_LTR;
+    Tunnel.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    Tunnel.colors.resize(4);
+    modes.push_back(Tunnel);
+
+    RGBController_LianLiUniHubSLV2::SetupZones();
+}
+
+RGBController_LianLiUniHubSLV2::~RGBController_LianLiUniHubSLV2()
+{
+    delete controller;
+}
+
+void RGBController_LianLiUniHubSLV2::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Only set LED count on the first run               |
+    \*-------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
+    {
+        first_run = true;
+        zones.resize(UNIHUB_SLV2_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));
+
+        zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
+        zones[channel_idx].leds_min             = 0;
+        zones[channel_idx].leds_max             = UNIHUB_SLV2_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_LianLiUniHubSLV2::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_LianLiUniHubSLV2::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_LianLiUniHubSLV2::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_LianLiUniHubSLV2::UpdateSingleLED(int /* led */)
+{
+    DeviceUpdateMode();
+
+}
+
+void RGBController_LianLiUniHubSLV2::DeviceUpdateMode()
+{
+    if(!active_mode)
+    {
+        return;                 // Do nothing, custom mode should go through DeviceUpdateLEDs() to avoid flooding controller
+    }
+
+    initializedMode   = true;
+
+    int                 fan_idx = 0;
+
+    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 / 16) - 1);        // Indexes start at 0
+
+        controller->SetChannelMode(zone_idx,
+                                   modes[active_mode],
+                                   fan_idx);
+
+    }
+}
+
+void RGBController_LianLiUniHubSLV2::SetCustomMode()
+{
+    /*-------------------------------------------------*\
+    | Set mode to Static Color                          |
+    \*-------------------------------------------------*/
+    active_mode = 0;
+}
+

Controllers/LianLiController/RGBController_LianLiUniHubSLV2.h

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

Controllers/LianLiController/RGBController_LianLiUniHub_AL10.cpp

@@ -16,7 +16,7 @@
     @name Lian Li Uni Hub
     @type USB
     @save :x:
-    @direct :warning:
+    @direct :rotating_light:
     @effects :white_check_mark:
     @detectors DetectLianLiUniHub
     @comment

Controllers/LinuxLEDController/LinuxLEDControllerDetect.cpp

@@ -18,7 +18,7 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectLinuxLEDControllers(std::vector<RGBController*> &rgb_controllers)
+void DetectLinuxLEDControllers()
 {
     json                    linux_led_settings;
 
@@ -67,7 +67,7 @@ void DetectLinuxLEDControllers(std::vector<RGBController*> &rgb_controllers)
             RGBController_LinuxLED* rgb_controller = new RGBController_LinuxLED(controller);
             rgb_controller->name                   = name;
 
-            rgb_controllers.push_back(rgb_controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
     }
 

Controllers/LogitechController/LogitechControllerDetect.cpp

@@ -99,6 +99,7 @@ using namespace std::chrono_literals;
 #define LOGITECH_G933_PID                           0x0A5B
 #define LOGITECH_G935_PID                           0x0A87
 #define LOGITECH_G733_PID                           0x0AB5
+#define LOGITECH_G633_PID                           0X0A5C
 
 /*-----------------------------------------------------*\
 | Unifying Device IDs (Including Lightspeed receivers)  |
@@ -680,7 +681,10 @@ REGISTER_HID_DETECTOR_IPU("Logitech G560 Lightsync Speaker",                Dete
 REGISTER_HID_DETECTOR_IPU("Logitech G933 Lightsync Headset",                DetectLogitechG933,         LOGITECH_VID, LOGITECH_G933_PID,                    3, 0xFF43, 514);
 /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
 | Joysticks                                                                                                                                         |
+|   Older versions of the HOTAS have the controller on usage 1 however registering a IP detector resulted in duplicate detections on Linux          |
 \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Logitech X56 Rhino Hotas Joystick",              DetectLogitechX56,          LOGITECH_X56_VID, LOGITECH_X56_JOYSTICK_PID,        2, 0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Logitech X56 Rhino Hotas Throttle",              DetectLogitechX56,          LOGITECH_X56_VID, LOGITECH_X56_THROTTLE_PID,        2, 0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Logitech X56 Rhino Hotas Joystick",              DetectLogitechX56,          LOGITECH_X56_VID, LOGITECH_X56_JOYSTICK_PID,        2, 0xFF00, 3);
 REGISTER_HID_DETECTOR_IPU("Logitech X56 Rhino Hotas Throttle",              DetectLogitechX56,          LOGITECH_X56_VID, LOGITECH_X56_THROTTLE_PID,        2, 0xFF00, 3);
 
@@ -905,5 +909,6 @@ REGISTER_HID_DETECTOR_IPU("Logitech G900 Wireless Gaming Mouse (wired)",
 REGISTER_HID_DETECTOR_IPU("Logitech G903 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G903_LIGHTSPEED_PID,                 1, 0xFF00, 2);
 REGISTER_HID_DETECTOR_IPU("Logitech G903 Hero Wireless Gaming Mouse (wired)",   DetectLogitechWired,        LOGITECH_VID, LOGITECH_G903_LIGHTSPEED_HERO_PID,            1, 0xFF00, 2);
 REGISTER_HID_DETECTOR_IPU("Logitech G Pro Wireless Gaming Mouse (wired)",       DetectLogitechWired,        LOGITECH_VID, LOGITECH_G_PRO_WIRELESS_PID,                  2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G633 Gaming Headset",                       DetectLogitechWired,        LOGITECH_VID, LOGITECH_G633_PID,                            3, 0xFF43, 514);
 REGISTER_HID_DETECTOR_IPU("Logitech G733 Gaming Headset",                       DetectLogitechWired,        LOGITECH_VID, LOGITECH_G733_PID,                            3, 0xFF43, 514);
 REGISTER_HID_DETECTOR_IPU("Logitech G935 Gaming Headset",                       DetectLogitechWired,        LOGITECH_VID, LOGITECH_G935_PID,                            3, 0xFF43, 514);

Controllers/LogitechController/LogitechLightspeedController.cpp

@@ -54,15 +54,14 @@ std::string LogitechLightspeedController::GetSerialString()
 
 void LogitechLightspeedController::SendMouseMode
     (
-    unsigned char       mode,
-    uint16_t            speed,
-    unsigned char       zone,
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue,
-    unsigned char       brightness,
-    bool                bright_cycle_swap
+        uint8_t         mode,
+        uint16_t        speed,
+        uint8_t         zone,
+        uint8_t         red,
+        uint8_t         green,
+        uint8_t         blue,
+        uint8_t         brightness
     )
 {
-    lightspeed->setMode(mode, speed, zone, red, green, blue, brightness, bright_cycle_swap);
+    lightspeed->setMode(mode, speed, zone, red, green, blue, brightness);
 }

Controllers/LogitechController/LogitechLightspeedController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  LogitechLightspeedController.h           | 
+|  LogitechLightspeedController.h           |
 |                                           |
 |  Definitions and types for Logitech G     |
 |  Lightsync Wireless Gaming Mice lighting  |
@@ -19,20 +19,12 @@
 #define LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MIN      0x01
 #define LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX      0x64
 
-enum
-{
-    LOGITECH_G_PRO_WIRELESS_MODE_OFF               = 0x00,
-    LOGITECH_G_PRO_WIRELESS_MODE_STATIC            = 0x01,
-    LOGITECH_G_PRO_WIRELESS_MODE_CYCLE             = 0x02,
-    LOGITECH_G_PRO_WIRELESS_MODE_BREATHING         = 0x03,
-};
-
 /*---------------------------------------------------------------------------------------------*\
 | Speed is 1000 for fast and 20000 for slow.                                                    |
 | Values are multiplied by 100 later to give lots of GUI steps.                                 |
 \*---------------------------------------------------------------------------------------------*/
 enum
-{   
+{
     LOGITECH_G_PRO_WIRELESS_SPEED_SLOWEST          = 0xC8,  /* Slowest speed                   */
     LOGITECH_G_PRO_WIRELESS_SPEED_NORMAL           = 0x32,  /* Normal speed                    */
     LOGITECH_G_PRO_WIRELESS_SPEED_FASTEST          = 0x0A,  /* Fastest speed                   */
@@ -45,21 +37,20 @@ public:
     ~LogitechLightspeedController();
 
     logitech_device* lightspeed;
-    
+
     std::string GetDeviceLocation();
     std::string GetSerialString();
 
     void        SendMouseMode
-                   (
-                    unsigned char       mode,
-                    uint16_t            speed,
-                    unsigned char       zone,
-                    unsigned char       red,
-                    unsigned char       green,
-                    unsigned char       blue,
-                    unsigned char       brightness,
-                    bool                bright_cycle_swap
-                   );
+                (
+                    uint8_t         mode,
+                    uint16_t        speed,
+                    uint8_t         zone,
+                    uint8_t         red,
+                    uint8_t         green,
+                    uint8_t         blue,
+                    uint8_t         brightness
+                );
 
 private:
     hid_device*             dev;

Controllers/LogitechController/LogitechProtocolCommon.cpp

@@ -178,6 +178,7 @@ void logitech_device::initialiseDevice()
             {
                 feature_list.emplace(*page, feature_index);
                 RGB_feature_index = feature_index;
+                break;
             }
         }
 
@@ -346,7 +347,7 @@ uint8_t logitech_device::getFeatureIndex(uint16_t feature_page)
         hid_read_timeout(dev_use2, response.buffer, response.size(), LOGITECH_PROTOCOL_TIMEOUT);
 
         feature_index           = response.data[0];
-        
+
         LOG_DEBUG("[%s] Feature Page %04X found @ index %02X - %02X %02X %02X %02X %02X %02X %02X %02X", device_name.c_str(), feature_page, feature_index,
                 response.data[0], response.data[1],  response.data[2],  response.data[3], response.data[4], response.data[5],  response.data[6],  response.data[7]);
     }
@@ -707,7 +708,7 @@ uint8_t logitech_device::setDirectMode(bool direct)
     return result;
 }
 
-uint8_t logitech_device::setMode(uint8_t mode, uint16_t speed, uint8_t zone, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness, bool bright_cycle_swap)
+uint8_t logitech_device::setMode(uint8_t mode, uint16_t speed, uint8_t zone, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness)
 {
     /*-----------------------------------------------------------------*\
     | Check the usage map for usage2 (0x11 Long FAP Message) then       |
@@ -716,6 +717,7 @@ uint8_t logitech_device::setMode(uint8_t mode, uint16_t speed, uint8_t zone, uin
     hid_device* dev_use2    = getDevice(2);
     uint16_t feature_page   = getFeaturePage(RGB_feature_index);
     int result              = 0;
+    LOGITECH_DEVICE_MODE fx = leds[zone].fx[mode].mode;
 
     if(dev_use2)
     {
@@ -738,31 +740,36 @@ uint8_t logitech_device::setMode(uint8_t mode, uint16_t speed, uint8_t zone, uin
         set_mode.data[4] = blue;
 
         speed *= 100;
-        if(mode == 1)   //Static
+        switch(fx)
         {
-            set_mode.data[5]    = 0x02; //zone;
-            //set_mode.data[12]   = 0x01; //Save to flash testing
-        }
-        else if(mode == 2)  //Spectrum Cycle - LOGITECH_DEVICE_LED_SPECTRUM
-        {
-            if(bright_cycle_swap)
-            {
-                set_mode.data[1] = 3;
-            }
-            set_mode.data[7]    = speed >> 8;
-            set_mode.data[8]    = speed & 0xFF;
-            set_mode.data[9]    = brightness;
-        }
-        else if(mode == 3)  //Breathing - LOGITECH_DEVICE_LED_BREATHING
-        {
-            if(bright_cycle_swap)
-            {
-                set_mode.data[1] = 2;
-            }
-            set_mode.data[5]    = speed >> 8;
-            set_mode.data[6]    = speed & 0xFF;
-            //set_mode.data[7]    = curve_type; //Value 0-6: Default, Sine, Square, Triangle, Sawtooth, Reverse_Sawtooth, Exponent
-            set_mode.data[8]    = brightness;
+            case LOGITECH_DEVICE_LED_ON:
+                set_mode.data[5]    = 0x02;     //zone;
+                //set_mode.data[12]   = 0x01;     //Save to flash testing
+                break;
+
+            case LOGITECH_DEVICE_LED_SPECTRUM:
+                set_mode.data[7]    = speed >> 8;
+                set_mode.data[8]    = speed & 0xFF;
+                set_mode.data[9]    = brightness;
+                break;
+
+            case LOGITECH_DEVICE_LED_BREATHING:
+                set_mode.data[5]    = speed >> 8;
+                set_mode.data[6]    = speed & 0xFF;
+                //set_mode.data[7]    = curve_type; //Value 0-6: Default, Sine, Square, Triangle, Sawtooth, Reverse_Sawtooth, Exponent
+                set_mode.data[8]    = brightness;
+                break;
+
+            /*-----------------------------------------------------*\
+            | Place holders for later implementation                |
+            \*-----------------------------------------------------*/
+            case LOGITECH_DEVICE_LED_OFF:
+            case LOGITECH_DEVICE_LED_WAVE:
+            case LOGITECH_DEVICE_LED_STAR:
+            case LOGITECH_DEVICE_LED_RIPPLE:
+            case LOGITECH_DEVICE_LED_CUSTOM:
+            default:
+                break;
         }
 
         /*-----------------------------------------------------*\

Controllers/LogitechController/LogitechProtocolCommon.h

@@ -255,7 +255,7 @@ public:
     uint8_t                     getLED_count();
     logitech_led                getLED_info(uint8_t LED_num);
     uint8_t                     setDirectMode(bool direct);
-    uint8_t                     setMode(uint8_t mode, uint16_t speed, uint8_t zone, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness, bool bright_cycle_swap);
+    uint8_t                     setMode(uint8_t mode, uint16_t speed, uint8_t zone, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness);
     int                         getDeviceName();
 private:
     std::map<uint8_t, logitech_led> leds;

Controllers/LogitechController/RGBController_LogitechLightspeed.cpp

@@ -28,7 +28,7 @@ RGBController_LogitechLightspeed::RGBController_LogitechLightspeed(LogitechLight
 
     mode Off;
     Off.name                        = "Off";
-    Off.value                       = LOGITECH_G_PRO_WIRELESS_MODE_OFF;
+    Off.value                       = LOGITECH_DEVICE_LED_OFF;
     Off.flags                       = 0;
     Off.color_mode                  = MODE_COLORS_NONE;
     modes.push_back(Off);
@@ -64,48 +64,83 @@ RGBController_LogitechLightspeed::RGBController_LogitechLightspeed(LogitechLight
                 LOG_INFO("Logitech device type not known: %i", controller->lightspeed->logitech_device_type);
         }
 
-        mode Direct;
-        Direct.name                 = "Direct";
-        Direct.value                = 0xFF;
-        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-        Direct.color_mode           = MODE_COLORS_PER_LED;
-        modes.push_back(Direct);
+        logitech_led fx             = controller->lightspeed->getLED_info(0);
 
-        mode Static;
-        Static.name                 = "Static";
-        Static.value                = LOGITECH_G_PRO_WIRELESS_MODE_STATIC;
-        Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-        Static.color_mode           = MODE_COLORS_PER_LED;
-        Static.brightness_min       = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MIN;
-        Static.brightness_max       = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
-        Static.brightness           = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
-        modes.push_back(Static);
+        for(uint8_t i = 0; i < fx.fx.size(); i++)
+        {
+            /*---------------------------------------------------------*\
+            | Logitech devices don't have a set order for effects and   |
+            |   each device needs to have the effect index mapped       |
+            \*---------------------------------------------------------*/
+            switch(fx.fx[i].mode)
+            {
+                case LOGITECH_DEVICE_LED_OFF:
+                    /* Do nothing as it's already added */
+                    break;
 
-        mode Cycle;
-        Cycle.name                  = "Spectrum Cycle";
-        Cycle.value                 = LOGITECH_G_PRO_WIRELESS_MODE_CYCLE;
-        Cycle.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-        Cycle.color_mode            = MODE_COLORS_NONE;
-        Cycle.brightness_min        = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MIN;
-        Cycle.brightness_max        = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
-        Cycle.brightness            = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
-        Cycle.speed_min             = LOGITECH_G_PRO_WIRELESS_SPEED_SLOWEST;
-        Cycle.speed_max             = LOGITECH_G_PRO_WIRELESS_SPEED_FASTEST;
-        Cycle.speed                 = LOGITECH_G_PRO_WIRELESS_SPEED_NORMAL;
-        modes.push_back(Cycle);
+                case LOGITECH_DEVICE_LED_ON:
+                {
+                    mode Direct;
+                    Direct.name                 = "Direct";
+                    Direct.value                = i;
+                    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             = LOGITECH_G_PRO_WIRELESS_MODE_BREATHING;
-        Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-        Breathing.color_mode        = MODE_COLORS_PER_LED;
-        Breathing.brightness_min    = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MIN;
-        Breathing.brightness_max    = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
-        Breathing.brightness        = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
-        Breathing.speed_min         = LOGITECH_G_PRO_WIRELESS_SPEED_SLOWEST;
-        Breathing.speed_max         = LOGITECH_G_PRO_WIRELESS_SPEED_FASTEST;
-        Breathing.speed             = LOGITECH_G_PRO_WIRELESS_SPEED_NORMAL;
-        modes.push_back(Breathing);
+                    mode Static;
+                    Static.name                 = "Static";
+                    Static.value                = i;
+                    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+                    Static.color_mode           = MODE_COLORS_PER_LED;
+                    Static.brightness_min       = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MIN;
+                    Static.brightness_max       = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
+                    Static.brightness           = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
+                    modes.push_back(Static);
+                    LOG_DEBUG("[%s] Adding %s & %s modes at index - %02i", name.c_str(), Direct.name.c_str(), Static.name.c_str(), i);
+                    break;
+                }
+
+                case LOGITECH_DEVICE_LED_SPECTRUM:
+                {
+                    mode Cycle;
+                    Cycle.name                  = "Spectrum Cycle";
+                    Cycle.value                 = i;
+                    Cycle.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+                    Cycle.color_mode            = MODE_COLORS_NONE;
+                    Cycle.brightness_min        = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MIN;
+                    Cycle.brightness_max        = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
+                    Cycle.brightness            = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
+                    Cycle.speed_min             = LOGITECH_G_PRO_WIRELESS_SPEED_SLOWEST;
+                    Cycle.speed_max             = LOGITECH_G_PRO_WIRELESS_SPEED_FASTEST;
+                    Cycle.speed                 = LOGITECH_G_PRO_WIRELESS_SPEED_NORMAL;
+                    modes.push_back(Cycle);
+                    LOG_DEBUG("[%s] Adding %s mode at index - %02i", name.c_str(), Cycle.name.c_str(), i);
+                    break;
+                }
+
+                case LOGITECH_DEVICE_LED_BREATHING:
+                {
+                    mode Breathing;
+                    Breathing.name              = "Breathing";
+                    Breathing.value             = i;
+                    Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+                    Breathing.color_mode        = MODE_COLORS_PER_LED;
+                    Breathing.brightness_min    = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MIN;
+                    Breathing.brightness_max    = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
+                    Breathing.brightness        = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
+                    Breathing.speed_min         = LOGITECH_G_PRO_WIRELESS_SPEED_SLOWEST;
+                    Breathing.speed_max         = LOGITECH_G_PRO_WIRELESS_SPEED_FASTEST;
+                    Breathing.speed             = LOGITECH_G_PRO_WIRELESS_SPEED_NORMAL;
+                    modes.push_back(Breathing);
+                    LOG_DEBUG("[%s] Adding %s mode at index - %02i", name.c_str(), Breathing.name.c_str(), i);
+                    break;
+                }
+
+                default:
+                    LOG_WARNING("[%s] Effect at index - %02i not added: Value %04X unrecognised", name.c_str(), i, fx.fx[i].mode);
+                    break;
+            }
+        }
 
         SetupZones();
     }
@@ -190,17 +225,7 @@ void RGBController_LogitechLightspeed::UpdateZoneLEDs(int zone)
     unsigned char grn       = RGBGetGValue(colors[zone]);
     unsigned char blu       = RGBGetBValue(colors[zone]);
 
-    /*---------------------------------------------------------*\
-    | Workaround for G502 mode breathing / spectrum cycle swap  |
-    \*---------------------------------------------------------*/
-    bool bright_cycle_swap  = (pid == 0xC08B || pid == 0xC332 || pid == 0x0AB5 || pid == 0x0A87);
-
-    /*---------------------------------------------------------*\
-    | Replace direct mode with static when sending to controller|
-    \*---------------------------------------------------------*/
-    unsigned char temp_mode = (modes[active_mode].value == 0xFF) ? LOGITECH_G_PRO_WIRELESS_MODE_STATIC : modes[active_mode].value;
-
-    controller->SendMouseMode(temp_mode, modes[active_mode].speed, zone, red, grn, blu, modes[active_mode].brightness, bright_cycle_swap);
+    controller->SendMouseMode(modes[active_mode].value, modes[active_mode].speed, zone, red, grn, blu, modes[active_mode].brightness);
 }
 
 void RGBController_LogitechLightspeed::UpdateSingleLED(int led)
@@ -215,6 +240,6 @@ void RGBController_LogitechLightspeed::DeviceUpdateMode()
     | mouse in direct mode.  This code will only be called when |
     | we change modes as to not spam the device.                |
     \*---------------------------------------------------------*/
-    controller->lightspeed->setDirectMode(modes[active_mode].value == 0xFF);
+    controller->lightspeed->setDirectMode(modes[active_mode].name == "Direct");
     DeviceUpdateLEDs();
 }

Controllers/MSIGPUController/MSIGPUController.h

@@ -12,46 +12,53 @@
 
 typedef unsigned char msi_gpu_dev_id;
 
+#define MSI_GPU_SPEED_MIN                   0
+#define MSI_GPU_SPEED_MID                   1
+#define MSI_GPU_SPEED_MAX                   2
+#define MSI_GPU_BRIGHTNESS_MIN              0
+#define MSI_GPU_BRIGHTNESS_MAX              5
+#define MSI_GPU_BRIGHTNESS_MULTI            20
+
 enum
 {
-    MSI_GPU_REG_BRIGHTNESS                 = 0x36,    /* MSI GPU Brightness Register     */
-    MSI_GPU_REG_SPEED                      = 0x38,    /* MSI GPU Speed Register          */
-    MSI_GPU_REG_UNKNOWN                    = 0x26,    /* MSI GPU Unknown Register        */
-    MSI_GPU_REG_R1                         = 0x30,    /* MSI GPU R1 Register             */
-    MSI_GPU_REG_G1                         = 0x31,    /* MSI GPU G1 Register             */
-    MSI_GPU_REG_B1                         = 0x32,    /* MSI GPU B1 Register             */
-    MSI_GPU_REG_R2                         = 0x27,    /* MSI GPU R2 Register             */
-    MSI_GPU_REG_G2                         = 0x28,    /* MSI GPU G2 Register             */
-    MSI_GPU_REG_B2                         = 0x29,    /* MSI GPU B2 Register             */
-    MSI_GPU_REG_R3                         = 0x2a,    /* MSI GPU R3 Register             */
-    MSI_GPU_REG_G3                         = 0x2b,    /* MSI GPU G3 Register             */
-    MSI_GPU_REG_B3                         = 0x2c,    /* MSI GPU B3 Register             */
-    MSI_GPU_REG_MODE                       = 0x22,    /* MSI GPU Mode Selection Register */
-    MSI_GPU_REG_SAVE                       = 0x3f,    /* MSI GPU Save Changes Register  */
+    MSI_GPU_REG_BRIGHTNESS                  = 0x36,     /* MSI GPU Brightness Register     */
+    MSI_GPU_REG_SPEED                       = 0x38,     /* MSI GPU Speed Register          */
+    MSI_GPU_REG_UNKNOWN                     = 0x26,     /* MSI GPU Unknown Register        */
+    MSI_GPU_REG_R1                          = 0x30,     /* MSI GPU R1 Register             */
+    MSI_GPU_REG_G1                          = 0x31,     /* MSI GPU G1 Register             */
+    MSI_GPU_REG_B1                          = 0x32,     /* MSI GPU B1 Register             */
+    MSI_GPU_REG_R2                          = 0x27,     /* MSI GPU R2 Register             */
+    MSI_GPU_REG_G2                          = 0x28,     /* MSI GPU G2 Register             */
+    MSI_GPU_REG_B2                          = 0x29,     /* MSI GPU B2 Register             */
+    MSI_GPU_REG_R3                          = 0x2A,     /* MSI GPU R3 Register             */
+    MSI_GPU_REG_G3                          = 0x2B,     /* MSI GPU G3 Register             */
+    MSI_GPU_REG_B3                          = 0x2C,     /* MSI GPU B3 Register             */
+    MSI_GPU_REG_MODE                        = 0x22,     /* MSI GPU Mode Selection Register */
+    MSI_GPU_REG_SAVE                        = 0x3F,     /* MSI GPU Save Changes Register  */
 };
 
 enum
 {
-    MSI_GPU_MODE_OFF                       = 0x01,        /* OFF mode                                            */
-    MSI_GPU_MODE_RAINBOW                   = 0x08,        /* Rainbow effect mode                                 */
-    MSI_GPU_MODE_STATIC                    = 0x13,        /* Static color mode                                   */
-    MSI_GPU_MODE_RAINDROP                  = 0x1a,        /* Raindrop effect mode                                */
-    MSI_GPU_MODE_MAGIC                     = 0x07,        /* Magic effect mode                                   */
-    MSI_GPU_MODE_PATROLLING                = 0x05,        /* Patrolling effect mode                              */
-    MSI_GPU_MODE_STREAMING                 = 0x06,        /* Streaming effect mode                               */
-    MSI_GPU_MODE_LIGHTNING                 = 0x15,        /* Lightning effect mode                               */
-    MSI_GPU_MODE_WAVE                      = 0x1f,        /* Wave effect mode                                    */
-    MSI_GPU_MODE_METEOR                    = 0x16,        /* Meteor effect mode                                  */
-    MSI_GPU_MODE_STACK                     = 0x0d,       /* Stack effect mode                                   */
-    MSI_GPU_MODE_RHYTHM                    = 0x0b,       /* Rhythm effect mode                                  */
-    MSI_GPU_MODE_FLOWING                   = 0x09,       /* Flowing effect mode                                 */
-    MSI_GPU_MODE_WHIRLING                  = 0x0f,       /* Whirling effect mode                                */
-    MSI_GPU_MODE_TWISTING                  = 0x11,       /* Twisting effect mode                                */
-    MSI_GPU_MODE_LAMINATING                = 0x1d,       /* Laminating effect mode                              */
-    MSI_GPU_MODE_FADEIN                    = 0x14,       /* Fadein effect mode                                  */
-    MSI_GPU_MODE_BREATHING                 = 0x04,       /* Breathing effect mode                               */
-    MSI_GPU_MODE_FLASHING                  = 0x02,       /* Flashing effect mode                                */
-    MSI_GPU_MODE_DOUBLEFLASHING            = 0x03,       /* Doubleflashing effect mode                          */
+    MSI_GPU_MODE_OFF                        = 0x01,     /* OFF mode                                            */
+    MSI_GPU_MODE_RAINBOW                    = 0x08,     /* Rainbow effect mode                                 */
+    MSI_GPU_MODE_STATIC                     = 0x13,     /* Static color mode                                   */
+    MSI_GPU_MODE_RAINDROP                   = 0x1A,     /* Raindrop effect mode                                */
+    MSI_GPU_MODE_MAGIC                      = 0x07,     /* Magic effect mode                                   */
+    MSI_GPU_MODE_PATROLLING                 = 0x05,     /* Patrolling effect mode                              */
+    MSI_GPU_MODE_STREAMING                  = 0x06,     /* Streaming effect mode                               */
+    MSI_GPU_MODE_LIGHTNING                  = 0x15,     /* Lightning effect mode                               */
+    MSI_GPU_MODE_WAVE                       = 0x1F,     /* Wave effect mode                                    */
+    MSI_GPU_MODE_METEOR                     = 0x16,     /* Meteor effect mode                                  */
+    MSI_GPU_MODE_STACK                      = 0x0D,     /* Stack effect mode                                   */
+    MSI_GPU_MODE_RHYTHM                     = 0x0B,     /* Rhythm effect mode                                  */
+    MSI_GPU_MODE_FLOWING                    = 0x09,     /* Flowing effect mode                                 */
+    MSI_GPU_MODE_WHIRLING                   = 0x0F,     /* Whirling effect mode                                */
+    MSI_GPU_MODE_TWISTING                   = 0x11,     /* Twisting effect mode                                */
+    MSI_GPU_MODE_LAMINATING                 = 0x1D,     /* Laminating effect mode                              */
+    MSI_GPU_MODE_FADEIN                     = 0x14,     /* Fadein effect mode                                  */
+    MSI_GPU_MODE_BREATHING                  = 0x04,     /* Breathing effect mode                               */
+    MSI_GPU_MODE_FLASHING                   = 0x02,     /* Flashing effect mode                                */
+    MSI_GPU_MODE_DOUBLEFLASHING             = 0x03,     /* Doubleflashing effect mode                          */
 };
 
 class MSIGPUController