Implement size verification on RGBController set description functions

* Only create server instance if server is actually needed
    * Pass initial server host and port through ResourceManager
    * Allow setting default server host and port in Server settings

.gitlab/CODEOWNERS

@@ -22,13 +22,12 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/BlinkyTapeController/
 /Controllers/CoolerMasterController/                        @Dr_No
 /Controllers/CorsairCommanderCoreController/
-/Controllers/CorsairDominatorPlatinumController/
+/Controllers/CorsairDRAMController/
 /Controllers/CorsairHydroController/
 /Controllers/CorsairHydroPlatinumController/
 /Controllers/CorsairLightingNodeController/
 /Controllers/CorsairPeripheralController/
 /Controllers/CorsairVengeanceController/
-/Controllers/CorsairVengeanceProController/
 /Controllers/CorsairWirelessController/
 /Controllers/CreativeController/
 /Controllers/CrucialController/

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -228,7 +228,8 @@ void RGBController_PolychromeUSB::SetupZones()
                 zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
             }
 
             if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/ASRockSMBusController/ASRockSMBusControllerDetect.cpp

@@ -85,31 +85,31 @@ uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
     }
 }
 
-DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
+DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& buses)
 {
     DetectedControllers detected_controllers;
 
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
-        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
         {
-            if(busses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
+            if(buses[bus]->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
-                if(TestForPolychromeSMBusController(busses[bus], SMBUS_ADDRESS))
+                if(TestForPolychromeSMBusController(buses[bus], SMBUS_ADDRESS))
                 {
                     LOG_DEBUG("[%s] Detected a device at address 0x%02X, testing for a known controller",  ASROCK_DETECTOR_NAME, SMBUS_ADDRESS);
 
                     u16_to_u8 version;
-                    version.u16 = GetFirmwareVersion(busses[bus], SMBUS_ADDRESS);
+                    version.u16 = GetFirmwareVersion(buses[bus], SMBUS_ADDRESS);
 
                     switch(version.msb)
                     {
                         case ASROCK_TYPE_ASRLED:
                             {
                                 LOG_DEBUG("[%s] Found a ASR RGB LED Controller", ASROCK_DETECTOR_NAME);
-                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(busses[bus], SMBUS_ADDRESS);
+                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(buses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockASRRGBSMBus* rgb_controller = new RGBController_ASRockASRRGBSMBus(controller);
                                 detected_controllers.push_back(rgb_controller);
@@ -119,7 +119,7 @@ DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface
                             case ASROCK_TYPE_POLYCHROME_V1:
                             {
                                 LOG_DEBUG("[%s] Found a Polychrome v1 Controller", ASROCK_DETECTOR_NAME);
-                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(busses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(buses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockPolychromeV1SMBus* rgb_controller = new RGBController_ASRockPolychromeV1SMBus(controller);
                                 detected_controllers.push_back(rgb_controller);
@@ -129,7 +129,7 @@ DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface
                             case ASROCK_TYPE_POLYCHROME_V2:
                             {
                                 LOG_DEBUG("[%s] Found a Polychrome v2 Controller", ASROCK_DETECTOR_NAME);
-                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(busses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(buses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockPolychromeV2SMBus* rgb_controller = new RGBController_ASRockPolychromeV2SMBus(controller);
                                 detected_controllers.push_back(rgb_controller);

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -170,7 +170,8 @@ void RGBController_AuraUSB::SetupZones()
                 zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
             }
 
             if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/BlinkyTapeController/RGBController_BlinkyTape.cpp

@@ -79,7 +79,8 @@ void RGBController_BlinkyTape::SetupZones()
         zones[0].flags                  = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
     }
 
     if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -76,3 +76,6 @@ REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           Detec
 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 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 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);

Controllers/CoolerMasterController/CMARGBController/RGBController_CMARGBController.cpp

@@ -406,7 +406,8 @@ void RGBController_CMARGBController::SetupZones()
             zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/CoolerMasterController/CMSmallARGBController/RGBController_CMSmallARGBController.cpp

@@ -217,7 +217,8 @@ void RGBController_CMSmallARGBController::SetupZones()
             zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.cpp

@@ -111,7 +111,8 @@ void RGBController_CorsairCommanderCore::SetupZones()
             zones[0].flags                          = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
@@ -164,7 +165,8 @@ void RGBController_CorsairCommanderCore::SetupZones()
             zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/CorsairDRAMController/CorsairDRAMController.cpp

@@ -0,0 +1,422 @@
+/*---------------------------------------------------------*\
+| CorsairDRAMController.cpp                                 |
+|                                                           |
+|   Driver for Corsair DRAM RGB controllers                 |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
+|   Erik Gilling (konkers)                      25 Sep 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "CRC.h"
+#include "CorsairDRAMController.h"
+#include "LogManager.h"
+
+#define CORSAIR_DRAM_NAME "Corsair DRAM"
+
+using namespace std::chrono_literals;
+
+CorsairDRAMController::CorsairDRAMController(i2c_smbus_interface *bus, corsair_dev_id dev)
+{
+    /*-----------------------------------------------------*\
+    | Initialize class variables                            |
+    \*-----------------------------------------------------*/
+    this->bus           = bus;
+    this->dev           = dev;
+    device_index        = 0;
+    pid                 = 0;
+    vid                 = 0;
+    protocol_version    = 0;
+
+    /*-----------------------------------------------------*\
+    | Read device information                               |
+    \*-----------------------------------------------------*/
+    ReadDeviceInfo();
+}
+
+CorsairDRAMController::~CorsairDRAMController()
+{
+}
+
+unsigned int CorsairDRAMController::GetLEDCount()
+{
+    return(corsair_dram_device_list[device_index]->led_count);
+}
+
+unsigned char CorsairDRAMController::GetProtocolVersion()
+{
+    return(protocol_version);
+}
+
+std::string CorsairDRAMController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+std::string CorsairDRAMController::GetDeviceName()
+{
+    return(corsair_dram_device_list[device_index]->name);
+}
+
+std::string CorsairDRAMController::GetDeviceVersion()
+{
+    return(firmware_version);
+}
+
+void CorsairDRAMController::SetColorsPerLED(RGBColor* colors)
+{
+    /*-----------------------------------------------------*\
+    | Get LED count from device list                        |
+    \*-----------------------------------------------------*/
+    unsigned int        led_count           = corsair_dram_device_list[device_index]->led_count;
+
+    if(direct_mode)
+    {
+        /*-------------------------------------------------*\
+        | Sanity check - Direct mode can only be used on    |
+        | protocol 4+                                       |
+        \*-------------------------------------------------*/
+        if(protocol_version < 4)
+        {
+            LOG_ERROR("[%s] Protocol version %d tried to use direct mode, ignoring", CORSAIR_DRAM_NAME, protocol_version);
+            return;
+        }
+
+        /*-------------------------------------------------*\
+        | Packet format:                                    |
+        |   Size n is (LED count * 3) + 2                   |
+        |   0:          Command byte (0x0A or 0x0C)         |
+        |   1 to (n-2): LED color data in R/G/B order       |
+        |   (n-1):      CRC8 of bytes 0 to (n-2)            |
+        \*-------------------------------------------------*/
+        unsigned int    direct_packet_size  = (led_count * 3) + 2;
+        unsigned char*  direct_packet       = new unsigned char[direct_packet_size];
+
+        /*-------------------------------------------------*\
+        | First byte in packet is LED count                 |
+        \*-------------------------------------------------*/
+        direct_packet[0]                    = led_count;
+
+        /*-------------------------------------------------*\
+        | Fill in LED data                                  |
+        \*-------------------------------------------------*/
+        for(unsigned int led_idx = 0; led_idx < led_count; led_idx++)
+        {
+            unsigned int color_index        = led_idx;
+            unsigned int offset             = (led_idx * 3) + 1;
+
+            if(corsair_dram_device_list[device_index]->reverse)
+            {
+                color_index                 = (led_count -1) - led_idx;
+            }
+
+            direct_packet[offset + 0]       = RGBGetRValue(colors[color_index]);
+            direct_packet[offset + 1]       = RGBGetGValue(colors[color_index]);
+            direct_packet[offset + 2]       = RGBGetBValue(colors[color_index]);
+        }
+
+        /*-------------------------------------------------*\
+        | Last byte in packet is CRC of all data up to it   |
+        \*-------------------------------------------------*/
+        direct_packet[direct_packet_size - 1] = CRCPP::CRC::Calculate(direct_packet, (direct_packet_size - 1), CRCPP::CRC::CRC_8());
+
+        /*-------------------------------------------------*\
+        | Write using block writes, if packet exceeds 32    |
+        | 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);
+
+        if(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);
+        }
+
+        /*-------------------------------------------------*\
+        | Remember to delete the data buffer                |
+        \*-------------------------------------------------*/
+        delete[] direct_packet;
+    }
+    else
+    {
+        /*-------------------------------------------------*\
+        | Local variables                                   |
+        \*-------------------------------------------------*/
+        unsigned char   device_crc;
+        unsigned char   calc_crc;
+
+        /*-------------------------------------------------*\
+        | Packet format:                                    |
+        |   Size n is (LED count * 4)                       |
+        |   Format is 0xRR, 0xGG, 0xBB, 0xFF for each LED   |
+        \*-------------------------------------------------*/
+        unsigned int    color_data_size     = (led_count * 4);
+        unsigned char*  color_data_packet   = new unsigned char[color_data_size];
+
+        for(unsigned int led_idx = 0; led_idx < led_count; led_idx++)
+        {
+            unsigned int color_index        = led_idx;
+
+            if(corsair_dram_device_list[device_index]->reverse)
+            {
+                color_index                 = (led_count -1) - led_idx;
+            }
+
+            color_data_packet[(led_idx * 4) + 0]  = RGBGetRValue(colors[color_index]);
+            color_data_packet[(led_idx * 4) + 1]  = RGBGetGValue(colors[color_index]);
+            color_data_packet[(led_idx * 4) + 2]  = RGBGetBValue(colors[color_index]);
+            color_data_packet[(led_idx * 4) + 3]  = 0xFF;
+        }
+
+        /*-------------------------------------------------*\
+        | Write LED color data packet                       |
+        \*-------------------------------------------------*/
+        bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_RESET_BUFFER, 0x00);
+        bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_BINARY_START, 0x00);
+
+        for(unsigned int i = 0; i < color_data_size; i++)
+        {
+            bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_SET_BINARY_DATA, color_data_packet[i]);
+        }
+
+        /*-------------------------------------------------*\
+        | Calculate CRC and read CRC reported by device     |
+        \*-------------------------------------------------*/
+        calc_crc    = CRCPP::CRC::Calculate(color_data_packet, color_data_size, CRCPP::CRC::CRC_8());
+        device_crc  = bus->i2c_smbus_read_byte_data(dev, CORSAIR_DRAM_REG_GET_CHECKSUM);
+
+        /*-------------------------------------------------*\
+        | Write effect configuration only if CRCs match     |
+        \*-------------------------------------------------*/
+        if(calc_crc == device_crc)
+        {
+            bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_WRITE_CONFIGURATION, CORSAIR_DRAM_ID_COLOR_DATA);
+            WaitReady();
+        }
+
+        /*-------------------------------------------------*\
+        | Remember to delete the data buffer                |
+        \*-------------------------------------------------*/
+        delete[] color_data_packet;
+    }
+}
+
+void CorsairDRAMController::SetDirect(bool direct)
+{
+    direct_mode = direct;
+}
+
+void CorsairDRAMController::SetEffect
+    (
+    unsigned char mode,
+    unsigned char speed,
+    unsigned char direction,
+    bool          random,
+    unsigned char brightness,
+    unsigned char red1,
+    unsigned char grn1,
+    unsigned char blu1,
+    unsigned char red2,
+    unsigned char grn2,
+    unsigned char blu2
+    )
+{
+    /*-----------------------------------------------------*\
+    | Local variables                                       |
+    \*-----------------------------------------------------*/
+    unsigned char   effect_data[20];
+    unsigned char   device_crc;
+    unsigned char   calc_crc;
+    unsigned char   random_byte;
+
+    /*-----------------------------------------------------*\
+    | If mode is direct (which is a dummy value not         |
+    | understood by the hardware), return.  Direct mode is  |
+    | not set in the effect configuration.                  |
+    \*-----------------------------------------------------*/
+    direct_mode = (mode == CORSAIR_DRAM_MODE_DIRECT);
+
+    if(direct_mode)
+    {
+        return;
+    }
+
+    /*-----------------------------------------------------*\
+    | Determine random byte                                 |
+    \*-----------------------------------------------------*/
+    if(random)
+    {
+        random_byte = CORSAIR_DRAM_EFFECT_RANDOM_COLORS;
+    }
+    else
+    {
+        random_byte = CORSAIR_DRAM_EFFECT_CUSTOM_COLORS;
+    }
+
+    /*-----------------------------------------------------*\
+    | Fill in effect packet                                 |
+    \*-----------------------------------------------------*/
+    effect_data[0]  = mode;         // Mode
+    effect_data[1]  = speed;        // Speed
+    effect_data[2]  = random_byte;  // Custom color
+    effect_data[3]  = direction;    // Direction
+    effect_data[4]  = red1;         // Custom color 1 red
+    effect_data[5]  = grn1;         // Custom color 1 green
+    effect_data[6]  = blu1;         // Custom color 1 blue
+    effect_data[7]  = brightness;
+    effect_data[8]  = red2;         // Custom color 2 red
+    effect_data[9]  = grn2;         // Custom color 2 green
+    effect_data[10] = blu2;         // Custom color 2 blue
+    effect_data[11] = brightness;
+    effect_data[12] = 0x00;
+    effect_data[13] = 0x00;
+    effect_data[14] = 0x00;
+    effect_data[15] = 0x00;
+    effect_data[16] = 0x00;
+    effect_data[17] = 0x00;
+    effect_data[18] = 0x00;
+    effect_data[19] = 0x00;
+
+    /*-----------------------------------------------------*\
+    | Write effect packet                                   |
+    \*-----------------------------------------------------*/
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_RESET_BUFFER, 0x00);
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_BINARY_START, 0x00);
+
+    for(unsigned int i = 0; i < 20; i++)
+    {
+        bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_SET_BINARY_DATA, effect_data[i]);
+    }
+
+    /*-----------------------------------------------------*\
+    | Calculate CRC and read CRC reported by device         |
+    \*-----------------------------------------------------*/
+    calc_crc    = CRCPP::CRC::Calculate(effect_data, sizeof(effect_data), CRCPP::CRC::CRC_8());
+    device_crc  = bus->i2c_smbus_read_byte_data(dev, CORSAIR_DRAM_REG_GET_CHECKSUM);
+
+    /*-----------------------------------------------------*\
+    | Write effect configuration only if CRCs match         |
+    \*-----------------------------------------------------*/
+    if(calc_crc == device_crc)
+    {
+        bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_WRITE_CONFIGURATION, CORSAIR_DRAM_ID_EFFECT_CONFIGURATION);
+        WaitReady();
+    }
+}
+
+bool CorsairDRAMController::WaitReady()
+{
+    /*-----------------------------------------------------*\
+    | Poll status register 0x30; bit 3 (0x08) = busy.       |
+    | Device is ready when bit 3 is clear.                  |
+    \*-----------------------------------------------------*/
+    for(int retry = 0; retry < 5; retry++)
+    {
+        int status = bus->i2c_smbus_read_byte_data(dev, CORSAIR_DRAM_REG_STATUS);
+
+        if(status >= 0 && (status & 0x08) == 0)
+        {
+            return true;
+        }
+
+        std::this_thread::sleep_for(10ms);
+    }
+
+    return false;
+}
+
+void CorsairDRAMController::ReadDeviceInfo()
+{
+    unsigned char   device_information_data[32];
+    unsigned char   device_crc;
+    unsigned char   calc_crc;
+
+    /*-----------------------------------------------------*\
+    | Request Device Information Data                       |
+    \*-----------------------------------------------------*/
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_GET_DEVICE_INFO, 0x00);
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_BINARY_START,    0x00);
+
+    /*-----------------------------------------------------*\
+    | Read Device Information Data                          |
+    \*-----------------------------------------------------*/
+    for(unsigned int i = 0; i < 32; i++)
+    {
+        device_information_data[i] = bus->i2c_smbus_read_byte_data(dev, CORSAIR_DRAM_REG_GET_BINARY_DATA);
+    }
+
+    /*-----------------------------------------------------*\
+    | Compare CRC                                           |
+    \*-----------------------------------------------------*/
+    calc_crc    = CRCPP::CRC::Calculate(device_information_data, sizeof(device_information_data), CRCPP::CRC::CRC_8());
+    device_crc  = bus->i2c_smbus_read_byte_data(dev, CORSAIR_DRAM_REG_GET_CHECKSUM);
+
+    if(calc_crc != device_crc)
+    {
+        LOG_ERROR("[%s] ReadDeviceInfo CRC Mismatch", CORSAIR_DRAM_NAME);
+    }
+
+    /*-----------------------------------------------------*\
+    | Log Device Information Data                           |
+    \*-----------------------------------------------------*/
+    if(LogManager::get()->getLoglevel() >= LL_TRACE)
+    {
+        char            device_info_buf[256];
+        unsigned int    pos;
+
+        pos = snprintf(device_info_buf, sizeof(device_info_buf), "%02X: ", dev);
+
+        for(unsigned int i = 0; i < 32; i++)
+        {
+            pos += snprintf(&device_info_buf[pos], sizeof(device_info_buf) - pos, "%02X ", device_information_data[i]);
+        }
+
+        LOG_TRACE("[%s] Device Info: %s", CORSAIR_DRAM_NAME, device_info_buf);
+    }
+
+    /*-----------------------------------------------------*\
+    | Read VID                                              |
+    \*-----------------------------------------------------*/
+    vid = (device_information_data[1] << 8) | device_information_data[0];
+
+    /*-----------------------------------------------------*\
+    | Read PID                                              |
+    \*-----------------------------------------------------*/
+    pid = (device_information_data[3] << 8) | device_information_data[2];
+
+    /*-----------------------------------------------------*\
+    | Format Firwmare Version                               |
+    \*-----------------------------------------------------*/
+    firmware_version = std::to_string(device_information_data[9]) + "." + std::to_string(device_information_data[8]) + "." + std::to_string((device_information_data[11] << 8) | device_information_data[10]);
+
+    /*-----------------------------------------------------*\
+    | Read Protocol Version                                 |
+    \*-----------------------------------------------------*/
+    protocol_version = device_information_data[28];
+
+    /*-----------------------------------------------------*\
+    | Loop through all known devices to look for a PID      |
+    | match                                                 |
+    \*-----------------------------------------------------*/
+    for(unsigned int i = 0; i < CORSAIR_DRAM_NUM_DEVICES; i++)
+    {
+        for(unsigned int j = 0; j < CORSAIR_DRAM_MAX_PIDS; j++)
+        {
+            if(corsair_dram_device_list[i]->pids[j] == pid)
+            {
+                /*-----------------------------------------*\
+                | Set device ID                             |
+                \*-----------------------------------------*/
+                device_index = i;
+                break;
+            }
+        }
+    }
+}

Controllers/CorsairDRAMController/CorsairDRAMController.h

@@ -0,0 +1,149 @@
+/*---------------------------------------------------------*\
+| CorsairDRAMController.h                                   |
+|                                                           |
+|   Driver for Corsair DRAM RGB controllers                 |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
+|   Erik Gilling (konkers)                      25 Sep 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include "i2c_smbus.h"
+#include "CorsairDRAMDevices.h"
+#include "RGBController.h"
+
+typedef unsigned char corsair_dev_id;
+
+enum
+{   /* (*) indicates deprecated registers no longer used by iCue                                            */
+    CORSAIR_DRAM_REG_RESET_BUFFER           = 0x0B,     /* Reset buffer by writing 0x00                     */
+    CORSAIR_DRAM_REG_SET_BINARY_DATA        = 0x20,     /* Write byte to active binary data buffer          */
+    CORSAIR_DRAM_REG_BINARY_START           = 0x21,     /* Start binary data transfer by writing 0x00       */
+    CORSAIR_DRAM_REG_SWITCH_MODE            = 0x23,     /* Switch between Bootloader(0x00) and Normal(0x01) */
+    CORSAIR_DRAM_REG_SET_BUFFER             = 0x26,     /* Select configuration buffer to write by ID (*)   */
+    CORSAIR_DRAM_REG_STATUS                 = 0x30,     /* Status register                                  */
+    CORSAIR_DRAM_REG_COLOR_BUFFER_BLOCK_1   = 0x31,     /* Direct color buffer block register 1             */
+    CORSAIR_DRAM_REG_COLOR_BUFFER_BLOCK_2   = 0x32,     /* Direct color buffer block register 2             */
+    CORSAIR_DRAM_REG_GET_BINARY_DATA        = 0x40,     /* Read byte from active binary data buffer         */
+    CORSAIR_DRAM_REG_BUSY_STATUS            = 0x41,     /* Reads nonzero while busy, zero when ready(*)     */
+    CORSAIR_DRAM_REG_GET_CHECKSUM           = 0x42,     /* Get checksum (CRC8) of active binary data buffer */
+    CORSAIR_DRAM_REG_GET_DEVICE_INFO        = 0x61,     /* Select device info buffer                        */
+    CORSAIR_DRAM_REG_GET_CONFIGURATION      = 0x63,     /* Select configuration buffer to read by ID        */
+    CORSAIR_DRAM_REG_WRITE_CONFIGURATION    = 0x82,     /* Write/Apply configuration by writing buffer ID   */
+};
+
+enum
+{
+    CORSAIR_DRAM_ID_COMMAND_LIST            = 0,        /* Command list                                     */
+    CORSAIR_DRAM_ID_EFFECT_CONFIGURATION    = 1,        /* Effect configuration                             */
+    CORSAIR_DRAM_ID_COLOR_DATA              = 2,        /* Color data                                       */
+};
+
+enum
+{
+    CORSAIR_DRAM_MODE_DIRECT                = 0xDD,     /* Arbitrary value to compare against later. Not the actual packet  */
+    CORSAIR_DRAM_MODE_COLOR_SHIFT           = 0x00,     /* Color Shift mode                                                 */
+    CORSAIR_DRAM_MODE_COLOR_PULSE           = 0x01,     /* Color Pulse mode                                                 */
+    CORSAIR_DRAM_MODE_RAINBOW_WAVE          = 0x03,     /* Rainbow Wave mode                                                */
+    CORSAIR_DRAM_MODE_COLOR_WAVE            = 0x04,     /* Color Wave mode                                                  */
+    CORSAIR_DRAM_MODE_VISOR                 = 0x05,     /* Visor mode                                                       */
+    CORSAIR_DRAM_MODE_RAIN                  = 0x06,     /* Rain mode                                                        */
+    CORSAIR_DRAM_MODE_MARQUEE               = 0x07,     /* Marquee mode                                                     */
+    CORSAIR_DRAM_MODE_RAINBOW               = 0x08,     /* Rainbow mode                                                     */
+    CORSAIR_DRAM_MODE_SEQUENTIAL            = 0x09,     /* Sequential mode                                                  */
+    CORSAIR_DRAM_MODE_STATIC                = 0x10,     /* Static mode                                                      */
+
+    CORSAIR_DRAM_NUMBER_MODES               = 10,       /* Number of Corsair Pro modes          */
+};
+
+enum
+{
+    CORSAIR_DRAM_SPEED_SLOW                 = 0x00,     /* Slow speed                           */
+    CORSAIR_DRAM_SPEED_MEDIUM               = 0x01,     /* Medium speed                         */
+    CORSAIR_DRAM_SPEED_FAST                 = 0x02,     /* Fast speed                           */
+};
+
+enum
+{
+    CORSAIR_DRAM_EFFECT_RANDOM_COLORS       = 0x00,     /* Random colors                        */
+    CORSAIR_DRAM_EFFECT_CUSTOM_COLORS       = 0x01,     /* Custom colors                        */
+};
+
+enum
+{
+    CORSAIR_DRAM_DIRECTION_UP               = 0x00,     /* Up direction                         */
+    CORSAIR_DRAM_DIRECTION_DOWN             = 0x01,     /* Down direction                       */
+    CORSAIR_DRAM_DIRECTION_LEFT             = 0x02,     /* Left direction                       */
+    CORSAIR_DRAM_DIRECTION_RIGHT            = 0x03,     /* Right direction                      */
+    CORSAIR_DRAM_DIRECTION_VERTICAL         = 0x01,     /* Vertical direction                   */
+    CORSAIR_DRAM_DIRECTION_HORIZONTAL       = 0x03,     /* Horizontal direction                 */
+};
+
+enum
+{
+    CORSAIR_DRAM_BRIGHTNESS_MIN             = 0,        /* Minimum brightness                   */
+    CORSAIR_DRAM_BRIGHTNESS_MAX             = 255,      /* Maximum brightness                   */
+    CORSAIR_DRAM_BRIGHTNESS_DEFAULT         = 255,      /* Default brightness                   */
+};
+
+class CorsairDRAMController
+{
+public:
+    CorsairDRAMController(i2c_smbus_interface *bus, corsair_dev_id dev);
+    ~CorsairDRAMController();
+
+    std::string             GetDeviceLocation();
+    std::string             GetDeviceName();
+    std::string             GetDeviceVersion();
+
+    unsigned int            GetLEDCount();
+    unsigned char           GetProtocolVersion();
+
+    void                    SetColorsPerLED(RGBColor* colors);
+    void                    SetDirect(bool direct);
+    void                    SetEffect(unsigned char mode,
+                                      unsigned char speed,
+                                      unsigned char direction,
+                                      bool          random,
+                                      unsigned char brightness,
+                                      unsigned char red1,
+                                      unsigned char grn1,
+                                      unsigned char blu1,
+                                      unsigned char red2,
+                                      unsigned char grn2,
+                                      unsigned char blu2);
+
+    bool                    WaitReady();
+
+private:
+    /*-----------------------------------------------------*\
+    | I2C                                                   |
+    \*-----------------------------------------------------*/
+    i2c_smbus_interface*    bus;
+    corsair_dev_id          dev;
+
+    /*-----------------------------------------------------*\
+    | State tracking                                        |
+    \*-----------------------------------------------------*/
+    bool                    direct_mode;
+
+    /*-----------------------------------------------------*\
+    | Corsair DRAM information                              |
+    \*-----------------------------------------------------*/
+    unsigned short          vid;
+    unsigned short          pid;
+    std::string             firmware_version;
+    unsigned char           protocol_version;
+
+    unsigned int            device_index;
+
+    /*-----------------------------------------------------*\
+    | Private functions                                     |
+    \*-----------------------------------------------------*/
+    void                    ReadDeviceInfo();
+};

Controllers/CorsairDRAMController/CorsairDRAMControllerDetect.cpp

@@ -0,0 +1,96 @@
+/*---------------------------------------------------------*\
+| CorsairDRAMControllerDetect.cpp                           |
+|                                                           |
+|   Detector for Corsair DRAM RGB controllers               |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
+|   Erik Gilling (konkers)                      25 Sep 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <vector>
+#include "CorsairDRAMController.h"
+#include "DetectionManager.h"
+#include "i2c_smbus.h"
+#include "LogManager.h"
+#include "pci_ids.h"
+#include "RGBController_CorsairDRAM.h"
+
+using namespace std::chrono_literals;
+
+#define CORSAIR_DRAM_NAME "Corsair DRAM"
+
+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);
+
+    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);
+        return false;
+    }
+
+    res = bus->i2c_smbus_read_byte_data(address, 0x44);
+
+    if(!(res == 0x03 || res == 0x04))
+    {
+        LOG_DEBUG("[%s] Failed: expected 0x03 or 0x04, got %04X", CORSAIR_DRAM_NAME, res);
+        return false;
+    }
+
+    return true;
+}
+
+DetectedControllers DetectCorsairDRAMControllers(std::vector<i2c_smbus_interface *> &buses)
+{
+    DetectedControllers detected_controllers;
+
+    for(unsigned int bus = 0; bus < buses.size(); bus++)
+    {
+        IF_DRAM_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
+        {
+            LOG_DEBUG("[%s] Testing bus %d", CORSAIR_DRAM_NAME, bus);
+
+            std::vector<unsigned char> addresses;
+
+            for(unsigned char addr = 0x58; addr <= 0x5F; addr++)
+            {
+                addresses.push_back(addr);
+            }
+
+            for(unsigned char addr = 0x18; addr <= 0x1F; addr++)
+            {
+                addresses.push_back(addr);
+            }
+
+            for(unsigned char addr : addresses)
+            {
+                if(TestForCorsairDRAMController(buses[bus], addr))
+                {
+                    CorsairDRAMController*     controller     = new CorsairDRAMController(buses[bus], addr);
+                    RGBController_CorsairDRAM* rgb_controller = new RGBController_CorsairDRAM(controller);
+
+                    detected_controllers.push_back(rgb_controller);
+                }
+
+                std::this_thread::sleep_for(10ms);
+            }
+        }
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_I2C_DETECTOR(CORSAIR_DRAM_NAME, DetectCorsairDRAMControllers);

Controllers/CorsairDRAMController/CorsairDRAMDevices.cpp

@@ -0,0 +1,163 @@
+/*---------------------------------------------------------*\
+| CorsairDRAMDevices.cpp                                    |
+|                                                           |
+|   Device list for Corsair DRAM RGB controllers            |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                07 Apr 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "CorsairDRAMDevices.h"
+
+static const corsair_dram_device corsair_vengeance_pro_ddr4_device =
+{
+    "Corsair Vengeance RGB Pro DDR4",
+    {
+        CORSAIR_VENGEANCE_PRO_DDR4_PID_1,
+        CORSAIR_VENGEANCE_PRO_DDR4_PID_2,
+        0,
+        0,
+        0,
+        0,
+    },
+    10,
+    false
+};
+
+static const corsair_dram_device corsair_dominator_platinum_ddr4_device =
+{
+    "Corsair Dominator Platinum RGB DDR4",
+    {
+        CORSAIR_DOMINATOR_PLATINUM_DDR4_PID_1,
+        CORSAIR_DOMINATOR_PLATINUM_DDR4_PID_2,
+        0,
+        0,
+        0,
+        0,
+    },
+    12,
+    true
+};
+
+static const corsair_dram_device corsair_vengeance_pro_sl_ddr4_device =
+{
+    "Corsair Vengeance RGB Pro SL DDR4",
+    {
+        CORSAIR_VENGEANCE_PRO_SL_DDR4_PID_1,
+        CORSAIR_VENGEANCE_PRO_SL_DDR4_PID_2,
+        0,
+        0,
+        0,
+        0,
+    },
+    10,
+    false
+};
+
+static const corsair_dram_device corsair_vengeance_rs_ddr4_device =
+{
+    "Corsair Vengeance RGB RS DDR4",
+    {
+        CORSAIR_VENGEANCE_RS_DDR4_PID_1,
+        CORSAIR_VENGEANCE_RS_DDR4_PID_2,
+        0,
+        0,
+        0,
+        0,
+    },
+    6,
+    false
+};
+
+static const corsair_dram_device corsair_dominator_platinum_ddr5_device =
+{
+    "Corsair Dominator Platinum RGB DDR5",
+    {
+        CORSAIR_DOMINATOR_PLATINUM_DDR5_PID_1,
+        CORSAIR_DOMINATOR_PLATINUM_DDR5_PID_2,
+        0,
+        0,
+        0,
+        0,
+    },
+    12,
+    true
+};
+
+static const corsair_dram_device corsair_dominator_titanium_ddr5_device =
+{
+    "Corsair Dominator Titanium RGB DDR5",
+    {
+        CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_1,
+        CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_2,
+        CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_3,
+        CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_4,
+        0,
+        0,
+    },
+    12,
+    true
+};
+
+static const corsair_dram_device corsair_vengeance_ddr5_device =
+{
+    "Corsair Vengeance RGB DDR5",
+    {
+        CORSAIR_VENGEANCE_DDR5_PID_1,
+        CORSAIR_VENGEANCE_DDR5_PID_2,
+        CORSAIR_VENGEANCE_DDR5_PID_3,
+        CORSAIR_VENGEANCE_DDR5_PID_4,
+        CORSAIR_VENGEANCE_DDR5_PID_5,
+        CORSAIR_VENGEANCE_DDR5_PID_6,
+    },
+    10,
+    false
+};
+
+static const corsair_dram_device corsair_vengeance_shugo_series_ddr5_device =
+{
+    "Corsair Vengeance Shugo Series DDR5",
+    {
+        CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_1,
+        CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_2,
+        CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_3,
+        CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_4,
+        0,
+        0,
+    },
+    10,
+    false
+};
+
+static const corsair_dram_device corsair_vengeance_rs_ddr5_device =
+{
+    "Corsair Vengeance RGB RS DDR5",
+    {
+        CORSAIR_VENGEANCE_RS_DDR5_PID_1,
+        CORSAIR_VENGEANCE_RS_DDR5_PID_2,
+        0,
+        0,
+        0,
+        0,
+    },
+    6,
+    false
+};
+
+static const corsair_dram_device* device_list[] =
+{
+    &corsair_vengeance_pro_ddr4_device,
+    &corsair_dominator_platinum_ddr4_device,
+    &corsair_vengeance_pro_sl_ddr4_device,
+    &corsair_vengeance_rs_ddr4_device,
+    &corsair_dominator_platinum_ddr5_device,
+    &corsair_dominator_titanium_ddr5_device,
+    &corsair_vengeance_ddr5_device,
+    &corsair_vengeance_shugo_series_ddr5_device,
+    &corsair_vengeance_rs_ddr5_device,
+};
+
+const unsigned int CORSAIR_DRAM_NUM_DEVICES = (sizeof(device_list) / sizeof(device_list[ 0 ]));
+const corsair_dram_device** corsair_dram_device_list = device_list;

Controllers/CorsairDRAMController/CorsairDRAMDevices.h

@@ -0,0 +1,68 @@
+/*---------------------------------------------------------*\
+| CorsairDRAMDevices.h                                      |
+|                                                           |
+|   Device list for Corsair DRAM RGB controllers            |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                07 Apr 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+
+/*---------------------------------------------------------*\
+| Maximum number of PIDs for a given DRAM model             |
+\*---------------------------------------------------------*/
+#define CORSAIR_DRAM_MAX_PIDS                       6
+
+/*---------------------------------------------------------*\
+| Corsair DRAM vendor ID                                    |
+\*---------------------------------------------------------*/
+#define CORSAIR_DRAM_VID                            0x1B1C
+
+/*---------------------------------------------------------*\
+| Corsair DRAM product IDs                                  |
+\*---------------------------------------------------------*/
+#define CORSAIR_VENGEANCE_PRO_DDR4_PID_1            0x0100
+#define CORSAIR_VENGEANCE_PRO_DDR4_PID_2            0x0101
+#define CORSAIR_DOMINATOR_PLATINUM_DDR4_PID_1       0x0200
+#define CORSAIR_DOMINATOR_PLATINUM_DDR4_PID_2       0x0201
+#define CORSAIR_VENGEANCE_PRO_SL_DDR4_PID_1         0x0300
+#define CORSAIR_VENGEANCE_PRO_SL_DDR4_PID_2         0x0301
+#define CORSAIR_VENGEANCE_RS_DDR4_PID_1             0x0400
+#define CORSAIR_VENGEANCE_RS_DDR4_PID_2             0x0401
+#define CORSAIR_DOMINATOR_PLATINUM_DDR5_PID_1       0x0600
+#define CORSAIR_DOMINATOR_PLATINUM_DDR5_PID_2       0x0601
+#define CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_1       0x0800
+#define CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_2       0x0801
+#define CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_3       0x0810
+#define CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_4       0x0811
+#define CORSAIR_VENGEANCE_DDR5_PID_1                0x0700
+#define CORSAIR_VENGEANCE_DDR5_PID_2                0x0701
+#define CORSAIR_VENGEANCE_DDR5_PID_3                0x0900
+#define CORSAIR_VENGEANCE_DDR5_PID_4                0x0901
+#define CORSAIR_VENGEANCE_DDR5_PID_5                0x0910
+#define CORSAIR_VENGEANCE_DDR5_PID_6                0x0911
+#define CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_1   0x0A00
+#define CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_2   0x0A01
+#define CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_3   0x0A10
+#define CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_4   0x0A11
+#define CORSAIR_VENGEANCE_RS_DDR5_PID_1             0x0B00
+#define CORSAIR_VENGEANCE_RS_DDR5_PID_2             0x0B01
+
+typedef struct
+{
+    std::string                         name;
+    unsigned short                      pids[CORSAIR_DRAM_MAX_PIDS];
+    unsigned int                        led_count;
+    bool                                reverse;
+} corsair_dram_device;
+
+/*-----------------------------------------------------*\
+| These constant values are defined in RazerDevices.cpp |
+\*-----------------------------------------------------*/
+extern const unsigned int CORSAIR_DRAM_NUM_DEVICES;
+extern const corsair_dram_device** corsair_dram_device_list;

Controllers/CorsairDRAMController/RGBController_CorsairDRAM.cpp

@@ -0,0 +1,324 @@
+/*---------------------------------------------------------*\
+| RGBController_CorsairDRAM.cpp                             |
+|                                                           |
+|   RGBController for Corsair DRAM RGB controllers          |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
+|   Erik Gilling (konkers)                      25 Sep 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_CorsairDRAM.h"
+
+/**------------------------------------------------------------------*\
+    @name Corsair DRAM
+    @category RAM
+    @type SMBus
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectCorsairDRAMControllers
+    @comment
+        The Corsair DRAM RGB controller chip can be found on several
+        Corsair memory sticks which have different LED counts. This can be controlled
+        by editing the Part Number in OpenRGB.json with values in the below table.
+
+        | Part Number | LED Count |
+        | :---------: | --------: |
+        | CMG         |  6        |
+        | CMH         | 10        |
+        | CMN         | 10        |
+        | CMT         | 12        |
+\*-------------------------------------------------------------------*/
+
+RGBController_CorsairDRAM::RGBController_CorsairDRAM(CorsairDRAMController* controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    name                        = controller->GetDeviceName();
+    vendor                      = "Corsair";
+    type                        = DEVICE_TYPE_DRAM;
+    description                 = "Corsair DRAM RGB Device";
+    location                    = controller->GetDeviceLocation();
+    version                     = controller->GetDeviceVersion();
+
+    if(controller->GetProtocolVersion() >= 4)
+    {
+        mode Direct;
+        Direct.name             = "Direct";
+        Direct.value            = CORSAIR_DRAM_MODE_DIRECT;
+        Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+        Direct.color_mode       = MODE_COLORS_PER_LED;
+        modes.push_back(Direct);
+    }
+
+    mode Custom;
+    Custom.name                 = "Custom";
+    Custom.value                = CORSAIR_DRAM_MODE_STATIC;
+    Custom.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Custom.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Custom);
+
+    mode ColorShift;
+    ColorShift.name             = "Color Shift";
+    ColorShift.value            = CORSAIR_DRAM_MODE_COLOR_SHIFT;
+    ColorShift.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    ColorShift.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    ColorShift.speed_min        = CORSAIR_DRAM_SPEED_SLOW;
+    ColorShift.speed_max        = CORSAIR_DRAM_SPEED_FAST;
+    ColorShift.speed            = CORSAIR_DRAM_SPEED_SLOW;
+    ColorShift.brightness_min   = CORSAIR_DRAM_BRIGHTNESS_MIN;
+    ColorShift.brightness_max   = CORSAIR_DRAM_BRIGHTNESS_MAX;
+    ColorShift.brightness       = CORSAIR_DRAM_BRIGHTNESS_DEFAULT;
+    ColorShift.colors_min       = 2;
+    ColorShift.colors_max       = 2;
+    ColorShift.colors.resize(2);
+    modes.push_back(ColorShift);
+
+    mode ColorPulse;
+    ColorPulse.name             = "Color Pulse";
+    ColorPulse.value            = CORSAIR_DRAM_MODE_COLOR_PULSE;
+    ColorPulse.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    ColorPulse.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    ColorPulse.speed_min        = CORSAIR_DRAM_SPEED_SLOW;
+    ColorPulse.speed_max        = CORSAIR_DRAM_SPEED_FAST;
+    ColorPulse.speed            = CORSAIR_DRAM_SPEED_SLOW;
+    ColorPulse.brightness_min   = CORSAIR_DRAM_BRIGHTNESS_MIN;
+    ColorPulse.brightness_max   = CORSAIR_DRAM_BRIGHTNESS_MAX;
+    ColorPulse.brightness       = CORSAIR_DRAM_BRIGHTNESS_DEFAULT;
+    ColorPulse.colors_min       = 2;
+    ColorPulse.colors_max       = 2;
+    ColorPulse.colors.resize(2);
+    modes.push_back(ColorPulse);
+
+    mode RainbowWave;
+    RainbowWave.name            = "Rainbow Wave";
+    RainbowWave.value           = CORSAIR_DRAM_MODE_RAINBOW_WAVE;
+    RainbowWave.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
+    RainbowWave.color_mode      = MODE_COLORS_NONE;
+    RainbowWave.speed_min       = CORSAIR_DRAM_SPEED_SLOW;
+    RainbowWave.speed_max       = CORSAIR_DRAM_SPEED_FAST;
+    RainbowWave.speed           = CORSAIR_DRAM_SPEED_SLOW;
+    RainbowWave.direction       = MODE_DIRECTION_DOWN;
+    modes.push_back(RainbowWave);
+
+    mode ColorWave;
+    ColorWave.name              = "Color Wave";
+    ColorWave.value             = CORSAIR_DRAM_MODE_COLOR_WAVE;
+    ColorWave.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    ColorWave.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    ColorWave.speed_min         = CORSAIR_DRAM_SPEED_SLOW;
+    ColorWave.speed_max         = CORSAIR_DRAM_SPEED_FAST;
+    ColorWave.speed             = CORSAIR_DRAM_SPEED_SLOW;
+    ColorWave.direction         = MODE_DIRECTION_DOWN;
+    ColorWave.brightness_min    = CORSAIR_DRAM_BRIGHTNESS_MIN;
+    ColorWave.brightness_max    = CORSAIR_DRAM_BRIGHTNESS_MAX;
+    ColorWave.brightness        = CORSAIR_DRAM_BRIGHTNESS_DEFAULT;
+    ColorWave.colors_min        = 2;
+    ColorWave.colors_max        = 2;
+    ColorWave.colors.resize(2);
+    modes.push_back(ColorWave);
+
+    mode Visor;
+    Visor.name                  = "Visor";
+    Visor.value                 = CORSAIR_DRAM_MODE_VISOR;
+    Visor.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Visor.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Visor.speed_min             = CORSAIR_DRAM_SPEED_SLOW;
+    Visor.speed_max             = CORSAIR_DRAM_SPEED_FAST;
+    Visor.speed                 = CORSAIR_DRAM_SPEED_SLOW;
+    Visor.direction             = MODE_DIRECTION_VERTICAL;
+    Visor.brightness_min        = CORSAIR_DRAM_BRIGHTNESS_MIN;
+    Visor.brightness_max        = CORSAIR_DRAM_BRIGHTNESS_MAX;
+    Visor.brightness            = CORSAIR_DRAM_BRIGHTNESS_DEFAULT;
+    Visor.colors_min            = 2;
+    Visor.colors_max            = 2;
+    Visor.colors.resize(2);
+    modes.push_back(Visor);
+
+    mode Rain;
+    Rain.name                   = "Rain";
+    Rain.value                  = CORSAIR_DRAM_MODE_RAIN;
+    Rain.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Rain.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Rain.speed_min              = CORSAIR_DRAM_SPEED_SLOW;
+    Rain.speed_max              = CORSAIR_DRAM_SPEED_FAST;
+    Rain.speed                  = CORSAIR_DRAM_SPEED_SLOW;
+    Rain.direction              = MODE_DIRECTION_DOWN;
+    Rain.brightness_min         = CORSAIR_DRAM_BRIGHTNESS_MIN;
+    Rain.brightness_max         = CORSAIR_DRAM_BRIGHTNESS_MAX;
+    Rain.brightness             = CORSAIR_DRAM_BRIGHTNESS_DEFAULT;
+    Rain.colors_min             = 2;
+    Rain.colors_max             = 2;
+    Rain.colors.resize(2);
+    modes.push_back(Rain);
+
+    mode Marquee;
+    Marquee.name                = "Marquee";
+    Marquee.value               = CORSAIR_DRAM_MODE_MARQUEE;
+    Marquee.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Marquee.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+    Marquee.speed_min           = CORSAIR_DRAM_SPEED_SLOW;
+    Marquee.speed_max           = CORSAIR_DRAM_SPEED_FAST;
+    Marquee.speed               = CORSAIR_DRAM_SPEED_SLOW;
+    Marquee.brightness_min      = CORSAIR_DRAM_BRIGHTNESS_MIN;
+    Marquee.brightness_max      = CORSAIR_DRAM_BRIGHTNESS_MAX;
+    Marquee.brightness          = CORSAIR_DRAM_BRIGHTNESS_DEFAULT;
+    Marquee.colors_min          = 1;
+    Marquee.colors_max          = 1;
+    Marquee.colors.resize(1);
+    modes.push_back(Marquee);
+
+    mode Rainbow;
+    Rainbow.name                = "Rainbow";
+    Rainbow.value               = CORSAIR_DRAM_MODE_RAINBOW;
+    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    Rainbow.speed_min           = CORSAIR_DRAM_SPEED_SLOW;
+    Rainbow.speed_max           = CORSAIR_DRAM_SPEED_FAST;
+    Rainbow.speed               = CORSAIR_DRAM_SPEED_SLOW;
+    modes.push_back(Rainbow);
+
+    mode Sequential;
+    Sequential.name             = "Sequential";
+    Sequential.value            = CORSAIR_DRAM_MODE_SEQUENTIAL;
+    Sequential.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Sequential.color_mode       = MODE_COLORS_MODE_SPECIFIC;
+    Sequential.speed_min        = CORSAIR_DRAM_SPEED_SLOW;
+    Sequential.speed_max        = CORSAIR_DRAM_SPEED_FAST;
+    Sequential.speed            = CORSAIR_DRAM_SPEED_SLOW;
+    Sequential.direction        = MODE_DIRECTION_DOWN;
+    Sequential.brightness_min   = CORSAIR_DRAM_BRIGHTNESS_MIN;
+    Sequential.brightness_max   = CORSAIR_DRAM_BRIGHTNESS_MAX;
+    Sequential.brightness       = CORSAIR_DRAM_BRIGHTNESS_DEFAULT;
+    Sequential.colors_min       = 1;
+    Sequential.colors_max       = 1;
+    Sequential.colors.resize(1);
+    modes.push_back(Sequential);
+
+    SetupZones();
+}
+
+RGBController_CorsairDRAM::~RGBController_CorsairDRAM()
+{
+    Shutdown();
+
+    delete controller;
+}
+
+void RGBController_CorsairDRAM::SetupZones()
+{
+    /*-----------------------------------------------------*\
+    | Set up zone                                           |
+    \*-----------------------------------------------------*/
+    zone new_zone;
+    new_zone.name           = "Corsair DRAM";
+    new_zone.type           = ZONE_TYPE_LINEAR;
+    new_zone.leds_min       = controller->GetLEDCount();
+    new_zone.leds_max       = controller->GetLEDCount();
+    new_zone.leds_count     = controller->GetLEDCount();
+    zones.push_back(new_zone);
+
+    /*-----------------------------------------------------*\
+    | Set up LEDs                                           |
+    \*-----------------------------------------------------*/
+    for(std::size_t led_idx = 0; led_idx < zones[0].leds_count; led_idx++)
+    {
+        led new_led;
+        new_led.name        = "Corsair DRAM LED ";
+        new_led.name.append(std::to_string(led_idx));
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_CorsairDRAM::DeviceUpdateLEDs()
+{
+    controller->SetColorsPerLED(colors.data());
+}
+
+void RGBController_CorsairDRAM::DeviceUpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CorsairDRAM::DeviceUpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CorsairDRAM::DeviceUpdateMode()
+{
+    unsigned int  corsair_direction = 0;
+    bool          random            = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+    unsigned char mode_colors[6];
+
+    switch(modes[active_mode].direction)
+    {
+        case MODE_DIRECTION_LEFT:
+            corsair_direction = CORSAIR_DRAM_DIRECTION_LEFT;
+            break;
+        case MODE_DIRECTION_RIGHT:
+            corsair_direction = CORSAIR_DRAM_DIRECTION_RIGHT;
+            break;
+        case MODE_DIRECTION_UP:
+            corsair_direction = CORSAIR_DRAM_DIRECTION_UP;
+            break;
+        case MODE_DIRECTION_DOWN:
+            corsair_direction = CORSAIR_DRAM_DIRECTION_DOWN;
+            break;
+        case MODE_DIRECTION_HORIZONTAL:
+            corsair_direction = CORSAIR_DRAM_DIRECTION_HORIZONTAL;
+            break;
+        case MODE_DIRECTION_VERTICAL:
+            corsair_direction = CORSAIR_DRAM_DIRECTION_VERTICAL;
+            break;
+    }
+
+    mode_colors[0] = 0;
+    mode_colors[1] = 0;
+    mode_colors[2] = 0;
+    mode_colors[3] = 0;
+    mode_colors[4] = 0;
+    mode_colors[5] = 0;
+
+    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        mode_colors[0] = RGBGetRValue(modes[active_mode].colors[0]);
+        mode_colors[1] = RGBGetGValue(modes[active_mode].colors[0]);
+        mode_colors[2] = RGBGetBValue(modes[active_mode].colors[0]);
+
+        if(modes[active_mode].colors.size() == 2)
+        {
+            mode_colors[3] = RGBGetRValue(modes[active_mode].colors[1]);
+            mode_colors[4] = RGBGetGValue(modes[active_mode].colors[1]);
+            mode_colors[5] = RGBGetBValue(modes[active_mode].colors[1]);
+        }
+    }
+
+    if(modes[active_mode].name == "Direct")
+    {
+        controller->SetDirect(true);
+    }
+    else
+    {
+        controller->SetDirect(false);
+    }
+
+    controller->SetEffect(modes[active_mode].value,
+                          modes[active_mode].speed,
+                          corsair_direction,
+                          random,
+                          (unsigned char)modes[active_mode].brightness,
+                          mode_colors[0],
+                          mode_colors[1],
+                          mode_colors[2],
+                          mode_colors[3],
+                          mode_colors[4],
+                          mode_colors[5]);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(15));
+}

Controllers/CorsairDRAMController/RGBController_CorsairDRAM.h

@@ -1,8 +1,9 @@
 /*---------------------------------------------------------*\
-| RGBController_CorsairDominatorPlatinum.h                  |
+| RGBController_CorsairDRAM.h                               |
 |                                                           |
-|   RGBController for Corsair Dominator Platinum RAM        |
+|   RGBController for Corsair DRAM RGB controllers          |
 |                                                           |
+|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
 |   Erik Gilling (konkers)                      25 Sep 2020 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
@@ -12,13 +13,13 @@
 #pragma once
 
 #include "RGBController.h"
-#include "CorsairDominatorPlatinumController.h"
+#include "CorsairDRAMController.h"
 
-class RGBController_CorsairDominatorPlatinum : public RGBController
+class RGBController_CorsairDRAM : public RGBController
 {
 public:
-    RGBController_CorsairDominatorPlatinum(CorsairDominatorPlatinumController* controller_ptr);
-    ~RGBController_CorsairDominatorPlatinum();
+    RGBController_CorsairDRAM(CorsairDRAMController* controller_ptr);
+    ~RGBController_CorsairDRAM();
 
     void SetupZones();
 
@@ -29,5 +30,5 @@ public:
     void DeviceUpdateMode();
 
 private:
-    CorsairDominatorPlatinumController* controller;
+    CorsairDRAMController* controller;
 };

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumController.cpp

@@ -1,134 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairDominatorPlatinumController.cpp                    |
-|                                                           |
-|   Driver for Corsair Dominator Platinum RAM               |
-|                                                           |
-|   Erik Gilling (konkers)                      25 Sep 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include <chrono>
-#include "CorsairDominatorPlatinumController.h"
-
-using namespace std::chrono_literals;
-
-CorsairDominatorPlatinumController::CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev, unsigned int leds_count, std::string dev_name)
-{
-    this->bus           = bus;
-    this->dev           = dev;
-    this->leds_count    = leds_count;
-    this->name          = dev_name;
-
-    led_data[0] = 0xc;
-}
-
-CorsairDominatorPlatinumController::~CorsairDominatorPlatinumController()
-{
-}
-
-unsigned int CorsairDominatorPlatinumController::GetLEDCount()
-{
-    return leds_count;
-}
-
-std::string CorsairDominatorPlatinumController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-std::string CorsairDominatorPlatinumController::GetDeviceName()
-{
-    return(name);
-}
-
-void CorsairDominatorPlatinumController::SetAllColors
-    (
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    for(unsigned int led = 0; led < leds_count; led++)
-    {
-        SetLEDColor(led, red, green, blue);
-    }
-}
-
-void CorsairDominatorPlatinumController::SetLEDColor
-    (
-    unsigned int    led,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    if(led >= leds_count)
-    {
-        return;
-    }
-
-    unsigned int offset     = (led * 3) + 1;
-    led_data[offset]        = red;
-    led_data[offset + 1]    = green;
-    led_data[offset + 2]    = blue;
-}
-
-unsigned char CorsairDominatorPlatinumController::crc8
-    (
-    unsigned char   init,
-    unsigned char   poly,
-    unsigned char*  data,
-    unsigned char   len
-    )
-{
-    unsigned char crc = init;
-
-    for(unsigned int i = 0; i < len; i++)
-    {
-        unsigned char val = data[i];
-        for(unsigned char mask = 0x80; mask != 0; mask >>= 1)
-        {
-            unsigned char bit;
-            if ((val & mask) != 0)
-            {
-                bit = (crc & 0x80) ^ 0x80;
-            }
-            else
-            {
-                bit = crc & 0x80;
-            }
-
-            if (bit == 0)
-            {
-                crc <<= 1;
-            }
-            else
-            {
-                crc = (crc << 1) ^ poly;
-            }
-        }
-    }
-
-    return crc;
-}
-
-void CorsairDominatorPlatinumController::ApplyColors()
-{
-    unsigned char data[sizeof(led_data)];
-    memcpy(data, led_data, sizeof(led_data));
-    unsigned char crc = crc8(0x0, 0x7, data, sizeof(data) - 1);
-    data[sizeof(data) - 1] = crc;
-
-    bus->i2c_smbus_write_block_data(dev, 0x31, 0x20, data);
-    std::this_thread::sleep_for(800us);
-    bus->i2c_smbus_write_block_data(dev, 0x32, sizeof(data) - 0x20, data + 0x20);
-    std::this_thread::sleep_for(200us);
-}

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumController.h

@@ -1,44 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairDominatorPlatinumController.h                      |
-|                                                           |
-|   Driver for Corsair Dominator Platinum RAM               |
-|                                                           |
-|   Erik Gilling (konkers)                      25 Sep 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include "i2c_smbus.h"
-
-#define CORSAIR_DOMINATOR_PLATINUM_DATA_SIZE 38
-
-typedef unsigned char corsair_dev_id;
-
-class CorsairDominatorPlatinumController
-{
-public:
-    CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev, unsigned int leds_count, std::string dev_name);
-    ~CorsairDominatorPlatinumController();
-
-    std::string GetDeviceLocation();
-    std::string GetDeviceName();
-    unsigned int GetLEDCount();
-
-    void SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
-    void SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
-    void ApplyColors();
-    bool WaitReady();
-
-private:
-    unsigned char           led_data[CORSAIR_DOMINATOR_PLATINUM_DATA_SIZE];
-    i2c_smbus_interface*    bus;
-    corsair_dev_id          dev;
-    unsigned int            leds_count;
-    std::string             name;
-
-    static unsigned char crc8(unsigned char init, unsigned char poly, unsigned char *data, unsigned char len);
-};

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumControllerDetect.cpp

@@ -1,168 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairDominatorPlatinumControllerDetect.cpp              |
-|                                                           |
-|   Detector for Corsair Dominator Platinum RAM             |
-|                                                           |
-|   Erik Gilling (konkers)                      25 Sep 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <vector>
-#include "CorsairDominatorPlatinumController.h"
-#include "DetectionManager.h"
-#include "i2c_smbus.h"
-#include "LogManager.h"
-#include "pci_ids.h"
-#include "ResourceManager.h"
-#include "RGBController_CorsairDominatorPlatinum.h"
-#include "SettingsManager.h"
-
-using namespace std::chrono_literals;
-
-json corsair_dominator_models =
-{
-    {
-        "CMT",
-        {
-            {"name",  "Corsair Dominator Platinum"},
-            {"leds",  12}
-        }
-    },
-    {
-        "CMH",
-        {
-            {"name",  "Corsair Vengeance Pro SL"},
-            {"leds",  10}
-        }
-    },
-    {
-        "CMN",
-        {
-            {"name",  "Corsair Vengeance RGB RT"},
-            {"leds",  10}
-        }
-    },
-    {
-        "CMG",
-        {
-            {"name",  "Corsair Vengeance RGB RS"},
-            {"leds",  6}
-        }
-    },
-    {
-        "CMP",
-        {
-            {"name",  "Corsair Dominator Titanium"},
-            {"leds",  11}
-        }
-    }
-};
-
-#define CORSAIR_DOMINATOR_PLATINUM_NAME "Corsair Dominator Platinum"
-
-bool TestForCorsairDominatorPlatinumController(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_DOMINATOR_PLATINUM_NAME, address);
-
-    if(res < 0)
-    {
-        LOG_DEBUG("[%s] Failed: res was %04X", CORSAIR_DOMINATOR_PLATINUM_NAME, res);
-        return false;
-    }
-
-    res = bus->i2c_smbus_read_byte_data(address, 0x43);
-
-    if(!(res == 0x1A || res == 0x1B))
-    {
-        LOG_DEBUG("[%s] Failed: expected 0x1a or 0x1b, got %04X", CORSAIR_DOMINATOR_PLATINUM_NAME, res);
-        return false;
-    }
-
-    res = bus->i2c_smbus_read_byte_data(address, 0x44);
-
-    if(res != 0x04)
-    {
-        LOG_DEBUG("[%s] Failed: expected 0x04, got %04X", CORSAIR_DOMINATOR_PLATINUM_NAME, res);
-        return false;
-    }
-
-    return true;
-}
-
-DetectedControllers DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *> &busses)
-{
-    DetectedControllers detected_controllers;
-    SettingsManager*    settings_manager            = ResourceManager::get()->GetSettingsManager();
-    json                corsair_dominator_settings  = settings_manager->GetSettings("CorsairDominatorSettings");
-
-    if(!corsair_dominator_settings.contains("model"))
-    {
-        // Set default value
-        corsair_dominator_settings["model"] = "CMT";
-        settings_manager->SetSettings("CorsairDominatorSettings", corsair_dominator_settings);
-        settings_manager->SaveSettings();
-    }
-
-    std::string model = corsair_dominator_settings["model"];
-
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
-        {
-            LOG_DEBUG("[%s] Testing bus %d", CORSAIR_DOMINATOR_PLATINUM_NAME, bus);
-
-            std::vector<unsigned char> addresses;
-
-            for(unsigned char addr = 0x58; addr <= 0x5F; addr++)
-            {
-                addresses.push_back(addr);
-            }
-
-            for(unsigned char addr = 0x18; addr <= 0x1F; addr++)
-            {
-                addresses.push_back(addr);
-            }
-
-            for(unsigned char addr : addresses)
-            {
-                if(TestForCorsairDominatorPlatinumController(busses[bus], addr))
-                {
-                    unsigned int leds;
-                    std::string name;
-
-                    if(corsair_dominator_models.contains(model))
-                    {
-                        leds = corsair_dominator_models[model]["leds"];
-                        name = corsair_dominator_models[model]["name"];
-                    }
-                    else
-                    {
-                        leds = corsair_dominator_models["CMT"]["leds"];
-                        name = corsair_dominator_models["CMT"]["name"];
-                    }
-
-                    LOG_DEBUG("[%s] Model: %s, Leds: %d", CORSAIR_DOMINATOR_PLATINUM_NAME, name.c_str(), leds);
-
-                    CorsairDominatorPlatinumController*     controller     = new CorsairDominatorPlatinumController(busses[bus], addr, leds, name);
-                    RGBController_CorsairDominatorPlatinum* rgb_controller = new RGBController_CorsairDominatorPlatinum(controller);
-
-                    detected_controllers.push_back(rgb_controller);
-                }
-
-                std::this_thread::sleep_for(10ms);
-            }
-        }
-        else
-        {
-            LOG_DEBUG("[%s] Bus %d is not a DRAM bus", CORSAIR_DOMINATOR_PLATINUM_NAME, bus);
-        }
-    }
-
-    return(detected_controllers);
-}
-
-REGISTER_I2C_DETECTOR(CORSAIR_DOMINATOR_PLATINUM_NAME, DetectCorsairDominatorPlatinumControllers);

Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.cpp

@@ -1,128 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_CorsairDominatorPlatinum.cpp                |
-|                                                           |
-|   RGBController for Corsair Dominator Platinum RAM        |
-|                                                           |
-|   Erik Gilling (konkers)                      25 Sep 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBController_CorsairDominatorPlatinum.h"
-
-/**------------------------------------------------------------------*\
-    @name Corsair Dominator Platinum
-    @category RAM
-    @type SMBus
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectCorsairDominatorPlatinumControllers
-    @comment
-        The Corsair Dominator controller chip can be found on several
-        Corsair memory sticks which have different LED counts. This can be controlled
-        by editing the Part Number in OpenRGB.json with values in the below table.
-
-        | Part Number | LED Count |
-        | :---------: | --------: |
-        | CMG         |  6        |
-        | CMH         | 10        |
-        | CMN         | 10        |
-        | CMT         | 12        |
-\*-------------------------------------------------------------------*/
-
-RGBController_CorsairDominatorPlatinum::RGBController_CorsairDominatorPlatinum(CorsairDominatorPlatinumController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = controller->GetDeviceName();
-    vendor      = "Corsair";
-    type        = DEVICE_TYPE_DRAM;
-    description = "Corsair RAM RGB Device";
-    location    = controller->GetDeviceLocation();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.speed_min  = 0;
-    Direct.speed_max  = 0;
-    Direct.speed      = 0;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-
-    active_mode = 0;
-}
-
-RGBController_CorsairDominatorPlatinum::~RGBController_CorsairDominatorPlatinum()
-{
-    Shutdown();
-
-    delete controller;
-}
-
-void RGBController_CorsairDominatorPlatinum::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zone                                               |
-    \*---------------------------------------------------------*/
-    zone new_zone;
-    new_zone.name       = "Corsair RAM Zone";
-    new_zone.type       = ZONE_TYPE_LINEAR;
-    new_zone.leds_min   = controller->GetLEDCount();
-    new_zone.leds_max   = controller->GetLEDCount();
-    new_zone.leds_count = controller->GetLEDCount();
-    zones.push_back(new_zone);
-
-    /*---------------------------------------------------------*\
-    | Set up LEDs                                               |
-    \*---------------------------------------------------------*/
-    for(std::size_t led_idx = 0; led_idx < zones[0].leds_count; led_idx++)
-    {
-        led new_led;
-        new_led.name   = "Corsair RAM LED ";
-        new_led.name.append(std::to_string(led_idx));
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_CorsairDominatorPlatinum::DeviceUpdateLEDs()
-{
-    for(unsigned int led = 0; led < (unsigned int)colors.size(); led++)
-    {
-        RGBColor color    = colors[led];
-        unsigned char red = RGBGetRValue(color);
-        unsigned char grn = RGBGetGValue(color);
-        unsigned char blu = RGBGetBValue(color);
-
-        controller->SetLEDColor(led, red, grn, blu);
-    }
-
-    controller->ApplyColors();
-}
-
-void RGBController_CorsairDominatorPlatinum::DeviceUpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_CorsairDominatorPlatinum::DeviceUpdateSingleLED(int led)
-{
-    RGBColor color    = colors[led];
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    controller->SetLEDColor(led, red, grn, blu);
-    controller->ApplyColors();
-}
-
-void RGBController_CorsairDominatorPlatinum::DeviceUpdateMode()
-{
-
-}

Controllers/CorsairHydroPlatinumController/RGBController_CorsairHydroPlatinum.cpp

@@ -110,7 +110,8 @@ void RGBController_CorsairHydroPlatinum::SetupZones()
             zones[1].flags                  = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                             | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                             | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[1].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp

@@ -332,7 +332,8 @@ void RGBController_CorsairLightingNode::SetupZones()
             zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/CorsairVengeanceProController/CorsairVengeanceProController.cpp

@@ -1,213 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairVengeanceProController.cpp                         |
-|                                                           |
-|   Driver for Corsair Vengeance Pro RGB RAM                |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include <chrono>
-#include "CorsairVengeanceProController.h"
-
-using namespace std::chrono_literals;
-
-CorsairVengeanceProController::CorsairVengeanceProController(i2c_smbus_interface* bus, corsair_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-
-    strcpy(device_name, "Corsair Vengeance Pro RGB");
-    led_count = CORSAIR_PRO_LED_COUNT;
-
-    direct_mode = false;
-    effect_mode = CORSAIR_PRO_MODE_STATIC;
-
-    for (unsigned int i = 0; i < led_count; i++)
-    {
-        led_red[i]      = 0;
-        led_green[i]    = 0;
-        led_blue[i]     = 0;
-    }
-}
-
-CorsairVengeanceProController::~CorsairVengeanceProController()
-{
-
-}
-
-std::string CorsairVengeanceProController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string CorsairVengeanceProController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-unsigned int CorsairVengeanceProController::GetLEDCount()
-{
-    return(led_count);
-}
-
-unsigned char CorsairVengeanceProController::GetEffect()
-{
-    return(effect_mode);
-}
-
-void CorsairVengeanceProController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
-{
-    for (unsigned int i = 0; i < led_count; i++)
-    {
-        led_red[i]      = red;
-        led_green[i]    = green;
-        led_blue[i]     = blue;
-    }
-}
-
-void CorsairVengeanceProController::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
-{
-    led_red[led]    = red;
-    led_green[led]  = green;
-    led_blue[led]   = blue;
-}
-
-void CorsairVengeanceProController::ApplyColors()
-{
-    if(direct_mode)
-    {
-        unsigned char   full_packet[32];
-        unsigned char   crc_packet[31];
-
-        full_packet[0]  = 0x0A;
-        crc_packet[0]   = 0x0A;
-
-        for (int i = 0; i < 10; i++)
-        {
-            crc_packet[(i * 3) + 1]     = led_red[i];
-            full_packet[(i * 3) + 1]    = led_red[i];
-
-            crc_packet[(i * 3) + 2]     = led_green[i];
-            full_packet[(i * 3) + 2]    = led_green[i];
-
-            crc_packet[(i * 3) + 3]     = led_blue[i];
-            full_packet[(i * 3) + 3]    = led_blue[i];
-        }
-
-        uint8_t footer = CRCPP::CRC::Calculate(crc_packet, 31, CRCPP::CRC::CRC_8());
-
-        full_packet[31] = footer;
-
-        bus->i2c_smbus_write_block_data(dev, CORSAIR_PRO_DIRECT_COMMAND, 32, full_packet);
-    }
-    else
-    {
-        bus->i2c_smbus_write_byte_data(dev, 0x26, 0x02);
-        std::this_thread::sleep_for(1ms);
-        bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
-        std::this_thread::sleep_for(1ms);
-
-        for (int i = 0; i < 10; i++)
-        {
-            bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_red[i]);
-            bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_green[i]);
-            bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_blue[i]);
-            bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0xFF);
-        }
-
-        bus->i2c_smbus_write_byte_data(dev, 0x82, 0x02);
-    }
-}
-
-void CorsairVengeanceProController::SetEffect(unsigned char mode,
-                                     unsigned char speed,
-                                     unsigned char direction,
-                                     bool          random,
-                                     unsigned char red1,
-                                     unsigned char grn1,
-                                     unsigned char blu1,
-                                     unsigned char red2,
-                                     unsigned char grn2,
-                                     unsigned char blu2
-                                    )
-{
-    if(mode == effect_mode)
-    {
-        return;
-    }
-
-    effect_mode = mode;
-
-    direct_mode = (effect_mode == CORSAIR_PRO_MODE_DIRECT);
-
-    if(direct_mode)
-    {
-        return;
-    }
-
-    bus->i2c_smbus_write_byte_data(dev, 0x26, 0x01);
-    std::this_thread::sleep_for(1ms);
-    bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
-    std::this_thread::sleep_for(1ms);
-
-    unsigned char random_byte;
-
-    if(random)
-    {
-        random_byte = CORSAIR_PRO_EFFECT_RANDOM_COLORS;
-    }
-    else
-    {
-        random_byte = CORSAIR_PRO_EFFECT_CUSTOM_COLORS;
-    }
-
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, effect_mode);  // Mode
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, speed);        // Speed
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, random_byte);  // Custom color
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, direction);    // Direction
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, red1);         // Custom color 1 red
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, grn1);         // Custom color 1 green
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, blu1);         // Custom color 1 blue
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0xFF);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, red2);         // Custom color 2 red
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, grn2);         // Custom color 2 green
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, blu2);         // Custom color 2 blue
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0xFF);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-
-    bus->i2c_smbus_write_byte_data(dev, 0x82, 0x01);
-    WaitReady();
-}
-
-bool CorsairVengeanceProController::WaitReady()
-{
-    int i = 0;
-    while (bus->i2c_smbus_read_byte_data(dev, 0x41) != 0x00)
-    {
-        i++;
-        std::this_thread::sleep_for(1ms);
-    }
-
-    return false;
-}
-
-void CorsairVengeanceProController::SetDirect(bool direct)
-{
-    direct_mode = direct;
-}

Controllers/CorsairVengeanceProController/CorsairVengeanceProController.h

@@ -1,109 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairVengeanceProController.h                           |
-|                                                           |
-|   Driver for Corsair Vengeance Pro RGB RAM                |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include "i2c_smbus.h"
-#include "CRC.h"
-
-typedef unsigned char	corsair_dev_id;
-
-#define CORSAIR_PRO_LED_COUNT   ( 10 )
-#define CORSAIR_VENGEANCE_RGB_PRO_NAME "Corsair Vengeance RGB PRO"
-
-enum
-{
-    CORSAIR_PRO_REG_COMMAND             = 0x20,     /* Command write register               */
-    CORSAIR_PRO_DIRECT_COMMAND          = 0x31,     /* Where it writes direct mode colors   */
-};
-
-enum
-{
-    CORSAIR_PRO_MODE_DIRECT             = 0xDD,     /* Arbitrary value to compare against later. Not the actual packet  */
-    CORSAIR_PRO_MODE_COLOR_SHIFT        = 0x00,     /* Color Shift mode                                                 */
-    CORSAIR_PRO_MODE_COLOR_PULSE        = 0x01,     /* Color Pulse mode                                                 */
-    CORSAIR_PRO_MODE_RAINBOW_WAVE       = 0x03,     /* Rainbow Wave mode                                                */
-    CORSAIR_PRO_MODE_COLOR_WAVE         = 0x04,     /* Color Wave mode                                                  */
-    CORSAIR_PRO_MODE_VISOR              = 0x05,     /* Visor mode                                                       */
-    CORSAIR_PRO_MODE_RAIN               = 0x06,     /* Rain mode                                                        */
-    CORSAIR_PRO_MODE_MARQUEE            = 0x07,     /* Marquee mode                                                     */
-    CORSAIR_PRO_MODE_RAINBOW            = 0x08,     /* Rainbow mode                                                     */
-    CORSAIR_PRO_MODE_SEQUENTIAL         = 0x09,     /* Sequential mode                                                  */
-    CORSAIR_PRO_MODE_STATIC             = 0x10,     /* Static mode                                                      */
-
-    CORSAIR_PRO_NUMBER_MODES            = 10,       /* Number of Corsair Pro modes          */
-};
-
-enum
-{
-    CORSAIR_PRO_SPEED_SLOW              = 0x00,     /* Slow speed                           */
-    CORSAIR_PRO_SPEED_MEDIUM            = 0x01,     /* Medium speed                         */
-    CORSAIR_PRO_SPEED_FAST              = 0x02,     /* Fast speed                           */
-};
-
-enum
-{
-    CORSAIR_PRO_EFFECT_RANDOM_COLORS    = 0x00,     /* Random colors                        */
-    CORSAIR_PRO_EFFECT_CUSTOM_COLORS    = 0x01,     /* Custom colors                        */
-};
-
-enum
-{
-    CORSAIR_PRO_DIRECTION_UP            = 0x00,     /* Up direction                         */
-    CORSAIR_PRO_DIRECTION_DOWN          = 0x01,     /* Down direction                       */
-    CORSAIR_PRO_DIRECTION_LEFT          = 0x02,     /* Left direction                       */
-    CORSAIR_PRO_DIRECTION_RIGHT         = 0x03,     /* Right direction                      */
-    CORSAIR_PRO_DIRECTION_VERTICAL      = 0x01,     /* Vertical direction                   */
-    CORSAIR_PRO_DIRECTION_HORIZONTAL    = 0x03,     /* Horizontal direction                 */
-};
-
-class CorsairVengeanceProController
-{
-public:
-    CorsairVengeanceProController(i2c_smbus_interface* bus, corsair_dev_id dev);
-    ~CorsairVengeanceProController();
-
-    std::string     GetDeviceName();
-    std::string     GetDeviceLocation();
-    unsigned int    GetLEDCount();
-    unsigned char   GetEffect();
-    void            SetEffect(unsigned char mode,
-                              unsigned char speed,
-                              unsigned char direction,
-                              bool          random,
-                              unsigned char red1,
-                              unsigned char grn1,
-                              unsigned char blu1,
-                              unsigned char red2,
-                              unsigned char grn2,
-                              unsigned char blu2
-                             );
-
-    void            SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
-    void            SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
-    void            ApplyColors();
-    bool            WaitReady();
-
-    void            SetDirect(bool direct);
-
-private:
-    char                    device_name[32];
-    unsigned int            led_count;
-    bool                    direct_mode;
-    unsigned char           effect_mode;
-    unsigned char           led_red[CORSAIR_PRO_LED_COUNT];
-    unsigned char           led_green[CORSAIR_PRO_LED_COUNT];
-    unsigned char           led_blue[CORSAIR_PRO_LED_COUNT];
-
-    i2c_smbus_interface*    bus;
-    corsair_dev_id          dev;
-};

Controllers/CorsairVengeanceProController/CorsairVengeanceProControllerDetect.cpp

@@ -1,89 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairVengeanceProControllerDetect.cpp                   |
-|                                                           |
-|   Detector for Corsair Vengeance Pro RGB RAM              |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <vector>
-#include "DetectionManager.h"
-#include "CorsairVengeanceProController.h"
-#include "RGBController_CorsairVengeancePro.h"
-#include "i2c_smbus.h"
-#include "pci_ids.h"
-#include "LogManager.h"
-
-using namespace std::chrono_literals;
-
-bool TestForCorsairVengeanceProController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-
-    LOG_DEBUG("[%s] Trying address %02X", CORSAIR_VENGEANCE_RGB_PRO_NAME, address);
-
-    if(res >= 0)
-    {
-        pass = true;
-
-        res = bus->i2c_smbus_read_byte_data(address, 0x43);
-
-        if (res != 0x1C)
-        {
-            pass = false;
-            LOG_DEBUG("[%s] Failed: was expecting 0x1C got %02X", CORSAIR_VENGEANCE_RGB_PRO_NAME, res);
-        }
-
-        res = bus->i2c_smbus_read_byte_data(address, 0x44);
-
-        if(!((res == 0x03) || (res == 0x04)))
-        {
-            pass = false;
-            LOG_DEBUG("[%s] Failed: was expecting 0x03 or 0x04 got %02X", CORSAIR_VENGEANCE_RGB_PRO_NAME, res);
-        }
-    }
-    else
-    {
-        LOG_DEBUG("[%s] Failed: res was %04X", CORSAIR_VENGEANCE_RGB_PRO_NAME, res);
-    }
-
-    std::this_thread::sleep_for(10ms);
-
-    return(pass);
-}
-
-DetectedControllers DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &busses)
-{
-    DetectedControllers detected_controllers;
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        LOG_DEBUG("[%s] Testing bus %d", CORSAIR_VENGEANCE_RGB_PRO_NAME, bus);
-
-        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
-        {
-            for(unsigned char addr = 0x58; addr <= 0x5F; addr++)
-            {
-                if(TestForCorsairVengeanceProController(busses[bus], addr))
-                {
-                    CorsairVengeanceProController*     controller     = new CorsairVengeanceProController(busses[bus], addr);
-                    RGBController_CorsairVengeancePro* rgb_controller = new RGBController_CorsairVengeancePro(controller);
-
-                    detected_controllers.push_back(rgb_controller);
-                }
-            }
-        }
-        else
-        {
-            LOG_DEBUG("[%s] Bus %d is not a DRAM bus", CORSAIR_VENGEANCE_RGB_PRO_NAME, bus);
-        }
-    }
-
-    return(detected_controllers);
-}
-
-REGISTER_I2C_DETECTOR("Corsair Vengeance Pro", DetectCorsairVengeanceProControllers);

Controllers/CorsairVengeanceProController/RGBController_CorsairVengeancePro.cpp

@@ -1,310 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_CorsairVengeancePro.cpp                     |
-|                                                           |
-|   RGBController for Corsair Vengeance Pro RGB RAM         |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBController_CorsairVengeancePro.h"
-
-/**------------------------------------------------------------------*\
-    @name Corsair Vengeance Pro
-    @category RAM
-    @type SMBus
-    @save :robot:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectCorsairVengeanceProControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_CorsairVengeancePro::RGBController_CorsairVengeancePro(CorsairVengeanceProController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = controller->GetDeviceName();
-    vendor      = "Corsair";
-    type        = DEVICE_TYPE_DRAM;
-    description = "Corsair Vengeance Pro RGB Device";
-    location    = controller->GetDeviceLocation();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = CORSAIR_PRO_MODE_DIRECT;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.speed_min  = 0;
-    Direct.speed_max  = 0;
-    Direct.speed      = 0;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name       = "Static";
-    Static.value      = CORSAIR_PRO_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.speed_min  = 0;
-    Static.speed_max  = 0;
-    Static.speed      = 0;
-    Static.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Static);
-
-    mode ColorShift;
-    ColorShift.name       = "Color Shift";
-    ColorShift.value      = CORSAIR_PRO_MODE_COLOR_SHIFT;
-    ColorShift.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    ColorShift.speed_min  = CORSAIR_PRO_SPEED_SLOW;
-    ColorShift.speed_max  = CORSAIR_PRO_SPEED_FAST;
-    ColorShift.colors_min = 2;
-    ColorShift.colors_max = 2;
-    ColorShift.speed      = CORSAIR_PRO_SPEED_SLOW;
-    ColorShift.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    ColorShift.colors.resize(2);
-    modes.push_back(ColorShift);
-
-    mode ColorPulse;
-    ColorPulse.name       = "Color Pulse";
-    ColorPulse.value      = CORSAIR_PRO_MODE_COLOR_PULSE;
-    ColorPulse.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    ColorPulse.speed_min  = CORSAIR_PRO_SPEED_SLOW;
-    ColorPulse.speed_max  = CORSAIR_PRO_SPEED_FAST;
-    ColorPulse.colors_min = 2;
-    ColorPulse.colors_max = 2;
-    ColorPulse.speed      = CORSAIR_PRO_SPEED_SLOW;
-    ColorPulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    ColorPulse.colors.resize(2);
-    modes.push_back(ColorPulse);
-
-    mode RainbowWave;
-    RainbowWave.name       = "Rainbow Wave";
-    RainbowWave.value      = CORSAIR_PRO_MODE_RAINBOW_WAVE;
-    RainbowWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
-    RainbowWave.speed_min  = CORSAIR_PRO_SPEED_SLOW;
-    RainbowWave.speed_max  = CORSAIR_PRO_SPEED_FAST;
-    RainbowWave.speed      = CORSAIR_PRO_SPEED_SLOW;
-    RainbowWave.direction  = MODE_DIRECTION_DOWN;
-    RainbowWave.color_mode = MODE_COLORS_NONE;
-    modes.push_back(RainbowWave);
-
-    mode ColorWave;
-    ColorWave.name       = "Color Wave";
-    ColorWave.value      = CORSAIR_PRO_MODE_COLOR_WAVE;
-    ColorWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    ColorWave.speed_min  = CORSAIR_PRO_SPEED_SLOW;
-    ColorWave.speed_max  = CORSAIR_PRO_SPEED_FAST;
-    ColorWave.colors_min = 2;
-    ColorWave.colors_max = 2;
-    ColorWave.speed      = CORSAIR_PRO_SPEED_SLOW;
-    ColorWave.direction  = MODE_DIRECTION_DOWN;
-    ColorWave.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    ColorWave.colors.resize(2);
-    modes.push_back(ColorWave);
-
-    mode Visor;
-    Visor.name       = "Visor";
-    Visor.value      = CORSAIR_PRO_MODE_VISOR;
-    Visor.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Visor.speed_min  = CORSAIR_PRO_SPEED_SLOW;
-    Visor.speed_max  = CORSAIR_PRO_SPEED_FAST;
-    Visor.colors_min = 2;
-    Visor.colors_max = 2;
-    Visor.speed      = CORSAIR_PRO_SPEED_SLOW;
-    Visor.direction  = MODE_DIRECTION_VERTICAL;
-    Visor.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Visor.colors.resize(2);
-    modes.push_back(Visor);
-
-    mode Rain;
-    Rain.name       = "Rain";
-    Rain.value      = CORSAIR_PRO_MODE_RAIN;
-    Rain.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Rain.speed_min  = CORSAIR_PRO_SPEED_SLOW;
-    Rain.speed_max  = CORSAIR_PRO_SPEED_FAST;
-    Rain.colors_min = 2;
-    Rain.colors_max = 2;
-    Rain.speed      = CORSAIR_PRO_SPEED_SLOW;
-    Rain.direction  = MODE_DIRECTION_DOWN;
-    Rain.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Rain.colors.resize(2);
-    modes.push_back(Rain);
-
-    mode Marquee;
-    Marquee.name       = "Marquee";
-    Marquee.value      = CORSAIR_PRO_MODE_MARQUEE;
-    Marquee.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Marquee.speed_min  = CORSAIR_PRO_SPEED_SLOW;
-    Marquee.speed_max  = CORSAIR_PRO_SPEED_FAST;
-    Marquee.colors_min = 1;
-    Marquee.colors_max = 1;
-    Marquee.speed      = CORSAIR_PRO_SPEED_SLOW;
-    Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Marquee.colors.resize(1);
-    modes.push_back(Marquee);
-
-    mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = CORSAIR_PRO_MODE_RAINBOW;
-    Rainbow.flags      = MODE_FLAG_HAS_SPEED;
-    Rainbow.speed_min  = CORSAIR_PRO_SPEED_SLOW;
-    Rainbow.speed_max  = CORSAIR_PRO_SPEED_FAST;
-    Rainbow.speed      = CORSAIR_PRO_SPEED_SLOW;
-    Rainbow.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Rainbow);
-
-    mode Sequential;
-    Sequential.name       = "Sequential";
-    Sequential.value      = CORSAIR_PRO_MODE_SEQUENTIAL;
-    Sequential.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Sequential.speed_min  = CORSAIR_PRO_SPEED_SLOW;
-    Sequential.speed_max  = CORSAIR_PRO_SPEED_FAST;
-    Sequential.colors_min = 1;
-    Sequential.colors_max = 1;
-    Sequential.speed      = CORSAIR_PRO_SPEED_SLOW;
-    Sequential.direction  = MODE_DIRECTION_DOWN;
-    Sequential.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Sequential.colors.resize(1);
-    modes.push_back(Sequential);
-
-    SetupZones();
-
-    active_mode = 9;
-}
-
-RGBController_CorsairVengeancePro::~RGBController_CorsairVengeancePro()
-{
-    Shutdown();
-
-    delete controller;
-}
-
-void RGBController_CorsairVengeancePro::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zone                                               |
-    \*---------------------------------------------------------*/
-    zone new_zone;
-    new_zone.name           = "Corsair Pro Zone";
-    new_zone.type           = ZONE_TYPE_LINEAR;
-    new_zone.leds_min       = controller->GetLEDCount();
-    new_zone.leds_max       = controller->GetLEDCount();
-    new_zone.leds_count     = controller->GetLEDCount();
-    zones.push_back(new_zone);
-
-    /*---------------------------------------------------------*\
-    | Set up LEDs                                               |
-    \*---------------------------------------------------------*/
-    for(std::size_t led_idx = 0; led_idx < zones[0].leds_count; led_idx++)
-    {
-        led* new_led        = new led();
-        new_led->name       = "Corsair Pro LED ";
-        new_led->name.append(std::to_string(led_idx));
-        leds.push_back(*new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_CorsairVengeancePro::DeviceUpdateLEDs()
-{
-    for(unsigned int led = 0; led < (unsigned int)colors.size(); led++)
-    {
-        RGBColor      color = colors[led];
-        unsigned char red   = RGBGetRValue(color);
-        unsigned char grn   = RGBGetGValue(color);
-        unsigned char blu   = RGBGetBValue(color);
-        controller->SetLEDColor(led, red, grn, blu);
-    }
-
-    controller->ApplyColors();
-}
-
-void RGBController_CorsairVengeancePro::DeviceUpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_CorsairVengeancePro::DeviceUpdateSingleLED(int led)
-{
-    RGBColor      color = colors[led];
-    unsigned char red   = RGBGetRValue(color);
-    unsigned char grn   = RGBGetGValue(color);
-    unsigned char blu   = RGBGetBValue(color);
-
-    controller->SetLEDColor(led, red, grn, blu);
-    controller->ApplyColors();
-}
-
-void RGBController_CorsairVengeancePro::DeviceUpdateMode()
-{
-    unsigned int  corsair_direction = 0;
-    bool          random            = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-    unsigned char mode_colors[6];
-
-    switch(modes[active_mode].direction)
-    {
-        case MODE_DIRECTION_LEFT:
-            corsair_direction = CORSAIR_PRO_DIRECTION_LEFT;
-            break;
-        case MODE_DIRECTION_RIGHT:
-            corsair_direction = CORSAIR_PRO_DIRECTION_RIGHT;
-            break;
-        case MODE_DIRECTION_UP:
-            corsair_direction = CORSAIR_PRO_DIRECTION_UP;
-            break;
-        case MODE_DIRECTION_DOWN:
-            corsair_direction = CORSAIR_PRO_DIRECTION_DOWN;
-            break;
-        case MODE_DIRECTION_HORIZONTAL:
-            corsair_direction = CORSAIR_PRO_DIRECTION_HORIZONTAL;
-            break;
-        case MODE_DIRECTION_VERTICAL:
-            corsair_direction = CORSAIR_PRO_DIRECTION_VERTICAL;
-            break;
-    }
-
-    mode_colors[0] = 0;
-    mode_colors[1] = 0;
-    mode_colors[2] = 0;
-    mode_colors[3] = 0;
-    mode_colors[4] = 0;
-    mode_colors[5] = 0;
-
-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        mode_colors[0] = RGBGetRValue(modes[active_mode].colors[0]);
-        mode_colors[1] = RGBGetGValue(modes[active_mode].colors[0]);
-        mode_colors[2] = RGBGetBValue(modes[active_mode].colors[0]);
-
-        if(modes[active_mode].colors.size() == 2)
-        {
-            mode_colors[3] = RGBGetRValue(modes[active_mode].colors[1]);
-            mode_colors[4] = RGBGetGValue(modes[active_mode].colors[1]);
-            mode_colors[5] = RGBGetBValue(modes[active_mode].colors[1]);
-        }
-    }
-
-    if (modes[active_mode].name == "Direct")
-    {
-        controller->SetDirect(true);
-    }
-    else
-    {
-        controller->SetDirect(false);
-    }
-
-    controller->SetEffect(modes[active_mode].value,
-                          modes[active_mode].speed,
-                          corsair_direction,
-                          random,
-                          mode_colors[0],
-                          mode_colors[1],
-                          mode_colors[2],
-                          mode_colors[3],
-                          mode_colors[4],
-                          mode_colors[5]);
-
-    std::this_thread::sleep_for(std::chrono::milliseconds(15));
-}

Controllers/CorsairVengeanceProController/RGBController_CorsairVengeancePro.h

@@ -1,33 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_CorsairVengeancePro.h                       |
-|                                                           |
-|   RGBController for Corsair Vengeance Pro RGB RAM         |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "CorsairVengeanceProController.h"
-
-class RGBController_CorsairVengeancePro : public RGBController
-{
-public:
-    RGBController_CorsairVengeancePro(CorsairVengeanceProController* controller_ptr);
-    ~RGBController_CorsairVengeancePro();
-
-    void        SetupZones();
-
-    void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    CorsairVengeanceProController* controller;
-};

Controllers/CreativeController/RGBController_CreativeSoundBlasterAE5_Windows.cpp

@@ -87,7 +87,8 @@ void RGBController_CreativeSoundBlasterAE5::SetupZones()
         zones[1].flags                  = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
     }
 
     if(!(zones[1].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/CrucialController/CrucialControllerDetect.cpp

@@ -137,19 +137,19 @@ void CrucialRegisterWrite(i2c_smbus_interface* bus, unsigned char dev, unsigned
     bus->i2c_smbus_write_byte_data(dev, 0x01, val);
 }
 
-DetectedControllers DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses)
+DetectedControllers DetectCrucialControllers(std::vector<i2c_smbus_interface*> &buses)
 {
     DetectedControllers detected_controllers;
 
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
         int address_list_idx = -1;
 
-        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        IF_DRAM_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
         {
             for(unsigned int slot = 0; slot < 4; slot++)
             {
-                int res = busses[bus]->i2c_smbus_write_quick(0x27, I2C_SMBUS_WRITE);
+                int res = buses[bus]->i2c_smbus_write_quick(0x27, I2C_SMBUS_WRITE);
 
                 if(res < 0)
                 {
@@ -163,7 +163,7 @@ DetectedControllers DetectCrucialControllers(std::vector<i2c_smbus_interface*> &
 
                     if(address_list_idx < CRUCIAL_ADDRESS_COUNT)
                     {
-                        res = busses[bus]->i2c_smbus_write_quick(crucial_addresses[address_list_idx], I2C_SMBUS_WRITE);
+                        res = buses[bus]->i2c_smbus_write_quick(crucial_addresses[address_list_idx], I2C_SMBUS_WRITE);
                     }
                     else
                     {
@@ -174,24 +174,24 @@ DetectedControllers DetectCrucialControllers(std::vector<i2c_smbus_interface*> &
                 if(address_list_idx < CRUCIAL_ADDRESS_COUNT)
                 {
                     LOG_DEBUG("[%s] Remapping slot %d to address %02X", CRUCIAL_CONTROLLER_NAME, slot, crucial_addresses[address_list_idx]);
-                    CrucialRegisterWrite(busses[bus], 0x27, 0x82EE, slot);
-                    CrucialRegisterWrite(busses[bus], 0x27, 0x82EF, (crucial_addresses[address_list_idx] << 1));
-                    CrucialRegisterWrite(busses[bus], 0x27, 0x82F0, 0xF0);
+                    CrucialRegisterWrite(buses[bus], 0x27, 0x82EE, slot);
+                    CrucialRegisterWrite(buses[bus], 0x27, 0x82EF, (crucial_addresses[address_list_idx] << 1));
+                    CrucialRegisterWrite(buses[bus], 0x27, 0x82F0, 0xF0);
                 }
 
                 std::this_thread::sleep_for(1ms);
             }
 
-            LOG_DEBUG("[%s] In bus: %02X:%02X looking for devices at [%s]", CRUCIAL_CONTROLLER_NAME, busses[bus]->pci_vendor, busses[bus]->pci_device, TESTING_ADDRESSES);
+            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);
 
             // Add Crucial controllers
             for(unsigned int address_list_idx = 0; address_list_idx < CRUCIAL_ADDRESS_COUNT; address_list_idx++)
             {
                 LOG_DEBUG("[%s] Testing address %02X to see if there is a device there", CRUCIAL_CONTROLLER_NAME, crucial_addresses[address_list_idx]);
 
-                if(TestForCrucialController(busses[bus], crucial_addresses[address_list_idx]))
+                if(TestForCrucialController(buses[bus], crucial_addresses[address_list_idx]))
                 {
-                    CrucialController*     controller     = new CrucialController(busses[bus], crucial_addresses[address_list_idx]);
+                    CrucialController*     controller     = new CrucialController(buses[bus], crucial_addresses[address_list_idx]);
                     RGBController_Crucial* rgb_controller = new RGBController_Crucial(controller);
 
                     detected_controllers.push_back(rgb_controller);

Controllers/DRGBController/RGBController_DRGB.cpp

@@ -85,7 +85,8 @@ void RGBController_DRGB::SetupZones()
             zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/DebugController/RGBController_Debug.cpp

@@ -602,7 +602,8 @@ void RGBController_Debug::SetupZones()
                 resizable_zone.flags    = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
                 zones.push_back(resizable_zone);
             }
 

Controllers/ENESMBusController/ENESMBusController.cpp

@@ -266,6 +266,21 @@ ENESMBusController::ENESMBusController(ENESMBusInterface* interface, ene_dev_id
         led_count = config_table[ENE_CONFIG_LED_COUNT_0107];
     }
     /*-----------------------------------------------------*\
+    | AUMA0-E6K5-1114                                       |
+    | Found on ASUS ROG MATRIX PLATINUM 5090                |
+    \*-----------------------------------------------------*/
+    else if(strcmp(device_version, "AUMA0-E6K5-1114") == 0)
+    {
+        direct_reg  = ENE_REG_COLORS_DIRECT_V2;
+        effect_reg  = ENE_REG_COLORS_EFFECT_V2;
+        channel_cfg = ENE_CONFIG_CHANNEL_V2;
+
+        /*-------------------------------------------------*\
+        | Read LED count from configuration table           |
+        \*-------------------------------------------------*/
+        led_count = config_table[ENE_CONFIG_LED_COUNT_0107];
+    }
+    /*-----------------------------------------------------*\
     | ROG ARION - ASUS ROG Arion external SSD enclosure     |
     | This device does not support ENE read, so we fake the |
     | device name string if the interface is ROG Arion type.|

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -36,7 +36,7 @@ using namespace std::chrono_literals;
 | This list contains the available SMBus addresses for      |
 | mapping ENE RAM                                           |
 \*---------------------------------------------------------*/
-#define ENE_RAM_ADDRESS_COUNT  23
+#define ENE_RAM_ADDRESS_COUNT  (sizeof(ene_ram_addresses) / sizeof(ene_ram_addresses[0]))
 
 static const unsigned char ene_ram_addresses[] =
 {
@@ -47,14 +47,7 @@ static const unsigned char ene_ram_addresses[] =
     0x74,
     0x75,
     0x76,
-    0x78,
-    0x79,
-    0x7A,
-    0x7B,
-    0x7C,
-    0x7D,
-    0x7E,
-    0x7F,
+    0x77,
     0x4F,
     0x66,
     0x67,
@@ -69,7 +62,7 @@ static const unsigned char ene_ram_addresses[] =
 | This list contains the available SMBus addresses for      |
 | mapping Aura motherboards                                 |
 \*---------------------------------------------------------*/
-#define AURA_MOBO_ADDRESS_COUNT 3
+#define AURA_MOBO_ADDRESS_COUNT (sizeof(aura_mobo_addresses) / sizeof(aura_mobo_addresses[0]))
 
 static const unsigned char aura_mobo_addresses[] =
 {
@@ -153,21 +146,21 @@ bool TestForENESMBusController(i2c_smbus_interface* bus, unsigned char address)
     return(pass);
 }
 
-DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
+DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interface*> &buses)
 {
     DetectedControllers detected_controllers;
 
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
         int address_list_idx = -1;
 
-        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        IF_DRAM_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
         {
             LOG_DEBUG("[ENE SMBus DRAM] Remapping ENE SMBus RAM modules on 0x77");
 
             for(unsigned int slot = 0; slot < 8; slot++)
             {
-                int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
+                int res = buses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
 
                 if(res < 0)
                 {
@@ -179,11 +172,11 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
                 {
                     address_list_idx++;
 
-                    if(address_list_idx < ENE_RAM_ADDRESS_COUNT)
+                    if(address_list_idx < (int)ENE_RAM_ADDRESS_COUNT)
                     {
                         LOG_DEBUG("[ENE SMBus DRAM] Testing address %02X to see if there is a device there", ene_ram_addresses[address_list_idx]);
 
-                        res = busses[bus]->i2c_smbus_write_quick(ene_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
+                        res = buses[bus]->i2c_smbus_write_quick(ene_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
                     }
                     else
                     {
@@ -191,21 +184,21 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
                     }
                 } while(res >= 0);
 
-                if(address_list_idx < ENE_RAM_ADDRESS_COUNT)
+                if(address_list_idx < (int)ENE_RAM_ADDRESS_COUNT)
                 {
                     LOG_DEBUG("[ENE SMBus DRAM] Remapping slot %d to address %02X", slot, ene_ram_addresses[address_list_idx]);
 
-                    ENERegisterWrite(busses[bus], 0x77, ENE_REG_SLOT_INDEX, slot);
-                    ENERegisterWrite(busses[bus], 0x77, ENE_REG_I2C_ADDRESS, (ene_ram_addresses[address_list_idx] << 1));
+                    ENERegisterWrite(buses[bus], 0x77, ENE_REG_SLOT_INDEX, slot);
+                    ENERegisterWrite(buses[bus], 0x77, ENE_REG_I2C_ADDRESS, (ene_ram_addresses[address_list_idx] << 1));
                 }
             }
 
             // Add ENE controllers at their remapped addresses
             for(unsigned int address_list_idx = 0; address_list_idx < ENE_RAM_ADDRESS_COUNT; address_list_idx++)
             {
-                if(TestForENESMBusController(busses[bus], ene_ram_addresses[address_list_idx]))
+                if(TestForENESMBusController(buses[bus], ene_ram_addresses[address_list_idx]))
                 {
-                    ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(busses[bus]);
+                    ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(buses[bus]);
                     ENESMBusController*          controller     = new ENESMBusController(interface, ene_ram_addresses[address_list_idx], "ENE DRAM", DEVICE_TYPE_DRAM);
                     RGBController_ENESMBus*      rgb_controller = new RGBController_ENESMBus(controller);
 
@@ -220,26 +213,26 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
     return(detected_controllers);
 }
 
-DetectedControllers DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &busses)
+DetectedControllers DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &buses)
 {
     DetectedControllers detected_controllers;
 
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
         // Add ENE (ASUS Aura) motherboard controllers
-        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
         {
-            if(busses[bus]->pci_subsystem_vendor == ASUS_SUB_VEN || busses[bus]->pci_subsystem_vendor == 0 || busses[bus]->pci_subsystem_vendor == 0xFFFF)
+            if(buses[bus]->pci_subsystem_vendor == ASUS_SUB_VEN || buses[bus]->pci_subsystem_vendor == 0 || buses[bus]->pci_subsystem_vendor == 0xFFFF)
             {
                 for(unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
                 {
                     LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, aura_mobo_addresses[address_list_idx]);
 
-                    if(TestForENESMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
+                    if(TestForENESMBusController(buses[bus], aura_mobo_addresses[address_list_idx]))
                     {
                         DMIInfo dmi;
 
-                        ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(busses[bus]);
+                        ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(buses[bus]);
                         ENESMBusController*          controller     = new ENESMBusController(interface, aura_mobo_addresses[address_list_idx], "ASUS " + dmi.getMainboard(), DEVICE_TYPE_MOTHERBOARD);
                         RGBController_ENESMBus*      rgb_controller = new RGBController_ENESMBus(controller);
 

Controllers/EVGASMBusController/EVGASMBusControllerDetect.cpp

@@ -40,21 +40,21 @@ bool TestForAcx30SMBusController(i2c_smbus_interface *bus, uint8_t address)
     return(pass);
 }
 
-DetectedControllers DetectAcx30SMBusControllers(std::vector<i2c_smbus_interface *> &busses)
+DetectedControllers DetectAcx30SMBusControllers(std::vector<i2c_smbus_interface *> &buses)
 {
     DetectedControllers detected_controllers;
 
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
-        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
         {
-            if(busses[bus]->pci_subsystem_vendor == EVGA_SUB_VEN)
+            if(buses[bus]->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
-                if(TestForAcx30SMBusController(busses[bus], SMBUS_ADDRESS))
+                if(TestForAcx30SMBusController(buses[bus], SMBUS_ADDRESS))
                 {
-                    EVGAACX30SMBusController *     controller     = new EVGAACX30SMBusController(busses[bus], SMBUS_ADDRESS);
+                    EVGAACX30SMBusController *     controller     = new EVGAACX30SMBusController(buses[bus], SMBUS_ADDRESS);
                     RGBController_EVGAACX30SMBus * rgb_controller = new RGBController_EVGAACX30SMBus(controller);
 
                     detected_controllers.push_back(rgb_controller);

Controllers/GaiZongGaiKeyboardController/RGBController_GaiZhongGai.cpp

@@ -572,7 +572,8 @@ void RGBController_GaiZhongGaiKeyboard::SetupZones()
                     zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                             | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                             | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
                 }
 
                 if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
@@ -608,7 +609,8 @@ void RGBController_GaiZhongGaiKeyboard::SetupZones()
                     zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                             | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                             | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
                 }
 
                 if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/GigabyteRGBFusion2BlackwellGPUController/GigabyteRGBFusion2BlackwellGPUControllerDetect.cpp

@@ -134,4 +134,5 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9060 XT GAMING",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9060 XT GAMING OC",                   DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        AMD_GPU_VEN, AMD_NAVI44_DEV,        GIGABYTE_SUB_VEN, GIGABYTE_RX9060XT_GAMING_OC_16G_SUB_DEV,          0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS Radeon RX 9070 XT Elite",                 DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        AMD_GPU_VEN, AMD_NAVI48_DEV,        GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RX9070XT_ELITE_16G_SUB_DEV,        0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9070 XT GAMING OC",                   DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        AMD_GPU_VEN, AMD_NAVI48_DEV,        GIGABYTE_SUB_VEN, GIGABYTE_RX9070XT_GAMING_OC_16G_SUB_DEV,          0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9070 XT GAMING OC ICE",               DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        AMD_GPU_VEN, AMD_NAVI48_DEV,        GIGABYTE_SUB_VEN, GIGABYTE_RX9070XT_GAMING_OC_ICE_16G_SUB_DEV,      0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9070 XT GAMING",                      DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        AMD_GPU_VEN, AMD_NAVI48_DEV,        GIGABYTE_SUB_VEN, GIGABYTE_RX9070XT_GAMING_16G_SUB_DEV,             0x75);

Controllers/GigabyteRGBFusion2DRAMController/GigabyteRGBFusion2DRAMControllerDetect.cpp

@@ -48,18 +48,18 @@ bool TestForGigabyteRGBFusion2DRAMController(i2c_smbus_interface* bus, unsigned
     return(pass);
 }
 
-DetectedControllers DetectGigabyteRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>& busses)
+DetectedControllers DetectGigabyteRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>& buses)
 {
     DetectedControllers detected_controllers;
 
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
-        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        IF_DRAM_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
         {
             // Check for RGB Fusion 2 DRAM controller at 0x67
-            if(TestForGigabyteRGBFusion2DRAMController(busses[bus], 0x67))
+            if(TestForGigabyteRGBFusion2DRAMController(buses[bus], 0x67))
             {
-                RGBFusion2DRAMController*     controller     = new RGBFusion2DRAMController(busses[bus], 0x67);
+                RGBFusion2DRAMController*     controller     = new RGBFusion2DRAMController(buses[bus], 0x67);
                 RGBController_RGBFusion2DRAM* rgb_controller = new RGBController_RGBFusion2DRAM(controller);
 
                 detected_controllers.push_back(rgb_controller);

Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp

@@ -180,4 +180,5 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RX 6750 XT ELITE 12G",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RX 6900 XT EXTREME WATERFORCE WB",           DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI21_DEV2,           GIGABYTE_SUB_VEN,   GIGABYTE_RX6900XT_XTREME_WATERFORCE_WB_SUB_DEV, 0x70);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS Radeon RX 9070 XT Elite",                    DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI48_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RX9070XT_ELITE_16G_SUB_DEV,      0x73);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9070 XT GAMING OC",                      DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI48_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX9070XT_GAMING_OC_16G_SUB_DEV,        0x73);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9070 XT GAMING OC ICE",                  DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI48_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX9070XT_GAMING_OC_ICE_16G_SUB_DEV,    0x73);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9070 GAMING OC",                         DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI48_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX9070_GAMING_OC_16G_SUB_DEV,          0x73);

Controllers/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusControllerDetect.cpp

@@ -74,7 +74,7 @@ bool TestForGigabyteRGBFusion2SMBusController(i2c_smbus_interface* bus, unsigned
     return(pass);
 }
 
-DetectedControllers DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses)
+DetectedControllers DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& buses)
 {
     DetectedControllers                 detected_controllers;
     SettingsManager*                    set_man = ResourceManager::get()->GetSettingsManager();
@@ -112,18 +112,18 @@ DetectedControllers DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smb
     if(found)
     {
         LOG_DEBUG(GIGABYTE_FOUND_MB_MESSAGE_EN, DETECTOR_NAME, dmi.getMainboard().c_str());
-        for(unsigned int bus = 0; bus < busses.size(); bus++)
+        for(unsigned int bus = 0; bus < buses.size(); bus++)
         {
-            IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+            IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
             {
-                if(busses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
+                if(buses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
                 {
                     /*-------------------------------------*\
                     | TODO - Is this necessary? Or an       |
                     | artifact of my own system?  Skip dmcd |
                     | devices                               |
                     \*-------------------------------------*/
-                    std::string device_name = std::string(busses[bus]->device_name);
+                    std::string device_name = std::string(buses[bus]->device_name);
 
                     if(device_name.find("dmdc") == std::string::npos)
                     {
@@ -133,9 +133,9 @@ DetectedControllers DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smb
                         | Check for RGB Fusion 2 controller |
                         | at 0x68                           |
                         \*---------------------------------*/
-                        if(TestForGigabyteRGBFusion2SMBusController(busses[bus], SMBUS_ADDRESS))
+                        if(TestForGigabyteRGBFusion2SMBusController(buses[bus], SMBUS_ADDRESS))
                         {
-                            RGBFusion2SMBusController*     controller     = new RGBFusion2SMBusController(busses[bus], SMBUS_ADDRESS, dmi.getMainboard() );
+                            RGBFusion2SMBusController*     controller     = new RGBFusion2SMBusController(buses[bus], SMBUS_ADDRESS, dmi.getMainboard() );
                             RGBController_RGBFusion2SMBus* rgb_controller = new RGBController_RGBFusion2SMBus(controller);
 
                             detected_controllers.push_back(rgb_controller);

Controllers/GigabyteRGBFusion2USBController/GigabyteFusion2USB_Devices.cpp

@@ -2065,6 +2065,51 @@ static const gb_fusion2_device x570_aorus_ultra_device =
     "X570 AORUS ULTRA",
 };
 
+/*-------------------------------------------------------------*\
+|  X570_AORUS_XTREME    048D:8297                               |
+|                                                               |
+|    Zone "Digital LED 1"           : Linear                    |
+|    Zone "Digital LED 2"           : Linear                    |
+|    Zone "Back I/O"                : Single                    |
+|    Zone "PCIe"                    : Single                    |
+|    Zone "CPU Header"              : Single                    |
+\*-------------------------------------------------------------*/
+static const gb_fusion2_zone xtreme_back_io_zone =
+{
+    LED3,
+    1,
+    1,
+    "Back I/O",
+};
+
+static const gb_fusion2_zone xtreme_cpu_hdr_zone =
+{
+    LED7,
+    1,
+    1,
+    "CPU Header",
+};
+
+static gb_fusion2_layout x570_aorus_xtreme_layout =
+{
+    &common_d_led1_zone,
+    &common_d_led2_zone,
+    &xtreme_back_io_zone,
+    &common_pcie_led4_zone,
+    &xtreme_cpu_hdr_zone,
+    nullptr,
+    nullptr,
+    nullptr
+};
+
+static const gb_fusion2_device x570_aorus_xtreme_device =
+{
+    &x570_aorus_xtreme_layout,
+    0xCDE4CFFE,
+    1,
+    "X570 AORUS XTREME",
+};
+
 /*-------------------------------------------------------------------------*\
 |  Generic Layout (Used when no match found)                                |
 \*-------------------------------------------------------------------------*/
@@ -3831,6 +3876,7 @@ const gb_fusion2_device* gb_fusion2_device_list_data[] =
     &x570_aorus_pro_device,
     &x570_aorus_pro_wifi_device,
     &x570_aorus_ultra_device,
+    &x570_aorus_xtreme_device,
     &x570i_aorus_pro_wifi_device,
     &z390_aorus_master_cf_device,
 

Controllers/GigabyteRGBFusion2USBController/RGBController_GigabyteRGBFusion2USB.cpp

@@ -406,7 +406,8 @@ void RGBController_RGBFusion2USB::SetupZones()
                 zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
             }
 
             if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/GigabyteRGBFusionController/GigabyteRGBFusionControllerDetect.cpp

@@ -43,24 +43,24 @@ bool TestForGigabyteRGBFusionController(i2c_smbus_interface* bus, unsigned char
     return(pass);
 }
 
-DetectedControllers DetectGigabyteRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses)
+DetectedControllers DetectGigabyteRGBFusionControllers(std::vector<i2c_smbus_interface*>& buses)
 {
     DetectedControllers detected_controllers;
 
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
-        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
         {
-            if(busses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
+            if(buses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
             {
                 LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
 
                 /*-----------------------------------------*\
                 | Check for RGB Fusion controller at 0x28   |
                 \*-----------------------------------------*/
-                if(TestForGigabyteRGBFusionController(busses[bus], SMBUS_ADDRESS))
+                if(TestForGigabyteRGBFusionController(buses[bus], SMBUS_ADDRESS))
                 {
-                    RGBFusionController*     controller     = new RGBFusionController(busses[bus], SMBUS_ADDRESS);
+                    RGBFusionController*     controller     = new RGBFusionController(buses[bus], SMBUS_ADDRESS);
                     RGBController_RGBFusion* rgb_controller = new RGBController_RGBFusion(controller);
 
                     detected_controllers.push_back(rgb_controller);

Controllers/HyperXKeyboardController/HyperXAlloyOrigins60and65Controller/HyperXAlloyOrigins60and65Controller.cpp

@@ -17,7 +17,7 @@ HyperXAlloyOrigins60and65Controller::HyperXAlloyOrigins60and65Controller(hid_dev
 {
     dev         = dev_handle;
     location    = path;
-    dev_name    = name;
+    name        = dev_name;
 }
 
 HyperXAlloyOrigins60and65Controller::~HyperXAlloyOrigins60and65Controller()

Controllers/JGINYUEInternalUSBController/RGBController_JGINYUEInternalUSB.cpp

@@ -215,7 +215,8 @@ void RGBController_JGINYUEInternalUSB::SetupZones()
             zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/JGINYUEInternalUSBV2Controller/RGBController_JGINYUEInternalUSBV2.cpp

@@ -407,7 +407,8 @@ void RGBController_JGINYUEInternalUSBV2::SetupZones()
             zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/LEDStripController/LEDStripController.cpp

@@ -102,13 +102,13 @@ void LEDStripController::Initialize(char* ledstring, led_protocol proto)
 
 void LEDStripController::InitializeI2C(char* i2cname)
 {
-    for(unsigned int i2c_idx = 0; i2c_idx < ResourceManager::get()->GetI2CBusses().size(); i2c_idx++)
+    for(unsigned int i2c_idx = 0; i2c_idx < ResourceManager::get()->GetI2CBuses().size(); i2c_idx++)
     {
-        if(ResourceManager::get()->GetI2CBusses()[i2c_idx]->device_name == std::string(i2cname))
+        if(ResourceManager::get()->GetI2CBuses()[i2c_idx]->device_name == std::string(i2cname))
         {
             if(i2c_addr < 128)
             {
-                i2cport = ResourceManager::get()->GetI2CBusses()[i2c_idx];
+                i2cport = ResourceManager::get()->GetI2CBuses()[i2c_idx];
                 break;
             }
         }

Controllers/LenovoControllers/LenovoDevices.h

@@ -38,6 +38,7 @@
 #define LEGION_7GEN9                            0xC997
 #define LEGION_7GEN9_H                          0xC998
 #define LEGION_7GEN10                           0xC197
+#define LEGION_5GEN10                           0xC195
 
 enum LENOVO_KEYBOARD
 {

Controllers/LenovoControllers/LenovoUSBControllerDetect.cpp

@@ -77,3 +77,4 @@ REGISTER_HID_DETECTOR_PU("Lenovo Legion 7S Gen 8",  DetectLenovoLegionUSBControl
 REGISTER_HID_DETECTOR_PU("Lenovo Legion 7 Gen 9",   DetectLenovoLegionUSBControllersGen7And8, ITE_VID, LEGION_7GEN9,   LENOVO_PAGE, LENOVO_USAGE);
 REGISTER_HID_DETECTOR_PU("Lenovo Legion 7 Gen 9",   DetectLenovoLegionUSBControllersGen7And8, ITE_VID, LEGION_7GEN9_H, LENOVO_PAGE, LENOVO_USAGE);
 REGISTER_HID_DETECTOR_PU("Lenovo Legion 7 Gen 10",  DetectLenovoLegionUSBControllersGen7And8, ITE_VID, LEGION_7GEN10,  LENOVO_PAGE, LENOVO_USAGE);
+REGISTER_HID_DETECTOR_PU("Lenovo Legion 5 Gen 10", DetectLenovoLegionUSBControllersGen7And8, ITE_VID, LEGION_5GEN10, LENOVO_PAGE, LENOVO_USAGE);

Controllers/LenovoControllers/LenovoUSBController_Gen7_8/LenovoUSBController_Gen7_8.cpp

@@ -17,7 +17,7 @@ using namespace std;
 
 static void SetGen10PayloadLength(uint16_t pid, uint8_t* buffer, uint16_t payload_length)
 {
-    if(pid != LEGION_7GEN10)
+    if(pid != LEGION_7GEN10 && pid != LEGION_5GEN10)
     {
         return;
     }
@@ -26,6 +26,11 @@ static void SetGen10PayloadLength(uint16_t pid, uint8_t* buffer, uint16_t payloa
     buffer[3] = (payload_length >> 8) & 0xFF;
 }
 
+static bool UsesGen10PacketFormat(uint16_t pid)
+{
+    return pid == LEGION_7GEN10 || pid == LEGION_5GEN10;
+}
+
 LenovoGen7And8USBController::LenovoGen7And8USBController(hid_device* dev_handle, const char* path, uint16_t in_pid, std::string dev_name)
 {
     dev                     = dev_handle;
@@ -114,7 +119,7 @@ void LenovoGen7And8USBController::setLedsByGroup(uint8_t profile_id, vector<led_
             i+= led_count * sizeof(uint16_t);
         }
 
-        if(pid == LEGION_7GEN10)
+        if(UsesGen10PacketFormat(pid))
         {
             SetGen10PayloadLength(pid, buffer, static_cast<uint16_t>(i - 4));
         }
@@ -162,7 +167,7 @@ void LenovoGen7And8USBController::setLedsDirectOff(uint8_t profile_id)
 
 void LenovoGen7And8USBController::setLedsDirect(std::vector<led> &leds, std::vector<RGBColor> &colors)
 {
-    if(pid == LEGION_7GEN10)
+    if(UsesGen10PacketFormat(pid))
     {
         /*---------------------------------------------------------*\
         | Gen10 uses 0x07/A1 direct updates, with payload length     |

Controllers/LenovoControllers/LenovoUSBController_Gen7_8/RGBController_Lenovo_Gen7_8.cpp

@@ -13,6 +13,78 @@
 
 using namespace std;
 
+static bool UsesGen10PacketFormat(uint16_t pid)
+{
+    return pid == LEGION_7GEN10 || pid == LEGION_5GEN10;
+}
+
+static bool Is24ZoneDevice(uint16_t pid)
+{
+    return pid == LEGION_5GEN10;
+}
+
+static bool IsKeyboardOnlyDevice(uint16_t pid)
+{
+    return pid == LEGION_5GEN10;
+}
+
+static const lenovo_led legion_5gen10_24zone_leds[] =
+{
+    {0x01, "Zone R1C1"},
+    {0x02, "Zone R1C2"},
+    {0x03, "Zone R1C3"},
+    {0x04, "Zone R1C4"},
+    {0x05, "Zone R1C5"},
+    {0x06, "Zone R1C6"},
+    {0x07, "Zone R2C1"},
+    {0x08, "Zone R2C2"},
+    {0x09, "Zone R2C3"},
+    {0x0A, "Zone R2C4"},
+    {0x0B, "Zone R2C5"},
+    {0x0C, "Zone R2C6"},
+    {0x0D, "Zone R3C1"},
+    {0x0E, "Zone R3C2"},
+    {0x0F, "Zone R3C3"},
+    {0x10, "Zone R3C4"},
+    {0x11, "Zone R3C5"},
+    {0x12, "Zone R3C6"},
+    {0x13, "Zone R4C1"},
+    {0x14, "Zone R4C2"},
+    {0x15, "Zone R4C3"},
+    {0x16, "Zone R4C4"},
+    {0x17, "Zone R4C5"},
+    {0x18, "Zone R4C6"},
+};
+
+static const unsigned int legion_5gen10_24zone_matrix_map[] =
+{
+    0, 1, 2, 3, 4, 5,
+    6, 7, 8, 9, 10, 11,
+    12, 13, 14, 15, 16, 17,
+    18, 19, 20, 21, 22, 23,
+};
+
+static const lenovo_zone legion_5gen10_kbd_24zone =
+{
+    "Keyboard (24-zone)",
+    ZONE_TYPE_MATRIX,
+    0,
+    4,
+    6,
+    legion_5gen10_24zone_matrix_map,
+    legion_5gen10_24zone_leds,
+    0,
+    23,
+};
+
+static const RGBColor legion_5gen10_zone_visualization_colors[24] =
+{
+    0xFF0000, 0x00FFFF, 0xFFFF00, 0x0000FF, 0x00FF00, 0xFF00FF,
+    0xFF7F00, 0x007FFF, 0x7FFF00, 0x7F00FF, 0xFF007F, 0x00FF7F,
+    0xFFD700, 0x0055FF, 0x55FF00, 0xFF0055, 0x00BFFF, 0xBF00FF,
+    0xFF3B00, 0x00FF3B, 0x3B00FF, 0xFF1493, 0x14FF93, 0x9314FF,
+};
+
 LenovoRGBController_Gen7_8::LenovoRGBController_Gen7_8(LenovoGen7And8USBController* controller_ptr)
 {
     controller = controller_ptr;
@@ -139,72 +211,79 @@ LenovoRGBController_Gen7_8::LenovoRGBController_Gen7_8(LenovoGen7And8USBControll
     Smooth.brightness = brightness;
     modes.push_back(Smooth);
 
-    mode Rain;
-    Rain.name = "Rain";
-    Rain.value = LENOVO_LEGION_GEN7_8_MODE_RAIN;
-    Rain.flags = MODE_FLAG_HAS_SPEED |
-        MODE_FLAG_HAS_MODE_SPECIFIC_COLOR |
-        MODE_FLAG_HAS_RANDOM_COLOR |
-        MODE_FLAG_HAS_BRIGHTNESS |
-        MODE_FLAG_AUTOMATIC_SAVE;
-    Rain.speed_min = 0x01;
-    Rain.speed_max = 0x03;
-    Rain.speed = 2;
-    Rain.colors_min = 1;
-    Rain.colors_max = 4;
-    Rain.colors.resize(4);
-    Rain.colors[0] = 0xFFF500;
-    Rain.color_mode = MODE_COLORS_RANDOM;
-    Rain.brightness_min = 0;
-    Rain.brightness_max = 9;
-    Rain.brightness = brightness;
-    modes.push_back(Rain);
+    if(!Is24ZoneDevice(controller->getPid()))
+    {
+        mode Rain;
+        Rain.name = "Rain";
+        Rain.value = LENOVO_LEGION_GEN7_8_MODE_RAIN;
+        Rain.flags = MODE_FLAG_HAS_SPEED |
+            MODE_FLAG_HAS_MODE_SPECIFIC_COLOR |
+            MODE_FLAG_HAS_RANDOM_COLOR |
+            MODE_FLAG_HAS_BRIGHTNESS |
+            MODE_FLAG_AUTOMATIC_SAVE;
+        Rain.speed_min = 0x01;
+        Rain.speed_max = 0x03;
+        Rain.speed = 2;
+        Rain.colors_min = 1;
+        Rain.colors_max = 4;
+        Rain.colors.resize(4);
+        Rain.colors[0] = 0xFFF500;
+        Rain.color_mode = MODE_COLORS_RANDOM;
+        Rain.brightness_min = 0;
+        Rain.brightness_max = 9;
+        Rain.brightness = brightness;
+        modes.push_back(Rain);
+    }
 
-    mode Ripple;
-    Ripple.name = "Ripple";
-    Ripple.value = LENOVO_LEGION_GEN7_8_MODE_RIPPLE;
-    Ripple.flags = MODE_FLAG_HAS_SPEED |
-        MODE_FLAG_HAS_MODE_SPECIFIC_COLOR |
-        MODE_FLAG_HAS_RANDOM_COLOR |
-        MODE_FLAG_HAS_BRIGHTNESS |
-        MODE_FLAG_AUTOMATIC_SAVE;
-    Ripple.speed_min = 0x01;
-    Ripple.speed_max = 0x03;
-    Ripple.speed = 2;
-    Ripple.colors_min = 1;
-    Ripple.colors_max = 4;
-    Ripple.colors.resize(4);
-    Ripple.colors[0] = 0xFFF500;
-    Ripple.color_mode = MODE_COLORS_RANDOM;
-    Ripple.brightness_min = 0;
-    Ripple.brightness_max = 9;
-    Ripple.brightness = brightness;
-    modes.push_back(Ripple);
+    if(!IsKeyboardOnlyDevice(controller->getPid()))
+    {
+        mode Ripple;
+        Ripple.name = "Ripple";
+        Ripple.value = LENOVO_LEGION_GEN7_8_MODE_RIPPLE;
+        Ripple.flags = MODE_FLAG_HAS_SPEED |
+            MODE_FLAG_HAS_MODE_SPECIFIC_COLOR |
+            MODE_FLAG_HAS_RANDOM_COLOR |
+            MODE_FLAG_HAS_BRIGHTNESS |
+            MODE_FLAG_AUTOMATIC_SAVE;
+        Ripple.speed_min = 0x01;
+        Ripple.speed_max = 0x03;
+        Ripple.speed = 2;
+        Ripple.colors_min = 1;
+        Ripple.colors_max = 4;
+        Ripple.colors.resize(4);
+        Ripple.colors[0] = 0xFFF500;
+        Ripple.color_mode = MODE_COLORS_RANDOM;
+        Ripple.brightness_min = 0;
+        Ripple.brightness_max = 9;
+        Ripple.brightness = brightness;
+        modes.push_back(Ripple);
 
-    mode AudioBounce;
-    AudioBounce.name = "Audio Bounce Lighting";
-    AudioBounce.value = LENOVO_LEGION_GEN7_8_MODE_AUDIO_BOUNCE;
-    AudioBounce.flags = MODE_FLAG_HAS_BRIGHTNESS;
-    AudioBounce.color_mode = MODE_COLORS_NONE;
-    AudioBounce.brightness_min = 0;
-    AudioBounce.brightness_max = 9;
-    AudioBounce.brightness = brightness;
-    modes.push_back(AudioBounce);
+        mode AudioBounce;
+        AudioBounce.name = "Audio Bounce Lighting";
+        AudioBounce.value = LENOVO_LEGION_GEN7_8_MODE_AUDIO_BOUNCE;
+        AudioBounce.flags = MODE_FLAG_HAS_BRIGHTNESS;
+        AudioBounce.color_mode = MODE_COLORS_NONE;
+        AudioBounce.brightness_min = 0;
+        AudioBounce.brightness_max = 9;
+        AudioBounce.brightness = brightness;
+        modes.push_back(AudioBounce);
 
-    mode AudioRipple;
-    AudioRipple.name = "Audio Ripple Lighting";
-    AudioRipple.value = LENOVO_LEGION_GEN7_8_MODE_AUDIO_RIPPLE;
-    AudioRipple.flags = MODE_FLAG_HAS_BRIGHTNESS;
-    AudioRipple.color_mode = MODE_COLORS_NONE;
-    AudioRipple.brightness_min = 0;
-    AudioRipple.brightness_max = 9;
-    AudioRipple.brightness = brightness;
-    modes.push_back(AudioRipple);
+        mode AudioRipple;
+        AudioRipple.name = "Audio Ripple Lighting";
+        AudioRipple.value = LENOVO_LEGION_GEN7_8_MODE_AUDIO_RIPPLE;
+        AudioRipple.flags = MODE_FLAG_HAS_BRIGHTNESS;
+        AudioRipple.color_mode = MODE_COLORS_NONE;
+        AudioRipple.brightness_min = 0;
+        AudioRipple.brightness_max = 9;
+        AudioRipple.brightness = brightness;
+        modes.push_back(AudioRipple);
+    }
 
     mode Static;
     Static.name = "Static";
     Static.value = LENOVO_LEGION_GEN7_8_MODE_STATIC;
     Static.flags = MODE_FLAG_HAS_PER_LED_COLOR |
+        MODE_FLAG_HAS_RANDOM_COLOR |
         MODE_FLAG_HAS_BRIGHTNESS |
         MODE_FLAG_AUTOMATIC_SAVE;
     Static.color_mode = MODE_COLORS_PER_LED;
@@ -213,37 +292,43 @@ LenovoRGBController_Gen7_8::LenovoRGBController_Gen7_8(LenovoGen7And8USBControll
     Static.brightness = brightness;
     modes.push_back(Static);
 
-    mode Type;
-    Type.name = "Type Lighting";
-    Type.value = LENOVO_LEGION_GEN7_8_MODE_TYPE;
-    Type.flags = MODE_FLAG_HAS_SPEED |
-        MODE_FLAG_HAS_MODE_SPECIFIC_COLOR |
-        MODE_FLAG_HAS_RANDOM_COLOR |
-        MODE_FLAG_HAS_BRIGHTNESS |
-        MODE_FLAG_AUTOMATIC_SAVE;
-    Type.speed_min = 0x01;
-    Type.speed_max = 0x03;
-    Type.speed = 2;
-    Type.colors_min = 1;
-    Type.colors_max = 4;
-    Type.colors.resize(4);
-    Type.colors[0] = 0xFFF500;
-    Type.color_mode = MODE_COLORS_RANDOM;
-    Type.brightness_min = 0;
-    Type.brightness_max = 9;
-    Type.brightness = brightness;
-    modes.push_back(Type);
+    if(!Is24ZoneDevice(controller->getPid()))
+    {
+        mode Type;
+        Type.name = "Type Lighting";
+        Type.value = LENOVO_LEGION_GEN7_8_MODE_TYPE;
+        Type.flags = MODE_FLAG_HAS_SPEED |
+            MODE_FLAG_HAS_MODE_SPECIFIC_COLOR |
+            MODE_FLAG_HAS_RANDOM_COLOR |
+            MODE_FLAG_HAS_BRIGHTNESS |
+            MODE_FLAG_AUTOMATIC_SAVE;
+        Type.speed_min = 0x01;
+        Type.speed_max = 0x03;
+        Type.speed = 2;
+        Type.colors_min = 1;
+        Type.colors_max = 4;
+        Type.colors.resize(4);
+        Type.colors[0] = 0xFFF500;
+        Type.color_mode = MODE_COLORS_RANDOM;
+        Type.brightness_min = 0;
+        Type.brightness_max = 9;
+        Type.brightness = brightness;
+        modes.push_back(Type);
+    }
 
-    mode Direct;
-    Direct.name = "Direct";
-    Direct.value = LENOVO_LEGION_GEN7_8_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 = 9;
-    Direct.brightness = brightness;
-    modes.push_back(Direct);
+    if(!IsKeyboardOnlyDevice(controller->getPid()))
+    {
+        mode Direct;
+        Direct.name = "Direct";
+        Direct.value = LENOVO_LEGION_GEN7_8_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 = 9;
+        Direct.brightness = brightness;
+        modes.push_back(Direct);
+    }
 
     name   = controller->getName();
     type   = DEVICE_TYPE_KEYBOARD;
@@ -275,6 +360,10 @@ LenovoRGBController_Gen7_8::LenovoRGBController_Gen7_8(LenovoGen7And8USBControll
     case LEGION_7GEN10:
         description = "Lenovo Legion 7 Generation 10";
         break;
+
+    case LEGION_5GEN10:
+        description = "Lenovo Legion 5 Gen 10";
+        break;
     }
 
     brightness = controller->getCurrentBrightness();
@@ -312,8 +401,19 @@ LenovoRGBController_Gen7_8::~LenovoRGBController_Gen7_8()
 void LenovoRGBController_Gen7_8::SetupZones()
 {
     vector<lenovo_zone> lenovo_zones;
-    lenovo_zones.push_back(legion7_gen7and8_kbd_ansi);
-    lenovo_zones.push_back(legion7_gen7and8_neon);
+    if(Is24ZoneDevice(controller->getPid()))
+    {
+        lenovo_zones.push_back(legion_5gen10_kbd_24zone);
+    }
+    else
+    {
+        lenovo_zones.push_back(legion7_gen7and8_kbd_ansi);
+    }
+
+    if(!IsKeyboardOnlyDevice(controller->getPid()))
+    {
+        lenovo_zones.push_back(legion7_gen7and8_neon);
+    }
 
     if (controller->getPid() == LEGION_7GEN7)
     {
@@ -408,7 +508,7 @@ void LenovoRGBController_Gen7_8::DeviceUpdateMode()
         {
             controller->setLedsDirectOn(profile_id);
             direct_enabled = true;
-            if(controller->getPid() != LEGION_7GEN10)
+            if(!UsesGen10PacketFormat(controller->getPid()))
             {
                 controller->setLedsByGroup(profile_id, GetLedGroups());
             }
@@ -432,7 +532,7 @@ void LenovoRGBController_Gen7_8::DeviceUpdateLEDs()
 {
     if(modes[active_mode].value == LENOVO_LEGION_GEN7_8_MODE_DIRECT)
     {
-        if(controller->getPid() == LEGION_7GEN10)
+        if(UsesGen10PacketFormat(controller->getPid()))
         {
             /*---------------------------------------------*\
             | Gen10 may ignore A1 updates unless D0 is      |
@@ -556,6 +656,29 @@ void LenovoRGBController_Gen7_8::ReadDeviceSettings()
 
 std::vector<led_group> LenovoRGBController_Gen7_8::GetLedGroups()
 {
+    if(Is24ZoneDevice(controller->getPid()) &&
+       modes[active_mode].value == LENOVO_LEGION_GEN7_8_MODE_STATIC &&
+       modes[active_mode].color_mode == MODE_COLORS_RANDOM)
+    {
+        vector<led_group> led_groups;
+        led_groups.reserve(leds.size());
+
+        for(size_t i = 0; i < leds.size(); i++)
+        {
+            led_group group;
+            group.mode = modes[active_mode].value;
+            group.speed = modes[active_mode].speed;
+            group.spin = 0x00;
+            group.direction = 0x00;
+            group.color_mode = 0x02;
+            group.colors.push_back(legion_5gen10_zone_visualization_colors[i % 24]);
+            group.leds.push_back(leds[i].value);
+            led_groups.push_back(group);
+        }
+
+        return led_groups;
+    }
+
     std::unordered_map<RGBColor, vector<uint16_t>> led_map;
 
     if(modes[active_mode].color_mode == MODE_COLORS_PER_LED &&

Controllers/LianLiController/LianLiUniHubALController/RGBController_LianLiUniHubAL.cpp

@@ -377,7 +377,8 @@ void RGBController_LianLiUniHubAL::SetupZones()
             zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/LianLiController/LianLiUniHubController/RGBController_LianLiUniHub.cpp

@@ -254,7 +254,8 @@ void RGBController_LianLiUniHub::SetupZones()
             zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/LianLiController/LianLiUniHubSLController/RGBController_LianLiUniHubSL.cpp

@@ -323,7 +323,8 @@ void RGBController_LianLiUniHubSL::SetupZones()
             zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/LianLiController/LianLiUniHubSLInfinityController/RGBController_LianLiUniHubSLInfinity.cpp

@@ -351,7 +351,8 @@ void RGBController_LianLiUniHubSLInfinity::SetupZones()
             zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/LianLiController/LianLiUniHubSLV2Controller/LianLiUniHubSLV2Controller.cpp

@@ -235,7 +235,7 @@ void LianLiUniHubSLV2Controller::SetChannelMode(unsigned char channel, const mod
 
 void LianLiUniHubSLV2Controller::SendStartAction(unsigned char channel, unsigned int num_fans)
 {
-    unsigned char usb_buf[65];
+    unsigned char usb_buf[353];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -291,7 +291,7 @@ void LianLiUniHubSLV2Controller::SendColorData(unsigned char   channel, unsigned
 
 void LianLiUniHubSLV2Controller::SendCommitAction(unsigned char channel, unsigned char effect, unsigned char speed, unsigned int direction, unsigned int brightness)
 {
-    unsigned char usb_buf[65];
+    unsigned char usb_buf[353];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |

Controllers/LianLiController/LianLiUniHubSLV2Controller/RGBController_LianLiUniHubSLV2.cpp

@@ -350,7 +350,8 @@ void RGBController_LianLiUniHubSLV2::SetupZones()
             zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/LianLiController/LianLiUniHub_AL10Controller/RGBController_LianLiUniHub_AL10.cpp

@@ -392,7 +392,8 @@ void RGBController_LianLiUniHub_AL10::SetupZones()
             zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/MSIGPUController/MSIGPUv2Controller/MSIGPUv2ControllerDetect.cpp

@@ -41,6 +41,7 @@ REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4070 Gaming X Slim",
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4070 Gaming X Slim White",               DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4070_DEV,         MSI_SUB_VEN,    MSI_RTX4070S_GAMING_X_SLIM_WHITE_SUB_DEV,      0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4070 SUPER Gaming X Slim",               DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4070S_DEV,        MSI_SUB_VEN,    MSI_RTX4070S_GAMING_X_SLIM_SUB_DEV,            0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4070 SUPER Gaming X Slim White",         DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4070S_DEV,        MSI_SUB_VEN,    MSI_RTX4070S_GAMING_X_SLIM_WHITE_SUB_DEV,      0x68);
+REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4070 SUPER Gaming X Slim MLG",           DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4070S_DEV,         MSI_SUB_VEN,    MSI_RTX4070S_GAMING_X_SLIM_MLG_SUB_DEV,        0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4070 Ti Gaming X Trio",                  DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4070TI_DEV,       MSI_SUB_VEN,    MSI_RTX4070TI_GAMING_X_TRIO_SUB_DEV,           0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4070 Ti Gaming X Trio White",            DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4070TI_DEV,       MSI_SUB_VEN,    MSI_RTX4070TI_GAMING_X_TRIO_WHITE_SUB_DEV,     0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4070 Ti Gaming X Slim White",            DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4070TI_DEV,       MSI_SUB_VEN,    MSI_RTX4070TI_GAMING_X_SLIM_WHITE_SUB_DEV,     0x68);

Controllers/MSIKeyboardController/MSIMysticLightKBController/RGBController_MSIMysticLightKB.cpp

@@ -20,7 +20,7 @@
     @save :robot:
     @direct :white_check_mark:
     @effects :white_check_mark:
-    @detectors DetectMSIMysticLight1565Controller
+    @detectors DetectMSIKeyboardController
     @comment
 \*-------------------------------------------------------------------*/
 

Controllers/MSIMysticLightController/MSIMysticLight185Controller/MSIMysticLight185Controller.cpp

@@ -232,6 +232,18 @@ const std::vector<MSI_ZONE> zones_set20 =
     MSI_ZONE_J_RGB_1,
 };
 
+const std::vector<MSI_ZONE> zones_set21 =
+{
+    MSI_ZONE_J_RGB_1,
+    MSI_ZONE_J_RGB_2,
+    MSI_ZONE_J_RAINBOW_1,
+    MSI_ZONE_J_RAINBOW_2,
+    MSI_ZONE_J_CORSAIR,
+    MSI_ZONE_J_PIPE_1,
+    MSI_ZONE_J_PIPE_2,
+    MSI_ZONE_ON_BOARD_LED_0
+};
+
 
 /*---------------------------------------------------------------------------------------------------------------------------------*\
 | Definition of the board sepcific configurations (number of onboard LEDs and supported zones).                                     |
@@ -333,10 +345,12 @@ static const mystic_light_185_config board_configs[] =
     { 0x7E09, 0,  0,  0, 0, &zones_set19, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // B650M PROJECT ZERO
     { 0x7E10, 0,  6,  0, 2, &zones_set17, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MPG B650 EDGE WIFI
     { 0x7E12, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG X670E TOMAHAWK WIFI
+    { 0x0076, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG X670E TOMAHAWK WIFI (Common PID)
     { 0x7E16, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // X670E GAMING PLUS WIFI
     { 0x7E24, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // B650M GAMING PLUS WIFI
     { 0x7E26, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // B650 GAMING PLUS WIFI
     { 0x7E27, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // PRO B650M-P
+    { 0x7E28, 6,  0,  0, 2, &zones_set21, MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED },    // MSI PRO A620M-B (MS-7E28)
 };
 
 
@@ -704,6 +718,19 @@ bool MSIMysticLight185Controller::Update
     }
     else
     {
+        /*-----------------------------------------------------*\
+        | Save new state, read current state from board,        |
+        | send old state first, then new state.                 |
+        | Windows Mystic Light sends two consecutive reports.   |
+        \*-----------------------------------------------------*/
+        FeaturePacket_185 new_data = data;
+        memcpy((unsigned char*)&new_data, (unsigned char*)&data, sizeof(data));
+
+        ReadSettings();
+        data.save_data = save;
+        hid_send_feature_report(dev, (unsigned char*)&data, sizeof(data));
+
+        memcpy((unsigned char*)&data, (unsigned char*)&new_data, sizeof(data));
         data.save_data = save;
         return (hid_send_feature_report(dev, (unsigned char*)&data, sizeof(data)) == sizeof(data));
     }

Controllers/MSIMysticLightController/MSIMysticLight185Controller/RGBController_MSIMysticLight185.cpp

@@ -172,10 +172,19 @@ void RGBController_MSIMysticLight185::SetupZones()
         {
             zones[zone_idx].name                        = zd->name;
             zones[zone_idx].type                        = ZONE_TYPE_SINGLE;
-            zones[zone_idx].flags                       = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE_EFFECTS_ONLY;
             zones[zone_idx].leds_min                    = 0;
             zones[zone_idx].leds_max                    = 30;//maxLeds;
-            zones[zone_idx].leds_count                  = 0;
+
+            if(first_run)
+            {
+                zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE_EFFECTS_ONLY;
+            }
+
+            if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
+            {
+                zones[zone_idx].leds_count              = 0;
+            }
+
             last_resizable_zone                         = zd->zone_type;
         }
         /*--------------------------------------------------\
@@ -192,7 +201,8 @@ void RGBController_MSIMysticLight185::SetupZones()
                 zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
             }
 
             if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
@@ -217,7 +227,7 @@ void RGBController_MSIMysticLight185::SetupZones()
                 zones[zone_idx].matrix_map.map.resize(0);
             }
 
-            last_resizable_zone = zd->zone_type;
+            last_resizable_zone                         = zd->zone_type;
         }
 
         controller->SetCycleCount(zone_description[zone_idx]->zone_type, zones[zone_idx].leds_count);
@@ -468,7 +478,7 @@ void RGBController_MSIMysticLight185::GetDeviceConfig()
 
             if(zones[i].colors != nullptr)
             {
-                for(size_t j = 0; j < zones[i].leds_count; ++j)
+                for(size_t j = 0; j < GetLEDsInZone((unsigned int)i); ++j)
                 {
                     zones[i].colors[j] = color;
                 }

Controllers/MSIMysticLightController/MSIMysticLight761Controller/MSIMysticLight761Controller.cpp

@@ -65,7 +65,9 @@ static const std::string board_names[] =
     "MSI PRO X870-P WIFI (MS-7E47)",
     "MSI MPG X870E EDGE TI WIFI (MS-7E59)",
     "MSI MAG B850 TOMAHAWK MAX WIFI (MS-7E62)",
-    "MSI PRO B850M-P WIFI (MS-7E71)"
+    "MSI PRO B850M-P WIFI (MS-7E71)",
+    "MSI MAG Z890 TOMAHAWK WIFI (MS-7E32)",
+    "MSI MPG B850 EDGE TI WIFI (MS-7E62)"
 };
 
 static const mystic_light_761_config board_configs[] =
@@ -89,6 +91,8 @@ static const mystic_light_761_config board_configs[] =
     { &(board_names[16]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI MPG X870E EDGE TI WIFI
     { &(board_names[17]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI MAG B850 TOMAHAWK MAX WIFI
     { &(board_names[18]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI PRO B850M-P WIFI (MS-7E71)
+    { &(board_names[19]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI MAG Z890 TOMAHAWK WIFI (MS-7E32)
+    { &(board_names[20]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI MPG B850 EDGE TI WIFI (MS-7E62)
 };
 
 enum MSI_ZONE setup_map [] =

Controllers/MSIMysticLightController/MSIMysticLight761Controller/RGBController_MSIMysticLight761.cpp

@@ -152,10 +152,19 @@ void RGBController_MSIMysticLight761::SetupZones()
         {
             zones[zone_idx].name                        = zd->name;
             zones[zone_idx].type                        = ZONE_TYPE_SINGLE;
-            zones[zone_idx].flags                       = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE_EFFECTS_ONLY;
             zones[zone_idx].leds_min                    = 0;
             zones[zone_idx].leds_max                    = 30;//maxLeds;
-            zones[zone_idx].leds_count                  = 0;
+
+            if(first_run)
+            {
+                zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE_EFFECTS_ONLY;
+            }
+
+            if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
+            {
+                zones[zone_idx].leds_count              = 0;
+            }
+
             last_resizable_zone                         = zd->zone_type;
         }
         /*--------------------------------------------------\
@@ -172,7 +181,8 @@ void RGBController_MSIMysticLight761::SetupZones()
                 zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                         | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
             }
 
             if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
@@ -197,7 +207,7 @@ void RGBController_MSIMysticLight761::SetupZones()
                 zones[zone_idx].matrix_map.map.resize(0);
             }
 
-            last_resizable_zone = zd->zone_type;
+            last_resizable_zone                         = zd->zone_type;
         }
 
         controller->SetCycleCount(zone_description[zone_idx]->zone_type, zones[zone_idx].leds_count);
@@ -404,7 +414,7 @@ void RGBController_MSIMysticLight761::GetDeviceConfig()
 
             if(zones[i].colors != nullptr)
             {
-                for(unsigned int j = 0; j < zones[i].leds_count; ++j)
+                for(size_t j = 0; j < GetLEDsInZone((unsigned int)i); ++j)
                 {
                     zones[i].colors[j] = color;
                 }

Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp

@@ -243,6 +243,7 @@ REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E59",    DetectMSIMysticLightCont
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E80",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7E80,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E81",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7E81,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E34",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7E34,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E32",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7E32,   0x0001, 0x00);
 // Detector for the set of common boards
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light Common",     DetectMSIMysticLightControllers,   MSI_USB_VID_COMMON,  MSI_USB_PID_COMMON, 0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light X870",     DetectMSIMysticLightControllers,   MSI_USB_VID_COMMON,  MSI_USB_PID_COMMON, 0xFF00, 0x01);

Controllers/MountainKeyboardController/RGBController_Mountain60Keyboard.cpp

@@ -28,7 +28,7 @@ std::vector<unsigned int> mountain60_keyboard_key_id_values =
         /* CPLK    A     S     D     F     G     H     J     K     L     ;     "         ENTR   */
         63,   64,   65,   66,   67,   68,   69,   70,   71,   72,   73,   74,         76,
         /* LSFT    Z     X     C     V     B     N     M     ,     .     /   RSFT  ARWU   DEL   */
-        84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,   97,   94,   56,
+        84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,   97,   99,   56,
         /* LCTL  LWIN  LALT               SPC              RALT  RFNC  FNC   ARWL  ARWD  ARWR   */
         105,  106,  107,                110,                  113,  115,  119,  120,  121,
 };

Controllers/NZXTHuePlusController/RGBController_NZXTHuePlus.cpp

@@ -261,7 +261,8 @@ void RGBController_HuePlus::SetupZones()
             zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/NollieController/NollieController.cpp

@@ -1,4 +1,4 @@
-/*---------------------------------------------------------*\
+/*---------------------------------------------------------*\
 | NollieController.cpp                                      |
 |                                                           |
 |   Driver for Nollie                                       |
@@ -136,7 +136,8 @@ void NollieController::SetMos(bool mos)
 
 void NollieController::SetChannelLEDs(unsigned char channel, RGBColor* colors, unsigned int num_colors)
 {
-   if(usb_pid == NOLLIE32_PID || usb_pid == NOLLIE16_PID)
+   if(usb_pid == NOLLIE32_PID || usb_pid == NOLLIE16_PID
+   || usb_pid == NOLLIE32_OS2_1_PID || usb_pid == NOLLIE16_OS2_1_PID)
    {
        SendPacket(channel,&colors[0], num_colors);
    }
@@ -216,9 +217,12 @@ void NollieController::SendPacketFS(unsigned char channel,unsigned char packet_i
             packet_interval = 2;
             break;
         case NOLLIE8_PID:
+        case NOLLIE8_OS2_1_PID:
+        case PRISM8_OS2_1_PID:
             packet_interval = 6;
             break;
         case NOLLIE1_PID:
+        case NOLLIE1_OS2_1_PID:
             packet_interval = 30;
             break;
         default:
@@ -233,7 +237,8 @@ void NollieController::SendPacketFS(unsigned char channel,unsigned char packet_i
         usb_buf[0x02 + (color_idx * 3)] = RGBGetRValue(colors[color_idx]);
         usb_buf[0x03 + (color_idx * 3)] = RGBGetGValue(colors[color_idx]);
         usb_buf[0x04 + (color_idx * 3)] = RGBGetBValue(colors[color_idx]);
-        if(dev_pid == NOLLIE8_PID || dev_pid == NOLLIE1_PID )
+        if(dev_pid == NOLLIE8_PID || dev_pid == NOLLIE1_PID
+        || dev_pid == NOLLIE8_OS2_1_PID || dev_pid == NOLLIE1_OS2_1_PID || dev_pid == PRISM8_OS2_1_PID)
         {
             usb_buf[0x02 + (color_idx * 3)] = RGBGetGValue(colors[color_idx]);
             usb_buf[0x03 + (color_idx * 3)] = RGBGetRValue(colors[color_idx]);

Controllers/NollieController/NollieControllerDetect.cpp

@@ -1,4 +1,4 @@
-/*---------------------------------------------------------*\
+/*---------------------------------------------------------*\
 | NollieControllerDetect.cpp                                |
 |                                                           |
 |   Detector for Nollie                                     |
@@ -44,3 +44,9 @@ REGISTER_HID_DETECTOR("Nollie 32_OS2", DetectNollieControllers, NOLLIERGBOS_2_VI
 REGISTER_HID_DETECTOR("Nollie 16_OS2", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE16_PID);
 REGISTER_HID_DETECTOR("Nollie 8_OS2", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE8_PID);
 REGISTER_HID_DETECTOR("Nollie 1_OS2", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE1_PID);
+/* OS2_1 composite device: RGB HID on interface 2 (1/8 CH) or 0 (16/32 CH) */
+REGISTER_HID_DETECTOR_I("Nollie 32_OS2_1", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE32_OS2_1_PID, 0);
+REGISTER_HID_DETECTOR_I("Nollie 16_OS2_1", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE16_OS2_1_PID, 0);
+REGISTER_HID_DETECTOR_I("Nollie 8_OS2_1", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE8_OS2_1_PID, 2);
+REGISTER_HID_DETECTOR_I("Prism8 8_OS2_1", DetectNollieControllers, NOLLIERGBOS_2_VID, PRISM8_OS2_1_PID, 2);
+REGISTER_HID_DETECTOR_I("Nollie 1_OS2_1", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE1_OS2_1_PID, 2);

Controllers/NollieController/NollieDevices.cpp

@@ -121,6 +121,51 @@ static const nollie_device nollie1_os2 =
     dflt
 };
 
+static const nollie_device nollie32_os2_1 =
+{
+    NOLLIERGBOS_2_VID,
+    NOLLIE32_OS2_1_PID,
+    32,
+    NOLLIE_HS_CH_LED_NUM,
+    ch32
+};
+
+static const nollie_device nollie16_os2_1 =
+{
+    NOLLIERGBOS_2_VID,
+    NOLLIE16_OS2_1_PID,
+    16,
+    NOLLIE_HS_CH_LED_NUM,
+    n16
+};
+
+static const nollie_device nollie8_os2_1 =
+{
+    NOLLIERGBOS_2_VID,
+    NOLLIE8_OS2_1_PID,
+    8,
+    126,
+    dflt
+};
+
+static const nollie_device prism8_os2_1 =
+{
+    NOLLIERGBOS_2_VID,
+    PRISM8_OS2_1_PID,
+    8,
+    126,
+    dflt
+};
+
+static const nollie_device nollie1_os2_1 =
+{
+    NOLLIERGBOS_2_VID,
+    NOLLIE1_OS2_1_PID,
+    1,
+    630,
+    dflt
+};
+
 /*---------------------------------------------------------*\
 | Nollie Device List                                        |
 \*---------------------------------------------------------*/
@@ -137,6 +182,11 @@ static const nollie_device* device_list[] =
     &nollie16_os2,
     &nollie8_os2,
     &nollie1_os2,
+    &nollie32_os2_1,
+    &nollie16_os2_1,
+    &nollie8_os2_1,
+    &prism8_os2_1,
+    &nollie1_os2_1,
 };
 
 const unsigned int      NOLLIE_NUM_DEVICES = (sizeof(device_list) / sizeof(device_list[ 0 ]));

Controllers/NollieController/NollieDevices.h

@@ -34,6 +34,13 @@
 #define NOLLIE28_L1_PID            0x1617
 #define NOLLIE28_L2_PID            0x1618
 
+/* OS2_1 USB layout (interface 2 for 1/8 CH, 0 for 16/32 CH); same HID protocol */
+#define NOLLIE1_OS2_1_PID          0x2A01
+#define NOLLIE8_OS2_1_PID          0x2A08
+#define PRISM8_OS2_1_PID           0x2C08
+#define NOLLIE16_OS2_1_PID         0x2A16
+#define NOLLIE32_OS2_1_PID         0x2A32
+
 /*---------------------------------------------------------*\
 | Common Nollie LED counts                                  |
 \*---------------------------------------------------------*/

Controllers/NollieController/RGBController_Nollie.cpp

@@ -1,4 +1,4 @@
-/*---------------------------------------------------------*\
+/*---------------------------------------------------------*\
 | RGBController_Nollie.cpp                                  |
 |                                                           |
 |   RGBController for Nollie                                |
@@ -84,7 +84,8 @@ void RGBController_Nollie::SetupZones()
             zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
@@ -155,7 +156,8 @@ void RGBController_Nollie::DeviceConfigureZone(int zone_idx)
 void RGBController_Nollie::DeviceUpdateLEDs()
 {
     unsigned int DevPid = controller->GetUSBPID();
-    if(DevPid == NOLLIE32_PID || DevPid == NOLLIE16_PID)
+    if(DevPid == NOLLIE32_PID || DevPid == NOLLIE16_PID
+    || DevPid == NOLLIE32_OS2_1_PID || DevPid == NOLLIE16_OS2_1_PID)
     {
         const int* channel_index = controller->GetChannelIndex();
         std::vector<int> ChSort;

Controllers/QMKController/QMKOpenRGBController/QMKOpenRGBRev9Controller/RGBController_QMKOpenRGBRev9.cpp

@@ -346,7 +346,7 @@ void RGBController_QMKOpenRGBRev9::SetupZones()
     keys_zone.leds_min                      = number_of_key_leds;
     keys_zone.leds_max                      = keys_zone.leds_min;
     keys_zone.leds_count                    = keys_zone.leds_min;
-    keys_zone.matrix_map.Set((unsigned int)matrix_map[0].size(), (unsigned int)matrix_map.size(), flat_matrix_map.data());
+    keys_zone.matrix_map.Set((unsigned int)matrix_map.size(), (unsigned int)matrix_map[0].size(), flat_matrix_map.data());
     zones.push_back(keys_zone);
 
     /*---------------------------------------------------------*\
@@ -360,7 +360,7 @@ void RGBController_QMKOpenRGBRev9::SetupZones()
         underglow_zone.leds_min             = number_of_underglow_leds;
         underglow_zone.leds_max             = underglow_zone.leds_min;
         underglow_zone.leds_count           = underglow_zone.leds_min;
-        underglow_zone.matrix_map.Set((unsigned int)underglow_map[0].size(), (unsigned int)underglow_map.size(), flat_underglow_map.data());
+        underglow_zone.matrix_map.Set((unsigned int)underglow_map.size(), (unsigned int)underglow_map[0].size(), flat_underglow_map.data());
         zones.push_back(underglow_zone);
     }
 

Controllers/QMKController/QMKOpenRGBController/QMKOpenRGBRevBController/RGBController_QMKOpenRGBRevB.cpp

@@ -345,7 +345,7 @@ void RGBController_QMKOpenRGBRevB::SetupZones()
     keys_zone.leds_min                      = number_of_key_leds;
     keys_zone.leds_max                      = keys_zone.leds_min;
     keys_zone.leds_count                    = keys_zone.leds_min;
-    keys_zone.matrix_map.Set((unsigned int)matrix_map[0].size(), (unsigned int)matrix_map.size(), flat_matrix_map.data());
+    keys_zone.matrix_map.Set((unsigned int)matrix_map.size(), (unsigned int)matrix_map[0].size(), flat_matrix_map.data());
     zones.push_back(keys_zone);
 
     /*---------------------------------------------------------*\
@@ -359,7 +359,7 @@ void RGBController_QMKOpenRGBRevB::SetupZones()
         underglow_zone.leds_min             = number_of_underglow_leds;
         underglow_zone.leds_max             = underglow_zone.leds_min;
         underglow_zone.leds_count           = underglow_zone.leds_min;
-        underglow_zone.matrix_map.Set((unsigned int)underglow_map[0].size(), (unsigned int)underglow_map.size(), flat_underglow_map.data());
+        underglow_zone.matrix_map.Set((unsigned int)underglow_map.size(), (unsigned int)underglow_map[0].size(), flat_underglow_map.data());
         zones.push_back(underglow_zone);
     }
 

Controllers/QMKController/QMKOpenRGBController/QMKOpenRGBRevDController/RGBController_QMKOpenRGBRevD.cpp

@@ -340,7 +340,7 @@ void RGBController_QMKOpenRGBRevD::SetupZones()
     keys_zone.leds_min                      = number_of_key_leds;
     keys_zone.leds_max                      = keys_zone.leds_min;
     keys_zone.leds_count                    = keys_zone.leds_min;
-    keys_zone.matrix_map.Set((unsigned int)matrix_map[0].size(), (unsigned int)matrix_map.size(), flat_matrix_map.data());
+    keys_zone.matrix_map.Set((unsigned int)matrix_map.size(), (unsigned int)matrix_map[0].size(), flat_matrix_map.data());
     zones.push_back(keys_zone);
 
     /*---------------------------------------------------------*\
@@ -354,7 +354,7 @@ void RGBController_QMKOpenRGBRevD::SetupZones()
         underglow_zone.leds_min             = number_of_underglow_leds;
         underglow_zone.leds_max             = underglow_zone.leds_min;
         underglow_zone.leds_count           = underglow_zone.leds_min;
-        underglow_zone.matrix_map.Set((unsigned int)underglow_map[0].size(), (unsigned int)underglow_map.size(), flat_underglow_map.data());
+        underglow_zone.matrix_map.Set((unsigned int)underglow_map.size(), (unsigned int)underglow_map[0].size(), flat_underglow_map.data());
         zones.push_back(underglow_zone);
     }
 

Controllers/QMKController/QMKOpenRGBController/QMKOpenRGBRevEController/RGBController_QMKOpenRGBRevE.cpp

@@ -356,7 +356,7 @@ void RGBController_QMKOpenRGBRevE::SetupZones()
     keys_zone.leds_min                      = number_of_key_leds;
     keys_zone.leds_max                      = keys_zone.leds_min;
     keys_zone.leds_count                    = keys_zone.leds_min;
-    keys_zone.matrix_map.Set((unsigned int)matrix_map[0].size(), (unsigned int)matrix_map.size(), flat_matrix_map.data());
+    keys_zone.matrix_map.Set((unsigned int)matrix_map.size(), (unsigned int)matrix_map[0].size(), flat_matrix_map.data());
     zones.push_back(keys_zone);
 
     /*---------------------------------------------------------*\
@@ -370,7 +370,7 @@ void RGBController_QMKOpenRGBRevE::SetupZones()
         underglow_zone.leds_min             = number_of_underglow_leds;
         underglow_zone.leds_max             = underglow_zone.leds_min;
         underglow_zone.leds_count           = underglow_zone.leds_min;
-        underglow_zone.matrix_map.Set((unsigned int)underglow_map[0].size(), (unsigned int)underglow_map.size(), flat_underglow_map.data());
+        underglow_zone.matrix_map.Set((unsigned int)underglow_map.size(), (unsigned int)underglow_map[0].size(), flat_underglow_map.data());
         zones.push_back(underglow_zone);
     }
 

Controllers/QMKController/QMKVialRGBController/RGBController_QMKVialRGB.cpp

@@ -20,6 +20,8 @@ typedef struct
     bool            has_speed;
 } vialrgb_mode;
 
+#define VIALRGB_NUM_MODES (sizeof(vialrgb_modes) / sizeof(vialrgb_mode))
+
 static const vialrgb_mode vialrgb_modes[] =
 {
     { VIALRGB_EFFECT_OFF,                       "Off",                          false },
@@ -85,9 +87,16 @@ RGBController_QMKVialRGB::RGBController_QMKVialRGB(QMKVialRGBController* control
     \*-----------------------------------------------------*/
     for(std::size_t effect_idx = 0; effect_idx < controller->GetEffectCount(); effect_idx++)
     {
-        mode new_mode;
-        new_mode.name           = vialrgb_modes[controller->GetEffect(effect_idx)].name;
-        new_mode.value          = vialrgb_modes[controller->GetEffect(effect_idx)].value;
+        unsigned short  mode_index = controller->GetEffect(effect_idx);
+        mode            new_mode;
+
+        if(mode_index > VIALRGB_NUM_MODES)
+        {
+            continue;
+        }
+
+        new_mode.name           = vialrgb_modes[mode_index].name;
+        new_mode.value          = vialrgb_modes[mode_index].value;
 
         if(new_mode.value == VIALRGB_EFFECT_DIRECT)
         {
@@ -104,7 +113,7 @@ RGBController_QMKVialRGB::RGBController_QMKVialRGB(QMKVialRGBController* control
             new_mode.colors.resize(1);
         }
 
-        if(vialrgb_modes[controller->GetEffect(effect_idx)].has_speed)
+        if(vialrgb_modes[mode_index].has_speed)
         {
             new_mode.flags     |= MODE_FLAG_HAS_SPEED;
             new_mode.speed_min  = 0;

Controllers/RazerController/RazerController/RGBController_RazerAddressable.cpp

@@ -177,7 +177,8 @@ void RGBController_RazerAddressable::SetupZones()
             zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/RazerController/RazerController/RazerController.cpp

@@ -441,6 +441,8 @@ bool RazerController::SupportsWave()
         case RAZER_BLACKWIDOW_V4_PRO_75_WIRED_PID:
         case RAZER_BLACKWIDOW_V4_75_WIRED_PID:
         case RAZER_BLACKWIDOW_V4_X_PID:
+        case RAZER_BLACKWIDOW_V4_TKL_WIRED_PID:
+        case RAZER_BLACKWIDOW_V4_TKL_WIRELESS_PID:
         case RAZER_BLACKWIDOW_X_CHROMA_PID:
         case RAZER_BLACKWIDOW_X_CHROMA_TE_PID:
         case RAZER_BLADE_2016_PID:

Controllers/RazerController/RazerControllerDetect.cpp

@@ -233,6 +233,8 @@ REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V4 Pro 75% (Wired)",             Det
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V4 Pro 75% (Wireless)",          DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V4_PRO_75_WIRELESS_PID,        0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V4 75% (Wired)",                 DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V4_75_WIRED_PID,               0x03,   0x01,   0x00);
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V4 X",                           DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V4_X_PID,                      0x02,   0x01,   0x02);
+REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V4 TKL (Wired)",                 DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V4_TKL_WIRED_PID,              0x03,   0x0C,   0x01);
+REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V4 TKL (Wireless)",              DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V4_TKL_WIRELESS_PID,           0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow X Chroma",                       DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_X_CHROMA_PID,                  0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow X Chroma Tournament Edition",    DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_X_CHROMA_TE_PID,               0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Cynosa Chroma",                             DetectRazerControllers,        RAZER_VID,  RAZER_CYNOSA_CHROMA_PID,                        0x02,   0x01,   0x02);

Controllers/RazerController/RazerDevices.cpp

@@ -415,6 +415,29 @@ keyboard_keymap_overlay_values razer_blackwidow_v4_x_layout
     }
 };
 
+keyboard_keymap_overlay_values razer_blackwidow_v4_tkl_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
+    {
+        {   /* ANSI Value set not used */   },
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Name,                       Alternate Name,             OpCode                              |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        {   0,      0,      10,          0,          KEY_EN_UNUSED,                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Move F9 1 right (Shifts row)
+        {   0,      1,      14,          0,          KEY_EN_UNUSED,                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Move Insert 1 right (Shifts row)
+        {   0,      2,      14,          0,          KEY_EN_UNUSED,                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Move Del 1 right (Shifts row)
+        {   0,      4,      14,          0,          KEY_EN_UNUSED,                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Move Up Arrow 1 right (Shifts row)
+        {   0,      5,      5,           0,          KEY_EN_UNUSED,                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Move Right Alt 1 right (Shifts row)
+
+    }
+};
+
 keyboard_keymap_overlay_values razer_blackwidow_x_chroma_te_layout
 {
     KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
@@ -1963,6 +1986,76 @@ static const razer_device blackwidow_v4_x_device =
     &razer_blackwidow_v4_x_layout
 };
 
+/*-------------------------------------------------------------*\
+|  Razer Blackwidow V4 TKL (Wired) 1532:02D7                    |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       6 Rows, 18 Columns                                      |
+\*-------------------------------------------------------------*/
+static const razer_zone blackwidow_v4_tkl_wired_zone =
+{
+    ZONE_EN_KEYBOARD,
+    ZONE_TYPE_MATRIX,
+    6,
+    18
+};
+
+static const razer_device blackwidow_v4_tkl_wired_device =
+{
+    "Razer Blackwidow V4 TKL (Wired)",
+    RAZER_BLACKWIDOW_V4_TKL_WIRED_PID,
+    DEVICE_TYPE_KEYBOARD,
+    RAZER_MATRIX_TYPE_EXTENDED,
+    0x1F,
+    6,
+    18,
+    {
+        &blackwidow_v4_tkl_wired_zone,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL
+    },
+    &razer_blackwidow_v4_tkl_layout
+};
+
+/*-------------------------------------------------------------*\
+|  Razer Blackwidow V4 TKL (Wireless) 1532:02D5                 |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       6 Rows, 18 Columns                                      |
+\*-------------------------------------------------------------*/
+static const razer_zone blackwidow_v4_tkl_wireless_zone =
+{
+    ZONE_EN_KEYBOARD,
+    ZONE_TYPE_MATRIX,
+    6,
+    18
+};
+
+static const razer_device blackwidow_v4_tkl_wireless_device =
+{
+    "Razer Blackwidow V4 TKL (Wireless)",
+    RAZER_BLACKWIDOW_V4_TKL_WIRELESS_PID,
+    DEVICE_TYPE_KEYBOARD,
+    RAZER_MATRIX_TYPE_EXTENDED,
+    0x9F,
+    6,
+    18,
+    {
+        &blackwidow_v4_tkl_wireless_zone,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL
+    },
+    &razer_blackwidow_v4_tkl_layout
+};
+
 /*-------------------------------------------------------------*\
 |  Razer Blackwidow X Chroma 1532:0216                          |
 |                                                               |
@@ -9234,6 +9327,8 @@ const razer_device* razer_device_list[] =
     &blackwidow_v4_pro_75_wireless_device,
     &blackwidow_v4_75_wired_device,
     &blackwidow_v4_x_device,
+    &blackwidow_v4_tkl_wired_device,
+    &blackwidow_v4_tkl_wireless_device,
     &blackwidow_x_chroma_device,
     &blackwidow_x_chroma_te_device,
     &cynosa_chroma_device,

Controllers/RazerController/RazerDevices.h

@@ -57,6 +57,8 @@
 #define RAZER_BLACKWIDOW_V4_PRO_75_WIRED_PID            0x02B3
 #define RAZER_BLACKWIDOW_V4_PRO_75_WIRELESS_PID         0x02B4
 #define RAZER_BLACKWIDOW_V4_75_WIRED_PID                0x02A5
+#define RAZER_BLACKWIDOW_V4_TKL_WIRED_PID               0x02D7
+#define RAZER_BLACKWIDOW_V4_TKL_WIRELESS_PID            0x02D5
 #define RAZER_BLACKWIDOW_X_CHROMA_PID                   0x0216
 #define RAZER_BLACKWIDOW_X_CHROMA_TE_PID                0x021A
 #define RAZER_BLADE_2016_PID                            0x020F

Controllers/RoccatController/RoccatControllerDetect.cpp

@@ -130,6 +130,7 @@ DetectedControllers DetectRoccatVulcanKeyboardControllers(hid_device_info* info,
         case ROCCAT_MAGMA_PID:
         case ROCCAT_MAGMA_MINI_PID:
         case ROCCAT_VULCAN_II_PID:
+        case ROCCAT_VULCAN_II_MAX_PID:
         case TURTLE_BEACH_VULCAN_II_PID:
             dev_led_page   = 0xFF00;
             dev_ctrl_page  = 0xFF01;
@@ -396,6 +397,7 @@ REGISTER_HID_DETECTOR_IP ("Roccat Vulcan TKL",                  DetectRoccatVulc
 REGISTER_HID_DETECTOR_IP ("Roccat Vulcan Pro",                  DetectRoccatVulcanKeyboardControllers,      ROCCAT_VID, ROCCAT_VULCAN_PRO_PID,                      1,          0xFF01);
 REGISTER_HID_DETECTOR_IP ("Roccat Vulcan TKL Pro",              DetectRoccatVulcanKeyboardControllers,      ROCCAT_VID, ROCCAT_VULCAN_TKL_PRO_PID,                  1,          0xFF01);
 REGISTER_HID_DETECTOR_IP ("Roccat Vulcan II",                   DetectRoccatVulcanKeyboardControllers,      ROCCAT_VID, ROCCAT_VULCAN_II_PID,                       1,          0xFF01);
+REGISTER_HID_DETECTOR_IP ("Roccat Vulcan II Max",               DetectRoccatVulcanKeyboardControllers,      ROCCAT_VID, ROCCAT_VULCAN_II_MAX_PID,                   1,          0xFF01);
 REGISTER_HID_DETECTOR_IP ("Turtle Beach Vulcan II",             DetectRoccatVulcanKeyboardControllers,      TURTLE_BEACH_VID, TURTLE_BEACH_VULCAN_II_PID,           1,          0xFF01);
 REGISTER_HID_DETECTOR_IP ("Turtle Beach Vulcan II TKL",         DetectRoccatVulcanKeyboardControllers,      TURTLE_BEACH_VID, TURTLE_BEACH_VULCAN_II_TKL_PID,       1,          11);
 REGISTER_HID_DETECTOR_IP ("Turtle Beach Vulcan II TKL Pro",     DetectRoccatVulcanKeyboardControllers,      TURTLE_BEACH_VID, TURTLE_BEACH_VULCAN_II_TKL_PRO_PID,   1,          0x0001);

Controllers/RoccatController/RoccatVulcanKeyboardController/RGBController_RoccatVulcanKeyboard.cpp

@@ -129,6 +129,9 @@ void RGBController_RoccatVulcanKeyboard::SetupZones()
         case TURTLE_BEACH_VULCAN_II_PID:
             keyboard_ptr = &RoccatVulcanIILayouts;
             break;
+        case ROCCAT_VULCAN_II_MAX_PID:
+            keyboard_ptr = &RoccatVulcanIIMaxLayouts;
+            break;
         case ROCCAT_MAGMA_PID:
         case ROCCAT_MAGMA_MINI_PID:
             keyboard_ptr = &RoccatMagmaLayouts;
@@ -154,15 +157,87 @@ void RGBController_RoccatVulcanKeyboard::SetupZones()
     }
 
 
+    /*---------------------------------------------------------*\
+    | Determine zone sizes                                      |
+    | Vulcan II MAX has 108 keyboard keys + 24 secondary LEDs   |
+    | (physically under parent keys) + 16 palm rest LEDs.       |
+    | Secondary LEDs are split into labeled linear zones.       |
+    \*---------------------------------------------------------*/
+    int keyboard_size = keyboard[layout].size;
+
+    if(pid == ROCCAT_VULCAN_II_MAX_PID)
+    {
+        keyboard_size  = 108;
+    }
+
     zone keyboard_zone;
     keyboard_zone.name               = "Keyboard";
     keyboard_zone.type               = ZONE_TYPE_MATRIX;
-    keyboard_zone.leds_min           = keyboard[layout].size;
-    keyboard_zone.leds_max           = keyboard[layout].size;
-    keyboard_zone.leds_count         = keyboard[layout].size;
+    keyboard_zone.leds_min           = keyboard_size;
+    keyboard_zone.leds_max           = keyboard_size;
+    keyboard_zone.leds_count         = keyboard_size;
     keyboard_zone.matrix_map.Set(keyboard[layout].rows, keyboard[layout].cols, keyboard[layout].matrix_map);
     zones.push_back(keyboard_zone);
 
+    if(pid == ROCCAT_VULCAN_II_MAX_PID)
+    {
+        zone fkey_ind_zone;
+        fkey_ind_zone.name               = "F-Key Indicators";
+        fkey_ind_zone.type               = ZONE_TYPE_LINEAR;
+        fkey_ind_zone.leds_min           = 15;
+        fkey_ind_zone.leds_max           = 15;
+        fkey_ind_zone.leds_count         = 15;
+        zones.push_back(fkey_ind_zone);
+
+        zone nav1_zone;
+        nav1_zone.name               = "Nav Cluster Indicators";
+        nav1_zone.type               = ZONE_TYPE_LINEAR;
+        nav1_zone.leds_min           = 3;
+        nav1_zone.leds_max           = 3;
+        nav1_zone.leds_count         = 3;
+        zones.push_back(nav1_zone);
+
+        zone numlock_zone;
+        numlock_zone.name               = "Num Lock Indicator";
+        numlock_zone.type               = ZONE_TYPE_LINEAR;
+        numlock_zone.leds_min           = 1;
+        numlock_zone.leds_max           = 1;
+        numlock_zone.leds_count         = 1;
+        zones.push_back(numlock_zone);
+
+        zone nav2_zone;
+        nav2_zone.name               = "Nav Cluster Indicators 2";
+        nav2_zone.type               = ZONE_TYPE_LINEAR;
+        nav2_zone.leds_min           = 3;
+        nav2_zone.leds_max           = 3;
+        nav2_zone.leds_count         = 3;
+        zones.push_back(nav2_zone);
+
+        zone caps_zone;
+        caps_zone.name               = "Caps Lock Indicator";
+        caps_zone.type               = ZONE_TYPE_LINEAR;
+        caps_zone.leds_min           = 1;
+        caps_zone.leds_max           = 1;
+        caps_zone.leds_count         = 1;
+        zones.push_back(caps_zone);
+
+        zone win_zone;
+        win_zone.name               = "Win Key Indicator";
+        win_zone.type               = ZONE_TYPE_LINEAR;
+        win_zone.leds_min           = 1;
+        win_zone.leds_max           = 1;
+        win_zone.leds_count         = 1;
+        zones.push_back(win_zone);
+
+        zone palmrest_zone;
+        palmrest_zone.name               = "Palm Rest";
+        palmrest_zone.type               = ZONE_TYPE_LINEAR;
+        palmrest_zone.leds_min           = 16;
+        palmrest_zone.leds_max           = 16;
+        palmrest_zone.leds_count         = 16;
+        zones.push_back(palmrest_zone);
+    }
+
     for(int led_id = 0; led_id < keyboard[layout].size; led_id++)
     {
         led new_led;

Controllers/RoccatController/RoccatVulcanKeyboardController/RoccatVulcanKeyboardController.cpp

@@ -69,6 +69,7 @@ device_info RoccatVulcanKeyboardController::InitDeviceInfo()
         case ROCCAT_VULCAN_PRO_PID:
         case ROCCAT_VULCAN_TKL_PRO_PID:
         case ROCCAT_VULCAN_II_PID:
+        case ROCCAT_VULCAN_II_MAX_PID:
         case TURTLE_BEACH_VULCAN_II_PID:
         case TURTLE_BEACH_VULCAN_II_TKL_PRO_PID:
             packet_length = 9;
@@ -126,6 +127,7 @@ void RoccatVulcanKeyboardController::EnableDirect(bool on_off_switch)
         case ROCCAT_VULCAN_PRO_PID:
         case ROCCAT_VULCAN_TKL_PRO_PID:
         case ROCCAT_VULCAN_II_PID:
+        case ROCCAT_VULCAN_II_MAX_PID:
         case TURTLE_BEACH_VULCAN_II_PID:
         case TURTLE_BEACH_VULCAN_II_TKL_PRO_PID:
             buf = new uint8_t[5] { 0x0E, 0x05, on_off_switch, 0x00, 0x00 };
@@ -169,6 +171,11 @@ void RoccatVulcanKeyboardController::SendColors(std::vector<led_color> colors)
         column_length = 1;
         protocol_version = 2;
         break;
+    case ROCCAT_VULCAN_II_MAX_PID:
+        packet_length = 567;
+        column_length = 1;
+        protocol_version = 2;
+        break;
     case TURTLE_BEACH_VULCAN_II_TKL_PRO_PID:
         packet_length = 320;
         column_length = 1;
@@ -342,6 +349,11 @@ void RoccatVulcanKeyboardController::SendMode(unsigned int mode, unsigned int sp
             packet_length = 377;
             column_length = 1;
             break;
+        case ROCCAT_VULCAN_II_MAX_PID:
+            protocol_version = 2;
+            packet_length = 542;
+            column_length = 1;
+            break;
         case TURTLE_BEACH_VULCAN_II_TKL_PRO_PID:
             packet_length = 284;
             column_length = 1;

Controllers/RoccatController/RoccatVulcanKeyboardController/RoccatVulcanKeyboardController.h

@@ -26,6 +26,7 @@
 #define ROCCAT_VULCAN_PRO_PID               0x30F7
 #define ROCCAT_VULCAN_TKL_PRO_PID           0x311A
 #define ROCCAT_VULCAN_II_PID                0x2F4E
+#define ROCCAT_VULCAN_II_MAX_PID            0x2EE2
 #define ROCCAT_PYRO_PID                     0x314C
 #define ROCCAT_MAGMA_PID                    0x3124
 #define ROCCAT_MAGMA_MINI_PID               0x69A0

Controllers/RoccatController/RoccatVulcanKeyboardController/RoccatVulcanKeyboardLayouts.h

@@ -805,6 +805,229 @@ static std::map<int, layout_info> RoccatVulcanIILayouts =
     },
 };
 
+static unsigned int ROCCAT_VULCAN_II_MAX_LAYOUT_KEYS_ANSI[6][24] =
+{
+    {   0,  NA,   9,  15,  20,  25,  NA,  35,  40,  45,  50,  56,  62,  67,  72,  NA,  75,  79,  84,  NA, 105, 106, 107,  NA },
+    {   1,   6,  10,  16,  21,  26,  30,  36,  41,  46,  51,  57,  63,  68,  NA,  NA,  76,  80,  85,  NA,  88,  93,  97, 102 },
+    {   2,  NA,  11,  17,  22,  27,  31,  37,  42,  47,  52,  58,  64,  69,  70,  NA,  77,  81,  86,  NA,  89,  94,  98, 103 },
+    {   3,  NA,  12,  18,  23,  28,  32,  38,  43,  48,  53,  59,  65,  73,  NA,  NA,  NA,  NA,  NA,  NA,  90,  95,  99,  NA },
+    {   4,  NA,  13,  19,  24,  29,  33,  39,  44,  49,  54,  60,  71,  NA,  NA,  NA,  NA,  82,  NA,  NA,  91,  96, 100, 104 },
+    {   5,   8,  14,  NA,  NA,  NA,  34,  NA,  NA,  NA,  55,  61,  66,  74,  NA,  NA,  78,  83,  87,  NA,  92,  NA, 101,  NA }
+};
+
+static std::map<int, layout_info> RoccatVulcanIIMaxLayouts =
+{
+    {
+        ROCCAT_VULCAN_LAYOUT_US,
+        {
+            *ROCCAT_VULCAN_II_MAX_LAYOUT_KEYS_ANSI,
+            148,
+            6,
+            24,
+            {
+                { KEY_EN_ESCAPE,              0x02 },
+                { KEY_EN_BACK_TICK,           0x03 },
+                { KEY_EN_TAB,                 0x04 },
+                { KEY_EN_CAPS_LOCK,           0x05 },
+                { KEY_EN_LEFT_SHIFT,          0x00 },
+                { KEY_EN_LEFT_CONTROL,        0x01 },
+
+                { KEY_EN_1,                   0x08 },
+                { KEY_EN_UNUSED,              0x06 },
+                { KEY_EN_LEFT_WINDOWS,        0x07 },
+
+                { KEY_EN_F1,                  0x0D },
+                { KEY_EN_2,                   0x0E },
+                { KEY_EN_Q,                   0x09 },
+                { KEY_EN_A,                   0x0A },
+                { KEY_EN_Z,                   0x0B },
+                { KEY_EN_LEFT_ALT,            0x0C },
+
+                { KEY_EN_F2,                  0x14 },
+                { KEY_EN_3,                   0x15 },
+                { KEY_EN_W,                   0x0F },
+                { KEY_EN_S,                   0x10 },
+                { KEY_EN_X,                   0x11 },
+
+                { KEY_EN_F3,                  0x19 },
+                { KEY_EN_4,                   0x1A },
+                { KEY_EN_E,                   0x16 },
+                { KEY_EN_D,                   0x17 },
+                { KEY_EN_C,                   0x18 },
+
+                { KEY_EN_F4,                  0x1F },
+                { KEY_EN_5,                   0x1E },
+                { KEY_EN_R,                   0x1B },
+                { KEY_EN_F,                   0x1C },
+                { KEY_EN_V,                   0x21 },
+
+                { KEY_EN_6,                   0x24 },
+                { KEY_EN_T,                   0x20 },
+                { KEY_EN_G,                   0x1D },
+                { KEY_EN_B,                   0x22 },
+                { KEY_EN_SPACE,               0x28 },
+
+                { KEY_EN_F5,                  0x23 },
+                { KEY_EN_7,                   0x29 },
+                { KEY_EN_Y,                   0x25 },
+                { KEY_EN_H,                   0x26 },
+                { KEY_EN_N,                   0x27 },
+
+                { KEY_EN_F6,                  0x2F },
+                { KEY_EN_8,                   0x30 },
+                { KEY_EN_U,                   0x3D },
+                { KEY_EN_J,                   0x2B },
+                { KEY_EN_M,                   0x2C },
+
+                { KEY_EN_F7,                  0x35 },
+                { KEY_EN_9,                   0x36 },
+                { KEY_EN_I,                   0x31 },
+                { KEY_EN_K,                   0x32 },
+                { KEY_EN_COMMA,               0x33 },
+
+                { KEY_EN_F8,                  0x3B },
+                { KEY_EN_0,                   0x3C },
+                { KEY_EN_O,                   0x37 },
+                { KEY_EN_L,                   0x38 },
+                { KEY_EN_PERIOD,              0x39 },
+                { KEY_EN_RIGHT_ALT,           0x3A },
+
+                { KEY_EN_F9,                  0x41 },
+                { KEY_EN_MINUS,               0x42 },
+                { KEY_EN_P,                   0x2A },
+                { KEY_EN_SEMICOLON,           0x3E },
+                { KEY_EN_FORWARD_SLASH,       0x3F },
+                { KEY_EN_RIGHT_FUNCTION,      0x40 },
+
+                { KEY_EN_F10,                 0x47 },
+                { KEY_EN_EQUALS,              0x48 },
+                { KEY_EN_LEFT_BRACKET,        0x43 },
+                { KEY_EN_QUOTE,               0x44 },
+                { KEY_EN_MENU,                0x46 },
+
+                { KEY_EN_F11,                 0x4D },
+                { KEY_EN_BACKSPACE,           0x50 },
+                { KEY_EN_RIGHT_BRACKET,       0x49 },
+                { KEY_EN_ANSI_BACK_SLASH,     0x51 },
+                { KEY_EN_RIGHT_SHIFT,         0x4B },
+
+                { KEY_EN_F12,                 0x4F },
+                { KEY_EN_ANSI_ENTER,          0x52 },
+                { KEY_EN_RIGHT_CONTROL,       0x4C },
+
+                { KEY_EN_PRINT_SCREEN,        0x53 },
+                { KEY_EN_INSERT,              0x54 },
+                { KEY_EN_DELETE,              0x55 },
+                { KEY_EN_LEFT_ARROW,          0x56 },
+
+                { KEY_EN_SCROLL_LOCK,         0x57 },
+                { KEY_EN_HOME,                0x58 },
+                { KEY_EN_END,                 0x59 },
+                { KEY_EN_UP_ARROW,            0x5A },
+                { KEY_EN_DOWN_ARROW,          0x5B },
+
+                { KEY_EN_PAUSE_BREAK,         0x5C },
+                { KEY_EN_PAGE_UP,             0x5D },
+                { KEY_EN_PAGE_DOWN,           0x5E },
+                { KEY_EN_RIGHT_ARROW,         0x5F },
+
+                { KEY_EN_NUMPAD_LOCK,         0x60 },
+                { KEY_EN_NUMPAD_7,            0x61 },
+                { KEY_EN_NUMPAD_4,            0x62 },
+                { KEY_EN_NUMPAD_1,            0x6C },
+                { KEY_EN_NUMPAD_0,            0x64 },
+
+                { KEY_EN_NUMPAD_DIVIDE,       0x65 },
+                { KEY_EN_NUMPAD_8,            0x66 },
+                { KEY_EN_NUMPAD_5,            0x67 },
+                { KEY_EN_NUMPAD_2,            0x68 },
+
+                { KEY_EN_NUMPAD_TIMES,        0x69 },
+                { KEY_EN_NUMPAD_9,            0x6A },
+                { KEY_EN_NUMPAD_6,            0x6B },
+                { KEY_EN_NUMPAD_3,            0x63 },
+                { KEY_EN_NUMPAD_PERIOD,       0x6D },
+
+                { KEY_EN_NUMPAD_MINUS,        0x6E },
+                { KEY_EN_NUMPAD_PLUS,         0x6F },
+                { KEY_EN_NUMPAD_ENTER,        0x71 },
+
+                { KEY_EN_MEDIA_PREVIOUS,      0x72 },
+                { KEY_EN_MEDIA_PLAY_PAUSE,    0x73 },
+                { KEY_EN_MEDIA_NEXT,          0x74 },
+
+                /*-------------------------------------------------------------*\
+                |  F-Key Indicators (secondary LEDs)                            |
+                \*-------------------------------------------------------------*/
+                { "Key: F1 LED 2",            0x89 },
+                { "Key: F2 LED 2",            0x7B },
+                { "Key: F3 LED 2",            0x81 },
+                { "Key: F4 LED 2",            0x87 },
+                { "Key: F5 LED 2",            0x8D },
+                { "Key: F6 LED 2",            0x76 },
+                { "Key: F7 LED 2",            0x7C },
+                { "Key: F8 LED 2",            0x82 },
+                { "Key: F9 LED 2",            0x88 },
+                { "Key: F10 LED 2",           0x8E },
+                { "Key: F11 LED 2",           0x7A },
+                { "Key: F12 LED 2",           0x80 },
+                { "Key: Print Screen LED 2",  0x86 },
+                { "Key: Scroll Lock LED 2",   0x8C },
+                { "Key: Pause/Break LED 2",   0x92 },
+
+                /*-------------------------------------------------------------*\
+                |  Nav Cluster Indicators (secondary LEDs)                      |
+                \*-------------------------------------------------------------*/
+                { "Key: Insert LED 2",        0x75 },
+                { "Key: Home LED 2",          0x7E },
+                { "Key: Page Up LED 2",       0x84 },
+
+                /*-------------------------------------------------------------*\
+                |  Num Lock Indicator (secondary LED)                           |
+                \*-------------------------------------------------------------*/
+                { "Key: Num Lock LED 2",      0x8B },
+
+                /*-------------------------------------------------------------*\
+                |  Nav Cluster Indicators 2 (secondary LEDs)                    |
+                \*-------------------------------------------------------------*/
+                { "Key: Delete LED 2",        0x78 },
+                { "Key: End LED 2",           0x90 },
+                { "Key: Page Down LED 2",     0x8A },
+
+                /*-------------------------------------------------------------*\
+                |  Caps Lock Indicator (secondary LED)                          |
+                \*-------------------------------------------------------------*/
+                { "Key: Caps Lock LED 2",     0x7D },
+
+                /*-------------------------------------------------------------*\
+                |  Win Key Indicator (secondary LED)                            |
+                \*-------------------------------------------------------------*/
+                { "Key: Left Windows LED 2",  0x83 },
+
+                /*-------------------------------------------------------------*\
+                |  Palm Rest LEDs (order approximate - needs verification)       |
+                \*-------------------------------------------------------------*/
+                { "Palm Rest LED 1",          0x96 },
+                { "Palm Rest LED 2",          0xAD },
+                { "Palm Rest LED 3",          0xA7 },
+                { "Palm Rest LED 4",          0xA1 },
+                { "Palm Rest LED 5",          0x9B },
+                { "Palm Rest LED 6",          0x95 },
+                { "Palm Rest LED 7",          0xAC },
+                { "Palm Rest LED 8",          0xA6 },
+                { "Palm Rest LED 9",          0xA0 },
+                { "Palm Rest LED 10",         0x9A },
+                { "Palm Rest LED 11",         0x94 },
+                { "Palm Rest LED 12",         0xAB },
+                { "Palm Rest LED 13",         0xA5 },
+                { "Palm Rest LED 14",         0x9F },
+                { "Palm Rest LED 15",         0x99 },
+                { "Palm Rest LED 16",         0x93 }
+            }
+        }
+    },
+};
+
 static std::map<int, layout_info> RoccatVulcanTKLLayouts =
 {
     {

Controllers/SRGBmodsController/SRGBmodsLEDControllerV1/RGBController_SRGBmodsLEDControllerV1.cpp

@@ -128,7 +128,8 @@ void RGBController_SRGBmodsLEDControllerV1::SetupZones()
             zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/SRGBmodsController/SRGBmodsPicoController/RGBController_SRGBmodsPico.cpp

@@ -87,7 +87,8 @@ void RGBController_SRGBmodsPico::SetupZones()
             zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/SteelSeriesController/SteelSeriesApexBaseController.cpp

@@ -10,6 +10,7 @@
 \*---------------------------------------------------------*/
 
 #include "SteelSeriesApexBaseController.h"
+#include <algorithm>
 
 SteelSeriesApexBaseController::SteelSeriesApexBaseController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
@@ -34,17 +35,15 @@ std::string SteelSeriesApexBaseController::GetName()
 }
 
 /*---------------------------------------------------------*\
-| The serial number of the keyboard is acquired by sending  |
-| an output report to address 0xFF and reading the result.  |
-| The HID capability table is not used.  The serial number  |
-| also contains the model number which can be used to       |
-| determine the physical layout of different region         |
-| keyboards throughout the product stack.                   |
+| Gen 1 Apex Pro stores the unit serial number in firmware. |
+| The first 5 digits determine the region of the keyboard.  |
+| This is not the case for Gen 3, call to this function     |
+| will be ignored.                                          |
 \*---------------------------------------------------------*/
 std::string SteelSeriesApexBaseController::GetSerial()
 {
     std::string return_string = "";
-    if(proto_type == APEX)
+    if(proto_type == APEX && kbd_quirk == APEX_GEN1)
     {
         unsigned char obuf[STEELSERIES_PACKET_OUT_SIZE];
         unsigned char ibuf[STEELSERIES_PACKET_IN_SIZE];
@@ -70,6 +69,27 @@ std::string SteelSeriesApexBaseController::GetSerial()
         return(return_string);
 }
 
+std::string ExtractVersion(std::string version_string)
+{
+    /*---------------------------------------------*\
+    | Find 2 periods in string, if found we can     |
+    | form a X.Y.Z revision.                        |
+    \*---------------------------------------------*/
+    std::size_t majorp = version_string.find('.');
+    if(majorp != std::string::npos)
+    {
+        std::size_t minorp = version_string.find('.', majorp+1);
+        if(minorp != std::string::npos)
+        {
+            std::string major = version_string.substr(0, majorp);
+            std::string minor = version_string.substr(majorp+1, (minorp-majorp-1));
+            std::string build = version_string.substr(minorp+1);
+            return major + "." + minor + "." + build;
+        }
+    }
+    return "";
+}
+
 std::string SteelSeriesApexBaseController::GetVersion()
 {
     std::string return_string = "Unsupported protocol";
@@ -77,11 +97,9 @@ std::string SteelSeriesApexBaseController::GetVersion()
     if(proto_type == APEX)
     {
         /*-------------------------------------------------*\
-        | For the Apex Pro there are two firmware versions  |
-        | which can be acquired, KBD and LED.  We know      |
-        | where both are located, we do not know which is   |
-        | what.  For now we'll make an assumption and fix   |
-        | if proven wrong.                                  |
+        | Gen 1 & 2 Apex Pro report KBD and LED firmware    |
+        | Gen 3 only reports the KBD firmware, ignoring     |
+        | requests to read the LED version                  |
         \*-------------------------------------------------*/
         unsigned char   obuf[STEELSERIES_PACKET_OUT_SIZE];
         unsigned char   ibuf[STEELSERIES_PACKET_IN_SIZE];
@@ -96,50 +114,36 @@ std::string SteelSeriesApexBaseController::GetVersion()
         if(result > 0)
         {
             std::string fwver(ibuf, ibuf+STEELSERIES_PACKET_IN_SIZE);
-            fwver = fwver.c_str();
+            fwver.erase(std::remove(fwver.begin(), fwver.end(), '\0'), fwver.end());
 
             /*---------------------------------------------*\
-            | Find 2 periods in string, if found we can     |
-            | form a X.Y.Z revision.                        |
+            | Apex Pro Gen 3 needs the first char dropped   |
             \*---------------------------------------------*/
-            std::size_t majorp = fwver.find('.');
-            if(majorp != std::string::npos)
+            if(kbd_quirk == APEX_GEN3)
             {
-                std::size_t minorp = fwver.find('.', majorp+1);
-                if(minorp != std::string::npos)
-                {
-                    std::string major = fwver.substr(0, majorp);
-                    std::string minor = fwver.substr(majorp+1, (minorp-majorp-1));
-                    std::string build = fwver.substr(minorp+1);
-                    return_string = "KBD: " + major + "." + minor + "." + build;
-                }
+                fwver.erase(0,1);
             }
+
+            return_string = "KBD: " + ExtractVersion(fwver);
         }
 
         /*-------------------------------------------------*\
         | Clear and reuse buffer                            |
         \*-------------------------------------------------*/
-        memset(ibuf, 0x00, sizeof(ibuf));
-        obuf[0x02] = 0x01;
-        hid_write(dev, obuf, STEELSERIES_PACKET_OUT_SIZE);
-        result = hid_read_timeout(dev, ibuf, STEELSERIES_PACKET_IN_SIZE, 10);
-
-        if(result > 0)
+        if(kbd_quirk != APEX_GEN3)
         {
-            std::string fwver(ibuf, ibuf+STEELSERIES_PACKET_IN_SIZE);
-            fwver = fwver.c_str();
+            memset(ibuf, 0x00, sizeof(ibuf));
+            obuf[0x02] = 0x01;
+            hid_write(dev, obuf, STEELSERIES_PACKET_OUT_SIZE);
+            result = hid_read_timeout(dev, ibuf, STEELSERIES_PACKET_IN_SIZE, 10);
 
-            std::size_t majorp = fwver.find('.');
-            if(majorp != std::string::npos)
+            if(result > 0)
             {
-                std::size_t minorp = fwver.find('.', majorp+1);
-                if(minorp != std::string::npos)
-                {
-                    std::string major = fwver.substr(0, majorp);
-                    std::string minor = fwver.substr(majorp+1, (minorp-majorp-1));
-                    std::string build = fwver.substr(minorp+1);
-                    return_string = return_string + " / LED: " + major + "." + minor + "." + build;
-                }
+                std::string fwver(ibuf, ibuf+STEELSERIES_PACKET_IN_SIZE);
+                fwver.erase(std::remove(fwver.begin(), fwver.end(), '\0'), fwver.end());
+                fwver = fwver.c_str();
+
+                return_string = return_string + " / LED: " + ExtractVersion(fwver);
             }
         }
     }

Controllers/SteelSeriesController/SteelSeriesApexBaseController.h

@@ -19,6 +19,20 @@
 #define STEELSERIES_PACKET_IN_SIZE  64
 #define STEELSERIES_PACKET_OUT_SIZE STEELSERIES_PACKET_IN_SIZE + 1
 
+/*-------------------------------------------------*\
+| Gen 1: 2019-22 models (all FW) & 2023 FW < 1.19.7 |
+| Gen 2: 2023 models with FW >= 1.19.7              |
+| Gen 3: 2025+ and may feature Gen 3 in the name    |
+\*-------------------------------------------------*/
+
+typedef enum
+{
+    APEX_GEN1                 = 0x00,
+    APEX_GEN2                 = 0x01,
+    APEX_GEN3                 = 0x02,
+
+} protocol_quirk;
+
 class SteelSeriesApexBaseController
 {
 public:
@@ -41,4 +55,5 @@ protected:
     unsigned char       active_mode;
     std::string         location;
     std::string         name;
+    protocol_quirk      kbd_quirk;
 };

Controllers/SteelSeriesController/SteelSeriesApexController/SteelSeriesApexController.cpp

@@ -33,18 +33,31 @@ static unsigned int keys[] = {0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x
                               0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xF0, 0x31, 0x87,
                               0x88, 0x89, 0x8A, 0x8B, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, //100
                               0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62,
-                              0x63 };
+                              0x63, 0xFB };
 
 SteelSeriesApexController::SteelSeriesApexController(hid_device* dev_handle, steelseries_type type, const char* path, std::string dev_name) : SteelSeriesApexBaseController(dev_handle, path, dev_name)
 {
     proto_type = type;
-    use_new_protocol = false;
+    kbd_quirk = APEX_GEN1;
 
     SendInitialization();
 }
 
 SteelSeriesApexController::~SteelSeriesApexController()
 {
+    /*-----------------------------------------------------*\
+    | Gen 3 models must be explicitly cleared for on-board  |
+    | config selection to apply without power cycling after |
+    | OpenRGB shuts down.                                   |
+    \*-----------------------------------------------------*/
+    if(kbd_quirk == APEX_GEN3)
+    {
+        unsigned char obuf[STEELSERIES_PACKET_OUT_SIZE];
+        memset(obuf, 0x00, sizeof(obuf));
+        obuf[0x00] = 0;
+        obuf[0x01] = APEX_GEN3_PACKET_CLEAR_LIGHTING;
+        hid_write(dev, obuf, STEELSERIES_PACKET_OUT_SIZE);
+    }
     hid_close(dev);
 }
 
@@ -70,7 +83,7 @@ void SteelSeriesApexController::SetLEDsDirect(std::vector<RGBColor> colors)
 
     num_keys = sizeof(keys) / sizeof(*keys);
 
-    if(use_new_protocol)
+    if(kbd_quirk >= APEX_GEN2)
     {
         struct hid_device_info* info = hid_get_device_info(dev);
 
@@ -79,7 +92,9 @@ void SteelSeriesApexController::SetLEDsDirect(std::vector<RGBColor> colors)
         | protocol, make sure to place their PID here and   |
         | further below when developing.                    |
         \*-------------------------------------------------*/
-        if(info && (info->product_id == 0x162C || info->product_id == 0x162D))
+        if(info && (info->product_id == 0x1630 || info->product_id == 0x1632
+                 || info->product_id == 0x162C || info->product_id == 0x162D
+                 || info->product_id == 0x1644 || info->product_id == 0x1646))
         {
              packet_id = APEX_2023_PACKET_ID_DIRECT_WIRELESS;
         }
@@ -99,7 +114,7 @@ void SteelSeriesApexController::SetLEDsDirect(std::vector<RGBColor> colors)
     \*-----------------------------------------------------*/
     buf[0x00]   = 0;
     buf[0x01]   = packet_id;
-    buf[0x02]   = (use_new_protocol) ? (unsigned char)colors.size() : num_keys;
+    buf[0x02]   = kbd_quirk ? (unsigned char)colors.size() : num_keys;
 
     /*-----------------------------------------------------*\
     | Fill in color data                                    |
@@ -149,7 +164,7 @@ void SteelSeriesApexController::SendInitialization()
     unsigned short pid = (info) ? info->product_id : 0;
 
     /*-----------------------------------------------------*\
-    | Firmware check                                        |
+    | Firmware check for TKL 2023                           |
     \*-----------------------------------------------------*/
     if(pid == 0x1628)
     {
@@ -190,17 +205,17 @@ void SteelSeriesApexController::SendInitialization()
                 \*-----------------------------------------*/
                 if(major > 1)
                 {
-                    use_new_protocol = true;
+                    kbd_quirk = APEX_GEN2;
                 }
                 else if(major == 1)
                 {
                     if(minor > 19)
                     {
-                        use_new_protocol = true;
+                        kbd_quirk = APEX_GEN2;
                     }
                     else if(minor == 19 && patch >= 7)
                     {
-                        use_new_protocol = true;
+                        kbd_quirk = APEX_GEN2;
                     }
                 }
             }
@@ -211,15 +226,17 @@ void SteelSeriesApexController::SendInitialization()
     | sure to place their PID here and further above for    |
     | wireless when developing.                             |
     \*-----------------------------------------------------*/
-    else if(pid == 0x162C || pid == 0x162D)
+    else if(pid == 0x1630 || pid == 0x1632
+         || pid == 0x162C || pid == 0x162D
+         || pid == 0x1642 || pid == 0x1644 || pid == 0x1646)
     {
-        use_new_protocol = true;
+        kbd_quirk = APEX_GEN3;
     }
 
     /*-----------------------------------------------------*\
     | Send Initialization packet on new protocol.           |
     \*-----------------------------------------------------*/
-    if(use_new_protocol)
+    if(kbd_quirk >= APEX_GEN2)
     {
         memset(buf, 0x00, sizeof(buf));
         buf[0x00]   = 0x00;
@@ -236,8 +253,64 @@ void SteelSeriesApexController::SendInitialization()
 
 std::string SteelSeriesApexController::GetSerial()
 {
-    if(use_new_protocol)
+    /*-------------------------------------------------*\
+    | Gen 3 doesn't expose the serial number in         |
+    | firmware. A region code is instead set by the     |
+    | user and subsequently read back. This region code |
+    | is used by all 5 on-board configs.                |
+    | For consistency with other Apex keyboards, this   |
+    | region code in combination with the PID is mapped |
+    | to an approximate product number as the region    |
+    | patch logic from that point is identical.         |
+    | The product number used may not be an exact match |
+    | for the keyboard but should reflect the form      |
+    | factor, region and RGB layout                     |
+    \*-------------------------------------------------*/
+    if(kbd_quirk >= APEX_GEN2)
     {
+        unsigned char           obuf[STEELSERIES_PACKET_OUT_SIZE];
+        unsigned char           ibuf[STEELSERIES_PACKET_IN_SIZE];
+        int                     result;
+        struct hid_device_info* info = hid_get_device_info(dev);
+        unsigned short          pid = (info) ? info->product_id : 0;
+
+        memset(obuf, 0x00, sizeof(obuf));
+
+        if(pid == 0x1642)
+        {
+            obuf[0x00] = 0;
+            obuf[0x01] = 0xF5;
+            hid_write(dev, obuf, STEELSERIES_PACKET_OUT_SIZE);
+            result = hid_read_timeout(dev, ibuf, STEELSERIES_PACKET_IN_SIZE, 2);
+
+            if(result > 3 && ibuf[0] == 0xF5)
+            {
+                switch(ibuf[2])
+                {
+                case 0x1:
+                    return "64740";
+                    break;
+                case 0x3:
+                    return "64741";
+                    break;
+                case 0x4:
+                    return "64743";
+                    break;
+                case 0x6:
+                    return "64744";
+                    break;
+                case 0xA:
+                    return "64742";
+                    break;
+                case 0xD:
+                    return "64745";
+                    break;
+                default:
+                    break;
+                }
+            }
+        }
+
         return "64865";
     }
 

Controllers/SteelSeriesController/SteelSeriesApexController/SteelSeriesApexController.h

@@ -28,6 +28,7 @@ enum
     APEX_2023_PACKET_ID_DIRECT_WIRELESS = 0x61,     /* New Wireless Direct mode   */
     APEX_2023_PACKET_ID_INIT            = 0x4B,     /* New Initialization         */
     APEX_2023_PACKET_LENGTH             = 643,
+    APEX_GEN3_PACKET_CLEAR_LIGHTING     = 0x41,
 };
 
 class SteelSeriesApexController : public SteelSeriesApexBaseController
@@ -55,5 +56,4 @@ private:
 
     void    SendInitialization();
 
-    bool    use_new_protocol;
 };

Controllers/SteelSeriesController/SteelSeriesApexRegions.h

@@ -20,17 +20,16 @@
 #define NA  0xFFFFFFFF
 
 /*----------------------------------------------------------------------*\
-| As of firmware 4.1.0 there are in total 111 possible standard keys     |
-| which are shared across the Apex Pro / 7 / TKL / 5 and their regional  |
-| SKUs in addition to the 6 media keys. No SKU has all 111, however      |
-| regardless of the physial layout, the one configuration can be used    |
-| across all SKUs with missing keys simply having no effect.             |
-| The complication comes in the visualisation as different key layouts   |
-| change the LED positions, additionally some labels / scancodes are     |
-| overloaded based on the language which clashes with the OpenRGB        |
-| defaults. In order to account for this a base SKU (ANSI) is assumed    |
-| which is transformed into a regional SKU when device detection returns |
-| a known SKU number from the first 5 characters of the serial number.   |
+| Steelseries keyboards share a library of 111 standard keys plus extra  |
+| ambients across all physical form factors. No keyboard has every key   |
+| fitted but the same format packet can be sent regardless of model and  |
+| the firmware will pick the keys applicable to it, ignoring the rest.   |
+| The complication comes in commuicating this to the OpenRGB GUI as      |
+| different key layouts change the LED positions, additionally some      |
+| labels / scancodes are overloaded based on the language which clashes  |
+| with the OpenRGB defaults. In order to account for this a base SKU     |
+| (ANSI) is assumed which is transformed into a regional SKU when device |
+| detection returns a known product number acquired from the keyboard    |
 \*----------------------------------------------------------------------*/
 
 #define MATRIX_HEIGHT 6
@@ -50,6 +49,10 @@
 
 static const int matrix_mapsize = MATRIX_HEIGHT * MATRIX_WIDTH;
 
+/*-------------------------------------------------------*\
+| These map to the values defined in the keys array at    |
+| SteelSeriesApexController                               |
+\*-------------------------------------------------------*/
 static const char* led_names[] =
 {
     KEY_EN_A,
@@ -163,6 +166,7 @@ static const char* led_names[] =
     KEY_EN_NUMPAD_9,
     KEY_EN_NUMPAD_0,
     KEY_EN_NUMPAD_PERIOD,
+    KEY_EN_MEDIA_PLAY_PAUSE
 };
 
 struct matrix_region_patch
@@ -244,7 +248,7 @@ static const std::vector<matrix_region_patch> apex_tkl_us_region_patch =
 {
     {0, 15, NA},
     {0, 16, NA},
-    {0, 17, NA},
+    {0, 17, 111},
     {1, 18, NA},
     {1, 19, NA},
     {1, 20, NA},
@@ -367,6 +371,9 @@ static const std::map<std::string, sku_patch> patch_lookup =
     { "64660", { {}, {}, {} }},
 
     { "64740", { apex_tkl_us_region_patch, {}, {} }},
+    { "64742", { apex_tkl_us_region_patch, apex_iso_region_patch, apex_nor_keyname_lookup }},
+    { "64743", { apex_tkl_us_region_patch, apex_iso_region_patch, apex_uk_keyname_lookup }},
+    { "64745", { apex_tkl_us_region_patch, apex_jp_region_patch, apex_jp_keyname_lookup }},
     { "64871", { apex_tkl_us_region_patch, {}, {} }},
 
     { "64913", { apex_mini_us_region_patch, {}, {} }},
@@ -486,7 +493,7 @@ static void SetSkuLedNames (std::vector<led>& input, std::string& sku, unsigned
 | SKU codes for all known Apex Pro / 7 / 5 & TKL variant      |
 | keyboards as at Janauary 2022. Generated by cross-checking  |
 | store listings aginst Steelseries website.                  |
-| Updated 2025 for Apex 9 and Pro Gen 2 & Gen 3               |
+| Updated 2026 for Apex 9 and Pro Gen 2 & Gen 3               |
 | The product Pro Mini seem to belong to Gen 2                |
 |                                                             |
 |  -- APEX PRO Gen 3 --                                       |
@@ -495,11 +502,17 @@ static void SetSkuLedNames (std::vector<led>& input, std::string& sku, unsigned
 |                                                             |
 |  >> APEX PRO TKL Gen 3                                      |
 |                                                             |
-|  "64740", // US TKL                                         |
+|  "64740", // US TKL Black                                   |
+|  "64741", // UK TKL Black                                   |
+|  "64742", // Nordic TKL Black                               |
+|  "64743", // German TKL Black                               |
+|  "64744", // French TKL Black                               |
+|  "64745", // Japanese TKL Black                             |
 |                                                             |
 |  >> APEX PRO TKL Wireless Gen 3                             |
 |                                                             |
-|  "64871", // US TKL Wireless                                |
+|  "64871", // US TKL Black Wireless                          |
+|  "64876", // Japanese TKL Black Wireless                    |
 |                                                             |
 |  >> APEX PRO Mini Gen 3                                     |
 |                                                             |
@@ -510,6 +523,7 @@ static void SetSkuLedNames (std::vector<led>& input, std::string& sku, unsigned
 |  >> APEX PRO TKL Gen 2 / 2023                               |
 |                                                             |
 |  "64856", // US TKL                                         |
+|  "64861", // Japanese TKL                                   |
 |                                                             |
 |  >> APEX PRO TKL Wireless Gen 2 / 2023                      |
 |                                                             |

Controllers/SteelSeriesController/SteelSeriesControllerDetect.cpp

@@ -108,22 +108,25 @@
 /*---------------------------------------------------------*\
 | Keyboard product IDs                                      |
 \*---------------------------------------------------------*/
-#define STEELSERIES_APEX_3_PID                          0x161A
-#define STEELSERIES_APEX_3_TKL_PID                      0x1622
-#define STEELSERIES_APEX_5_PID                          0x161C
-#define STEELSERIES_APEX_7_PID                          0x1612
-#define STEELSERIES_APEX_7_TKL_PID                      0x1618
-#define STEELSERIES_APEX_9_TKL_PID                      0x1634
-#define STEELSERIES_APEX_9_MINI_PID                     0x1620
-#define STEELSERIES_APEX_PRO_PID                        0x1610
-#define STEELSERIES_APEX_PRO_TKL_PID                    0x1614
-#define STEELSERIES_APEX_PRO_TKL_2023_PID               0x1628
-#define STEELSERIES_APEX_PRO_TKL_2023_WL_PID_1          0x1630
-#define STEELSERIES_APEX_PRO_TKL_2023_WL_PID_2          0x1632
-#define STEELSERIES_APEX_M750_PID                       0x0616
-#define STEELSERIES_APEX_OG_PID                         0x1202
-#define STEELSERIES_APEX_350_PID                        0x1206
-#define STEELSERIES_APEX_PRO3_PID                       0x1640
+#define STEELSERIES_APEX_3_PID                      0x161A
+#define STEELSERIES_APEX_3_TKL_PID                  0x1622
+#define STEELSERIES_APEX_5_PID                      0x161C
+#define STEELSERIES_APEX_7_PID                      0x1612
+#define STEELSERIES_APEX_7_TKL_PID                  0x1618
+#define STEELSERIES_APEX_9_TKL_PID                  0x1634
+#define STEELSERIES_APEX_9_MINI_PID                 0x1620
+#define STEELSERIES_APEX_PRO_PID                    0x1610
+#define STEELSERIES_APEX_PRO_TKL_PID                0x1614
+#define STEELSERIES_APEX_PRO_TKL_2023_PID           0x1628
+#define STEELSERIES_APEX_PRO_TKL_2023_WL_PID_1      0x1630
+#define STEELSERIES_APEX_PRO_TKL_2023_WL_PID_2      0x1632
+#define STEELSERIES_APEX_M750_PID                   0x0616
+#define STEELSERIES_APEX_OG_PID                     0x1202
+#define STEELSERIES_APEX_350_PID                    0x1206
+#define STEELSERIES_APEX_PRO3_PID                   0x1640
+#define STEELSERIES_APEX_PRO_TKL_GEN3_PID           0x1642
+#define STEELSERIES_APEX_PRO_TKL_GEN3_WL_PID_1      0x1644
+#define STEELSERIES_APEX_PRO_TKL_GEN3_WL_PID_2      0x1646
 
 DetectedControllers DetectSteelSeriesAerox3(hid_device_info* info, const std::string& name)
 {
@@ -612,3 +615,6 @@ REGISTER_HID_DETECTOR_I  ("SteelSeries Apex M750",                          Dete
 REGISTER_HID_DETECTOR_I  ("SteelSeries Apex (OG)/Apex Fnatic",              DetectSteelSeriesApexOld,   STEELSERIES_VID, STEELSERIES_APEX_OG_PID,                   	0  );
 REGISTER_HID_DETECTOR_I  ("SteelSeries Apex 350",                           DetectSteelSeriesApexOld,   STEELSERIES_VID, STEELSERIES_APEX_350_PID,                      0  );
 REGISTER_HID_DETECTOR_I  ("SteelSeries Apex Pro 3",                         DetectSteelSeriesApex,      STEELSERIES_VID, STEELSERIES_APEX_PRO3_PID,                     1  );
+REGISTER_HID_DETECTOR_I  ("SteelSeries Apex Pro TKL Gen 3",                DetectSteelSeriesApex,      STEELSERIES_VID, STEELSERIES_APEX_PRO_TKL_GEN3_PID,             1  );
+REGISTER_HID_DETECTOR_IPU("SteelSeries Apex Pro TKL Gen 3 Wireless",       DetectSteelSeriesApex,      STEELSERIES_VID, STEELSERIES_APEX_PRO_TKL_GEN3_WL_PID_1, 3, 0xFFC0, 1);
+REGISTER_HID_DETECTOR_IPU("SteelSeries Apex Pro TKL Gen 3 Wireless",       DetectSteelSeriesApex,      STEELSERIES_VID, STEELSERIES_APEX_PRO_TKL_GEN3_WL_PID_2, 3, 0xFFC0, 1);

Controllers/ThermaltakeRiingController/ThermaltakeRiingController/RGBController_ThermaltakeRiing.cpp

@@ -163,7 +163,8 @@ void RGBController_ThermaltakeRiing::SetupZones()
             zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/ThermaltakeRiingController/ThermaltakeRiingQuadController/RGBController_ThermaltakeRiingQuad.cpp

@@ -89,7 +89,8 @@ void RGBController_ThermaltakeRiingQuad::SetupZones()
             zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/ThermaltakeRiingController/ThermaltakeRiingTrioController/RGBController_ThermaltakeRiingTrio.cpp

@@ -89,7 +89,8 @@ void RGBController_ThermaltakeRiingTrio::SetupZones()
             zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/ZalmanZSyncController/RGBController_ZalmanZSync.cpp

@@ -266,7 +266,8 @@ void RGBController_ZalmanZSync::SetupZones()
             zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
                                                     | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/ZotacBlackwellGPUController/RGBController_ZotacBlackwellGPU.cpp

@@ -0,0 +1,356 @@
+/*---------------------------------------------------------*\
+| RGBController_ZotacBlackwellGPU.cpp                       |
+|                                                           |
+|   RGBController for ZOTAC Blackwell (RTX 50 series) GPU   |
+|                                                           |
+|   Eder Sánchez                                27 Mar 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_ZotacBlackwellGPU.h"
+
+/**------------------------------------------------------------------*\
+    @name ZOTAC RTX 50 series GPU
+    @category GPU
+    @type I2C
+    @save :robot:
+    @direct :x:
+    @effects :tools:
+    @detectors DetectZotacBlackwellGPUControllersPCI
+    @comment
+        Supports ZOTAC Blackwell (RTX 50 series) GPUs with 3 zones:
+        Logo, Side Bar, and Infinity Mirror.
+
+        The controller uses individual SMBus byte writes (registers
+        0x20-0x2F) with a 3ms delay between each transaction.
+
+        To add new cards, add PCI ID entries in `pci_ids/pci_ids.h`
+        and detection entries in
+        `Controllers/ZotacBlackwellGPUController/ZotacBlackwellGPUControllerDetect.cpp`.
+\*-------------------------------------------------------------------*/
+
+RGBController_ZotacBlackwellGPU::RGBController_ZotacBlackwellGPU(ZotacBlackwellGPUController* controller_ptr)
+{
+    controller              = controller_ptr;
+
+    name                    = controller->GetName();
+    vendor                  = "ZOTAC";
+    description             = "ZOTAC RTX 50 series RGB GPU Device (" + controller->GetVersion() + ")";
+    location                = controller->GetDeviceLocation();
+    type                    = DEVICE_TYPE_GPU;
+    version                 = controller->GetVersion();
+
+    /*---------------------------------------------------------*\
+    | Static mode                                               |
+    \*---------------------------------------------------------*/
+    mode STATIC;
+    STATIC.name             = "Static";
+    STATIC.value            = ZOTAC_BLACKWELL_GPU_MODE_STATIC;
+    STATIC.flags            = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
+    STATIC.brightness_min   = 0;
+    STATIC.brightness_max   = 100;
+    STATIC.brightness       = 100;
+    STATIC.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(STATIC);
+
+    /*---------------------------------------------------------*\
+    | Breathe mode                                              |
+    \*---------------------------------------------------------*/
+    mode BREATHE;
+    BREATHE.name            = "Breathe";
+    BREATHE.value           = ZOTAC_BLACKWELL_GPU_MODE_BREATHE;
+    BREATHE.flags           = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    BREATHE.brightness_min  = 0;
+    BREATHE.brightness_max  = 100;
+    BREATHE.brightness      = 100;
+    BREATHE.speed_min       = 0;
+    BREATHE.speed_max       = 100;
+    BREATHE.speed           = 20;
+    BREATHE.color_mode      = MODE_COLORS_PER_LED;
+    modes.push_back(BREATHE);
+
+    /*---------------------------------------------------------*\
+    | Fade mode                                                 |
+    \*---------------------------------------------------------*/
+    mode FADE;
+    FADE.name               = "Fade";
+    FADE.value              = ZOTAC_BLACKWELL_GPU_MODE_FADE;
+    FADE.flags              = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED;
+    FADE.speed_min          = 0;
+    FADE.speed_max          = 100;
+    FADE.speed              = 20;
+    FADE.color_mode         = MODE_COLORS_NONE;
+    modes.push_back(FADE);
+
+    /*---------------------------------------------------------*\
+    | Wink mode                                                 |
+    \*---------------------------------------------------------*/
+    mode WINK;
+    WINK.name               = "Wink";
+    WINK.value              = ZOTAC_BLACKWELL_GPU_MODE_WINK;
+    WINK.flags              = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    WINK.brightness_min     = 0;
+    WINK.brightness_max     = 100;
+    WINK.brightness         = 100;
+    WINK.speed_min          = 0;
+    WINK.speed_max          = 100;
+    WINK.speed              = 20;
+    WINK.color_mode         = MODE_COLORS_PER_LED;
+    modes.push_back(WINK);
+
+    /*---------------------------------------------------------*\
+    | Glide mode                                                |
+    \*---------------------------------------------------------*/
+    mode GLIDE;
+    GLIDE.name              = "Glide";
+    GLIDE.value             = ZOTAC_BLACKWELL_GPU_MODE_GLIDE;
+    GLIDE.flags             = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_PER_LED_COLOR;
+    GLIDE.brightness_min    = 0;
+    GLIDE.brightness_max    = 100;
+    GLIDE.brightness        = 100;
+    GLIDE.speed_min         = 0;
+    GLIDE.speed_max         = 100;
+    GLIDE.speed             = 20;
+    GLIDE.color_mode        = MODE_COLORS_PER_LED;
+    modes.push_back(GLIDE);
+
+    /*---------------------------------------------------------*\
+    | Prism mode (called "Rainbow" in older firmware)           |
+    \*---------------------------------------------------------*/
+    mode PRISM;
+    PRISM.name              = "Prism";
+    PRISM.value             = ZOTAC_BLACKWELL_GPU_MODE_PRISM;
+    PRISM.flags             = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    PRISM.speed_min         = 0;
+    PRISM.speed_max         = 100;
+    PRISM.speed             = 20;
+    PRISM.color_mode        = MODE_COLORS_NONE;
+    modes.push_back(PRISM);
+
+    /*---------------------------------------------------------*\
+    | Bokeh mode                                                |
+    \*---------------------------------------------------------*/
+    mode BOKEH;
+    BOKEH.name              = "Bokeh";
+    BOKEH.value             = ZOTAC_BLACKWELL_GPU_MODE_BOKEH;
+    BOKEH.flags             = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    BOKEH.brightness_min    = 0;
+    BOKEH.brightness_max    = 100;
+    BOKEH.brightness        = 100;
+    BOKEH.speed_min         = 0;
+    BOKEH.speed_max         = 100;
+    BOKEH.speed             = 20;
+    BOKEH.color_mode        = MODE_COLORS_PER_LED;
+    modes.push_back(BOKEH);
+
+    /*---------------------------------------------------------*\
+    | Beacon mode                                               |
+    \*---------------------------------------------------------*/
+    mode BEACON;
+    BEACON.name             = "Beacon";
+    BEACON.value            = ZOTAC_BLACKWELL_GPU_MODE_BEACON;
+    BEACON.flags            = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    BEACON.brightness_min   = 0;
+    BEACON.brightness_max   = 100;
+    BEACON.brightness       = 100;
+    BEACON.speed_min        = 0;
+    BEACON.speed_max        = 100;
+    BEACON.speed            = 20;
+    BEACON.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(BEACON);
+
+    /*---------------------------------------------------------*\
+    | Tandem mode                                               |
+    \*---------------------------------------------------------*/
+    mode TANDEM;
+    TANDEM.name             = "Tandem";
+    TANDEM.value            = ZOTAC_BLACKWELL_GPU_MODE_TANDEM;
+    TANDEM.flags            = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    TANDEM.brightness_min   = 0;
+    TANDEM.brightness_max   = 100;
+    TANDEM.brightness       = 100;
+    TANDEM.speed_min        = 0;
+    TANDEM.speed_max        = 100;
+    TANDEM.speed            = 20;
+    TANDEM.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(TANDEM);
+
+    /*---------------------------------------------------------*\
+    | Tidal mode                                                |
+    \*---------------------------------------------------------*/
+    mode TIDAL;
+    TIDAL.name              = "Tidal";
+    TIDAL.value             = ZOTAC_BLACKWELL_GPU_MODE_TIDAL;
+    TIDAL.flags             = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_PER_LED_COLOR;
+    TIDAL.brightness_min    = 0;
+    TIDAL.brightness_max    = 100;
+    TIDAL.brightness        = 100;
+    TIDAL.speed_min         = 0;
+    TIDAL.speed_max         = 100;
+    TIDAL.speed             = 20;
+    TIDAL.color_mode        = MODE_COLORS_PER_LED;
+    modes.push_back(TIDAL);
+
+    /*---------------------------------------------------------*\
+    | Astra mode                                                |
+    \*---------------------------------------------------------*/
+    mode ASTRA;
+    ASTRA.name              = "Astra";
+    ASTRA.value             = ZOTAC_BLACKWELL_GPU_MODE_ASTRA;
+    ASTRA.flags             = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    ASTRA.brightness_min    = 0;
+    ASTRA.brightness_max    = 100;
+    ASTRA.brightness        = 100;
+    ASTRA.speed_min         = 0;
+    ASTRA.speed_max         = 100;
+    ASTRA.speed             = 20;
+    ASTRA.color_mode        = MODE_COLORS_PER_LED;
+    modes.push_back(ASTRA);
+
+    /*---------------------------------------------------------*\
+    | Cosmic mode                                               |
+    \*---------------------------------------------------------*/
+    mode COSMIC;
+    COSMIC.name             = "Cosmic";
+    COSMIC.value            = ZOTAC_BLACKWELL_GPU_MODE_COSMIC;
+    COSMIC.flags            = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    COSMIC.brightness_min   = 0;
+    COSMIC.brightness_max   = 100;
+    COSMIC.brightness       = 100;
+    COSMIC.speed_min        = 0;
+    COSMIC.speed_max        = 100;
+    COSMIC.speed            = 20;
+    COSMIC.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(COSMIC);
+
+    /*---------------------------------------------------------*\
+    | Volta mode                                                |
+    \*---------------------------------------------------------*/
+    mode VOLTA;
+    VOLTA.name              = "Volta";
+    VOLTA.value             = ZOTAC_BLACKWELL_GPU_MODE_VOLTA;
+    VOLTA.flags             = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    VOLTA.brightness_min    = 0;
+    VOLTA.brightness_max    = 100;
+    VOLTA.brightness        = 100;
+    VOLTA.speed_min         = 0;
+    VOLTA.speed_max         = 100;
+    VOLTA.speed             = 20;
+    VOLTA.color_mode        = MODE_COLORS_PER_LED;
+    modes.push_back(VOLTA);
+
+    SetupZones();
+}
+
+RGBController_ZotacBlackwellGPU::~RGBController_ZotacBlackwellGPU()
+{
+    Shutdown();
+
+    delete controller;
+}
+
+void RGBController_ZotacBlackwellGPU::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Zone 0: Logo                                              |
+    \*---------------------------------------------------------*/
+    zone logo_zone;
+    logo_zone.name          = "Logo";
+    logo_zone.type          = ZONE_TYPE_SINGLE;
+    logo_zone.leds_min      = 1;
+    logo_zone.leds_max      = 1;
+    logo_zone.leds_count    = 1;
+    zones.push_back(logo_zone);
+
+    led logo_led;
+    logo_led.name           = "Logo LED";
+    leds.push_back(logo_led);
+
+    /*---------------------------------------------------------*\
+    | Zone 1: Side Bar                                          |
+    \*---------------------------------------------------------*/
+    zone sidebar_zone;
+    sidebar_zone.name       = "Side Bar";
+    sidebar_zone.type       = ZONE_TYPE_SINGLE;
+    sidebar_zone.leds_min   = 1;
+    sidebar_zone.leds_max   = 1;
+    sidebar_zone.leds_count = 1;
+    zones.push_back(sidebar_zone);
+
+    led sidebar_led;
+    sidebar_led.name        = "Side Bar LED";
+    leds.push_back(sidebar_led);
+
+    /*---------------------------------------------------------*\
+    | Zone 2: Infinity Mirror                                   |
+    \*---------------------------------------------------------*/
+    zone infinity_zone;
+    infinity_zone.name       = "Infinity Mirror";
+    infinity_zone.type       = ZONE_TYPE_SINGLE;
+    infinity_zone.leds_min   = 1;
+    infinity_zone.leds_max   = 1;
+    infinity_zone.leds_count = 1;
+    zones.push_back(infinity_zone);
+
+    led infinity_led;
+    infinity_led.name        = "Infinity Mirror LED";
+    leds.push_back(infinity_led);
+
+    SetupColors();
+}
+
+void RGBController_ZotacBlackwellGPU::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_ZotacBlackwellGPU::DeviceUpdateZoneLEDs(int zone)
+{
+    unsigned int mode_val   = modes[active_mode].value;
+    unsigned int brightness = modes[active_mode].brightness;
+    unsigned int speed      = modes[active_mode].speed;
+    unsigned int direction  = modes[active_mode].direction == MODE_DIRECTION_RIGHT
+                            ? ZOTAC_BLACKWELL_GPU_DIR_RIGHT
+                            : ZOTAC_BLACKWELL_GPU_DIR_LEFT;
+
+    RGBColor color1;
+    RGBColor color2 = ToRGBColor(0, 0, 0);
+
+    switch(modes[active_mode].color_mode)
+    {
+        case MODE_COLORS_PER_LED:
+            color1 = colors[zone];
+            break;
+
+        case MODE_COLORS_MODE_SPECIFIC:
+            color1 = (modes[active_mode].colors.size() >= 1)
+                   ? modes[active_mode].colors[0]
+                   : ToRGBColor(0, 0, 0);
+            color2 = (modes[active_mode].colors.size() >= 2)
+                   ? modes[active_mode].colors[1]
+                   : ToRGBColor(0, 0, 0);
+            break;
+
+        default:
+            color1 = ToRGBColor(0, 0, 0);
+            break;
+    }
+
+    controller->SetMode(zone, mode_val, color1, color2, brightness, speed, direction);
+    controller->Commit();
+}
+
+void RGBController_ZotacBlackwellGPU::DeviceUpdateSingleLED(int led)
+{
+    DeviceUpdateZoneLEDs(led);
+}
+
+void RGBController_ZotacBlackwellGPU::DeviceUpdateMode()
+{
+    for(unsigned int zone_idx = 0; zone_idx < ZOTAC_BLACKWELL_GPU_NUM_ZONES; zone_idx++)
+    {
+        DeviceUpdateZoneLEDs(zone_idx);
+    }
+}

Controllers/ZotacBlackwellGPUController/RGBController_ZotacBlackwellGPU.h

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------*\
+| RGBController_ZotacBlackwellGPU.h                         |
+|                                                           |
+|   RGBController for ZOTAC Blackwell (RTX 50 series) GPU   |
+|                                                           |
+|   Eder Sánchez                                27 Mar 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ZotacBlackwellGPUController.h"
+
+class RGBController_ZotacBlackwellGPU : public RGBController
+{
+public:
+    RGBController_ZotacBlackwellGPU(ZotacBlackwellGPUController* controller_ptr);
+    ~RGBController_ZotacBlackwellGPU();
+
+    void SetupZones();
+
+    void DeviceUpdateLEDs();
+    void DeviceUpdateZoneLEDs(int zone);
+    void DeviceUpdateSingleLED(int led);
+
+    void DeviceUpdateMode();
+
+private:
+    ZotacBlackwellGPUController* controller;
+};