Zone and Segment type updates

* Add zone flags to indicate if fields are manually configurable and if they have been manually configured
  * Add flags field to segment type
  * Add segment flags for group start and group member
  * Add color mode support flags to zone (RGB, RBG, GRB, GBR, BRG, BGR)
  * Add color mode enum to zone
  * Update zone and segment description functions to support new fields
  * Rename the effects-only configurable size flag
  * Remove zone type and matrix map configuration from E1.31 manual configuration, use zone editor instead
  * Rework DeviceResizeZone to DeviceConfigureZone
  * Rework most ARGB controllers to allow zone customizations
  * Rework DRGBController to define devices in DRGBDevices list (similar to RazerDevices)
  * Rework NollieController to define devices in NollieDevices list (similar to RazerDevices)

.gitlab-ci.yml

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

.gitlab/CODEOWNERS

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

CONTRIBUTING.md

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

Controllers/AOCKeyboardController/AOCKeyboardController.cpp

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

Controllers/AOCMouseController/AOCMouseController.cpp

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

Controllers/AOCMousematController/AOCMousematController.cpp

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

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -228,8 +228,7 @@ 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_SEGMENTS;
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
             }
 
             if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/ASRockASRRGBSMBusController.cpp

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

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/ASRockPolychromeV1SMBusController.cpp

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

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/ASRockPolychromeV2SMBusController.cpp

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

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*>& buses)
+DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
 {
     DetectedControllers detected_controllers;
 
-    for(unsigned int bus = 0; bus < buses.size(); bus++)
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
-        IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
+        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            if(buses[bus]->info.pci_subsystem_vendor == ASROCK_SUB_VEN)
+            if(busses[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(buses[bus], SMBUS_ADDRESS))
+                if(TestForPolychromeSMBusController(busses[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(buses[bus], SMBUS_ADDRESS);
+                    version.u16 = GetFirmwareVersion(busses[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(buses[bus], SMBUS_ADDRESS);
+                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(busses[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(buses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(busses[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(buses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(busses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockPolychromeV2SMBus* rgb_controller = new RGBController_ASRockPolychromeV2SMBus(controller);
                                 detected_controllers.push_back(rgb_controller);

Controllers/AsusAuraGPUController/AsusAuraGPUController.cpp

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

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

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

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.cpp

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

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -170,8 +170,7 @@ 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_SEGMENTS;
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
             }
 
             if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -120,7 +120,6 @@
 #define AURA_TERMINAL_PID                                   0x1889
 #define ROG_STRIX_LC120_PID                                 0x879E
 #define AURA_RYUO_AIO_PID                                   0x1887
-#define AURA_RYUJIN_AIO_PID                                 0x18AE
 #define ASUS_ROG_ALLY_PID                                   0x1ABE
 #define ASUS_ROG_ALLY_X_PID                                 0x1B4C
 
@@ -524,7 +523,6 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG PG32UQ",                             DetectAs
 REGISTER_HID_DETECTOR    ("ASUS ROG AURA Terminal",                     DetectAsusAuraUSBTerminal,      AURA_USB_VID, AURA_TERMINAL_PID);
 REGISTER_HID_DETECTOR_PU ("ASUS ROG Strix LC",                          DetectAsusAuraUSBROGStrixLC,    AURA_USB_VID, ROG_STRIX_LC120_PID,                          0x00FF, 1);
 REGISTER_HID_DETECTOR_PU ("ASUS ROG Ryuo AIO",                          DetectAsusAuraUSBRyuoAIO,       AURA_USB_VID, AURA_RYUO_AIO_PID,                        0xFF72, 0x00A1);
-REGISTER_HID_DETECTOR_PU ("ASUS ROG Ryujin AIO",                        DetectAsusAuraUSBRyuoAIO,       AURA_USB_VID, AURA_RYUJIN_AIO_PID,                     0xFF72, 0x00A1);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne",                            DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_PID,                          0);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI",                         DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID,                       0);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI GUNDAM",                  DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_GUNDAM_PID,                0);

Controllers/BlinkyTapeController/RGBController_BlinkyTape.cpp

@@ -79,8 +79,7 @@ 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_SEGMENTS;
+                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
     }
 
     if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/ColorfulGPUController/ColorfulGPUController.cpp

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

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -76,6 +76,3 @@ 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/ColorfulTuringGPUController/ColorfulTuringGPUController.cpp

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

Controllers/ColorfulTuringGPUController/ColorfulTuringGPUControllerDetect.cpp

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

Controllers/CoolerMasterController/CMARGBController/RGBController_CMARGBController.cpp

@@ -406,8 +406,7 @@ 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_SEGMENTS;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
         }
 
         if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/CoolerMasterController/CMSmallARGBController/RGBController_CMSmallARGBController.cpp

@@ -217,8 +217,7 @@ 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_SEGMENTS;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.cpp

@@ -111,8 +111,7 @@ 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_SEGMENTS;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
         }
 
         if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
@@ -165,8 +164,7 @@ 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_SEGMENTS;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/CorsairDRAMController/CorsairDRAMController.cpp

@@ -1,422 +0,0 @@
-/*---------------------------------------------------------*\
-| 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->info.device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-std::string 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

@@ -1,149 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,96 +0,0 @@
-/*---------------------------------------------------------*\
-| 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 == 0x01 || res == 0x03 || res == 0x04))
-    {
-        LOG_DEBUG("[%s] Failed: expected 0x01, 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]->info.pci_vendor, buses[bus]->info.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

@@ -1,163 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,68 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,324 +0,0 @@
-/*---------------------------------------------------------*\
-| 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/CorsairDominatorPlatinumController/CorsairDominatorPlatinumController.cpp

@@ -0,0 +1,134 @@
+/*---------------------------------------------------------*\
+| 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

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------*\
+| 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

@@ -0,0 +1,168 @@
+/*---------------------------------------------------------*\
+| 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

@@ -0,0 +1,128 @@
+/*---------------------------------------------------------*\
+| 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/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.h

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

Controllers/CorsairHydroPlatinumController/RGBController_CorsairHydroPlatinum.cpp

@@ -110,8 +110,7 @@ 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_SEGMENTS;
+                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
         }
 
         if(!(zones[1].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp

@@ -332,8 +332,7 @@ 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_SEGMENTS;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/CorsairVengeanceController/CorsairVengeanceController.cpp

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

Controllers/CorsairVengeanceProController/CorsairVengeanceProController.cpp

@@ -0,0 +1,213 @@
+/*---------------------------------------------------------*\
+| 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

@@ -0,0 +1,109 @@
+/*---------------------------------------------------------*\
+| 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

@@ -0,0 +1,89 @@
+/*---------------------------------------------------------*\
+| 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

@@ -0,0 +1,310 @@
+/*---------------------------------------------------------*\
+| 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

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------*\
+| 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/CreativeSoundBlasterXG6Controller.cpp

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

Controllers/CreativeController/RGBController_CreativeSoundBlasterAE5_Windows.cpp

@@ -87,8 +87,7 @@ 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_SEGMENTS;
+                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
     }
 
     if(!(zones[1].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/CrucialController/CrucialController.cpp

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

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*> &buses)
+DetectedControllers DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses)
 {
     DetectedControllers detected_controllers;
 
-    for(unsigned int bus = 0; bus < buses.size(); bus++)
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         int address_list_idx = -1;
 
-        IF_DRAM_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
+        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
             for(unsigned int slot = 0; slot < 4; slot++)
             {
-                int res = buses[bus]->i2c_smbus_write_quick(0x27, I2C_SMBUS_WRITE);
+                int res = busses[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 = buses[bus]->i2c_smbus_write_quick(crucial_addresses[address_list_idx], I2C_SMBUS_WRITE);
+                        res = busses[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(buses[bus], 0x27, 0x82EE, slot);
-                    CrucialRegisterWrite(buses[bus], 0x27, 0x82EF, (crucial_addresses[address_list_idx] << 1));
-                    CrucialRegisterWrite(buses[bus], 0x27, 0x82F0, 0xF0);
+                    CrucialRegisterWrite(busses[bus], 0x27, 0x82EE, slot);
+                    CrucialRegisterWrite(busses[bus], 0x27, 0x82EF, (crucial_addresses[address_list_idx] << 1));
+                    CrucialRegisterWrite(busses[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, buses[bus]->info.pci_vendor, buses[bus]->info.pci_device, TESTING_ADDRESSES);
+            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);
 
             // 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(buses[bus], crucial_addresses[address_list_idx]))
+                if(TestForCrucialController(busses[bus], crucial_addresses[address_list_idx]))
                 {
-                    CrucialController*     controller     = new CrucialController(buses[bus], crucial_addresses[address_list_idx]);
+                    CrucialController*     controller     = new CrucialController(busses[bus], crucial_addresses[address_list_idx]);
                     RGBController_Crucial* rgb_controller = new RGBController_Crucial(controller);
 
                     detected_controllers.push_back(rgb_controller);

Controllers/DDPController/DDPControllerDetect.cpp

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

Controllers/DRGBController/RGBController_DRGB.cpp

@@ -85,8 +85,7 @@ 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_SEGMENTS;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
         }
 
         if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/DebugController/RGBController_Debug.cpp

@@ -13,7 +13,6 @@
 #include <algorithm>
 #include <cstring>
 #include "KeyboardLayoutManager.h"
-#include "JsonUtils.h"
 #include "RGBController_Debug.h"
 
 /**------------------------------------------------------------------*\
@@ -55,69 +54,80 @@ RGBController_Debug::RGBController_Debug(bool custom, json settings)
     if(custom_controller)
     {
         /*-------------------------------------------------*\
-        | Set the name, description, location, version, and |
-        | serial                                            |
+        | Set the name                                      |
         \*-------------------------------------------------*/
-        name                            = JsonUtils::JsonGetString(debug_settings, "DeviceName", "Custom Device");
-        description                     = JsonUtils::JsonGetString(debug_settings, "DeviceDescription");
-        location                        = JsonUtils::JsonGetString(debug_settings, "DeviceLocation");
-        version                         = JsonUtils::JsonGetString(debug_settings, "DeviceVersion");
-        serial                          = JsonUtils::JsonGetString(debug_settings, "DeviceSerial");
+        name = debug_settings["DeviceName"];
 
         /*-------------------------------------------------*\
         | Find the device type                              |
         \*-------------------------------------------------*/
-        std::string device_type         = JsonUtils::JsonGetString(debug_settings, "DeviceType", "keyboard");
+        if      (debug_settings["DeviceType"] == "motherboard")   type = DEVICE_TYPE_MOTHERBOARD;
+        else if (debug_settings["DeviceType"] == "dram")          type = DEVICE_TYPE_DRAM;
+        else if (debug_settings["DeviceType"] == "gpu")           type = DEVICE_TYPE_GPU;
+        else if (debug_settings["DeviceType"] == "cooler")        type = DEVICE_TYPE_COOLER;
+        else if (debug_settings["DeviceType"] == "led_strip")     type = DEVICE_TYPE_LEDSTRIP;
+        else if (debug_settings["DeviceType"] == "keyboard")      type = DEVICE_TYPE_KEYBOARD;
+        else if (debug_settings["DeviceType"] == "mouse")         type = DEVICE_TYPE_MOUSE;
+        else if (debug_settings["DeviceType"] == "mousemat")      type = DEVICE_TYPE_MOUSEMAT;
+        else if (debug_settings["DeviceType"] == "headset")       type = DEVICE_TYPE_HEADSET;
+        else if (debug_settings["DeviceType"] == "headset_stand") type = DEVICE_TYPE_HEADSET_STAND;
+        else if (debug_settings["DeviceType"] == "gamepad")       type = DEVICE_TYPE_GAMEPAD;
+        else if (debug_settings["DeviceType"] == "light")         type = DEVICE_TYPE_LIGHT;
+        else if (debug_settings["DeviceType"] == "speaker")       type = DEVICE_TYPE_SPEAKER;
+        else if (debug_settings["DeviceType"] == "unknown")       type = DEVICE_TYPE_UNKNOWN;
 
-        if(     device_type == "motherboard")   type = DEVICE_TYPE_MOTHERBOARD;
-        else if(device_type == "dram")          type = DEVICE_TYPE_DRAM;
-        else if(device_type == "gpu")           type = DEVICE_TYPE_GPU;
-        else if(device_type == "cooler")        type = DEVICE_TYPE_COOLER;
-        else if(device_type == "led_strip")     type = DEVICE_TYPE_LEDSTRIP;
-        else if(device_type == "keyboard")      type = DEVICE_TYPE_KEYBOARD;
-        else if(device_type == "mouse")         type = DEVICE_TYPE_MOUSE;
-        else if(device_type == "mousemat")      type = DEVICE_TYPE_MOUSEMAT;
-        else if(device_type == "headset")       type = DEVICE_TYPE_HEADSET;
-        else if(device_type == "headset_stand") type = DEVICE_TYPE_HEADSET_STAND;
-        else if(device_type == "gamepad")       type = DEVICE_TYPE_GAMEPAD;
-        else if(device_type == "light")         type = DEVICE_TYPE_LIGHT;
-        else if(device_type == "speaker")       type = DEVICE_TYPE_SPEAKER;
-        else if(device_type == "unknown")       type = DEVICE_TYPE_UNKNOWN;
+        /*-------------------------------------------------*\
+        | Set description, location, version, and serial    |
+        \*-------------------------------------------------*/
+        description                             = debug_settings["DeviceDescription"];
+        location                                = debug_settings["DeviceLocation"];
+        version                                 = debug_settings["DeviceVersion"];
+        serial                                  = debug_settings["DeviceSerial"];
     }
     else
     {
-        std::string name_setting        = JsonUtils::JsonGetString(debug_settings, "name");
-        std::string type_setting        = JsonUtils::JsonGetString(debug_settings, "type", "keyboard");
+        std::string name_setting    = "";
+        std::string type_setting    = "keyboard";
+
+        if(debug_settings.contains("name"))
+        {
+            name_setting = debug_settings["name"];
+        }
+
+        if(debug_settings.contains("type"))
+        {
+            type_setting = debug_settings["type"];
+        }
 
         if(type_setting == "motherboard")
         {
-            name                        = "Debug Motherboard";
-            type                        = DEVICE_TYPE_MOTHERBOARD;
+            name                = "Debug Motherboard";
+            type                = DEVICE_TYPE_MOTHERBOARD;
         }
         else if(type_setting == "dram")
         {
-            name                        = "Debug DRAM";
-            type                        = DEVICE_TYPE_DRAM;
+            name                = "Debug DRAM";
+            type                = DEVICE_TYPE_DRAM;
         }
         else if(type_setting == "gpu")
         {
-            name                        = "Debug GPU";
-            type                        = DEVICE_TYPE_GPU;
+            name                = "Debug GPU";
+            type                = DEVICE_TYPE_GPU;
         }
         else if(type_setting == "keyboard")
         {
-            name                        = "Debug Keyboard";
-            type                        = DEVICE_TYPE_KEYBOARD;
+            name                = "Debug Keyboard";
+            type                = DEVICE_TYPE_KEYBOARD;
         }
       else if(type_setting == "mouse")
         {
-            name                        = "Debug Mouse";
-            type                        = DEVICE_TYPE_MOUSE;
+            name                = "Debug Mouse";
+            type                = DEVICE_TYPE_MOUSE;
         }
         else if(type_setting == "argb")
         {
-            name                        = "Debug ARGB Controller";
-            type                        = DEVICE_TYPE_LEDSTRIP;
+            name                = "Debug ARGB Controller";
+            type                = DEVICE_TYPE_LEDSTRIP;
         }
 
         /*---------------------------------------------------------*\
@@ -133,41 +143,6 @@ RGBController_Debug::RGBController_Debug(bool custom, json settings)
         {
             name                        = name_setting;
         }
-
-        /*---------------------------------------------------------*\
-        | Create test configuration                                 |
-        \*---------------------------------------------------------*/
-        nlohmann::json configuration_json;
-        JsonUtils::JsonParse(configuration, configuration_json);
-
-        configuration_json["schema"]["test_string"]["title"]     = "String Setting";
-        configuration_json["schema"]["test_string"]["type"]      = "string";
-
-        configuration_json["schema"]["test_bool"]["title"]       = "Boolean Setting";
-        configuration_json["schema"]["test_bool"]["type"]        = "bool";
-
-        configuration_json["schema"]["test_enum"]["title"]       = "String Enum Setting";
-        configuration_json["schema"]["test_enum"]["type"]        = "string";
-        configuration_json["schema"]["test_enum"]["enum"][0]     = "Option 1";
-        configuration_json["schema"]["test_enum"]["enum"][1]     = "Option 2";
-        configuration_json["schema"]["test_enum"]["enum"][2]     = "Option 3";
-
-        configuration_json["schema"]["test_enum_int"]["title"]   = "Integer Enum Setting";
-        configuration_json["schema"]["test_enum_int"]["type"]    = "integer";
-        configuration_json["schema"]["test_enum_int"]["enum"][0] = 2;
-        configuration_json["schema"]["test_enum_int"]["enum"][1] = 4;
-        configuration_json["schema"]["test_enum_int"]["enum"][2] = 8;
-
-        configuration_json["schema"]["test_int"]["title"]        = "Integer Setting";
-        configuration_json["schema"]["test_int"]["type"]         = "integer";
-
-        configuration_json["configuration"]["test_string"]       = "This is a test";
-        configuration_json["configuration"]["test_bool"]         = true;
-        configuration_json["configuration"]["test_enum"]         = "Option 2";
-        configuration_json["configuration"]["test_enum_int"]     = 4;
-        configuration_json["configuration"]["test_int"]          = 12345;
-
-        configuration = configuration_json.dump();
     }
 
     /*-----------------------------------------------------*\
@@ -206,7 +181,6 @@ void RGBController_Debug::SetupZones()
     /*-------------------------------------------------*\
     | Clear any existing color/LED configuration        |
     \*-------------------------------------------------*/
-    led_alt_names.clear();
     leds.clear();
     colors.clear();
 
@@ -242,9 +216,9 @@ void RGBController_Debug::SetupZones()
                 continue;
             }
 
-            custom_zone.leds_min        = JsonUtils::JsonGetInt(ZoneJson, "leds_min");
-            custom_zone.leds_max        = JsonUtils::JsonGetInt(ZoneJson, "leds_max");
-            custom_zone.leds_count      = JsonUtils::JsonGetInt(ZoneJson, "leds_count");
+            custom_zone.leds_min   = ZoneJson["leds_min"];
+            custom_zone.leds_max   = ZoneJson["leds_max"];
+            custom_zone.leds_count = ZoneJson["leds_count"];
 
             /*---------------------------------------------*\
             | Fill in the matrix map                        |
@@ -267,8 +241,8 @@ void RGBController_Debug::SetupZones()
                     continue;
                 }
 
-                unsigned int H                  = JsonUtils::JsonGetInt(ZoneJson, "matrix_width");
-                unsigned int W                  = JsonUtils::JsonGetInt(ZoneJson, "matrix_height");
+                unsigned int H                  = ZoneJson["matrix_width"];
+                unsigned int W                  = ZoneJson["matrix_height"];
 
                 BadVal                          = ((unsigned int)ZoneJson["matrix_map"].size() != H);
 
@@ -359,11 +333,36 @@ void RGBController_Debug::SetupZones()
     }
     else
     {
-        bool    zone_single             = JsonUtils::JsonGetBool(debug_settings, "single", true);
-        bool    zone_linear             = JsonUtils::JsonGetBool(debug_settings, "linear", true);
-        bool    zone_resizable          = JsonUtils::JsonGetBool(debug_settings, "resizable", false);
-        bool    zone_keyboard           = JsonUtils::JsonGetBool(debug_settings, "keyboard", false);
-        bool    zone_underglow          = JsonUtils::JsonGetBool(debug_settings, "underglow", false);
+        bool    zone_single             = true;
+        bool    zone_linear             = true;
+        bool    zone_resizable          = false;
+        bool    zone_keyboard           = false;
+        bool    zone_underglow          = false;
+
+        if(debug_settings.contains("single"))
+        {
+            zone_single = debug_settings["single"];
+        }
+
+        if(debug_settings.contains("linear"))
+        {
+            zone_linear = debug_settings["linear"];
+        }
+
+        if(debug_settings.contains("resizable"))
+        {
+            zone_resizable = debug_settings["resizable"];
+        }
+
+        if(debug_settings.contains("keyboard"))
+        {
+            zone_keyboard = debug_settings["keyboard"];
+        }
+
+        if(debug_settings.contains("underglow"))
+        {
+            zone_underglow = debug_settings["underglow"];
+        }
 
         /*-------------------------------------------------*\
         | Create a single zone/LED                          |
@@ -372,23 +371,21 @@ void RGBController_Debug::SetupZones()
         {
             zone single_zone;
 
+            single_zone.name            = "Single Zone";
+            single_zone.type            = ZONE_TYPE_SINGLE;
+            single_zone.leds_min        = 1;
+            single_zone.leds_max        = 1;
+            single_zone.leds_count      = 1;
+
             if(first_run)
             {
                 zones.push_back(single_zone);
             }
-
-            zones[zone_idx].name        = "Single Zone";
-            zones[zone_idx].type        = ZONE_TYPE_SINGLE;
-
-            if(first_run)
+            else
             {
-                zones[zone_idx].flags   = ZONE_FLAG_MANUALLY_CONFIGURABLE_DEVICE_SPECIFIC;
+                zones[zone_idx] = single_zone;
             }
 
-            zones[zone_idx].leds_min    = 1;
-            zones[zone_idx].leds_max    = 1;
-            zones[zone_idx].leds_count  = 1;
-
             led single_led;
 
             single_led.name             = "Single LED";
@@ -397,27 +394,6 @@ void RGBController_Debug::SetupZones()
 
             led_alt_names.push_back("");
 
-            nlohmann::json configuration_json;
-            JsonUtils::JsonParse(configuration, configuration_json);
-
-            if(first_run)
-            {
-                /*-----------------------------------------*\
-                | Create test configuration                 |
-                \*-----------------------------------------*/
-                configuration_json["zones"][zone_idx]["schema"]["color_order"]["title"]     = "Color Order";
-                configuration_json["zones"][zone_idx]["schema"]["color_order"]["type"]      = "string";
-                configuration_json["zones"][zone_idx]["schema"]["color_order"]["enum"][0]   = "RGB";
-                configuration_json["zones"][zone_idx]["schema"]["color_order"]["enum"][1]   = "GRB";
-            }
-
-            if((zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_DEVICE_SPECIFIC) == 0)
-            {
-                configuration_json["zones"][zone_idx]["configuration"]["color_order"]       = "RGB";
-            }
-
-            configuration = configuration_json.dump();
-
             zone_idx++;
         }
 
@@ -428,18 +404,22 @@ void RGBController_Debug::SetupZones()
         {
             zone linear_zone;
 
+            linear_zone.name            = "Linear Zone";
+            linear_zone.type            = ZONE_TYPE_LINEAR;
+            linear_zone.leds_min        = 10;
+            linear_zone.leds_max        = 10;
+            linear_zone.leds_count      = 10;
+
             if(first_run)
             {
                 zones.push_back(linear_zone);
             }
+            else
+            {
+                zones[zone_idx] = linear_zone;
+            }
 
-            zones[zone_idx].name        = "Linear Zone";
-            zones[zone_idx].type        = ZONE_TYPE_LINEAR;
-            zones[zone_idx].leds_min    = 10;
-            zones[zone_idx].leds_max    = 10;
-            zones[zone_idx].leds_count  = 10;
-
-            for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
+            for(std::size_t led_idx = 0; led_idx < 10; led_idx++)
             {
                 led linear_led;
 
@@ -461,24 +441,6 @@ void RGBController_Debug::SetupZones()
             KEYBOARD_LAYOUT layout              = KEYBOARD_LAYOUT::KEYBOARD_LAYOUT_ANSI_QWERTY;
             KEYBOARD_SIZE   size                = KEYBOARD_SIZE::KEYBOARD_SIZE_FULL;
 
-            nlohmann::json configuration_json;
-            JsonUtils::JsonParse(configuration, configuration_json);
-
-            zone keyboard_zone;
-
-            if(first_run)
-            {
-                zones.push_back(keyboard_zone);
-            }
-
-            zones[zone_idx].name                = "Keyboard Zone";
-            zones[zone_idx].type                = ZONE_TYPE_MATRIX;
-
-            if(first_run)
-            {
-                zones[zone_idx].flags           = ZONE_FLAG_MANUALLY_CONFIGURABLE_DEVICE_SPECIFIC | ZONE_FLAG_ZONE_GEOMETRY_MAY_CHANGE;
-            }
-
             if(debug_settings.contains("layout"))
             {
                 KEYBOARD_LAYOUT temp_layout = debug_settings["layout"];
@@ -489,29 +451,6 @@ void RGBController_Debug::SetupZones()
                 }
             }
 
-            if(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_DEVICE_SPECIFIC)
-            {
-                if(configuration_json.contains("zones") && (zone_idx < (int)configuration_json["zones"].size()))
-                {
-                    if(configuration_json["zones"][zone_idx].contains("configuration"))
-                    {
-                        if(configuration_json["zones"][zone_idx]["configuration"].contains("layout"))
-                        {
-                            std::string layout_string = configuration_json["zones"][zone_idx]["configuration"]["layout"];
-
-                            for(std::size_t layout_idx = 0; layout_idx < NUM_LAYOUTS; layout_idx++)
-                            {
-                                if(layout_names[layout_idx] == layout_string)
-                                {
-                                    layout = (KEYBOARD_LAYOUT)layout_idx;
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
             if(debug_settings.contains("size"))
             {
                 size = debug_settings["size"];
@@ -519,6 +458,8 @@ void RGBController_Debug::SetupZones()
 
             KeyboardLayoutManager new_kb(layout, size);
 
+            description                        += ", Layout: " + layout_names[layout] + ", Size: " + new_kb.GetName();
+
             /*---------------------------------------------*\
             | Check for custom key inserts and swaps        |
             \*---------------------------------------------*/
@@ -577,12 +518,25 @@ void RGBController_Debug::SetupZones()
                 new_kb.ChangeKeys(change);
             }
 
-            zones[zone_idx].leds_min            = new_kb.GetKeyCount();
-            zones[zone_idx].leds_max            = new_kb.GetKeyCount();
-            zones[zone_idx].leds_count          = new_kb.GetKeyCount();
-            zones[zone_idx].matrix_map          = new_kb.GetKeyMap(KEYBOARD_MAP_FILL_TYPE_COUNT);
+            zone keyboard_zone;
 
-            for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
+            keyboard_zone.name                  = "Keyboard Zone";
+            keyboard_zone.type                  = ZONE_TYPE_MATRIX;
+            keyboard_zone.leds_min              = new_kb.GetKeyCount();
+            keyboard_zone.leds_max              = new_kb.GetKeyCount();
+            keyboard_zone.leds_count            = new_kb.GetKeyCount();
+            keyboard_zone.matrix_map = new_kb.GetKeyMap(KEYBOARD_MAP_FILL_TYPE_COUNT);
+
+            if(first_run)
+            {
+                zones.push_back(keyboard_zone);
+            }
+            else
+            {
+                zones[zone_idx] = keyboard_zone;
+            }
+
+            for(unsigned int led_idx = 0; led_idx < keyboard_zone.leds_count; led_idx++)
             {
                 led keyboard_led;
 
@@ -593,28 +547,6 @@ void RGBController_Debug::SetupZones()
                 led_alt_names.push_back(new_kb.GetKeyAltNameAt(led_idx));
             }
 
-            if(first_run)
-            {
-                /*-----------------------------------------*\
-                | Create test configuration                 |
-                \*-----------------------------------------*/
-                configuration_json["zones"][zone_idx]["schema"]["layout"]["title"]      = "Layout";
-                configuration_json["zones"][zone_idx]["schema"]["layout"]["type"]       = "string";
-                configuration_json["zones"][zone_idx]["schema"]["layout"]["enum"][0]    = "Default",
-                configuration_json["zones"][zone_idx]["schema"]["layout"]["enum"][1]    = "ANSI QWERTY";
-                configuration_json["zones"][zone_idx]["schema"]["layout"]["enum"][2]    = "ISO QWERTY";
-                configuration_json["zones"][zone_idx]["schema"]["layout"]["enum"][3]    = "ISO QWERTZ";
-                configuration_json["zones"][zone_idx]["schema"]["layout"]["enum"][4]    = "ISO AZERTY";
-                configuration_json["zones"][zone_idx]["schema"]["layout"]["enum"][5]    = "JIS";
-            }
-
-            if((zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_DEVICE_SPECIFIC) == 0)
-            {
-                configuration_json["zones"][zone_idx]["configuration"]["layout"]        = "Default";
-            }
-
-            configuration = configuration_json.dump();
-
             zone_idx++;
         }
 
@@ -670,8 +602,7 @@ 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_SEGMENTS;
+                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
                 zones.push_back(resizable_zone);
             }
 
@@ -742,13 +673,3 @@ void RGBController_Debug::DeviceUpdateMode()
 {
 
 }
-
-void RGBController_Debug::DeviceUpdateDeviceSpecificConfiguration()
-{
-
-}
-
-void RGBController_Debug::DeviceUpdateDeviceSpecificZoneConfiguration(int zone)
-{
-    SetupZones();
-}

Controllers/DebugController/RGBController_Debug.h

@@ -33,9 +33,6 @@ public:
 
     void        DeviceUpdateMode();
 
-    void        DeviceUpdateDeviceSpecificConfiguration();
-    void        DeviceUpdateDeviceSpecificZoneConfiguration(int zone);
-
 private:
     json        debug_settings;
     bool        custom_controller;

Controllers/E131Controller/RGBController_E131.cpp

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

Controllers/ENESMBusController/ENESMBusController.cpp

@@ -53,7 +53,7 @@ ENESMBusController::ENESMBusController(ENESMBusInterface* interface, ene_dev_id
         | If this is running with TRACE or higher loglevel  |
         | then dump the entire Feature list to log          |
         \*-------------------------------------------------*/
-        if(LogManager::get()->GetLogLevel() >= LL_TRACE)
+        if(LogManager::get()->getLoglevel() >= LL_TRACE)
         {
             LOG_TRACE("[ENE SMBus] ENE config table for 0x%02X:", dev);
             LOG_TRACE("    %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X", config_table[0],  config_table[1],  config_table[2],  config_table[3],
@@ -266,21 +266,6 @@ 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  (sizeof(ene_ram_addresses) / sizeof(ene_ram_addresses[0]))
+#define ENE_RAM_ADDRESS_COUNT  23
 
 static const unsigned char ene_ram_addresses[] =
 {
@@ -47,7 +47,14 @@ static const unsigned char ene_ram_addresses[] =
     0x74,
     0x75,
     0x76,
-    0x77,
+    0x78,
+    0x79,
+    0x7A,
+    0x7B,
+    0x7C,
+    0x7D,
+    0x7E,
+    0x7F,
     0x4F,
     0x66,
     0x67,
@@ -62,7 +69,7 @@ static const unsigned char ene_ram_addresses[] =
 | This list contains the available SMBus addresses for      |
 | mapping Aura motherboards                                 |
 \*---------------------------------------------------------*/
-#define AURA_MOBO_ADDRESS_COUNT (sizeof(aura_mobo_addresses) / sizeof(aura_mobo_addresses[0]))
+#define AURA_MOBO_ADDRESS_COUNT 3
 
 static const unsigned char aura_mobo_addresses[] =
 {
@@ -146,21 +153,21 @@ bool TestForENESMBusController(i2c_smbus_interface* bus, unsigned char address)
     return(pass);
 }
 
-DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interface*> &buses)
+DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
 {
     DetectedControllers detected_controllers;
 
-    for(unsigned int bus = 0; bus < buses.size(); bus++)
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         int address_list_idx = -1;
 
-        IF_DRAM_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
+        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[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 = buses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
+                int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
 
                 if(res < 0)
                 {
@@ -172,11 +179,11 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
                 {
                     address_list_idx++;
 
-                    if(address_list_idx < (int)ENE_RAM_ADDRESS_COUNT)
+                    if(address_list_idx < 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 = buses[bus]->i2c_smbus_write_quick(ene_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
+                        res = busses[bus]->i2c_smbus_write_quick(ene_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
                     }
                     else
                     {
@@ -184,21 +191,21 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
                     }
                 } while(res >= 0);
 
-                if(address_list_idx < (int)ENE_RAM_ADDRESS_COUNT)
+                if(address_list_idx < ENE_RAM_ADDRESS_COUNT)
                 {
                     LOG_DEBUG("[ENE SMBus DRAM] Remapping slot %d to address %02X", slot, ene_ram_addresses[address_list_idx]);
 
-                    ENERegisterWrite(buses[bus], 0x77, ENE_REG_SLOT_INDEX, slot);
-                    ENERegisterWrite(buses[bus], 0x77, ENE_REG_I2C_ADDRESS, (ene_ram_addresses[address_list_idx] << 1));
+                    ENERegisterWrite(busses[bus], 0x77, ENE_REG_SLOT_INDEX, slot);
+                    ENERegisterWrite(busses[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(buses[bus], ene_ram_addresses[address_list_idx]))
+                if(TestForENESMBusController(busses[bus], ene_ram_addresses[address_list_idx]))
                 {
-                    ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(buses[bus]);
+                    ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(busses[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);
 
@@ -213,26 +220,26 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
     return(detected_controllers);
 }
 
-DetectedControllers DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &buses)
+DetectedControllers DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &busses)
 {
     DetectedControllers detected_controllers;
 
-    for(unsigned int bus = 0; bus < buses.size(); bus++)
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         // Add ENE (ASUS Aura) motherboard controllers
-        IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
+        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            if(buses[bus]->info.pci_subsystem_vendor == ASUS_SUB_VEN || buses[bus]->info.pci_subsystem_vendor == 0 || buses[bus]->info.pci_subsystem_vendor == 0xFFFF)
+            if(busses[bus]->pci_subsystem_vendor == ASUS_SUB_VEN || busses[bus]->pci_subsystem_vendor == 0 || busses[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(buses[bus], aura_mobo_addresses[address_list_idx]))
+                    if(TestForENESMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
                     {
                         DMIInfo dmi;
 
-                        ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(buses[bus]);
+                        ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(busses[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);
 
@@ -302,7 +309,6 @@ REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 3060 Ti Gaming OC",
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 3060 Ti OC",                      DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060TI_O8G_OC,               0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 3060 Ti OC",                            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060TI_O8G_OC_V2,                  0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 3060 Ti V2 OC",                   DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060TI_O8G_V2_GAMING,        0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 3060 Ti V2 OC",                   DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060TI_O8G_V2_2_GAMING,      0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 3070 OC",                         DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_OC,                     0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 3070 Gaming OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_GAMING,             0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 3070 White OC",                   DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_WHITE,              0x67);
@@ -410,8 +416,7 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 4090 Gaming White",
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 4090 Gaming White OC",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4090_O24G_GAMING_WHITE,      0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 4090 Gaming White OC",            DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4090_O24G_GAMING_WHITE_2,    0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG MATRIX PLATINUM GeForce RTX 4090",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_MATRIX_PLATINUM_RTX_4090_24G,          0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5060 Gaming OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5060_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_5060_O8G_GAMING,                   0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5070 Gaming OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_5070_O12G_GAMING,                  0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5070 Gaming",                           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_5070_O12G_GAMING,                  0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5070 Ti Gaming OC",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_5070TI_O16G_GAMING,                0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 5070 Ti Gaming OC",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_5070TI_O16G_GAMING_OC,       0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5080 Gaming OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_5080_O16G_GAMING,                  0x67);
@@ -450,7 +455,6 @@ REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 7700 XT Gaming OC",
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 7800 XT Gaming OC",                       DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI32_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_7800XT_O16G_GAMING,                 0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 7800 XT Gaming OC",                       DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI32_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_7800XT_O16G_GAMING_0606,            0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 7800 XT Gaming White OC",                 DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI32_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_7800XT_O16G_WHITE_GAMING,           0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 7900 GRE Gaming OC",                      DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI31_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_7900GRE_O16G_GAMING,                0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 7900 XT Gaming OC",                       DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI31_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_7900XT_020G_GAMING,                 0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 7900 XTX Gaming OC",                      DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI31_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_7900XTX_O24G_GAMING,                0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 9070 Gaming OC",                          DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI48_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_9070_016G_GAMING,                   0x67);

Controllers/ENESMBusController/ENESMBusInterface/ENESMBusInterface_i2c_smbus.cpp

@@ -28,7 +28,7 @@ ene_interface_type ENESMBusInterface_i2c_smbus::GetInterfaceType()
 
 std::string ENESMBusInterface_i2c_smbus::GetLocation()
 {
-    std::string return_string(bus->info.device_name);
+    std::string return_string(bus->device_name);
     return("I2C: " + return_string);
 }
 

Controllers/EVGAAmpereGPUController/EVGAAmpereGPUControllerDetect.cpp

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

Controllers/EVGAAmpereGPUController/EVGAGPUv3Controller.cpp

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

Controllers/EVGAGP102GPUController/EVGAGP102Controller.cpp

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

Controllers/EVGAGP102GPUController/EVGAGP102GPUControllerDetect.cpp

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

Controllers/EVGAPascalGPUController/EVGAGPUv1Controller.cpp

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

Controllers/EVGAPascalGPUController/EVGAPascalGPUControllerDetect.cpp

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

Controllers/EVGASMBusController/EVGAACX30SMBusController.cpp

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

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

Controllers/EVGATuringGPUController/EVGAGPUv2Controller.cpp

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

Controllers/EVGATuringGPUController/EVGATuringGPUControllerDetect.cpp

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

Controllers/ElgatoLightStripController/ElgatoLightStripController.cpp

@@ -13,9 +13,8 @@
 #include <sstream>
 #include <thread>
 #include <vector>
-#include <nlohmann/json.hpp>
 #include "ElgatoLightStripController.h"
-#include "JsonUtils.h"
+#include <nlohmann/json.hpp>
 #include "LogManager.h"
 
 using json = nlohmann::json;
@@ -59,8 +58,7 @@ ElgatoLightStripController::ElgatoLightStripController(std::string ip)
         }
 
         std::string result = recv_list[5];
-        json elgato_lightstrip_data;
-        JsonUtils::JsonParse(result, elgato_lightstrip_data);
+        json elgato_lightstrip_data = json::parse(result);
 
         firmware_version = elgato_lightstrip_data["firmwareVersion"];
         serialnumber = elgato_lightstrip_data["serialNumber"];

Controllers/FnaticStreakController/FnaticStreakController.cpp

@@ -44,7 +44,7 @@ FnaticStreakController::~FnaticStreakController()
 
 std::string FnaticStreakController::GetDeviceLocation()
 {
-    return("HID: " + location);
+    return("HID " + location);
 }
 
 std::string FnaticStreakController::GetNameString()

Controllers/GaiZongGaiKeyboardController/RGBController_GaiZhongGai.cpp

@@ -572,8 +572,7 @@ 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_SEGMENTS;
+                                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
                 }
 
                 if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
@@ -609,8 +608,7 @@ 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_SEGMENTS;
+                                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
                 }
 
                 if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/GainwardGPUController/GainwardGPUv1Controller/GainwardGPUv1Controller.cpp

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

Controllers/GainwardGPUController/GainwardGPUv2Controller/GainwardGPUv2Controller.cpp

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

Controllers/GalaxGPUController/GalaxGPUv1Controller/GalaxGPUv1Controller.cpp

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

Controllers/GalaxGPUController/GalaxGPUv2Controller/GalaxGPUv2Controller.cpp

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

Controllers/GigabyteRGBFusion2BlackwellGPUController/GigabyteRGBFusion2BlackwellGPUController.cpp

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

Controllers/GigabyteRGBFusion2BlackwellGPUController/GigabyteRGBFusion2BlackwellGPUControllerDetect.cpp

@@ -20,7 +20,7 @@
 
 bool TestForGigabyteRGBFusion2BlackwellGPUController(i2c_smbus_interface* bus, unsigned char address)
 {
-    if(bus->info.pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
+    if(bus->pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
     {
         return false;
     }
@@ -134,5 +134,4 @@ 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/GigabyteRGBFusion2DRAMController.cpp

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

Controllers/GigabyteRGBFusion2DRAMController/GigabyteRGBFusion2DRAMControllerDetect.cpp

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

Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.cpp

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

Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp

@@ -20,7 +20,7 @@
 
 bool TestForGigabyteRGBFusion2GPUController(i2c_smbus_interface* bus, unsigned char address)
 {
-    if(bus->info.pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
+    if(bus->pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
     {
         return false;
     }
@@ -180,5 +180,4 @@ 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/GigabyteRGBFusion2SMBusController.cpp

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

Controllers/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusControllerDetect.cpp

@@ -74,7 +74,7 @@ bool TestForGigabyteRGBFusion2SMBusController(i2c_smbus_interface* bus, unsigned
     return(pass);
 }
 
-DetectedControllers DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& buses)
+DetectedControllers DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses)
 {
     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 < buses.size(); bus++)
+        for(unsigned int bus = 0; bus < busses.size(); bus++)
         {
-            IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
+            IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
             {
-                if(buses[bus]->info.pci_subsystem_vendor == GIGABYTE_SUB_VEN)
+                if(busses[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(buses[bus]->info.device_name);
+                    std::string device_name = std::string(busses[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(buses[bus], SMBUS_ADDRESS))
+                        if(TestForGigabyteRGBFusion2SMBusController(busses[bus], SMBUS_ADDRESS))
                         {
-                            RGBFusion2SMBusController*     controller     = new RGBFusion2SMBusController(buses[bus], SMBUS_ADDRESS, dmi.getMainboard() );
+                            RGBFusion2SMBusController*     controller     = new RGBFusion2SMBusController(busses[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,51 +2065,6 @@ 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)                                |
 \*-------------------------------------------------------------------------*/
@@ -3876,7 +3831,6 @@ 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,8 +406,7 @@ 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_SEGMENTS;
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
             }
 
             if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/GigabyteRGBFusionController/GigabyteRGBFusionController.cpp

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

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*>& buses)
+DetectedControllers DetectGigabyteRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses)
 {
     DetectedControllers detected_controllers;
 
-    for(unsigned int bus = 0; bus < buses.size(); bus++)
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
-        IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
+        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            if(buses[bus]->info.pci_subsystem_vendor == GIGABYTE_SUB_VEN)
+            if(busses[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(buses[bus], SMBUS_ADDRESS))
+                if(TestForGigabyteRGBFusionController(busses[bus], SMBUS_ADDRESS))
                 {
-                    RGBFusionController*     controller     = new RGBFusionController(buses[bus], SMBUS_ADDRESS);
+                    RGBFusionController*     controller     = new RGBFusionController(busses[bus], SMBUS_ADDRESS);
                     RGBController_RGBFusion* rgb_controller = new RGBController_RGBFusion(controller);
 
                     detected_controllers.push_back(rgb_controller);

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUController.cpp

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

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUControllerDetect.cpp

@@ -98,7 +98,6 @@ DetectedControllers DetectGigabyteRGBFusionGPUControllers(i2c_smbus_interface* b
     return(detected_controllers);
 }
 
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1050 G1 Gaming",                             DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1050_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1050_G1_GAMING_SUB_DEV,             0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce GTX 1050 Ti G1 Gaming Rev A1",           DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1050TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1050TI_G1_GAMING_SUB_DEV,           0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce GTX 1050 Ti G1 Gaming",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1050TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1050TI_G1_GAMING_SUB_DEV,           0x48);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce GTX 1060 G1 Gaming",                     DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_G1_GAMING_SUB_DEV,             0x48);

Controllers/GoveeController/GoveeController.cpp

@@ -13,7 +13,6 @@
 #include <nlohmann/json.hpp>
 #include "base64.hpp"
 #include "GoveeController.h"
-#include "JsonUtils.h"
 
 using json = nlohmann::json;
 using namespace std::chrono_literals;
@@ -107,8 +106,7 @@ void GoveeController::ReceiveBroadcast(char* recv_buf, int size)
     /*-----------------------------------------------------*\
     | Convert null-terminated response to JSON              |
     \*-----------------------------------------------------*/
-    json response;
-    JsonUtils::JsonParse(recv_buf, response);
+    json response = json::parse(recv_buf);
 
     /*-----------------------------------------------------*\
     | Check if the response contains the method name        |

Controllers/HyperXDRAMController/HyperXDRAMController.cpp

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

Controllers/HyperXDRAMController/HyperXDRAMControllerDetect.cpp

@@ -55,7 +55,7 @@ DetectedControllers DetectHyperXDRAMControllers(i2c_smbus_interface* bus, std::v
     unsigned char       slots_valid   = 0x00;
 
     // Check for HyperX controller at 0x27
-    LOG_DEBUG("[%s] Testing bus %d at address 0x27", HYPERX_CONTROLLER_NAME, bus->info.port_id);
+    LOG_DEBUG("[%s] Testing bus %d at address 0x27", HYPERX_CONTROLLER_NAME, bus->port_id);
 
     if(TestForHyperXDRAMController(bus, 0x27))
     {

Controllers/HyperXKeyboardController/HyperXAlloyOrigins60and65Controller/HyperXAlloyOrigins60and65Controller.cpp

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

Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp

@@ -15,14 +15,12 @@
 #include "HyperXAlloyOriginsController.h"
 #include "HyperXAlloyOriginsCoreController.h"
 #include "HyperXAlloyOrigins60and65Controller.h"
-#include "HyperXOrigins2_65Controller.h"
 #include "RGBController_HyperXAlloyElite.h"
 #include "RGBController_HyperXAlloyElite2.h"
 #include "RGBController_HyperXAlloyFPS.h"
 #include "RGBController_HyperXAlloyOrigins.h"
 #include "RGBController_HyperXAlloyOriginsCore.h"
 #include "RGBController_HyperXAlloyOrigins60and65.h"
-#include "RGBController_HyperXOrigins2_65.h"
 
 /*---------------------------------------------------------*\
 | HyperX keyboard vendor and product IDs                    |
@@ -46,7 +44,6 @@
 #define HYPERX_ALLOY_ORIGINS_65_HP_PID             0x038F
 #define HYPERX_ALLOY_ORIGINS_CORE_HP_PID           0x098F
 #define HYPERX_ALLOY_ORIGINS_HP_PID                0x0591
-#define HYPERX_ORIGINS_2_65_HP_PID                 0x0CC2
 
 AlloyOrigins60and65MappingLayoutType GetAlloyOrigins60and65MappingLayoutType(int pid)
 {
@@ -173,32 +170,12 @@ DetectedControllers DetectHyperXAlloyOrigins60and65(hid_device_info* info, const
     return(detected_controllers);
 }
 
-DetectedControllers DetectHyperXOrigins2_65(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        HyperXOrigins2_65Controller* controller = new HyperXOrigins2_65Controller(dev, info->path, name);
-        RGBController_HyperXOrigins2_65* rgb_controller = new RGBController_HyperXOrigins2_65(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
-
 REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite RGB",        DetectHyperXAlloyElite,          HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID,           2, 0xFF01);
 REGISTER_HID_DETECTOR_IP("HyperX Alloy FPS RGB",          DetectHyperXAlloyFPS,            HYPERX_KEYBOARD_VID, HYPERX_ALLOY_FPS_RGB_PID,         2, 0xFF01);
 REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core",      DetectHyperXAlloyOriginsCore,    HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_CORE_PID,    2);
 
 REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core (HP)", DetectHyperXAlloyOriginsCore,    HP_KEYBOARD_VID,     HYPERX_ALLOY_ORIGINS_CORE_HP_PID, 2);
 
-REGISTER_HID_DETECTOR_I("HyperX Origins 2 65 (HP)",       DetectHyperXOrigins2_65,         HP_KEYBOARD_VID,     HYPERX_ORIGINS_2_65_HP_PID,       3);
-
 #ifdef _WIN32
 REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",           DetectHyperXAlloyOrigins,        HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,         3);
 REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2",          DetectHyperXAlloyElite2,         HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,         3, 0xFF90);

Controllers/HyperXKeyboardController/HyperXOrigins2_65Controller/HyperXOrigins2_65Controller.cpp

@@ -1,151 +0,0 @@
-/*---------------------------------------------------------*\
-| HyperXOrigins2_65Controller.cpp                           |
-|                                                           |
-|   Driver for HyperX Origins 2 65 keyboard                 |
-|                                                           |
-|   Ricardo Amorim                              28 Mar 2026 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include "HyperXOrigins2_65Controller.h"
-#include "StringUtils.h"
-
-HyperXOrigins2_65Controller::HyperXOrigins2_65Controller(hid_device* dev_handle, const char* path, std::string dev_name)
-{
-    dev         = dev_handle;
-    location    = path;
-    name        = dev_name;
-}
-
-HyperXOrigins2_65Controller::~HyperXOrigins2_65Controller()
-{
-    hid_close(dev);
-}
-
-std::string HyperXOrigins2_65Controller::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string HyperXOrigins2_65Controller::GetNameString()
-{
-    return(name);
-}
-
-std::string HyperXOrigins2_65Controller::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return ("");
-    }
-
-    return(StringUtils::wstring_to_string(serial_string));
-}
-
-void HyperXOrigins2_65Controller::SetLEDsDirect(std::vector<RGBColor> colors)
-{
-    /*-----------------------------------------------------*\
-    | Set up variables to track progress of color transmit  |
-    | Do this after inserting blanks                        |
-    \*-----------------------------------------------------*/
-    int colors_to_send = (int)colors.size();
-    int colors_sent    = 0;
-
-    SendDirectInitialization();
-
-    for(int pkt_idx = 0; pkt_idx < 4; pkt_idx++)
-    {
-        if(colors_to_send > 20)
-        {
-            SendDirectColorPacket(&colors[colors_sent], 20, pkt_idx);
-            colors_sent    += 20;
-            colors_to_send -= 20;
-        }
-        else if(colors_to_send > 0)
-        {
-            SendDirectColorPacket(&colors[colors_sent], colors_to_send, pkt_idx);
-            colors_sent    += colors_to_send;
-            colors_to_send -= colors_to_send;
-        }
-        else
-        {
-            RGBColor temp = 0x00000000;
-            SendDirectColorPacket(&temp, 1, pkt_idx);
-        }
-    }
-}
-
-void HyperXOrigins2_65Controller::SendDirectInitialization()
-{
-    unsigned char buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Direct Initialization packet                   |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x44;
-    buf[0x01]   = 0x01;
-    buf[0x02]   = 0x04;
-    buf[0x03]   = 0x00;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, buf, 65);
-}
-
-void HyperXOrigins2_65Controller::SendDirectColorPacket
-    (
-    RGBColor*       color_data,
-    unsigned int    color_count,
-    unsigned int    seq
-    )
-{
-    unsigned char buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Direct Initialization packet                   |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x44;
-    buf[0x01]   = 0x02;
-    buf[0x02]   = (unsigned char)seq;
-    buf[0x03]   = 0x00;
-
-    /*-----------------------------------------------------*\
-    | The maximum number of colors per packet is 20         |
-    \*-----------------------------------------------------*/
-    if(color_count > 20)
-    {
-        color_count = 20;
-    }
-
-    /*-----------------------------------------------------*\
-    | Copy in color data                                    |
-    \*-----------------------------------------------------*/
-    for(unsigned int color_idx = 0; color_idx < color_count; color_idx++)
-    {
-        buf[4 + (color_idx * 3)]     = RGBGetRValue(color_data[color_idx]);
-        buf[4 + (color_idx * 3) + 1] = RGBGetGValue(color_data[color_idx]);
-        buf[4 + (color_idx * 3) + 2] = RGBGetBValue(color_data[color_idx]);
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, buf, 65);
-}

Controllers/HyperXKeyboardController/HyperXOrigins2_65Controller/HyperXOrigins2_65Controller.h

@@ -1,43 +0,0 @@
-/*---------------------------------------------------------*\
-| HyperXOrigins2_65Controller.h                             |
-|                                                           |
-|   Driver for HyperX Origins 2 65 keyboard                 |
-|                                                           |
-|   Ricardo Amorim                              28 Mar 2026 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
-class HyperXOrigins2_65Controller
-{
-public:
-    HyperXOrigins2_65Controller(hid_device* dev_handle, const char* path, std::string dev_name);
-    ~HyperXOrigins2_65Controller();
-
-    std::string     GetDeviceLocation();
-    std::string     GetNameString();
-    std::string     GetSerialString();
-
-    void SetLEDsDirect(std::vector<RGBColor> colors);
-
-private:
-    hid_device*             dev;
-    std::string             location;
-    std::string             name;
-
-    void    SendDirectInitialization();
-    void    SendDirectColorPacket
-                (
-                RGBColor*       color_data,
-                unsigned int    color_count,
-                unsigned int    seq
-                );
-};
-

Controllers/HyperXKeyboardController/HyperXOrigins2_65Controller/RGBController_HyperXOrigins2_65.cpp

@@ -1,234 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_HyperXOrigins2_65.cpp                       |
-|                                                           |
-|   RGBController for HyperX Origins 2 65 keyboard          |
-|                                                           |
-|   Ricardo Amorim                              28 Mar 2026 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include "RGBController_HyperXOrigins2_65.h"
-
-using namespace std::chrono_literals;
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-static unsigned int matrix_map[5][15] =
-    { {   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14  },
-      {  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  NA,  29  },
-      {  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44  },
-      {  45,  61,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  59  },
-      {  60,  62,  63,  65,  NA,  NA,  66,  NA,  NA,  68,  69,  70,  71,  72,  73  } };
-
-static const char* zone_names[] =
-{
-    ZONE_EN_KEYBOARD,
-};
-
-static zone_type zone_types[] =
-{
-    ZONE_TYPE_MATRIX,
-};
-
-static const unsigned int zone_sizes[] =
-{
-    74,
-};
-
-static const char *led_names[] =
-{
-    KEY_EN_ESCAPE,
-    KEY_EN_1,
-    KEY_EN_2,
-    KEY_EN_3,
-    KEY_EN_4,
-    KEY_EN_5,
-    KEY_EN_6,
-    KEY_EN_7,
-    KEY_EN_8,
-    KEY_EN_9,
-    KEY_EN_0,
-    KEY_EN_MINUS,
-    KEY_EN_EQUALS,
-    KEY_EN_BACKSPACE,
-    KEY_EN_DELETE,
-    KEY_EN_TAB,
-    KEY_EN_Q,
-    KEY_EN_W,
-    KEY_EN_E,
-    KEY_EN_R,
-    KEY_EN_T,
-    KEY_EN_Y,
-    KEY_EN_U,
-    KEY_EN_I,
-    KEY_EN_O,
-    KEY_EN_P,
-    KEY_EN_LEFT_BRACKET,
-    KEY_EN_RIGHT_BRACKET,
-    KEY_EN_UNUSED,
-    KEY_EN_HOME,
-    KEY_EN_CAPS_LOCK,
-    KEY_EN_A,
-    KEY_EN_S,
-    KEY_EN_D,
-    KEY_EN_F,
-    KEY_EN_G,
-    KEY_EN_H,
-    KEY_EN_J,
-    KEY_EN_K,
-    KEY_EN_L,
-    KEY_EN_SEMICOLON,
-    KEY_EN_QUOTE,
-    KEY_EN_POUND,
-    KEY_EN_ISO_ENTER,
-    KEY_EN_PAGE_UP,
-    KEY_EN_LEFT_SHIFT,
-    KEY_EN_Z,
-    KEY_EN_X,
-    KEY_EN_C,
-    KEY_EN_V,
-    KEY_EN_B,
-    KEY_EN_N,
-    KEY_EN_M,
-    KEY_EN_COMMA,
-    KEY_EN_PERIOD,
-    KEY_EN_FORWARD_SLASH,
-    KEY_EN_RIGHT_SHIFT,
-    KEY_EN_UP_ARROW,
-    KEY_EN_UNUSED,
-    KEY_EN_PAGE_DOWN,
-    KEY_EN_LEFT_CONTROL,
-    KEY_EN_ISO_BACK_SLASH,
-    KEY_EN_LEFT_WINDOWS,
-    KEY_EN_LEFT_ALT,
-    KEY_EN_UNUSED,
-    "Left Space",
-    KEY_EN_SPACE,
-    "Right Space",
-    KEY_EN_UNUSED,
-    KEY_EN_RIGHT_ALT,
-    KEY_EN_RIGHT_FUNCTION,
-    KEY_EN_LEFT_ARROW,
-    KEY_EN_DOWN_ARROW,
-    KEY_EN_RIGHT_ARROW
-};
-
-/**------------------------------------------------------------------*\
-    @name HyperX Origins 2 65
-    @category Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectHyperXOrigins2_65
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_HyperXOrigins2_65::RGBController_HyperXOrigins2_65(HyperXOrigins2_65Controller* controller_ptr)
-{
-    controller          = controller_ptr;
-
-    name                = controller->GetNameString();
-    vendor              = "HyperX";
-    type                = DEVICE_TYPE_KEYBOARD;
-    location            = controller->GetDeviceLocation();
-    serial              = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name         = "Direct";
-    Direct.value        = 0xFFFF;
-    Direct.flags        = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode   = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-
-    keepalive_thread_run = 1;
-    keepalive_thread = new std::thread(&RGBController_HyperXOrigins2_65::KeepaliveThread, this);
-}
-
-RGBController_HyperXOrigins2_65::~RGBController_HyperXOrigins2_65()
-{
-    Shutdown();
-
-    keepalive_thread_run = 0;
-    keepalive_thread->join();
-    delete keepalive_thread;
-
-    delete controller;
-}
-
-void RGBController_HyperXOrigins2_65::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    unsigned int total_led_count = 0;
-    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
-    {
-        zone new_zone;
-        new_zone.name                   = zone_names[zone_idx];
-        new_zone.type                   = zone_types[zone_idx];
-        new_zone.leds_min               = zone_sizes[zone_idx];
-        new_zone.leds_max               = zone_sizes[zone_idx];
-        new_zone.leds_count             = zone_sizes[zone_idx];
-
-        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
-        {
-            new_zone.matrix_map.Set(5, 15, (unsigned int *)&matrix_map);
-        }
-
-        zones.push_back(new_zone);
-
-        total_led_count += zone_sizes[zone_idx];
-    }
-
-    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
-    {
-        led new_led;
-        new_led.name = led_names[led_idx];
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_HyperXOrigins2_65::DeviceUpdateLEDs()
-{
-    controller->SetLEDsDirect(colors);
-}
-
-void RGBController_HyperXOrigins2_65::DeviceUpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_HyperXOrigins2_65::DeviceUpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_HyperXOrigins2_65::DeviceUpdateMode()
-{
-
-}
-
-void RGBController_HyperXOrigins2_65::KeepaliveThread()
-{
-    while(keepalive_thread_run.load())
-    {
-        if(active_mode == 0)
-        {
-            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50))
-            {
-                UpdateLEDs();
-            }
-        }
-        std::this_thread::sleep_for(10ms);;
-    }
-}
-

Controllers/HyperXKeyboardController/HyperXOrigins2_65Controller/RGBController_HyperXOrigins2_65.h

@@ -1,40 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_HyperXOrigins2_65.h                         |
-|                                                           |
-|   RGBController for HyperX Origins 2 65 keyboard          |
-|                                                           |
-|   Ricardo Amorim                              28 Mar 2026 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <chrono>
-#include "RGBController.h"
-#include "HyperXOrigins2_65Controller.h"
-
-class RGBController_HyperXOrigins2_65 : public RGBController
-{
-public:
-    RGBController_HyperXOrigins2_65(HyperXOrigins2_65Controller* controller_ptr);
-    ~RGBController_HyperXOrigins2_65();
-
-    void        SetupZones();
-
-    void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-    void        KeepaliveThread();
-
-private:
-    HyperXOrigins2_65Controller*                        controller;
-    std::thread*                                        keepalive_thread;
-    std::atomic<bool>                                   keepalive_thread_run;
-    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
-};
-

Controllers/JGINYUEInternalUSBController/RGBController_JGINYUEInternalUSB.cpp

@@ -215,8 +215,7 @@ 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_SEGMENTS;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/JGINYUEInternalUSBV2Controller/RGBController_JGINYUEInternalUSBV2.cpp

@@ -407,8 +407,7 @@ 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_SEGMENTS;
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP;
         }
 
         if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))

Controllers/KasaSmartController/KasaSmartController.cpp

@@ -10,9 +10,8 @@
 \*---------------------------------------------------------*/
 
 #include <cstdint>
-#include <nlohmann/json.hpp>
-#include "JsonUtils.h"
 #include "KasaSmartController.h"
+#include <nlohmann/json.hpp>
 #include "hsv.h"
 
 using json = nlohmann::json;
@@ -65,7 +64,11 @@ bool KasaSmartController::Initialize()
     }
 
     json system_information;
-    if(!JsonUtils::JsonParse(system_info_json, system_information))
+    try
+    {
+        system_information = json::parse(system_info_json);
+    }
+    catch (json::parse_error&)
     {
         /*-----------------------*\
         | Can't parse system info |

Controllers/KingstonFuryDRAMController/KingstonFuryDRAMController.cpp

@@ -28,7 +28,7 @@ KingstonFuryDRAMController::KingstonFuryDRAMController(i2c_smbus_interface* bus,
 
 std::string KingstonFuryDRAMController::GetDeviceLocation()
 {
-    std::string return_string(bus->info.device_name);
+    std::string return_string(bus->device_name);
     return_string.append(", addresses [");
     for(std::size_t idx = 0; idx < slots.size(); idx++)
     {

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()->GetI2CBuses().size(); i2c_idx++)
+    for(unsigned int i2c_idx = 0; i2c_idx < ResourceManager::get()->GetI2CBusses().size(); i2c_idx++)
     {
-        if(ResourceManager::get()->GetI2CBuses()[i2c_idx]->info.device_name == std::string(i2cname))
+        if(ResourceManager::get()->GetI2CBusses()[i2c_idx]->device_name == std::string(i2cname))
         {
             if(i2c_addr < 128)
             {
-                i2cport = ResourceManager::get()->GetI2CBuses()[i2c_idx];
+                i2cport = ResourceManager::get()->GetI2CBusses()[i2c_idx];
                 break;
             }
         }
@@ -155,7 +155,7 @@ std::string LEDStripController::GetLocation()
     }
     else if(i2cport != NULL)
     {
-        return("I2C: " + std::string(i2cport->info.device_name) + ", Address " + std::to_string(i2c_addr));
+        return("I2C: " + std::string(i2cport->device_name) + ", Address " + std::to_string(i2c_addr));
     }
     else
     {