Implement size verification on RGBController set description functions

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

.gitlab-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}"

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

@@ -269,7 +269,7 @@ void RGBController_PolychromeUSB::SetupZones()
             new_led.name = zones[channel_idx].name;
             new_led.name.append(", LED ");
             new_led.name.append(std::to_string(led_ch_idx + 1));
-            new_led.value = (unsigned int)channel_idx;
+            new_led.value = channel_idx;
 
             leds.push_back(new_led);
         }

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/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

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

Controllers/ASRockSMBusController/ASRockSMBusControllerDetect.cpp

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

Controllers/ArcticController/ArcticControllerDetect.cpp

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

Controllers/AsusAuraGPUController/AsusAuraGPUController.cpp

@@ -32,7 +32,7 @@ std::string AuraGPUController::GetDeviceName()
 
 std::string AuraGPUController::GetDeviceLocation()
 {
-    std::string return_string(bus->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/AsusAuraMouseController/AsusAuraMouseDevices.h

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

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.cpp

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

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

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
 
@@ -464,7 +463,6 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                        DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,               1,  0xFF13);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                        DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,               2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III",                                DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_PID,                         0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Core",                           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_CORE_PID,                    0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless USB",                   DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_USB_PID,            0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless 2.4Ghz",                DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID,            0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth",             DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_BT_PID,             0,  0xFF01);
@@ -525,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/BlinkyTapeControllerDetect.cpp

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

Controllers/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

@@ -1,4 +1,4 @@
-/*---------------------------------------------------------*\
+/*---------------------------------------------------------*\
 | ColorfulGPUControllerDetect.cpp                           |
 |                                                           |
 |   Detector for Colorful GPU                               |
@@ -52,7 +52,7 @@ REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Advanced OC 12G L-V",    Detec
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_GA106_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,        0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,        0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,        0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,           0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060TI_ADVANCED_OC,          0x61);
@@ -76,9 +76,6 @@ REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           Detec
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2,            0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV,           0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV2,          0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ultra W OC",             DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060_ULTRAW_OC,              0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ultra W OC",             DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060_ULTRAW_OC_2,            0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ti Ultra W DUO OC",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060TI_ULTRAW_DUO_OC,        0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ti Ultra W DUO OC",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060TI_ULTRAW_DUO_OC_2,      0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 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/CorsairCommanderCoreController/CorsairCommanderCoreController.cpp

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

Controllers/CorsairDRAMController/CorsairDRAMController.cpp

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

Controllers/CorsairDRAMController/CorsairDRAMControllerDetect.cpp

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

Controllers/CorsairICueLinkController/RGBController_CorsairICueLink.cpp

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

Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp

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

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.cpp

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

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.h

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

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2ControllerDetect.cpp

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

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.cpp

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

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.h

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

Controllers/CorsairVengeanceController/CorsairVengeanceController.cpp

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

Controllers/CorsairWirelessController/CorsairWirelessController.cpp

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

Controllers/CorsairWirelessController/CorsairWirelessController.h

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

Controllers/CorsairWirelessController/CorsairWirelessControllerDetect.cpp

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

Controllers/CorsairWirelessController/RGBController_CorsairWireless.cpp

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

Controllers/CorsairWirelessController/RGBController_CorsairWireless.h

@@ -1,40 +1,41 @@
-/*---------------------------------------------------------*\
-| 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;
-};
-
+/*---------------------------------------------------------*\
+| RGBController_CorsairWireless.h                           |
+|                                                           |
+|   RGBController for Corsair wireless keyboard             |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                08 May 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "CorsairWirelessController.h"
+
+class RGBController_CorsairWireless : public RGBController
+{
+public:
+    RGBController_CorsairWireless(CorsairWirelessController* controller_ptr);
+    ~RGBController_CorsairWireless();
+
+    int         physical_layout;
+    int         logical_layout;
+
+    void        SetupZones();
+
+    void        DeviceUpdateLEDs();
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+    void        KeepaliveThread();
+
+private:
+    CorsairWirelessController*                          controller;
+    std::thread*                                        keepalive_thread;
+    std::atomic<bool>                                   keepalive_thread_run;
+    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
+};

Controllers/CreativeController/CreativeSoundBlasterXG6Controller.cpp

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

Controllers/CrucialController/CrucialController.cpp

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

Controllers/CrucialController/CrucialControllerDetect.cpp

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

Controllers/DDPController/DDPControllerDetect.cpp

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

Controllers/DRGBController/RGBController_DRGB.cpp

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

Controllers/DebugController/RGBController_Debug.cpp

@@ -13,7 +13,6 @@
 #include <algorithm>
 #include <cstring>
 #include "KeyboardLayoutManager.h"
-#include "JsonUtils.h"
 #include "RGBController_Debug.h"
 
 /**------------------------------------------------------------------*\
@@ -52,6 +51,100 @@ RGBController_Debug::RGBController_Debug(bool custom, json settings)
     custom_controller   = custom;
     debug_settings      = settings;
 
+    if(custom_controller)
+    {
+        /*-------------------------------------------------*\
+        | Set the name                                      |
+        \*-------------------------------------------------*/
+        name = debug_settings["DeviceName"];
+
+        /*-------------------------------------------------*\
+        | Find the device type                              |
+        \*-------------------------------------------------*/
+        if      (debug_settings["DeviceType"] == "motherboard")   type = DEVICE_TYPE_MOTHERBOARD;
+        else if (debug_settings["DeviceType"] == "dram")          type = DEVICE_TYPE_DRAM;
+        else if (debug_settings["DeviceType"] == "gpu")           type = DEVICE_TYPE_GPU;
+        else if (debug_settings["DeviceType"] == "cooler")        type = DEVICE_TYPE_COOLER;
+        else if (debug_settings["DeviceType"] == "led_strip")     type = DEVICE_TYPE_LEDSTRIP;
+        else if (debug_settings["DeviceType"] == "keyboard")      type = DEVICE_TYPE_KEYBOARD;
+        else if (debug_settings["DeviceType"] == "mouse")         type = DEVICE_TYPE_MOUSE;
+        else if (debug_settings["DeviceType"] == "mousemat")      type = DEVICE_TYPE_MOUSEMAT;
+        else if (debug_settings["DeviceType"] == "headset")       type = DEVICE_TYPE_HEADSET;
+        else if (debug_settings["DeviceType"] == "headset_stand") type = DEVICE_TYPE_HEADSET_STAND;
+        else if (debug_settings["DeviceType"] == "gamepad")       type = DEVICE_TYPE_GAMEPAD;
+        else if (debug_settings["DeviceType"] == "light")         type = DEVICE_TYPE_LIGHT;
+        else if (debug_settings["DeviceType"] == "speaker")       type = DEVICE_TYPE_SPEAKER;
+        else if (debug_settings["DeviceType"] == "unknown")       type = DEVICE_TYPE_UNKNOWN;
+
+        /*-------------------------------------------------*\
+        | Set description, location, version, and serial    |
+        \*-------------------------------------------------*/
+        description                             = debug_settings["DeviceDescription"];
+        location                                = debug_settings["DeviceLocation"];
+        version                                 = debug_settings["DeviceVersion"];
+        serial                                  = debug_settings["DeviceSerial"];
+    }
+    else
+    {
+        std::string name_setting    = "";
+        std::string type_setting    = "keyboard";
+
+        if(debug_settings.contains("name"))
+        {
+            name_setting = debug_settings["name"];
+        }
+
+        if(debug_settings.contains("type"))
+        {
+            type_setting = debug_settings["type"];
+        }
+
+        if(type_setting == "motherboard")
+        {
+            name                = "Debug Motherboard";
+            type                = DEVICE_TYPE_MOTHERBOARD;
+        }
+        else if(type_setting == "dram")
+        {
+            name                = "Debug DRAM";
+            type                = DEVICE_TYPE_DRAM;
+        }
+        else if(type_setting == "gpu")
+        {
+            name                = "Debug GPU";
+            type                = DEVICE_TYPE_GPU;
+        }
+        else if(type_setting == "keyboard")
+        {
+            name                = "Debug Keyboard";
+            type                = DEVICE_TYPE_KEYBOARD;
+        }
+      else if(type_setting == "mouse")
+        {
+            name                = "Debug Mouse";
+            type                = DEVICE_TYPE_MOUSE;
+        }
+        else if(type_setting == "argb")
+        {
+            name                = "Debug ARGB Controller";
+            type                = DEVICE_TYPE_LEDSTRIP;
+        }
+
+        /*---------------------------------------------------------*\
+        | Fill in debug controller information                      |
+        \*---------------------------------------------------------*/
+        description                     = name + " Device";
+        vendor                          = name + " Vendor String";
+        location                        = name + " Location String";
+        version                         = name + " Version String";
+        serial                          = name + " Serial String";
+
+        if(name_setting != "")
+        {
+            name                        = name_setting;
+        }
+    }
+
     /*-----------------------------------------------------*\
     | Create the mode                                       |
     \*-----------------------------------------------------*/
@@ -64,7 +157,6 @@ RGBController_Debug::RGBController_Debug(bool custom, json settings)
 
     modes.push_back(Direct);
 
-    SetupDevice();
     SetupZones();
 }
 
@@ -73,137 +165,6 @@ RGBController_Debug::~RGBController_Debug()
     Shutdown();
 }
 
-void RGBController_Debug::SetupDevice()
-{
-    if(custom_controller)
-    {
-        /*-------------------------------------------------*\
-        | Set the name, description, location, version, and |
-        | serial                                            |
-        \*-------------------------------------------------*/
-        name                            = JsonUtils::JsonGetString(debug_settings, "DeviceName", "Custom Device");
-        description                     = JsonUtils::JsonGetString(debug_settings, "DeviceDescription");
-        location                        = JsonUtils::JsonGetString(debug_settings, "DeviceLocation");
-        version                         = JsonUtils::JsonGetString(debug_settings, "DeviceVersion");
-        serial                          = JsonUtils::JsonGetString(debug_settings, "DeviceSerial");
-
-        /*-------------------------------------------------*\
-        | Find the device type                              |
-        \*-------------------------------------------------*/
-        std::string device_type         = JsonUtils::JsonGetString(debug_settings, "DeviceType", "keyboard");
-
-        if(     device_type == "motherboard")   type = DEVICE_TYPE_MOTHERBOARD;
-        else if(device_type == "dram")          type = DEVICE_TYPE_DRAM;
-        else if(device_type == "gpu")           type = DEVICE_TYPE_GPU;
-        else if(device_type == "cooler")        type = DEVICE_TYPE_COOLER;
-        else if(device_type == "led_strip")     type = DEVICE_TYPE_LEDSTRIP;
-        else if(device_type == "keyboard")      type = DEVICE_TYPE_KEYBOARD;
-        else if(device_type == "mouse")         type = DEVICE_TYPE_MOUSE;
-        else if(device_type == "mousemat")      type = DEVICE_TYPE_MOUSEMAT;
-        else if(device_type == "headset")       type = DEVICE_TYPE_HEADSET;
-        else if(device_type == "headset_stand") type = DEVICE_TYPE_HEADSET_STAND;
-        else if(device_type == "gamepad")       type = DEVICE_TYPE_GAMEPAD;
-        else if(device_type == "light")         type = DEVICE_TYPE_LIGHT;
-        else if(device_type == "speaker")       type = DEVICE_TYPE_SPEAKER;
-        else if(device_type == "unknown")       type = DEVICE_TYPE_UNKNOWN;
-    }
-    else
-    {
-        std::string name_value;
-        std::string name_setting        = JsonUtils::JsonGetString(debug_settings, "name");
-        std::string type_setting        = JsonUtils::JsonGetString(debug_settings, "type", "keyboard");
-
-        if(type_setting == "motherboard")
-        {
-            name_value                  = "Debug Motherboard";
-            type                        = DEVICE_TYPE_MOTHERBOARD;
-        }
-        else if(type_setting == "dram")
-        {
-            name_value                  = "Debug DRAM";
-            type                        = DEVICE_TYPE_DRAM;
-        }
-        else if(type_setting == "gpu")
-        {
-            name_value                  = "Debug GPU";
-            type                        = DEVICE_TYPE_GPU;
-        }
-        else if(type_setting == "keyboard")
-        {
-            name_value                  = "Debug Keyboard";
-            type                        = DEVICE_TYPE_KEYBOARD;
-        }
-        else if(type_setting == "mouse")
-        {
-            name_value                  = "Debug Mouse";
-            type                        = DEVICE_TYPE_MOUSE;
-        }
-        else if(type_setting == "argb")
-        {
-            name_value                  = "Debug ARGB Controller";
-            type                        = DEVICE_TYPE_LEDSTRIP;
-        }
-
-        /*---------------------------------------------------------*\
-        | Fill in debug controller information                      |
-        \*---------------------------------------------------------*/
-        description                     = name_value + " Device";
-        vendor                          = name_value + " Vendor String";
-        location                        = name_value + " Location String";
-        version                         = name_value + " Version String";
-        serial                          = name_value + " Serial String";
-        flags                          |= CONTROLLER_FLAG_MANUALLY_CONFIGURABLE_NAME | CONTROLLER_FLAG_MANUALLY_CONFIGURABLE_DEVICE_SPECIFIC;
-
-        if(name_setting != "")
-        {
-            name_value                  = name_setting;
-        }
-
-        if((flags & CONTROLLER_FLAG_MANUALLY_CONFIGURED_NAME) == 0)
-        {
-            name                        = name_value;
-        }
-
-        /*---------------------------------------------------------*\
-        | Create test configuration                                 |
-        \*---------------------------------------------------------*/
-        nlohmann::json configuration_json;
-        JsonUtils::JsonParse(configuration, configuration_json);
-
-        configuration_json["schema"]["test_string"]["title"]     = "String Setting";
-        configuration_json["schema"]["test_string"]["type"]      = "string";
-
-        configuration_json["schema"]["test_bool"]["title"]       = "Boolean Setting";
-        configuration_json["schema"]["test_bool"]["type"]        = "bool";
-
-        configuration_json["schema"]["test_enum"]["title"]       = "String Enum Setting";
-        configuration_json["schema"]["test_enum"]["type"]        = "string";
-        configuration_json["schema"]["test_enum"]["enum"][0]     = "Option 1";
-        configuration_json["schema"]["test_enum"]["enum"][1]     = "Option 2";
-        configuration_json["schema"]["test_enum"]["enum"][2]     = "Option 3";
-
-        configuration_json["schema"]["test_enum_int"]["title"]   = "Integer Enum Setting";
-        configuration_json["schema"]["test_enum_int"]["type"]    = "integer";
-        configuration_json["schema"]["test_enum_int"]["enum"][0] = 2;
-        configuration_json["schema"]["test_enum_int"]["enum"][1] = 4;
-        configuration_json["schema"]["test_enum_int"]["enum"][2] = 8;
-
-        configuration_json["schema"]["test_int"]["title"]        = "Integer Setting";
-        configuration_json["schema"]["test_int"]["type"]         = "integer";
-
-        if((flags & CONTROLLER_FLAG_MANUALLY_CONFIGURED_DEVICE_SPECIFIC) == 0)
-        {
-            configuration_json["configuration"]["test_string"]   = "This is a test";
-            configuration_json["configuration"]["test_bool"]     = true;
-            configuration_json["configuration"]["test_enum"]     = "Option 2";
-            configuration_json["configuration"]["test_enum_int"] = 4;
-            configuration_json["configuration"]["test_int"]      = 12345;
-        }
-
-        configuration = configuration_json.dump();
-    }
-}
-
 void RGBController_Debug::SetupZones()
 {
     /*-------------------------------------------------*\
@@ -220,7 +181,6 @@ void RGBController_Debug::SetupZones()
     /*-------------------------------------------------*\
     | Clear any existing color/LED configuration        |
     \*-------------------------------------------------*/
-    led_display_names.clear();
     leds.clear();
     colors.clear();
 
@@ -256,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                        |
@@ -281,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);
 
@@ -373,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                          |
@@ -386,51 +371,28 @@ 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";
 
             leds.push_back(single_led);
 
-            led_display_names.push_back("");
-
-            nlohmann::json configuration_json;
-            JsonUtils::JsonParse(configuration, configuration_json);
-
-            if(first_run)
-            {
-                /*-----------------------------------------*\
-                | Create test configuration                 |
-                \*-----------------------------------------*/
-                configuration_json["zones"][zone_idx]["schema"]["color_order"]["title"]     = "Color Order";
-                configuration_json["zones"][zone_idx]["schema"]["color_order"]["type"]      = "string";
-                configuration_json["zones"][zone_idx]["schema"]["color_order"]["enum"][0]   = "RGB";
-                configuration_json["zones"][zone_idx]["schema"]["color_order"]["enum"][1]   = "GRB";
-            }
-
-            if((zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_DEVICE_SPECIFIC) == 0)
-            {
-                configuration_json["zones"][zone_idx]["configuration"]["color_order"]       = "RGB";
-            }
-
-            configuration = configuration_json.dump();
+            led_alt_names.push_back("");
 
             zone_idx++;
         }
@@ -442,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,7 +427,7 @@ void RGBController_Debug::SetupZones()
 
                 leds.push_back(linear_led);
 
-                led_display_names.push_back("");
+                led_alt_names.push_back("");
             }
 
             zone_idx++;
@@ -475,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"];
@@ -503,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 < 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"];
@@ -533,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        |
             \*---------------------------------------------*/
@@ -591,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;
 
@@ -604,31 +544,9 @@ void RGBController_Debug::SetupZones()
 
                 leds.push_back(keyboard_led);
 
-                led_display_names.push_back(new_kb.GetKeyAltNameAt(led_idx));
+                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++;
         }
 
@@ -663,7 +581,7 @@ void RGBController_Debug::SetupZones()
 
                 leds.push_back(underglow_led);
 
-                led_display_names.push_back("");
+                led_alt_names.push_back("");
             }
 
             zone_idx++;
@@ -719,7 +637,7 @@ void RGBController_Debug::SetupZones()
 
                 leds.push_back(resizable_led);
 
-                led_display_names.push_back("");
+                led_alt_names.push_back("");
             }
 
             zone_idx++;
@@ -729,11 +647,6 @@ void RGBController_Debug::SetupZones()
     SetupColors();
 }
 
-void RGBController_Debug::DeviceConfigureDevice()
-{
-    SetupDevice();
-}
-
 void RGBController_Debug::DeviceConfigureZone(int zone_idx)
 {
     if((size_t)zone_idx < zones.size())
@@ -761,13 +674,3 @@ void RGBController_Debug::DeviceUpdateMode()
 {
 
 }
-
-void RGBController_Debug::DeviceUpdateDeviceSpecificConfiguration()
-{
-
-}
-
-void RGBController_Debug::DeviceUpdateDeviceSpecificZoneConfiguration(int /*zone*/)
-{
-    SetupZones();
-}

Controllers/DebugController/RGBController_Debug.h

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

Controllers/DygmaRaiseController/DygmaRaiseControllerDetect.cpp

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

Controllers/E131Controller/RGBController_E131.cpp

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

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -154,13 +154,13 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
     {
         int address_list_idx = -1;
 
-        IF_DRAM_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
+        IF_DRAM_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
         {
             LOG_DEBUG("[ENE SMBus DRAM] Remapping ENE SMBus RAM modules on 0x77");
 
             for(unsigned int slot = 0; slot < 8; slot++)
             {
-                int res = buses[bus]->i2c_smbus_read_byte(0x77);
+                int res = buses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
 
                 if(res < 0)
                 {
@@ -176,7 +176,7 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
                     {
                         LOG_DEBUG("[ENE SMBus DRAM] Testing address %02X to see if there is a device there", ene_ram_addresses[address_list_idx]);
 
-                        res = buses[bus]->i2c_smbus_read_byte(ene_ram_addresses[address_list_idx]);
+                        res = buses[bus]->i2c_smbus_write_quick(ene_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
                     }
                     else
                     {
@@ -220,9 +220,9 @@ DetectedControllers DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_i
     for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
         // Add ENE (ASUS Aura) motherboard controllers
-        IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
+        IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[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(buses[bus]->pci_subsystem_vendor == ASUS_SUB_VEN || buses[bus]->pci_subsystem_vendor == 0 || buses[bus]->pci_subsystem_vendor == 0xFFFF)
             {
                 for(unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
                 {
@@ -302,7 +302,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,11 +409,8 @@ 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 TUF GeForce RTX 5070 Ti Gaming BTF White OC",           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_5070TI_O16G_GAMING_BTF_WHITE,      0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5070 Ti Gaming White OC",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_5070TI_O16G_GAMING_WHITE,          0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 5070 Ti Gaming OC",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_5070TI_O16G_GAMING_OC,       0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5080 Gaming OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_5080_O16G_GAMING,                  0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5090 Gaming OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_5090_O32G_GAMING,                  0x67);
@@ -422,9 +418,7 @@ REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5090 Gaming",
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5080 OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5080_O16G_GAMING,           0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5080 OC WHITE",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5080_O16G_GAMING_WHITE,     0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5080",                           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5080_16G_GAMING,            0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5080 WHITE",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5080_16G_GAMING_WHITE,      0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090 OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING,           0x67);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090",                           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING_2,         0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090 OC BTF",                    DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING_BTF,       0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090 OC WHITE",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING_WHITE,     0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL LC GeForce RTX 5090 OC",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_LC_RTX_5090_O32G_GAMING,        0x67);
@@ -454,7 +448,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);
 }
 
@@ -61,12 +61,5 @@ void ENESMBusInterface_i2c_smbus::ENERegisterWriteBlock(ene_dev_id dev, ene_regi
     bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
 
     //Write ENE block data
-    if(bus->i2c_smbus_write_block_data(dev, 0x03, sz, data) == -1)
-    {
-        //Fall back to individual byte operations if the block operation fails
-        for(unsigned int block_byte = 0; block_byte < sz; block_byte++)
-        {
-            bus->i2c_smbus_write_byte_data(dev, 0x01, data[block_byte]);
-        }
-    }
+    bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
 }

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

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

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()
@@ -230,41 +230,16 @@ void FnaticStreakController::SetLEDsDirect(std::vector<led> leds, std::vector<RG
 
 void FnaticStreakController::SendRGBToDevice()
 {
-    if(keyboard_type == FNATIC_STREAK_TYPE_65)
-    {
-        unsigned char data[64];
-        memset(data, 0x00, sizeof(data));
+    unsigned int total_leds = GetLEDCount();
+    unsigned int data_size = total_leds * 3;
 
-        data[0]  = 0x0F;
-        data[1]  = 0x15;
-
-        data[7]  = 0x0F;
-        data[8]  = 0x03;
-
-        for(unsigned int i = 9; i < 25; i++)
-        {
-            data[i] = 0xFF;
-        }
-
-        data[25] = color_buf[0];
-        data[26] = color_buf[1];
-        data[27] = color_buf[2];
-
-        hid_write(dev, data, sizeof(data));
-    }
-    else
-    {
-        unsigned int total_leds = GetLEDCount();
-        unsigned int data_size = total_leds * 3;
-
-        /*-----------------------------------------------------*\
-        | For direct/software control, use command 0x0f         |
-        | This bypasses the profile and allows immediate update |
-        | The 0x03 subcommand indicates per-key color data      |
-        \*-----------------------------------------------------*/
-        unsigned char prefix[] = { 0x0f, 0x03 };
-        SendRequest(prefix, sizeof(prefix), color_buf, data_size);
-    }
+    /*-----------------------------------------------------*\
+    | For direct/software control, use command 0x0f         |
+    | This bypasses the profile and allows immediate update |
+    | The 0x03 subcommand indicates per-key color data      |
+    \*-----------------------------------------------------*/
+    unsigned char prefix[] = { 0x0f, 0x03 };
+    SendRequest(prefix, sizeof(prefix), color_buf, data_size);
 }
 
 void FnaticStreakController::SetPulse(unsigned char color_mode, unsigned char r, unsigned char g, unsigned char b, unsigned char speed)

Controllers/FnaticStreakController/FnaticStreakController.h

@@ -51,8 +51,7 @@
 enum FnaticStreakType
 {
     FNATIC_STREAK_TYPE_FULL,
-    FNATIC_STREAK_TYPE_MINI,
-    FNATIC_STREAK_TYPE_65
+    FNATIC_STREAK_TYPE_MINI
 };
 
 class FnaticStreakController

Controllers/FnaticStreakController/FnaticStreakControllerDetect.cpp

@@ -26,7 +26,6 @@
 
 #define FNATIC_STREAK_PID                           0x0101
 #define FNATIC_MINISTREAK_PID                       0x0102
-#define FNATIC_STREAK65_PID                         0x0105
 
 DetectedControllers DetectFnaticStreakKeyboard(hid_device_info* info, const std::string& name)
 {
@@ -43,10 +42,6 @@ DetectedControllers DetectFnaticStreakKeyboard(hid_device_info* info, const std:
         {
             kb_type = FNATIC_STREAK_TYPE_MINI;
         }
-        else if(info->product_id == FNATIC_STREAK65_PID)
-        {
-            kb_type = FNATIC_STREAK_TYPE_65;
-        }
         else
         {
             kb_type = FNATIC_STREAK_TYPE_FULL;
@@ -63,4 +58,3 @@ DetectedControllers DetectFnaticStreakKeyboard(hid_device_info* info, const std:
 
 REGISTER_HID_DETECTOR_I("Fnatic Streak",      DetectFnaticStreakKeyboard, FNATIC_VID, FNATIC_STREAK_PID,      1);
 REGISTER_HID_DETECTOR_I("Fnatic miniStreak",  DetectFnaticStreakKeyboard, FNATIC_VID, FNATIC_MINISTREAK_PID,  1);
-REGISTER_HID_DETECTOR_I("Fnatic Streak65",    DetectFnaticStreakKeyboard, FNATIC_VID, FNATIC_STREAK65_PID,    1);

Controllers/GaiZongGaiKeyboardController/RGBController_GaiZhongGai.cpp

@@ -563,7 +563,7 @@ void RGBController_GaiZhongGaiKeyboard::SetupZones()
                 break;
 
             case GAIZHONGGAI_RGB_HUB_GREEN_PID:
-                temp                                        = controller->GetChannelLen((uint8_t)zone_idx);//get led_len
+                temp                                        = controller->GetChannelLen(zone_idx);//get led_len
                 zones[zone_idx].leds_min                    = 0;
                 zones[zone_idx].leds_max                    = 637;
 
@@ -600,7 +600,7 @@ void RGBController_GaiZhongGaiKeyboard::SetupZones()
                 break;
 
             case GAIZHONGGAI_RGB_HUB_BLUE_PID:
-                temp                                        = controller->GetChannelLen((uint8_t)zone_idx);//get led_len
+                temp                                        = controller->GetChannelLen(zone_idx);//get led_len
                 zones[zone_idx].leds_min                    = 0;
                 zones[zone_idx].leds_max                    = 633;
 

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/GalaxGPUControllerDetect.cpp

@@ -29,13 +29,10 @@ bool TestForGalaxGPUController(i2c_smbus_interface* bus, unsigned char address)
         \*-------------------------------------------------*/
         case 0x32:
             res  = bus->i2c_smbus_read_byte_data(address, 0x00);
-            if(res == 0x27 || res == 0x26)
-            {
+            if(res == 0x27 || res == 0x26) {
                 res = bus->i2c_smbus_read_byte_data(address, 0x01);
-                if(res == 0x10 || res == 0x20)
-                {
+                if (res == 0x10 || res == 0x20)
                     pass = true;
-                }
             }
             break;
 
@@ -44,7 +41,7 @@ bool TestForGalaxGPUController(i2c_smbus_interface* bus, unsigned char address)
         \*-------------------------------------------------*/
         case 0x23:
             res = bus->i2c_smbus_read_byte_data(address, 0x00);
-            if(res == 0x27 || res == 0x30)
+            if(res == 0x30)
             {
                 pass = true;
             }
@@ -55,10 +52,8 @@ bool TestForGalaxGPUController(i2c_smbus_interface* bus, unsigned char address)
         \*-------------------------------------------------*/
         case 0x51:
             res = bus->i2c_smbus_read_byte_data(address, 0x00);
-            if(res == 0x80)
-            {
+            if (res == 0x80)
                 pass = true;
-            }
             break;
     }
 

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/GigabyteCastor3Controller/GigabyteCastor3Controller.cpp

@@ -1,238 +0,0 @@
-/*---------------------------------------------------------*\
-|  GigabyteCastor3Controller.cpp                            |
-|                                                           |
-|  Driver for Gigabyte Aorus Waterforce X II 360 AIO        |
-|  (Castor3 USB HID controller)                             |
-|                                                           |
-|  RGB ring control only — LCD not implemented              |
-|                                                           |
-|  This file is part of the OpenRGB project                 |
-|  SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include "GigabyteCastor3Controller.h"
-#include "StringUtils.h"
-
-GigabyteCastor3Controller::GigabyteCastor3Controller(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-
-    /*---------------------------------------------------------*\
-    |  Query firmware version via de 00                         |
-    |  Response: de [version_byte]                              |
-    |  Observed: de 02 -> version 2                             |
-    \*---------------------------------------------------------*/
-    unsigned char de_payload[] = { 0xDE, 0x00 };
-    SendPacket(de_payload, 2);
-
-    unsigned char response[CASTOR3_IN_SIZE];
-    int bytes_read = hid_read_timeout(dev, response, CASTOR3_IN_SIZE, CASTOR3_IN_TIMEOUT_MS);
-
-    if(bytes_read > 1)
-    {
-        /*-----------------------------------------------------*\
-        |  Strip report ID 0x99 if present on IN packets         |
-        \*-----------------------------------------------------*/
-        int offset = 0;
-        if(response[0] == CASTOR3_REPORT_ID)
-        {
-            offset = 1;
-        }
-
-        if(response[offset] == 0xDE && bytes_read > offset + 1)
-        {
-            firmware_version = std::to_string(response[offset + 1]);
-        }
-    }
-}
-
-GigabyteCastor3Controller::~GigabyteCastor3Controller()
-{
-    hid_close(dev);
-}
-
-std::string GigabyteCastor3Controller::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string GigabyteCastor3Controller::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));
-}
-
-std::string GigabyteCastor3Controller::GetFirmwareVersion()
-{
-    return firmware_version;
-}
-
-void GigabyteCastor3Controller::SetEffect
-    (
-    unsigned char               style,
-    unsigned char               speed,
-    unsigned char               brightness,
-    unsigned char               b4,
-    unsigned char               b5,
-    castor3_color_type          color_type,
-    std::vector<RGBColor>       colors
-    )
-{
-    /*---------------------------------------------------------*\
-    |  Wire protocol for LED effect apply                       |
-    |  (from castor3.py led_set_effect, confirmed from          |
-    |   led_profile.pcapng + .cled.dat cross-reference)         |
-    |                                                           |
-    |  Step 1: c9 [Style] [Speed*20] [Bright] [b4] [b5]        |
-    |  Step 2: cd [R] [G] [B]          (single-color only)      |
-    |    -OR-  b0..b3 palette registers (palette effects)       |
-    |  Step 3: b6                       (commit)                |
-    \*---------------------------------------------------------*/
-
-    /*---------------------------------------------------------*\
-    |  Step 1: c9 — effect select + parameters                  |
-    \*---------------------------------------------------------*/
-    unsigned char c9_payload[] =
-    {
-        0xC9,
-        style,
-        (unsigned char)(speed * 20),
-        brightness,
-        b4,
-        b5
-    };
-    SendPacket(c9_payload, sizeof(c9_payload));
-
-    /*---------------------------------------------------------*\
-    |  Step 2a: cd — primary color for single-color effects     |
-    |  Effects: static, pulse, flash, dflash, gradient, off     |
-    \*---------------------------------------------------------*/
-    if(color_type == CASTOR3_COLORS_SINGLE)
-    {
-        unsigned char r = 0xFF, g = 0x66, b = 0x00;
-
-        if(colors.size() > 0)
-        {
-            r = RGBGetRValue(colors[0]);
-            g = RGBGetGValue(colors[0]);
-            b = RGBGetBValue(colors[0]);
-        }
-
-        unsigned char cd_payload[] = { 0xCD, r, g, b };
-        SendPacket(cd_payload, sizeof(cd_payload));
-    }
-    /*---------------------------------------------------------*\
-    |  Step 2b: b0..b3 — palette registers for multi-color      |
-    |  Each register carries 2 colors (6 bytes RGB + 1 pad):    |
-    |    bN [Style] [R1 G1 B1] [R2 G2 B2] 0x00                |
-    |  b0=colors 1+2, b1=colors 3+4, b2=colors 5+6, b3=7+8   |
-    |                                                           |
-    |  Effects: colorshift(8), tricolor(3), spin(3), switch(2)  |
-    \*---------------------------------------------------------*/
-    else if(color_type == CASTOR3_COLORS_PALETTE)
-    {
-        /*-----------------------------------------------------*\
-        |  Build palette: pad to 8 colors by repeating last     |
-        \*-----------------------------------------------------*/
-        RGBColor palette[8];
-
-        for(int i = 0; i < 8; i++)
-        {
-            if(i < (int)colors.size())
-            {
-                palette[i] = colors[i];
-            }
-            else if(colors.size() > 0)
-            {
-                palette[i] = colors[colors.size() - 1];
-            }
-            else
-            {
-                palette[i] = ToRGBColor(0xFF, 0x00, 0x00);
-            }
-        }
-
-        unsigned char regs[] = { 0xB0, 0xB1, 0xB2, 0xB3 };
-
-        for(int i = 0; i < 4; i++)
-        {
-            RGBColor c1 = palette[i * 2];
-            RGBColor c2 = palette[i * 2 + 1];
-
-            unsigned char bN_payload[] =
-            {
-                regs[i],
-                style,
-                (unsigned char)RGBGetRValue(c1), (unsigned char)RGBGetGValue(c1), (unsigned char)RGBGetBValue(c1),
-                (unsigned char)RGBGetRValue(c2), (unsigned char)RGBGetGValue(c2), (unsigned char)RGBGetBValue(c2),
-                0x00
-            };
-            SendPacket(bN_payload, sizeof(bN_payload));
-        }
-    }
-
-    /*---------------------------------------------------------*\
-    |  Step 3: b6 — commit/apply                                |
-    \*---------------------------------------------------------*/
-    unsigned char b6_payload[] = { 0xB6 };
-    SendPacket(b6_payload, sizeof(b6_payload));
-}
-
-void GigabyteCastor3Controller::SetOff()
-{
-    /*---------------------------------------------------------*\
-    |  Off = Style 0x01 (Static) with Speed=0                   |
-    |  From castor3.py: off uses style 0x01, speed_wire=0       |
-    \*---------------------------------------------------------*/
-    std::vector<RGBColor> black;
-    black.push_back(ToRGBColor(0x00, 0x00, 0x00));
-
-    unsigned char c9_payload[] =
-    {
-        0xC9,
-        CASTOR3_STYLE_STATIC,
-        0x00,                       /* speed_wire = 0 for off */
-        CASTOR3_BRIGHTNESS_DEFAULT,
-        0x02,                       /* b4 */
-        0x01                        /* b5 */
-    };
-    SendPacket(c9_payload, sizeof(c9_payload));
-
-    unsigned char cd_payload[] = { 0xCD, 0x00, 0x00, 0x00 };
-    SendPacket(cd_payload, sizeof(cd_payload));
-
-    unsigned char b6_payload[] = { 0xB6 };
-    SendPacket(b6_payload, sizeof(b6_payload));
-}
-
-void GigabyteCastor3Controller::SendPacket(const unsigned char* payload, unsigned int payload_len)
-{
-    /*---------------------------------------------------------*\
-    |  Castor3 HID OUT transport:                               |
-    |  - Byte 0: Report ID (0x99)                               |
-    |  - Bytes 1..6143: payload, zero-padded                    |
-    |  Total write size: 6144 bytes                             |
-    \*---------------------------------------------------------*/
-    unsigned char buf[CASTOR3_OUT_TOTAL];
-    memset(buf, 0x00, CASTOR3_OUT_TOTAL);
-
-    buf[0] = CASTOR3_REPORT_ID;
-
-    if(payload_len > CASTOR3_OUT_PAYLOAD)
-    {
-        payload_len = CASTOR3_OUT_PAYLOAD;
-    }
-
-    memcpy(&buf[1], payload, payload_len);
-
-    hid_write(dev, buf, CASTOR3_OUT_TOTAL);
-}

Controllers/GigabyteCastor3Controller/GigabyteCastor3Controller.h

@@ -1,123 +0,0 @@
-/*---------------------------------------------------------*\
-|  GigabyteCastor3Controller.h                              |
-|                                                           |
-|  Driver for Gigabyte Aorus Waterforce X II 360 AIO        |
-|  (Castor3 USB HID controller)                             |
-|                                                           |
-|  RGB ring control only — LCD not implemented              |
-|                                                           |
-|  Protocol reference: castor3.py reverse engineering        |
-|  VID=0x0414  PID=0x7A5E  Report ID=0x99                  |
-|  OUT size: 6144 (report ID + 6143 payload)                |
-|  IN size:  255                                            |
-|                                                           |
-|  This file is part of the OpenRGB project                 |
-|  SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include <vector>
-#include <hidapi.h>
-#include "RGBController.h"
-
-/*---------------------------------------------------------*\
-|  Castor3 USB IDs                                          |
-\*---------------------------------------------------------*/
-
-#define CASTOR3_VID                     0x0414
-#define CASTOR3_PID                     0x7A5E
-
-/*---------------------------------------------------------*\
-|  Castor3 HID transport                                    |
-\*---------------------------------------------------------*/
-
-#define CASTOR3_REPORT_ID               0x99
-#define CASTOR3_OUT_PAYLOAD             6143    /* payload after report ID */
-#define CASTOR3_OUT_TOTAL               6144    /* report ID + payload     */
-#define CASTOR3_IN_SIZE                 255
-#define CASTOR3_IN_TIMEOUT_MS           2000
-
-/*---------------------------------------------------------*\
-|  LED effect style IDs (c9 byte[1])                        |
-|  From castor3.py LED_EFFECTS, cross-referenced with       |
-|  .cled.dat profile files and led_profile.pcapng           |
-\*---------------------------------------------------------*/
-
-#define CASTOR3_STYLE_STATIC            0x01
-#define CASTOR3_STYLE_PULSE             0x02
-#define CASTOR3_STYLE_CYCLE             0x03
-#define CASTOR3_STYLE_FLASH             0x04
-#define CASTOR3_STYLE_DFLASH            0x05
-#define CASTOR3_STYLE_GRADIENT          0x06
-#define CASTOR3_STYLE_COLORSHIFT        0x07
-#define CASTOR3_STYLE_WAVE              0x08
-#define CASTOR3_STYLE_RAINBOW           0x0A
-#define CASTOR3_STYLE_TRICOLOR          0x0B
-#define CASTOR3_STYLE_SPIN              0x0C
-#define CASTOR3_STYLE_SWITCH            0x0D
-
-/*---------------------------------------------------------*\
-|  LED speed range: 1-5 (wire value = speed * 20)           |
-|  LED brightness range: 1-10 (direct on wire)              |
-\*---------------------------------------------------------*/
-
-#define CASTOR3_SPEED_MIN               1
-#define CASTOR3_SPEED_MAX               5
-#define CASTOR3_SPEED_DEFAULT           5
-#define CASTOR3_BRIGHTNESS_MIN          1
-#define CASTOR3_BRIGHTNESS_MAX          10
-#define CASTOR3_BRIGHTNESS_DEFAULT      10
-
-/*---------------------------------------------------------*\
-|  Color type for effects                                   |
-\*---------------------------------------------------------*/
-
-enum castor3_color_type
-{
-    CASTOR3_COLORS_NONE     = 0,    /* cycle, wave, rainbow    */
-    CASTOR3_COLORS_SINGLE   = 1,    /* static, pulse, flash... */
-    CASTOR3_COLORS_PALETTE  = 2,    /* colorshift, tricolor... */
-};
-
-class GigabyteCastor3Controller
-{
-public:
-    GigabyteCastor3Controller(hid_device* dev_handle, const char* path);
-    ~GigabyteCastor3Controller();
-
-    std::string     GetDeviceLocation();
-    std::string     GetSerialString();
-    std::string     GetFirmwareVersion();
-
-    /*---------------------------------------------------------*\
-    |  LED effect application                                   |
-    |                                                           |
-    |  Wire sequence per effect apply:                          |
-    |    c9 [Style] [Speed*20] [Bright] [b4] [b5]              |
-    |    cd [R] [G] [B]                  — single-color only    |
-    |    b0 [Style] [R1G1B1] [R2G2B2] 00 — palette colors 1+2 |
-    |    b1 [Style] [R3G3B3] [R4G4B4] 00 — colors 3+4         |
-    |    b2 [Style] [R5G5B5] [R6G6B6] 00 — colors 5+6         |
-    |    b3 [Style] [R7G7B7] [R8G8B8] 00 — colors 7+8         |
-    |    b6                               — commit/apply        |
-    \*---------------------------------------------------------*/
-
-    void            SetEffect(unsigned char style,
-                              unsigned char speed,
-                              unsigned char brightness,
-                              unsigned char b4,
-                              unsigned char b5,
-                              castor3_color_type color_type,
-                              std::vector<RGBColor> colors);
-
-    void            SetOff();
-
-private:
-    hid_device*     dev;
-    std::string     location;
-    std::string     firmware_version;
-
-    void            SendPacket(const unsigned char* payload, unsigned int payload_len);
-};

Controllers/GigabyteCastor3Controller/GigabyteCastor3ControllerDetect.cpp

@@ -1,37 +0,0 @@
-/*---------------------------------------------------------*\
-|  GigabyteCastor3ControllerDetect.cpp                      |
-|                                                           |
-|  Detector for Gigabyte Aorus Waterforce X II 360 AIO      |
-|  (Castor3 USB HID controller)                             |
-|                                                           |
-|  This file is part of the OpenRGB project                 |
-|  SPDX-License-Identifier: GPL-2.0-or-later                |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
-#include "DetectionManager.h"
-#include "GigabyteCastor3Controller.h"
-#include "RGBController_GigabyteCastor3.h"
-
-#define GIGABYTE_CASTOR3_VID            0x0414
-#define GIGABYTE_CASTOR3_PID            0x7A5E
-
-DetectedControllers DetectGigabyteCastor3Controllers(hid_device_info* info, const std::string& /*name*/)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        GigabyteCastor3Controller*      controller      = new GigabyteCastor3Controller(dev, info->path);
-        RGBController_GigabyteCastor3*  rgb_controller  = new RGBController_GigabyteCastor3(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
-
-REGISTER_HID_DETECTOR_IPU("Gigabyte Aorus Waterforce X II 360", DetectGigabyteCastor3Controllers, GIGABYTE_CASTOR3_VID, GIGABYTE_CASTOR3_PID, 0, 0x0000, 0x0002);

Controllers/GigabyteCastor3Controller/RGBController_GigabyteCastor3.cpp

@@ -1,440 +0,0 @@
-/*---------------------------------------------------------*\
-|  RGBController_GigabyteCastor3.cpp                        |
-|                                                           |
-|  RGBController for Gigabyte Aorus Waterforce X II 360     |
-|  AIO Cooler (Castor3 controller)                          |
-|                                                           |
-|  This file is part of the OpenRGB project                 |
-|  SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBController_GigabyteCastor3.h"
-
-/**------------------------------------------------------------------*\
-    @name Gigabyte Aorus Waterforce X II 360
-    @category Cooler
-    @type USB
-    @save :o:
-    @direct :o:
-    @effects :white_check_mark:
-    @detectors DetectGigabyteCastor3Controllers
-    @comment Controls the LED ring on the pump head of the
-        Gigabyte Aorus Waterforce X II 360 AIO cooler.
-        Uses the Castor3 USB HID controller (VID 0x0414, PID 0x7A5E).
-        The LED ring and fans share the same controller — they are
-        not independently addressable and follow the same effect.
-        LCD display control is not implemented.
-        No direct/per-LED mode available — all modes are hardware
-        effects with a single color or palette.
-\*-------------------------------------------------------------------*/
-
-RGBController_GigabyteCastor3::RGBController_GigabyteCastor3(GigabyteCastor3Controller* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "Gigabyte Aorus Waterforce X II 360";
-    vendor      = "Gigabyte";
-    type        = DEVICE_TYPE_COOLER;
-    description = "Gigabyte Aorus Waterforce X II 360 AIO Cooler";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-    version     = controller->GetFirmwareVersion();
-
-    /*---------------------------------------------------------*\
-    |  All modes from castor3.py LED_EFFECTS (12 effects + off) |
-    |                                                           |
-    |  The Castor3 has no direct/per-LED mode. All effects are  |
-    |  hardware-driven, either single-color, palette, or        |
-    |  firmware-color (no user color).                          |
-    |                                                           |
-    |  Speed: 1-5 mapped to MODE_FLAG_HAS_SPEED                |
-    |  Brightness: 1-10 mapped to MODE_FLAG_HAS_BRIGHTNESS      |
-    |                                                           |
-    |  mode.value stores the style byte for the c9 command.     |
-    |  mode.speed stores 1-5 (scaled to speed*20 on wire).      |
-    |  mode.brightness stores 1-10 (direct on wire).            |
-    \*---------------------------------------------------------*/
-
-    /*---------------------------------------------------------*\
-    |  Off                                                      |
-    |  Wire: Style=0x01 (Static) with speed_wire=0              |
-    \*---------------------------------------------------------*/
-    mode Off;
-    Off.name            = "Off";
-    Off.value           = 0xFF;     /* sentinel — handled specially */
-    Off.flags           = 0;
-    Off.color_mode      = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    /*---------------------------------------------------------*\
-    |  Static — single color, no speed                          |
-    \*---------------------------------------------------------*/
-    mode Static;
-    Static.name         = "Static";
-    Static.value        = CASTOR3_STYLE_STATIC;
-    Static.flags        = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.colors_min   = 1;
-    Static.colors_max   = 1;
-    Static.color_mode   = MODE_COLORS_MODE_SPECIFIC;
-    Static.brightness_min = CASTOR3_BRIGHTNESS_MIN;
-    Static.brightness_max = CASTOR3_BRIGHTNESS_MAX;
-    Static.brightness   = CASTOR3_BRIGHTNESS_DEFAULT;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    /*---------------------------------------------------------*\
-    |  Pulse — single color, speed + brightness                 |
-    \*---------------------------------------------------------*/
-    mode Pulse;
-    Pulse.name          = "Pulse";
-    Pulse.value         = CASTOR3_STYLE_PULSE;
-    Pulse.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Pulse.speed_min     = CASTOR3_SPEED_MIN;
-    Pulse.speed_max     = CASTOR3_SPEED_MAX;
-    Pulse.speed         = CASTOR3_SPEED_DEFAULT;
-    Pulse.colors_min    = 1;
-    Pulse.colors_max    = 1;
-    Pulse.color_mode    = MODE_COLORS_MODE_SPECIFIC;
-    Pulse.brightness_min = CASTOR3_BRIGHTNESS_MIN;
-    Pulse.brightness_max = CASTOR3_BRIGHTNESS_MAX;
-    Pulse.brightness    = CASTOR3_BRIGHTNESS_DEFAULT;
-    Pulse.colors.resize(1);
-    modes.push_back(Pulse);
-
-    /*---------------------------------------------------------*\
-    |  Flash — single color, speed + brightness                 |
-    \*---------------------------------------------------------*/
-    mode Flash;
-    Flash.name          = "Flash";
-    Flash.value         = CASTOR3_STYLE_FLASH;
-    Flash.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Flash.speed_min     = CASTOR3_SPEED_MIN;
-    Flash.speed_max     = CASTOR3_SPEED_MAX;
-    Flash.speed         = CASTOR3_SPEED_DEFAULT;
-    Flash.colors_min    = 1;
-    Flash.colors_max    = 1;
-    Flash.color_mode    = MODE_COLORS_MODE_SPECIFIC;
-    Flash.brightness_min = CASTOR3_BRIGHTNESS_MIN;
-    Flash.brightness_max = CASTOR3_BRIGHTNESS_MAX;
-    Flash.brightness    = CASTOR3_BRIGHTNESS_DEFAULT;
-    Flash.colors.resize(1);
-    modes.push_back(Flash);
-
-    /*---------------------------------------------------------*\
-    |  Double Flash — single color, speed + brightness          |
-    \*---------------------------------------------------------*/
-    mode DFlash;
-    DFlash.name         = "Double Flash";
-    DFlash.value        = CASTOR3_STYLE_DFLASH;
-    DFlash.flags        = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    DFlash.speed_min    = CASTOR3_SPEED_MIN;
-    DFlash.speed_max    = CASTOR3_SPEED_MAX;
-    DFlash.speed        = CASTOR3_SPEED_DEFAULT;
-    DFlash.colors_min   = 1;
-    DFlash.colors_max   = 1;
-    DFlash.color_mode   = MODE_COLORS_MODE_SPECIFIC;
-    DFlash.brightness_min = CASTOR3_BRIGHTNESS_MIN;
-    DFlash.brightness_max = CASTOR3_BRIGHTNESS_MAX;
-    DFlash.brightness   = CASTOR3_BRIGHTNESS_DEFAULT;
-    DFlash.colors.resize(1);
-    modes.push_back(DFlash);
-
-    /*---------------------------------------------------------*\
-    |  Cycle — firmware colors, speed only                      |
-    \*---------------------------------------------------------*/
-    mode Cycle;
-    Cycle.name          = "Spectrum Cycle";
-    Cycle.value         = CASTOR3_STYLE_CYCLE;
-    Cycle.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Cycle.speed_min     = CASTOR3_SPEED_MIN;
-    Cycle.speed_max     = CASTOR3_SPEED_MAX;
-    Cycle.speed         = CASTOR3_SPEED_DEFAULT;
-    Cycle.color_mode    = MODE_COLORS_NONE;
-    Cycle.brightness_min = CASTOR3_BRIGHTNESS_MIN;
-    Cycle.brightness_max = CASTOR3_BRIGHTNESS_MAX;
-    Cycle.brightness    = CASTOR3_BRIGHTNESS_DEFAULT;
-    modes.push_back(Cycle);
-
-    /*---------------------------------------------------------*\
-    |  Gradient — single color, speed + brightness              |
-    |  Note: b4 = brightness on wire (special case)             |
-    \*---------------------------------------------------------*/
-    mode Gradient;
-    Gradient.name       = "Gradient";
-    Gradient.value      = CASTOR3_STYLE_GRADIENT;
-    Gradient.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Gradient.speed_min  = CASTOR3_SPEED_MIN;
-    Gradient.speed_max  = CASTOR3_SPEED_MAX;
-    Gradient.speed      = CASTOR3_SPEED_DEFAULT;
-    Gradient.colors_min = 1;
-    Gradient.colors_max = 1;
-    Gradient.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Gradient.brightness_min = CASTOR3_BRIGHTNESS_MIN;
-    Gradient.brightness_max = CASTOR3_BRIGHTNESS_MAX;
-    Gradient.brightness = CASTOR3_BRIGHTNESS_DEFAULT;
-    Gradient.colors.resize(1);
-    modes.push_back(Gradient);
-
-    /*---------------------------------------------------------*\
-    |  Color Shift — 8-color palette, speed + brightness        |
-    \*---------------------------------------------------------*/
-    mode ColorShift;
-    ColorShift.name         = "Color Shift";
-    ColorShift.value        = CASTOR3_STYLE_COLORSHIFT;
-    ColorShift.flags        = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    ColorShift.speed_min    = CASTOR3_SPEED_MIN;
-    ColorShift.speed_max    = CASTOR3_SPEED_MAX;
-    ColorShift.speed        = CASTOR3_SPEED_DEFAULT;
-    ColorShift.colors_min   = 1;
-    ColorShift.colors_max   = 8;
-    ColorShift.color_mode   = MODE_COLORS_MODE_SPECIFIC;
-    ColorShift.brightness_min = CASTOR3_BRIGHTNESS_MIN;
-    ColorShift.brightness_max = CASTOR3_BRIGHTNESS_MAX;
-    ColorShift.brightness   = CASTOR3_BRIGHTNESS_DEFAULT;
-    ColorShift.colors.resize(8);
-    ColorShift.colors[0] = ToRGBColor(0xFF, 0x00, 0x00);
-    ColorShift.colors[1] = ToRGBColor(0xFF, 0x72, 0x00);
-    ColorShift.colors[2] = ToRGBColor(0xFF, 0xFF, 0x00);
-    ColorShift.colors[3] = ToRGBColor(0x00, 0xFF, 0x00);
-    ColorShift.colors[4] = ToRGBColor(0x00, 0xFF, 0xFF);
-    ColorShift.colors[5] = ToRGBColor(0x00, 0x00, 0xFF);
-    ColorShift.colors[6] = ToRGBColor(0xFF, 0x00, 0xFF);
-    ColorShift.colors[7] = ToRGBColor(0xFF, 0x80, 0x80);
-    modes.push_back(ColorShift);
-
-    /*---------------------------------------------------------*\
-    |  Wave — firmware colors, speed only                       |
-    \*---------------------------------------------------------*/
-    mode Wave;
-    Wave.name           = "Wave";
-    Wave.value          = CASTOR3_STYLE_WAVE;
-    Wave.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Wave.speed_min      = CASTOR3_SPEED_MIN;
-    Wave.speed_max      = CASTOR3_SPEED_MAX;
-    Wave.speed          = CASTOR3_SPEED_DEFAULT;
-    Wave.color_mode     = MODE_COLORS_NONE;
-    Wave.brightness_min = CASTOR3_BRIGHTNESS_MIN;
-    Wave.brightness_max = CASTOR3_BRIGHTNESS_MAX;
-    Wave.brightness     = CASTOR3_BRIGHTNESS_DEFAULT;
-    modes.push_back(Wave);
-
-    /*---------------------------------------------------------*\
-    |  Rainbow — firmware colors, speed only                    |
-    \*---------------------------------------------------------*/
-    mode Rainbow;
-    Rainbow.name        = "Rainbow";
-    Rainbow.value       = CASTOR3_STYLE_RAINBOW;
-    Rainbow.flags       = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Rainbow.speed_min   = CASTOR3_SPEED_MIN;
-    Rainbow.speed_max   = CASTOR3_SPEED_MAX;
-    Rainbow.speed       = CASTOR3_SPEED_DEFAULT;
-    Rainbow.color_mode  = MODE_COLORS_NONE;
-    Rainbow.brightness_min = CASTOR3_BRIGHTNESS_MIN;
-    Rainbow.brightness_max = CASTOR3_BRIGHTNESS_MAX;
-    Rainbow.brightness  = CASTOR3_BRIGHTNESS_DEFAULT;
-    modes.push_back(Rainbow);
-
-    /*---------------------------------------------------------*\
-    |  Tri-Color — 3-color palette, speed + brightness          |
-    \*---------------------------------------------------------*/
-    mode TriColor;
-    TriColor.name       = "Tri-Color";
-    TriColor.value      = CASTOR3_STYLE_TRICOLOR;
-    TriColor.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    TriColor.speed_min  = CASTOR3_SPEED_MIN;
-    TriColor.speed_max  = CASTOR3_SPEED_MAX;
-    TriColor.speed      = CASTOR3_SPEED_DEFAULT;
-    TriColor.colors_min = 1;
-    TriColor.colors_max = 3;
-    TriColor.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    TriColor.brightness_min = CASTOR3_BRIGHTNESS_MIN;
-    TriColor.brightness_max = CASTOR3_BRIGHTNESS_MAX;
-    TriColor.brightness = CASTOR3_BRIGHTNESS_DEFAULT;
-    TriColor.colors.resize(3);
-    TriColor.colors[0]  = ToRGBColor(0x00, 0x00, 0xFF);
-    TriColor.colors[1]  = ToRGBColor(0x7D, 0x00, 0xFF);
-    TriColor.colors[2]  = ToRGBColor(0xFF, 0x00, 0xFF);
-    modes.push_back(TriColor);
-
-    /*---------------------------------------------------------*\
-    |  Spin — 3-color palette, speed + brightness               |
-    \*---------------------------------------------------------*/
-    mode Spin;
-    Spin.name           = "Spin";
-    Spin.value          = CASTOR3_STYLE_SPIN;
-    Spin.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Spin.speed_min      = CASTOR3_SPEED_MIN;
-    Spin.speed_max      = CASTOR3_SPEED_MAX;
-    Spin.speed          = CASTOR3_SPEED_DEFAULT;
-    Spin.colors_min     = 1;
-    Spin.colors_max     = 3;
-    Spin.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-    Spin.brightness_min = CASTOR3_BRIGHTNESS_MIN;
-    Spin.brightness_max = CASTOR3_BRIGHTNESS_MAX;
-    Spin.brightness     = CASTOR3_BRIGHTNESS_DEFAULT;
-    Spin.colors.resize(3);
-    Spin.colors[0]      = ToRGBColor(0xFF, 0x00, 0xFE);
-    Spin.colors[1]      = ToRGBColor(0x00, 0xFF, 0xFB);
-    Spin.colors[2]      = ToRGBColor(0xFF, 0xFF, 0x00);
-    modes.push_back(Spin);
-
-    /*---------------------------------------------------------*\
-    |  Switch — 2-color palette, speed + brightness             |
-    \*---------------------------------------------------------*/
-    mode Switch;
-    Switch.name         = "Switch";
-    Switch.value        = CASTOR3_STYLE_SWITCH;
-    Switch.flags        = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Switch.speed_min    = CASTOR3_SPEED_MIN;
-    Switch.speed_max    = CASTOR3_SPEED_MAX;
-    Switch.speed        = CASTOR3_SPEED_DEFAULT;
-    Switch.colors_min   = 1;
-    Switch.colors_max   = 2;
-    Switch.color_mode   = MODE_COLORS_MODE_SPECIFIC;
-    Switch.brightness_min = CASTOR3_BRIGHTNESS_MIN;
-    Switch.brightness_max = CASTOR3_BRIGHTNESS_MAX;
-    Switch.brightness   = CASTOR3_BRIGHTNESS_DEFAULT;
-    Switch.colors.resize(2);
-    Switch.colors[0]    = ToRGBColor(0xFF, 0x00, 0xFE);
-    Switch.colors[1]    = ToRGBColor(0x00, 0xFF, 0xFB);
-    modes.push_back(Switch);
-
-    SetupZones();
-}
-
-RGBController_GigabyteCastor3::~RGBController_GigabyteCastor3()
-{
-    Shutdown();
-
-    delete controller;
-}
-
-void RGBController_GigabyteCastor3::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    |  Single zone: LED ring + fans (not independently          |
-    |  addressable — fans follow the pump ring effect)          |
-    |                                                           |
-    |  This is a SINGLE zone because the protocol does not      |
-    |  expose per-LED addressing. All LEDs display the same     |
-    |  hardware effect simultaneously.                          |
-    \*---------------------------------------------------------*/
-    zone led_ring;
-    led_ring.name       = "LED Ring";
-    led_ring.type       = ZONE_TYPE_SINGLE;
-    led_ring.leds_min   = 1;
-    led_ring.leds_max   = 1;
-    led_ring.leds_count = 1;
-    zones.push_back(led_ring);
-
-    led new_led;
-    new_led.name = "LED Ring";
-    leds.push_back(new_led);
-
-    SetupColors();
-}
-
-void RGBController_GigabyteCastor3::DeviceUpdateLEDs()
-{
-    DeviceUpdateMode();
-}
-
-void RGBController_GigabyteCastor3::DeviceUpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_GigabyteCastor3::DeviceUpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_GigabyteCastor3::DeviceUpdateMode()
-{
-    unsigned char style = (unsigned char)modes[active_mode].value;
-
-    /*---------------------------------------------------------*\
-    |  Handle Off mode (sentinel value 0xFF)                    |
-    \*---------------------------------------------------------*/
-    if(style == 0xFF)
-    {
-        controller->SetOff();
-        return;
-    }
-
-    /*---------------------------------------------------------*\
-    |  Determine speed, brightness, b4, b5, and color type      |
-    |  from the effect lookup table matching castor3.py          |
-    \*---------------------------------------------------------*/
-    unsigned char speed      = CASTOR3_SPEED_DEFAULT;
-    unsigned char brightness = CASTOR3_BRIGHTNESS_DEFAULT;
-
-    if(modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
-    {
-        speed = (unsigned char)modes[active_mode].speed;
-    }
-
-    if(modes[active_mode].flags & MODE_FLAG_HAS_BRIGHTNESS)
-    {
-        brightness = (unsigned char)modes[active_mode].brightness;
-    }
-
-    /*---------------------------------------------------------*\
-    |  Look up b4, b5, and color_type per effect                |
-    |  These match the LED_EFFECTS dict in castor3.py           |
-    \*---------------------------------------------------------*/
-    unsigned char b4 = 0x02;
-    unsigned char b5 = 0x01;
-    castor3_color_type color_type = CASTOR3_COLORS_NONE;
-
-    switch(style)
-    {
-        case CASTOR3_STYLE_STATIC:
-        case CASTOR3_STYLE_PULSE:
-        case CASTOR3_STYLE_FLASH:
-        case CASTOR3_STYLE_DFLASH:
-            b4 = 0x02;
-            b5 = 0x01;
-            color_type = CASTOR3_COLORS_SINGLE;
-            break;
-
-        case CASTOR3_STYLE_GRADIENT:
-            /*-------------------------------------------------*\
-            |  Gradient: b4 = brightness on wire (special case)  |
-            \*-------------------------------------------------*/
-            b4 = brightness;
-            b5 = 0x01;
-            color_type = CASTOR3_COLORS_SINGLE;
-            break;
-
-        case CASTOR3_STYLE_CYCLE:
-        case CASTOR3_STYLE_WAVE:
-        case CASTOR3_STYLE_RAINBOW:
-            b4 = 0x02;
-            b5 = 0x01;
-            color_type = CASTOR3_COLORS_NONE;
-            break;
-
-        case CASTOR3_STYLE_COLORSHIFT:
-            b4 = 0x08;     /* ClrCount=8 */
-            b5 = 0x02;     /* CmbIndex+1=2 */
-            color_type = CASTOR3_COLORS_PALETTE;
-            break;
-
-        case CASTOR3_STYLE_TRICOLOR:
-        case CASTOR3_STYLE_SPIN:
-            b4 = 0x02;
-            b5 = 0x01;
-            color_type = CASTOR3_COLORS_PALETTE;
-            break;
-
-        case CASTOR3_STYLE_SWITCH:
-            b4 = 0x02;
-            b5 = 0x01;
-            color_type = CASTOR3_COLORS_PALETTE;
-            break;
-    }
-
-    controller->SetEffect(style, speed, brightness, b4, b5,
-                          color_type, modes[active_mode].colors);
-}

Controllers/GigabyteCastor3Controller/RGBController_GigabyteCastor3.h

@@ -1,32 +0,0 @@
-/*---------------------------------------------------------*\
-|  RGBController_GigabyteCastor3.h                          |
-|                                                           |
-|  RGBController for Gigabyte Aorus Waterforce X II 360     |
-|  AIO Cooler (Castor3 controller)                          |
-|                                                           |
-|  This file is part of the OpenRGB project                 |
-|  SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "GigabyteCastor3Controller.h"
-
-class RGBController_GigabyteCastor3 : public RGBController
-{
-public:
-    RGBController_GigabyteCastor3(GigabyteCastor3Controller* controller_ptr);
-    ~RGBController_GigabyteCastor3();
-
-    void        SetupZones();
-
-    void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    GigabyteCastor3Controller*  controller;
-};

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 ");
@@ -68,14 +68,9 @@ void RGBFusion2BlackwellGPUController::SetMode(uint8_t type, uint8_t zone, uint8
     if(zone_config.numberOfColors > 0)
     {
         int currentPos = 12;
-        switch(gpu_layout)
+        if(gpu_layout == RGB_FUSION2_BLACKWELL_GPU_AORUS_MASTER_5080_LAYOUT)
         {
-            case RGB_FUSION2_BLACKWELL_GPU_AORUS_MASTER_5080_LAYOUT:
-            case RGB_FUSION2_BLACKWELL_GPU_AORUS_MASTER_5090D_V2_ICE_LAYOUT:
-                currentPos = 11;
-                break;
-            default:
-                break;
+            currentPos = 11;
         }
 
         for(uint8_t i = 0; i < zone_config.numberOfColors; i++)
@@ -95,16 +90,6 @@ void RGBFusion2BlackwellGPUController::SetZone(uint8_t zone, uint8_t mode, fusio
     if(mode == RGB_FUSION2_BLACKWELL_GPU_MODE_BREATHING)
         zone_config.brightness = RGB_FUSION2_BLACKWELL_GPU_BRIGHTNESS_MAX;
 
-    switch(gpu_layout)
-    {
-        case RGB_FUSION2_BLACKWELL_GPU_AORUS_MASTER_5090D_V2_ICE_LAYOUT:
-            if(mode == RGB_FUSION2_BLACKWELL_GPU_MODE_DIRECT)
-                mode = RGB_FUSION2_BLACKWELL_GPU_MODE_STATIC;
-            break;
-        default:
-            break;
-    }
-
     uint8_t type = RGB_FUSION2_BLACKWELL_GPU_REG_COLOR;
     if(mode != RGB_FUSION2_BLACKWELL_GPU_MODE_DIRECT)
         type = RGB_FUSION2_BLACKWELL_GPU_REG_MODE;

Controllers/GigabyteRGBFusion2BlackwellGPUController/GigabyteRGBFusion2BlackwellGPUController.h

@@ -62,12 +62,11 @@ enum
 
 enum
 {
-    RGB_FUSION2_BLACKWELL_GPU_SINGLE_ZONE                          = 0,
-    RGB_FUSION2_BLACKWELL_GPU_GAMING_LAYOUT                        = 1,
-    RGB_FUSION2_BLACKWELL_GPU_WATERFORCE_LAYOUT                    = 2,
-    RGB_FUSION2_BLACKWELL_GPU_AORUS_WATERFORCE_LAYOUT              = 3,
-    RGB_FUSION2_BLACKWELL_GPU_AORUS_MASTER_5080_LAYOUT             = 4,
-    RGB_FUSION2_BLACKWELL_GPU_AORUS_MASTER_5090D_V2_ICE_LAYOUT     = 5,
+    RGB_FUSION2_BLACKWELL_GPU_SINGLE_ZONE              = 0,
+    RGB_FUSION2_BLACKWELL_GPU_GAMING_LAYOUT            = 1,
+    RGB_FUSION2_BLACKWELL_GPU_WATERFORCE_LAYOUT        = 2,
+    RGB_FUSION2_BLACKWELL_GPU_AORUS_WATERFORCE_LAYOUT  = 3,
+    RGB_FUSION2_BLACKWELL_GPU_AORUS_MASTER_5080_LAYOUT = 4,
 };
 
 class RGBFusion2BlackwellGPUController

Controllers/GigabyteRGBFusion2BlackwellGPUController/GigabyteRGBFusion2BlackwellGPUControllerDetect.cpp

@@ -1,4 +1,4 @@
-/*---------------------------------------------------------*\
+/*---------------------------------------------------------*\
 | GigabyteRGBFusion2BlackwellGPUControllerDetect.cpp        |
 |                                                           |
 |   Detector for Gigabyte RGB Fusion 2 Blackwell GPU        |
@@ -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;
     }
@@ -105,42 +105,34 @@ DetectedControllers DetectGigabyteRGBFusion2BlackwellAorusMaster5080LayoutGPUCon
     return(DetectGigabyteRGBFusion2BlackwellGPUControllers(bus, i2c_addr, name, RGB_FUSION2_BLACKWELL_GPU_AORUS_MASTER_5080_LAYOUT));
 }
 
-DetectedControllers DetectGigabyteRGBFusion2BlackwellAorusMaster5090DV2IceLayoutGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
-{
-    return(DetectGigabyteRGBFusion2BlackwellGPUControllers(bus, i2c_addr, name, RGB_FUSION2_BLACKWELL_GPU_AORUS_MASTER_5090D_V2_ICE_LAYOUT));
-}
-
 /*---------------------------------------------------------*\
 |  Nvidia GPUs                                              |
 \*---------------------------------------------------------*/
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5060 Ti Gaming OC",                 DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,                      NVIDIA_VEN,     NVIDIA_RTX5060TI_DEV,       GIGABYTE_SUB_VEN, GIGABYTE_RTX5060TI_GAMING_OC_16G_SUB_DEV,                 0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Aero OC",                      DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,                      NVIDIA_VEN,     NVIDIA_RTX5070_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5070_AERO_OC_12G_SUB_DEV,                     0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Eagle OC",                     DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,                      NVIDIA_VEN,     NVIDIA_RTX5070_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5070_EAGLE_OC_12G_SUB_DEV,                    0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Eagle OC ICE",                 DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,                      NVIDIA_VEN,     NVIDIA_RTX5070_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5070_EAGLE_OC_ICE_12G_SUB_DEV,                0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Gaming OC",                    DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    NVIDIA_VEN,     NVIDIA_RTX5070_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5070_GAMING_OC_12G_SUB_DEV,                   0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Ti Eagle OC",                  DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,                      NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       GIGABYTE_SUB_VEN, GIGABYTE_RTX5070TI_EAGLE_OC_16G_SUB_DEV,                  0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Ti Eagle OC ICE",              DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,                      NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       GIGABYTE_SUB_VEN, GIGABYTE_RTX5070TI_EAGLE_OC_ICE_16G_SUB_DEV,              0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Ti Aero OC",                   DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,                      NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       GIGABYTE_SUB_VEN, GIGABYTE_RTX5070TI_AERO_OC_16G_SUB_DEV,                   0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Ti Gaming OC",                 DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       GIGABYTE_SUB_VEN, GIGABYTE_RTX5070TI_GAMING_OC_16G_SUB_DEV,                 0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5080 Aero OC",                      DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,                      NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5080_AERO_OC_16G_SUB_DEV,                     0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5080 Gaming OC",                    DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5080_GAMING_OC_16G_SUB_DEV,                   0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5080 MASTER",                 DetectGigabyteRGBFusion2BlackwellAorusMaster5080LayoutGPUControllers,           NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5080_MASTER_16G_SUB_DEV,                0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5080 XTREME WATERFORCE",      DetectGigabyteRGBFusion2BlackwellAorusWaterforceLayoutGPUControllers,           NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5080_XTREME_WATERFORCE_16G_SUB_DEV,     0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5080 XTREME WATERFORCE",            DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers,                NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5080_XTREME_WATERFORCE_16G_SUB_DEV,           0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5080 MASTER ICE",             DetectGigabyteRGBFusion2BlackwellAorusMaster5080LayoutGPUControllers,           NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5080_MASTER_ICE_16G_SUB_DEV,            0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 Gaming OC",                    DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_GAMING_OC_32G_SUB_DEV,                   0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 XTREME WATERFORCE",            DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers,                NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV1,          0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 XTREME WATERFORCE",            DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers,                NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV2,          0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 MASTER",                 DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5090_MASTER_32G_SUB_DEV,                0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 MASTER ICE",             DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5090_MASTER_ICE_32G_SUB_DEV,            0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 D V2 MASTER ICE",        DetectGigabyteRGBFusion2BlackwellAorusMaster5090DV2IceLayoutGPUControllers,     NVIDIA_VEN,     NVIDIA_RTX5090D_V2_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5090D_V2_MASTER_ICE_24G_SUB_DEV,        0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5060 Ti Gaming OC",                 DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,          NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,   GIGABYTE_SUB_VEN, GIGABYTE_RTX5060TI_GAMING_OC_16G_SUB_DEV,         0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Aero OC",                      DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,          NVIDIA_VEN, NVIDIA_RTX5070_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_RTX5070_AERO_OC_12G_SUB_DEV,             0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Eagle OC",                     DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,          NVIDIA_VEN, NVIDIA_RTX5070_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_RTX5070_EAGLE_OC_12G_SUB_DEV,            0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Gaming OC",                    DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        NVIDIA_VEN, NVIDIA_RTX5070_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_RTX5070_GAMING_OC_12G_SUB_DEV,           0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Ti Eagle OC",                  DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,          NVIDIA_VEN, NVIDIA_RTX5070TI_DEV,   GIGABYTE_SUB_VEN, GIGABYTE_RTX5070TI_EAGLE_OC_16G_SUB_DEV,          0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Ti Eagle OC ICE",              DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,          NVIDIA_VEN, NVIDIA_RTX5070TI_DEV,   GIGABYTE_SUB_VEN, GIGABYTE_RTX5070TI_EAGLE_OC_ICE_16G_SUB_DEV,      0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Ti Aero OC",                   DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,          NVIDIA_VEN, NVIDIA_RTX5070TI_DEV,   GIGABYTE_SUB_VEN, GIGABYTE_RTX5070TI_AERO_OC_16G_SUB_DEV,           0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Ti Gaming OC",                 DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        NVIDIA_VEN, NVIDIA_RTX5070TI_DEV,   GIGABYTE_SUB_VEN, GIGABYTE_RTX5070TI_GAMING_OC_16G_SUB_DEV,         0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5080 Aero OC",                      DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,          NVIDIA_VEN, NVIDIA_RTX5080_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_RTX5080_AERO_OC_16G_SUB_DEV,             0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5080 Gaming OC",                    DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,             NVIDIA_VEN, NVIDIA_RTX5080_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_RTX5080_GAMING_OC_16G_SUB_DEV,                0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5080 MASTER",                 DetectGigabyteRGBFusion2BlackwellAorusMaster5080LayoutGPUControllers,    NVIDIA_VEN, NVIDIA_RTX5080_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5080_MASTER_16G_SUB_DEV,  0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5080 XTREME WATERFORCE",      DetectGigabyteRGBFusion2BlackwellAorusWaterforceLayoutGPUControllers,    NVIDIA_VEN, NVIDIA_RTX5080_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5080_XTREME_WATERFORCE_16G_SUB_DEV,  0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5080 XTREME WATERFORCE",            DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers,    NVIDIA_VEN, NVIDIA_RTX5080_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_RTX5080_XTREME_WATERFORCE_16G_SUB_DEV,        0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 Gaming OC",                    DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        NVIDIA_VEN, NVIDIA_RTX5090_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_GAMING_OC_32G_SUB_DEV,                0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 XTREME WATERFORCE",            DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers,    NVIDIA_VEN, NVIDIA_RTX5090_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV1,  0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 XTREME WATERFORCE",            DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers,    NVIDIA_VEN, NVIDIA_RTX5090_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV2,  0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 MASTER",                 DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        NVIDIA_VEN, NVIDIA_RTX5090_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5090_MASTER_32G_SUB_DEV,        0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 MASTER ICE",             DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        NVIDIA_VEN, NVIDIA_RTX5090_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5090_MASTER_ICE_32G_SUB_DEV,    0x75);
 
 /*---------------------------------------------------------*\
 |  AMD GPUs                                                 |
 \*---------------------------------------------------------*/
-REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9060 XT GAMING",                      DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    AMD_GPU_VEN,    AMD_NAVI44_DEV,             GIGABYTE_SUB_VEN, GIGABYTE_RX9060XT_GAMING_16G_SUB_DEV,                     0x75);
-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);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9060 XT GAMING",                      DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        AMD_GPU_VEN, AMD_NAVI44_DEV,        GIGABYTE_SUB_VEN, GIGABYTE_RX9060XT_GAMING_16G_SUB_DEV,             0x75);
+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/GigabyteRGBFusion2BlackwellGPUController/RGBController_GigabyteRGBFusion2BlackwellGPU.cpp

@@ -395,49 +395,6 @@ void RGBController_RGBFusion2BlackwellGPU::SetupZones()
         leds.push_back(top_led);
     }
 
-    else if(gpu_layout == RGB_FUSION2_BLACKWELL_GPU_AORUS_MASTER_5090D_V2_ICE_LAYOUT)
-    {
-        const char * fan_names[] = { "Right Fan", "Left Fan", "Middle Fan" };
-        for(int i = 0; i < 3; i++)
-        {
-            zone fan_zone;
-            fan_zone.name           = fan_names[i];
-            fan_zone.type           = ZONE_TYPE_SINGLE;
-            fan_zone.leds_min       = 1;
-            fan_zone.leds_max       = 1;
-            fan_zone.leds_count     = 1;
-            zones.push_back(fan_zone);
-
-            led new_led;
-            new_led.name = fan_names[i];
-            leds.push_back(new_led);
-        }
-
-        zone backplate;
-        backplate.name          = "Backplate";
-        backplate.type          = ZONE_TYPE_SINGLE;
-        backplate.leds_min      = 1;
-        backplate.leds_max      = 1;
-        backplate.leds_count    = 1;
-        zones.push_back(backplate);
-
-        led bp_led;
-        bp_led.name = "Backplate";
-        leds.push_back(bp_led);
-
-        zone side_logo;
-        side_logo.name          = "Side Logo";
-        side_logo.type          = ZONE_TYPE_SINGLE;
-        side_logo.leds_min      = 1;
-        side_logo.leds_max      = 1;
-        side_logo.leds_count    = 1;
-        zones.push_back(side_logo);
-
-        led sl_led;
-        sl_led.name = "Side Logo";
-        leds.push_back(sl_led);
-    }
-
     SetupColors();
 }
 
@@ -477,10 +434,6 @@ void RGBController_RGBFusion2BlackwellGPU::DeviceUpdateLEDs()
             gpu_zones = 6; // Zones 4 and 5 refer to ui zone 4
             break;
 
-        case RGB_FUSION2_BLACKWELL_GPU_AORUS_MASTER_5090D_V2_ICE_LAYOUT:
-            gpu_zones = 6;
-            break;
-
         default:
             LOG_TRACE("[%s] Invalid GPU layout (%d) when updating LEDs.", name.c_str(), gpu_layout);
             return; // should not happen
@@ -507,8 +460,7 @@ void RGBController_RGBFusion2BlackwellGPU::DeviceUpdateLEDs()
             }
             ui_zone_idx = zone_idx - 1; // Map: HW zone 1->UI zone 0, HW zone 2->UI zone 1, HW zone 3->UI zone 2, HW zone 4->UI zone 3
         }
-        else if(gpu_layout == RGB_FUSION2_BLACKWELL_GPU_AORUS_MASTER_5080_LAYOUT ||
-                gpu_layout == RGB_FUSION2_BLACKWELL_GPU_AORUS_MASTER_5090D_V2_ICE_LAYOUT)
+        else if(gpu_layout == RGB_FUSION2_BLACKWELL_GPU_AORUS_MASTER_5080_LAYOUT)
         {
             if(zone_idx == 5)
             {

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

@@ -54,7 +54,7 @@ DetectedControllers DetectGigabyteRGBFusion2DRAMControllers(std::vector<i2c_smbu
 
     for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
-        IF_DRAM_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
+        IF_DRAM_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
         {
             // Check for RGB Fusion 2 DRAM controller at 0x67
             if(TestForGigabyteRGBFusion2DRAMController(buses[bus], 0x67))

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;
     }
@@ -135,7 +135,6 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 3090 XTREME WATERFORCE",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 3090 XTREME WATERFORCE WB",      DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3090_XTREME_WATERFORCE_WB_SUB_DEV,  0x64);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 GAMING OC",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070_GAMING_OC_12G,                 0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 GAMING OC",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070_GAMING_OC_12G_V2,              0x71);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 GAMING OC",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070_AD103_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070_GAMING_OC_12G_V2,              0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Geforce RTX 4070 Aero OC",                         DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070_AERO_OC_12G_SUB_DEV,           0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 SUPER GAMING OC",                 DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_GAMING_OC_12G,                0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 SUPER Aero OC",                   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_AERO_OC_12G,                  0x71);
@@ -171,14 +170,12 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 7600 GAMING OC 8G",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 7600 GAMING OC 8G",                      DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI33_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX7600_GAMING_OC_8G_SUB_DEV2,          0x55);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 7600 XT GAMING OC 16G",                  DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI33_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX7600XT_GAMING_OC_16G_SUB_DEV,        0x55);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 6700 XT GAMING OC 12G",                  DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI22_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX6700XT_GAMING_OC_12G_SUB_DEV,        0x62);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 6800 XT GAMING OC",                      DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI21_DEV1,           GIGABYTE_SUB_VEN,   GIGABYTE_RX6800XT_GAMING_OC_SUB_DEV,            0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 6900 XT GAMING OC",                      DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI21_DEV1,           GIGABYTE_SUB_VEN,   GIGABYTE_RX6900XT_GAMING_OC_SUB_DEV,            0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 7700 XT GAMING OC",                      DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI32_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX7700XT_GAMING_OC_SUB_DEV,            0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 7800 XT GAMING OC",                      DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI32_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX7800XT_GAMING_OC_16G_SUB_DEV,        0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 7900 GRE GAMING OC",                     DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI31_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX7900GRE_GAMING_OC_16G_SUB_DEV,       0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 7900 XT GAMING OC",                      DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI31_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX7900XT_GAMING_OC_20G_SUB_DEV,        0x62);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 7900 XTX GAMING OC",                     DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI31_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX7900XTX_GAMING_OC_24G_SUB_DEV,       0x62);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS Radeon RX 7900 XTX ELITE 24G",               DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI31_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RX7900XTX_ELITE_24G_SUB_DEV,     0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RX 6750 XT ELITE 12G",                       DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI22_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RX_6750_XT_ELITE_12G_SUB_DEV,    0x70);
 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);

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

@@ -114,16 +114,16 @@ DetectedControllers DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smb
         LOG_DEBUG(GIGABYTE_FOUND_MB_MESSAGE_EN, DETECTOR_NAME, dmi.getMainboard().c_str());
         for(unsigned int bus = 0; bus < buses.size(); bus++)
         {
-            IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
+            IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
             {
-                if(buses[bus]->info.pci_subsystem_vendor == GIGABYTE_SUB_VEN)
+                if(buses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
                 {
                     /*-------------------------------------*\
                     | TODO - Is this necessary? Or an       |
                     | artifact of my own system?  Skip dmcd |
                     | devices                               |
                     \*-------------------------------------*/
-                    std::string device_name = std::string(buses[bus]->info.device_name);
+                    std::string device_name = std::string(buses[bus]->device_name);
 
                     if(device_name.find("dmdc") == std::string::npos)
                     {

Controllers/GigabyteRGBFusion2USBController/GigabyteFusion2USB_Devices.h

@@ -16,7 +16,7 @@
 #include <map>
 #include "RGBController.h"
 
-#define GB_FUSION2_ZONES_MAX                12
+#define GB_FUSION2_ZONES_MAX                8
 
 /*--------------------------------------------------------*\
 | Base LED mappings found on all controllers.              |
@@ -89,23 +89,6 @@ const FwdLedHeaders LedLookup =
     \*-------------------------------------------------*/
 };
 
-/*--------------------------------------------------------*\
-| The layout_id masks for supported effects.               |
-\*--------------------------------------------------------*/
-enum GB_LID_EFFECTS_MASKS : uint32_t
-{
-    GB_EFF_BREATH       = 0x001,
-    GB_EFF_BEAT         = 0x002,
-    GB_EFF_CYCLE        = 0x004,
-    GB_EFF_FLASH        = 0x008,
-    GB_EFF_RANDOM       = 0x010,
-    GB_EFF_WAVE         = 0x020,
-    GB_EFF_DFLASH       = 0x040,
-    GB_EFF_WAVE1        = 0x080,
-    GB_EFF_WAVE2        = 0x100,
-    GB_EFF_CORE_MASK    = 0x1FF
-};
-
 typedef struct
 {
     GB_FUSION2_LED_IDX  idx;

Controllers/GigabyteRGBFusion2USBController/GigabyteRGBFusion2USBController.cpp

@@ -95,9 +95,10 @@ bool RGBFusion2USBController::RefreshHardwareInfo()
         return false;
     }
 
+    IT8297Report report;
     std::memcpy(&report, buffer, sizeof(IT8297Report));
     report_loaded = true;
-    device_num  = report.device_num;
+
     description = std::string(report.str_product, 28);
     if(std::string::iterator nul = std::find(description.begin(), description.end(), '\0');
        nul != description.end())
@@ -317,7 +318,7 @@ bool RGBFusion2USBController::SetCalibration(const EncodedCalibration& cal, bool
     cal_data.mainboard = desired.c.rgb_cali;
     cal_data.spare[0]  = desired.c.c_spare0;
     cal_data.spare[1]  = desired.c.c_spare1;
-
+    
     if(product_id == 0x5711)
     {
         cal_data.dled[2]  = desired.c.d_strip_c2;
@@ -361,6 +362,7 @@ void RGBFusion2USBController::SetLedCount(unsigned int c0, unsigned int c1, unsi
 \*---------------------------------------------------------*/
 bool RGBFusion2USBController::SetStripBuiltinEffectState(int hdr, bool enable)
 {
+    static bool first_call = true;
     int bitmask = 0;
 
     if(hdr == -1)
@@ -390,16 +392,16 @@ bool RGBFusion2USBController::SetStripBuiltinEffectState(int hdr, bool enable)
         }
     }
 
-        int base_mask = (effect_disabled < 0) ? 0 : effect_disabled;
-        int new_effect_disabled = enable
-            ? (base_mask & ~bitmask)
-            : (base_mask | bitmask);
+    int new_effect_disabled = enable
+        ? (effect_disabled & ~bitmask)
+        : (effect_disabled | bitmask);
 
-        // Skip redundant writes only after we have synchronized at least once
-        if(effect_disabled >= 0 && new_effect_disabled == effect_disabled)
+    if(!first_call && new_effect_disabled == effect_disabled)
     {
         return true;
     }
+
+    first_call = false;
     effect_disabled = new_effect_disabled;
     int res = SendCCReport(0x32, effect_disabled);
     std::this_thread::sleep_for(std::chrono::milliseconds(50));
@@ -437,7 +439,7 @@ bool RGBFusion2USBController::EnableLampArray(bool enable)
 {
     return SendCCReport(0x48, enable ? 1 : 0);
 }
-
+       
 std::string RGBFusion2USBController::GetDeviceName()
 {
     return(name);
@@ -701,115 +703,3 @@ void RGBFusion2USBController::ResetController()
     }
     ApplyEffect(true);
 }
-
-/*---------------------------------------------------------*\
-| Check controller for gen2 ARGB support                    |
-|   Checks for supported device number                      |
-|   Then checks for supported controllers                   |
-|   Then checks for supported feature bit (SaveLEDState)    |
-|   Finally checks for strip detection value.               |
-\*---------------------------------------------------------*/
-bool RGBFusion2USBController::SupportsGen2() const
-{
-    bool supports_gen2 = false;
-
-    supports_gen2 =  (device_num == 0x00)
-                  && (product_id == 0x5702 || product_id==0x5711 || product_id==0x8950)
-                  && (report.support_cmd_flag & 0x01)
-                  && (report.strip_detect == 0x01);
-
-    return supports_gen2;
-}
-
-std::vector<Gen2StripInfo> RGBFusion2USBController::ExportGen2Strips() const
-{
-    size_t count = (product_id == 0x5711) ? 4u : 2u;
-    std::vector<Gen2StripInfo> out;
-    out.reserve(count);
-    for(size_t i = 0; i < count; ++i)
-    {
-        out.push_back(g2_strip_info[i]);
-    }
-    return out;
-}
-
-/*---------------------------------------------------------*\
-| Scan Headers for Gen2 Devices                             |
-\*---------------------------------------------------------*/
-bool RGBFusion2USBController::ScanGen2Strips()
-{
-    for(unsigned i = 0; i < 4; ++i)
-    {
-        if(g2_strip_info[i].LedsOfStrip.capacity() < 15)
-        {
-            g2_strip_info[i].LedsOfStrip.reserve(15);
-        }
-        g2_strip_info[i].numStrip  = 0;
-        g2_strip_info[i].totalLeds = 0;
-        g2_strip_info[i].LedsOfStrip.resize(0);
-    }
-
-    const unsigned int hdr_lim = (product_id == 0x5711) ? 4u : 2u;
-
-    for(unsigned int slot = 0; slot < hdr_lim; ++slot)
-    {
-        static constexpr uint8_t delta[4] = {4, 5, 0, 1};
-        uint8_t scan_cmd = static_cast<uint8_t>(GEN2_LED_BASE_SCAN + delta[slot]);
-        uint8_t info_cmd = static_cast<uint8_t>(scan_cmd + 2);
-
-        if(!SendCCReport(scan_cmd, 0x00, 0x00))
-        {
-            return false;
-        }
-        std::this_thread::sleep_for(std::chrono::milliseconds(700));
-
-        if(!SendCCReport(info_cmd, 0x00, 0x00))
-        {
-            return false;
-        }
-
-        unsigned char feature_buf[64] = {0};
-        feature_buf[0] = report_id;
-        int recv_len = hid_get_feature_report(dev, feature_buf, sizeof(feature_buf));
-        if(recv_len < 64)
-        {
-            return false;
-        }
-
-        int seg_count = static_cast<int>(feature_buf[1]);
-        if(seg_count < 0)
-        {
-            seg_count = 0;
-        }
-        if(seg_count > 15)
-        {
-            seg_count = 15;
-        }
-        Gen2StripInfo& dst = g2_strip_info[slot];
-        dst.numStrip = static_cast<uint8_t>(seg_count);
-        dst.LedsOfStrip.resize(static_cast<size_t>(seg_count));
-
-        uint32_t total_leds = 0;
-        const int counts_base = 2;
-
-        for(int k = 0; k < seg_count; ++k)
-        {
-            const int off = counts_base + (k * 2);
-            uint16_t lo   = static_cast<uint16_t>(feature_buf[off + 0]);
-            uint16_t hi   = static_cast<uint16_t>(feature_buf[off + 1]);
-            uint16_t cnt  = static_cast<uint16_t>(lo | (hi << 8));
-
-            dst.LedsOfStrip[static_cast<size_t>(k)] = cnt;
-            total_leds += cnt;
-        }
-
-        dst.totalLeds = total_leds;
-
-        SetLedCount(0, 0, 0, 0);
-        std::this_thread::sleep_for(std::chrono::milliseconds(20));
-        SaveLEDState(false);
-        std::this_thread::sleep_for(std::chrono::milliseconds(20));
-    }
-
-    return true;
-}

Controllers/GigabyteRGBFusion2USBController/GigabyteRGBFusion2USBController.h

@@ -21,11 +21,6 @@
 
 #define FUSION2_USB_BUFFER_SIZE   64
 
-/*--------------------------------------------------------*\
-| Gen2 scan/info opcode base                               |
-\*--------------------------------------------------------*/
-#define GEN2_LED_BASE_SCAN      0x38
-
 /*---------------------------------------------------------*\
 | Effects mode list                                         |
 \*---------------------------------------------------------*/
@@ -88,16 +83,6 @@ struct EncodedCalibration
     std::string mainboard;
 };
 
-/*---------------------------------------------------------*\
-| High level struct to contain Gen2 Header Data             |
-\*---------------------------------------------------------*/
-struct Gen2StripInfo
-{
-    uint8_t                 numStrip   = 0;
-    std::vector<uint16_t>   LedsOfStrip;
-    uint32_t                totalLeds  = 0;
-};
-
 #pragma pack(push, 1)
 
 /*---------------------------------------------------------*\
@@ -336,8 +321,6 @@ public:
     void                    SetLEDEffect(int led, int mode, unsigned int speed, unsigned char brightness, bool random, uint32_t* color);
     bool                    SetStripBuiltinEffectState(int hdr, bool enable);
     void                    SetStripColors(unsigned int hdr, RGBColor * colors, unsigned int num_colors, int single_led = -1);
-    bool                    SupportsGen2() const;
-    bool                    ScanGen2Strips();
 
     EncodedCalibration      GetCalibration(bool refresh_from_hw = false);
     std::string             GetDeviceName();
@@ -347,8 +330,6 @@ public:
     std::string             GetFWVersion();
     uint16_t                GetProductID();
     std::string             GetSerial();
-    std::vector<Gen2StripInfo> ExportGen2Strips() const;
-    Gen2StripInfo           g2_strip_info[4];
 
 private:
     std::string             DecodeCalibrationBuffer(uint32_t value) const;
@@ -364,7 +345,7 @@ private:
     int                     SendPacket(unsigned char* packet);
 
     hid_device*             dev;
-    uint8_t                 device_num;
+    int                     device_num;
     uint16_t                product_id;
     uint32_t                effect_zone_mask    = 0;
     int                     mode;
@@ -375,7 +356,7 @@ private:
     std::string             location;
     std::string             version;
     std::string             chip_id;
-    int                     effect_disabled     = -1;
+    int                     effect_disabled     = 0;
     int                     report_id           = 0xCC;
     bool                    report_loaded       = false;
     bool                    cali_loaded         = false;

Controllers/GigabyteRGBFusion2USBController/RGBController_GigabyteRGBFusion2USB.cpp

@@ -25,7 +25,7 @@
     @effects :white_check_mark:
     @detectors DetectGigabyteRGBFusion2USBControllers
     @comment The Fusion 2 USB controller applies to most AMD and
-        Intel mainboards from the X570 and z390 chipsets onwards.
+        Intel mainboards from the x570 and z390 chipsets onwards.
 \*-------------------------------------------------------------------*/
 
 RGBController_RGBFusion2USB::RGBController_RGBFusion2USB(RGBFusion2USBController* controller_ptr, std::string detector)
@@ -39,10 +39,8 @@ RGBController_RGBFusion2USB::RGBController_RGBFusion2USB(RGBFusion2USBController
     version                     = controller->GetFWVersion();
     location                    = controller->GetDeviceLocation();
     serial                      = controller->GetSerial();
-    product_id                  = controller->GetProductID();
     device_num                  = controller->GetDeviceNum();
 
-
     mode Direct;
     Direct.name                 = "Direct";
     Direct.value                = 0xFFFF;
@@ -208,13 +206,6 @@ RGBController_RGBFusion2USB::RGBController_RGBFusion2USB(RGBFusion2USBController
 
 RGBController_RGBFusion2USB::~RGBController_RGBFusion2USB()
 {
-    // Free any zones we allocated for the per-instance layout
-    for(gb_fusion2_zone* z : allocated_zones)
-    {
-        delete z;
-    }
-    allocated_zones.clear();
-
     Shutdown();
 
     delete controller;
@@ -225,125 +216,94 @@ RGBController_RGBFusion2USB::~RGBController_RGBFusion2USB()
 \*---------------------------------------------------------*/
 void RGBController_RGBFusion2USB::Init_Controller()
 {
-
-    const gb_fusion2_device* src_layout  = gb_fusion2_device_list[device_index];
-    const std::string SectionGen2        = "Gigabyte-Gen2-ARGB";
-    const std::string SectionCustomBase  = "CustomLayout";
-    const std::string SectionCustom      = SectionCustomBase + std::to_string(device_num);
+    const std::string SectionCustom      = "CustomLayout";
     const std::string SectionCalibration = "Calibration";
     RvrseLedHeaders ReverseLedLookup     = reverse_map(LedLookup);
     SettingsManager* settings_manager    = ResourceManager::get()->GetSettingsManager();
     nlohmann::json device_settings       = settings_manager->GetSettings(detector_name);
 
     /*---------------------------------------------------------*\
-    | Checks for Gen2 support and adds flag to json.            |
+    | Create the custom layout from the generic_device          |
     \*---------------------------------------------------------*/
-    if(controller->SupportsGen2())
-    {
-        if(!device_settings.contains(SectionGen2))
-        {
-            device_settings[SectionGen2]["Enabled"]   = false;
-            settings_manager->SetSettings(detector_name, device_settings);
-            settings_manager->SaveSettings();
-        }
-
-        supports_gen2 = device_settings[SectionGen2]["Enabled"];
-
-        if(supports_gen2)
-        {
-            controller->ScanGen2Strips();
-        }
-    }
-
-    /*---------------------------------------------------------*\
-    | Create the custom layout from the generic layout          |
-    \*---------------------------------------------------------*/
-    switch(product_id)
-    {
-        case 0x8950:
-                src_layout = gb_fusion2_device_list[device_index + 1];
-            break;
-        case 0x5711:
-                src_layout = gb_fusion2_device_list[device_index + 2];
-            break;
-        default:
-            break;
-    }
+    gb_fusion2_device* layout = const_cast<gb_fusion2_device*>(gb_fusion2_device_list[device_index]);
 
     if(!device_settings.contains(SectionCustom))
     {
         device_settings[SectionCustom]["Enabled"]   = false;
-        device_settings[SectionCustom]["Data"]      = BuildCustomLayoutJson(src_layout, ReverseLedLookup);
+        device_settings[SectionCustom]["Data"]      = BuildCustomLayoutJson(layout, ReverseLedLookup);
         settings_manager->SetSettings(detector_name, device_settings);
         settings_manager->SaveSettings();
     }
 
     bool custom_layout = device_settings[SectionCustom]["Enabled"];
 
+    if(custom_layout)
+    {
+        LoadCustomLayoutFromJson(device_settings[SectionCustom]["Data"], LedLookup, layout);
+    }
+
     EncodedCalibration hw_cal = controller->GetCalibration(false);
 
-    if(device_num == 0)
+    if(!device_settings.contains(SectionCalibration))
     {
-        if(!device_settings.contains(SectionCalibration))
+        device_settings[SectionCalibration]["Enabled"] = false;
+        device_settings[SectionCalibration]["Data"]    = WriteCalJsonFrom(hw_cal);
+        settings_manager->SetSettings(detector_name, device_settings);
+        settings_manager->SaveSettings();
+    }
+    else
+    {
+        nlohmann::json& cal_sec = device_settings[SectionCalibration];
+        bool cal_enable         = cal_sec.value("Enabled", false);
+
+        if(!cal_sec.contains("Data") || !cal_sec["Data"].is_object())
         {
-            device_settings[SectionCalibration]["Enabled"] = false;
-            device_settings[SectionCalibration]["Data"]    = WriteCalJsonFrom(hw_cal);
+            cal_sec["Data"] = WriteCalJsonFrom(hw_cal);
             settings_manager->SetSettings(detector_name, device_settings);
             settings_manager->SaveSettings();
         }
         else
         {
-            nlohmann::json& cal_sec = device_settings[SectionCalibration];
-            bool cal_enable         = cal_sec.value("Enabled", false);
+            nlohmann::json& cdata = cal_sec["Data"];
+            FillMissingWith(cdata, hw_cal);
 
-            if(!cal_sec.contains("Data") || !cal_sec["Data"].is_object())
+            if(!cal_enable)
             {
                 cal_sec["Data"] = WriteCalJsonFrom(hw_cal);
                 settings_manager->SetSettings(detector_name, device_settings);
                 settings_manager->SaveSettings();
             }
+        }
+
+        if(cal_enable)
+        {
+            const nlohmann::json& cdata = cal_sec["Data"];
+
+            EncodedCalibration desired;
+            desired.dled[0]   = GET_JSON_VAL_ELSE_OFF(cdata, "HDR_D_LED1");
+            desired.dled[1]   = GET_JSON_VAL_ELSE_OFF(cdata, "HDR_D_LED2");
+            desired.mainboard = GET_JSON_VAL_ELSE_OFF(cdata, "Mainboard");
+            desired.spare[0]  = GET_JSON_VAL_ELSE_OFF(cdata, "Spare0");
+            desired.spare[1]  = GET_JSON_VAL_ELSE_OFF(cdata, "Spare1");
+
+            if(controller->GetProductID() == 0x5711)
+            {
+                desired.dled[2]  = GET_JSON_VAL_ELSE_OFF(cdata, "HDR_D_LED3");
+                desired.dled[3]  = GET_JSON_VAL_ELSE_OFF(cdata, "HDR_D_LED4");
+                desired.spare[2] = GET_JSON_VAL_ELSE_OFF(cdata, "Spare2");
+                desired.spare[3] = GET_JSON_VAL_ELSE_OFF(cdata, "Spare3");
+            }
             else
             {
-                nlohmann::json& cdata = cal_sec["Data"];
-                FillMissingWith(cdata, hw_cal);
-
-                if(!cal_enable)
-                {
-                    cal_sec["Data"] = WriteCalJsonFrom(hw_cal);
-                    settings_manager->SetSettings(detector_name, device_settings);
-                    settings_manager->SaveSettings();
-                }
-            }
-
-            if(cal_enable)
-            {
-                const nlohmann::json& cdata = cal_sec["Data"];
-
-                EncodedCalibration desired;
-                desired.dled[0]   = GET_JSON_VAL_ELSE_OFF(cdata, "HDR_D_LED1");
-                desired.dled[1]   = GET_JSON_VAL_ELSE_OFF(cdata, "HDR_D_LED2");
-                desired.mainboard = GET_JSON_VAL_ELSE_OFF(cdata, "Mainboard");
-                desired.spare[0]  = GET_JSON_VAL_ELSE_OFF(cdata, "Spare0");
-                desired.spare[1]  = GET_JSON_VAL_ELSE_OFF(cdata, "Spare1");
-
-                if(controller->GetProductID() == 0x5711)
-                {
-                    desired.dled[2]  = GET_JSON_VAL_ELSE_OFF(cdata, "HDR_D_LED3");
-                    desired.dled[3]  = GET_JSON_VAL_ELSE_OFF(cdata, "HDR_D_LED4");
-                    desired.spare[2] = GET_JSON_VAL_ELSE_OFF(cdata, "Spare2");
-                    desired.spare[3] = GET_JSON_VAL_ELSE_OFF(cdata, "Spare3");
-                }
-                else
-                {
-                    desired.dled[2]  = "OFF";
-                    desired.dled[3]  = "OFF";
-                    desired.spare[2] = "OFF";
-                    desired.spare[3] = "OFF";
-                }
-                    controller->SetCalibration(desired, false);
+                desired.dled[2]  = "OFF";
+                desired.dled[3]  = "OFF";
+                desired.spare[2] = "OFF";
+                desired.spare[3] = "OFF";
             }
+                controller->SetCalibration(desired, false);
         }
     }
+
     /*---------------------------------------------------------------------*\
     |  When no match found the first entry (generic_device) will be used    |
     |    otherwise look up channel map based on device name                 |
@@ -357,63 +317,17 @@ void RGBController_RGBFusion2USB::Init_Controller()
         \*-----------------------------------------------------------------*/
         for(unsigned int i = 0; i < GB_FUSION2_DEVICE_COUNT; i++)
         {
-            if(gb_fusion2_device_list[i]->name == name &&
-                gb_fusion2_device_list[i]->device_num == device_num)
+            if(gb_fusion2_device_list[i]->name == name)
             {
                 /*---------------------------------------------------------*\
                 | Set device ID                                             |
                 \*---------------------------------------------------------*/
                 device_index = i;
-                src_layout = gb_fusion2_device_list[i];
+                layout = const_cast<gb_fusion2_device*>(gb_fusion2_device_list[i]);
                 break;
             }
         }
     }
-    /*---------------------------------------------------------------------*\
-    |  Creates per instance copy of layouts.                                |
-    \*---------------------------------------------------------------------*/
-    instance_layout.zones      = &instance_zones;
-    instance_layout.layout_id  = src_layout->layout_id;
-    instance_layout.device_num = src_layout->device_num;
-    instance_layout.name       = src_layout->name;
-
-    for(uint8_t zi = 0; zi < GB_FUSION2_ZONES_MAX; ++zi)
-    {
-        (*instance_layout.zones)[zi] = (*src_layout->zones)[zi];
-    }
-
-    if(custom_layout)
-    {
-        LoadCustomLayoutFromJson(device_settings[SectionCustom]["Data"], LedLookup, &instance_layout);
-    }
-    /*---------------------------------------------------------------------*\
-    | Culls the mode support based on layout_id.                            |
-    \*---------------------------------------------------------------------*/
-    const uint32_t effect_mask = instance_layout.layout_id & GB_EFF_CORE_MASK;
-    modes.erase(std::remove_if(modes.begin(), modes.end(),
-        [effect_mask](const mode& m)
-        {
-            if(m.value == 0xFFFF /* Direct */) { return false; }
-            if(m.value == EFFECT_STATIC)        { return false; }
-
-            uint32_t bit = 0u;
-            switch(m.value)
-            {
-                    case EFFECT_PULSE:       bit = GB_EFF_BREATH; break;
-                    case EFFECT_COLORCYCLE:  bit = GB_EFF_CYCLE;  break;
-                    case EFFECT_BLINKING:    bit = GB_EFF_FLASH;  break;
-                    case EFFECT_RANDOM:      bit = GB_EFF_RANDOM; break;
-                    case EFFECT_WAVE:        bit = GB_EFF_WAVE;   break;
-                    case EFFECT_DFLASH:      bit = GB_EFF_DFLASH; break;
-                    case EFFECT_WAVE1:       bit = GB_EFF_WAVE1;  break;
-                    case EFFECT_WAVE2:       bit = GB_EFF_WAVE2;  break;
-                    case EFFECT_WAVE3:       bit = GB_EFF_WAVE1;  break;
-                    case EFFECT_WAVE4:       bit = GB_EFF_WAVE2;  break;
-                default:                 bit = 0u; break;
-            }
-            return (bit == 0u) || ((effect_mask & bit) == 0u);
-        }),
-        modes.end());
 }
 
 void RGBController_RGBFusion2USB::SetupZones()
@@ -459,7 +373,7 @@ void RGBController_RGBFusion2USB::SetupZones()
         /*-------------------------------------------------*\
         | Get zone configuration from device data           |
         \*-------------------------------------------------*/
-        const gb_fusion2_zone* zone_at_idx = (*instance_layout.zones)[zone_idx];
+        const gb_fusion2_zone* zone_at_idx = gb_fusion2_device_list[device_index]->zones[0][zone_idx];
 
         if(!zone_at_idx)
         {
@@ -972,7 +886,6 @@ void RGBController_RGBFusion2USB::LoadCustomLayoutFromJson(
            && new_zone->idx <= GB_FUSION2_LED_IDX::LED11)
         {
             layout->zones[0][zone_idx]  = new_zone;
-            allocated_zones.push_back(new_zone);
         }
         else
         {

Controllers/GigabyteRGBFusion2USBController/RGBController_GigabyteRGBFusion2USB.h

@@ -62,26 +62,17 @@ private:
     std::string                 detector_name;
 
     RGBFusion2USBController*    controller;
-    uint8_t                     device_num;
+    int                         device_num;
     RGBColor                    null_color      = 0;
-    bool                        supports_gen2   = 0;
     /*---------------------------------------------------------*\
     | The intial value of device_index should point to the      |
     |   layout for the generic_device                           |
     \*---------------------------------------------------------*/
     uint32_t                    device_index    = 0;
-    uint16_t                    product_id      = 0;
-    uint32_t                    effects_mask    = 0;
+
     void                        Init_Controller();
     int                         GetLED_Zone(int led_idx);
 
-    /*---------------------------------------------------------*\
-    | Per instance layout lookup tables.                        |
-    \*---------------------------------------------------------*/
-    gb_fusion2_device           instance_layout{};
-    gb_fusion2_layout           instance_zones{};
-    std::vector<gb_fusion2_zone*> allocated_zones;
-
     nlohmann::json              WriteCalJsonFrom(
                                     const EncodedCalibration& src);
     void                        FillMissingWith(

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

@@ -49,9 +49,9 @@ DetectedControllers DetectGigabyteRGBFusionControllers(std::vector<i2c_smbus_int
 
     for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
-        IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
+        IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
         {
-            if(buses[bus]->info.pci_subsystem_vendor == GIGABYTE_SUB_VEN)
+            if(buses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
             {
                 LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
 

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/GoveeController/RGBController_Govee.cpp

@@ -16,21 +16,10 @@
 
 using namespace std::chrono_literals;
 
-struct GoveeHardwareInfo
+static std::map<std::string, unsigned int> govee_led_counts
 {
-    unsigned int led_count;
-    unsigned int matrix_row_len;    // 0 = linear
-};
-
-const unsigned int GOVEE_FALLBACK_LED_COUNT = 20;
-
-static std::map<std::string, GoveeHardwareInfo> govee_hardware_info
-{
-    { "H6022",   { 132, 12 } },    // Govee Smart Table Lamp 2
-    { "H612F",   { 12,  0 } },     // Govee Strip Light S (3m)
-    { "H619A",   { 20,  0 } },     // Govee RGBIC Led Strip Lights
-    { "H70B1",   { 20,  0 } },     // Govee LED Curtain Lights
-    { "H607C",   { 174, 0 } },     // Govee Floor Lamp 2
+    { "H619A", 20  },
+    { "H70B1", 20  },
 };
 
 RGBController_Govee::RGBController_Govee(GoveeController* controller_ptr)
@@ -80,61 +69,37 @@ RGBController_Govee::~RGBController_Govee()
 
 void RGBController_Govee::SetupZones()
 {
-    GoveeHardwareInfo hw = { GOVEE_FALLBACK_LED_COUNT, 0 };
-    bool resizable = true;
-
-    std::map<std::string, GoveeHardwareInfo>::iterator it = govee_hardware_info.find(controller->GetSku());
-    if(it != govee_hardware_info.end())
+    unsigned int led_count = 0;
+    std::map<std::string, unsigned int>::iterator it = govee_led_counts.find(controller->GetSku());
+    if(it != govee_led_counts.end())
     {
-        hw = it->second;
-        resizable = false;
+        led_count = it->second;
+    }
+    /*-----------------------------------------------------*\
+    | Fallback so Direct mode is usable even if SKU isn't  |
+    | in the table                                         |
+    \*-----------------------------------------------------*/
+    if(led_count == 0)
+    {
+        led_count = 20; /* safe default; user can resize in UI */
     }
 
     zone strip;
-    strip.leds_count            = hw.led_count;
-    strip.leds_min              = resizable ? 0   : hw.led_count;
-    strip.leds_max              = resizable ? 255 : hw.led_count;
-
-    if(hw.matrix_row_len == 0)
+    strip.name          = "Govee Strip";
+    strip.type          = ZONE_TYPE_LINEAR;
+    strip.leds_count    = led_count;
+    /*-----------------------------------------------------*\
+    | Only make resizable for unknown SKUs                 |
+    \*-----------------------------------------------------*/
+    if(govee_led_counts.find(controller->GetSku()) == govee_led_counts.end())
     {
-        strip.name              = "Govee Strip";
-        strip.type              = ZONE_TYPE_LINEAR;
+        strip.leds_min      = 1;
+        strip.leds_max      = 255;
     }
     else
     {
-        strip.name              = "Govee Matrix";
-        strip.type              = ZONE_TYPE_MATRIX;
-
-        unsigned int width      = hw.matrix_row_len;
-        unsigned int height     = hw.led_count / width;
-
-        strip.matrix_map.height = height;
-        strip.matrix_map.width  = width;
-        strip.matrix_map.map.resize(hw.led_count);
-
-        /*-------------------------------------------------*\
-        | On H6022, LEDs indexed bottom to top, alternating |
-        | clockwise and counterclockwise for each row.      |
-        \*-------------------------------------------------*/
-        for(unsigned int y = 0; y < height; y++)
-        {
-            /*---------------------------------------------*\
-            | LEDs numbered bottom to top, opposite of      |
-            | matrix clockwise and counterclockwise for     |
-            | each row.                                     |
-            \*---------------------------------------------*/
-            unsigned int led_y = (height - 1) - y;
-
-            for(unsigned int x = 0; x < width; x++)
-            {
-                /*-----------------------------------------*\
-                | LED is right-to-left for even rows,       |
-                | including first one                       |
-                \*-----------------------------------------*/
-                unsigned int led_x = led_y & 1 ? x : (width - 1) - x;
-                strip.matrix_map.map[y * width + x] = led_y * width + led_x;
-            }
-        }
+        strip.leds_min      = led_count;
+        strip.leds_max      = led_count;
     }
     zones.push_back(strip);
 
@@ -150,11 +115,6 @@ void RGBController_Govee::SetupZones()
 
 void RGBController_Govee::DeviceConfigureZone(int zone_idx)
 {
-    if(zones[zone_idx].type == ZONE_TYPE_MATRIX)
-    {
-        return;
-    }
-
     if((size_t)zone_idx < zones.size())
     {
         leds.clear();

Controllers/HYTEMousematController/HYTEMousematController_Windows_MacOS/HYTEMousematControllerDetect_Windows_MacOS.cpp

@@ -42,13 +42,13 @@ DetectedControllers DetectHYTEMousematControllers()
 
     for(unsigned int device_id = 0; device_id < HYTE_MOUSEMAT_NUM_DEVICES; device_id++)
     {
-        std::vector<std::string> ports = find_usb_serial_port(hyte_mousemat_devices[device_id].vid, hyte_mousemat_devices[device_id].pid);
+        std::vector<std::string *> ports = find_usb_serial_port(hyte_mousemat_devices[device_id].vid, hyte_mousemat_devices[device_id].pid);
 
         for(unsigned int i = 0; i < ports.size(); i++)
         {
-            if(ports[i] != "")
+            if(*ports[i] != "")
             {
-                HYTEMousematController *     controller     = new HYTEMousematController((char *)ports[i].c_str(), hyte_mousemat_devices[device_id].name);
+                HYTEMousematController *     controller     = new HYTEMousematController((char *)ports[i]->c_str(), hyte_mousemat_devices[device_id].name);
                 RGBController_HYTEMousemat * rgb_controller = new RGBController_HYTEMousemat(controller);
 
                 detected_controllers.push_back(rgb_controller);

Controllers/HYTENexusController/HYTENexusControllerDetect.cpp

@@ -38,13 +38,13 @@ DetectedControllers DetectHYTENexusControllers()
 
     for(unsigned int device_id = 0; device_id < HYTE_NEXUS_NUM_DEVICES; device_id++)
     {
-        std::vector<std::string> ports = find_usb_serial_port(hyte_nexus_devices[device_id].vid, hyte_nexus_devices[device_id].pid);
+        std::vector<std::string *> ports = find_usb_serial_port(hyte_nexus_devices[device_id].vid, hyte_nexus_devices[device_id].pid);
 
         for(unsigned int i = 0; i < ports.size(); i++)
         {
-            if(ports[i] != "")
+            if(*ports[i] != "")
             {
-                HYTENexusController *     controller     = new HYTENexusController((char *)ports[i].c_str(), hyte_nexus_devices[device_id].pid, hyte_nexus_devices[device_id].name);
+                HYTENexusController *     controller     = new HYTENexusController((char *)ports[i]->c_str(), hyte_nexus_devices[device_id].pid, hyte_nexus_devices[device_id].name);
                 RGBController_HYTENexus * rgb_controller = new RGBController_HYTENexus(controller);
 
                 detected_controllers.push_back(rgb_controller);