API5 PLUGIN CHANGE: Add function for plugins to save profiles, add RGBController static functions to plugin API

Two problems surfaced once disconnect stopped crashing.

Disconnecting the automatic local connection left auto_connection_client
pointing at the freed client and auto_connection_active still true.
RescanDevices and GetDetectionPercent/String trust those, so a rescan
afterward called into freed memory and aborted (std::system_error from
send_in_progress.lock() on a destroyed mutex). Clear the pointer and the
flag in the teardown when the removed client is the auto connection.

onDetectionEnded never lowered the detection view; only the progress
handler did, at 100 percent. A real detection reaches 100, but a client
teardown borrows DETECTION_STARTED/COMPLETE to make plugins release the
controllers and sends no progress, so the "detecting devices" overlay
stuck on after a disconnect until Cancel. Lower it unconditionally when
the sequence ends.

.gitlab-ci.yml

@@ -536,10 +536,7 @@ before_script:
   - macos
   stage: build
   script:
-  - eval $(/opt/homebrew/bin/brew shellenv)
-  - qmake OpenRGB.pro
-  - make -j16
-  - macdeployqt OpenRGB.app -codesign=OpenRGB
+  - ./scripts/build-macos.sh qt6 arm
 
   artifacts:
     name: "${CI_PROJECT_NAME}_MacOS_ARM64_${CI_COMMIT_SHORT_SHA}"
@@ -555,10 +552,7 @@ before_script:
   - macos
   stage: build
   script:
-  - eval $(/opt/homebrew/bin/brew shellenv)
-  - /opt/homebrew/opt/qt@5/bin/qmake OpenRGB.pro
-  - make -j16
-  - /opt/homebrew/opt/qt@5/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
+  - ./scripts/build-macos.sh qt5 arm
 
   artifacts:
     name: "${CI_PROJECT_NAME}_MacOS_Qt5_ARM64_${CI_COMMIT_SHORT_SHA}"
@@ -574,10 +568,7 @@ before_script:
   - macos
   stage: build
   script:
-  - eval $(/usr/local/bin/brew shellenv)
-  - arch -x86_64 /usr/local/bin/qmake OpenRGB.pro
-  - arch -x86_64 make -j16
-  - arch -x86_64 /usr/local/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
+  - ./scripts/build-macos.sh qt6 intel
 
   artifacts:
     name: "${CI_PROJECT_NAME}_MacOS_Intel_${CI_COMMIT_SHORT_SHA}"
@@ -593,10 +584,7 @@ before_script:
   - macos
   stage: build
   script:
-  - eval $(/usr/local/bin/brew shellenv)
-  - arch -x86_64 /usr/local/opt/qt@5/bin/qmake OpenRGB.pro
-  - arch -x86_64 make -j16
-  - arch -x86_64 /usr/local/opt/qt@5/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
+  - ./scripts/build-macos.sh qt5 intel
 
   artifacts:
     name: "${CI_PROJECT_NAME}_MacOS_Intel_Qt5_${CI_COMMIT_SHORT_SHA}"

AutoStart/AutoStart-Linux.cpp

@@ -119,6 +119,21 @@ bool AutoStart::IsAutoStartEnabled()
 
 std::string AutoStart::GetExePath()
 {
+    /*-----------------------------------------------------*\
+    | When running from an AppImage, the AppImage runtime   |
+    | sets the APPIMAGE environment variable to the path of |
+    | the AppImage file itself.  /proc/self/exe would       |
+    | instead point at the extracted binary inside the      |
+    | temporary squashfs mount, which disappears once the   |
+    | AppImage is closed, so prefer APPIMAGE when it is set |
+    \*-----------------------------------------------------*/
+    const char* appimage_path = getenv("APPIMAGE");
+
+    if(appimage_path != NULL)
+    {
+        return(std::string(appimage_path));
+    }
+
     /*-----------------------------------------------------*\
     | Create the OpenRGB executable path                    |
     \*-----------------------------------------------------*/

CONTRIBUTING.md

@@ -69,3 +69,7 @@ OpenRGB is written in C++, uses the Qt framework for UI, and uses the QMake buil
 
 Translation files are located in [`OpenRGB/qt/i18n/`](https://gitlab.com/CalcProgrammer1/OpenRGB/-/tree/master/qt/i18n), where languages are formatted using ISO 639-1 format: `OpenRGB_xx_XX.ts` — `xx_XX` representing the language code.
 In order to translate a file, you need to [fork](https://gitlab.com/CalcProgrammer1/OpenRGB/-/forks/new) the project, create a new file for your language with `lupdate` (or edit an exisiting one), edit the file with `qtlinguist`, commit, push, and create a merge request.
+
+## AI Guidelines
+
+OpenRGB is an open source project developed by humans for humans.  As a general rule, AI generated submissions are not permitted.  The licensing behind AI generated code is problematic.  If you choose to use AI for assistance in your development process, we can't stop you, but do not credit the AI in commits (no AI authorship/co-authorship).  Ultimately, you as a human developer are responsible for the code you submit and it is expected that any code you submit you fully understand and have manually vetted before submission.  Merge requests that appear to be straight from an AI output, commits with AI tool authorship or co-authorship tags, or otherwise AI generated submissions are subject to closure.

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -1,66 +0,0 @@
-/*---------------------------------------------------------*\
-| A4TechDetector.cpp                                        |
-|                                                           |
-|   Detector for A4Tech Devices                             |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
-#include "BloodyB820RController.h"
-#include "BloodyMouseController.h"
-#include "DetectionManager.h"
-#include "RGBController_BloodyB820R.h"
-#include "RGBController_BloodyMouse.h"
-
-/*---------------------------------------------------------*\
-| A4 Tech USB vendor ID                                     |
-\*---------------------------------------------------------*/
-#define A4_TECH_VID                                 0x09DA
-
-DetectedControllers DetectA4TechMouseControllers(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        BloodyMouseController*     controller       = new BloodyMouseController(dev, info->path, info->product_id, name);
-        RGBController_BloodyMouse* rgb_controller   = new RGBController_BloodyMouse(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
-
-DetectedControllers DetectBloodyB820R(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path, name);
-        RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
-
-REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
-REGISTER_HID_DETECTOR_IPU("Bloody W70 Max",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W70_MAX_PID,     2,      0xFF33,     0x0518);
-REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
-REGISTER_HID_DETECTOR_IPU("Bloody W90 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_PRO_PID,     2,      0xFF33,     0x054D);
-REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
-REGISTER_HID_DETECTOR_IPU("Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);

Controllers/A4TechController/BloodyB820RController/BloodyB820RControllerDetect.cpp

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------*\
+| BloodyB820RControllerDetect.cpp                           |
+|                                                           |
+|   Detector for Bloody B820R Devices                       |
+|                                                           |
+|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "BloodyB820RController.h"
+#include "DetectionManager.h"
+#include "RGBController_BloodyB820R.h"
+
+/*---------------------------------------------------------*\
+| A4 Tech USB vendor ID                                     |
+\*---------------------------------------------------------*/
+#define A4_TECH_VID                                 0x09DA
+
+DetectedControllers DetectBloodyB820R(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path, name);
+        RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_IPU("Bloody B820R", DetectBloodyB820R, A4_TECH_VID, BLOODY_B820R_PID, 2, 0xFF52, 0x0210);

Controllers/A4TechController/BloodyMouseController/BloodyMouseControllerDetect.cpp

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------*\
+| BloodyMouseControllerDetect.cpp                           |
+|                                                           |
+|   Detector for Bloody Mouse Devices                       |
+|                                                           |
+|   Chris M (Dr_No)                             30 Jun 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "BloodyMouseController.h"
+#include "DetectionManager.h"
+#include "RGBController_BloodyMouse.h"
+
+/*---------------------------------------------------------*\
+| A4 Tech USB vendor ID                                     |
+\*---------------------------------------------------------*/
+#define A4_TECH_VID                                 0x09DA
+
+DetectedControllers DetectBloodyMouseControllers(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        BloodyMouseController*     controller       = new BloodyMouseController(dev, info->path, info->product_id, name);
+        RGBController_BloodyMouse* rgb_controller   = new RGBController_BloodyMouse(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_W60_PRO_PID, 2,  0xFF33, 0x0529);
+REGISTER_HID_DETECTOR_IPU("Bloody W70 Max",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_W70_MAX_PID, 2,  0xFF33, 0x0518);
+REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_W90_MAX_PID, 2,  0xFF33, 0x053D);
+REGISTER_HID_DETECTOR_IPU("Bloody W90 Pro",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_W90_PRO_PID, 2,  0xFF33, 0x054D);
+REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_MP_50RS_PID, 2,  0xFFF2, 0x6009);

Controllers/AOCKeyboardController/AOCKeyboardController.cpp

@@ -31,7 +31,7 @@ AOCKeyboardController::~AOCKeyboardController()
 
 std::string AOCKeyboardController::GetDeviceLocation()
 {
-    return("HID " + location);
+    return("HID: " + location);
 }
 
 std::string AOCKeyboardController::GetDeviceName()

Controllers/AOCMouseController/AOCMouseController.cpp

@@ -27,7 +27,7 @@ AOCMouseController::~AOCMouseController()
 
 std::string AOCMouseController::GetDeviceLocation()
 {
-    return("HID " + location);
+    return("HID: " + location);
 }
 
 std::string AOCMouseController::GetDeviceName()

Controllers/AOCMousematController/AOCMousematController.cpp

@@ -27,7 +27,7 @@ AOCMousematController::~AOCMousematController()
 
 std::string AOCMousematController::GetDeviceLocation()
 {
-    return("HID " + location);
+    return("HID: " + location);
 }
 
 std::string AOCMousematController::GetDeviceName()

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -269,7 +269,7 @@ void RGBController_PolychromeUSB::SetupZones()
             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;
+            new_led.value = (unsigned int)channel_idx;
 
             leds.push_back(new_led);
         }
@@ -334,9 +334,14 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
     }
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
+        if(zones[zone_idx].leds_count == 0)
+        {
+            continue;
+        }
+
         unsigned char set_mode = zones_info[zone_idx].mode;
 
-        if (set_mode>modes.size())
+        if(set_mode>modes.size())
         {
             set_mode = active_mode;
         }
@@ -347,6 +352,11 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
 
 void RGBController_PolychromeUSB::DeviceUpdateZoneLEDs(int zone)
 {
+    if(zones[zone].leds_count == 0)
+    {
+        return;
+    }
+
     unsigned char set_mode=zones_info[zone].mode;
 
     if(set_mode > modes.size())
@@ -354,7 +364,7 @@ void RGBController_PolychromeUSB::DeviceUpdateZoneLEDs(int zone)
         set_mode = active_mode;
     }
 
-    controller->WriteZone(zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
+    controller->WriteZone((unsigned char)zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
 }
 
 void RGBController_PolychromeUSB::DeviceUpdateSingleLED(int led)
@@ -362,12 +372,17 @@ void RGBController_PolychromeUSB::DeviceUpdateSingleLED(int led)
     unsigned int  channel  = leds[led].value;
     unsigned char set_mode = zones_info[channel].mode;
 
+    if(zones[channel].leds_count == 0)
+    {
+        return;
+    }
+
     if(set_mode > modes.size())
     {
         set_mode = active_mode;
     }
 
-    controller->WriteZone(channel, set_mode, zones_info[channel].speed, zones[channel].colors[0], false);
+    controller->WriteZone((unsigned char)channel, set_mode, zones_info[channel].speed, zones[channel].colors[0], false);
 }
 
 unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/ASRockASRRGBSMBusController.cpp

@@ -36,7 +36,7 @@ ASRockASRRGBSMBusController::~ASRockASRRGBSMBusController()
 
 std::string ASRockASRRGBSMBusController::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");

Controllers/ASRockSMBusController/ASRockGPUSMBusController/ASRockGPUSMBusController.cpp

@@ -0,0 +1,199 @@
+/*---------------------------------------------------------*\
+| ASRockGPUSMBusController.cpp                              |
+|                                                           |
+|   Driver for ASRock GPU RGB controllers                   |
+|                                                           |
+|   Based on SignalRGB ASRock GPU.js plugin                 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "ASRockGPUSMBusController.h"
+#include "LogManager.h"
+#include <chrono>
+#include <cstdio>
+#include <cstring>
+#include <thread>
+
+using namespace std::chrono_literals;
+
+ASRockGPUSMBusController::ASRockGPUSMBusController(i2c_smbus_interface* bus, asrock_gpu_dev_id dev, std::string name)
+{
+    this->bus          = bus;
+    this->dev          = dev;
+    this->device_name  = name;
+    this->num_channels = 0;
+
+    memset(enabled_channels, 0, sizeof(enabled_channels));
+    memset(led_counts, 0, sizeof(led_counts));
+}
+
+ASRockGPUSMBusController::~ASRockGPUSMBusController()
+{
+}
+
+std::string ASRockGPUSMBusController::GetDeviceLocation()
+{
+    std::string return_string(bus->info.device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+std::string ASRockGPUSMBusController::GetDeviceName()
+{
+    return(device_name);
+}
+
+bool ASRockGPUSMBusController::WriteBlock(uint8_t command, uint8_t subcommand, const uint8_t* data, uint8_t len)
+{
+    /*-----------------------------------------------------*\
+    | SignalRGB packet format                              |
+    | [command, 0, subcommand, data...]                    |
+    | Uses pure I2C rather than SMBus                      |
+    \*-----------------------------------------------------*/
+    uint8_t packet[12];
+    memset(packet, 0, sizeof(packet));
+
+    packet[0] = command;
+    packet[1] = 0x00;
+    packet[2] = subcommand;
+
+    if(data != nullptr && len > 0)
+    {
+        uint8_t copy_len = (len > 9) ? 9 : len;
+        memcpy(&packet[3], data, copy_len);
+    }
+
+    int size   = 12;
+    int result = bus->i2c_write_block(dev, size, packet);
+
+    if(result < 0)
+    {
+        LOG_DEBUG("[ASRock GPU] Write block failed: %d", result);
+        return(false);
+    }
+
+    return(true);
+}
+
+bool ASRockGPUSMBusController::ReadBlock(uint8_t* response, uint8_t len)
+{
+    memset(response, 0, len);
+    int size   = len;
+    int result = bus->i2c_read_block(dev, &size, response);
+
+    if(result < 0)
+    {
+        LOG_DEBUG("[ASRock GPU] Read block failed: %d", result);
+        return(false);
+    }
+
+    return(true);
+}
+
+bool ASRockGPUSMBusController::DetectChannels()
+{
+    /*-----------------------------------------------------*\
+    | Get enabled channels                                 |
+    | Command 0x14, subcommand 0x01                        |
+    \*-----------------------------------------------------*/
+    if(!WriteBlock(0x14, 0x01, nullptr, 0))
+    {
+        LOG_WARNING("[ASRock GPU] Failed to request enabled channels");
+        return(false);
+    }
+
+    std::this_thread::sleep_for(20ms);
+
+    uint8_t response[I2C_SMBUS_BLOCK_MAX];
+    if(!ReadBlock(response, sizeof(response)))
+    {
+        LOG_WARNING("[ASRock GPU] Failed to read enabled channels");
+        return(false);
+    }
+
+    LOG_TRACE("[ASRock GPU] Enabled channels response: %02X %02X %02X %02X %02X %02X", response[0], response[1], response[2], response[3], response[4], response[5]);
+
+    /*-----------------------------------------------------*\
+    | Response format                                      |
+    | Bytes 4-5 contain the channel bitmap                 |
+    \*-----------------------------------------------------*/
+    uint16_t channel_bits = response[4] | (response[5] << 8);
+    LOG_TRACE("[ASRock GPU] Channel bits: 0x%04X", channel_bits);
+
+    /*-----------------------------------------------------*\
+    | Get LED counts                                       |
+    | Command 0x14, subcommand 0x02                        |
+    \*-----------------------------------------------------*/
+    if(!WriteBlock(0x14, 0x02, nullptr, 0))
+    {
+        LOG_WARNING("[ASRock GPU] Failed to request LED counts");
+        return(false);
+    }
+
+    std::this_thread::sleep_for(20ms);
+
+    if(!ReadBlock(response, sizeof(response)))
+    {
+        LOG_WARNING("[ASRock GPU] Failed to read LED counts");
+        return(false);
+    }
+
+    num_channels = 0;
+    for(int i = 0; i < 16; i++)
+    {
+        if(channel_bits & (1 << i))
+        {
+            enabled_channels[num_channels] = i;
+            led_counts[num_channels]       = response[4 + i];
+
+            const char* name = "Unknown";
+            if(i == ASROCK_GPU_CHANNEL_ARGB_HEADER)
+            {
+                name = "ARGB Header";
+            }
+            else if(i == ASROCK_GPU_CHANNEL_TOP_SIDE)
+            {
+                name = "Top Side";
+            }
+            else if(i == ASROCK_GPU_CHANNEL_FAN)
+            {
+                name = "Fan";
+            }
+
+            LOG_DEBUG("[ASRock GPU] Channel %d (%s) active with %d LEDs", i, name, response[4 + i]);
+            num_channels++;
+        }
+    }
+
+    LOG_DEBUG("[ASRock GPU] Found %d active channels", num_channels);
+    return(num_channels > 0);
+}
+
+void ASRockGPUSMBusController::SetChannelColor(uint8_t channel_idx, uint8_t red, uint8_t green, uint8_t blue)
+{
+    /*-----------------------------------------------------*\
+    | SignalRGB color packet                               |
+    | Command 0x10, subcommand is the channel index        |
+    \*-----------------------------------------------------*/
+    uint8_t data[8] =
+    {
+        0x01,  // Mode: direct/static
+        red,
+        green,
+        blue,
+        0x80,  // Brightness
+        0xFF,  // Effect speed
+        0x00,  // Effect direction
+        0x1A   // Unknown constant
+    };
+
+    if(!WriteBlock(0x10, channel_idx, data, sizeof(data)))
+    {
+        LOG_WARNING("[ASRock GPU] Failed to set color for channel %d", channel_idx);
+    }
+}

Controllers/ASRockSMBusController/ASRockGPUSMBusController/ASRockGPUSMBusController.h

@@ -0,0 +1,55 @@
+/*---------------------------------------------------------*\
+| ASRockGPUSMBusController.h                                |
+|                                                           |
+|   Driver for ASRock GPU RGB controllers                   |
+|                                                           |
+|   Based on SignalRGB ASRock GPU.js plugin                 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include "i2c_smbus.h"
+
+typedef uint8_t asrock_gpu_dev_id;
+
+#define ASROCK_GPU_CONTROLLER_NAME   "ASRock GPU SMBus Controller"
+#define ASROCK_GPU_SMBUS_ADDRESS     0x36
+
+/*-----------------------------------------------------*\
+| ASRock GPU Channel Names (from SignalRGB)             |
+\*-----------------------------------------------------*/
+enum
+{
+    ASROCK_GPU_CHANNEL_ARGB_HEADER  = 3,
+    ASROCK_GPU_CHANNEL_TOP_SIDE     = 6,
+    ASROCK_GPU_CHANNEL_FAN          = 7,
+};
+
+class ASRockGPUSMBusController
+{
+public:
+    ASRockGPUSMBusController(i2c_smbus_interface* bus, asrock_gpu_dev_id dev, std::string name);
+    ~ASRockGPUSMBusController();
+
+    std::string GetDeviceLocation();
+    std::string GetDeviceName();
+
+    void        SetChannelColor(uint8_t channel_idx, uint8_t red, uint8_t green, uint8_t blue);
+    bool        DetectChannels();
+
+    uint8_t     enabled_channels[16];
+    uint8_t     led_counts[16];
+    uint8_t     num_channels;
+
+private:
+    i2c_smbus_interface* bus;
+    asrock_gpu_dev_id    dev;
+    std::string          device_name;
+
+    bool        WriteBlock(uint8_t command, uint8_t subcommand, const uint8_t* data, uint8_t len);
+    bool        ReadBlock(uint8_t* response, uint8_t len);
+};

Controllers/ASRockSMBusController/ASRockGPUSMBusController/ASRockGPUSMBusControllerDetect.cpp

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------*\
+| ASRockGPUSMBusControllerDetect.cpp                        |
+|                                                           |
+|   Detector for ASRock GPU RGB controllers                 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "DetectionManager.h"
+#include "ASRockGPUSMBusController.h"
+#include "LogManager.h"
+#include "RGBController_ASRockGPUSMBus.h"
+#include "i2c_smbus.h"
+#include "pci_ids.h"
+
+DetectedControllers DetectASRockGPUSMBusControllers(i2c_smbus_interface* bus, uint8_t address, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+
+    LOG_DEBUG("[ASRock GPU] Checking GPU I2C bus for RGB controller at 0x%02X", address);
+
+    if(bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE) < 0)
+    {
+        LOG_DEBUG("[ASRock GPU] No response at address 0x%02X", address);
+        return(detected_controllers);
+    }
+
+    LOG_DEBUG("[ASRock GPU] Device responded at 0x%02X, creating controller", address);
+
+    ASRockGPUSMBusController* controller = new ASRockGPUSMBusController(bus, address, name);
+
+    if(controller->DetectChannels())
+    {
+        detected_controllers.push_back(new RGBController_ASRockGPUSMBus(controller));
+    }
+    else
+    {
+        LOG_WARNING("[ASRock GPU] No active channels found, device not registered");
+        delete controller;
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Steel Legend", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5403, ASROCK_GPU_SMBUS_ADDRESS);

Controllers/ASRockSMBusController/ASRockGPUSMBusController/RGBController_ASRockGPUSMBus.cpp

@@ -0,0 +1,127 @@
+/*---------------------------------------------------------*\
+| RGBController_ASRockGPUSMBus.cpp                          |
+|                                                           |
+|   RGBController for ASRock GPU RGB controllers            |
+|                                                           |
+|   Based on SignalRGB ASRock GPU.js plugin                 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_ASRockGPUSMBus.h"
+
+RGBController_ASRockGPUSMBus::RGBController_ASRockGPUSMBus(ASRockGPUSMBusController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = controller->GetDeviceName();
+    vendor      = "ASRock";
+    type        = DEVICE_TYPE_GPU;
+    description = "ASRock GPU RGB Controller";
+    location    = controller->GetDeviceLocation();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_ASRockGPUSMBus::~RGBController_ASRockGPUSMBus()
+{
+    delete controller;
+}
+
+void RGBController_ASRockGPUSMBus::SetupZones()
+{
+    /*-----------------------------------------------------*\
+    | Set up zones - one zone per channel                   |
+    \*-----------------------------------------------------*/
+    for(unsigned int i = 0; i < controller->num_channels; i++)
+    {
+        uint8_t channel_idx = controller->enabled_channels[i];
+        
+        zone new_zone;
+        new_zone.type = ZONE_TYPE_SINGLE;
+        new_zone.leds_min = 1;
+        new_zone.leds_max = 1;
+        new_zone.leds_count = 1;
+        
+        /*-----------------------------------------------------*\
+        | Channel names from SignalRGB                          |
+        \*-----------------------------------------------------*/
+        if(channel_idx == ASROCK_GPU_CHANNEL_ARGB_HEADER)
+        {
+            new_zone.name = "ARGB Header";
+        }
+        else if(channel_idx == ASROCK_GPU_CHANNEL_TOP_SIDE)
+        {
+            new_zone.name = "Top Side";
+        }
+        else if(channel_idx == ASROCK_GPU_CHANNEL_FAN)
+        {
+            new_zone.name = "Fan";
+        }
+        else
+        {
+            new_zone.name = "Channel " + std::to_string(channel_idx);
+        }
+        
+        zones.push_back(new_zone);
+        
+        /*-----------------------------------------------------*\
+        | Set up LED for this zone                              |
+        \*-----------------------------------------------------*/
+        led new_led;
+        new_led.name = new_zone.name;
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_ASRockGPUSMBus::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*-----------------------------------------------------*\
+    | This device does not support resizing zones           |
+    \*-----------------------------------------------------*/
+}
+
+void RGBController_ASRockGPUSMBus::DeviceUpdateLEDs()
+{
+    for(unsigned int i = 0; i < controller->num_channels; i++)
+    {
+        uint8_t channel_idx = controller->enabled_channels[i];
+        RGBColor color = colors[i];
+        
+        controller->SetChannelColor(channel_idx, 
+                                    RGBGetRValue(color),
+                                    RGBGetGValue(color),
+                                    RGBGetBValue(color));
+    }
+}
+
+void RGBController_ASRockGPUSMBus::UpdateZoneLEDs(int zone)
+{
+    uint8_t channel_idx = controller->enabled_channels[zone];
+    RGBColor color = colors[zone];
+    
+    controller->SetChannelColor(channel_idx,
+                                RGBGetRValue(color),
+                                RGBGetGValue(color),
+                                RGBGetBValue(color));
+}
+
+void RGBController_ASRockGPUSMBus::UpdateSingleLED(int led)
+{
+    UpdateZoneLEDs(led);
+}
+
+void RGBController_ASRockGPUSMBus::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}

Controllers/ASRockSMBusController/ASRockGPUSMBusController/RGBController_ASRockGPUSMBus.h

@@ -0,0 +1,34 @@
+/*---------------------------------------------------------*\
+| RGBController_ASRockGPUSMBus.h                            |
+|                                                           |
+|   RGBController for ASRock GPU RGB controllers            |
+|                                                           |
+|   Based on SignalRGB ASRock GPU.js plugin                 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockGPUSMBusController.h"
+
+class RGBController_ASRockGPUSMBus : public RGBController
+{
+public:
+    RGBController_ASRockGPUSMBus(ASRockGPUSMBusController* controller_ptr);
+    ~RGBController_ASRockGPUSMBus();
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    ASRockGPUSMBusController* controller;
+};

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/ASRockPolychromeV1SMBusController.cpp

@@ -36,7 +36,7 @@ ASRockPolychromeV1SMBusController::~ASRockPolychromeV1SMBusController()
 
 std::string ASRockPolychromeV1SMBusController::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/ASRockPolychromeV2SMBusController.cpp

@@ -37,7 +37,7 @@ ASRockPolychromeV2SMBusController::~ASRockPolychromeV2SMBusController()
 
 std::string ASRockPolychromeV2SMBusController::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

@@ -238,7 +238,6 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
         }
     }
 
-    unsigned int led_count = 0;
     /*---------------------------------------------------------*\
     | Set up LEDs                                               |
     \*---------------------------------------------------------*/
@@ -268,8 +267,6 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                 \*---------------------------------------------------------*/
                 leds.push_back(*new_led);
 
-                led_count++;
-
                 if(zone_idx == POLYCHROME_V2_ZONE_ADDRESSABLE)
                 {
                     break;

Controllers/ASRockSMBusController/ASRockSMBusControllerDetect.cpp

@@ -91,9 +91,9 @@ DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface
 
     for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
-        IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
+        IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
         {
-            if(buses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
+            if(buses[bus]->info.pci_subsystem_vendor == ASROCK_SUB_VEN)
             {
                 LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
                 // Check for Polychrome controller at 0x6A

Controllers/AcerNitroHidKeyboardController/AcerHidKeyboardControllerDetect.cpp

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------*\
+| RGBController_AcerNitroHidKeyboard.cpp                    |
+|                                                           |
+|   Detector for Acer Nitro HID Keyboard                    |
+|                                                           |
+|   Marek Pokropiński                           Jul 27 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <vector>
+#include "DetectionManager.h"
+#include "AcerNitroHidKeyboardController.h"
+#include "RGBController_AcerNitroHidKeyboard.h"
+#include "RGBController_AcerNitroHidLed.h"
+
+/*---------------------------------------------------------*\
+| HID vendor and product IDs for ENEK EC in Acer Nitro      |
+\*---------------------------------------------------------*/
+
+#define ACER_ENEC_VID           0x0CF2
+#define ACER_ENEC_PID           0x5130
+#define ACER_ENEC_USAGE_PAGE    0xFF5A
+#define ACER_ENEC_USAGE         0x01
+
+DetectedControllers DetectAcerHIDControllers(hid_device_info* info, const std::string&)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+    if(dev)
+    {
+        /*-------------------------------------------------*\
+        | Controller is shared between keyboard and onboard |
+        | led                                               |
+        \*-------------------------------------------------*/
+        std::shared_ptr<AcerNitroHidKeyboardController> controller  = std::make_shared<AcerNitroHidKeyboardController>(dev, info->path);
+        RGBController_AcerNitroHidKeyboard* rgb_kb_controller       = new RGBController_AcerNitroHidKeyboard(controller);
+        RGBController_AcerNitroHidLed* rgb_led_controller           = new RGBController_AcerNitroHidLed(controller);
+
+        detected_controllers.push_back(rgb_kb_controller);
+        detected_controllers.push_back(rgb_led_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_PU("AcerNitroHidKeyboardController", DetectAcerHIDControllers, ACER_ENEC_VID, ACER_ENEC_PID, ACER_ENEC_USAGE_PAGE, ACER_ENEC_USAGE);

Controllers/AcerNitroHidKeyboardController/AcerNitroHidKeyboardController.cpp

@@ -0,0 +1,80 @@
+/*---------------------------------------------------------*\
+| RGBController_AcerNitroHidKeyboard.cpp                    |
+|                                                           |
+|   Driver for Acer Nitro Keyboard                          |
+|                                                           |
+|   Marek Pokropiński                           Jul 27 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "AcerNitroHidKeyboardController.h"
+
+AcerNitroHidKeyboardController::AcerNitroHidKeyboardController(hid_device *dev_handle, const char *path)
+{
+    this->location  = path;
+    this->dev       = dev_handle;
+
+    device_name     = "Acer Nitro HID Keyboard";    
+}
+
+AcerNitroHidKeyboardController::~AcerNitroHidKeyboardController()
+{
+    if(dev)
+    {
+        hid_close(dev);
+    }
+}
+
+std::string AcerNitroHidKeyboardController::GetLocation() const
+{
+    return("HID: " + location);
+}
+
+std::string AcerNitroHidKeyboardController::GetDeviceName() const
+{
+    return(device_name);
+}
+
+void AcerNitroHidKeyboardController::SetLEDs(const std::vector<RGBColor>& colors, unsigned char brightness, unsigned char device_id)
+{
+    std::lock_guard<std::mutex> guard(device_mutex);
+
+    for(unsigned int led_idx = 0; (led_idx < colors.size()) && (led_idx < ACER_HID_NUM_ZONES); led_idx++)
+    {
+        /*-------------------------------------------------*\
+        | Convert colors to RGB format                      |
+        \*-------------------------------------------------*/
+        unsigned char r = RGBGetRValue(colors[led_idx]);
+        unsigned char g = RGBGetGValue(colors[led_idx]);        
+        unsigned char b = RGBGetBValue(colors[led_idx]);
+
+        /*-------------------------------------------------*\
+        | Send packet                                       |
+        \*-------------------------------------------------*/
+        unsigned char zone_select                   = (unsigned char)(1<<led_idx);
+        unsigned char packet[ACER_HID_PACKET_SIZE]  = {0xA4, device_id, ACER_HID_MODE_STATIC, brightness, 0, 1, r, g, b, zone_select, 0};
+        hid_send_feature_report(dev, packet, ACER_HID_PACKET_SIZE);
+    }
+}
+
+void AcerNitroHidKeyboardController::SetAllLEDs(const RGBColor &color, unsigned char brightness, unsigned char speed, unsigned char direction, unsigned char mode, unsigned char device_id)
+{
+    std::lock_guard<std::mutex> guard(device_mutex);
+
+    /*-----------------------------------------------------*\
+    | Convert color to RGB format                           |
+    \*-----------------------------------------------------*/
+    unsigned char r = RGBGetRValue(color);
+    unsigned char g = RGBGetGValue(color);        
+    unsigned char b = RGBGetBValue(color);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    | Zone select = All zones                               |
+    \*-----------------------------------------------------*/
+    unsigned char zone_select                   = 0x0F;
+    unsigned char packet[ACER_HID_PACKET_SIZE]  = {0xA4, device_id, mode, brightness, speed, direction, r, g, b, zone_select, 0};
+    hid_send_feature_report(dev, packet, ACER_HID_PACKET_SIZE);
+}

Controllers/AcerNitroHidKeyboardController/AcerNitroHidKeyboardController.h

@@ -0,0 +1,56 @@
+/*---------------------------------------------------------*\
+| RGBController_AcerNitroHidKeyboard.cpp                    |
+|                                                           |
+|   Driver for Acer Nitro Keyboard                          |
+|                                                           |
+|   Marek Pokropiński                           Jul 27 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+enum
+{
+    ACER_HID_MODE_DIRECT    = 1,
+    ACER_HID_MODE_STATIC    = 2,
+    ACER_HID_MODE_BREATHING = 4,
+    ACER_HID_MODE_NEON      = 5,
+    ACER_HID_MODE_OPMODE    = 6,
+    ACER_HID_MODE_WAVE      = 7,
+    ACER_HID_MODE_SHIFTING  = 8,
+    ACER_HID_MODE_ZOOM      = 9,
+    ACER_HID_MODE_METEOR    = 10,
+    ACER_HID_MODE_TWINKLING = 11,
+};
+
+#define ACER_HID_NAME_BUFFER_SIZE 255
+#define ACER_HID_NUM_ZONES 4
+#define ACER_HID_PACKET_SIZE 11
+
+#include <mutex>
+#include <string>
+#include <vector>
+#include <hidapi.h>
+#include "RGBControllerInterface.h"
+
+class AcerNitroHidKeyboardController
+{
+public:
+    AcerNitroHidKeyboardController(hid_device *dev_handle, const char *path);
+    ~AcerNitroHidKeyboardController();
+
+    std::string GetDeviceName() const;
+    std::string GetSerial() const;
+    std::string GetLocation() const;
+
+    void SetLEDs(const std::vector<RGBColor> &colors, unsigned char brightness, unsigned char device_id);
+    void SetAllLEDs(const RGBColor &color, unsigned char brightness, unsigned char speed, unsigned char direction, unsigned char mode, unsigned char device_id);
+
+private:
+    hid_device *dev;
+    std::string device_name;
+    std::string location;
+    std::mutex device_mutex;
+};

Controllers/AcerNitroHidKeyboardController/RGBController_AcerNitroHidKeyboard.cpp

@@ -0,0 +1,231 @@
+/*---------------------------------------------------------*\
+| RGBController_AcerNitroHidKeyboard.cpp                    |
+|                                                           |
+|   RGBController for Acer Nitro HID Keyboard               |
+|                                                           |
+|   Marek Pokropiński                           Jul 27 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_AcerNitroHidKeyboard.h"
+
+// /**------------------------------------------------------------------*\
+//     @name Acer Nitro HID Keyboard
+//     @category Laptop
+//     @type HID
+//     @save :x:
+//     @direct :white_check_mark:
+//     @effects :white_check_mark:
+//     @detectors DetectAcerHIDControllers
+//     @comment
+// \*-------------------------------------------------------------------*/
+
+RGBController_AcerNitroHidKeyboard::RGBController_AcerNitroHidKeyboard(std::shared_ptr<AcerNitroHidKeyboardController> controller)
+{
+    this->controller            = controller;
+    device_id                   = 0x21;
+
+    name                        = "Acer Nitro HID Keyboard";
+    vendor                      = "Acer";
+    type                        = DEVICE_TYPE_LAPTOP;
+    description                 = "Acer Nitro HID Keyboard Device";
+    location                    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = ACER_HID_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS ;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    Direct.brightness_min       = 0;
+    Direct.brightness_max       = 100;
+    Direct.brightness           = 100;
+
+    modes.push_back(Direct);
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = ACER_HID_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR  | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.brightness_min       = 0;
+    Static.brightness_max       = 100;
+    Static.brightness           = 100;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(1);
+    Static.speed                = 0;
+
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = ACER_HID_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR  | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.brightness_min    = 0;
+    Breathing.brightness_max    = 100;
+    Breathing.brightness        = 100;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
+    Breathing.speed_min         = 1;
+    Breathing.speed_max         = 9;
+    Breathing.speed             = 4;
+    Breathing.colors.resize(1);    
+
+    modes.push_back(Breathing);
+
+    mode Neon;
+    Neon.name                   = "Neon";
+    Neon.value                  = ACER_HID_MODE_NEON;
+    Neon.flags                  = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Neon.color_mode             = MODE_COLORS_NONE;
+    Neon.brightness_min         = 0;
+    Neon.brightness_max         = 100;
+    Neon.brightness             = 100;
+    Neon.speed_min              = 1;
+    Neon.speed_max              = 9;
+    Neon.speed                  = 4;  
+
+    modes.push_back(Neon);
+
+    mode Wave;
+    Wave.name                   = "Wave";
+    Wave.value                  = ACER_HID_MODE_WAVE;
+    Wave.flags                  = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Wave.color_mode             = MODE_COLORS_NONE;
+    Wave.brightness_min         = 0;
+    Wave.brightness_max         = 100;
+    Wave.brightness             = 100;
+    Wave.speed_min              = 1;
+    Wave.speed_max              = 9;
+    Wave.speed                  = 4;
+    Wave.direction              = 0;
+
+    modes.push_back(Wave);
+    
+    mode Shifting;
+    Shifting.name               = "Shifting";
+    Shifting.value              = ACER_HID_MODE_SHIFTING;
+    Shifting.flags              = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Shifting.color_mode         = MODE_COLORS_NONE;
+    Shifting.brightness_min     = 0;
+    Shifting.brightness_max     = 100;
+    Shifting.brightness         = 100;
+    Shifting.speed_min          = 1;
+    Shifting.speed_max          = 9;
+    Shifting.speed              = 4;
+
+    modes.push_back(Shifting);
+
+    mode Zoom;
+    Zoom.name                   = "Zoom";
+    Zoom.value                  = ACER_HID_MODE_ZOOM;
+    Zoom.flags                  = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Zoom.color_mode             = MODE_COLORS_NONE;
+    Zoom.brightness_min         = 0;
+    Zoom.brightness_max         = 100;
+    Zoom.brightness             = 100;
+    Zoom.speed_min              = 1;
+    Zoom.speed_max              = 9;
+    Zoom.speed                  = 4;
+
+    modes.push_back(Zoom);
+
+    mode Meteor;
+    Meteor.name                 = "Meteor";
+    Meteor.value                = ACER_HID_MODE_METEOR;
+    Meteor.flags                = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Meteor.color_mode           = MODE_COLORS_NONE;
+    Meteor.brightness_min       = 0;
+    Meteor.brightness_max       = 100;
+    Meteor.brightness           = 100;
+    Meteor.speed_min            = 1;
+    Meteor.speed_max            = 9;
+    Meteor.speed                = 4;
+
+    modes.push_back(Meteor);
+
+    mode Twinkling;
+    Twinkling.name              = "Twinkling";
+    Twinkling.value             = ACER_HID_MODE_TWINKLING;
+    Twinkling.flags             = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Twinkling.color_mode        = MODE_COLORS_NONE;
+    Twinkling.brightness_min    = 0;
+    Twinkling.brightness_max    = 100;
+    Twinkling.brightness        = 100;
+    Twinkling.colors_min        = 1;
+    Twinkling.colors_max        = 1;
+    Twinkling.speed_min         = 1;
+    Twinkling.speed_max         = 9;
+    Twinkling.speed             = 4;
+
+    modes.push_back(Twinkling);
+
+    SetupZones();
+}
+
+RGBController_AcerNitroHidKeyboard::~RGBController_AcerNitroHidKeyboard()
+{
+    Shutdown();
+}
+
+void RGBController_AcerNitroHidKeyboard::SetupZones()
+{
+    zone* new_zone          = new zone;
+
+    new_zone->name          = "Keyboard Backlight Zone";
+    new_zone->type          = ZONE_TYPE_LINEAR;
+    new_zone->leds_min      = 4;
+    new_zone->leds_max      = 4;
+    new_zone->leds_count    = 4;
+
+    zones.push_back(*new_zone);
+
+    for(std::size_t zone_idx = 0; zone_idx < ACER_HID_NUM_ZONES; zone_idx++)
+    {
+        led* new_led        = new led();
+        new_led->name       = "Keyboard Backlight Zone ";
+        new_led->name.append(std::to_string(zone_idx + 1));
+        new_led->value      = (unsigned int)leds.size();
+
+        leds.push_back(*new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AcerNitroHidKeyboard::DeviceUpdateLEDs()
+{
+    mode& current_mode = modes[active_mode];
+    if(current_mode.value == ACER_HID_MODE_DIRECT) 
+    {
+        controller->SetLEDs(colors, current_mode.brightness, device_id);
+    }
+    else 
+    {
+        RGBColor color          = current_mode.colors.size()==0? (RGBColor)0 :  current_mode.colors[0];
+        unsigned char direction = 1;
+        if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && modes[active_mode].direction) 
+        {
+            direction           = 2;
+        }
+        controller->SetAllLEDs(color, current_mode.brightness, current_mode.speed, direction, current_mode.value, device_id);
+    }
+}
+
+void RGBController_AcerNitroHidKeyboard::DeviceUpdateZoneLEDs(int)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AcerNitroHidKeyboard::DeviceUpdateSingleLED(int)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AcerNitroHidKeyboard::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}

Controllers/AcerNitroHidKeyboardController/RGBController_AcerNitroHidKeyboard.h

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------*\
+| RGBController_AcerNitroHidKeyboard.cpp                    |
+|                                                           |
+|   RGBController for Acer Nitro HID Keyboard               |
+|                                                           |
+|   Marek Pokropiński                           Jul 27 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AcerNitroHidKeyboardController.h"
+
+class RGBController_AcerNitroHidKeyboard : public RGBController
+{
+public:
+    RGBController_AcerNitroHidKeyboard(std::shared_ptr<AcerNitroHidKeyboardController> controller);
+    ~RGBController_AcerNitroHidKeyboard();
+
+    void SetupZones();
+
+    void DeviceUpdateLEDs();
+    void DeviceUpdateZoneLEDs(int zone);
+    void DeviceUpdateSingleLED(int led);
+    void DeviceUpdateMode();
+
+private:
+    std::shared_ptr<AcerNitroHidKeyboardController> controller;
+    unsigned int device_id;
+};

Controllers/AcerNitroHidKeyboardController/RGBController_AcerNitroHidLed.cpp

@@ -0,0 +1,152 @@
+/*---------------------------------------------------------*\
+| RGBController_AcerNitroHidLed.cpp                         |
+|                                                           |
+|   RGBController for Acer Nitro HID LED                    |
+|                                                           |
+|   Marek Pokropiński                           Jul 27 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_AcerNitroHidLed.h"
+
+// /**------------------------------------------------------------------*\
+//     @name Acer Nitro HID Led
+//     @category Laptop
+//     @type HID
+//     @save :x:
+//     @direct :white_check_mark:
+//     @effects :white_check_mark:
+//     @detectors DetectAcerHIDControllers
+//     @comment
+// \*-------------------------------------------------------------------*/
+
+RGBController_AcerNitroHidLed::RGBController_AcerNitroHidLed(std::shared_ptr<AcerNitroHidKeyboardController> controller)
+{
+    this->controller            = controller;
+    device_id                   = 0x65;
+
+    name                        = "Acer Nitro HID LED Device";
+    vendor                      = "Acer";
+    type                        = DEVICE_TYPE_LIGHT;
+    description                 = "Acer Nitro HID LED Device";
+    location                    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = ACER_HID_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS ;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    Direct.brightness_min       = 0;
+    Direct.brightness_max       = 100;
+    Direct.brightness           = 100;
+
+    modes.push_back(Direct);
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = ACER_HID_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR  | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.brightness_min       = 0;
+    Static.brightness_max       = 100;
+    Static.brightness           = 100;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(1);
+    Static.speed                = 0;
+
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = ACER_HID_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR  | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.brightness_min    = 0;
+    Breathing.brightness_max    = 100;
+    Breathing.brightness        = 100;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
+    Breathing.speed_min         = 1;
+    Breathing.speed_max         = 5;
+    Breathing.speed             = 4;
+    Breathing.colors.resize(1);
+
+    modes.push_back(Breathing);
+
+    mode Neon;
+    Neon.name                   = "Neon";
+    Neon.value                  = ACER_HID_MODE_NEON;
+    Neon.flags                  = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Neon.color_mode             = MODE_COLORS_NONE;
+    Neon.brightness_min         = 0;
+    Neon.brightness_max         = 100;
+    Neon.brightness             = 100;
+    Neon.speed_min              = 1;
+    Neon.speed_max              = 5;
+    Neon.speed                  = 4;
+
+    modes.push_back(Neon);
+
+    SetupZones();
+}
+
+RGBController_AcerNitroHidLed::~RGBController_AcerNitroHidLed()
+{
+    Shutdown();
+}
+
+void RGBController_AcerNitroHidLed::SetupZones()
+{
+    zone* new_zone          = new zone;
+
+    new_zone->name          = "LED";
+    new_zone->type          = ZONE_TYPE_LINEAR;
+    new_zone->leds_min      = 1;
+    new_zone->leds_max      = 1;
+    new_zone->leds_count    = 1;
+    zones.push_back(*new_zone);
+    
+    led* new_led            = new led();
+    new_led->name           = "LED";
+    new_led->value          = (unsigned int)leds.size();
+    leds.push_back(*new_led);
+    
+    SetupColors();
+}
+
+void RGBController_AcerNitroHidLed::DeviceUpdateLEDs()
+{
+    mode& current_mode = modes[active_mode];
+    if(current_mode.value == ACER_HID_MODE_DIRECT) 
+    {
+        controller->SetLEDs(colors, current_mode.brightness, device_id);
+    }
+    else 
+    {
+        RGBColor color          = current_mode.colors.size()==0? (RGBColor)0 :  current_mode.colors[0];
+        unsigned char direction = 1;
+        if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && modes[active_mode].direction) 
+        {
+            direction           = 2;
+        }
+        controller->SetAllLEDs(color, current_mode.brightness, current_mode.speed, direction, current_mode.value, device_id);
+    }
+}
+
+void RGBController_AcerNitroHidLed::DeviceUpdateZoneLEDs(int)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AcerNitroHidLed::DeviceUpdateSingleLED(int)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AcerNitroHidLed::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}

Controllers/AcerNitroHidKeyboardController/RGBController_AcerNitroHidLed.h

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------*\
+| RGBController_AcerNitroHidLed.cpp                         |
+|                                                           |
+|   RGBController for Acer Nitro HID LED                    |
+|                                                           |
+|   Marek Pokropiński                           Jul 27 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AcerNitroHidKeyboardController.h"
+#include "RGBController_AcerNitroHidKeyboard.h"
+
+class RGBController_AcerNitroHidLed : public RGBController
+{
+public:
+    RGBController_AcerNitroHidLed(std::shared_ptr<AcerNitroHidKeyboardController> controller);
+    ~RGBController_AcerNitroHidLed();
+
+    void SetupZones();
+
+    void DeviceUpdateLEDs();
+    void DeviceUpdateZoneLEDs(int zone);
+    void DeviceUpdateSingleLED(int led);
+
+    void DeviceUpdateMode();
+
+private:
+    std::shared_ptr<AcerNitroHidKeyboardController> controller;
+    unsigned int device_id;
+};

Controllers/AlienwareKeyboardController/AlienwareAW410KController/AlienwareAW410KControllerDetect.cpp

@@ -1,7 +1,7 @@
 /*---------------------------------------------------------*\
-| AlienwareKeyboardControllerDetect.cpp                     |
+| AlienwareAW410KControllerDetect.cpp                       |
 |                                                           |
-|   Detector for Alienware Keyboard                         |
+|   Detector for Alienware AW410K Keyboard                  |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -10,38 +10,17 @@
 #include <hidapi.h>
 #include "DetectionManager.h"
 #include "AlienwareAW410KController.h"
-#include "AlienwareAW510KController.h"
 #include "RGBController_AlienwareAW410K.h"
-#include "RGBController_AlienwareAW510K.h"
 
 /*---------------------------------------------------------*\
 | Alienware vendor ID                                       |
 \*---------------------------------------------------------*/
-#define ALIENWARE_VID                           0x04F2
+#define ALIENWARE_VID                               0x04F2
 
 /*---------------------------------------------------------*\
 | Keyboard product IDs                                      |
 \*---------------------------------------------------------*/
-#define ALIENWARE_AW510K_PID                    0x1830
-#define ALIENWARE_AW410K_PID                    0x1968
-
-DetectedControllers DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path, name);
-        RGBController_AlienwareAW510K* rgb_controller = new RGBController_AlienwareAW510K(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
+#define ALIENWARE_AW410K_PID                        0x1968
 
 DetectedControllers DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
 {
@@ -61,5 +40,4 @@ DetectedControllers DetectAlienwareAW410KControllers(hid_device_info* info, cons
     return(detected_controllers);
 }
 
-REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);
 REGISTER_HID_DETECTOR_IPU("Alienware AW410K",   DetectAlienwareAW410KControllers,   ALIENWARE_VID,  ALIENWARE_AW410K_PID,   0x02,   0xFF00, 0x01);

Controllers/AlienwareKeyboardController/AlienwareAW510KController/AlienwareAW510KControllerDetect.cpp

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------*\
+| AlienwareAW510KControllerDetect.cpp                       |
+|                                                           |
+|   Detector for Alienware AW510K Keyboard                  |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "DetectionManager.h"
+#include "AlienwareAW510KController.h"
+#include "RGBController_AlienwareAW510K.h"
+
+/*---------------------------------------------------------*\
+| Alienware vendor ID                                       |
+\*---------------------------------------------------------*/
+#define ALIENWARE_VID                               0x04F2
+
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+\*---------------------------------------------------------*/
+#define ALIENWARE_AW510K_PID                        0x1830
+
+DetectedControllers DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path, name);
+        RGBController_AlienwareAW510K* rgb_controller = new RGBController_AlienwareAW510K(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);

Controllers/ArcticController/ArcticControllerDetect.cpp

@@ -21,13 +21,13 @@
 DetectedControllers DetectArcticControllers()
 {
     DetectedControllers         detected_controllers;
-    std::vector<std::string *>  ports;
+    std::vector<std::string>    ports;
 
     ports = find_usb_serial_port(CH341_VID, CH341_PID);
 
     for(unsigned int device = 0; device < ports.size(); device++)
     {
-        ArcticController *controller = new ArcticController(*ports[device]);
+        ArcticController *controller = new ArcticController(ports[device]);
 
         if(controller->IsPresent())
         {
@@ -38,8 +38,6 @@ DetectedControllers DetectArcticControllers()
         {
             delete controller;
         }
-
-        delete ports[device];
     }
 
     return(detected_controllers);

Controllers/AsusAuraGPUController/AsusAuraGPUController.cpp

@@ -32,7 +32,7 @@ std::string AuraGPUController::GetDeviceName()
 
 std::string AuraGPUController::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");
@@ -79,7 +79,7 @@ void AuraGPUController::AuraGPURegisterWrite(unsigned char reg, unsigned char va
 
 bool AuraGPUController::SaveOnlyApplies()
 {
-    switch (bus->pci_subsystem_device)
+    switch (bus->info.pci_subsystem_device)
     {
         case ASUS_VEGA64_STRIX:
             return false;

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -21,7 +21,7 @@
 
 bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
 {
-    if(bus->pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
+    if(bus->info.pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
     {
         return false;
     }

Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseDevices.h

@@ -22,6 +22,7 @@
 #define AURA_ROG_GLADIUS_II_WIRELESS_1_PID              0x189E
 #define AURA_ROG_GLADIUS_II_WIRELESS_2_PID              0x18A0
 #define AURA_ROG_GLADIUS_III_PID                        0x197B
+#define AURA_ROG_GLADIUS_III_CORE_PID                   0x1C8D
 #define AURA_ROG_GLADIUS_III_WIRELESS_USB_PID           0x197D
 #define AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID           0x197F
 #define AURA_ROG_GLADIUS_III_WIRELESS_BT_PID            0x1981
@@ -217,6 +218,20 @@ static std::map<int,mouse_type> aura_mouse_devices =
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
     },
+    {
+        AURA_ROG_GLADIUS_III_CORE_PID, // ROG Gladius III Core
+        {
+            0,
+            0,
+            0,
+            100,
+            false,
+            1,
+            false,
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
+        }
+    },
     {
         AURA_ROG_GLADIUS_III_WIRELESS_USB_PID, // ROG Gladius III Wireless USB
         {

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.cpp

@@ -19,7 +19,10 @@ AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, con
     |    Manually adding device info for now                |
     |    TODO: Implement config table accurately            |
     \*-----------------------------------------------------*/
-    device_info.push_back({0x00, 0x00, 12, 0, AuraDeviceType::FIXED});
+    uint8_t leds = (dev_name.find("Ryujin") != std::string::npos) ? 5 : 12;
+
+    device_info.push_back({0x00, 0x00, leds, 0, AuraDeviceType::FIXED});
+
 }
 
 AsusAuraRyuoAIOController::~AsusAuraRyuoAIOController()

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -221,7 +221,7 @@ void RGBController_AuraUSB::SetupZones()
 
             new_led.name.append(std::to_string(led_idx));
 
-            new_led.value = channel_idx;
+            new_led.value = (unsigned int)channel_idx;
 
             leds.push_back(new_led);
         }

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -120,6 +120,7 @@
 #define AURA_TERMINAL_PID                                   0x1889
 #define ROG_STRIX_LC120_PID                                 0x879E
 #define AURA_RYUO_AIO_PID                                   0x1887
+#define AURA_RYUJIN_AIO_PID                                 0x18AE
 #define ASUS_ROG_ALLY_PID                                   0x1ABE
 #define ASUS_ROG_ALLY_X_PID                                 0x1B4C
 
@@ -463,6 +464,7 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                        DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,               1,  0xFF13);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                        DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,               2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III",                                DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_PID,                         0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Core",                           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_CORE_PID,                    0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless USB",                   DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_USB_PID,            0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless 2.4Ghz",                DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID,            0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth",             DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_BT_PID,             0,  0xFF01);
@@ -523,6 +525,7 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG PG32UQ",                             DetectAs
 REGISTER_HID_DETECTOR    ("ASUS ROG AURA Terminal",                     DetectAsusAuraUSBTerminal,      AURA_USB_VID, AURA_TERMINAL_PID);
 REGISTER_HID_DETECTOR_PU ("ASUS ROG Strix LC",                          DetectAsusAuraUSBROGStrixLC,    AURA_USB_VID, ROG_STRIX_LC120_PID,                          0x00FF, 1);
 REGISTER_HID_DETECTOR_PU ("ASUS ROG Ryuo AIO",                          DetectAsusAuraUSBRyuoAIO,       AURA_USB_VID, AURA_RYUO_AIO_PID,                        0xFF72, 0x00A1);
+REGISTER_HID_DETECTOR_PU ("ASUS ROG Ryujin AIO",                        DetectAsusAuraUSBRyuoAIO,       AURA_USB_VID, AURA_RYUJIN_AIO_PID,                     0xFF72, 0x00A1);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne",                            DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_PID,                          0);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI",                         DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID,                       0);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI GUNDAM",                  DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_GUNDAM_PID,                0);

Controllers/BlinkyTapeController/BlinkyTapeControllerDetect.cpp

@@ -24,12 +24,12 @@
 DetectedControllers DetectBlinkyTapeControllers()
 {
     DetectedControllers         detected_controllers;
-    std::vector<std::string *>  device_locations = find_usb_serial_port(BLINKINLABS_VID, BLINKYTAPE_PID);
+    std::vector<std::string>    device_locations = find_usb_serial_port(BLINKINLABS_VID, BLINKYTAPE_PID);
 
     for(unsigned int device_idx = 0; device_idx < device_locations.size(); device_idx++)
     {
         BlinkyTapeController*     controller     = new BlinkyTapeController();
-        controller->Initialize(*device_locations[device_idx]);
+        controller->Initialize(device_locations[device_idx]);
 
         RGBController_BlinkyTape* rgb_controller = new RGBController_BlinkyTape(controller);
 

Controllers/ClevoKeyboardController/ClevoKeyboardController.cpp

@@ -1,22 +1,25 @@
 /*---------------------------------------------------------*\
 | ClevoKeyboardController.cpp                               |
 |                                                           |
-|   Driver for Clevo laptop per-key RGB keyboard (ITE 8291) |
-|   Protocol based on tuxedo-drivers ite_8291 module        |
+|   Driver for Clevo per-key RGB keyboard                   |
+|   Supports ITE 8291 (PID 0x600B) and ITE 829x (0x8910)    |
 |                                                           |
 |   Kyle Cascade ([email protected])          16 Jan 2026 |
+|   Valentin Lobstein ([email protected]) 27 Mar 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
+#include <algorithm>
 #include <cstring>
 #include "ClevoKeyboardController.h"
 #include "StringUtils.h"
 
-ClevoKeyboardController::ClevoKeyboardController(hid_device* dev_handle, const hid_device_info& info)
+ClevoKeyboardController::ClevoKeyboardController(hid_device* dev_handle, const hid_device_info& info, clevo_keyboard_type kb_type)
 {
     dev      = dev_handle;
+    type     = kb_type;
     location = info.path;
     version  = info.release_number;
 }
@@ -26,6 +29,31 @@ ClevoKeyboardController::~ClevoKeyboardController()
     hid_close(dev);
 }
 
+clevo_keyboard_type ClevoKeyboardController::GetType()
+{
+    return type;
+}
+
+int ClevoKeyboardController::GetNumRows()
+{
+    return(type == CLEVO_KB_ITE829X) ? CLEVO_829X_NUM_ROWS : CLEVO_8291_NUM_ROWS;
+}
+
+int ClevoKeyboardController::GetNumCols()
+{
+    return(type == CLEVO_KB_ITE829X) ? CLEVO_829X_NUM_COLS : CLEVO_8291_NUM_COLS;
+}
+
+int ClevoKeyboardController::GetNumLEDs()
+{
+    return GetNumRows() * GetNumCols();
+}
+
+unsigned char ClevoKeyboardController::GetBrightnessMax()
+{
+    return(type == CLEVO_KB_ITE829X) ? CLEVO_829X_BRIGHTNESS_MAX : CLEVO_8291_BRIGHTNESS_MAX;
+}
+
 std::string ClevoKeyboardController::GetDeviceLocation()
 {
     return("HID: " + location);
@@ -51,147 +79,355 @@ std::string ClevoKeyboardController::GetFirmwareVersion()
     return(version_string);
 }
 
-void ClevoKeyboardController::WriteControl(unsigned char* data)
+/*---------------------------------------------------------*\
+| ITE 8291: 8-byte feature report, no report ID             |
+\*---------------------------------------------------------*/
+void ClevoKeyboardController::WriteControl8291(unsigned char* data)
 {
-    hid_send_feature_report(dev, data, CLEVO_KEYBOARD_REPORT_SIZE);
+    hid_send_feature_report(dev, data, CLEVO_8291_REPORT_SIZE);
 }
 
 void ClevoKeyboardController::WriteRowData(unsigned char* data)
 {
-    hid_write(dev, data, CLEVO_KEYBOARD_ROW_DATA_SIZE);
+    hid_write(dev, data, CLEVO_8291_ROW_DATA_SIZE);
+}
+
+/*---------------------------------------------------------*\
+| ITE 829x: 6-byte feature report with report ID 0xCC       |
+\*---------------------------------------------------------*/
+void ClevoKeyboardController::SendCommand829x(unsigned char cmd, unsigned char d0, unsigned char d1, unsigned char d2, unsigned char d3)
+{
+    unsigned char buf[CLEVO_829X_REPORT_SIZE];
+
+    buf[0] = CLEVO_829X_REPORT_ID;
+    buf[1] = cmd;
+    buf[2] = d0;
+    buf[3] = d1;
+    buf[4] = d2;
+    buf[5] = d3;
+
+    hid_send_feature_report(dev, buf, CLEVO_829X_REPORT_SIZE);
 }
 
 void ClevoKeyboardController::TurnOff()
 {
-    /*---------------------------------------------------------*\
-    | Turn off: 08 01 00 00 00 00 00 00                         |
-    \*---------------------------------------------------------*/
-    unsigned char buf[CLEVO_KEYBOARD_REPORT_SIZE];
+    if(type == CLEVO_KB_ITE829X)
+    {
+        SendCommand829x(CLEVO_829X_CMD_BRIGHTNESS);
+        return;
+    }
 
-    memset(buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
-    buf[0] = 0x08;
-    buf[1] = 0x01;
-
-    WriteControl(buf);
+    unsigned char buf[CLEVO_8291_REPORT_SIZE];
+    memset(buf, 0x00, CLEVO_8291_REPORT_SIZE);
+    buf[0] = CLEVO_8291_CMD_MODE;
+    buf[1] = CLEVO_8291_POWER_OFF;
+    WriteControl8291(buf);
 }
 
 void ClevoKeyboardController::SetMode(unsigned char mode, unsigned char brightness, unsigned char speed, unsigned char behaviour)
 {
-    /*---------------------------------------------------------*\
-    | Set params: 08 [power] [mode] [speed] [brightness] 08     |
-    |             [behaviour] 00                                |
-    | power: 01=off, 02=on                                      |
-    \*---------------------------------------------------------*/
-    unsigned char buf[CLEVO_KEYBOARD_REPORT_SIZE];
+    if(type == CLEVO_KB_ITE829X)
+    {
+        SendCommand829x(CLEVO_829X_CMD_BRIGHTNESS, brightness, speed);
+        return;
+    }
 
-    memset(buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
-    buf[0] = 0x08;
-    buf[1] = 0x02;                                          // Power on
+    unsigned char buf[CLEVO_8291_REPORT_SIZE];
+    memset(buf, 0x00, CLEVO_8291_REPORT_SIZE);
+    buf[0] = CLEVO_8291_CMD_MODE;
+    buf[1] = CLEVO_8291_POWER_ON;
     buf[2] = mode;
     buf[3] = speed;
     buf[4] = brightness;
-    buf[5] = 0x08;
+    buf[5] = CLEVO_8291_MODE_FLAG;
     buf[6] = behaviour;
-
-    WriteControl(buf);
+    WriteControl8291(buf);
 }
 
-void ClevoKeyboardController::SetModeColor(unsigned char color_idx, unsigned char red, unsigned char green, unsigned char blue)
+void ClevoKeyboardController::SetModeColor(unsigned char color_idx, RGBColor color)
 {
-    /*---------------------------------------------------------*\
-    | Set color define: 14 00 [index] R G B 00 00               |
-    | index: 1-7 for built-in effects                           |
-    \*---------------------------------------------------------*/
-    unsigned char buf[CLEVO_KEYBOARD_REPORT_SIZE];
-
-    memset(buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
-    buf[0] = 0x14;
-    buf[1] = 0x00;
-    buf[2] = color_idx;
-    buf[3] = red;
-    buf[4] = green;
-    buf[5] = blue;
-
-    WriteControl(buf);
-}
-
-void ClevoKeyboardController::SendColors(unsigned char* color_data, unsigned char brightness)
-{
-    /*---------------------------------------------------------*\
-    | Per-key RGB mode (mode 0x33)                              |
-    | 1. Set params with mode 0x33 and brightness               |
-    | 2. For each row 0-5:                                      |
-    |    - Announce row: 16 00 [row] 00 00 00 00 00             |
-    |    - Send 65 bytes row data via output report             |
-    |                                                           |
-    | Row data format (65 bytes):                               |
-    |   [0x00 padding][0x00 padding]                            |
-    |   [B0..B20][G0..G20][R0..R20]                             |
-    \*---------------------------------------------------------*/
-    unsigned char ctrl_buf[CLEVO_KEYBOARD_REPORT_SIZE];
-    unsigned char row_buf[CLEVO_KEYBOARD_ROW_DATA_SIZE];
-
-    /*---------------------------------------------------------*\
-    | Clamp brightness                                          |
-    \*---------------------------------------------------------*/
-    if(brightness > CLEVO_KEYBOARD_BRIGHTNESS_MAX)
+    if(type == CLEVO_KB_ITE829X)
     {
-        brightness = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+        return;
+    }
+
+    unsigned char buf[CLEVO_8291_REPORT_SIZE];
+    memset(buf, 0x00, CLEVO_8291_REPORT_SIZE);
+    buf[0] = CLEVO_8291_CMD_COLOR;
+    buf[2] = color_idx;
+    buf[3] = RGBGetRValue(color);
+    buf[4] = RGBGetGValue(color);
+    buf[5] = RGBGetBValue(color);
+    WriteControl8291(buf);
+}
+
+void ClevoKeyboardController::SetBrightnessSpeed829x(unsigned char brightness, unsigned char speed)
+{
+    if(brightness > CLEVO_829X_BRIGHTNESS_MAX)
+    {
+        brightness = CLEVO_829X_BRIGHTNESS_MAX;
+    }
+
+    if(brightness != current_brightness_829x || speed != current_speed_829x)
+    {
+        current_brightness_829x = brightness;
+        current_speed_829x      = speed;
+        SendCommand829x(CLEVO_829X_CMD_BRIGHTNESS, brightness, speed);
+    }
+}
+
+void ClevoKeyboardController::SendColorSlot829x(unsigned char cmd, unsigned char slot, RGBColor color)
+{
+    SendCommand829x(cmd, slot, RGBGetRValue(color), RGBGetGValue(color), RGBGetBValue(color));
+}
+
+/*---------------------------------------------------------*\
+| ITE 829x: Save/Clear BIOS keyboard state                  |
+\*---------------------------------------------------------*/
+void ClevoKeyboardController::SaveToBios829x()
+{
+    SendCommand829x(CLEVO_829X_CMD_SAVE_BIOS, 0x01);
+}
+
+void ClevoKeyboardController::ClearBiosSave829x()
+{
+    SendCommand829x(CLEVO_829X_CMD_SAVE_BIOS, 0x00);
+}
+
+void ClevoKeyboardController::StopAnimation829x()
+{
+    SendCommand829x(CLEVO_829X_CMD_ANIM, CLEVO_829X_CMD_STOP_ANIM);
+}
+
+void ClevoKeyboardController::SetEffect829x(unsigned char mode_value, const std::vector<RGBColor>& colors, unsigned int direction, unsigned int color_mode)
+{
+    bool mode_changed = (mode_value != current_mode_829x);
+    current_mode_829x = mode_value;
+    bool use_custom_color = (color_mode != MODE_COLORS_RANDOM) && !colors.empty();
+
+    /*---------------------------------------------------------*\
+    | Animation modes: send [CC, 00, mode_id] on mode change    |
+    \*---------------------------------------------------------*/
+    struct anim_entry { unsigned char mode; unsigned char anim_id; };
+    static const anim_entry anim_modes[] =
+    {
+        { CLEVO_829X_MODE_WAVE,          0x04 },
+        { CLEVO_829X_MODE_RANDOM,        0x09 },
+        { CLEVO_829X_MODE_SCAN,          0x0A },
+        { CLEVO_829X_MODE_SNAKE,         0x0B },
+        { CLEVO_829X_MODE_RAINBOW_CYCLE, 0x02 },
+        { CLEVO_829X_MODE_RAINBOW_GRAD,  0x04 },
+    };
+
+    const anim_entry* anim_it = std::find_if(std::begin(anim_modes), std::end(anim_modes),
+        [mode_value](const anim_entry& e) { return e.mode == mode_value; });
+
+    if(anim_it != std::end(anim_modes) && mode_changed)
+    {
+        SendCommand829x(CLEVO_829X_CMD_ANIM, anim_it->anim_id);
     }
 
     /*---------------------------------------------------------*\
-    | Set params for per-key mode                               |
+    | Direction-based effects (Wave/Snake)                      |
+    | Slot = base + direction_index                             |
+    | Custom color: base = 0xA1, Preset: base = 0x71            |
     \*---------------------------------------------------------*/
-    memset(ctrl_buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
-    ctrl_buf[0] = 0x08;
-    ctrl_buf[1] = 0x02;                                     // Power on
-    ctrl_buf[2] = CLEVO_KEYBOARD_MODE_DIRECT;               // Per-key mode
-    ctrl_buf[3] = 0x00;                                     // Speed (unused)
-    ctrl_buf[4] = brightness;
-    ctrl_buf[5] = 0x00;
-    ctrl_buf[6] = 0x00;
+    /*---------------------------------------------------------*\
+    | Map OpenRGB direction enum to firmware slot index         |
+    \*---------------------------------------------------------*/
+    static const unsigned char dir_to_wave_idx[] =
+    {
+        6,  /* MODE_DIRECTION_LEFT       */
+        7,  /* MODE_DIRECTION_RIGHT      */
+        4,  /* MODE_DIRECTION_UP         */
+        5,  /* MODE_DIRECTION_DOWN       */
+        6,  /* MODE_DIRECTION_HORIZONTAL */
+        4,  /* MODE_DIRECTION_VERTICAL   */
+        0,  /* MODE_DIRECTION_UP_LEFT    */
+        1,  /* MODE_DIRECTION_UP_RIGHT   */
+        2,  /* MODE_DIRECTION_DOWN_LEFT  */
+        3,  /* MODE_DIRECTION_DOWN_RIGHT */
+    };
 
-    WriteControl(ctrl_buf);
+    static const unsigned char dir_to_snake_idx[] =
+    {
+        0,  /* MODE_DIRECTION_LEFT       */
+        0,  /* MODE_DIRECTION_RIGHT      */
+        0,  /* MODE_DIRECTION_UP         */
+        0,  /* MODE_DIRECTION_DOWN       */
+        0,  /* MODE_DIRECTION_HORIZONTAL */
+        0,  /* MODE_DIRECTION_VERTICAL   */
+        0,  /* MODE_DIRECTION_UP_LEFT    */
+        1,  /* MODE_DIRECTION_UP_RIGHT   */
+        2,  /* MODE_DIRECTION_DOWN_LEFT  */
+        3,  /* MODE_DIRECTION_DOWN_RIGHT */
+    };
+
+    if((mode_value == CLEVO_829X_MODE_WAVE || mode_value == CLEVO_829X_MODE_RAINBOW_GRAD) && direction < sizeof(dir_to_wave_idx))
+    {
+        unsigned char base = use_custom_color ? CLEVO_829X_COLOR_SLOT_BASE : CLEVO_829X_PRESET_SLOT_BASE;
+        unsigned char idx  = dir_to_wave_idx[direction];
+        unsigned char slot = base + idx;
+
+        if(use_custom_color)
+        {
+            SendColorSlot829x(CLEVO_829X_CMD_WAVE_COLOR, slot, colors[0]);
+        }
+
+        if(!use_custom_color)
+        {
+            SendCommand829x(CLEVO_829X_CMD_WAVE_COLOR, slot);
+        }
+    }
+
+    if(mode_value == CLEVO_829X_MODE_SNAKE && direction < sizeof(dir_to_snake_idx))
+    {
+        unsigned char base = use_custom_color ? CLEVO_829X_COLOR_SLOT_BASE : CLEVO_829X_PRESET_SLOT_BASE;
+        unsigned char idx  = dir_to_snake_idx[direction];
+        unsigned char slot = base + idx;
+
+        if(use_custom_color)
+        {
+            SendColorSlot829x(CLEVO_829X_CMD_SNAKE_COLOR, slot, colors[0]);
+        }
+
+        if(!use_custom_color)
+        {
+            SendCommand829x(CLEVO_829X_CMD_SNAKE_COLOR, slot);
+        }
+    }
 
     /*---------------------------------------------------------*\
-    | Send each row                                             |
+    | Breathing/Flashing: random or custom color                |
     \*---------------------------------------------------------*/
-    for(int row = 0; row < CLEVO_KEYBOARD_NUM_ROWS; row++)
+    if(mode_value == CLEVO_829X_MODE_BREATH && use_custom_color)
     {
-        /*-----------------------------------------------------*\
-        | Announce row data                                     |
-        \*-----------------------------------------------------*/
-        memset(ctrl_buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
-        ctrl_buf[0] = 0x16;
-        ctrl_buf[1] = 0x00;
-        ctrl_buf[2] = row;
+        SendColorSlot829x(0x0A, CLEVO_829X_COLOR_CUSTOM, colors[0]);
+    }
 
-        WriteControl(ctrl_buf);
+    if(mode_value == CLEVO_829X_MODE_BREATH && !use_custom_color)
+    {
+        SendCommand829x(0x0A);
+    }
 
-        /*-----------------------------------------------------*\
-        | Build row data buffer                                 |
-        | Format: [pad][pad][B0..B20][G0..G20][R0..R20]         |
-        \*-----------------------------------------------------*/
-        memset(row_buf, 0x00, CLEVO_KEYBOARD_ROW_DATA_SIZE);
+    if(mode_value == CLEVO_829X_MODE_BLINK && use_custom_color)
+    {
+        SendColorSlot829x(0x0B, CLEVO_829X_COLOR_CUSTOM, colors[0]);
+    }
 
-        for(int col = 0; col < CLEVO_KEYBOARD_NUM_COLS; col++)
+    if(mode_value == CLEVO_829X_MODE_BLINK && !use_custom_color)
+    {
+        SendCommand829x(0x0B);
+    }
+
+    /*---------------------------------------------------------*\
+    | Random: custom color only (multicolor is the default)     |
+    \*---------------------------------------------------------*/
+    if(mode_value == CLEVO_829X_MODE_RANDOM && use_custom_color)
+    {
+        SendColorSlot829x(CLEVO_829X_CMD_RANDOM_COLOR, CLEVO_829X_COLOR_SLOT_BASE, colors[0]);
+    }
+
+    /*---------------------------------------------------------*\
+    | Scan: 2 custom color bands                                |
+    \*---------------------------------------------------------*/
+    if(mode_value == CLEVO_829X_MODE_SCAN)
+    {
+        for(size_t i = 0; i < colors.size() && i < 2; i++)
         {
-            int led_idx = (row * CLEVO_KEYBOARD_NUM_COLS) + col;
-            int color_offset = led_idx * 3;
+            SendColorSlot829x(CLEVO_829X_CMD_SCAN_COLOR, CLEVO_829X_COLOR_SLOT_BASE + i, colors[i]);
+        }
+    }
 
-            unsigned char red   = color_data[color_offset + 0];
-            unsigned char green = color_data[color_offset + 1];
-            unsigned char blue  = color_data[color_offset + 2];
+    /*---------------------------------------------------------*\
+    | Fn Highlight: per-key color on function keys              |
+    \*---------------------------------------------------------*/
+    if(mode_value == CLEVO_829X_MODE_FN_COLOR && !colors.empty())
+    {
+        static const unsigned char fn_keys[] =
+        {
+            0x01, 0x02, 0x03, 0x05, 0x06, 0x07, 0x08, 0x09,
+            0x0A, 0x0B, 0x0C, 0x21, 0x23, 0x31, 0x32, 0x33,
+            0x53, 0x73, 0xA2
+        };
 
-            /*-------------------------------------------------*\
-            | Row data layout (after 2-byte padding):           |
-            | Bytes  2-22: Blue values for columns 0-20         |
-            | Bytes 23-43: Green values for columns 0-20        |
-            | Bytes 44-64: Red values for columns 0-20          |
-            \*-------------------------------------------------*/
-            row_buf[2 + col]                             = blue;
-            row_buf[2 + CLEVO_KEYBOARD_NUM_COLS + col]   = green;
-            row_buf[2 + CLEVO_KEYBOARD_NUM_COLS*2 + col] = red;
+        SendCommand829x(CLEVO_829X_CMD_ANIM, CLEVO_829X_CMD_CLEAR);
+
+        for(unsigned char key : fn_keys)
+        {
+            SendCommand829x(CLEVO_829X_CMD_SET_LED, key,
+                RGBGetRValue(colors[0]),
+                RGBGetGValue(colors[0]),
+                RGBGetBValue(colors[0]));
+        }
+    }
+}
+
+void ClevoKeyboardController::SendColors(const unsigned char* color_data, unsigned char brightness, unsigned char speed)
+{
+    int num_rows = GetNumRows();
+    int num_cols = GetNumCols();
+
+    if(type == CLEVO_KB_ITE829X)
+    {
+        if(brightness > CLEVO_829X_BRIGHTNESS_MAX)
+        {
+            brightness = CLEVO_829X_BRIGHTNESS_MAX;
+        }
+
+        SendCommand829x(CLEVO_829X_CMD_BRIGHTNESS, brightness, speed);
+
+        for(int row = 0; row < num_rows; row++)
+        {
+            for(int col = 0; col < num_cols; col++)
+            {
+                int idx = (row * num_cols + col) * 3;
+
+                SendCommand829x(CLEVO_829X_CMD_SET_LED,
+                    CLEVO_829X_LED_ID(row, col),
+                    color_data[idx + 0],
+                    color_data[idx + 1],
+                    color_data[idx + 2]);
+            }
+        }
+
+        return;
+    }
+
+    /*---------------------------------------------------------*\
+    | ITE 8291: row-based color transfer                        |
+    \*---------------------------------------------------------*/
+    unsigned char ctrl_buf[CLEVO_8291_REPORT_SIZE];
+    unsigned char row_buf[CLEVO_8291_ROW_DATA_SIZE];
+
+    if(brightness > CLEVO_8291_BRIGHTNESS_MAX)
+    {
+        brightness = CLEVO_8291_BRIGHTNESS_MAX;
+    }
+
+    memset(ctrl_buf, 0x00, CLEVO_8291_REPORT_SIZE);
+    ctrl_buf[0] = CLEVO_8291_CMD_MODE;
+    ctrl_buf[1] = CLEVO_8291_POWER_ON;
+    ctrl_buf[2] = CLEVO_KEYBOARD_MODE_DIRECT;
+    ctrl_buf[4] = brightness;
+    WriteControl8291(ctrl_buf);
+
+    for(int row = 0; row < num_rows; row++)
+    {
+        memset(ctrl_buf, 0x00, CLEVO_8291_REPORT_SIZE);
+        ctrl_buf[0] = CLEVO_8291_CMD_ROW;
+        ctrl_buf[2] = row;
+        WriteControl8291(ctrl_buf);
+
+        memset(row_buf, 0x00, CLEVO_8291_ROW_DATA_SIZE);
+
+        for(int col = 0; col < num_cols; col++)
+        {
+            int idx = (row * num_cols + col) * 3;
+
+            row_buf[2 + col]                = color_data[idx + 2];
+            row_buf[2 + num_cols + col]     = color_data[idx + 1];
+            row_buf[2 + num_cols * 2 + col] = color_data[idx + 0];
         }
 
         WriteRowData(row_buf);

Controllers/ClevoKeyboardController/ClevoKeyboardController.h

@@ -1,9 +1,11 @@
 /*---------------------------------------------------------*\
 | ClevoKeyboardController.h                                 |
 |                                                           |
-|   Driver for Clevo laptop per-key RGB keyboard (ITE 8291) |
+|   Driver for Clevo per-key RGB keyboard                   |
+|   Supports ITE 8291 (PID 0x600B) and ITE 829x (0x8910)    |
 |                                                           |
 |   Kyle Cascade ([email protected])          16 Jan 2026 |
+|   Valentin Lobstein ([email protected]) 27 Mar 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -12,27 +14,75 @@
 #pragma once
 
 #include <string>
+#include <vector>
 #include <hidapi.h>
+#include "RGBController.h"
 
-/*-----------------------------------------------------*\
-| ITE 8291 keyboard defines                             |
-\*-----------------------------------------------------*/
-#define CLEVO_KEYBOARD_REPORT_SIZE     8
-#define CLEVO_KEYBOARD_ROW_DATA_SIZE   65
+/*---------------------------------------------------------*\
+| Device type enumeration                                   |
+\*---------------------------------------------------------*/
+enum clevo_keyboard_type
+{
+    CLEVO_KB_ITE8291,
+    CLEVO_KB_ITE829X,
+};
 
-#define CLEVO_KEYBOARD_NUM_ROWS        6
-#define CLEVO_KEYBOARD_NUM_COLS        21
-#define CLEVO_KEYBOARD_NUM_LEDS        (CLEVO_KEYBOARD_NUM_ROWS * CLEVO_KEYBOARD_NUM_COLS)
+/*---------------------------------------------------------*\
+| ITE 8291 keyboard defines (PID 0x600B)                    |
+| 8 bytes, no report ID, row-based color data               |
+\*---------------------------------------------------------*/
+#define CLEVO_8291_REPORT_SIZE         8
+#define CLEVO_8291_ROW_DATA_SIZE       65
+#define CLEVO_8291_NUM_ROWS            6
+#define CLEVO_8291_NUM_COLS            21
+#define CLEVO_8291_NUM_LEDS            (CLEVO_8291_NUM_ROWS * CLEVO_8291_NUM_COLS)
+#define CLEVO_8291_BRIGHTNESS_MAX      0x32
+#define CLEVO_8291_CMD_MODE            0x08
+#define CLEVO_8291_CMD_COLOR           0x14
+#define CLEVO_8291_CMD_ROW             0x16
+#define CLEVO_8291_POWER_OFF           0x01
+#define CLEVO_8291_POWER_ON            0x02
+#define CLEVO_8291_MODE_FLAG           0x08
 
+/*---------------------------------------------------------*\
+| ITE 829x keyboard defines (PID 0x8910)                    |
+| 6 bytes with report ID 0xCC, per-key color commands       |
+| Protocol: [0xCC, cmd, d0, d1, d2, d3]                     |
+| LED ID: ((row & 0x07) << 5) | (col & 0x1F)                |
+\*---------------------------------------------------------*/
+#define CLEVO_829X_REPORT_ID           0xCC
+#define CLEVO_829X_REPORT_SIZE         6
+#define CLEVO_829X_NUM_ROWS            6
+#define CLEVO_829X_NUM_COLS            20
+#define CLEVO_829X_NUM_LEDS            (CLEVO_829X_NUM_ROWS * CLEVO_829X_NUM_COLS)
+#define CLEVO_829X_BRIGHTNESS_MAX      0x0A
+#define CLEVO_829X_LED_ID(row, col)    (unsigned char)((((row) & 0x07) << 5) | ((col) & 0x1F))
+
+#define CLEVO_829X_CMD_SET_LED         0x01
+#define CLEVO_829X_CMD_BRIGHTNESS      0x09
+#define CLEVO_829X_CMD_ANIM            0x00
+#define CLEVO_829X_CMD_CLEAR           0x0C
+#define CLEVO_829X_CMD_WAVE_COLOR      0x15
+#define CLEVO_829X_CMD_SNAKE_COLOR     0x16
+#define CLEVO_829X_CMD_SCAN_COLOR      0x17
+#define CLEVO_829X_CMD_RANDOM_COLOR    0x18
+#define CLEVO_829X_COLOR_CUSTOM        0xAA
+#define CLEVO_829X_COLOR_SLOT_BASE     0xA1
+#define CLEVO_829X_PRESET_SLOT_BASE    0x71
+#define CLEVO_829X_CMD_SAVE_BIOS       0x20
+#define CLEVO_829X_CMD_STOP_ANIM       0x03
+
+/*---------------------------------------------------------*\
+| Shared defines                                            |
+\*---------------------------------------------------------*/
 #define CLEVO_KEYBOARD_BRIGHTNESS_MIN  0x00
-#define CLEVO_KEYBOARD_BRIGHTNESS_MAX  0x32
-
-#define CLEVO_KEYBOARD_SPEED_MIN       0x01
+#define CLEVO_KEYBOARD_SPEED_MIN       0x00
 #define CLEVO_KEYBOARD_SPEED_MAX       0x0A
+#define CLEVO_KEYBOARD_SPEED_DEFAULT   0x00
 
-/*-----------------------------------------------------*\
-| ITE 8291 modes                                        |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| ITE 8291 modes                                            |
+\*---------------------------------------------------------*/
 enum
 {
     CLEVO_KEYBOARD_MODE_DIRECT     = 0x33,
@@ -47,9 +97,36 @@ enum
     CLEVO_KEYBOARD_MODE_SPARK      = 0x11,
 };
 
-/*-----------------------------------------------------*\
-| Wave/reactive behaviour                               |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| ITE 829x firmware modes                                   |
+| Two command styles:                                       |
+|   cmd=0x00, d0=mode_id  (animation select)                |
+|   cmd=mode_id, d0=0x00  (standalone effects)              |
+\*---------------------------------------------------------*/
+enum
+{
+    CLEVO_829X_MODE_DIRECT          = 0xFD,
+    CLEVO_829X_MODE_WAVE            = 0xA0,
+    CLEVO_829X_MODE_WAVE_COLOR      = 0xB0,
+    CLEVO_829X_MODE_BREATH          = 0xA1,
+    CLEVO_829X_MODE_BREATH_COLOR    = 0xB1,
+    CLEVO_829X_MODE_BLINK           = 0xA2,
+    CLEVO_829X_MODE_BLINK_COLOR     = 0xB2,
+    CLEVO_829X_MODE_RANDOM          = 0xA3,
+    CLEVO_829X_MODE_RANDOM_COLOR    = 0xA9,
+    CLEVO_829X_MODE_SCAN            = 0xA4,
+    /* Ripple (0x07) requires Insyde BIOS EC config, not supported */
+    CLEVO_829X_MODE_SNAKE           = 0xA6,
+    CLEVO_829X_MODE_SNAKE_COLOR     = 0xB6,
+    CLEVO_829X_MODE_RAINBOW_CYCLE   = 0xA7,
+    CLEVO_829X_MODE_RAINBOW_GRAD    = 0xA8,
+    CLEVO_829X_MODE_FN_COLOR        = 0xAF,
+    CLEVO_829X_MODE_OFF             = 0xFF,
+};
+
+/*---------------------------------------------------------*\
+| Wave/reactive behaviour                                   |
+\*---------------------------------------------------------*/
 enum
 {
     CLEVO_KEYBOARD_DIRECTION_LEFT      = 0x01,
@@ -67,23 +144,40 @@ enum
 class ClevoKeyboardController
 {
 public:
-    ClevoKeyboardController(hid_device* dev_handle, const hid_device_info& info);
+    ClevoKeyboardController(hid_device* dev_handle, const hid_device_info& info, clevo_keyboard_type kb_type);
     ~ClevoKeyboardController();
 
+    clevo_keyboard_type GetType();
+    int             GetNumRows();
+    int             GetNumCols();
+    int             GetNumLEDs();
+    unsigned char   GetBrightnessMax();
+
     std::string     GetDeviceLocation();
     std::string     GetSerialString();
     std::string     GetFirmwareVersion();
 
     void            TurnOff();
     void            SetMode(unsigned char mode, unsigned char brightness, unsigned char speed, unsigned char behaviour);
-    void            SetModeColor(unsigned char color_idx, unsigned char red, unsigned char green, unsigned char blue);
-    void            SendColors(unsigned char* color_data, unsigned char brightness);
+    void            SetModeColor(unsigned char color_idx, RGBColor color);
+    void            SendColors(const unsigned char* color_data, unsigned char brightness, unsigned char speed);
+    void            SetEffect829x(unsigned char mode_value, const std::vector<RGBColor>& colors, unsigned int direction = 0, unsigned int color_mode = 0);
+    void            SetBrightnessSpeed829x(unsigned char brightness, unsigned char speed);
+    void            SaveToBios829x();
+    void            ClearBiosSave829x();
+    void            StopAnimation829x();
 
 private:
-    hid_device*     dev;
-    std::string     location;
-    unsigned short  version;
+    hid_device*             dev;
+    clevo_keyboard_type     type;
+    std::string             location;
+    unsigned short          version;
+    unsigned char           current_mode_829x = 0xFF;
+    unsigned char           current_brightness_829x = 0xFF;
+    unsigned char           current_speed_829x = 0xFF;
 
-    void            WriteControl(unsigned char* data);
+    void            WriteControl8291(unsigned char* data);
     void            WriteRowData(unsigned char* data);
+    void            SendCommand829x(unsigned char cmd, unsigned char d0 = 0, unsigned char d1 = 0, unsigned char d2 = 0, unsigned char d3 = 0);
+    void            SendColorSlot829x(unsigned char cmd, unsigned char slot, RGBColor color);
 };

Controllers/ClevoKeyboardController/ClevoKeyboardControllerDetect.cpp

@@ -1,9 +1,11 @@
 /*---------------------------------------------------------*\
 | ClevoKeyboardControllerDetect.cpp                         |
 |                                                           |
-|   Detector for Clevo per-key RGB keyboard (ITE 8291)      |
+|   Detector for Clevo per-key RGB keyboard                 |
+|   Supports ITE 8291 (PID 0x600B) and ITE 829x (0x8910)    |
 |                                                           |
 |   Kyle Cascade ([email protected])          16 Jan 2026 |
+|   Valentin Lobstein ([email protected]) 27 Mar 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -22,11 +24,12 @@
 
 /*---------------------------------------------------------*\
 | Clevo Keyboard product IDs                                |
-| These are ITE 8291 per-key RGB keyboard controllers       |
+|   ITE 8291 and ITE 829x per-key RGB keyboard controllers  |
 \*---------------------------------------------------------*/
-#define CLEVO_KEYBOARD_PID_600B                 0x600B
+#define CLEVO_KEYBOARD_PID_8291                 0x600B
+#define CLEVO_KEYBOARD_PID_829X                 0x8910
 
-DetectedControllers DetectClevoKeyboardControllers(hid_device_info* info, const std::string& /*name*/)
+static DetectedControllers DetectClevoKeyboard(hid_device_info* info, clevo_keyboard_type kb_type)
 {
     DetectedControllers detected_controllers;
     hid_device*         dev;
@@ -35,7 +38,7 @@ DetectedControllers DetectClevoKeyboardControllers(hid_device_info* info, const
 
     if(dev)
     {
-        ClevoKeyboardController*     controller     = new ClevoKeyboardController(dev, *info);
+        ClevoKeyboardController*     controller     = new ClevoKeyboardController(dev, *info, kb_type);
         RGBController_ClevoKeyboard* rgb_controller = new RGBController_ClevoKeyboard(controller);
 
         detected_controllers.push_back(rgb_controller);
@@ -44,4 +47,15 @@ DetectedControllers DetectClevoKeyboardControllers(hid_device_info* info, const
     return(detected_controllers);
 }
 
-REGISTER_HID_DETECTOR_PU("CLEVO Keyboard", DetectClevoKeyboardControllers, 0x048D, 0x600B, 0xFF03, 0x01);
+DetectedControllers DetectClevoKeyboard8291(hid_device_info* info, const std::string& /*name*/)
+{
+    return(DetectClevoKeyboard(info, CLEVO_KB_ITE8291));
+}
+
+DetectedControllers DetectClevoKeyboard829x(hid_device_info* info, const std::string& /*name*/)
+{
+    return(DetectClevoKeyboard(info, CLEVO_KB_ITE829X));
+}
+
+REGISTER_HID_DETECTOR_PU("Clevo Keyboard (ITE 8291)", DetectClevoKeyboard8291, ITE_VID, CLEVO_KEYBOARD_PID_8291, 0xFF03, 0x01);
+REGISTER_HID_DETECTOR_PU("Clevo Keyboard (ITE 829x)", DetectClevoKeyboard829x, ITE_VID, CLEVO_KEYBOARD_PID_829X, 0xFF89, 0xCC);

Controllers/ClevoKeyboardController/ClevoKeyboardDevices.cpp

@@ -1,9 +1,11 @@
 /*---------------------------------------------------------*\
 | ClevoKeyboardDevices.cpp                                  |
 |                                                           |
-|   Device list for Clevo per-key RGB keyboards (ITE 8291)  |
+|   Device list for Clevo per-key RGB keyboards             |
+|   Supports ITE 8291 (PID 0x600B) and ITE 829x (0x8910)    |
 |                                                           |
 |   Kyle Cascade ([email protected])          21 Jan 2026 |
+|   Valentin Lobstein ([email protected]) 27 Mar 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -112,6 +114,48 @@ static const std::vector<unsigned int> clevo_tkl_values =
     15,                                                         // Right
 };
 
+/*---------------------------------------------------------*\
+| ITE 829x LED value mapping                                |
+| LED ID = ((row & 7) << 5) | col                           |
+| Row 5 (F-keys) = 0xA0+, Row 4 (numbers) = 0x80+           |
+| Row 3 (QWERTY) = 0x60+, Row 2 (home)    = 0x40+           |
+| Row 1 (Z row)  = 0x20+, Row 0 (mods)    = 0x00+           |
+\*---------------------------------------------------------*/
+static const std::vector<unsigned int> clevo_829x_full_values =
+{
+    /*---------------------------------------------------------*\
+    | Values in FULL layout visual order (same as CM keyboard)  |
+    | LED ID = ((row & 7) << 5) | col                           |
+    | Row counts: 16, 21, 21, 17, 18, 13                        |
+    \*---------------------------------------------------------*/
+/*  ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK */
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0,    0,
+/*  BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BSPC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
+    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2D, 0x2E, 0x0E, 0x10, 0x12, 0x30, 0x31, 0x32, 0x33,
+/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     ANSI\ DEL   END   PGDN  NM7   NM8   NM9   NMPL */
+    0x40, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x0F, 0x11, 0x13, 0x50, 0x51, 0x52, 0x53,
+/*  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR  NM4   NM5   NM6        */
+    0x60, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0,    0x6E, 0x70, 0x71, 0x72,
+/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /     RSFT  ARWU  NM1   NM2   NM3   NMER */
+    0x80, 0,    0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8F, 0x90, 0x91, 0x92, 0x93,
+/*  LCTL  LFNC  LWIN  LALT  SPACE                         RALT  RMNU  RCTL  ARWL  ARDN  ARWR  NM0   NMPD */
+    0xA0, 0xA2, 0xA3, 0xA4, 0xA5,                         0xAA, 0xAB, 0xAC, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2,
+};
+
+keyboard_keymap_overlay_values clevo_829x_keyboard_layout
+{
+    KEYBOARD_SIZE_FULL,
+    {
+        clevo_829x_full_values,
+        {
+            /* No regional overlays needed */
+        }
+    },
+    {
+        /* No edit keys needed - all keys defined in full layout */
+    }
+};
+
 keyboard_keymap_overlay_values clevo_keyboard_layout
 {
     KEYBOARD_SIZE_TKL,
@@ -122,10 +166,9 @@ keyboard_keymap_overlay_values clevo_keyboard_layout
         }
     },
     {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        /*---------------------------------------------------------*\
+        | Edit Keys                                                 |
+        \*---------------------------------------------------------*/
 
         /*---------------------------------------------------------*\
         | Remove keys not present on Clevo keyboard                 |

Controllers/ClevoKeyboardController/ClevoKeyboardDevices.h

@@ -1,9 +1,11 @@
 /*---------------------------------------------------------*\
 | ClevoKeyboardDevices.h                                    |
 |                                                           |
-|   Device list for Clevo per-key RGB keyboards (ITE 8291)  |
+|   Device list for Clevo per-key RGB keyboards             |
+|   Supports ITE 8291 (PID 0x600B) and ITE 829x (0x8910)    |
 |                                                           |
 |   Kyle Cascade ([email protected])          21 Jan 2026 |
+|   Valentin Lobstein ([email protected]) 27 Mar 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -14,7 +16,8 @@
 #include <string>
 #include "KeyboardLayoutManager.h"
 
-/*-----------------------------------------------------*\
-| Clevo keyboard layout definitions                     |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Clevo keyboard layout definitions                         |
+\*---------------------------------------------------------*/
 extern keyboard_keymap_overlay_values clevo_keyboard_layout;
+extern keyboard_keymap_overlay_values clevo_829x_keyboard_layout;

Controllers/ClevoKeyboardController/RGBController_ClevoKeyboard.cpp

@@ -1,14 +1,17 @@
 /*---------------------------------------------------------*\
 | RGBController_ClevoKeyboard.cpp                           |
 |                                                           |
-|   RGBController for Clevo per-key RGB keyboard (ITE 8291) |
+|   RGBController for Clevo per-key RGB keyboard            |
+|   Supports ITE 8291 (PID 0x600B) and ITE 829x (0x8910)    |
 |                                                           |
 |   Kyle Cascade ([email protected])          16 Jan 2026 |
+|   Valentin Lobstein ([email protected]) 27 Mar 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
+#include <vector>
 #include "RGBController_ClevoKeyboard.h"
 #include "KeyboardLayoutManager.h"
 
@@ -40,152 +43,306 @@ RGBController_ClevoKeyboard::RGBController_ClevoKeyboard(ClevoKeyboardController
     Direct.value                    = CLEVO_KEYBOARD_MODE_DIRECT;
     Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Direct.brightness_min           = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-    Direct.brightness_max           = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Direct.brightness               = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Direct.brightness_max           = controller->GetBrightnessMax();
+    Direct.brightness               = controller->GetBrightnessMax();
     Direct.color_mode               = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
-    mode Rainbow;
-    Rainbow.name                    = "Rainbow";
-    Rainbow.value                   = CLEVO_KEYBOARD_MODE_RAINBOW;
-    Rainbow.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Rainbow.speed_min               = CLEVO_KEYBOARD_SPEED_MAX;
-    Rainbow.speed_max               = CLEVO_KEYBOARD_SPEED_MIN;
-    Rainbow.speed                   = 0x05;
-    Rainbow.brightness_min          = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-    Rainbow.brightness_max          = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Rainbow.brightness              = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Rainbow.color_mode              = MODE_COLORS_NONE;
-    modes.push_back(Rainbow);
+    /*---------------------------------------------------------*\
+    | ITE 8291 built-in effects (not available on ITE 829x)     |
+    \*---------------------------------------------------------*/
+    if(controller->GetType() == CLEVO_KB_ITE8291)
+    {
+        mode Rainbow;
+        Rainbow.name                    = "Rainbow";
+        Rainbow.value                   = CLEVO_KEYBOARD_MODE_RAINBOW;
+        Rainbow.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        Rainbow.speed_min               = CLEVO_KEYBOARD_SPEED_MAX;
+        Rainbow.speed_max               = CLEVO_KEYBOARD_SPEED_MIN;
+        Rainbow.speed                   = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Rainbow.brightness_min          = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Rainbow.brightness_max          = controller->GetBrightnessMax();
+        Rainbow.brightness              = controller->GetBrightnessMax();
+        Rainbow.color_mode              = MODE_COLORS_NONE;
+        modes.push_back(Rainbow);
 
-    mode Wave;
-    Wave.name                       = "Wave";
-    Wave.value                      = CLEVO_KEYBOARD_MODE_WAVE;
-    Wave.flags                      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Wave.speed_min                  = CLEVO_KEYBOARD_SPEED_MAX;
-    Wave.speed_max                  = CLEVO_KEYBOARD_SPEED_MIN;
-    Wave.speed                      = 0x05;
-    Wave.brightness_min             = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-    Wave.brightness_max             = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Wave.brightness                 = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Wave.direction                  = MODE_DIRECTION_LEFT;
-    Wave.colors_min                 = 1;
-    Wave.colors_max                 = 1;
-    Wave.colors.resize(1);
-    Wave.color_mode                 = MODE_COLORS_MODE_SPECIFIC;
-    modes.push_back(Wave);
+        mode Wave;
+        Wave.name                       = "Wave";
+        Wave.value                      = CLEVO_KEYBOARD_MODE_WAVE;
+        Wave.flags                      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+        Wave.speed_min                  = CLEVO_KEYBOARD_SPEED_MAX;
+        Wave.speed_max                  = CLEVO_KEYBOARD_SPEED_MIN;
+        Wave.speed                      = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Wave.brightness_min             = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Wave.brightness_max             = controller->GetBrightnessMax();
+        Wave.brightness                 = controller->GetBrightnessMax();
+        Wave.direction                  = MODE_DIRECTION_LEFT;
+        Wave.colors_min                 = 1;
+        Wave.colors_max                 = 1;
+        Wave.colors.resize(1);
+        Wave.color_mode                 = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(Wave);
 
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = CLEVO_KEYBOARD_MODE_BREATH;
-    Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Breathing.speed_min             = CLEVO_KEYBOARD_SPEED_MAX;
-    Breathing.speed_max             = CLEVO_KEYBOARD_SPEED_MIN;
-    Breathing.speed                 = 0x05;
-    Breathing.brightness_min        = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-    Breathing.brightness_max        = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Breathing.brightness            = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Breathing.colors_min            = 1;
-    Breathing.colors_max            = 1;
-    Breathing.colors.resize(1);
-    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    modes.push_back(Breathing);
+        mode Breathing;
+        Breathing.name                  = "Breathing";
+        Breathing.value                 = CLEVO_KEYBOARD_MODE_BREATH;
+        Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+        Breathing.speed_min             = CLEVO_KEYBOARD_SPEED_MAX;
+        Breathing.speed_max             = CLEVO_KEYBOARD_SPEED_MIN;
+        Breathing.speed                 = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Breathing.brightness_min        = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Breathing.brightness_max        = controller->GetBrightnessMax();
+        Breathing.brightness            = controller->GetBrightnessMax();
+        Breathing.colors_min            = 1;
+        Breathing.colors_max            = 1;
+        Breathing.colors.resize(1);
+        Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(Breathing);
 
-    mode Reactive;
-    Reactive.name                   = "Reactive";
-    Reactive.value                  = CLEVO_KEYBOARD_MODE_REACTIVE;
-    Reactive.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Reactive.speed_min              = CLEVO_KEYBOARD_SPEED_MAX;
-    Reactive.speed_max              = CLEVO_KEYBOARD_SPEED_MIN;
-    Reactive.speed                  = 0x05;
-    Reactive.brightness_min         = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-    Reactive.brightness_max         = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Reactive.brightness             = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Reactive.colors_min             = 1;
-    Reactive.colors_max             = 1;
-    Reactive.colors.resize(1);
-    Reactive.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-    modes.push_back(Reactive);
+        mode Reactive;
+        Reactive.name                   = "Reactive";
+        Reactive.value                  = CLEVO_KEYBOARD_MODE_REACTIVE;
+        Reactive.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+        Reactive.speed_min              = CLEVO_KEYBOARD_SPEED_MAX;
+        Reactive.speed_max              = CLEVO_KEYBOARD_SPEED_MIN;
+        Reactive.speed                  = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Reactive.brightness_min         = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Reactive.brightness_max         = controller->GetBrightnessMax();
+        Reactive.brightness             = controller->GetBrightnessMax();
+        Reactive.colors_min             = 1;
+        Reactive.colors_max             = 1;
+        Reactive.colors.resize(1);
+        Reactive.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(Reactive);
 
-    mode Ripple;
-    Ripple.name                     = "Ripple";
-    Ripple.value                    = CLEVO_KEYBOARD_MODE_RIPPLE;
-    Ripple.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Ripple.speed_min                = CLEVO_KEYBOARD_SPEED_MAX;
-    Ripple.speed_max                = CLEVO_KEYBOARD_SPEED_MIN;
-    Ripple.speed                    = 0x05;
-    Ripple.brightness_min           = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-    Ripple.brightness_max           = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Ripple.brightness               = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Ripple.colors_min               = 1;
-    Ripple.colors_max               = 1;
-    Ripple.colors.resize(1);
-    Ripple.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    modes.push_back(Ripple);
+        mode Ripple;
+        Ripple.name                     = "Ripple";
+        Ripple.value                    = CLEVO_KEYBOARD_MODE_RIPPLE;
+        Ripple.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+        Ripple.speed_min                = CLEVO_KEYBOARD_SPEED_MAX;
+        Ripple.speed_max                = CLEVO_KEYBOARD_SPEED_MIN;
+        Ripple.speed                    = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Ripple.brightness_min           = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Ripple.brightness_max           = controller->GetBrightnessMax();
+        Ripple.brightness               = controller->GetBrightnessMax();
+        Ripple.colors_min               = 1;
+        Ripple.colors_max               = 1;
+        Ripple.colors.resize(1);
+        Ripple.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(Ripple);
 
-    mode Marquee;
-    Marquee.name                    = "Marquee";
-    Marquee.value                   = CLEVO_KEYBOARD_MODE_MARQUEE;
-    Marquee.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Marquee.speed_min               = CLEVO_KEYBOARD_SPEED_MAX;
-    Marquee.speed_max               = CLEVO_KEYBOARD_SPEED_MIN;
-    Marquee.speed                   = 0x05;
-    Marquee.brightness_min          = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-    Marquee.brightness_max          = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Marquee.brightness              = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Marquee.colors_min              = 1;
-    Marquee.colors_max              = 1;
-    Marquee.colors.resize(1);
-    Marquee.color_mode              = MODE_COLORS_MODE_SPECIFIC;
-    modes.push_back(Marquee);
+        mode Marquee;
+        Marquee.name                    = "Marquee";
+        Marquee.value                   = CLEVO_KEYBOARD_MODE_MARQUEE;
+        Marquee.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+        Marquee.speed_min               = CLEVO_KEYBOARD_SPEED_MAX;
+        Marquee.speed_max               = CLEVO_KEYBOARD_SPEED_MIN;
+        Marquee.speed                   = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Marquee.brightness_min          = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Marquee.brightness_max          = controller->GetBrightnessMax();
+        Marquee.brightness              = controller->GetBrightnessMax();
+        Marquee.colors_min              = 1;
+        Marquee.colors_max              = 1;
+        Marquee.colors.resize(1);
+        Marquee.color_mode              = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(Marquee);
 
-    mode Raindrop;
-    Raindrop.name                   = "Raindrop";
-    Raindrop.value                  = CLEVO_KEYBOARD_MODE_RAINDROP;
-    Raindrop.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Raindrop.speed_min              = CLEVO_KEYBOARD_SPEED_MAX;
-    Raindrop.speed_max              = CLEVO_KEYBOARD_SPEED_MIN;
-    Raindrop.speed                  = 0x05;
-    Raindrop.brightness_min         = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-    Raindrop.brightness_max         = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Raindrop.brightness             = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Raindrop.colors_min             = 1;
-    Raindrop.colors_max             = 1;
-    Raindrop.colors.resize(1);
-    Raindrop.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-    modes.push_back(Raindrop);
+        mode Raindrop;
+        Raindrop.name                   = "Raindrop";
+        Raindrop.value                  = CLEVO_KEYBOARD_MODE_RAINDROP;
+        Raindrop.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+        Raindrop.speed_min              = CLEVO_KEYBOARD_SPEED_MAX;
+        Raindrop.speed_max              = CLEVO_KEYBOARD_SPEED_MIN;
+        Raindrop.speed                  = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Raindrop.brightness_min         = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Raindrop.brightness_max         = controller->GetBrightnessMax();
+        Raindrop.brightness             = controller->GetBrightnessMax();
+        Raindrop.colors_min             = 1;
+        Raindrop.colors_max             = 1;
+        Raindrop.colors.resize(1);
+        Raindrop.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(Raindrop);
 
-    mode Aurora;
-    Aurora.name                     = "Aurora";
-    Aurora.value                    = CLEVO_KEYBOARD_MODE_AURORA;
-    Aurora.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Aurora.speed_min                = CLEVO_KEYBOARD_SPEED_MAX;
-    Aurora.speed_max                = CLEVO_KEYBOARD_SPEED_MIN;
-    Aurora.speed                    = 0x05;
-    Aurora.brightness_min           = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-    Aurora.brightness_max           = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Aurora.brightness               = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Aurora.colors_min               = 1;
-    Aurora.colors_max               = 1;
-    Aurora.colors.resize(1);
-    Aurora.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    modes.push_back(Aurora);
+        mode Aurora;
+        Aurora.name                     = "Aurora";
+        Aurora.value                    = CLEVO_KEYBOARD_MODE_AURORA;
+        Aurora.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+        Aurora.speed_min                = CLEVO_KEYBOARD_SPEED_MAX;
+        Aurora.speed_max                = CLEVO_KEYBOARD_SPEED_MIN;
+        Aurora.speed                    = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Aurora.brightness_min           = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Aurora.brightness_max           = controller->GetBrightnessMax();
+        Aurora.brightness               = controller->GetBrightnessMax();
+        Aurora.colors_min               = 1;
+        Aurora.colors_max               = 1;
+        Aurora.colors.resize(1);
+        Aurora.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(Aurora);
 
-    mode Spark;
-    Spark.name                      = "Spark";
-    Spark.value                     = CLEVO_KEYBOARD_MODE_SPARK;
-    Spark.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Spark.speed_min                 = CLEVO_KEYBOARD_SPEED_MAX;
-    Spark.speed_max                 = CLEVO_KEYBOARD_SPEED_MIN;
-    Spark.speed                     = 0x05;
-    Spark.brightness_min            = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-    Spark.brightness_max            = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Spark.brightness                = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
-    Spark.colors_min                = 1;
-    Spark.colors_max                = 1;
-    Spark.colors.resize(1);
-    Spark.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    modes.push_back(Spark);
+        mode Spark;
+        Spark.name                      = "Spark";
+        Spark.value                     = CLEVO_KEYBOARD_MODE_SPARK;
+        Spark.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+        Spark.speed_min                 = CLEVO_KEYBOARD_SPEED_MAX;
+        Spark.speed_max                 = CLEVO_KEYBOARD_SPEED_MIN;
+        Spark.speed                     = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Spark.brightness_min            = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Spark.brightness_max            = controller->GetBrightnessMax();
+        Spark.brightness                = controller->GetBrightnessMax();
+        Spark.colors_min                = 1;
+        Spark.colors_max                = 1;
+        Spark.colors.resize(1);
+        Spark.color_mode                = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(Spark);
+    }
+
+    /*---------------------------------------------------------*\
+    | ITE 829x firmware effects                                 |
+    \*---------------------------------------------------------*/
+    if(controller->GetType() == CLEVO_KB_ITE829X)
+    {
+        unsigned char bmax = controller->GetBrightnessMax();
+
+        mode Wave;
+        Wave.name           = "Wave";
+        Wave.value          = CLEVO_829X_MODE_WAVE;
+        Wave.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_DIAG;
+        Wave.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
+        Wave.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
+        Wave.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Wave.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Wave.brightness_max = bmax;
+        Wave.brightness     = bmax;
+        Wave.direction      = MODE_DIRECTION_LEFT;
+        Wave.colors_min     = 1;
+        Wave.colors_max     = 1;
+        Wave.colors.resize(1, ToRGBColor(255, 0, 0));
+        Wave.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(Wave);
+
+        mode Breathing;
+        Breathing.name           = "Breathing";
+        Breathing.value          = CLEVO_829X_MODE_BREATH;
+        Breathing.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+        Breathing.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
+        Breathing.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
+        Breathing.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Breathing.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Breathing.brightness_max = bmax;
+        Breathing.brightness     = bmax;
+        Breathing.colors_min     = 1;
+        Breathing.colors_max     = 1;
+        Breathing.colors.resize(1, ToRGBColor(255, 0, 0));
+        Breathing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(Breathing);
+
+        mode Flashing;
+        Flashing.name           = "Flashing";
+        Flashing.value          = CLEVO_829X_MODE_BLINK;
+        Flashing.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+        Flashing.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
+        Flashing.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
+        Flashing.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Flashing.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Flashing.brightness_max = bmax;
+        Flashing.brightness     = bmax;
+        Flashing.colors_min     = 1;
+        Flashing.colors_max     = 1;
+        Flashing.colors.resize(1, ToRGBColor(255, 0, 0));
+        Flashing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(Flashing);
+
+        mode Random;
+        Random.name           = "Random";
+        Random.value          = CLEVO_829X_MODE_RANDOM;
+        Random.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+        Random.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
+        Random.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
+        Random.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Random.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Random.brightness_max = bmax;
+        Random.brightness     = bmax;
+        Random.colors_min     = 1;
+        Random.colors_max     = 1;
+        Random.colors.resize(1, ToRGBColor(255, 0, 0));
+        Random.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(Random);
+
+        mode Scan;
+        Scan.name           = "Scan";
+        Scan.value          = CLEVO_829X_MODE_SCAN;
+        Scan.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+        Scan.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
+        Scan.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
+        Scan.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Scan.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Scan.brightness_max = bmax;
+        Scan.brightness     = bmax;
+        Scan.colors_min     = 2;
+        Scan.colors_max     = 2;
+        Scan.colors.resize(2);
+        Scan.colors[0] = ToRGBColor(255, 0, 0);
+        Scan.colors[1] = ToRGBColor(0, 0, 255);
+        Scan.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(Scan);
+
+        mode Snake;
+        Snake.name           = "Snake";
+        Snake.value          = CLEVO_829X_MODE_SNAKE;
+        Snake.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_DIAG;
+        Snake.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
+        Snake.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
+        Snake.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        Snake.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        Snake.brightness_max = bmax;
+        Snake.brightness     = bmax;
+        Snake.direction      = MODE_DIRECTION_UP_LEFT;
+        Snake.colors_min     = 1;
+        Snake.colors_max     = 1;
+        Snake.colors.resize(1, ToRGBColor(255, 0, 0));
+        Snake.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(Snake);
+
+        mode RainbowCycle;
+        RainbowCycle.name           = "Spectrum Cycle";
+        RainbowCycle.value          = CLEVO_829X_MODE_RAINBOW_CYCLE;
+        RainbowCycle.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        RainbowCycle.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
+        RainbowCycle.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
+        RainbowCycle.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        RainbowCycle.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        RainbowCycle.brightness_max = bmax;
+        RainbowCycle.brightness     = bmax;
+        RainbowCycle.color_mode     = MODE_COLORS_NONE;
+        modes.push_back(RainbowCycle);
+
+        mode RainbowGrad;
+        RainbowGrad.name           = "Rainbow Wave";
+        RainbowGrad.value          = CLEVO_829X_MODE_RAINBOW_GRAD;
+        RainbowGrad.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_DIAG;
+        RainbowGrad.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
+        RainbowGrad.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
+        RainbowGrad.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
+        RainbowGrad.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        RainbowGrad.brightness_max = bmax;
+        RainbowGrad.brightness     = bmax;
+        RainbowGrad.direction      = MODE_DIRECTION_LEFT;
+        RainbowGrad.color_mode     = MODE_COLORS_NONE;
+        modes.push_back(RainbowGrad);
+
+        mode FnColor;
+        FnColor.name           = "Fn Highlight";
+        FnColor.value          = CLEVO_829X_MODE_FN_COLOR;
+        FnColor.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+        FnColor.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+        FnColor.brightness_max = bmax;
+        FnColor.brightness     = bmax;
+        FnColor.colors_min     = 1;
+        FnColor.colors_max     = 1;
+        FnColor.colors.resize(1, ToRGBColor(255, 0, 0));
+        FnColor.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+        modes.push_back(FnColor);
+    }
 
     mode Off;
     Off.name                        = "Off";
@@ -207,16 +364,22 @@ RGBController_ClevoKeyboard::~RGBController_ClevoKeyboard()
 void RGBController_ClevoKeyboard::SetupZones()
 {
     /*---------------------------------------------------------*\
-    | Create keyboard layout using KeyboardLayoutManager        |
+    | Select layout based on device type                        |
     \*---------------------------------------------------------*/
-    KeyboardLayoutManager new_kb(KEYBOARD_LAYOUT_ISO_QWERTY,
-                                 clevo_keyboard_layout.base_size,
-                                 clevo_keyboard_layout.key_values);
+    bool is_829x = (controller->GetType() == CLEVO_KB_ITE829X);
 
-    new_kb.ChangeKeys(clevo_keyboard_layout);
+    keyboard_keymap_overlay_values& layout = is_829x
+        ? clevo_829x_keyboard_layout
+        : clevo_keyboard_layout;
+
+    KeyboardLayoutManager new_kb(KEYBOARD_LAYOUT_ISO_QWERTY,
+                                 layout.base_size,
+                                 layout.key_values);
+
+    new_kb.ChangeKeys(layout);
 
     /*---------------------------------------------------------*\
-    | Create a matrix zone for the keyboard                     |
+    | Create keyboard zone from KLM                             |
     \*---------------------------------------------------------*/
     zone keyboard_zone;
 
@@ -233,9 +396,6 @@ void RGBController_ClevoKeyboard::SetupZones()
 
     zones.push_back(keyboard_zone);
 
-    /*---------------------------------------------------------*\
-    | Create LEDs from the KeyboardLayoutManager data           |
-    \*---------------------------------------------------------*/
     for(unsigned int led_idx = 0; led_idx < keyboard_zone.leds_count; led_idx++)
     {
         led new_led;
@@ -249,36 +409,48 @@ void RGBController_ClevoKeyboard::SetupZones()
     SetupColors();
 
     /*---------------------------------------------------------*\
-    | Create buffer map to translate OpenRGB LED order to       |
-    | hardware LED order. The hardware expects 126 color values |
-    | indexed by LED position (0-125).                          |
+    | Build buffer map from LED values to color pointers        |
+    | 829x LED IDs have gaps (stride 32), need larger map       |
     \*---------------------------------------------------------*/
     null_color = 0x00000000;
-    buffer_map.resize(CLEVO_KEYBOARD_NUM_LEDS, &null_color);
+
+    size_t map_size = is_829x
+        ? CLEVO_829X_LED_ID(CLEVO_829X_NUM_ROWS - 1, CLEVO_829X_NUM_COLS - 1) + 1
+        : (size_t)controller->GetNumLEDs();
+
+    buffer_map.resize(map_size, &null_color);
 
     for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        buffer_map[leds[led_idx].value] = &colors[led_idx];
+        if(leds[led_idx].value < buffer_map.size())
+        {
+            buffer_map[leds[led_idx].value] = &colors[led_idx];
+        }
     }
 }
 
 void RGBController_ClevoKeyboard::DeviceUpdateLEDs()
 {
-    /*---------------------------------------------------------*\
-    | Build color data array using buffer map and send to device|
-    | The buffer_map translates from hardware LED index to the  |
-    | corresponding color pointer for that LED.                 |
-    \*---------------------------------------------------------*/
-    unsigned char color_data[CLEVO_KEYBOARD_NUM_LEDS * 3];
+    int  num_rows = controller->GetNumRows();
+    int  num_cols = controller->GetNumCols();
+    bool is_829x  = (controller->GetType() == CLEVO_KB_ITE829X);
 
-    for(int i = 0; i < CLEVO_KEYBOARD_NUM_LEDS; i++)
+    std::vector<unsigned char> color_data(num_rows * num_cols * 3);
+
+    for(int row = 0; row < num_rows; row++)
     {
-        color_data[i * 3 + 0] = RGBGetRValue(*buffer_map[i]);
-        color_data[i * 3 + 1] = RGBGetGValue(*buffer_map[i]);
-        color_data[i * 3 + 2] = RGBGetBValue(*buffer_map[i]);
+        for(int col = 0; col < num_cols; col++)
+        {
+            int seq    = row * num_cols + col;
+            int led_id = is_829x ? CLEVO_829X_LED_ID(row, col) : seq;
+
+            color_data[seq * 3 + 0] = RGBGetRValue(*buffer_map[led_id]);
+            color_data[seq * 3 + 1] = RGBGetGValue(*buffer_map[led_id]);
+            color_data[seq * 3 + 2] = RGBGetBValue(*buffer_map[led_id]);
+        }
     }
 
-    controller->SendColors(color_data, modes[active_mode].brightness);
+    controller->SendColors(color_data.data(), modes[active_mode].brightness, modes[active_mode].speed);
 }
 
 void RGBController_ClevoKeyboard::DeviceUpdateZoneLEDs(int /*zone*/)
@@ -304,6 +476,16 @@ void RGBController_ClevoKeyboard::DeviceUpdateMode()
         return;
     }
 
+    /*---------------------------------------------------------*\
+    | Handle ITE 829x firmware effects                          |
+    \*---------------------------------------------------------*/
+    if(controller->GetType() == CLEVO_KB_ITE829X && mode_value != CLEVO_KEYBOARD_MODE_DIRECT)
+    {
+        controller->SetEffect829x(mode_value, modes[active_mode].colors, modes[active_mode].direction, modes[active_mode].color_mode);
+        controller->SetBrightnessSpeed829x(modes[active_mode].brightness, modes[active_mode].speed);
+        return;
+    }
+
     /*---------------------------------------------------------*\
     | Handle Direct (per-key) mode                              |
     \*---------------------------------------------------------*/
@@ -318,41 +500,26 @@ void RGBController_ClevoKeyboard::DeviceUpdateMode()
     \*---------------------------------------------------------*/
     unsigned char brightness = modes[active_mode].brightness;
     unsigned char speed      = modes[active_mode].speed;
-    unsigned char behaviour  = 0x00;
-
-    /*---------------------------------------------------------*\
-    | Set direction for wave mode                               |
-    \*---------------------------------------------------------*/
-    if(mode_value == CLEVO_KEYBOARD_MODE_WAVE)
-    {
-        switch(modes[active_mode].direction)
-        {
-            case MODE_DIRECTION_LEFT:
-                behaviour = CLEVO_KEYBOARD_DIRECTION_LEFT;
-                break;
-            case MODE_DIRECTION_RIGHT:
-                behaviour = CLEVO_KEYBOARD_DIRECTION_RIGHT;
-                break;
-            case MODE_DIRECTION_UP:
-                behaviour = CLEVO_KEYBOARD_DIRECTION_UP;
-                break;
-            case MODE_DIRECTION_DOWN:
-                behaviour = CLEVO_KEYBOARD_DIRECTION_DOWN;
-                break;
-        }
-    }
+    unsigned char behaviour  = (mode_value == CLEVO_KEYBOARD_MODE_WAVE)
+                             ? modes[active_mode].direction + 1
+                             : 0x00;
 
     /*---------------------------------------------------------*\
     | Set mode color if applicable                              |
     \*---------------------------------------------------------*/
     if(modes[active_mode].colors.size() > 0)
     {
-        unsigned char red   = RGBGetRValue(modes[active_mode].colors[0]);
-        unsigned char green = RGBGetGValue(modes[active_mode].colors[0]);
-        unsigned char blue  = RGBGetBValue(modes[active_mode].colors[0]);
-
-        controller->SetModeColor(1, red, green, blue);
+        controller->SetModeColor(1, modes[active_mode].colors[0]);
     }
 
     controller->SetMode(mode_value, brightness, speed, behaviour);
 }
+
+void RGBController_ClevoKeyboard::DeviceSaveMode()
+{
+    if(controller->GetType() == CLEVO_KB_ITE829X)
+    {
+        DeviceUpdateMode();
+        controller->SaveToBios829x();
+    }
+}

Controllers/ClevoKeyboardController/RGBController_ClevoKeyboard.h

@@ -1,9 +1,11 @@
 /*---------------------------------------------------------*\
 | RGBController_ClevoKeyboard.h                             |
 |                                                           |
-|   RGBController for Clevo per-key RGB keyboard (ITE 8291) |
+|   RGBController for Clevo per-key RGB keyboard            |
+|   Supports ITE 8291 (PID 0x600B) and ITE 829x (0x8910)    |
 |                                                           |
 |   Kyle Cascade ([email protected])          16 Jan 2026 |
+|   Valentin Lobstein ([email protected]) 27 Mar 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -18,7 +20,7 @@
 class RGBController_ClevoKeyboard : public RGBController
 {
 public:
-    RGBController_ClevoKeyboard(ClevoKeyboardController* controller_ptr);
+    explicit RGBController_ClevoKeyboard(ClevoKeyboardController* controller_ptr);
     ~RGBController_ClevoKeyboard();
 
     void        SetupZones();
@@ -28,6 +30,7 @@ public:
     void        DeviceUpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
     ClevoKeyboardController*        controller;

Controllers/ColorfulGPUController/ColorfulGPUController.cpp

@@ -26,7 +26,7 @@ ColorfulGPUController::~ColorfulGPUController()
 
 std::string ColorfulGPUController::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");
@@ -45,7 +45,8 @@ void ColorfulGPUController::SetDirect(RGBColor color)
     uint8_t g = RGBGetGValue(color);
     uint8_t b = RGBGetBValue(color);
 
-    if(this->bus->pci_subsystem_device == COLORFUL_IGAME_RTX_4070_VULCAN_OCV)
+    if(this->bus->info.pci_subsystem_device == COLORFUL_IGAME_RTX_4070_VULCAN_OCV
+    || this->bus->info.pci_subsystem_device == COLORFUL_IGAME_RTX_4090_NEPTUNE_OCV)
     {
         uint8_t data_pkt[COLORFUL_PACKET_LENGTH_V2] = { 0xAA, 0xEF, 0x01, 0x04, 0x88, 0x26 };
         for(int i=6; i < COLORFUL_PACKET_LENGTH_V2 -2; i = i + 3)

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -52,7 +52,7 @@ REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Advanced OC 12G L-V",    Detec
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_GA106_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,        0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,        0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,        0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,           0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060TI_ADVANCED_OC,          0x61);
@@ -71,11 +71,17 @@ REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Ti SUPER Advanced OC-V", Detec
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Ti SUPER Ultra W",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070TIS_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070TI_SUPER_ULTRA_W,        0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 SUPER Ultra W OC",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070S_DEV,         COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_SUPER_ULTRA_W_OC,       0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Vulcan OC-V",            DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_VULCAN_OCV,             0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_ULTRAW_OCV,             0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 SUPER Ultra W OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070S_DEV,         COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070S_ULTRAW_OCV,            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_OCV,             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);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Neptune OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_NEPTUNE_OCV,            0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV,           0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV2,          0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ti Ultra W DUO OC",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060TI_ULTRAW_DUO_OC,          0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ultra W OC",             DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060_ULTRAW_OC,              0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ultra W OC",             DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060_ULTRAW_OC_2,            0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ti Ultra W DUO OC",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060TI_ULTRAW_DUO_OC,        0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ti Ultra W DUO OC",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060TI_ULTRAW_DUO_OC_2,      0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV,             0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV2,            0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV2,            0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ti Ultra W OC",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070TI_ULTRAW_OC,            0x61);

Controllers/ColorfulTuringGPUController/ColorfulTuringGPUController.cpp

@@ -24,7 +24,7 @@ ColorfulTuringGPUController::~ColorfulTuringGPUController()
 
 std::string ColorfulTuringGPUController::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");

Controllers/ColorfulTuringGPUController/ColorfulTuringGPUControllerDetect.cpp

@@ -17,7 +17,7 @@ DetectedControllers DetectColorfulTuringGPUControllers(i2c_smbus_interface* bus,
 {
     DetectedControllers detected_controllers;
 
-    if(bus->port_id == 1)
+    if(bus->info.port_id == 1)
     {
         ColorfulTuringGPUController*     controller     = new ColorfulTuringGPUController(bus, i2c_addr, name);
         RGBController_ColorfulTuringGPU* rgb_controller = new RGBController_ColorfulTuringGPU(controller);

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.cpp

@@ -340,7 +340,6 @@ void CorsairCommanderCoreController::SetDirectColor
         lastzones               = zones;
         int packet_offset       = 0;
         int led_idx             = 0;
-        int channel_idx         = 0;
         int packet_len          = CORSAIR_COMMANDER_CORE_RGB_DATA_LENGTH;
 
         if(pid == CORSAIR_COMMANDER_CORE_XT_PID)
@@ -369,8 +368,6 @@ void CorsairCommanderCoreController::SetDirectColor
             {
                 packet_offset += 3 * (34 - zones[zone_idx].leds_count);
             }
-
-            channel_idx++;
         }
 
         /*-----------------------------------------------------*\

Controllers/CorsairDRAMController/CorsairDRAMController.cpp

@@ -26,6 +26,7 @@ CorsairDRAMController::CorsairDRAMController(i2c_smbus_interface *bus, corsair_d
     this->bus           = bus;
     this->dev           = dev;
     device_index        = 0;
+    direct_mode         = true;
     pid                 = 0;
     vid                 = 0;
     protocol_version    = 0;
@@ -52,7 +53,7 @@ unsigned char CorsairDRAMController::GetProtocolVersion()
 
 std::string CorsairDRAMController::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");
@@ -132,13 +133,77 @@ void CorsairDRAMController::SetColorsPerLED(RGBColor* colors)
         | bytes, use a second block write to the second     |
         | block write address for the remaining data        |
         \*-------------------------------------------------*/
-        bus->i2c_smbus_write_block_data(dev, CORSAIR_DRAM_REG_COLOR_BUFFER_BLOCK_1, 32, direct_packet);
+        s32 ret = bus->i2c_smbus_write_block_data(dev, CORSAIR_DRAM_REG_COLOR_BUFFER_BLOCK_1, 32, direct_packet);
 
-        if(direct_packet_size > 32)
+        if((ret >= 0) && (direct_packet_size > 32))
         {
             bus->i2c_smbus_write_block_data(dev, CORSAIR_DRAM_REG_COLOR_BUFFER_BLOCK_2, direct_packet_size - 32, direct_packet + 32);
         }
 
+        /*-------------------------------------------------*\
+        | Corsair DRAM supports an alternate means of       |
+        | writing block data without using SMBus block      |
+        | operations.  If block operations are not          |
+        | available, fall back to this scheme.              |
+        |                                                   |
+        | Blocks are split up into word data writes.        |
+        | Some data bytes are packed into the lower nibble  |
+        | of the register address byte.                     |
+        \*-------------------------------------------------*/
+        if(ret < 0)
+        {
+            unsigned int        block_index     = 0;
+
+            while(block_index < direct_packet_size)
+            {
+                unsigned char   reg_value_0     = 0xA0;
+                unsigned char   reg_value_1     = 0x00;
+                unsigned short  word_value_0    = 0;
+                unsigned short  word_value_1    = 0;
+
+                if(block_index == 0)
+                {
+                    reg_value_0                 = 0x90;
+                }
+
+                word_value_0                    = (direct_packet[block_index]);
+                block_index++;
+
+                if(block_index < direct_packet_size)
+                {
+                    word_value_0               |= (direct_packet[block_index] << 8);
+                    block_index++;
+                }
+
+                if(block_index < direct_packet_size)
+                {
+                    reg_value_1                 = 0xA0;
+                    reg_value_0                |= (direct_packet[block_index] & 0x0F);
+                    reg_value_1                |= (direct_packet[block_index] & 0xF0) >> 4;
+                    block_index++;
+                }
+
+                if(block_index < direct_packet_size)
+                {
+                    word_value_1                = (direct_packet[block_index]);
+                    block_index++;
+                }
+
+                if(block_index < direct_packet_size)
+                {
+                    word_value_1               |= (direct_packet[block_index] << 8);
+                    block_index++;
+                }
+
+                bus->i2c_smbus_write_word_data(dev, reg_value_0, word_value_0);
+
+                if(reg_value_1 > 0)
+                {
+                    bus->i2c_smbus_write_word_data(dev, reg_value_1, word_value_1);
+                }
+            }
+        }
+
         /*-------------------------------------------------*\
         | Remember to delete the data buffer                |
         \*-------------------------------------------------*/
@@ -366,7 +431,7 @@ void CorsairDRAMController::ReadDeviceInfo()
     /*-----------------------------------------------------*\
     | Log Device Information Data                           |
     \*-----------------------------------------------------*/
-    if(LogManager::get()->getLoglevel() >= LL_TRACE)
+    if(LogManager::get()->GetLogLevel() >= LL_TRACE)
     {
         char            device_info_buf[256];
         unsigned int    pos;

Controllers/CorsairDRAMController/CorsairDRAMControllerDetect.cpp

@@ -24,18 +24,15 @@ using namespace std::chrono_literals;
 
 bool TestForCorsairDRAMController(i2c_smbus_interface *bus, unsigned char address)
 {
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-
     LOG_DEBUG("[%s] Trying address %02X", CORSAIR_DRAM_NAME, address);
 
+    int res = bus->i2c_smbus_read_byte_data(address, 0x43);
+
     if(res < 0)
     {
-        LOG_DEBUG("[%s] Failed: res was %04X", CORSAIR_DRAM_NAME, res);
         return false;
     }
 
-    res = bus->i2c_smbus_read_byte_data(address, 0x43);
-
     if(!(res == 0x1A || res == 0x1B || res == 0x1C))
     {
         LOG_DEBUG("[%s] Failed: expected 0x1A, 0x1B, or 0x1C, got %04X", CORSAIR_DRAM_NAME, res);
@@ -44,9 +41,9 @@ bool TestForCorsairDRAMController(i2c_smbus_interface *bus, unsigned char addres
 
     res = bus->i2c_smbus_read_byte_data(address, 0x44);
 
-    if(!(res == 0x03 || res == 0x04))
+    if(!(res == 0x01 || res == 0x03 || res == 0x04))
     {
-        LOG_DEBUG("[%s] Failed: expected 0x03 or 0x04, got %04X", CORSAIR_DRAM_NAME, res);
+        LOG_DEBUG("[%s] Failed: expected 0x01, 0x03, or 0x04, got %04X", CORSAIR_DRAM_NAME, res);
         return false;
     }
 
@@ -59,7 +56,7 @@ DetectedControllers DetectCorsairDRAMControllers(std::vector<i2c_smbus_interface
 
     for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
-        IF_DRAM_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
+        IF_DRAM_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
         {
             LOG_DEBUG("[%s] Testing bus %d", CORSAIR_DRAM_NAME, bus);
 

Controllers/CorsairICueLinkController/RGBController_CorsairICueLink.cpp

@@ -98,7 +98,16 @@ void RGBController_CorsairICueLink::SetupZones()
                     lcd_zone.leds_min   = controller->GetEndpoints()[lcd_idx]->led_channels;
                     lcd_zone.leds_max   = lcd_zone.leds_min;
                     lcd_zone.leds_count = lcd_zone.leds_min;
+
                     zones.push_back(lcd_zone);
+
+                    for(unsigned int led_idx = 0; led_idx < lcd_zone.leds_count; led_idx++)
+                    {
+                        led new_led;
+                        new_led.name = "LED " + std::to_string(led_idx + 1);
+
+                        leds.push_back(new_led);
+                    }
                 }
             }
         }

Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp

@@ -365,7 +365,7 @@ void RGBController_CorsairLightingNode::SetupZones()
             new_led.name                            = zones[zone_idx].name + ", LED " + std::to_string(led_ch_idx + 1);
 
             leds.push_back(new_led);
-            leds_channel.push_back(zone_idx);
+            leds_channel.push_back((unsigned int)zone_idx);
         }
     }
 
@@ -413,7 +413,7 @@ void RGBController_CorsairLightingNode::DeviceUpdateMode()
     {
         for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
         {
-            DeviceUpdateZoneMode(zone_idx);
+            DeviceUpdateZoneMode((int)zone_idx);
         }
     }
 

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -526,27 +526,26 @@ void CorsairPeripheralController::ReadFirmwareInfo()
     char offset = 0;
 
     /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
+    | Some Corsair keyboards (e.g. K70 RGB MK.2) do not     |
+    | answer the firmware-info query on the control         |
+    | interface until several seconds after the host first  |
+    | talks to them following a cold boot.  A single read   |
+    | attempt returns all zeros, the device type comes back |
+    | as 0x00, and the device is discarded as UNKNOWN.      |
+    | Retry the query until a valid device type byte is     |
+    | returned or the attempt cap is reached.  Each failed  |
+    | attempt is paced by the 1s hid_read_timeout below, so |
+    | the cap also bounds the detection stall for a device  |
+    | that opens but never answers.  Observed need          |
+    | on a K70 RGB MK.2 cold boot is 2 attempts; the cap    |
+    | leaves generous headroom.                             |
     \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+    int attempt = 0;
 
-    /*-----------------------------------------------------*\
-    | Set up Read Firmware Info packet                      |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_COMMAND_READ;
-    usb_buf[0x02]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
-
-    /*-----------------------------------------------------*\
-    | Send packet and try reading it using an HID read      |
-    | If that fails, repeat the send and read the reply as  |
-    | a feature report.                                     |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
-    actual = hid_read_timeout(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH, 1000);
-
-    if(actual == 0)
+    do
     {
+        offset = 0;
+
         /*-------------------------------------------------*\
         | Zero out buffer                                   |
         \*-------------------------------------------------*/
@@ -559,10 +558,48 @@ void CorsairPeripheralController::ReadFirmwareInfo()
         usb_buf[0x01]   = CORSAIR_COMMAND_READ;
         usb_buf[0x02]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
 
-        hid_send_feature_report(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
-        actual = hid_get_feature_report(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
-        offset = 1;
-    }
+        /*-------------------------------------------------*\
+        | Send packet and try reading it using an HID read  |
+        | If that fails, repeat the send and read the reply |
+        | as a feature report.                              |
+        \*-------------------------------------------------*/
+        hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+        actual = hid_read_timeout(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH, 1000);
+
+        if(actual == 0)
+        {
+            /*---------------------------------------------*\
+            | Zero out buffer                               |
+            \*---------------------------------------------*/
+            memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+
+            /*---------------------------------------------*\
+            | Set up Read Firmware Info packet              |
+            \*---------------------------------------------*/
+            usb_buf[0x00]   = 0x00;
+            usb_buf[0x01]   = CORSAIR_COMMAND_READ;
+            usb_buf[0x02]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
+
+            hid_send_feature_report(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+            actual = hid_get_feature_report(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+            offset = 1;
+        }
+
+        attempt++;
+
+        LOG_DEBUG("[%s] Firmware info attempt %d/%d: device type %02X", CORSAIR_PERIPHERAL_CONTROLLER_NAME, attempt, CORSAIR_FW_INFO_MAX_ATTEMPTS, usb_buf[0x14 + offset]);
+
+        /*-------------------------------------------------*\
+        | Stop as soon as a valid device type is returned   |
+        |   0xC0 keyboard / 0xC1 mouse / 0xC2 pad or stand  |
+        \*-------------------------------------------------*/
+        if(usb_buf[0x14 + offset] == 0xC0
+        || usb_buf[0x14 + offset] == 0xC1
+        || usb_buf[0x14 + offset] == 0xC2)
+        {
+            break;
+        }
+    } while(attempt < CORSAIR_FW_INFO_MAX_ATTEMPTS);
 
     /*-----------------------------------------------------*\
     | Get device type                                       |
@@ -570,7 +607,7 @@ void CorsairPeripheralController::ReadFirmwareInfo()
     |   0xC1    Device is a mouse                           |
     |   0xC2    Device is a mousepad or headset stand       |
     \*-----------------------------------------------------*/
-    LOG_DEBUG("[%s] Device type %02X", CORSAIR_PERIPHERAL_CONTROLLER_NAME, usb_buf[0x14 + offset]);
+    LOG_DEBUG("[%s] Device type %02X after %d attempt(s)", CORSAIR_PERIPHERAL_CONTROLLER_NAME, usb_buf[0x14 + offset], attempt);
 
     switch(usb_buf[0x14 + offset])
     {

Controllers/CorsairPeripheralController/CorsairPeripheralController.h

@@ -16,6 +16,7 @@
 #include "RGBController.h"
 
 #define CORSAIR_PERIPHERAL_PACKET_LENGTH 65
+#define CORSAIR_FW_INFO_MAX_ATTEMPTS     10
 
 enum
 {

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.cpp

@@ -35,6 +35,12 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
             write_cmd   = CORSAIR_V2_WRITE_WIRELESS_ID;
             pid         = GetAddress(0x12);
             break;
+
+        case CORSAIR_K57_RGB_WIRED_PID:
+            write_cmd   = 0x80;
+            light_ctrl  = CORSAIR_V2_LIGHT_CTRL1;
+            skip_reads  = true;
+            break;
     }
 
     /*---------------------------------------------------------*\
@@ -93,14 +99,17 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
     |   If lighting control endpoint 2 is unavailable           |
     |   then use endpoint 1.                                    |
     \*---------------------------------------------------------*/
-    result = StartTransaction(0);
-    if(result > 0)
+    if(light_ctrl == CORSAIR_V2_LIGHT_CTRL2)
     {
-        light_ctrl = CORSAIR_V2_LIGHT_CTRL1;
-        StartTransaction(0);
+        result = StartTransaction(0);
+        if(result > 0)
+        {
+            light_ctrl = CORSAIR_V2_LIGHT_CTRL1;
+            StartTransaction(0);
+        }
+        StopTransaction(0);
+        LOG_DEBUG("[%s] Lighting Endpoint set to %02X", device_name.c_str(), light_ctrl);
     }
-    StopTransaction(0);
-    LOG_DEBUG("[%s] Lighting Endpoint set to %02X", device_name.c_str(), light_ctrl);
 }
 
 CorsairPeripheralV2Controller::~CorsairPeripheralV2Controller()
@@ -171,7 +180,11 @@ void CorsairPeripheralV2Controller::SetRenderMode(corsair_v2_device_mode mode)
     buffer[5]   = mode;
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
-    hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+
+    if(!skip_reads)
+    {
+        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+    }
 }
 
 void CorsairPeripheralV2Controller::LightingControl(uint8_t opt1)
@@ -191,7 +204,11 @@ void CorsairPeripheralV2Controller::LightingControl(uint8_t opt1)
     buffer[5]   = 0x00;
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
-    hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+
+    if(!skip_reads)
+    {
+        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+    }
 }
 
 unsigned int CorsairPeripheralV2Controller::GetKeyboardLayout()
@@ -240,7 +257,11 @@ unsigned char CorsairPeripheralV2Controller::StartTransaction(uint8_t opt1)
     buffer[4]   = light_ctrl;
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
-    hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+
+    if(!skip_reads)
+    {
+        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+    }
 
     return buffer[2];
 }
@@ -257,11 +278,20 @@ void CorsairPeripheralV2Controller::StopTransaction(uint8_t opt1)
     buffer[4]   = opt1;
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
-    hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+
+    if(!skip_reads)
+    {
+        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+    }
 }
 
 void CorsairPeripheralV2Controller::ClearPacketBuffer()
 {
+    if(skip_reads)
+    {
+        return;
+    }
+
     uint8_t result          = 0;
     uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
 
@@ -304,7 +334,11 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
     memcpy(&buffer[offset1], &data[0], copy_bytes);
 
     hid_write(dev, buffer, pkt_sze);
-    hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT_SHORT);
+
+    if(!skip_reads)
+    {
+        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT_SHORT);
+    }
 
     remaining              -= copy_bytes;
     buffer[2]               = CORSAIR_V2_CMD_BLK_WN;
@@ -325,7 +359,11 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
         memcpy(&buffer[offset2], &data[index], copy_bytes);
 
         hid_write(dev, buffer, pkt_sze);
-        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT_SHORT);
+
+        if(!skip_reads)
+        {
+            hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT_SHORT);
+        }
 
         remaining          -= copy_bytes;
     }

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.h

@@ -109,6 +109,7 @@ private:
 
     uint8_t                         write_cmd           = CORSAIR_V2_WRITE_WIRED_ID;
     uint16_t                        pkt_sze             = CORSAIR_V2_WRITE_SIZE;
+    bool                            skip_reads          = false;
     std::string                     firmware_version;
     std::string                     location;
 };

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2ControllerDetect.cpp

@@ -67,6 +67,7 @@ DetectedControllers DetectCorsairV2SoftwareControllers(hid_device_info* info, co
 | Keyboards                                                 |
 \*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K55_RGB_PRO_PID,                1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K57 RGB (Wired)",                 DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K57_RGB_WIRED_PID,              1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO Low Profile",         DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_LP_PID,             1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO TKL Black",           DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_TKL_B_PID,          1,  0xFF42);

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.cpp

@@ -48,6 +48,31 @@ std::vector<unsigned int> corsair_full_size_values =
 /*-------------------------------------------------------------------------*\
 |  KEYMAPS                                                                  |
 \*-------------------------------------------------------------------------*/
+keyboard_keymap_overlay_values corsair_K57_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
+    {
+        corsair_full_size_values,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Name,                       Alternate Name,             OpCode                              |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       17,        0,          "Power/Wireless Indicator", KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Profile into new row
+        {   0,      0,       18,        1,          "Lock/Macro Indicator",     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Light key
+        {   0,      1,       0,         131,        "Key: G1",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert G1 key
+        {   0,      2,       0,         132,        "Key: G2",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert G2 key
+        {   0,      3,       0,         133,        "Key: G3",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert G3 key
+        {   0,      4,       0,         134,        "Key: G4",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert G4 key
+        {   0,      5,       0,         135,        "Key: G5",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert G5 key
+        {   0,      6,       0,         136,        "Key: G6",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert G6 key
+    }
+};
+
 keyboard_keymap_overlay_values corsair_K60_layout
 {
     KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
@@ -116,12 +141,14 @@ keyboard_keymap_overlay_values corsair_k70_pro_layout
         {   0,      0,       0,         128,        "Profile",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Profile into new row
         {   0,      0,       1,         113,        "Light",                    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Light key
         {   0,      0,       2,         114,        "Lock",                     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lock Key
-        {   0,      0,      10,         191,        "Logo",                     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Logo
+        {   0,      0,      10,         138,        "Logo",                     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Logo
         {   0,      0,      18,         102,        KEY_EN_MEDIA_MUTE,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute Key
         {   0,      1,      17,         123,        KEY_EN_MEDIA_STOP,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Stop Key
         {   0,      1,      18,         126,        KEY_EN_MEDIA_PREVIOUS,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Previous Track Key
         {   0,      1,      19,         124,        KEY_EN_MEDIA_PLAY_PAUSE,    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play Pause Key
         {   0,      1,      20,         125,        KEY_EN_MEDIA_NEXT,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Next Tack Key
+        {   0,      6,       5,         140,        KEY_EN_SPACE,               KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert spacebar L
+        {   0,      6,       7,         141,        KEY_EN_SPACE,               KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert spacebar R
     }
 };
 
@@ -167,10 +194,10 @@ keyboard_keymap_overlay_values corsair_K70_CORE_TKL_layout
         | Edit Keys                                                                                                                             |
         |   Zone,   Row,    Column,     Value,      Name,                       Alternate Name,             OpCode,                             |
         \*-------------------------------------------------------------------------------------------------------------------------------------*/
-        {   0,      0,      14,         70,         KEY_EN_MEDIA_MUTE,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,         },  // Swap PRSC with Mute 
+        {   0,      0,      14,         70,         KEY_EN_MEDIA_MUTE,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,         },  // Swap PRSC with Mute
         {   0,      0,      15,         71,         KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,         },  // Remove SCLK
-        {   0,      0,      16,         72,         KEY_EN_MEDIA_VOLUME_UP,     KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,         },  // Swap PSBK with Volume Potion Up 
-        
+        {   0,      0,      16,         72,         KEY_EN_MEDIA_VOLUME_UP,     KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,         },  // Swap PSBK with Volume Potion Up
+
     }
 };
 
@@ -772,6 +799,38 @@ static const corsair_v2_device k55_rgb_pro_device =
     nullptr
 };
 
+/*-------------------------------------------------------------*\
+|  Corsair K57 RGB (Wired) 1B1C:1B6E                            |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       7 Rows, 22 Columns                                      |
+\*-------------------------------------------------------------*/
+static const corsair_v2_zone k57_rgb_wired_zone =
+{
+    ZONE_EN_KEYBOARD,
+    ZONE_TYPE_MATRIX,
+    7,
+    22
+};
+
+static const corsair_v2_device k57_rgb_wired_device =
+{
+    CORSAIR_K57_RGB_WIRED_PID,
+    DEVICE_TYPE_KEYBOARD,
+    7,
+    22,
+    {
+        &k57_rgb_wired_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    &corsair_K57_layout
+};
+
 /*-------------------------------------------------------------*\
 |  Corsair K60 RGB Pro 1B1C:1BA0                                |
 |                                                               |
@@ -1461,6 +1520,7 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
     &k55_rgb_pro_device,
+    &k57_rgb_wired_device,
     &k60_rgb_pro_device,
     &k60_rgb_pro_lp_device,
     &k60_rgb_pro_tkl_device_b,

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.h

@@ -69,6 +69,8 @@ typedef struct
 | Corsair V2 Protocol Keyboards                         |
 \*-----------------------------------------------------*/
 #define CORSAIR_K55_RGB_PRO_PID                     0x1BA4
+#define CORSAIR_K57_RGB_WIRED_PID                   0x1B6E
+#define CORSAIR_K57_RGB_WIRELESS_PID                0x1B62
 #define CORSAIR_K60_RGB_PRO_PID                     0x1BA0
 #define CORSAIR_K60_RGB_PRO_LP_PID                  0x1BAD
 #define CORSAIR_K60_RGB_PRO_TKL_B_PID               0x1BC7

Controllers/CorsairVengeanceController/CorsairVengeanceController.cpp

@@ -34,7 +34,7 @@ std::string CorsairVengeanceController::GetDeviceName()
 
 std::string CorsairVengeanceController::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");

Controllers/CorsairWirelessController/CorsairWirelessController.cpp

@@ -1,217 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairWirelessController.cpp                             |
-|                                                           |
-|   Driver for Corsair wireless keyboard                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include "CorsairWirelessController.h"
-#include "StringUtils.h"
-
-using namespace std::chrono_literals;
-
-CorsairWirelessController::CorsairWirelessController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-
-    type        = DEVICE_TYPE_KEYBOARD;
-
-    EnterDirectMode();
-}
-
-CorsairWirelessController::~CorsairWirelessController()
-{
-    hid_close(dev);
-}
-
-device_type CorsairWirelessController::GetDeviceType()
-{
-    return type;
-}
-
-std::string CorsairWirelessController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string CorsairWirelessController::GetFirmwareString()
-{
-    return firmware_version;
-}
-
-std::string CorsairWirelessController::GetName()
-{
-    return name;
-}
-
-std::string CorsairWirelessController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    return(StringUtils::wstring_to_string(serial_string));
-}
-
-void CorsairWirelessController::SetLEDs(std::vector<RGBColor>colors)
-{
-    unsigned char buf[3 * 137];
-
-    for(int color = 0; color < 137; color++)
-    {
-        buf[0 + color]   = RGBGetRValue(colors[color]);
-        buf[137 + color] = RGBGetGValue(colors[color]);
-        buf[274+color]   = RGBGetBValue(colors[color]);
-    }
-
-    StartDirectMode();
-
-    SendDirectFrame(true,  &buf[0]);
-    SendDirectFrame(false, &buf[57]);
-    SendDirectFrame(false, &buf[118]);
-    SendDirectFrame(false, &buf[179]);
-    SendDirectFrame(false, &buf[240]);
-    SendDirectFrame(false, &buf[301]);
-    SendDirectFrame(false, &buf[362]);
-}
-
-void CorsairWirelessController::SetName(std::string device_name)
-{
-    name = device_name;
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void CorsairWirelessController::EnterDirectMode()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Submit Mouse Colors packet                     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x80;
-    usb_buf[0x02]   = 0x01;
-    usb_buf[0x03]   = 0x03;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = 0x02;
-
-    /*-----------------------------------------------------*\
-    | Send packet using feature reports, as headset stand   |
-    | seems to not update completely using HID writes       |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-}
-
-void CorsairWirelessController::StartDirectMode()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Submit Mouse Colors packet                     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x80;
-    usb_buf[0x02]   = 0x0D;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet using feature reports, as headset stand   |
-    | seems to not update completely using HID writes       |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-}
-
-void CorsairWirelessController::ExitDirectMode()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Submit Mouse Colors packet                     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x80;
-    usb_buf[0x02]   = 0x01;
-    usb_buf[0x03]   = 0x03;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet using feature reports, as headset stand   |
-    | seems to not update completely using HID writes       |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-}
-
-void CorsairWirelessController::SendDirectFrame(bool first_frame, unsigned char* data)
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Submit Mouse Colors packet                     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x80;
-    usb_buf[0x02]   = first_frame ? 0x06 : 0x07;
-    usb_buf[0x03]   = 0x00;
-
-    if(first_frame)
-    {
-        usb_buf[0x04]   = 0x9B;
-        usb_buf[0x05]   = 0x01;
-    }
-
-    /*-----------------------------------------------------*\
-    | Copy in colors in <RED> <GREEN> <BLUE> order          |
-    \*-----------------------------------------------------*/
-    if(first_frame)
-    {
-        memcpy(&usb_buf[0x08], data, 57);
-    }
-    else
-    {
-        memcpy(&usb_buf[0x04], data, 61);
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet using feature reports, as headset stand   |
-    | seems to not update completely using HID writes       |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}

Controllers/CorsairWirelessController/CorsairWirelessController.h

@@ -1,45 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairWirelessController.h                               |
-|                                                           |
-|   Driver for Corsair wireless keyboard                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
-class CorsairWirelessController
-{
-public:
-    CorsairWirelessController(hid_device* dev_handle, const char* path);
-    ~CorsairWirelessController();
-
-    device_type     GetDeviceType();
-    std::string     GetDeviceLocation();
-    std::string     GetFirmwareString();
-    std::string     GetName();
-    std::string     GetSerialString();
-
-    void            SetLEDs(std::vector<RGBColor> colors);
-    void            SetName(std::string device_name);
-
-private:
-    hid_device*             dev;
-
-    std::string             firmware_version;
-    std::string             location;
-    std::string             name;
-    device_type             type;
-
-    void            EnterDirectMode();
-    void            ExitDirectMode();
-    void            StartDirectMode();
-    void            SendDirectFrame(bool first_frame, unsigned char* data);
-};

Controllers/CorsairWirelessController/CorsairWirelessControllerDetect.cpp

@@ -1,59 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairWirelessControllerDetect.cpp                       |
-|                                                           |
-|   Detector for Corsair wireless keyboard                  |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
-#include "DetectionManager.h"
-#include "CorsairWirelessController.h"
-#include "RGBController.h"
-#include "RGBController_CorsairWireless.h"
-
-/*---------------------------------------------------------*\
-| Corsair vendor ID                                         |
-\*---------------------------------------------------------*/
-#define CORSAIR_VID                     0x1B1C
-
-/*---------------------------------------------------------*\
-| Keyboard product IDs                                      |
-\*---------------------------------------------------------*/
-#define CORSAIR_K57_RGB_WIRED_PID       0x1B6E
-#define CORSAIR_K57_RGB_WIRELESS_PID    0x1B62
-
-DetectedControllers DetectCorsairWirelessControllers(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        CorsairWirelessController* controller = new CorsairWirelessController(dev, info->path);
-        controller->SetName(name);
-
-        if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
-        {
-            RGBController_CorsairWireless* rgb_controller = new RGBController_CorsairWireless(controller);
-            detected_controllers.push_back(rgb_controller);
-        }
-        else
-        {
-            delete controller;
-        }
-    }
-
-    return(detected_controllers);
-}
-
-/*---------------------------------------------------------*\
-| Keyboards                                                 |
-\*---------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Corsair K57 RGB (Wired)",         DetectCorsairWirelessControllers,   CORSAIR_VID,    CORSAIR_K57_RGB_WIRED_PID,     1,  0xFF42, 1);
-//REGISTER_HID_DETECTOR_IPU("Corsair K57 RGB (Wireless)",      DetectCorsairWirelessControllers,   CORSAIR_VID,    CORSAIR_K57_RGB_WIRELESS_PID,  1,  0xFF42, 1);

Controllers/CorsairWirelessController/RGBController_CorsairWireless.cpp

@@ -1,319 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_CorsairWireless.cpp                         |
-|                                                           |
-|   RGBController for Corsair wireless keyboard             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include "RGBController_CorsairWireless.h"
-
-using namespace std::chrono_literals;
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-static unsigned int matrix_map[7][24] =
-    { {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,   0,   1,  NA,  NA,  NA },
-      { 131,  41,  NA,  58,  59,  60,  61,  NA,  62,  63,  64,  65,  NA,  66,  67,  68,  69,  70,  71,  72,  NA,  NA,  NA,  NA },
-      { 132,  53,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  NA,  45,  46,  42,  NA,  73,  74,  75,  83,  84,  85,  86 },
-      { 133,  43,  NA,  20,  26,   8,  21,  NA,  23,  28,  24,  12,  18,  19,  47,  48,  49,  76,  77,  78,  95,  96,  97,  87 },
-      { 134,  57,  NA,   4,  22,   7,   9,  NA,  10,  11,  13,  14,  15,  51,  52,  NA,  40,  NA,  NA,  NA,  92,  93,  94,  NA },
-      { 135, 106,  NA,  29,  27,   6,  25,  NA,   5,  NA,  17,  16,  54,  55,  56, 110,  NA,  NA,  82,  NA,  89,  90,  91,  88 },
-      { 136, 105, 108, 107,  NA,  NA,  NA,  NA,  44,  NA,  NA,  NA,  NA, 111, 122, 101, 109,  80,  81,  79,  98,  NA,  99,  NA } };
-
-static const char* zone_names[] =
-{
-    ZONE_EN_KEYBOARD,
-};
-
-static const unsigned int zone_sizes[] =
-{
-    137
-};
-
-static const zone_type zone_types[] =
-{
-    ZONE_TYPE_MATRIX,
-};
-
-static const char* led_names[] =
-{
-    "Power/Wireless Indicator",
-    "Lock/Macro Indicator",
-    "N/A",
-    "N/A",
-    KEY_EN_A,
-    KEY_EN_B,
-    KEY_EN_C,
-    KEY_EN_D,
-    KEY_EN_E,
-    KEY_EN_F,
-    KEY_EN_G,
-    KEY_EN_H,
-    KEY_EN_I,
-    KEY_EN_J,
-    KEY_EN_K,
-    KEY_EN_L,
-    KEY_EN_M,
-    KEY_EN_N,
-    KEY_EN_O,
-    KEY_EN_P,
-    KEY_EN_Q,
-    KEY_EN_R,
-    KEY_EN_S,
-    KEY_EN_T,
-    KEY_EN_U,
-    KEY_EN_V,
-    KEY_EN_W,
-    KEY_EN_X,
-    KEY_EN_Y,
-    KEY_EN_Z,
-    KEY_EN_1,
-    KEY_EN_2,
-    KEY_EN_3,
-    KEY_EN_4,
-    KEY_EN_5,
-    KEY_EN_6,
-    KEY_EN_7,
-    KEY_EN_8,
-    KEY_EN_9,
-    KEY_EN_0,
-    KEY_EN_ANSI_ENTER,
-    KEY_EN_ESCAPE,
-    KEY_EN_BACKSPACE,
-    KEY_EN_TAB,
-    KEY_EN_SPACE,
-    KEY_EN_MINUS,
-    KEY_EN_EQUALS,
-    KEY_EN_LEFT_BRACKET,
-    KEY_EN_RIGHT_BRACKET,
-    KEY_EN_ANSI_BACK_SLASH,
-    KEY_EN_UNUSED,
-    KEY_EN_SEMICOLON,
-    KEY_EN_QUOTE,
-    KEY_EN_BACK_TICK,
-    KEY_EN_COMMA,
-    KEY_EN_PERIOD,
-    KEY_EN_FORWARD_SLASH,
-    KEY_EN_CAPS_LOCK,
-    KEY_EN_F1,
-    KEY_EN_F2,
-    KEY_EN_F3,
-    KEY_EN_F4,
-    KEY_EN_F5,
-    KEY_EN_F6,
-    KEY_EN_F7,
-    KEY_EN_F8,
-    KEY_EN_F9,
-    KEY_EN_F10,
-    KEY_EN_F11,
-    KEY_EN_F12,
-    KEY_EN_PRINT_SCREEN,
-    KEY_EN_SCROLL_LOCK,
-    KEY_EN_PAUSE_BREAK,
-    KEY_EN_INSERT,
-    KEY_EN_HOME,
-    KEY_EN_PAGE_UP,
-    KEY_EN_DELETE,
-    KEY_EN_END,
-    KEY_EN_PAGE_DOWN,
-    KEY_EN_RIGHT_ARROW,
-    KEY_EN_LEFT_ARROW,
-    KEY_EN_DOWN_ARROW,
-    KEY_EN_UP_ARROW,
-    KEY_EN_NUMPAD_LOCK,
-    KEY_EN_NUMPAD_DIVIDE,
-    KEY_EN_NUMPAD_TIMES,
-    KEY_EN_NUMPAD_MINUS,
-    KEY_EN_NUMPAD_PLUS,
-    KEY_EN_NUMPAD_ENTER,
-    KEY_EN_NUMPAD_1,
-    KEY_EN_NUMPAD_2,
-    KEY_EN_NUMPAD_3,
-    KEY_EN_NUMPAD_4,
-    KEY_EN_NUMPAD_5,
-    KEY_EN_NUMPAD_6,
-    KEY_EN_NUMPAD_7,
-    KEY_EN_NUMPAD_8,
-    KEY_EN_NUMPAD_9,
-    KEY_EN_NUMPAD_0,
-    KEY_EN_NUMPAD_PERIOD,
-    KEY_EN_UNUSED,
-    KEY_EN_MENU,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_LEFT_CONTROL,
-    KEY_EN_LEFT_SHIFT,
-    KEY_EN_LEFT_ALT,
-    KEY_EN_LEFT_WINDOWS,
-    KEY_EN_RIGHT_CONTROL,
-    KEY_EN_RIGHT_SHIFT,
-    KEY_EN_RIGHT_ALT,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_RIGHT_FUNCTION,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    "Key: G1",
-    "Key: G2",
-    "Key: G3",
-    "Key: G4",
-    "Key: G5",
-    "Key: G6",
-};
-
-/**------------------------------------------------------------------*\
-    @name Corsair Wireless Peripheral
-    @category Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectCorsairWirelessControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_CorsairWireless::RGBController_CorsairWireless(CorsairWirelessController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = controller->GetName();
-    vendor      = "Corsair";
-    description = "Corsair RGB Peripheral Device";
-    type        = controller->GetDeviceType();
-    version     = controller->GetFirmwareString();
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    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();
-
-    /*-----------------------------------------------------*\
-    | The Corsair Lighting Node Pro requires a packet within|
-    | 20 seconds of sending the lighting change in order    |
-    | to not revert back into rainbow mode.  Start a thread |
-    | to continuously send a keepalive packet every 5s      |
-    \*-----------------------------------------------------*/
-    keepalive_thread_run = true;
-    keepalive_thread = new std::thread(&RGBController_CorsairWireless::KeepaliveThread, this);
-}
-
-RGBController_CorsairWireless::~RGBController_CorsairWireless()
-{
-    Shutdown();
-
-    /*-----------------------------------------------------*\
-    | Close keepalive thread                                |
-    \*-----------------------------------------------------*/
-    keepalive_thread_run = false;
-    keepalive_thread->join();
-    delete keepalive_thread;
-
-    delete controller;
-}
-
-void RGBController_CorsairWireless::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Determine number of zones                                 |
-    |   For now, keyboard has 2 zones and mousemat has 1        |
-    \*---------------------------------------------------------*/
-    unsigned int num_zones = 1;
-
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    unsigned int total_led_count = 0;
-    for(unsigned int zone_idx = 0; zone_idx < num_zones; zone_idx++)
-    {
-        zone new_zone;
-
-        new_zone.name                   = zone_names[zone_idx];
-        new_zone.type                   = zone_types[zone_idx];
-        new_zone.leds_min               = zone_sizes[zone_idx];
-        new_zone.leds_max               = zone_sizes[zone_idx];
-        new_zone.leds_count             = zone_sizes[zone_idx];
-
-        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
-        {
-            new_zone.matrix_map.Set(7, 24, (unsigned int *)&matrix_map);
-        }
-
-        zones.push_back(new_zone);
-        total_led_count += new_zone.leds_count;
-    }
-
-    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
-    {
-        led new_led;
-
-        new_led.name                    = led_names[led_idx];
-
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_CorsairWireless::DeviceUpdateLEDs()
-{
-    last_update_time = std::chrono::steady_clock::now();
-
-    controller->SetLEDs(colors);
-}
-
-void RGBController_CorsairWireless::DeviceUpdateZoneLEDs(int /*zone*/)
-{
-    controller->SetLEDs(colors);
-}
-
-void RGBController_CorsairWireless::DeviceUpdateSingleLED(int /*led*/)
-{
-    controller->SetLEDs(colors);
-}
-
-void RGBController_CorsairWireless::DeviceUpdateMode()
-{
-
-}
-
-void RGBController_CorsairWireless::KeepaliveThread()
-{
-    while(keepalive_thread_run.load())
-    {
-        if(active_mode == 0)
-        {
-            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(5000))
-            {
-                DeviceUpdateLEDs();
-            }
-        }
-        std::this_thread::sleep_for(1000ms);
-    }
-}

Controllers/CreativeController/CreativeSoundBlasterXG6Controller.cpp

@@ -23,7 +23,7 @@ CreativeSoundBlasterXG6Controller::~CreativeSoundBlasterXG6Controller()
 
 std::string CreativeSoundBlasterXG6Controller::GetDeviceLocation()
 {
-    return("HID " + location);
+    return("HID: " + location);
 }
 
 std::string CreativeSoundBlasterXG6Controller::GetDeviceName()

Controllers/CrucialController/CrucialController.cpp

@@ -35,7 +35,7 @@ std::string CrucialController::GetDeviceVersion()
 
 std::string CrucialController::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");
@@ -134,7 +134,14 @@ void CrucialController::CrucialRegisterWriteBlock(crucial_register reg, unsigned
     bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
 
     //Write Crucial block data
-    bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
+    if(bus->i2c_smbus_write_block_data(dev, 0x03, sz, data) == -1)
+    {
+        //Fall back to individual byte operations if the block operation fails
+        for(unsigned int block_byte = 0; block_byte < sz; block_byte++)
+        {
+            bus->i2c_smbus_write_byte_data(dev, 0x01, data[block_byte]);
+        }
+    }
 }
 
 void CrucialController::SendEffectColor

Controllers/CrucialController/CrucialControllerDetect.cpp

@@ -28,12 +28,6 @@ using namespace std::chrono_literals;
 
 static const unsigned char crucial_addresses[] =
 {
-/*---------------------------------------------------------*\
-| These addresses have been disabled due to conflict with   |
-| ENE DRAM.  Since the detection scheme is the same, ENE    |
-| RAM will be detected as Crucial.  We need to improve the  |
-| Crucial detection scheme.                                 |
-\*---------------------------------------------------------*/
     0x39,
     0x3A,
     0x3B,
@@ -71,19 +65,19 @@ bool TestForCrucialController(i2c_smbus_interface* bus, unsigned char address)
 {
     bool pass = false;
 
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
+    int res = bus->i2c_smbus_read_byte(address);
 
-    if (res >= 0)
+    if(res >= 0)
     {
         pass = true;
 
         LOG_DEBUG("[%s] Detected an I2C device at address %02X", CRUCIAL_CONTROLLER_NAME, address);
 
-        for (int i = 0xA0; i < 0xB0; i++)
+        for(int i = 0xA0; i < 0xB0; i++)
         {
             res = bus->i2c_smbus_read_byte_data(address, i);
 
-            if (res != (i - 0xA0))
+            if(res != (i - 0xA0))
             {
                 LOG_VERBOSE("[%s] Detection failed testing register %02X.  Expected %02X, got %02X.", CRUCIAL_CONTROLLER_NAME, i, (i - 0xA0), res);
 
@@ -145,11 +139,11 @@ DetectedControllers DetectCrucialControllers(std::vector<i2c_smbus_interface*> &
     {
         int address_list_idx = -1;
 
-        IF_DRAM_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
+        IF_DRAM_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
         {
             for(unsigned int slot = 0; slot < 4; slot++)
             {
-                int res = buses[bus]->i2c_smbus_write_quick(0x27, I2C_SMBUS_WRITE);
+                int res = buses[bus]->i2c_smbus_read_byte(0x27);
 
                 if(res < 0)
                 {
@@ -163,7 +157,7 @@ DetectedControllers DetectCrucialControllers(std::vector<i2c_smbus_interface*> &
 
                     if(address_list_idx < CRUCIAL_ADDRESS_COUNT)
                     {
-                        res = buses[bus]->i2c_smbus_write_quick(crucial_addresses[address_list_idx], I2C_SMBUS_WRITE);
+                        res = buses[bus]->i2c_smbus_read_byte(crucial_addresses[address_list_idx]);
                     }
                     else
                     {
@@ -182,7 +176,7 @@ DetectedControllers DetectCrucialControllers(std::vector<i2c_smbus_interface*> &
                 std::this_thread::sleep_for(1ms);
             }
 
-            LOG_DEBUG("[%s] In bus: %02X:%02X looking for devices at [%s]", CRUCIAL_CONTROLLER_NAME, buses[bus]->pci_vendor, buses[bus]->pci_device, TESTING_ADDRESSES);
+            LOG_DEBUG("[%s] In bus: %02X:%02X looking for devices at [%s]", CRUCIAL_CONTROLLER_NAME, buses[bus]->info.pci_vendor, buses[bus]->info.pci_device, TESTING_ADDRESSES);
 
             // Add Crucial controllers
             for(unsigned int address_list_idx = 0; address_list_idx < CRUCIAL_ADDRESS_COUNT; address_list_idx++)

Controllers/DDPController/DDPControllerDetect.cpp

@@ -9,7 +9,7 @@
 
 #include <string>
 #include <vector>
-#include "nlohmann/json.hpp"
+#include <nlohmann/json.hpp>
 #include "DetectionManager.h"
 #include "LogManager.h"
 #include "ResourceManager.h"

Controllers/DRGBController/RGBController_DRGB.cpp

@@ -116,7 +116,7 @@ void RGBController_DRGB::SetupZones()
             led new_led;
             new_led.name                = zones[channel_idx].name + ", LED " + std::to_string(led_ch_idx);
             leds.push_back(new_led);
-            leds_channel.push_back(channel_idx);
+            leds_channel.push_back((unsigned int)channel_idx);
         }
     }
 

Controllers/DebugController/RGBController_Debug.cpp

@@ -13,6 +13,7 @@
 #include <algorithm>
 #include <cstring>
 #include "KeyboardLayoutManager.h"
+#include "JsonUtils.h"
 #include "RGBController_Debug.h"
 
 /**------------------------------------------------------------------*\
@@ -51,100 +52,6 @@ RGBController_Debug::RGBController_Debug(bool custom, json settings)
     custom_controller   = custom;
     debug_settings      = settings;
 
-    if(custom_controller)
-    {
-        /*-------------------------------------------------*\
-        | Set the name                                      |
-        \*-------------------------------------------------*/
-        name = debug_settings["DeviceName"];
-
-        /*-------------------------------------------------*\
-        | Find the device type                              |
-        \*-------------------------------------------------*/
-        if      (debug_settings["DeviceType"] == "motherboard")   type = DEVICE_TYPE_MOTHERBOARD;
-        else if (debug_settings["DeviceType"] == "dram")          type = DEVICE_TYPE_DRAM;
-        else if (debug_settings["DeviceType"] == "gpu")           type = DEVICE_TYPE_GPU;
-        else if (debug_settings["DeviceType"] == "cooler")        type = DEVICE_TYPE_COOLER;
-        else if (debug_settings["DeviceType"] == "led_strip")     type = DEVICE_TYPE_LEDSTRIP;
-        else if (debug_settings["DeviceType"] == "keyboard")      type = DEVICE_TYPE_KEYBOARD;
-        else if (debug_settings["DeviceType"] == "mouse")         type = DEVICE_TYPE_MOUSE;
-        else if (debug_settings["DeviceType"] == "mousemat")      type = DEVICE_TYPE_MOUSEMAT;
-        else if (debug_settings["DeviceType"] == "headset")       type = DEVICE_TYPE_HEADSET;
-        else if (debug_settings["DeviceType"] == "headset_stand") type = DEVICE_TYPE_HEADSET_STAND;
-        else if (debug_settings["DeviceType"] == "gamepad")       type = DEVICE_TYPE_GAMEPAD;
-        else if (debug_settings["DeviceType"] == "light")         type = DEVICE_TYPE_LIGHT;
-        else if (debug_settings["DeviceType"] == "speaker")       type = DEVICE_TYPE_SPEAKER;
-        else if (debug_settings["DeviceType"] == "unknown")       type = DEVICE_TYPE_UNKNOWN;
-
-        /*-------------------------------------------------*\
-        | Set description, location, version, and serial    |
-        \*-------------------------------------------------*/
-        description                             = debug_settings["DeviceDescription"];
-        location                                = debug_settings["DeviceLocation"];
-        version                                 = debug_settings["DeviceVersion"];
-        serial                                  = debug_settings["DeviceSerial"];
-    }
-    else
-    {
-        std::string name_setting    = "";
-        std::string type_setting    = "keyboard";
-
-        if(debug_settings.contains("name"))
-        {
-            name_setting = debug_settings["name"];
-        }
-
-        if(debug_settings.contains("type"))
-        {
-            type_setting = debug_settings["type"];
-        }
-
-        if(type_setting == "motherboard")
-        {
-            name                = "Debug Motherboard";
-            type                = DEVICE_TYPE_MOTHERBOARD;
-        }
-        else if(type_setting == "dram")
-        {
-            name                = "Debug DRAM";
-            type                = DEVICE_TYPE_DRAM;
-        }
-        else if(type_setting == "gpu")
-        {
-            name                = "Debug GPU";
-            type                = DEVICE_TYPE_GPU;
-        }
-        else if(type_setting == "keyboard")
-        {
-            name                = "Debug Keyboard";
-            type                = DEVICE_TYPE_KEYBOARD;
-        }
-      else if(type_setting == "mouse")
-        {
-            name                = "Debug Mouse";
-            type                = DEVICE_TYPE_MOUSE;
-        }
-        else if(type_setting == "argb")
-        {
-            name                = "Debug ARGB Controller";
-            type                = DEVICE_TYPE_LEDSTRIP;
-        }
-
-        /*---------------------------------------------------------*\
-        | Fill in debug controller information                      |
-        \*---------------------------------------------------------*/
-        description                     = name + " Device";
-        vendor                          = name + " Vendor String";
-        location                        = name + " Location String";
-        version                         = name + " Version String";
-        serial                          = name + " Serial String";
-
-        if(name_setting != "")
-        {
-            name                        = name_setting;
-        }
-    }
-
     /*-----------------------------------------------------*\
     | Create the mode                                       |
     \*-----------------------------------------------------*/
@@ -157,6 +64,7 @@ RGBController_Debug::RGBController_Debug(bool custom, json settings)
 
     modes.push_back(Direct);
 
+    SetupDevice();
     SetupZones();
 }
 
@@ -165,6 +73,137 @@ RGBController_Debug::~RGBController_Debug()
     Shutdown();
 }
 
+void RGBController_Debug::SetupDevice()
+{
+    if(custom_controller)
+    {
+        /*-------------------------------------------------*\
+        | Set the name, description, location, version, and |
+        | serial                                            |
+        \*-------------------------------------------------*/
+        name                            = JsonUtils::JsonGetString(debug_settings, "DeviceName", "Custom Device");
+        description                     = JsonUtils::JsonGetString(debug_settings, "DeviceDescription");
+        location                        = JsonUtils::JsonGetString(debug_settings, "DeviceLocation");
+        version                         = JsonUtils::JsonGetString(debug_settings, "DeviceVersion");
+        serial                          = JsonUtils::JsonGetString(debug_settings, "DeviceSerial");
+
+        /*-------------------------------------------------*\
+        | Find the device type                              |
+        \*-------------------------------------------------*/
+        std::string device_type         = JsonUtils::JsonGetString(debug_settings, "DeviceType", "keyboard");
+
+        if(     device_type == "motherboard")   type = DEVICE_TYPE_MOTHERBOARD;
+        else if(device_type == "dram")          type = DEVICE_TYPE_DRAM;
+        else if(device_type == "gpu")           type = DEVICE_TYPE_GPU;
+        else if(device_type == "cooler")        type = DEVICE_TYPE_COOLER;
+        else if(device_type == "led_strip")     type = DEVICE_TYPE_LEDSTRIP;
+        else if(device_type == "keyboard")      type = DEVICE_TYPE_KEYBOARD;
+        else if(device_type == "mouse")         type = DEVICE_TYPE_MOUSE;
+        else if(device_type == "mousemat")      type = DEVICE_TYPE_MOUSEMAT;
+        else if(device_type == "headset")       type = DEVICE_TYPE_HEADSET;
+        else if(device_type == "headset_stand") type = DEVICE_TYPE_HEADSET_STAND;
+        else if(device_type == "gamepad")       type = DEVICE_TYPE_GAMEPAD;
+        else if(device_type == "light")         type = DEVICE_TYPE_LIGHT;
+        else if(device_type == "speaker")       type = DEVICE_TYPE_SPEAKER;
+        else if(device_type == "unknown")       type = DEVICE_TYPE_UNKNOWN;
+    }
+    else
+    {
+        std::string name_value;
+        std::string name_setting        = JsonUtils::JsonGetString(debug_settings, "name");
+        std::string type_setting        = JsonUtils::JsonGetString(debug_settings, "type", "keyboard");
+
+        if(type_setting == "motherboard")
+        {
+            name_value                  = "Debug Motherboard";
+            type                        = DEVICE_TYPE_MOTHERBOARD;
+        }
+        else if(type_setting == "dram")
+        {
+            name_value                  = "Debug DRAM";
+            type                        = DEVICE_TYPE_DRAM;
+        }
+        else if(type_setting == "gpu")
+        {
+            name_value                  = "Debug GPU";
+            type                        = DEVICE_TYPE_GPU;
+        }
+        else if(type_setting == "keyboard")
+        {
+            name_value                  = "Debug Keyboard";
+            type                        = DEVICE_TYPE_KEYBOARD;
+        }
+        else if(type_setting == "mouse")
+        {
+            name_value                  = "Debug Mouse";
+            type                        = DEVICE_TYPE_MOUSE;
+        }
+        else if(type_setting == "argb")
+        {
+            name_value                  = "Debug ARGB Controller";
+            type                        = DEVICE_TYPE_LEDSTRIP;
+        }
+
+        /*---------------------------------------------------------*\
+        | Fill in debug controller information                      |
+        \*---------------------------------------------------------*/
+        description                     = name_value + " Device";
+        vendor                          = name_value + " Vendor String";
+        location                        = name_value + " Location String";
+        version                         = name_value + " Version String";
+        serial                          = name_value + " Serial String";
+        flags                          |= CONTROLLER_FLAG_MANUALLY_CONFIGURABLE_NAME | CONTROLLER_FLAG_MANUALLY_CONFIGURABLE_DEVICE_SPECIFIC;
+
+        if(name_setting != "")
+        {
+            name_value                  = name_setting;
+        }
+
+        if((flags & CONTROLLER_FLAG_MANUALLY_CONFIGURED_NAME) == 0)
+        {
+            name                        = name_value;
+        }
+
+        /*---------------------------------------------------------*\
+        | Create test configuration                                 |
+        \*---------------------------------------------------------*/
+        nlohmann::json configuration_json;
+        JsonUtils::JsonParse(configuration, configuration_json);
+
+        configuration_json["schema"]["test_string"]["title"]     = "String Setting";
+        configuration_json["schema"]["test_string"]["type"]      = "string";
+
+        configuration_json["schema"]["test_bool"]["title"]       = "Boolean Setting";
+        configuration_json["schema"]["test_bool"]["type"]        = "bool";
+
+        configuration_json["schema"]["test_enum"]["title"]       = "String Enum Setting";
+        configuration_json["schema"]["test_enum"]["type"]        = "string";
+        configuration_json["schema"]["test_enum"]["enum"][0]     = "Option 1";
+        configuration_json["schema"]["test_enum"]["enum"][1]     = "Option 2";
+        configuration_json["schema"]["test_enum"]["enum"][2]     = "Option 3";
+
+        configuration_json["schema"]["test_enum_int"]["title"]   = "Integer Enum Setting";
+        configuration_json["schema"]["test_enum_int"]["type"]    = "integer";
+        configuration_json["schema"]["test_enum_int"]["enum"][0] = 2;
+        configuration_json["schema"]["test_enum_int"]["enum"][1] = 4;
+        configuration_json["schema"]["test_enum_int"]["enum"][2] = 8;
+
+        configuration_json["schema"]["test_int"]["title"]        = "Integer Setting";
+        configuration_json["schema"]["test_int"]["type"]         = "integer";
+
+        if((flags & CONTROLLER_FLAG_MANUALLY_CONFIGURED_DEVICE_SPECIFIC) == 0)
+        {
+            configuration_json["configuration"]["test_string"]   = "This is a test";
+            configuration_json["configuration"]["test_bool"]     = true;
+            configuration_json["configuration"]["test_enum"]     = "Option 2";
+            configuration_json["configuration"]["test_enum_int"] = 4;
+            configuration_json["configuration"]["test_int"]      = 12345;
+        }
+
+        configuration = configuration_json.dump();
+    }
+}
+
 void RGBController_Debug::SetupZones()
 {
     /*-------------------------------------------------*\
@@ -181,6 +220,7 @@ void RGBController_Debug::SetupZones()
     /*-------------------------------------------------*\
     | Clear any existing color/LED configuration        |
     \*-------------------------------------------------*/
+    led_display_names.clear();
     leds.clear();
     colors.clear();
 
@@ -216,9 +256,9 @@ void RGBController_Debug::SetupZones()
                 continue;
             }
 
-            custom_zone.leds_min   = ZoneJson["leds_min"];
-            custom_zone.leds_max   = ZoneJson["leds_max"];
-            custom_zone.leds_count = ZoneJson["leds_count"];
+            custom_zone.leds_min        = JsonUtils::JsonGetInt(ZoneJson, "leds_min");
+            custom_zone.leds_max        = JsonUtils::JsonGetInt(ZoneJson, "leds_max");
+            custom_zone.leds_count      = JsonUtils::JsonGetInt(ZoneJson, "leds_count");
 
             /*---------------------------------------------*\
             | Fill in the matrix map                        |
@@ -241,8 +281,8 @@ void RGBController_Debug::SetupZones()
                     continue;
                 }
 
-                unsigned int H                  = ZoneJson["matrix_width"];
-                unsigned int W                  = ZoneJson["matrix_height"];
+                unsigned int H                  = JsonUtils::JsonGetInt(ZoneJson, "matrix_width");
+                unsigned int W                  = JsonUtils::JsonGetInt(ZoneJson, "matrix_height");
 
                 BadVal                          = ((unsigned int)ZoneJson["matrix_map"].size() != H);
 
@@ -333,36 +373,11 @@ void RGBController_Debug::SetupZones()
     }
     else
     {
-        bool    zone_single             = true;
-        bool    zone_linear             = true;
-        bool    zone_resizable          = false;
-        bool    zone_keyboard           = false;
-        bool    zone_underglow          = false;
-
-        if(debug_settings.contains("single"))
-        {
-            zone_single = debug_settings["single"];
-        }
-
-        if(debug_settings.contains("linear"))
-        {
-            zone_linear = debug_settings["linear"];
-        }
-
-        if(debug_settings.contains("resizable"))
-        {
-            zone_resizable = debug_settings["resizable"];
-        }
-
-        if(debug_settings.contains("keyboard"))
-        {
-            zone_keyboard = debug_settings["keyboard"];
-        }
-
-        if(debug_settings.contains("underglow"))
-        {
-            zone_underglow = debug_settings["underglow"];
-        }
+        bool    zone_single             = JsonUtils::JsonGetBool(debug_settings, "single", true);
+        bool    zone_linear             = JsonUtils::JsonGetBool(debug_settings, "linear", true);
+        bool    zone_resizable          = JsonUtils::JsonGetBool(debug_settings, "resizable", false);
+        bool    zone_keyboard           = JsonUtils::JsonGetBool(debug_settings, "keyboard", false);
+        bool    zone_underglow          = JsonUtils::JsonGetBool(debug_settings, "underglow", false);
 
         /*-------------------------------------------------*\
         | Create a single zone/LED                          |
@@ -371,28 +386,51 @@ void RGBController_Debug::SetupZones()
         {
             zone single_zone;
 
-            single_zone.name            = "Single Zone";
-            single_zone.type            = ZONE_TYPE_SINGLE;
-            single_zone.leds_min        = 1;
-            single_zone.leds_max        = 1;
-            single_zone.leds_count      = 1;
-
             if(first_run)
             {
                 zones.push_back(single_zone);
             }
-            else
+
+            zones[zone_idx].name        = "Single Zone";
+            zones[zone_idx].type        = ZONE_TYPE_SINGLE;
+
+            if(first_run)
             {
-                zones[zone_idx] = single_zone;
+                zones[zone_idx].flags   = ZONE_FLAG_MANUALLY_CONFIGURABLE_DEVICE_SPECIFIC;
             }
 
+            zones[zone_idx].leds_min    = 1;
+            zones[zone_idx].leds_max    = 1;
+            zones[zone_idx].leds_count  = 1;
+
             led single_led;
 
             single_led.name             = "Single LED";
 
             leds.push_back(single_led);
 
-            led_alt_names.push_back("");
+            led_display_names.push_back("");
+
+            nlohmann::json configuration_json;
+            JsonUtils::JsonParse(configuration, configuration_json);
+
+            if(first_run)
+            {
+                /*-----------------------------------------*\
+                | Create test configuration                 |
+                \*-----------------------------------------*/
+                configuration_json["zones"][zone_idx]["schema"]["color_order"]["title"]     = "Color Order";
+                configuration_json["zones"][zone_idx]["schema"]["color_order"]["type"]      = "string";
+                configuration_json["zones"][zone_idx]["schema"]["color_order"]["enum"][0]   = "RGB";
+                configuration_json["zones"][zone_idx]["schema"]["color_order"]["enum"][1]   = "GRB";
+            }
+
+            if((zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_DEVICE_SPECIFIC) == 0)
+            {
+                configuration_json["zones"][zone_idx]["configuration"]["color_order"]       = "RGB";
+            }
+
+            configuration = configuration_json.dump();
 
             zone_idx++;
         }
@@ -404,22 +442,18 @@ void RGBController_Debug::SetupZones()
         {
             zone linear_zone;
 
-            linear_zone.name            = "Linear Zone";
-            linear_zone.type            = ZONE_TYPE_LINEAR;
-            linear_zone.leds_min        = 10;
-            linear_zone.leds_max        = 10;
-            linear_zone.leds_count      = 10;
-
             if(first_run)
             {
                 zones.push_back(linear_zone);
             }
-            else
-            {
-                zones[zone_idx] = linear_zone;
-            }
 
-            for(std::size_t led_idx = 0; led_idx < 10; led_idx++)
+            zones[zone_idx].name        = "Linear Zone";
+            zones[zone_idx].type        = ZONE_TYPE_LINEAR;
+            zones[zone_idx].leds_min    = 10;
+            zones[zone_idx].leds_max    = 10;
+            zones[zone_idx].leds_count  = 10;
+
+            for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
             {
                 led linear_led;
 
@@ -427,7 +461,7 @@ void RGBController_Debug::SetupZones()
 
                 leds.push_back(linear_led);
 
-                led_alt_names.push_back("");
+                led_display_names.push_back("");
             }
 
             zone_idx++;
@@ -441,6 +475,24 @@ void RGBController_Debug::SetupZones()
             KEYBOARD_LAYOUT layout              = KEYBOARD_LAYOUT::KEYBOARD_LAYOUT_ANSI_QWERTY;
             KEYBOARD_SIZE   size                = KEYBOARD_SIZE::KEYBOARD_SIZE_FULL;
 
+            nlohmann::json configuration_json;
+            JsonUtils::JsonParse(configuration, configuration_json);
+
+            zone keyboard_zone;
+
+            if(first_run)
+            {
+                zones.push_back(keyboard_zone);
+            }
+
+            zones[zone_idx].name                = "Keyboard Zone";
+            zones[zone_idx].type                = ZONE_TYPE_MATRIX;
+
+            if(first_run)
+            {
+                zones[zone_idx].flags           = ZONE_FLAG_MANUALLY_CONFIGURABLE_DEVICE_SPECIFIC | ZONE_FLAG_ZONE_GEOMETRY_MAY_CHANGE;
+            }
+
             if(debug_settings.contains("layout"))
             {
                 KEYBOARD_LAYOUT temp_layout = debug_settings["layout"];
@@ -451,6 +503,29 @@ void RGBController_Debug::SetupZones()
                 }
             }
 
+            if(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_DEVICE_SPECIFIC)
+            {
+                if(configuration_json.contains("zones") && (zone_idx < configuration_json["zones"].size()))
+                {
+                    if(configuration_json["zones"][zone_idx].contains("configuration"))
+                    {
+                        if(configuration_json["zones"][zone_idx]["configuration"].contains("layout"))
+                        {
+                            std::string layout_string = configuration_json["zones"][zone_idx]["configuration"]["layout"];
+
+                            for(std::size_t layout_idx = 0; layout_idx < NUM_LAYOUTS; layout_idx++)
+                            {
+                                if(layout_names[layout_idx] == layout_string)
+                                {
+                                    layout = (KEYBOARD_LAYOUT)layout_idx;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
             if(debug_settings.contains("size"))
             {
                 size = debug_settings["size"];
@@ -458,8 +533,6 @@ void RGBController_Debug::SetupZones()
 
             KeyboardLayoutManager new_kb(layout, size);
 
-            description                        += ", Layout: " + layout_names[layout] + ", Size: " + new_kb.GetName();
-
             /*---------------------------------------------*\
             | Check for custom key inserts and swaps        |
             \*---------------------------------------------*/
@@ -518,25 +591,12 @@ void RGBController_Debug::SetupZones()
                 new_kb.ChangeKeys(change);
             }
 
-            zone keyboard_zone;
+            zones[zone_idx].leds_min            = new_kb.GetKeyCount();
+            zones[zone_idx].leds_max            = new_kb.GetKeyCount();
+            zones[zone_idx].leds_count          = new_kb.GetKeyCount();
+            zones[zone_idx].matrix_map          = new_kb.GetKeyMap(KEYBOARD_MAP_FILL_TYPE_COUNT);
 
-            keyboard_zone.name                  = "Keyboard Zone";
-            keyboard_zone.type                  = ZONE_TYPE_MATRIX;
-            keyboard_zone.leds_min              = new_kb.GetKeyCount();
-            keyboard_zone.leds_max              = new_kb.GetKeyCount();
-            keyboard_zone.leds_count            = new_kb.GetKeyCount();
-            keyboard_zone.matrix_map = new_kb.GetKeyMap(KEYBOARD_MAP_FILL_TYPE_COUNT);
-
-            if(first_run)
-            {
-                zones.push_back(keyboard_zone);
-            }
-            else
-            {
-                zones[zone_idx] = keyboard_zone;
-            }
-
-            for(unsigned int led_idx = 0; led_idx < keyboard_zone.leds_count; led_idx++)
+            for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
             {
                 led keyboard_led;
 
@@ -544,9 +604,31 @@ void RGBController_Debug::SetupZones()
 
                 leds.push_back(keyboard_led);
 
-                led_alt_names.push_back(new_kb.GetKeyAltNameAt(led_idx));
+                led_display_names.push_back(new_kb.GetKeyAltNameAt(led_idx));
             }
 
+            if(first_run)
+            {
+                /*-----------------------------------------*\
+                | Create test configuration                 |
+                \*-----------------------------------------*/
+                configuration_json["zones"][zone_idx]["schema"]["layout"]["title"]      = "Layout";
+                configuration_json["zones"][zone_idx]["schema"]["layout"]["type"]       = "string";
+                configuration_json["zones"][zone_idx]["schema"]["layout"]["enum"][0]    = "Default",
+                configuration_json["zones"][zone_idx]["schema"]["layout"]["enum"][1]    = "ANSI QWERTY";
+                configuration_json["zones"][zone_idx]["schema"]["layout"]["enum"][2]    = "ISO QWERTY";
+                configuration_json["zones"][zone_idx]["schema"]["layout"]["enum"][3]    = "ISO QWERTZ";
+                configuration_json["zones"][zone_idx]["schema"]["layout"]["enum"][4]    = "ISO AZERTY";
+                configuration_json["zones"][zone_idx]["schema"]["layout"]["enum"][5]    = "JIS";
+            }
+
+            if((zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_DEVICE_SPECIFIC) == 0)
+            {
+                configuration_json["zones"][zone_idx]["configuration"]["layout"]        = "Default";
+            }
+
+            configuration = configuration_json.dump();
+
             zone_idx++;
         }
 
@@ -581,7 +663,7 @@ void RGBController_Debug::SetupZones()
 
                 leds.push_back(underglow_led);
 
-                led_alt_names.push_back("");
+                led_display_names.push_back("");
             }
 
             zone_idx++;
@@ -637,7 +719,7 @@ void RGBController_Debug::SetupZones()
 
                 leds.push_back(resizable_led);
 
-                led_alt_names.push_back("");
+                led_display_names.push_back("");
             }
 
             zone_idx++;
@@ -647,6 +729,11 @@ void RGBController_Debug::SetupZones()
     SetupColors();
 }
 
+void RGBController_Debug::DeviceConfigureDevice()
+{
+    SetupDevice();
+}
+
 void RGBController_Debug::DeviceConfigureZone(int zone_idx)
 {
     if((size_t)zone_idx < zones.size())
@@ -674,3 +761,13 @@ void RGBController_Debug::DeviceUpdateMode()
 {
 
 }
+
+void RGBController_Debug::DeviceUpdateDeviceSpecificConfiguration()
+{
+
+}
+
+void RGBController_Debug::DeviceUpdateDeviceSpecificZoneConfiguration(int /*zone*/)
+{
+    SetupZones();
+}

Controllers/DebugController/RGBController_Debug.h

@@ -23,8 +23,10 @@ public:
     RGBController_Debug(bool custom, json settings);
     ~RGBController_Debug();
 
+    void        SetupDevice();
     void        SetupZones();
 
+    void        DeviceConfigureDevice();
     void        DeviceConfigureZone(int zone_idx);
 
     void        DeviceUpdateLEDs();
@@ -33,6 +35,9 @@ public:
 
     void        DeviceUpdateMode();
 
+    void        DeviceUpdateDeviceSpecificConfiguration();
+    void        DeviceUpdateDeviceSpecificZoneConfiguration(int zone);
+
 private:
     json        debug_settings;
     bool        custom_controller;

Controllers/DygmaRaiseController/DygmaRaiseControllerDetect.cpp

@@ -21,14 +21,14 @@
 DetectedControllers DetectDygmaRaiseControllers()
 {
     DetectedControllers         detected_controllers;
-    std::vector<std::string *>  ports = find_usb_serial_port(DYGMA_RAISE_VID, DYGMA_RAISE_PID);
+    std::vector<std::string>    ports = find_usb_serial_port(DYGMA_RAISE_VID, DYGMA_RAISE_PID);
 
     for(std::size_t i = 0; i < ports.size(); i++)
     {
-        if(*ports[i] != "")
+        if(ports[i] != "")
         {
             DygmaRaiseController*     controller     = new DygmaRaiseController();
-            controller->Initialize((char *)ports[i]->c_str());
+            controller->Initialize((char *)ports[i].c_str());
 
             RGBController_DygmaRaise* rgb_controller = new RGBController_DygmaRaise(controller);
 

Controllers/E131Controller/RGBController_E131.cpp

@@ -235,8 +235,7 @@ void RGBController_E131::SetupZones()
         led_zone.leds_count     = devices[zone_idx].num_leds;
         led_zone.flags          = ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
                                 | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS
-                                | ZONE_FLAG_MANUALLY_CONFIGURABLE_COLOR_ORDER;
+                                | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
 
         zones.push_back(led_zone);
     }

Controllers/ENESMBusController/ENESMBusController.cpp

@@ -53,7 +53,7 @@ ENESMBusController::ENESMBusController(ENESMBusInterface* interface, ene_dev_id
         | If this is running with TRACE or higher loglevel  |
         | then dump the entire Feature list to log          |
         \*-------------------------------------------------*/
-        if(LogManager::get()->getLoglevel() >= LL_TRACE)
+        if(LogManager::get()->GetLogLevel() >= LL_TRACE)
         {
             LOG_TRACE("[ENE SMBus] ENE config table for 0x%02X:", dev);
             LOG_TRACE("    %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X", config_table[0],  config_table[1],  config_table[2],  config_table[3],

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -154,13 +154,13 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
     {
         int address_list_idx = -1;
 
-        IF_DRAM_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
+        IF_DRAM_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
         {
             LOG_DEBUG("[ENE SMBus DRAM] Remapping ENE SMBus RAM modules on 0x77");
 
             for(unsigned int slot = 0; slot < 8; slot++)
             {
-                int res = buses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
+                int res = buses[bus]->i2c_smbus_read_byte(0x77);
 
                 if(res < 0)
                 {
@@ -176,7 +176,7 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
                     {
                         LOG_DEBUG("[ENE SMBus DRAM] Testing address %02X to see if there is a device there", ene_ram_addresses[address_list_idx]);
 
-                        res = buses[bus]->i2c_smbus_write_quick(ene_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
+                        res = buses[bus]->i2c_smbus_read_byte(ene_ram_addresses[address_list_idx]);
                     }
                     else
                     {
@@ -220,9 +220,9 @@ DetectedControllers DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_i
     for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
         // Add ENE (ASUS Aura) motherboard controllers
-        IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
+        IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
         {
-            if(buses[bus]->pci_subsystem_vendor == ASUS_SUB_VEN || buses[bus]->pci_subsystem_vendor == 0 || buses[bus]->pci_subsystem_vendor == 0xFFFF)
+            if(buses[bus]->info.pci_subsystem_vendor == ASUS_SUB_VEN || buses[bus]->info.pci_subsystem_vendor == 0 || buses[bus]->info.pci_subsystem_vendor == 0xFFFF)
             {
                 for(unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
                 {
@@ -302,6 +302,7 @@ REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 3060 Ti Gaming OC",
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 3060 Ti OC",                      DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060TI_O8G_OC,               0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 3060 Ti OC",                            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060TI_O8G_OC_V2,                  0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 3060 Ti V2 OC",                   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 GeForce RTX 3060 Ti V2 OC",                   DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060TI_O8G_V2_2_GAMING,      0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 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 GeForce RTX 3070 Gaming OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_GAMING,             0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 3070 White OC",                   DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_WHITE,              0x67);
@@ -409,8 +410,12 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 4090 Gaming White",
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 4090 Gaming White OC",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4090_O24G_GAMING_WHITE,      0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 4090 Gaming White OC",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4090_O24G_GAMING_WHITE_2,    0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG MATRIX PLATINUM GeForce RTX 4090",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_MATRIX_PLATINUM_RTX_4090_24G,          0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5070 Gaming",                           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_5070_O12G_GAMING,                  0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5060 Gaming OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5060_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_5060_O8G_GAMING,                   0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5060 Ti Gaming OC",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5060TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_5060TI_O16G_GAMING,                0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5070 Gaming OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_5070_O12G_GAMING,                  0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5070 Ti Gaming OC",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_5070TI_O16G_GAMING,                0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5070 Ti Gaming BTF White OC",           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_5070TI_O16G_GAMING_BTF_WHITE,      0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5070 Ti Gaming White OC",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_5070TI_O16G_GAMING_WHITE,          0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 5070 Ti Gaming OC",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_5070TI_O16G_GAMING_OC,       0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5080 Gaming OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_5080_O16G_GAMING,                  0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5090 Gaming OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_5090_O32G_GAMING,                  0x67);
@@ -418,7 +423,9 @@ REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5090 Gaming",
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5080 OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5080_O16G_GAMING,           0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5080 OC WHITE",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5080_O16G_GAMING_WHITE,     0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5080",                           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5080_16G_GAMING,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5080 WHITE",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5080_16G_GAMING_WHITE,      0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090 OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING,           0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090",                           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING_2,         0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090 OC BTF",                    DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING_BTF,       0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090 OC WHITE",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING_WHITE,     0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL LC GeForce RTX 5090 OC",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_LC_RTX_5090_O32G_GAMING,        0x67);
@@ -448,6 +455,7 @@ REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 7700 XT Gaming OC",
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 7800 XT Gaming OC",                       DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI32_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_7800XT_O16G_GAMING,                 0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 7800 XT Gaming OC",                       DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI32_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_7800XT_O16G_GAMING_0606,            0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 7800 XT Gaming White OC",                 DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI32_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_7800XT_O16G_WHITE_GAMING,           0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 7900 GRE Gaming OC",                      DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI31_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_7900GRE_O16G_GAMING,                0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 7900 XT Gaming OC",                       DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI31_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_7900XT_020G_GAMING,                 0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 7900 XTX Gaming OC",                      DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI31_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_7900XTX_O24G_GAMING,                0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 9070 Gaming OC",                          DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI48_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_9070_016G_GAMING,                   0x67);

Controllers/ENESMBusController/ENESMBusInterface/ENESMBusInterface_i2c_smbus.cpp

@@ -28,7 +28,7 @@ ene_interface_type ENESMBusInterface_i2c_smbus::GetInterfaceType()
 
 std::string ENESMBusInterface_i2c_smbus::GetLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     return("I2C: " + return_string);
 }
 
@@ -61,5 +61,12 @@ void ENESMBusInterface_i2c_smbus::ENERegisterWriteBlock(ene_dev_id dev, ene_regi
     bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
 
     //Write ENE block data
-    bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
+    if(bus->i2c_smbus_write_block_data(dev, 0x03, sz, data) == -1)
+    {
+        //Fall back to individual byte operations if the block operation fails
+        for(unsigned int block_byte = 0; block_byte < sz; block_byte++)
+        {
+            bus->i2c_smbus_write_byte_data(dev, 0x01, data[block_byte]);
+        }
+    }
 }

Controllers/EVGAAmpereGPUController/EVGAAmpereGPUControllerDetect.cpp

@@ -20,7 +20,7 @@ DetectedControllers DetectEVGAAmpereGPUControllers(i2c_smbus_interface* bus, uin
 {
     DetectedControllers detected_controllers;
 
-    if(bus->port_id == 1)
+    if(bus->info.port_id == 1)
     {
         EVGAGPUv3Controller*     controller;
         RGBController_EVGAGPUv3* rgb_controller;

Controllers/EVGAAmpereGPUController/EVGAGPUv3Controller.cpp

@@ -26,7 +26,7 @@ EVGAGPUv3Controller::~EVGAGPUv3Controller()
 
 std::string EVGAGPUv3Controller::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     char        addr[5];
 
     snprintf(addr, 5, "0x%02X", dev);

Controllers/EVGAGP102GPUController/EVGAGP102Controller.cpp

@@ -25,7 +25,7 @@ EVGAGP102Controller::~EVGAGP102Controller()
 
 std::string EVGAGP102Controller::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", zi.dev_addr);
     return_string.append(", address ");

Controllers/EVGAGP102GPUController/EVGAGP102GPUControllerDetect.cpp

@@ -21,7 +21,7 @@ DetectedControllers DetectEVGAGP102GPUControllers(i2c_smbus_interface* bus, uint
 {
     DetectedControllers detected_controllers;
 
-    if(bus->port_id == 1)
+    if(bus->info.port_id == 1)
     {
         std::vector<EVGAGP102Controller*>   controllers;
 

Controllers/EVGAPascalGPUController/EVGAGPUv1Controller.cpp

@@ -25,7 +25,7 @@ EVGAGPUv1Controller::~EVGAGPUv1Controller()
 
 std::string EVGAGPUv1Controller::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");

Controllers/EVGAPascalGPUController/EVGAPascalGPUControllerDetect.cpp

@@ -20,7 +20,7 @@ DetectedControllers DetectEVGAPascalGPUControllers(i2c_smbus_interface* bus, uin
 {
     DetectedControllers detected_controllers;
 
-    if(bus->port_id == 1)
+    if(bus->info.port_id == 1)
     {
         EVGAGPUv1Controller*     controller     = new EVGAGPUv1Controller(bus, address, name);
         RGBController_EVGAGPUv1* rgb_controller = new RGBController_EVGAGPUv1(controller);

Controllers/EVGASMBusController/EVGAACX30SMBusController.cpp

@@ -32,7 +32,7 @@ EVGAACX30SMBusController::~EVGAACX30SMBusController()
 
 std::string EVGAACX30SMBusController::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");

Controllers/EVGASMBusController/EVGASMBusControllerDetect.cpp

@@ -46,9 +46,9 @@ DetectedControllers DetectAcx30SMBusControllers(std::vector<i2c_smbus_interface
 
     for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
-        IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
+        IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
         {
-            if(buses[bus]->pci_subsystem_vendor == EVGA_SUB_VEN)
+            if(buses[bus]->info.pci_subsystem_vendor == EVGA_SUB_VEN)
             {
                 LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, EVGA_DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
                 // Check for ACX 30 controller at 0x28

Controllers/EVGATuringGPUController/EVGAGPUv2Controller.cpp

@@ -25,7 +25,7 @@ EVGAGPUv2Controller::~EVGAGPUv2Controller()
 
 std::string EVGAGPUv2Controller::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
     char        addr[5];
 
     snprintf(addr, 5, "0x%02X", dev);

Controllers/EVGATuringGPUController/EVGATuringGPUControllerDetect.cpp

@@ -19,7 +19,7 @@ DetectedControllers DetectEVGATuringGPUControllers(i2c_smbus_interface* bus, uin
 {
     DetectedControllers detected_controllers;
 
-    if(bus->port_id == 1)
+    if(bus->info.port_id == 1)
     {
         EVGAGPUv2Controller*     controller     = new EVGAGPUv2Controller(bus, address, name);
         RGBController_EVGAGPUv2* rgb_controller = new RGBController_EVGAGPUv2(controller);

Controllers/EVGAUSBController/EVGAKeyboardController/EVGAKeyboardControllerDetect.cpp

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------*\
+| EVGAKeyboardControllerDetect.cpp                          |
+|                                                           |
+|   Detector for EVGA keyboard devices                      |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "DetectionManager.h"
+#include "RGBController_EVGAKeyboard.h"
+
+/*---------------------------------------------------------*\
+| EVGA USB vendor ID                                        |
+\*---------------------------------------------------------*/
+#define EVGA_USB_VID                                0x3842
+
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+\*---------------------------------------------------------*/
+#define Z15_ISO_PID                                 0x260E
+#define Z15_ANSI_PID                                0x2608
+#define Z20_ANSI_PID                                0x260A
+#define Z20_UK_PID                                  0x2610
+
+DetectedControllers DetectEVGAKeyboardControllers(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        EVGAKeyboardController*     controller      = new EVGAKeyboardController(dev, info->path, info->product_id, name);
+        RGBController_EVGAKeyboard* rgb_controller  = new RGBController_EVGAKeyboard(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_IPU("EVGA Z15 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z15_ISO_PID,                1,  0x08,   0x4B);
+REGISTER_HID_DETECTOR_IPU("EVGA Z15 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z15_ANSI_PID,               1,  0x08,   0x4B);
+REGISTER_HID_DETECTOR_IPU("EVGA Z20 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z20_ANSI_PID,               1,  0x08,   0x4B);
+REGISTER_HID_DETECTOR_IPU("EVGA Z20 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z20_UK_PID,                 1,  0x08,   0x4B);
+

Controllers/EVGAUSBController/EVGAMouseController/EVGAMouseControllerDetect.cpp

@@ -1,7 +1,7 @@
 /*---------------------------------------------------------*\
-| EVGAUSBControllerDetect.cpp                               |
+| EVGAMouseControllerDetect.cpp                             |
 |                                                           |
-|   Detector for EVGA USB devices                           |
+|   Detector for EVGA mouse devices                         |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -9,45 +9,18 @@
 
 #include <hidapi.h>
 #include "DetectionManager.h"
-#include "RGBController_EVGAKeyboard.h"
 #include "RGBController_EVGAMouse.h"
 
 /*---------------------------------------------------------*\
 | EVGA USB vendor ID                                        |
 \*---------------------------------------------------------*/
-#define EVGA_USB_VID                            0x3842
-
-/*---------------------------------------------------------*\
-| Keyboard product IDs                                      |
-\*---------------------------------------------------------*/
-#define Z15_ISO_PID                             0x260E
-#define Z15_ANSI_PID                            0x2608
-#define Z20_ANSI_PID                            0x260A
-#define Z20_UK_PID                              0x2610
+#define EVGA_USB_VID                                0x3842
 
 /*---------------------------------------------------------*\
 | Mouse product IDs                                         |
 \*---------------------------------------------------------*/
-#define X20_WIRED_PID                           0x2420
-#define X20_WIRELESS_ADAPTER_PID                0x2402
-
-DetectedControllers DetectEVGAKeyboardControllers(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        EVGAKeyboardController*     controller      = new EVGAKeyboardController(dev, info->path, info->product_id, name);
-        RGBController_EVGAKeyboard* rgb_controller  = new RGBController_EVGAKeyboard(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
+#define X20_WIRED_PID                               0x2420
+#define X20_WIRELESS_ADAPTER_PID                    0x2402
 
 DetectedControllers DetectEVGAMouse(hid_device_info* info, const std::string &name, int connection_type)
 {
@@ -77,10 +50,5 @@ DetectedControllers DetectWirelessEVGAMouse(hid_device_info* info, const std::st
     return(DetectEVGAMouse(info, name, EVGA_PERIPHERAL_CONNECTION_TYPE_WIRELESS));
 }
 
-REGISTER_HID_DETECTOR_IPU("EVGA Z15 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z15_ISO_PID,                1,  0x08,   0x4B);
-REGISTER_HID_DETECTOR_IPU("EVGA Z15 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z15_ANSI_PID,               1,  0x08,   0x4B);
-REGISTER_HID_DETECTOR_IPU("EVGA Z20 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z20_ANSI_PID,               1,  0x08,   0x4B);
-REGISTER_HID_DETECTOR_IPU("EVGA Z20 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z20_UK_PID,                 1,  0x08,   0x4B);
-
 REGISTER_HID_DETECTOR_IPU("EVGA X20 Gaming Mouse",  DetectWiredEVGAMouse,           EVGA_USB_VID,   X20_WIRED_PID,              2,  0xFFFF, 0);
 REGISTER_HID_DETECTOR_IPU("EVGA X20 USB Receiver",  DetectWirelessEVGAMouse,        EVGA_USB_VID,   X20_WIRELESS_ADAPTER_PID,   2,  0xFFFF, 0);

Controllers/EVisionKeyboardController/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------*\
+| EVisionKeyboardControllerDetect.cpp                       |
+|                                                           |
+|   Detector for EVision/Huafenda keyboards                 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "DetectionManager.h"
+#include "EVisionKeyboardController.h"
+#include "RGBController_EVisionKeyboard.h"
+#include "ResourceManager.h"
+#include "SettingsManager.h"
+
+/*---------------------------------------------------------*\
+| EVision vendor ID                                         |
+|   NOTE: EVision (and Huafenda) use rebranded Sonix MCUs   |
+|   Some EVision/Huafenda keyboards use the Sonix VID while |
+|   others use EVision's VID                                |
+\*---------------------------------------------------------*/
+#define SONIX_VID                                   0x0C45
+#define EVISION_VID                                 0x320F
+
+/*---------------------------------------------------------*\
+| EVision Usage Page                                        |
+\*---------------------------------------------------------*/
+#define EVISION_KEYBOARD_USAGE_PAGE                 0xFF1C
+
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+\*---------------------------------------------------------*/
+#define EVISION_SONIX_5004_PID                      0x5004
+#define EVISION_SONIX_5104_PID                      0x5104
+#define EVISION_SONIX_5204_PID                      0x5204
+#define EVISION_SONIX_652F_PID                      0x652F
+#define EVISION_SONIX_7672_PID                      0x7672
+#define EVISION_SONIX_7698_PID                      0x7698
+#define EVISION_SONIX_8520_PID                      0x8520
+#define EVISION_5000_PID                            0x5000
+#define EVISION_502A_PID                            0x502A
+#define EVISION_505B_PID                            0x505B
+#define EVISION_5064_PID                            0x5064
+#define EVISION_5078_PID                            0x5078
+#define EVISION_5084_PID                            0x5084
+
+DetectedControllers DetectEVisionKeyboards(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        EVisionKeyboardController*     controller     = new EVisionKeyboardController(dev, info->path, name);
+        RGBController_EVisionKeyboard* rgb_controller = new RGBController_EVisionKeyboard(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+/*---------------------------------------------------------*\
+| Keyboards                                                 |
+\*---------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5004",  DetectEVisionKeyboards, SONIX_VID,      EVISION_SONIX_5004_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5104",  DetectEVisionKeyboards, SONIX_VID,      EVISION_SONIX_5104_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5204",  DetectEVisionKeyboards, SONIX_VID,      EVISION_SONIX_5204_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:652F",  DetectEVisionKeyboards, SONIX_VID,      EVISION_SONIX_652F_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:7672",  DetectEVisionKeyboards, SONIX_VID,      EVISION_SONIX_7672_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:7698",  DetectEVisionKeyboards, SONIX_VID,      EVISION_SONIX_7698_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:8520",  DetectEVisionKeyboards, SONIX_VID,      EVISION_SONIX_8520_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5000",  DetectEVisionKeyboards, EVISION_VID,    EVISION_5000_PID,       1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:502A",  DetectEVisionKeyboards, EVISION_VID,    EVISION_502A_PID,       1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:505B",  DetectEVisionKeyboards, EVISION_VID,    EVISION_505B_PID,       1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5078",  DetectEVisionKeyboards, EVISION_VID,    EVISION_5078_PID,       1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5064",  DetectEVisionKeyboards, EVISION_VID,    EVISION_5064_PID,       1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5084",  DetectEVisionKeyboards, EVISION_VID,    EVISION_5084_PID,       1, EVISION_KEYBOARD_USAGE_PAGE);

Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp

@@ -1,129 +0,0 @@
-/*---------------------------------------------------------*\
-| EVisionKeyboardControllerDetect.cpp                       |
-|                                                           |
-|   Detector for EVision keyboards                          |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
-#include "DetectionManager.h"
-#include "EVisionKeyboardController.h"
-#include "EVisionV2KeyboardController.h"
-#include "RGBController_EVisionKeyboard.h"
-#include "RGBController_EVisionV2Keyboard.h"
-#include "ResourceManager.h"
-#include "SettingsManager.h"
-
-/*---------------------------------------------------------*\
-| Keyboard product IDs                                      |
-\*---------------------------------------------------------*/
-#define EVISION_KEYBOARD_VID        0x0C45
-#define EVISION_KEYBOARD2_VID       0x320F
-#define EVISION_KEYBOARD3_VID       0x3299
-#define EVISION_KEYBOARD_USAGE_PAGE 0xFF1C
-#define ENDORFY_OMNIS_PID           0x0012
-#define DEXP_BLAZE_PID              0x5084
-#define GLORIOUS_GMMK_TKL_PID       0x5064
-#define REDRAGON_K550_PID           0x5204
-#define MARS_GAMING_MKMINI_PID      0x5078
-#define SKILLKORP_K5_PID            0x505B
-#define REDRAGON_K552_PID           0x5104
-#define REDRAGON_K552_V2_PID        0x5000
-#define REDRAGON_K556_PID           0x5004
-#define TECWARE_PHANTOM_ELITE_PID   0x652F
-#define WARRIOR_KANE_TC235          0x8520
-#define WOMIER_K87_PID              0x502A
-#define WOMIER_K66_PID              0x7698
-#define BYGG_CSB_ICL01_PID          0x5041
-#define GAMEPOWER_OGRE_RGB_PID      0x7672
-
-DetectedControllers DetectEVisionKeyboards(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        EVisionKeyboardController*     controller     = new EVisionKeyboardController(dev, info->path, name);
-        RGBController_EVisionKeyboard* rgb_controller = new RGBController_EVisionKeyboard(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
-
-DetectedControllers DetectEVisionV2Keyboards(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    json                settings    = ResourceManager::get()->GetSettingsManager()->GetSettings("EVision2Settings");
-    hid_device*         dev         = hid_open_path(info->path);
-
-    if(dev)
-    {
-        EVisionV2KeyboardController*     controller     = new EVisionV2KeyboardController(dev, info->path, EVISION_V2_KEYBOARD_LAYOUT, name);
-        RGBController_EVisionV2Keyboard* rgb_controller = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_KEYBOARD);
-
-        detected_controllers.push_back(rgb_controller);
-
-        if(!settings.contains("AdditionalZones") || settings["AdditionalZones"] == true)
-        {
-            rgb_controller                             = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_LOGO);
-
-            detected_controllers.push_back(rgb_controller);
-
-            rgb_controller                             = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_EDGE);
-
-            detected_controllers.push_back(rgb_controller);
-        }
-    }
-
-    return(detected_controllers);
-}
-
-DetectedControllers DetectEndorfyKeyboards(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    json                settings    = ResourceManager::get()->GetSettingsManager()->GetSettings("EndorfySettings");
-    hid_device*         dev         = hid_open_path(info->path);
-
-    if(dev)
-    {
-        EVisionV2KeyboardController*     controller     = new EVisionV2KeyboardController(dev, info->path, ENDORFY_KEYBOARD_LAYOUT, name);
-        RGBController_EVisionV2Keyboard* rgb_controller = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_KEYBOARD);
-
-        detected_controllers.push_back(rgb_controller);
-
-        if(!settings.contains("AdditionalZones") || settings["AdditionalZones"] == true)
-        {
-            rgb_controller                              = new RGBController_EVisionV2Keyboard(controller, ENDORFY_KEYBOARD_PART_EDGE);
-
-            detected_controllers.push_back(rgb_controller);
-        }
-    }
-
-    return(detected_controllers);
-}
-
-/*---------------------------------------------------------------------------------------------------------------------------------------------*\
-| Keyboards                                                                                                                                     |
-\*---------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5078",      DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, MARS_GAMING_MKMINI_PID,    1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5204",      DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  REDRAGON_K550_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5104",      DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  REDRAGON_K552_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5000",      DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, REDRAGON_K552_V2_PID,      1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5004",      DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  REDRAGON_K556_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:652F",      DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  TECWARE_PHANTOM_ELITE_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:8520",      DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  WARRIOR_KANE_TC235,        1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:502A",      DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, WOMIER_K87_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:7698",      DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  WOMIER_K66_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5064",      DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, GLORIOUS_GMMK_TKL_PID,     1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5084",      DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, DEXP_BLAZE_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:505B",      DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, SKILLKORP_K5_PID,          1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Endorfy Omnis",                   DetectEndorfyKeyboards,   EVISION_KEYBOARD3_VID, ENDORFY_OMNIS_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("CSB/ICL01 Keyboard",              DetectEVisionV2Keyboards, EVISION_KEYBOARD2_VID, BYGG_CSB_ICL01_PID,        1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Gamepower Ogre RGB 0C45:7672",    DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  GAMEPOWER_OGRE_RGB_PID,    1, EVISION_KEYBOARD_USAGE_PAGE);

Controllers/EVisionKeyboardController/EVisionV2KeyboardController/EVisionV2KeyboardControllerDetect.cpp

@@ -0,0 +1,90 @@
+/*---------------------------------------------------------*\
+| EVisionKeyboardV2ControllerDetect.cpp                     |
+|                                                           |
+|   Detector for EVision V2 keyboards                       |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "DetectionManager.h"
+#include "EVisionV2KeyboardController.h"
+#include "RGBController_EVisionV2Keyboard.h"
+#include "ResourceManager.h"
+#include "SettingsManager.h"
+
+/*---------------------------------------------------------*\
+| EVision vendor ID                                         |
+\*---------------------------------------------------------*/
+#define EVISION_VID                                 0x320F
+#define SPCGEAR_VID                                 0x3299
+
+/*---------------------------------------------------------*\
+| EVision Usage Page                                        |
+\*---------------------------------------------------------*/
+#define EVISION_KEYBOARD_USAGE_PAGE                 0xFF1C
+
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+\*---------------------------------------------------------*/
+#define ENDORFY_OMNIS_PID                           0x0012
+#define BYGG_CSB_ICL01_PID                          0x5041
+
+DetectedControllers DetectEVisionV2Keyboards(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    json                settings    = ResourceManager::get()->GetSettingsManager()->GetSettings("EVision2Settings");
+    hid_device*         dev         = hid_open_path(info->path);
+
+    if(dev)
+    {
+        EVisionV2KeyboardController*     controller     = new EVisionV2KeyboardController(dev, info->path, EVISION_V2_KEYBOARD_LAYOUT, name);
+        RGBController_EVisionV2Keyboard* rgb_controller = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_KEYBOARD);
+
+        detected_controllers.push_back(rgb_controller);
+
+        if(!settings.contains("AdditionalZones") || settings["AdditionalZones"] == true)
+        {
+            rgb_controller                             = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_LOGO);
+
+            detected_controllers.push_back(rgb_controller);
+
+            rgb_controller                             = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_EDGE);
+
+            detected_controllers.push_back(rgb_controller);
+        }
+    }
+
+    return(detected_controllers);
+}
+
+DetectedControllers DetectEndorfyKeyboards(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    json                settings    = ResourceManager::get()->GetSettingsManager()->GetSettings("EndorfySettings");
+    hid_device*         dev         = hid_open_path(info->path);
+
+    if(dev)
+    {
+        EVisionV2KeyboardController*     controller     = new EVisionV2KeyboardController(dev, info->path, ENDORFY_KEYBOARD_LAYOUT, name);
+        RGBController_EVisionV2Keyboard* rgb_controller = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_KEYBOARD);
+
+        detected_controllers.push_back(rgb_controller);
+
+        if(!settings.contains("AdditionalZones") || settings["AdditionalZones"] == true)
+        {
+            rgb_controller                              = new RGBController_EVisionV2Keyboard(controller, ENDORFY_KEYBOARD_PART_EDGE);
+
+            detected_controllers.push_back(rgb_controller);
+        }
+    }
+
+    return(detected_controllers);
+}
+
+/*---------------------------------------------------------*\
+| Keyboards                                                 |
+\*---------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5041",  DetectEVisionV2Keyboards,   EVISION_VID,    BYGG_CSB_ICL01_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Endorfy Omnis",               DetectEndorfyKeyboards,     SPCGEAR_VID,    ENDORFY_OMNIS_PID,  1, EVISION_KEYBOARD_USAGE_PAGE);