Implement size verification on RGBController set description functions

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

.gitlab/CODEOWNERS

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

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.cpp

@@ -173,6 +173,8 @@ RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *cont
 
 RGBController_BloodyB820R::~RGBController_BloodyB820R()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.cpp

@@ -89,6 +89,8 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont
 
 RGBController_BloodyMouse::~RGBController_BloodyMouse()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AMBXController/RGBController_AMBX.cpp

@@ -44,6 +44,8 @@ RGBController_AMBX::RGBController_AMBX(AMBXController* controller_ptr)
 
 RGBController_AMBX::~RGBController_AMBX()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -132,6 +132,8 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
 
 RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp

@@ -257,6 +257,8 @@ RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* cont
 
 RGBController_AOCKeyboard::~RGBController_AOCKeyboard()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AOCMouseController/RGBController_AOCMouse.cpp

@@ -123,6 +123,8 @@ RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_pt
 
 RGBController_AOCMouse::~RGBController_AOCMouse()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AOCMousematController/RGBController_AOCMousemat.cpp

@@ -113,6 +113,8 @@ RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* cont
 
 RGBController_AOCMousemat::~RGBController_AOCMousemat()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -191,7 +191,7 @@ void PolychromeUSBController::SetDeviceInfo()
     WriteRGSwap(rgswap_final[0], rgswap_final[1], rgswap_final[2], rgswap_final[3], rgswap_final[4], rgswap_final[5], rgswap_final[6], rgswap_final[7]);
 }
 
-void PolychromeUSBController::DeviceResizeZone(int zone, int new_size)
+void PolychromeUSBController::SetZoneSize(int zone, int new_size)
 {
     unsigned char zonecfg[POLYCHROME_USB_ZONE_MAX_NUM];
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

@@ -135,7 +135,7 @@ public:
                                                     unsigned int    configsize
                                                     );
 
-    void                                        DeviceResizeZone(int zone, int new_size);
+    void                                        SetZoneSize(int zone, int new_size);
     void                                        SetRGSwap(bool reset);
 
 protected:

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -185,8 +185,25 @@ RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController
     SetupZones();
 }
 
+RGBController_PolychromeUSB::~RGBController_PolychromeUSB()
+{
+    Shutdown();
+
+    delete controller;
+}
+
 void RGBController_PolychromeUSB::SetupZones()
 {
+    /*-----------------------------------------------------*\
+    | Only set LED count on the first run                   |
+    \*-----------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
+    {
+        first_run = true;
+    }
+
     /*-------------------------------------------------*\
     | Clear any existing color/LED configuration        |
     \*-------------------------------------------------*/
@@ -197,28 +214,55 @@ void RGBController_PolychromeUSB::SetupZones()
     /*-------------------------------------------------*\
     | Set zones and leds                                |
     \*-------------------------------------------------*/
-    for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    for(std::size_t channel_idx = 0; channel_idx < zones.size(); channel_idx++)
     {
         PolychromeDeviceInfo device_info = controller->GetPolychromeDevices()[channel_idx];
 
-        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
-
         if(device_info.device_type== PolychromeDeviceType::ADDRESSABLE)
         {
-            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
-            zones[channel_idx].leds_min   = 0;
-            zones[channel_idx].leds_max   = ASROCK_ADDRESSABLE_MAX_LEDS;
-            zones[channel_idx].leds_count = device_info.num_leds;
+            zones[channel_idx].leds_min                 = 0;
+            zones[channel_idx].leds_max                 = ASROCK_ADDRESSABLE_MAX_LEDS;
+
+            if(first_run)
+            {
+                zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
+            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
+            {
+                zones[channel_idx].name                 = polychrome_USB_zone_names[device_info.zone_type];
+            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
+            {
+                zones[channel_idx].leds_count           = device_info.num_leds;
+            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
+            {
+                zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
+            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
+            {
+                zones[channel_idx].matrix_map.width     = 0;
+                zones[channel_idx].matrix_map.height    = 0;
+                zones[channel_idx].matrix_map.map.resize(0);
+            }
         }
         else if(device_info.device_type==PolychromeDeviceType::FIXED)
         {
-            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
-            zones[channel_idx].leds_min   = device_info.num_leds;
-            zones[channel_idx].leds_max   = device_info.num_leds;
-            zones[channel_idx].leds_count = device_info.num_leds;
+            zones[channel_idx].name                     = polychrome_USB_zone_names[device_info.zone_type];
+            zones[channel_idx].type                     = ZONE_TYPE_LINEAR;
+            zones[channel_idx].leds_min                 = device_info.num_leds;
+            zones[channel_idx].leds_max                 = device_info.num_leds;
+            zones[channel_idx].leds_count               = device_info.num_leds;
         }
 
-
         for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
         {
             led new_led;
@@ -271,10 +315,14 @@ void RGBController_PolychromeUSB::SetupZones()
      }
 }
 
-void RGBController_PolychromeUSB::DeviceResizeZone(int zone, int new_size)
+void RGBController_PolychromeUSB::DeviceConfigureZone(int zone_idx)
 {
-    zones[zone].leds_count = (unsigned char) new_size;
-    controller->DeviceResizeZone(zones_info[zone].zone, new_size);
+    if((size_t)zone_idx < zones.size())
+    {
+        controller->SetZoneSize(zones_info[zone_idx].zone, zones[zone_idx].leds_count);
+
+        SetupZones();
+    }
 }
 
 void RGBController_PolychromeUSB::DeviceUpdateLEDs()

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -19,10 +19,11 @@ class RGBController_PolychromeUSB : public RGBController
 {
 public:
     RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr);
+    ~RGBController_PolychromeUSB();
 
     void        SetupZones();
 
-    void        DeviceResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.cpp

@@ -113,6 +113,8 @@ RGBController_ASRockASRRGBSMBus::RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMB
 
 RGBController_ASRockASRRGBSMBus::~RGBController_ASRockASRRGBSMBus()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -159,13 +161,6 @@ void RGBController_ASRockASRRGBSMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockASRRGBSMBus::DeviceResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_ASRockASRRGBSMBus::DeviceUpdateLEDs()
 {
     for(unsigned int led = 0; led < colors.size(); led++)

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.h

@@ -22,8 +22,6 @@ public:
 
     void        SetupZones();
 
-    void        DeviceResizeZone(int zone, int new_size);
-
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);
     void        DeviceUpdateSingleLED(int led);

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.cpp

@@ -230,6 +230,8 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
 
 RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -296,10 +298,9 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV1SMBus::DeviceResizeZone(int zone, int new_size)
+void RGBController_ASRockPolychromeV1SMBus::DeviceConfigureZone(int zone_idx)
 {
-    LOG_TRACE("[%s] DeviceResizeZone(%02X, %02X)", name.c_str(), zone, new_size);
-    controller-> SetARGBSize(new_size & 0xFF);
+    controller-> SetARGBSize(zones[zone_idx].leds_count & 0xFF);
     zones[POLYCHROME_V1_ZONE_ADDRESSABLE].leds_count = 1;
 }
 

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.h

@@ -23,7 +23,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

@@ -185,6 +185,8 @@ RGBController_ASRockPolychromeV2SMBus::RGBController_ASRockPolychromeV2SMBus(ASR
 
 RGBController_ASRockPolychromeV2SMBus::~RGBController_ASRockPolychromeV2SMBus()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -279,7 +281,7 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV2SMBus::DeviceResizeZone(int /*zone*/, int /*new_size*/)
+void RGBController_ASRockPolychromeV2SMBus::DeviceConfigureZone(int /*zone_idx*/)
 {
     /*---------------------------------------------------------*\
     | This device does not support resizing zones               |

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.h

@@ -23,7 +23,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);

Controllers/ASRockSMBusController/ASRockSMBusControllerDetect.cpp

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

Controllers/AlienwareController/RGBController_Alienware.cpp

@@ -125,6 +125,13 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     controller->UpdateDim();
 }
 
+RGBController_Alienware::~RGBController_Alienware()
+{
+    Shutdown();
+
+    delete controller;
+}
+
 void RGBController_Alienware::SetupZones()
 {
     /*-------------------------------------------------*\

Controllers/AlienwareController/RGBController_Alienware.h

@@ -19,6 +19,7 @@ class RGBController_Alienware : public RGBController
 {
 public:
     RGBController_Alienware(AlienwareController* controller_ptr);
+    ~RGBController_Alienware();
 
     void        SetupZones();
 

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.cpp

@@ -278,6 +278,8 @@ RGBController_AlienwareAW410K::RGBController_AlienwareAW410K(AlienwareAW410KCont
 
 RGBController_AlienwareAW410K::~RGBController_AlienwareAW410K()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.cpp

@@ -277,6 +277,8 @@ RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KCont
 
 RGBController_AlienwareAW510K::~RGBController_AlienwareAW510K()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AlienwareMonitorController/RGBController_AlienwareAW3423DWF.cpp

@@ -46,6 +46,8 @@ RGBController_AlienwareAW3423DWF::RGBController_AlienwareAW3423DWF(AlienwareAW34
 
 RGBController_AlienwareAW3423DWF::~RGBController_AlienwareAW3423DWF()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AlienwareMonitorController/RGBController_AlienwareMonitor.cpp

@@ -46,6 +46,8 @@ RGBController_AlienwareMonitor::RGBController_AlienwareMonitor(AlienwareMonitorC
 
 RGBController_AlienwareMonitor::~RGBController_AlienwareMonitor()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp

@@ -144,6 +144,8 @@ RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_pt
 
 RGBController_AnnePro2::~RGBController_AnnePro2()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/ArcticController/RGBController_Arctic.cpp

@@ -55,6 +55,8 @@ RGBController_Arctic::RGBController_Arctic(ArcticController* controller_ptr)
 
 RGBController_Arctic::~RGBController_Arctic()
 {
+    Shutdown();
+
     keepalive_thread_run = false;
     keepalive_thread.join();
     delete controller;

Controllers/AresonController/RGBController_Areson.cpp

@@ -125,6 +125,8 @@ RGBController_Areson::RGBController_Areson(AresonController* controller_ptr)
 
 RGBController_Areson::~RGBController_Areson()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusAuraCoreController/AsusAuraCoreController/RGBController_AsusAuraCore.cpp

@@ -45,6 +45,13 @@ RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_pt
     SetupZones();
 }
 
+RGBController_AuraCore::~RGBController_AuraCore()
+{
+    Shutdown();
+
+    delete controller;
+}
+
 void RGBController_AuraCore::SetupKeyboard()
 {
     name                    = "ASUS Aura Keyboard";
@@ -170,11 +177,6 @@ void RGBController_AuraCore::SetupGA15DH()
     modes.push_back(Static);
 }
 
-RGBController_AuraCore::~RGBController_AuraCore()
-{
-    delete controller;
-}
-
 void RGBController_AuraCore::SetupZones()
 {
     zone auraZone;

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.cpp

@@ -268,6 +268,8 @@ RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreL
 
 RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp

@@ -124,6 +124,8 @@ RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * controller_ptr)
 
 RGBController_AuraGPU::~RGBController_AuraGPU()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/RGBController_AsusAuraHeadsetStand.cpp

@@ -112,6 +112,8 @@ RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandC
 
 RGBController_AuraHeadsetStand::~RGBController_AuraHeadsetStand()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.cpp

@@ -380,6 +380,8 @@ RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* c
 
 RGBController_AuraKeyboard::~RGBController_AuraKeyboard()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraMonitorController/RGBController_AsusAuraMonitor.cpp

@@ -45,6 +45,8 @@ RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* cont
 
 RGBController_AuraMonitor::~RGBController_AuraMonitor()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.cpp

@@ -185,6 +185,8 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
 
 RGBController_AuraMouse::~RGBController_AuraMouse()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.cpp

@@ -116,6 +116,8 @@ RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Contro
 
 RGBController_AsusROGSpatha::~RGBController_AsusROGSpatha()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGStrixEvolve.cpp

@@ -79,6 +79,8 @@ RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouse
 
 RGBController_AsusROGStrixEvolve::~RGBController_AsusROGStrixEvolve()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.cpp

@@ -182,6 +182,8 @@ RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* c
 
 RGBController_AuraMousemat::~RGBController_AuraMousemat()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.cpp

@@ -128,6 +128,8 @@ RGBController_AsusAuraRyuoAIO::RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOCont
 
 RGBController_AsusAuraRyuoAIO::~RGBController_AsusAuraRyuoAIO()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -410,6 +410,8 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
 
 RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -119,6 +119,8 @@ RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr)
 
 RGBController_AuraUSB::~RGBController_AuraUSB()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -145,41 +147,68 @@ void RGBController_AuraUSB::SetupZones()
     | Set zones and leds                                |
     \*-------------------------------------------------*/
     int addressableCounter = 1;
-    for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+
+    for(std::size_t channel_idx = 0; channel_idx < zones.size(); channel_idx++)
     {
         AuraDeviceInfo device_info  = controller->GetAuraDevices()[channel_idx];
 
-        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
-
         if(device_info.device_type == AuraDeviceType::FIXED)
         {
-            zones[channel_idx].name       = "Aura Mainboard";
-            zones[channel_idx].leds_min   = device_info.num_leds;
-            zones[channel_idx].leds_max   = device_info.num_leds;
-            zones[channel_idx].leds_count = device_info.num_leds;
+            zones[channel_idx].name                     = "Aura Mainboard";
+            zones[channel_idx].type                     = ZONE_TYPE_LINEAR;
+            zones[channel_idx].leds_min                 = device_info.num_leds;
+            zones[channel_idx].leds_max                 = device_info.num_leds;
+            zones[channel_idx].leds_count               = device_info.num_leds;
         }
         else
         {
-            zones[channel_idx].name       = "Aura Addressable ";
-            zones[channel_idx].name.append(std::to_string(addressableCounter));
-            zones[channel_idx].leds_min   = 0;
-            zones[channel_idx].leds_max   = AURA_ADDRESSABLE_MAX_LEDS;
-
-            addressableCounter++;
+            zones[channel_idx].leds_min                 = 0;
+            zones[channel_idx].leds_max                 = AURA_ADDRESSABLE_MAX_LEDS;
 
             if(first_run)
             {
-                zones[channel_idx].leds_count = 0;
+                zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
             }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
+            {
+                zones[channel_idx].name                 = "Addressable RGB Header ";
+                zones[channel_idx].name.append(std::to_string(addressableCounter));
+            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
+            {
+                zones[channel_idx].leds_count           = 0;
+            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
+            {
+                zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
+            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
+            {
+                zones[channel_idx].matrix_map.width     = 0;
+                zones[channel_idx].matrix_map.height    = 0;
+                zones[channel_idx].matrix_map.map.resize(0);
+            }
+
+            addressableCounter++;
         }
 
         unsigned int num_mainboard_leds = device_info.num_leds - device_info.num_headers;
-        for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
+
+        for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
         {
             unsigned led_idx = led_ch_idx + 1;
             led new_led;
 
             new_led.name = zones[channel_idx].name;
+
             if(device_info.device_type == AuraDeviceType::FIXED && led_ch_idx >= num_mainboard_leds)
             {
                 new_led.name.append(", RGB Header ");
@@ -189,6 +218,7 @@ void RGBController_AuraUSB::SetupZones()
             {
                 new_led.name.append(", LED ");
             }
+
             new_led.name.append(std::to_string(led_idx));
 
             new_led.value = channel_idx;
@@ -200,17 +230,10 @@ void RGBController_AuraUSB::SetupZones()
     SetupColors();
 }
 
-void RGBController_AuraUSB::DeviceResizeZone(int zone, int new_size)
+void RGBController_AuraUSB::DeviceConfigureZone(int zone_idx)
 {
-    if((size_t) zone >= zones.size())
+    if((size_t)zone_idx < zones.size())
     {
-        return;
-    }
-
-    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
-    {
-        zones[zone].leds_count = new_size;
-
         SetupZones();
     }
 }

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.h

@@ -24,7 +24,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);

Controllers/AsusAuraUSBController/AsusROGAllyController/RGBController_AsusROGAlly.cpp

@@ -117,6 +117,8 @@ RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controll
 
 RGBController_AsusROGAlly::~RGBController_AsusROGAlly()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.cpp

@@ -129,6 +129,8 @@ RGBController_AsusROGStrixLC::RGBController_AsusROGStrixLC(AsusROGStrixLCControl
 
 RGBController_AsusROGStrixLC::~RGBController_AsusROGStrixLC()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController/RGBController_AsusCerberusKeyboard.cpp

@@ -283,6 +283,8 @@ RGBController_AsusCerberusKeyboard::RGBController_AsusCerberusKeyboard(AsusCerbe
 
 RGBController_AsusCerberusKeyboard::~RGBController_AsusCerberusKeyboard()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController/RGBController_AsusSagarisKeyboard.cpp

@@ -165,6 +165,8 @@ RGBController_AsusSagarisKeyboard::RGBController_AsusSagarisKeyboard(AsusSagaris
 
 RGBController_AsusSagarisKeyboard::~RGBController_AsusSagarisKeyboard()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusMonitorController/AsusMonitorController.cpp

@@ -89,7 +89,7 @@ void AsusMonitorController::SetDirect(std::vector<RGBColor> colors)
     usb_buf[0x00] = 0xEC;
     usb_buf[0x01] = 0x40;
     usb_buf[0x02] = 0x84;
-    usb_buf[0x04] = colors.size();
+    usb_buf[0x04] = (uint8_t)colors.size();
 
     for(size_t i = 0; i < colors.size(); i++)
     {

Controllers/AsusMonitorController/RGBController_AsusMonitor.cpp

@@ -46,6 +46,8 @@ RGBController_AsusMonitor::RGBController_AsusMonitor(AsusMonitorController* cont
 
 RGBController_AsusMonitor::~RGBController_AsusMonitor()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptop_Linux.cpp

@@ -92,6 +92,13 @@ RGBController_AsusTUFLaptopLinux::RGBController_AsusTUFLaptopLinux(AsusTUFLaptop
     SetupZones();
 }
 
+RGBController_AsusTUFLaptopLinux::~RGBController_AsusTUFLaptopLinux()
+{
+    Shutdown();
+
+    delete controller;
+}
+
 void RGBController_AsusTUFLaptopLinux::SetupZones()
 {
     /*---------------------------------------------------------*\

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptop_Linux.h

@@ -16,6 +16,7 @@ class RGBController_AsusTUFLaptopLinux : public RGBController
 {
 public:
     RGBController_AsusTUFLaptopLinux(AsusTUFLaptopLinuxController* controller_ptr);
+    ~RGBController_AsusTUFLaptopLinux();
 
     void SetupZones();
 

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptop_Windows.cpp

@@ -85,6 +85,8 @@ RGBController_AsusTUFLaptopWMI::RGBController_AsusTUFLaptopWMI(AsusTUFLaptopCont
 
 RGBController_AsusTUFLaptopWMI::~RGBController_AsusTUFLaptopWMI()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/BlinkyTapeController/RGBController_BlinkyTape.cpp

@@ -44,86 +44,90 @@ RGBController_BlinkyTape::RGBController_BlinkyTape(BlinkyTapeController* control
 
 RGBController_BlinkyTape::~RGBController_BlinkyTape()
 {
+    Shutdown();
+
     delete controller;
 }
 
 void RGBController_BlinkyTape::SetupZones()
 {
-    zones.clear();
+    /*-------------------------------------------------*\
+    | Only set LED count on the first run               |
+    \*-------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
+    {
+        first_run = true;
+    }
+
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
     leds.clear();
+    colors.clear();
+    zones.resize(1);
 
-    zone led_zone;
-    led_zone.name       = "LED Strip";
-    led_zone.type       = ZONE_TYPE_LINEAR;
-    led_zone.leds_min   = 0;
-    led_zone.leds_max   = 512;
-    led_zone.leds_count = 0;
-    zones.push_back(led_zone);
+    /*-----------------------------------------------------*\
+    | Set up zones                                          |
+    \*-----------------------------------------------------*/
+    zones[0].leds_min                   = 0;
+    zones[0].leds_max                   = 512;
 
-    DeviceResizeZone(0, led_zone.leds_count);
-}
-
-void RGBController_BlinkyTape::DeviceResizeZone(int zone, int new_size)
-{
-    /*-------------------------------------------------*\
-    | Explicitly cast these to avoid compiler warnings  |
-    \*-------------------------------------------------*/
-    const unsigned int zone_u       = static_cast<unsigned int>(zone);
-    const unsigned int new_size_u   = static_cast<unsigned int>(new_size);
-
-    /*-------------------------------------------------*\
-    | Check that the zone is in bounds                  |
-    \*-------------------------------------------------*/
-    if((zone_u > zones.size()) || (zone < 0))
+    if(first_run)
     {
-        return;
+        zones[0].flags                  = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
+                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
+                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
+                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
     }
 
-    /*-------------------------------------------------*\
-    | And that the new size is in bounds                |
-    \*-------------------------------------------------*/
-    if((new_size_u > zones.at(zone).leds_max) || (new_size_u < zones.at(zone).leds_min))
+    if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
     {
-        return;
+        zones[0].name                   = "Addressable RGB Header";
     }
 
-    /*-------------------------------------------------*\
-    | And that there's actually a change                |
-    \*-------------------------------------------------*/
-    if(zones.at(zone).leds_count == new_size_u)
+    if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
     {
-        return;
+        zones[0].leds_count             = 0;
     }
 
-    /*-------------------------------------------------*\
-    | If the new size is less than the current size,    |
-    | just chop off the end                             |
-    \*-------------------------------------------------*/
-    if(leds.size() > new_size_u)
+    if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
     {
-        leds.resize(new_size);
+        zones[0].type                   = ZONE_TYPE_LINEAR;
     }
 
-    /*-------------------------------------------------*\
-    | Otherwise, add new LEDs to the end                |
-    \*-------------------------------------------------*/
-    if(leds.size() < new_size_u)
+    if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
     {
-        for(size_t led_idx = leds.size(); led_idx < new_size_u; led_idx++)
-        {
-            led new_led;
-            new_led.name = "LED ";
-            new_led.name.append(std::to_string(led_idx));
-
-            leds.push_back(new_led);
-        }
+        zones[0].matrix_map.width       = 0;
+        zones[0].matrix_map.height      = 0;
+        zones[0].matrix_map.map.resize(0);
     }
 
-    zones.at(zone).leds_count = new_size;
+    /*-----------------------------------------------------*\
+    | Set up LEDs                                           |
+    \*-----------------------------------------------------*/
+    for(size_t led_idx = leds.size(); led_idx < zones[0].leds_count; led_idx++)
+    {
+        led new_led;
+        new_led.name = zones[0].name + ", LED ";
+        new_led.name.append(std::to_string(led_idx));
+
+        leds.push_back(new_led);
+    }
 
     SetupColors();
 }
 
+void RGBController_BlinkyTape::DeviceConfigureZone(int zone_idx)
+{
+    if((size_t)zone_idx < zones.size())
+    {
+        SetupZones();
+    }
+}
+
 void RGBController_BlinkyTape::DeviceUpdateLEDs()
 {
     controller->SetLEDs(colors);

Controllers/BlinkyTapeController/RGBController_BlinkyTape.h

@@ -23,7 +23,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);

Controllers/CherryKeyboardController/RGBController_CherryKeyboard.cpp

@@ -312,6 +312,8 @@ RGBController_CherryKeyboard::RGBController_CherryKeyboard(CherryKeyboardControl
 
 RGBController_CherryKeyboard::~RGBController_CherryKeyboard()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/ClevoKeyboardController/ClevoKeyboardController.cpp

@@ -10,8 +10,9 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "ClevoKeyboardController.h"
 #include <cstring>
+#include "ClevoKeyboardController.h"
+#include "StringUtils.h"
 
 ClevoKeyboardController::ClevoKeyboardController(hid_device* dev_handle, const hid_device_info& info)
 {
@@ -40,10 +41,7 @@ std::string ClevoKeyboardController::GetSerialString()
         return("");
     }
 
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }
 
 std::string ClevoKeyboardController::GetFirmwareVersion()

Controllers/ClevoKeyboardController/ClevoKeyboardControllerDetect.cpp

@@ -9,8 +9,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
 #include "ClevoKeyboardController.h"
+#include "DetectionManager.h"
 #include "RGBController_ClevoKeyboard.h"
 #include "RGBController.h"
 #include <hidapi.h>
@@ -26,7 +26,7 @@
 \*---------------------------------------------------------*/
 #define CLEVO_KEYBOARD_PID_600B                 0x600B
 
-DetectedControllers DetectClevoKeyboardControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectClevoKeyboardControllers(hid_device_info* info, const std::string& /*name*/)
 {
     DetectedControllers detected_controllers;
     hid_device*         dev;

Controllers/ClevoKeyboardController/RGBController_ClevoKeyboard.cpp

@@ -199,6 +199,8 @@ RGBController_ClevoKeyboard::RGBController_ClevoKeyboard(ClevoKeyboardController
 
 RGBController_ClevoKeyboard::~RGBController_ClevoKeyboard()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/ClevoLightbarController/ClevoLightbarController.cpp

@@ -10,8 +10,9 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "ClevoLightbarController.h"
 #include <cstring>
+#include "ClevoLightbarController.h"
+#include "StringUtils.h"
 
 ClevoLightbarController::ClevoLightbarController(hid_device* dev_handle, const hid_device_info& info)
 {
@@ -40,10 +41,7 @@ std::string ClevoLightbarController::GetSerialString()
         return("");
     }
 
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
+    return(StringUtils::wstring_to_string(serial_string));
 }
 
 std::string ClevoLightbarController::GetFirmwareVersion()

Controllers/ClevoLightbarController/ClevoLightbarControllerDetect.cpp

@@ -9,8 +9,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
 #include "ClevoLightbarController.h"
+#include "DetectionManager.h"
 #include "RGBController_ClevoLightbar.h"
 #include "RGBController.h"
 #include <hidapi.h>
@@ -25,7 +25,7 @@
 \*---------------------------------------------------------*/
 #define CLEVO_LIGHTBAR_PID                      0x7001
 
-DetectedControllers DetectClevoLightbarControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectClevoLightbarControllers(hid_device_info* info, const std::string& /*name*/)
 {
     DetectedControllers detected_controllers;
     hid_device*         dev;

Controllers/ClevoLightbarController/RGBController_ClevoLightbar.cpp

@@ -121,6 +121,8 @@ RGBController_ClevoLightbar::RGBController_ClevoLightbar(ClevoLightbarController
 
 RGBController_ClevoLightbar::~RGBController_ClevoLightbar()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -76,3 +76,6 @@ REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           Detec
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2,            0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV,           0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV2,          0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ti Ultra W DUO OC",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060TI_ULTRAW_DUO_OC,          0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV,             0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV2,            0x61);

Controllers/ColorfulGPUController/RGBController_ColorfulGPU.cpp

@@ -44,6 +44,8 @@ RGBController_ColorfulGPU::RGBController_ColorfulGPU(ColorfulGPUController * col
 
 RGBController_ColorfulGPU::~RGBController_ColorfulGPU()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/ColorfulTuringGPUController/RGBController_ColorfulTuringGPU.cpp

@@ -75,6 +75,8 @@ RGBController_ColorfulTuringGPU::RGBController_ColorfulTuringGPU(ColorfulTuringG
 
 RGBController_ColorfulTuringGPU::~RGBController_ColorfulTuringGPU()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/CoolerMasterController/CMARGBController/CMARGBController.cpp

@@ -12,16 +12,27 @@
 #include "CMARGBController.h"
 #include "StringUtils.h"
 
-CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx, std::shared_ptr<std::mutex> cm_mutex)
+/*---------------------------------------------------------*\
+| Map to convert port index to port ID used in protocol     |
+\*---------------------------------------------------------*/
+static unsigned char cm_argb_port_index_to_id[5] =
 {
-    dev                     = dev_handle;
-    location                = _path;
-    zone_index              = _zone_idx;
-    mutex_ptr               = cm_mutex;
+    CM_ARGB_PORT_ARGB_1,
+    CM_ARGB_PORT_ARGB_2,
+    CM_ARGB_PORT_ARGB_3,
+    CM_ARGB_PORT_ARGB_4,
+    CM_ARGB_PORT_RGB
+};
 
-    /*---------------------------------------------------------*\
-    | Get device name from HID manufacturer and product strings |
-    \*---------------------------------------------------------*/
+CMARGBController::CMARGBController(hid_device* dev_handle, char *path)
+{
+    dev         = dev_handle;
+    location    = path;
+
+    /*-----------------------------------------------------*\
+    | Get device name from HID manufacturer and product     |
+    | strings                                               |
+    \*-----------------------------------------------------*/
     wchar_t name_string[HID_MAX_STR];
 
     hid_get_manufacturer_string(dev, name_string, HID_MAX_STR);
@@ -29,57 +40,11 @@ CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned
 
     hid_get_product_string(dev, name_string, HID_MAX_STR);
     device_name.append(" ").append(StringUtils::wstring_to_string(name_string));
-
-    GetStatus();
 }
 
 CMARGBController::~CMARGBController()
 {
-    if(mutex_ptr.use_count() <= 1)
-    {
-        hid_close(dev);
-    }
-}
-
-void CMARGBController::GetStatus()
-{
-    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00, 0x80, 0x0B, 0x01 };
-    int buffer_size                             = (sizeof(buffer) / sizeof(buffer[0]));
-    int rgb_offset                              = 0;
-    int zone;
-
-    if (argb_header_data[zone_index].digital)
-    {
-        zone                                    = argb_header_data[zone_index].header;
-        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0B;
-    }
-    else
-    {
-        zone                                    = 0x00;
-        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0A;
-        rgb_offset                              = 1;
-    }
-
-    /*---------------------------------------------*\
-    | Guard the writes to the controller until the  |
-    |   for loop has completed to avoid collisons   |
-    \*---------------------------------------------*/
-    std::lock_guard<std::mutex> guard(*mutex_ptr);
-
-    /*---------------------------------------------------------*\
-    | If this is the group then just return the first status    |
-    \*---------------------------------------------------------*/
-    buffer[CM_ARGB_ZONE_BYTE]                   = ( zone > 0x08 ) ? 0x01 : zone;
-    hid_write(dev, buffer, buffer_size);
-    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
-
-    current_mode                                = buffer[4 - rgb_offset];
-    bool_random                                 = ( buffer[5 - rgb_offset] == 0x00 );
-    current_speed                               = buffer[6 - rgb_offset];
-    current_brightness                          = buffer[7 - rgb_offset];
-    current_red                                 = buffer[8 - rgb_offset];
-    current_green                               = buffer[9 - rgb_offset];
-    current_blue                                = buffer[10 - rgb_offset];
+    hid_close(dev);
 }
 
 std::string CMARGBController::GetDeviceName()
@@ -87,6 +52,33 @@ std::string CMARGBController::GetDeviceName()
     return(device_name);
 }
 
+std::string CMARGBController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+std::string CMARGBController::GetVersion()
+{
+    /*-----------------------------------------------------*\
+    | This device uses the serial value to determine the    |
+    | version.  It does not report a proper unique serial.  |
+    \*-----------------------------------------------------*/
+    std::string serial_string = GetSerial();
+
+    if(serial_string == CM_ARGB_FW0023)
+    {
+        return("0023");
+    }
+    else if(serial_string == CM_ARGB_FW0028)
+    {
+        return("0028");
+    }
+    else
+    {
+        return("Unsupported");
+    }
+}
+
 std::string CMARGBController::GetSerial()
 {
     wchar_t serial_string[HID_MAX_STR];
@@ -100,118 +92,187 @@ std::string CMARGBController::GetSerial()
     return(StringUtils::wstring_to_string(serial_string));
 }
 
-std::string CMARGBController::GetLocation()
+void CMARGBController::GetPortStatus
+    (
+    unsigned char   port_idx,
+    unsigned char*  port_mode,
+    unsigned char*  port_speed,
+    unsigned char*  port_brightness,
+    bool*           port_random,
+    unsigned char*  port_red,
+    unsigned char*  port_green,
+    unsigned char*  port_blue
+    )
 {
-    return("HID: " + location);
+    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = {0x00, 0x80, 0x0B, 0x01};
+    int buffer_size                             = (sizeof(buffer) / sizeof(buffer[0]));
+    int rgb_offset                              = 0;
+    int zone;
+
+    /*-----------------------------------------------------*\
+    | RGB port is handled differently from ARGB ports       |
+    \*-----------------------------------------------------*/
+    if(cm_argb_port_index_to_id[port_idx] != CM_ARGB_PORT_RGB)
+    {
+        zone                                    = cm_argb_port_index_to_id[port_idx];
+        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0B;
+    }
+    else
+    {
+        zone                                    = 0x00;
+        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0A;
+        rgb_offset                              = 1;
+    }
+
+    /*-----------------------------------------------------*\
+    | If this is the group then just return the first       |
+    | status                                                |
+    \*-----------------------------------------------------*/
+    buffer[CM_ARGB_ZONE_BYTE]                   = ( zone > 0x08 ) ? 0x01 : zone;
+
+    /*-----------------------------------------------------*\
+    | Send the command and read the response                |
+    \*-----------------------------------------------------*/
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
+
+    /*-----------------------------------------------------*\
+    | Read data out of response                             |
+    \*-----------------------------------------------------*/
+    *port_mode                                  = buffer[4 - rgb_offset];
+    *port_random                                = (buffer[5 - rgb_offset] == 0x00);
+    *port_speed                                 = buffer[6 - rgb_offset];
+    *port_brightness                            = buffer[7 - rgb_offset];
+    *port_red                                   = buffer[8 - rgb_offset];
+    *port_green                                 = buffer[9 - rgb_offset];
+    *port_blue                                  = buffer[10 - rgb_offset];
 }
 
-unsigned char CMARGBController::GetZoneIndex()
+void CMARGBController::SetPortLEDCount(unsigned char port_idx, unsigned char led_count)
 {
-    return(zone_index);
-}
-
-unsigned char CMARGBController::GetMode()
-{
-    return(current_mode);
-}
-
-unsigned char CMARGBController::GetLedRed()
-{
-    return(current_red);
-}
-
-unsigned char CMARGBController::GetLedGreen()
-{
-    return(current_green);
-}
-
-unsigned char CMARGBController::GetLedBlue()
-{
-    return(current_blue);
-}
-
-unsigned char CMARGBController::GetLedSpeed()
-{
-    return(current_speed);
-}
-
-bool CMARGBController::GetRandomColours()
-{
-    return(bool_random);
-}
-
-void CMARGBController::SetLedCount(int zone, int led_count)
-{
-    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00, 0x80, 0x0D, 0x02 };
+    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = {0x00, 0x80, 0x0D, 0x02};
     int  buffer_size                            = (sizeof(buffer) / sizeof(buffer[0]));
 
-    buffer[CM_ARGB_ZONE_BYTE]                   = zone;
+    buffer[CM_ARGB_ZONE_BYTE]                   = cm_argb_port_index_to_id[port_idx];
     buffer[CM_ARGB_MODE_BYTE]                   = led_count;
-    buffer[CM_ARGB_COLOUR_INDEX_BYTE]           = (0x0F - led_count > 0) ? 0x0F - led_count : 0x01;
-
-    /*---------------------------------------------*\
-    | Guard the writes to the controller until the  |
-    |   for loop has completed to avoid collisons   |
-    \*---------------------------------------------*/
-    std::lock_guard<std::mutex> guard(*mutex_ptr);
+    buffer[CM_ARGB_COLOUR_INDEX_BYTE]           = 1;
 
+    /*-----------------------------------------------------*\
+    | Send the command                                      |
+    \*-----------------------------------------------------*/
     hid_write(dev, buffer, buffer_size);
 }
 
-void CMARGBController::SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor colour, bool random_colours)
+void CMARGBController::SetPortMode
+    (
+    unsigned char   port_idx,
+    unsigned char   port_mode,
+    unsigned char   port_speed,
+    unsigned char   port_brightness,
+    bool            port_random,
+    unsigned char   port_red,
+    unsigned char   port_green,
+    unsigned char   port_blue
+    )
 {
-    bool needs_update   = !( (current_mode == mode) && (current_speed == speed) && (current_brightness == brightness) && (ToRGBColor(current_red, current_green, current_blue) == colour));
+    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = {0x00};
+    int  buffer_size                            = (sizeof(buffer) / sizeof(buffer[0]));
+    bool boolARGB_header                        = (cm_argb_port_index_to_id[port_idx] != CM_ARGB_PORT_RGB);
+    bool boolPassthru                           = (port_mode == CM_ARGB_MODE_PASSTHRU) || (port_mode == CM_RGB_MODE_PASSTHRU);
+    bool boolDirect                             = (port_mode == CM_ARGB_MODE_DIRECT);
+    unsigned char function                      = boolPassthru ? (boolARGB_header ? 0x02 : 0x04) : (boolARGB_header ? 0x01 : 0x03);
+    buffer[CM_ARGB_REPORT_BYTE]                 = 0x80;
+    buffer[CM_ARGB_COMMAND_BYTE]                = 0x01;
 
-    if (needs_update)
+    if(boolDirect)
     {
-        current_mode        = mode;
-        current_speed       = speed;
-        current_brightness  = brightness;
-        current_red         = RGBGetRValue(colour);
-        current_green       = RGBGetGValue(colour);
-        current_blue        = RGBGetBValue(colour);
-        bool_random         = random_colours;
+        buffer[CM_ARGB_FUNCTION_BYTE]           = 0x01;
+        buffer[CM_ARGB_ZONE_BYTE]               = 0x02;
 
-        SendUpdate();
+        /*-------------------------------------------------*\
+        | Send the command                                  |
+        \*-------------------------------------------------*/
+        hid_write(dev, buffer, buffer_size);
+
+        /*-------------------------------------------------*\
+        | Direct mode is now set up and no other mode       |
+        | packet is required                                |
+        \*-------------------------------------------------*/
+        return;
     }
+
+    buffer[CM_ARGB_FUNCTION_BYTE]               = function;
+
+    /*-----------------------------------------------------*\
+    | Send the command                                      |
+    \*-----------------------------------------------------*/
+    hid_write(dev, buffer, buffer_size);
+
+    /*-----------------------------------------------------*\
+    | ARGB ports send command 0x0B, RGB port sends 0x04     |
+    \*-----------------------------------------------------*/
+    if(boolARGB_header)
+    {
+        buffer[CM_ARGB_COMMAND_BYTE]                        = 0x0B;
+        buffer[CM_ARGB_FUNCTION_BYTE]                       = (false) ? 0x01 : 0x02;
+        buffer[CM_ARGB_ZONE_BYTE]                           = cm_argb_port_index_to_id[port_idx];
+        buffer[CM_ARGB_MODE_BYTE]                           = port_mode;
+        buffer[CM_ARGB_COLOUR_INDEX_BYTE]                   = port_random ? 0x00 : 0x10;
+        buffer[CM_ARGB_SPEED_BYTE]                          = port_speed;
+        buffer[CM_ARGB_BRIGHTNESS_BYTE]                     = port_brightness;
+        buffer[CM_ARGB_RED_BYTE]                            = port_red;
+        buffer[CM_ARGB_GREEN_BYTE]                          = port_green;
+        buffer[CM_ARGB_BLUE_BYTE]                           = port_blue;
+    }
+    else
+    {
+        buffer[CM_ARGB_COMMAND_BYTE]                        = boolPassthru ? 0x01 : 0x04;
+        buffer[CM_ARGB_MODE_BYTE + CM_RGB_OFFSET]           = port_mode;
+        buffer[CM_ARGB_COLOUR_INDEX_BYTE + CM_RGB_OFFSET]   = port_random ? 0x00 : 0x10;
+        buffer[CM_ARGB_SPEED_BYTE + CM_RGB_OFFSET]          = port_speed;
+        buffer[CM_ARGB_BRIGHTNESS_BYTE + CM_RGB_OFFSET]     = port_brightness;
+        buffer[CM_ARGB_RED_BYTE + CM_RGB_OFFSET]            = port_red;
+        buffer[CM_ARGB_GREEN_BYTE + CM_RGB_OFFSET]          = port_green;
+        buffer[CM_ARGB_BLUE_BYTE + CM_RGB_OFFSET]           = port_blue;
+    }
+
+    /*-----------------------------------------------------*\
+    | Send the command and wait for response                |
+    \*-----------------------------------------------------*/
+    hid_write(dev, buffer, buffer_size);
 }
 
-void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_count)
+void CMARGBController::SetPortLEDsDirect(unsigned char port_idx, RGBColor *led_colours, unsigned int led_count)
 {
     const unsigned char buffer_size     = CM_ARGB_PACKET_SIZE;
     unsigned char buffer[buffer_size]   = { 0x00, 0x00, 0x07, 0x02 };
     unsigned char packet_count          = 0;
     std::vector<uint8_t> colours;
 
-    /*---------------------------------------------*\
-    | Set up the RGB triplets to send               |
-    \*---------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Set up the RGB triplets to send                       |
+    \*-----------------------------------------------------*/
     for(unsigned int i = 0; i < led_count; i++)
     {
         RGBColor      colour            = led_colours[i];
 
-        colours.push_back( RGBGetRValue(colour) );
-        colours.push_back( RGBGetGValue(colour) );
-        colours.push_back( RGBGetBValue(colour) );
+        colours.push_back(RGBGetRValue(colour));
+        colours.push_back(RGBGetGValue(colour));
+        colours.push_back(RGBGetBValue(colour));
     }
 
-    buffer[CM_ARGB_FUNCTION_BYTE]       = zone_index - 1;
+    buffer[CM_ARGB_FUNCTION_BYTE]       = port_idx;
     buffer[CM_ARGB_ZONE_BYTE]           = led_count;
     unsigned char buffer_idx            = CM_ARGB_MODE_BYTE;
 
-    /*---------------------------------------------*\
-    | Guard the writes to the controller until the  |
-    |   for loop has completed to avoid collisons   |
-    \*---------------------------------------------*/
-    std::lock_guard<std::mutex> guard(*mutex_ptr);
-
     for(std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = CM_ARGB_COMMAND_BYTE)
     {
-        /*-----------------------------------------------------------------*\
-        | Fill the write buffer till its full or the colour buffer is empty |
-        \*-----------------------------------------------------------------*/
+        /*-------------------------------------------------*\
+        | Fill the write buffer till its full or the        |
+        | colour buffer is empty                            |
+        \*-------------------------------------------------*/
         buffer[CM_ARGB_REPORT_BYTE] = packet_count;
-        while (( buffer_idx < buffer_size) && ( it != colours.end() ))
+        while((buffer_idx < buffer_size) && (it != colours.end()))
         {
             buffer[buffer_idx] = *it;
             buffer_idx++;
@@ -223,76 +284,15 @@ void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_cou
             buffer[CM_ARGB_REPORT_BYTE] += 0x80;
         }
 
+        /*-------------------------------------------------*\
+        | Send the buffer                                   |
+        \*-------------------------------------------------*/
         hid_write(dev, buffer, buffer_size);
 
-        /*-----------------------------------------------------------------*\
-        | Reset the write buffer                                            |
-        \*-----------------------------------------------------------------*/
+        /*-------------------------------------------------*\
+        | Reset the write buffer                            |
+        \*-------------------------------------------------*/
         memset(buffer, 0x00, buffer_size );
         packet_count++;
     }
 }
-
-void CMARGBController::SendUpdate()
-{
-    /*---------------------------------------------*\
-    | Guard the writes to the controller            |
-    \*---------------------------------------------*/
-    std::lock_guard<std::mutex> guard(*mutex_ptr);
-
-    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00 };
-    int  buffer_size                            = (sizeof(buffer) / sizeof(buffer[0]));
-    bool boolARGB_header                        = argb_header_data[zone_index].digital;
-    bool boolPassthru                           = ( current_mode == CM_ARGB_MODE_PASSTHRU ) || ( current_mode == CM_RGB_MODE_PASSTHRU );
-    bool boolDirect                             = ( current_mode == CM_ARGB_MODE_DIRECT );
-    unsigned char function                      = boolPassthru ? (boolARGB_header ? 0x02 : 0x04) : (boolARGB_header ? 0x01 : 0x03);
-    buffer[CM_ARGB_REPORT_BYTE]                 = 0x80;
-    buffer[CM_ARGB_COMMAND_BYTE]                = 0x01;
-
-    if(boolDirect)
-    {
-        buffer[CM_ARGB_FUNCTION_BYTE]           = 0x01;
-        buffer[CM_ARGB_ZONE_BYTE]               = 0x02;
-
-        hid_write(dev, buffer, buffer_size);
-        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
-
-        /*-----------------------------------------------------------------*\
-        | Direct mode is now set up and no other mode packet is required    |
-        \*-----------------------------------------------------------------*/
-        return;
-    }
-
-    buffer[CM_ARGB_FUNCTION_BYTE]           = function;
-
-    hid_write(dev, buffer, buffer_size);
-    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
-
-    if(boolARGB_header)
-    {
-        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0B;                                     //ARGB sends 0x0B (1011) RGB sends 0x04 (0100)
-        buffer[CM_ARGB_FUNCTION_BYTE]           = (false) ? 0x01 : 0x02;                    //This controls direct mode TODO
-        buffer[CM_ARGB_ZONE_BYTE]               = argb_header_data[zone_index].header;
-        buffer[CM_ARGB_MODE_BYTE]               = current_mode;
-        buffer[CM_ARGB_COLOUR_INDEX_BYTE]       = bool_random ? 0x00 : 0x10;
-        buffer[CM_ARGB_SPEED_BYTE]              = current_speed;
-        buffer[CM_ARGB_BRIGHTNESS_BYTE]         = current_brightness;
-        buffer[CM_ARGB_RED_BYTE]                = current_red;
-        buffer[CM_ARGB_GREEN_BYTE]              = current_green;
-        buffer[CM_ARGB_BLUE_BYTE]               = current_blue;
-    }
-    else
-    {
-        buffer[CM_ARGB_COMMAND_BYTE]                        = boolPassthru ? 0x01 : 0x04;   //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
-        buffer[CM_ARGB_MODE_BYTE + CM_RGB_OFFSET]           = current_mode;
-        buffer[CM_ARGB_COLOUR_INDEX_BYTE + CM_RGB_OFFSET]   = bool_random ? 0x00 : 0x10;
-        buffer[CM_ARGB_SPEED_BYTE + CM_RGB_OFFSET]          = current_speed;
-        buffer[CM_ARGB_BRIGHTNESS_BYTE + CM_RGB_OFFSET]     = current_brightness;
-        buffer[CM_ARGB_RED_BYTE + CM_RGB_OFFSET]            = current_red;
-        buffer[CM_ARGB_GREEN_BYTE + CM_RGB_OFFSET]          = current_green;
-        buffer[CM_ARGB_BLUE_BYTE + CM_RGB_OFFSET]           = current_blue;
-    }
-
-    hid_write(dev, buffer, buffer_size);
-    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
-}

Controllers/CoolerMasterController/CMARGBController/CMARGBController.h

@@ -16,19 +16,20 @@
 #include <array>
 #include <memory>
 #include <hidapi.h>
-#include "RGBController.h"  //Needed to set the direct mode
+#include "RGBController.h"
 
-#define CM_ARGB_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
-#define CM_ARGB_HEADER_DATA_SIZE (sizeof(argb_header_data) / sizeof(argb_headers) )
-#define CM_ARGB_INTERRUPT_TIMEOUT 250
-#define CM_ARGB_PACKET_SIZE 65
-#define CM_ARGB_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
-#define CM_RGB_OFFSET -2
-#define HID_MAX_STR 255
+#define CM_ARGB_COLOUR_MODE_DATA_SIZE   (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
+#define CM_ARGB_HEADER_DATA_SIZE        (sizeof(argb_header_data) / sizeof(argb_headers) )
+#define CM_ARGB_INTERRUPT_TIMEOUT       250
+#define CM_ARGB_PACKET_SIZE             65
+#define CM_ARGB_DEVICE_NAME_SIZE        (sizeof(device_name) / sizeof(device_name[ 0 ]))
+#define CM_RGB_OFFSET                   -2
+#define HID_MAX_STR                     255
 
-#define CM_ARGB_BRIGHTNESS_MAX  255
-#define CM_ARGB_FW0023          std::string("A202011171238")
-#define CM_ARGB_FW0028          std::string("A202105291658")
+#define CM_ARGB_BRIGHTNESS_MAX          255
+#define CM_ARGB_FW0000                  std::string("A201804091608")
+#define CM_ARGB_FW0023                  std::string("A202011171238")
+#define CM_ARGB_FW0028                  std::string("A202105291658")
 
 enum
 {
@@ -45,22 +46,13 @@ enum
     CM_ARGB_BLUE_BYTE           = 11
 };
 
-struct argb_headers
+enum
 {
-    const char*     name;
-    unsigned char   header;
-    bool            digital;
-    unsigned int    count;
-};
-
-static argb_headers argb_header_data[] =
-{
-    { "RGB Header",         0xFE, false,  1 },
-    { "Digital ARGB1",      0x01, true,  12 },
-    { "Digital ARGB2",      0x02, true,  12 },
-    { "Digital ARGB3",      0x04, true,  12 },
-    { "Digital ARGB4",      0x08, true,  12 },
-    //{ "All Digital ARGB",   0xFF, true,  12 }
+    CM_ARGB_PORT_ARGB_1         = 0x01,
+    CM_ARGB_PORT_ARGB_2         = 0x02,
+    CM_ARGB_PORT_ARGB_3         = 0x04,
+    CM_ARGB_PORT_ARGB_4         = 0x08,
+    CM_ARGB_PORT_RGB            = 0xFE,
 };
 
 enum
@@ -101,40 +93,44 @@ enum
 class CMARGBController
 {
 public:
-    CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx, std::shared_ptr<std::mutex> cm_mutex);
+    CMARGBController(hid_device* dev_handle, char* path);
     ~CMARGBController();
 
     std::string GetDeviceName();
     std::string GetSerial();
     std::string GetLocation();
+    std::string GetVersion();
 
-    unsigned char GetZoneIndex();
-    unsigned char GetMode();
-    unsigned char GetLedRed();
-    unsigned char GetLedGreen();
-    unsigned char GetLedBlue();
-    unsigned char GetLedSpeed();
-    bool GetRandomColours();
-    void SetLedCount(int zone, int led_count);
-    void SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor colour, bool random_colours);
-    void SetLedsDirect(RGBColor * led_colours, unsigned int led_count);
+    void GetPortStatus
+        (
+        unsigned char   port_idx,
+        unsigned char*  port_mode,
+        unsigned char*  port_speed,
+        unsigned char*  port_brightness,
+        bool*           port_random,
+        unsigned char*  port_red,
+        unsigned char*  port_green,
+        unsigned char*  port_blue
+        );
+
+    void SetPortLEDCount(unsigned char port_idx, unsigned char led_count);
+
+    void SetPortMode
+        (
+        unsigned char   port_idx,
+        unsigned char   port_mode,
+        unsigned char   port_speed,
+        unsigned char   port_brightness,
+        bool            port_random,
+        unsigned char   port_red,
+        unsigned char   port_green,
+        unsigned char   port_blue
+        );
+
+    void SetPortLEDsDirect(unsigned char port_idx, RGBColor *led_colours, unsigned int led_count);
 
 private:
-    std::string                 device_name;
-    std::string                 location;
-    hid_device*                 dev;
-    std::shared_ptr<std::mutex> mutex_ptr;
-
-    unsigned char               zone_index;
-    unsigned char               current_mode;
-    unsigned char               current_speed;
-
-    unsigned char               current_red;
-    unsigned char               current_green;
-    unsigned char               current_blue;
-    unsigned char               current_brightness;
-    bool                        bool_random;
-
-    void GetStatus();
-    void SendUpdate();
+    hid_device*         dev;
+    std::string         device_name;
+    std::string         location;
 };

Controllers/CoolerMasterController/CMARGBController/RGBController_CMARGBController.cpp

@@ -27,401 +27,594 @@
 RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController* controller_ptr)
 {
     controller                      = controller_ptr;
-    unsigned char speed             = controller->GetLedSpeed();
 
-    name                            = argb_header_data[controller->GetZoneIndex()].name;
+    name                            = controller->GetDeviceName();
     vendor                          = "Cooler Master";
     type                            = DEVICE_TYPE_LEDSTRIP;
-    description                     = controller->GetDeviceName();
-    version                         = "3.0 for FW0028";
+    description                     = "Cooler Master ARGB Controller Device";
+    version                         = controller->GetVersion();
     serial                          = controller->GetSerial();
     location                        = controller->GetLocation();
 
-    if(argb_header_data[controller->GetZoneIndex()].digital)
-    {
-        mode Off;
-        Off.name                    = "Turn Off";
-        Off.value                   = CM_ARGB_MODE_OFF;
-        Off.color_mode              = MODE_COLORS_NONE;
-        modes.push_back(Off);
-
-        mode Reload;
-        Reload.name                 = "Reload";
-        Reload.value                = CM_ARGB_MODE_RELOAD;
-        Reload.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-        Reload.colors_min           = 1;
-        Reload.colors_max           = 1;
-        Reload.colors.resize(Reload.colors_max);
-        Reload.brightness_min       = 0;
-        Reload.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
-        Reload.brightness           = CM_ARGB_BRIGHTNESS_MAX;
-        Reload.speed_min            = CM_ARGB_SPEED_SLOWEST;
-        Reload.speed_max            = CM_ARGB_SPEED_FASTEST;
-        Reload.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Reload.speed                = speed;
-        modes.push_back(Reload);
-
-        mode Recoil;
-        Recoil.name                 = "Recoil";
-        Recoil.value                = CM_ARGB_MODE_RECOIL;
-        Recoil.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-        Recoil.colors_min           = 1;
-        Recoil.colors_max           = 1;
-        Recoil.colors.resize(Recoil.colors_max);
-        Recoil.brightness_min       = 0;
-        Recoil.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
-        Recoil.brightness           = CM_ARGB_BRIGHTNESS_MAX;
-        Recoil.speed_min            = CM_ARGB_SPEED_SLOWEST;
-        Recoil.speed_max            = CM_ARGB_SPEED_FASTEST;
-        Recoil.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Recoil.speed                = speed;
-        modes.push_back(Recoil);
-
-        mode Breathing;
-        Breathing.name              = "Breathing";
-        Breathing.value             = CM_ARGB_MODE_BREATHING;
-        Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-        Breathing.colors_min        = 1;
-        Breathing.colors_max        = 1;
-        Breathing.colors.resize(Breathing.colors_max);
-        Breathing.brightness_min    = 0;
-        Breathing.brightness_max    = CM_ARGB_BRIGHTNESS_MAX;
-        Breathing.brightness        = CM_ARGB_BRIGHTNESS_MAX;
-        Breathing.speed_min         = CM_ARGB_SPEED_SLOWEST;
-        Breathing.speed_max         = CM_ARGB_SPEED_FASTEST;
-        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Breathing.speed             = speed;
-        modes.push_back(Breathing);
-
-        mode Refill;
-        Refill.name                 = "Refill";
-        Refill.value                = CM_ARGB_MODE_REFILL;
-        Refill.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-        Refill.colors_min           = 1;
-        Refill.colors_max           = 1;
-        Refill.colors.resize(Refill.colors_max);
-        Refill.brightness_min       = 0;
-        Refill.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
-        Refill.brightness           = CM_ARGB_BRIGHTNESS_MAX;
-        Refill.speed_min            = CM_ARGB_SPEED_SLOWEST;
-        Refill.speed_max            = CM_ARGB_SPEED_FASTEST;
-        Refill.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Refill.speed                = speed;
-        modes.push_back(Refill);
-
-        mode Demo;
-        Demo.name                   = "Demo";
-        Demo.value                  = CM_ARGB_MODE_DEMO;
-        Demo.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-        Demo.brightness_min         = 0;
-        Demo.brightness_max         = CM_ARGB_BRIGHTNESS_MAX;
-        Demo.brightness             = CM_ARGB_BRIGHTNESS_MAX;
-        Demo.speed_min              = CM_ARGB_SPEED_SLOWEST;
-        Demo.speed_max              = CM_ARGB_SPEED_FASTEST;
-        Demo.color_mode             = MODE_COLORS_NONE;
-        Demo.speed                  = speed;
-        modes.push_back(Demo);
-
-        mode Spectrum;
-        Spectrum.name               = "Spectrum";
-        Spectrum.value              = CM_ARGB_MODE_SPECTRUM;
-        Spectrum.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-        Spectrum.brightness_min     = 0;
-        Spectrum.brightness_max     = CM_ARGB_BRIGHTNESS_MAX;
-        Spectrum.brightness         = CM_ARGB_BRIGHTNESS_MAX;
-        Spectrum.speed_min          = CM_ARGB_SPEED_SLOWEST;
-        Spectrum.speed_max          = CM_ARGB_SPEED_FASTEST;
-        Spectrum.color_mode         = MODE_COLORS_NONE;
-        Spectrum.speed              = speed;
-        modes.push_back(Spectrum);
-
-        mode FillFlow;
-        FillFlow.name               = "Fill Flow";
-        FillFlow.value              = CM_ARGB_MODE_FILLFLOW;
-        FillFlow.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-        FillFlow.brightness_min     = 0;
-        FillFlow.brightness_max     = CM_ARGB_BRIGHTNESS_MAX;
-        FillFlow.brightness         = CM_ARGB_BRIGHTNESS_MAX;
-        FillFlow.speed_min          = CM_ARGB_SPEED_SLOWEST;
-        FillFlow.speed_max          = CM_ARGB_SPEED_FASTEST;
-        FillFlow.color_mode         = MODE_COLORS_NONE;
-        FillFlow.speed              = speed;
-        modes.push_back(FillFlow);
-
-        mode Rainbow;
-        Rainbow.name                = "Rainbow";
-        Rainbow.value               = CM_ARGB_MODE_RAINBOW;
-        Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-        Rainbow.brightness_min      = 0;
-        Rainbow.brightness_max      = CM_ARGB_BRIGHTNESS_MAX;
-        Rainbow.brightness          = CM_ARGB_BRIGHTNESS_MAX;
-        Rainbow.speed_min           = CM_ARGB_SPEED_SLOWEST;
-        Rainbow.speed_max           = CM_ARGB_SPEED_FASTEST;
-        Rainbow.color_mode          = MODE_COLORS_NONE;
-        Rainbow.speed               = speed;
-        modes.push_back(Rainbow);
-
-        mode Static;
-        Static.name                 = "Static";
-        Static.value                = CM_ARGB_MODE_STATIC;
-        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-        Static.colors_min           = 1;
-        Static.colors_max           = 1;
-        Static.colors.resize(Static.colors_max);
-        Static.brightness_min       = 0;
-        Static.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
-        Static.brightness           = CM_ARGB_BRIGHTNESS_MAX;
-        Static.speed_min            = CM_ARGB_SPEED_SLOWEST;
-        Static.speed_max            = CM_ARGB_SPEED_FASTEST;
-        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Static.speed                = speed;
-        modes.push_back(Static);
-
-        mode Direct;
-        Direct.name                 = (serial >= CM_ARGB_FW0028) ? "Direct" : "Custom";
-        Direct.value                = CM_ARGB_MODE_DIRECT;
-        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-        Direct.color_mode           = MODE_COLORS_PER_LED;
-        modes.push_back(Direct);
-
-        mode PassThru;
-        PassThru.name               = "Pass Thru";
-        PassThru.value              = CM_ARGB_MODE_PASSTHRU;
-        PassThru.flags              = 0;
-        PassThru.color_mode         = MODE_COLORS_NONE;
-        modes.push_back(PassThru);
-    }
-    else
-    {
-        mode Static;
-        Static.name                 = "Static";
-        Static.value                = CM_RGB_MODE_STATIC;
-        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-        Static.colors_min           = 1;
-        Static.colors_max           = 1;
-        Static.colors.resize(Static.colors_max);
-        Static.brightness_min       = 0;
-        Static.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
-        Static.brightness           = CM_ARGB_BRIGHTNESS_MAX;
-        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Static.speed                = 0;
-        modes.push_back(Static);
-
-        mode Breathing;
-        Breathing.name              = "Breathing";
-        Breathing.value             = CM_RGB_MODE_BREATHING;
-        Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-        Breathing.colors_min        = 1;
-        Breathing.colors_max        = 1;
-        Breathing.colors.resize(Breathing.colors_max);
-        Breathing.brightness_min    = 0;
-        Breathing.brightness_max    = CM_ARGB_BRIGHTNESS_MAX;
-        Breathing.brightness        = CM_ARGB_BRIGHTNESS_MAX;
-        Breathing.speed_min         = CM_ARGB_SPEED_SLOWEST;
-        Breathing.speed_max         = CM_ARGB_SPEED_FASTEST;
-        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Breathing.speed             = CM_ARGB_SPEED_NORMAL;
-        modes.push_back(Breathing);
-
-        mode Flash;
-        Flash.name                  = "Flash";
-        Flash.value                 = CM_RGB_MODE_FLASH;
-        Flash.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-        Flash.colors_min            = 1;
-        Flash.colors_max            = 1;
-        Flash.colors.resize(Flash.colors_max);
-        Flash.brightness_min        = 0;
-        Flash.brightness_max        = CM_ARGB_BRIGHTNESS_MAX;
-        Flash.brightness            = CM_ARGB_BRIGHTNESS_MAX;
-        Flash.speed_min             = CM_ARGB_SPEED_SLOWEST;
-        Flash.speed_max             = CM_ARGB_SPEED_FASTEST;
-        Flash.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-        Flash.speed                 = CM_ARGB_SPEED_NORMAL;
-        modes.push_back(Flash);
-
-        mode Mirage;
-        Mirage.name                 = "Mirage";
-        Mirage.value                = CM_RGB_MODE_MIRAGE;
-        Mirage.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-        Mirage.colors_min           = 1;
-        Mirage.colors_max           = 1;
-        Mirage.colors.resize(Mirage.colors_max);
-        Mirage.brightness_min       = 0;
-        Mirage.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
-        Mirage.brightness           = CM_ARGB_BRIGHTNESS_MAX;
-        Mirage.speed_min            = CM_ARGB_SPEED_SLOWEST;
-        Mirage.speed_max            = CM_ARGB_SPEED_FASTEST;
-        Mirage.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Mirage.speed                = CM_ARGB_SPEED_NORMAL;
-        modes.push_back(Mirage);
-
-        mode PassThru;
-        PassThru.name               = "Pass Thru";
-        PassThru.value              = CM_RGB_MODE_PASSTHRU;
-        PassThru.color_mode         = MODE_COLORS_NONE;
-        modes.push_back(PassThru);
-
-        mode Off;
-        Off.name                    = "Turn Off";
-        Off.value                   = CM_RGB_MODE_OFF;
-        Off.color_mode              = MODE_COLORS_NONE;
-        modes.push_back(Off);
-    }
-
-    Init_Controller();
     SetupZones();
+    SetupModes();
 
-    int temp_mode   = controller->GetMode();
-    for(int mode_idx = 0; mode_idx < (int)modes.size() ; mode_idx++)
+    /*-----------------------------------------------------*\
+    | Initialize the active mode to port 0                  |
+    \*-----------------------------------------------------*/
+    unsigned char   port_mode;
+    unsigned char   port_speed;
+    unsigned char   port_brightness;
+    bool            port_random;
+    unsigned char   port_red;
+    unsigned char   port_green;
+    unsigned char   port_blue;
+
+    controller->GetPortStatus(0, &port_mode, &port_speed, &port_brightness, &port_random, &port_red, &port_green, &port_blue);
+
+    for(std::size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
     {
-        if (temp_mode == modes[mode_idx].value)
+        if(modes[mode_idx].value == port_mode)
         {
-            active_mode = mode_idx;
+            active_mode = (int)mode_idx;
+
+            if((modes[mode_idx].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR) && (modes[mode_idx].colors.size() > 0))
+            {
+                modes[mode_idx].colors[0] = ToRGBColor(port_red, port_green, port_blue);
+            }
+
+            if(modes[mode_idx].flags & MODE_FLAG_HAS_SPEED)
+            {
+                modes[mode_idx].speed = port_speed;
+            }
+
+            if(modes[mode_idx].flags & MODE_FLAG_HAS_BRIGHTNESS)
+            {
+                modes[mode_idx].brightness = port_brightness;
+            }
+
+            if(modes[mode_idx].flags & MODE_FLAG_HAS_RANDOM_COLOR)
+            {
+                if(port_random)
+                {
+                    modes[mode_idx].color_mode = MODE_COLORS_RANDOM;
+                }
+            }
+
             break;
         }
     }
-    if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
-    {
-        modes[active_mode].colors[0] = ToRGBColor(controller->GetLedRed(), controller->GetLedGreen(), controller->GetLedBlue());
-        modes[active_mode].color_mode = (controller->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
-    }
-    if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
-    {
-        modes[active_mode].speed = controller->GetLedSpeed();
-    }
 }
 
 RGBController_CMARGBController::~RGBController_CMARGBController()
 {
+    Shutdown();
+
     delete controller;
 }
 
-void RGBController_CMARGBController::Init_Controller()
+void RGBController_CMARGBController::SetupModes()
 {
-    int zone_idx            = controller->GetZoneIndex();
-    int zone_led_count      = argb_header_data[zone_idx].count;
+    /*-----------------------------------------------------*\
+    | Define Direct and Passthrough modes as require entire |
+    | device, these are not available as per-zone modes     |
+    \*-----------------------------------------------------*/
+    mode Direct;
+    Direct.name                     = (serial >= CM_ARGB_FW0028) ? "Direct" : "Custom";
+    Direct.value                    = CM_ARGB_MODE_DIRECT;
+    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_REQUIRES_ENTIRE_DEVICE;
+    Direct.color_mode               = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
 
-    /*-------------------------------------------------*\
-    | If argb_header_data[zone_idx].count == 1 then the |
-    | zone is ZONE_TYPE_SINGLE                          |
-    \*-------------------------------------------------*/
-    bool boolSingleLED      = ( zone_led_count == 1 );
+    mode PassThru;
+    PassThru.name                   = "Passthrough";
+    PassThru.value                  = CM_ARGB_MODE_PASSTHRU | MODE_FLAG_REQUIRES_ENTIRE_DEVICE;
+    PassThru.flags                  = 0;
+    PassThru.color_mode             = MODE_COLORS_NONE;
+    modes.push_back(PassThru);
 
-    zone ARGB_zone;
-    ARGB_zone.name          = std::to_string(zone_idx);
-    ARGB_zone.type          = (boolSingleLED) ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
-    ARGB_zone.leds_min      = 4;
-    ARGB_zone.leds_max      = 48;
-    ARGB_zone.leds_count    = zone_led_count;
-    zones.push_back(ARGB_zone);
+    /*-----------------------------------------------------*\
+    | The ARGB ports support more modes than the RGB port.  |
+    | Define all of the modes the ARGB ports support and    |
+    | map RGB modes to them as best as we can.              |
+    \*-----------------------------------------------------*/
+    mode Off;
+    Off.name                        = "Off";
+    Off.value                       = CM_ARGB_MODE_OFF;
+    Off.color_mode                  = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
+    {
+        zones[zone_idx].modes.push_back(Off);
+    }
+
+    mode Reload;
+    Reload.name                     = "Reload";
+    Reload.value                    = CM_ARGB_MODE_RELOAD;
+    Reload.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Reload.speed_min                = CM_ARGB_SPEED_SLOWEST;
+    Reload.speed_max                = CM_ARGB_SPEED_FASTEST;
+    Reload.speed                    = CM_ARGB_SPEED_NORMAL;
+    Reload.brightness_min           = 0;
+    Reload.brightness_max           = CM_ARGB_BRIGHTNESS_MAX;
+    Reload.brightness               = CM_ARGB_BRIGHTNESS_MAX;
+    Reload.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    Reload.colors_min               = 1;
+    Reload.colors_max               = 1;
+    Reload.colors.resize(Reload.colors_max);
+    modes.push_back(Reload);
+
+    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
+    {
+        zones[zone_idx].modes.push_back(Reload);
+    }
+
+    mode Recoil;
+    Recoil.name                     = "Recoil";
+    Recoil.value                    = CM_ARGB_MODE_RECOIL;
+    Recoil.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Recoil.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    Recoil.speed_min                = CM_ARGB_SPEED_SLOWEST;
+    Recoil.speed_max                = CM_ARGB_SPEED_FASTEST;
+    Recoil.speed                    = CM_ARGB_SPEED_NORMAL;
+    Recoil.brightness_min           = 0;
+    Recoil.brightness_max           = CM_ARGB_BRIGHTNESS_MAX;
+    Recoil.brightness               = CM_ARGB_BRIGHTNESS_MAX;
+    Recoil.colors_min               = 1;
+    Recoil.colors_max               = 1;
+    Recoil.colors.resize(Recoil.colors_max);
+    modes.push_back(Recoil);
+
+    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
+    {
+        zones[zone_idx].modes.push_back(Recoil);
+    }
+
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = CM_ARGB_MODE_BREATHING;
+    Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed_min             = CM_ARGB_SPEED_SLOWEST;
+    Breathing.speed_max             = CM_ARGB_SPEED_FASTEST;
+    Breathing.speed                 = CM_ARGB_SPEED_NORMAL;
+    Breathing.brightness_min        = 0;
+    Breathing.brightness_max        = CM_ARGB_BRIGHTNESS_MAX;
+    Breathing.brightness            = CM_ARGB_BRIGHTNESS_MAX;
+    Breathing.colors_min            = 1;
+    Breathing.colors_max            = 1;
+    Breathing.colors.resize(Breathing.colors_max);
+    modes.push_back(Breathing);
+
+    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
+    {
+        zones[zone_idx].modes.push_back(Breathing);
+    }
+
+    mode Refill;
+    Refill.name                     = "Refill";
+    Refill.value                    = CM_ARGB_MODE_REFILL;
+    Refill.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Refill.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    Refill.speed_min                = CM_ARGB_SPEED_SLOWEST;
+    Refill.speed_max                = CM_ARGB_SPEED_FASTEST;
+    Refill.speed                    = CM_ARGB_SPEED_NORMAL;
+    Refill.brightness_min           = 0;
+    Refill.brightness_max           = CM_ARGB_BRIGHTNESS_MAX;
+    Refill.brightness               = CM_ARGB_BRIGHTNESS_MAX;
+    Refill.colors_min               = 1;
+    Refill.colors_max               = 1;
+    Refill.colors.resize(Refill.colors_max);
+    modes.push_back(Refill);
+
+    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
+    {
+        zones[zone_idx].modes.push_back(Refill);
+    }
+
+    mode Demo;
+    Demo.name                       = "Demo";
+    Demo.value                      = CM_ARGB_MODE_DEMO;
+    Demo.flags                      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Demo.color_mode                 = MODE_COLORS_NONE;
+    Demo.speed_min                  = CM_ARGB_SPEED_SLOWEST;
+    Demo.speed_max                  = CM_ARGB_SPEED_FASTEST;
+    Demo.speed                      = CM_ARGB_SPEED_NORMAL;
+    Demo.brightness_min             = 0;
+    Demo.brightness_max             = CM_ARGB_BRIGHTNESS_MAX;
+    Demo.brightness                 = CM_ARGB_BRIGHTNESS_MAX;
+    modes.push_back(Demo);
+
+    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
+    {
+        zones[zone_idx].modes.push_back(Demo);
+    }
+
+    mode Spectrum;
+    Spectrum.name                   = "Rainbow Wave";
+    Spectrum.value                  = CM_ARGB_MODE_SPECTRUM;
+    Spectrum.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Spectrum.color_mode             = MODE_COLORS_NONE;
+    Spectrum.speed_min              = CM_ARGB_SPEED_SLOWEST;
+    Spectrum.speed_max              = CM_ARGB_SPEED_FASTEST;
+    Spectrum.speed                  = CM_ARGB_SPEED_NORMAL;
+    Spectrum.brightness_min         = 0;
+    Spectrum.brightness_max         = CM_ARGB_BRIGHTNESS_MAX;
+    Spectrum.brightness             = CM_ARGB_BRIGHTNESS_MAX;
+    modes.push_back(Spectrum);
+
+    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
+    {
+        zones[zone_idx].modes.push_back(Spectrum);
+    }
+
+    mode FillFlow;
+    FillFlow.name                   = "Fill Flow";
+    FillFlow.value                  = CM_ARGB_MODE_FILLFLOW;
+    FillFlow.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    FillFlow.color_mode             = MODE_COLORS_NONE;
+    FillFlow.speed_min              = CM_ARGB_SPEED_SLOWEST;
+    FillFlow.speed_max              = CM_ARGB_SPEED_FASTEST;
+    FillFlow.speed                  = CM_ARGB_SPEED_NORMAL;
+    FillFlow.brightness_min         = 0;
+    FillFlow.brightness_max         = CM_ARGB_BRIGHTNESS_MAX;
+    FillFlow.brightness             = CM_ARGB_BRIGHTNESS_MAX;
+    modes.push_back(FillFlow);
+
+    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
+    {
+        zones[zone_idx].modes.push_back(FillFlow);
+    }
+
+    mode Rainbow;
+    Rainbow.name                    = "Rainbow";
+    Rainbow.value                   = CM_ARGB_MODE_RAINBOW;
+    Rainbow.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Rainbow.color_mode              = MODE_COLORS_NONE;
+    Rainbow.speed_min               = CM_ARGB_SPEED_SLOWEST;
+    Rainbow.speed_max               = CM_ARGB_SPEED_FASTEST;
+    Rainbow.speed                   = CM_ARGB_SPEED_NORMAL;
+    Rainbow.brightness_min          = 0;
+    Rainbow.brightness_max          = CM_ARGB_BRIGHTNESS_MAX;
+    Rainbow.brightness              = CM_ARGB_BRIGHTNESS_MAX;
+    modes.push_back(Rainbow);
+
+    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
+    {
+        zones[zone_idx].modes.push_back(Rainbow);
+    }
+
+    mode Static;
+    Static.name                     = "Static";
+    Static.value                    = CM_ARGB_MODE_STATIC;
+    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    Static.brightness_min           = 0;
+    Static.brightness_max           = CM_ARGB_BRIGHTNESS_MAX;
+    Static.brightness               = CM_ARGB_BRIGHTNESS_MAX;
+    Static.colors_min               = 1;
+    Static.colors_max               = 1;
+    Static.colors.resize(Static.colors_max);
+    modes.push_back(Static);
+
+    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
+    {
+        zones[zone_idx].modes.push_back(Static);
+    }
+
+    /*-----------------------------------------------------*\
+    | Define zone-specific modes for the RGB port           |
+    \*-----------------------------------------------------*/
+    mode RGBOff;
+    RGBOff.name                     = "Off";
+    RGBOff.value                    = CM_RGB_MODE_OFF;
+    RGBOff.color_mode               = MODE_COLORS_NONE;
+    zones[4].modes.push_back(RGBOff);
+
+    mode RGBMirage;
+    RGBMirage.name                  = "Mirage";
+    RGBMirage.value                 = CM_RGB_MODE_MIRAGE;
+    RGBMirage.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    RGBMirage.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    RGBMirage.speed_min             = CM_ARGB_SPEED_SLOWEST;
+    RGBMirage.speed_max             = CM_ARGB_SPEED_FASTEST;
+    RGBMirage.speed                 = CM_ARGB_SPEED_NORMAL;
+    RGBMirage.brightness_min        = 0;
+    RGBMirage.brightness_max        = CM_ARGB_BRIGHTNESS_MAX;
+    RGBMirage.brightness            = CM_ARGB_BRIGHTNESS_MAX;
+    RGBMirage.colors_min            = 1;
+    RGBMirage.colors_max            = 1;
+    RGBMirage.colors.resize(RGBMirage.colors_max);
+    zones[4].modes.push_back(RGBMirage);
+
+    mode RGBFlash;
+    RGBFlash.name                   = "Flash";
+    RGBFlash.value                  = CM_RGB_MODE_FLASH;
+    RGBFlash.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    RGBFlash.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    RGBFlash.speed_min              = CM_ARGB_SPEED_SLOWEST;
+    RGBFlash.speed_max              = CM_ARGB_SPEED_FASTEST;
+    RGBFlash.speed                  = CM_ARGB_SPEED_NORMAL;
+    RGBFlash.brightness_min         = 0;
+    RGBFlash.brightness_max         = CM_ARGB_BRIGHTNESS_MAX;
+    RGBFlash.brightness             = CM_ARGB_BRIGHTNESS_MAX;
+    RGBFlash.colors_min             = 1;
+    RGBFlash.colors_max             = 1;
+    RGBFlash.colors.resize(RGBFlash.colors_max);
+    zones[4].modes.push_back(RGBFlash);
+
+    mode RGBBreathing;
+    RGBBreathing.name               = "Breathing";
+    RGBBreathing.value              = CM_RGB_MODE_BREATHING;
+    RGBBreathing.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    RGBBreathing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    RGBBreathing.speed_min          = CM_ARGB_SPEED_SLOWEST;
+    RGBBreathing.speed_max          = CM_ARGB_SPEED_FASTEST;
+    RGBBreathing.speed              = CM_ARGB_SPEED_NORMAL;
+    RGBBreathing.brightness_min     = 0;
+    RGBBreathing.brightness_max     = CM_ARGB_BRIGHTNESS_MAX;
+    RGBBreathing.brightness         = CM_ARGB_BRIGHTNESS_MAX;
+    RGBBreathing.colors_min         = 1;
+    RGBBreathing.colors_max         = 1;
+    RGBBreathing.colors.resize(RGBBreathing.colors_max);
+    zones[4].modes.push_back(RGBBreathing);
+
+    mode RGBStatic;
+    RGBStatic.name                  = "Static";
+    RGBStatic.value                 = CM_RGB_MODE_STATIC;
+    RGBStatic.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    RGBStatic.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    RGBStatic.brightness_min        = 0;
+    RGBStatic.brightness_max        = CM_ARGB_BRIGHTNESS_MAX;
+    RGBStatic.brightness            = CM_ARGB_BRIGHTNESS_MAX;
+    RGBStatic.colors_min            = 1;
+    RGBStatic.colors_max            = 1;
+    RGBStatic.colors.resize(RGBStatic.colors_max);
+    zones[4].modes.push_back(RGBStatic);
 }
 
 void RGBController_CMARGBController::SetupZones()
 {
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Only set LED count on the first run                   |
+    \*-----------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
+    {
+        first_run = true;
+    }
+
+    /*-----------------------------------------------------*\
+    | Clear any existing color/LED configuration            |
+    \*-----------------------------------------------------*/
     leds.clear();
     colors.clear();
+    zones.resize(5);
 
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    /*-----------------------------------------------------*\
+    | Set up addressable zones                              |
+    \*-----------------------------------------------------*/
+    for(unsigned int channel_idx = 0; channel_idx < 4; channel_idx++)
     {
-        bool boolSingleLED = (zones[zone_idx].type == ZONE_TYPE_SINGLE);
+        zones[channel_idx].leds_min                 = 0;
+        zones[channel_idx].leds_max                 = 48;
 
-        if (!boolSingleLED)
+        if(first_run)
         {
-            controller->SetLedCount( std::stoi(zones[zone_idx].name), zones[zone_idx].leds_count);
+            zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
         }
 
-        for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
+        if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
         {
-            led     new_led;
-            unsigned int i = std::stoi(zones[zone_idx].name);
+            zones[channel_idx].name                 = "Addressable RGB Header ";
+            zones[channel_idx].name.append(std::to_string(channel_idx + 1));
+        }
 
-            if(boolSingleLED)
-            {
-                new_led.name  = i;
-                new_led.value = argb_header_data[i].header;
-            }
-            else
-            {
-                new_led.name = i;
-                new_led.name.append(" LED " + std::to_string(lp_idx));
-                new_led.value = argb_header_data[i].header;
-            }
+        if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
+        {
+            zones[channel_idx].leds_count           = 0;
+        }
+
+        if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
+        {
+            zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
+        }
+
+        if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
+        {
+            zones[channel_idx].matrix_map.width     = 0;
+            zones[channel_idx].matrix_map.height    = 0;
+            zones[channel_idx].matrix_map.map.resize(0);
+        }
+
+        for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
+        {
+            led new_led;
+            new_led.name            = zones[channel_idx].name;
+            new_led.name.append(", LED ");
+            new_led.name.append(std::to_string(led_ch_idx + 1));
+            new_led.value           = channel_idx;
 
             leds.push_back(new_led);
         }
     }
 
+    /*-----------------------------------------------------*\
+    | Set up RGB zone                                       |
+    \*-----------------------------------------------------*/
+    zones[4].name                   = "RGB Header";
+    zones[4].type                   = ZONE_TYPE_SINGLE;
+    zones[4].leds_min               = 1;
+    zones[4].leds_max               = 1;
+    zones[4].leds_count             = 1;
+
+    led new_led;
+    new_led.name                    = "RGB Header";
+    new_led.value                   = 4;
+    leds.push_back(new_led);
+
     SetupColors();
 }
 
-void RGBController_CMARGBController::DeviceResizeZone(int zone, int new_size)
+void RGBController_CMARGBController::DeviceConfigureZone(int zone_idx)
 {
-    if((size_t) zone >= zones.size())
+    if((size_t)zone_idx < zones.size())
     {
-        return;
-    }
-    uint8_t end_zone = last_zone(zone);
+        controller->SetPortLEDCount(zone_idx, zones[zone_idx].leds_count);
 
-    for(std::size_t zone_idx = first_zone(zone); zone_idx < end_zone; zone_idx++)
-    {
-        if(((unsigned int)new_size >= zones[zone_idx].leds_min) && ((unsigned int)new_size <= zones[zone_idx].leds_max))
-        {
-            zones[zone_idx].leds_count = new_size;
-        }
+        SetupZones();
     }
-
-    SetupZones();
 }
 
 void RGBController_CMARGBController::DeviceUpdateLEDs()
 {
-    uint8_t end_zone = last_zone(cmargb->GetZoneIndex());
-
-    for(int zone_idx = first_zone(cmargb->GetZoneIndex()); zone_idx < end_zone; zone_idx++)
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
-        DeviceUpdateZoneLEDs(zone_idx);
+        DeviceUpdateZoneLEDs((int)zone_idx);
     }
 }
 
 void RGBController_CMARGBController::DeviceUpdateZoneLEDs(int zone)
 {
-    controller->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
+    if(modes[active_mode].value != CM_ARGB_MODE_DIRECT)
+    {
+        return;
+    }
+
+    /*-----------------------------------------------------*\
+    | The RGB zone doesn't have a separate Direct mode, so  |
+    | use static mode with the per-LED color for it         |
+    \*-----------------------------------------------------*/
+    if(zone < 4)
+    {
+        controller->SetPortLEDsDirect(zone, zones[zone].colors, zones[zone].leds_count);
+    }
+    else
+    {
+        controller->SetPortMode(zone, CM_RGB_MODE_STATIC, 0, 255, false, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
+    }
 }
 
 void RGBController_CMARGBController::DeviceUpdateSingleLED(int led)
 {
-    DeviceUpdateZoneLEDs(GetLED_Zone(led));
+    unsigned int zone_idx = leds[led].value;
+
+    UpdateZoneLEDs(zone_idx);
 }
 
 void RGBController_CMARGBController::DeviceUpdateMode()
 {
-    bool     random_colours = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-    RGBColor colour         = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
-
-    controller->SetMode( modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, colour, random_colours );
+    /*-----------------------------------------------------*\
+    | Apply mode to all zones                               |
+    \*-----------------------------------------------------*/
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        DeviceUpdateZoneMode((int)zone_idx);
+    }
 }
 
-int RGBController_CMARGBController::GetLED_Zone(int led_idx)
+void RGBController_CMARGBController::DeviceUpdateZoneMode(int zone)
 {
-    /*---------------------------------------------------------*\
-    | This may be more useful in the abstract RGBController.cpp |
-    \*---------------------------------------------------------*/
-    for(int zone_idx = 0; zone_idx < (int)zones.size(); zone_idx++)
-    {
-        int zone_start  = zones[zone_idx].start_idx;
-        int zone_end    = zone_start + zones[zone_idx].leds_count - 1;
+    /*-----------------------------------------------------*\
+    | Determine the active mode for this zone               |
+    \*-----------------------------------------------------*/
+    bool            use_zone_mode       = false;
+    int             zone_active_mode    = active_mode;
+    int             zone_mode_value     = modes[active_mode].value;
 
-        if(zone_start <= led_idx && zone_end >= led_idx)
+    /*-----------------------------------------------------*\
+    | Set up mode parameters                                |
+    \*-----------------------------------------------------*/
+    bool            random              = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+    RGBColor        color               = 0;
+    unsigned int    brightness          = modes[active_mode].brightness;
+    unsigned int    speed               = modes[active_mode].speed;
+
+    if(modes[active_mode].colors.size() > 0)
+    {
+        color                           = modes[active_mode].colors[0];
+    }
+
+    if(!(modes[active_mode].flags & MODE_FLAG_REQUIRES_ENTIRE_DEVICE))
+    {
+        if(zones[zone].active_mode >= 0)
         {
-            return(zone_idx);
+            use_zone_mode               = true;
+            zone_active_mode            = zones[zone].active_mode;
+            zone_mode_value             = zones[zone].modes[zone_active_mode].value;
+
+            random                      = (zones[zone].modes[zone_active_mode].color_mode == MODE_COLORS_RANDOM);
+
+            if(zones[zone].modes[zone_active_mode].colors.size() > 0)
+            {
+                color                   = zones[zone].modes[zone_active_mode].colors[0];
+            }
+
+            brightness                  = zones[zone].modes[zone_active_mode].brightness;
+            speed                       = zones[zone].modes[zone_active_mode].speed;
         }
     }
 
-    return -1;
+    if((zone == 4) && !use_zone_mode)
+    {
+        /*-------------------------------------------------*\
+        | Map entire-device ARGB modes with the equivalent  |
+        | RGB modes for the RGB zone                        |
+        \*-------------------------------------------------*/
+        switch(modes[active_mode].value)
+        {
+            case CM_ARGB_MODE_SPECTRUM:
+            case CM_ARGB_MODE_FILLFLOW:
+            case CM_ARGB_MODE_RAINBOW:
+                zone_mode_value         = CM_RGB_MODE_MIRAGE;
+                random                  = true;
+                break;
+
+            case CM_ARGB_MODE_RELOAD:
+            case CM_ARGB_MODE_RECOIL:
+                zone_mode_value         = CM_RGB_MODE_FLASH;
+                break;
+
+            case CM_ARGB_MODE_BREATHING:
+                zone_mode_value         = CM_RGB_MODE_BREATHING;
+                break;
+
+            case CM_ARGB_MODE_REFILL:
+            case CM_ARGB_MODE_STATIC:
+                zone_mode_value         = CM_RGB_MODE_STATIC;
+                break;
+
+            case CM_ARGB_MODE_DEMO:
+                zone_mode_value         = CM_RGB_MODE_FLASH;
+                random                  = true;
+                break;
+
+            case CM_ARGB_MODE_OFF:
+            default:
+                zone_mode_value         = CM_RGB_MODE_OFF;
+                break;
+
+            case CM_ARGB_MODE_PASSTHRU:
+                zone_mode_value         = CM_RGB_MODE_PASSTHRU;
+                break;
+        }
+    }
+
+    controller->SetPortMode
+                    (
+                        zone,
+                        zone_mode_value,
+                        speed,
+                        brightness,
+                        random,
+                        RGBGetRValue(color),
+                        RGBGetGValue(color),
+                        RGBGetBValue(color)
+                    );
 }

Controllers/CoolerMasterController/CMARGBController/RGBController_CMARGBController.h

@@ -12,11 +12,8 @@
 #pragma once
 
 #include <vector>
-#include "RGBController.h"
 #include "CMARGBController.h"
-
-#define first_zone(zn)          ((zones.size() > 1) ? 1 : 0)
-#define last_zone(zn)           ((zones.size() > 1) ? 4 : 1)
+#include "RGBController.h"
 
 class RGBController_CMARGBController : public RGBController
 {
@@ -24,19 +21,19 @@ public:
     RGBController_CMARGBController(CMARGBController* controller_ptr);
     ~RGBController_CMARGBController();
 
+    void        SetupModes();
     void        SetupZones();
-    void        DeviceResizeZone(int zone, int new_size);
+
+    void        DeviceConfigureZone(int zone_idx);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);
     void        DeviceUpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
+    void        DeviceUpdateZoneMode(int zone);
 
 private:
-    void        Init_Controller();
-    int         GetDeviceMode();
-    int         GetLED_Zone(int led_idx);
-
-    CMARGBController*   controller;
+    CMARGBController*           controller;
+    std::vector<unsigned int>   leds_channel;
 };

Controllers/CoolerMasterController/CMARGBGen2A1Controller/RGBController_CMARGBGen2A1Controller.cpp

@@ -186,6 +186,8 @@ RGBController_CMARGBGen2A1Controller::RGBController_CMARGBGen2A1Controller(CMARG
 
 RGBController_CMARGBGen2A1Controller::~RGBController_CMARGBGen2A1Controller()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -218,10 +220,8 @@ void RGBController_CMARGBGen2A1Controller::SetupZones()
     SetupColors();
 }
 
-void RGBController_CMARGBGen2A1Controller::DeviceResizeZone(int zone, int new_size)
+void RGBController_CMARGBGen2A1Controller::DeviceConfigureZone(int zone_idx)
 {
-    zones[zone].leds_count = new_size;
-
     unsigned int total_leds = 0;
 
     for(unsigned int channel = 0; channel < CM_ARGB_GEN2_A1_CHANNEL_COUNT; channel++)
@@ -236,7 +236,7 @@ void RGBController_CMARGBGen2A1Controller::DeviceResizeZone(int zone, int new_si
         leds[i].name = "LED " + std::to_string(i + 1);
     }
 
-    controller->SetupZoneSize(zone, new_size);
+    controller->SetupZoneSize(zone_idx, zones[zone_idx].leds_count);
 
     SetupColors();
 }

Controllers/CoolerMasterController/CMARGBGen2A1Controller/RGBController_CMARGBGen2A1Controller.h

@@ -23,7 +23,7 @@ public:
     ~RGBController_CMARGBGen2A1Controller();
 
     void SetupZones();
-    void DeviceResizeZone(int zone, int new_size);
+    void DeviceConfigureZone(int zone_idx);
     void DeviceUpdateLEDs();
     void DeviceUpdateZoneLEDs(int zone);
     void UpdateSegmentLEDs(int zone, int subchannel);

Controllers/CoolerMasterController/CMGD160Controller/RGBController_CMGD160Controller.cpp

@@ -140,6 +140,8 @@ RGBController_CMGD160Controller::RGBController_CMGD160Controller(CMGD160Controll
 
 RGBController_CMGD160Controller::~RGBController_CMGD160Controller()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/CoolerMasterController/CMKeyboardController/RGBController_CMKeyboardController.cpp

@@ -49,6 +49,8 @@ RGBController_CMKeyboardController::RGBController_CMKeyboardController(CMKeyboar
 
 RGBController_CMKeyboardController::~RGBController_CMKeyboardController()
 {
+    Shutdown();
+
     if(m_pController)
     {
         delete m_pController;

Controllers/CoolerMasterController/CMMM711Controller/RGBController_CMMM711Controller.cpp

@@ -129,6 +129,8 @@ RGBController_CMMM711Controller::RGBController_CMMM711Controller(CMMM711Controll
 
 RGBController_CMMM711Controller::~RGBController_CMMM711Controller()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/CoolerMasterController/CMMM712Controller/RGBController_CMMM712Controller.cpp

@@ -122,6 +122,8 @@ RGBController_CMMM712Controller::RGBController_CMMM712Controller(CMMM712Controll
 
 RGBController_CMMM712Controller::~RGBController_CMMM712Controller()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/CoolerMasterController/CMMMController/RGBController_CMMMController.cpp

@@ -168,6 +168,8 @@ RGBController_CMMMController::RGBController_CMMMController(CMMMController* contr
 
 RGBController_CMMMController::~RGBController_CMMMController()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/CoolerMasterController/CMMP750Controller/RGBController_CMMP750Controller.cpp

@@ -93,6 +93,8 @@ RGBController_CMMP750Controller::RGBController_CMMP750Controller(CMMP750Controll
 
 RGBController_CMMP750Controller::~RGBController_CMMP750Controller()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/CoolerMasterController/CMMonitorController/RGBController_CMMonitorController.cpp

@@ -141,6 +141,8 @@ RGBController_CMMonitorController::RGBController_CMMonitorController(CMMonitorCo
 
 RGBController_CMMonitorController::~RGBController_CMMonitorController()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/CoolerMasterController/CMR6000Controller/RGBController_CMR6000Controller.cpp

@@ -152,6 +152,8 @@ RGBController_CMR6000Controller::RGBController_CMR6000Controller(CMR6000Controll
 
 RGBController_CMR6000Controller::~RGBController_CMR6000Controller()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/CoolerMasterController/CMRGBController/RGBController_CMRGBController.cpp

@@ -153,6 +153,8 @@ RGBController_CMRGBController::RGBController_CMRGBController(CMRGBController* co
 
 RGBController_CMRGBController::~RGBController_CMRGBController()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/CoolerMasterController/CMSmallARGBController/CMSmallARGBController.cpp

@@ -18,11 +18,10 @@ cm_small_argb_headers cm_small_argb_header_data[1] =
     { "CM Small ARGB",  0x01, true,  12 }
 };
 
-CMSmallARGBController::CMSmallARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx)
+CMSmallARGBController::CMSmallARGBController(hid_device* dev_handle, char *_path)
 {
     dev                     = dev_handle;
     location                = _path;
-    zone_index              = _zone_idx;
     current_speed           = CM_SMALL_ARGB_SPEED_NORMAL;
 
     /*---------------------------------------------------------*\
@@ -51,7 +50,7 @@ void CMSmallARGBController::GetStatus()
 {
     unsigned char buffer[CM_SMALL_ARGB_PACKET_SIZE]     = { 0x00, 0x80, 0x01, 0x01 };
     int buffer_size                                     = (sizeof(buffer) / sizeof(buffer[0]));
-    int header                                          = zone_index - 1;
+    int header                                          = 0 - 1;
 
     buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = header;
     buffer[CM_SMALL_ARGB_MODE_BYTE]                     = 0x01;
@@ -98,11 +97,6 @@ std::string CMSmallARGBController::GetLocation()
     return("HID: " + location);
 }
 
-unsigned char CMSmallARGBController::GetZoneIndex()
-{
-    return(zone_index);
-}
-
 unsigned char CMSmallARGBController::GetMode()
 {
     return(current_mode);
@@ -177,7 +171,7 @@ void CMSmallARGBController::SetLedsDirect(RGBColor* led_colours, unsigned int le
         colours.push_back( RGBGetBValue(colour) );
     }
 
-    buffer[CM_SMALL_ARGB_ZONE_BYTE]     = zone_index - 1; //argb_header_data[zone_index].header;
+    buffer[CM_SMALL_ARGB_ZONE_BYTE]     = 0 - 1; //argb_header_data[zone_index].header;
     buffer[CM_SMALL_ARGB_MODE_BYTE]     = led_count;
     unsigned char buffer_idx            = CM_SMALL_ARGB_MODE_BYTE + 1;
 
@@ -225,7 +219,7 @@ void CMSmallARGBController::SendUpdate()
 
     buffer[CM_SMALL_ARGB_COMMAND_BYTE]                  = 0x0b;
     buffer[CM_SMALL_ARGB_FUNCTION_BYTE]                 = (false) ? 0x01 : 0x02; //This controls custom mode TODO
-    buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = cm_small_argb_header_data[zone_index].header;
+    buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = cm_small_argb_header_data[0].header;
     buffer[CM_SMALL_ARGB_MODE_BYTE]                     = current_mode;
     buffer[CM_SMALL_ARGB_SPEED_BYTE]                    = current_speed;
     buffer[CM_SMALL_ARGB_COLOUR_INDEX_BYTE]             = (bool_random) ? 0x00 : 0x10; //This looks to still be the colour index and controls random colours

Controllers/CoolerMasterController/CMSmallARGBController/CMSmallARGBController.h

@@ -74,14 +74,13 @@ enum
 class CMSmallARGBController
 {
 public:
-    CMSmallARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx);
+    CMSmallARGBController(hid_device* dev_handle, char *_path);
     ~CMSmallARGBController();
 
     std::string         GetDeviceName();
     std::string         GetSerial();
     std::string         GetLocation();
 
-    unsigned char       GetZoneIndex();
     unsigned char       GetMode();
     unsigned char       GetLedRed();
     unsigned char       GetLedGreen();
@@ -97,7 +96,6 @@ private:
     std::string         location;
     hid_device*         dev;
 
-    unsigned char       zone_index;
     unsigned char       current_mode;
     unsigned char       current_speed;
 

Controllers/CoolerMasterController/CMSmallARGBController/RGBController_CMSmallARGBController.cpp

@@ -29,7 +29,7 @@ RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmall
     controller                  = controller_ptr;
     unsigned char speed         = controller->GetLedSpeed();
 
-    name                        = cm_small_argb_header_data[controller->GetZoneIndex()].name;
+    name                        = cm_small_argb_header_data[0].name;
     vendor                      = "Cooler Master";
     type                        = DEVICE_TYPE_LEDSTRIP;
     description                 = controller->GetDeviceName();
@@ -152,7 +152,6 @@ RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmall
     PassThru.color_mode         = MODE_COLORS_NONE;
     modes.push_back(PassThru);
 
-    Init_Controller();         //Only processed on first run
     SetupZones();
 
     int temp_mode               = controller->GetMode();
@@ -181,60 +180,75 @@ RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmall
 
 RGBController_CMSmallARGBController::~RGBController_CMSmallARGBController()
 {
+    Shutdown();
+
     delete controller;
 }
 
-void RGBController_CMSmallARGBController::Init_Controller()
-{
-    int zone_idx            = controller->GetZoneIndex();
-    int zone_led_count      = cm_small_argb_header_data[zone_idx].count;
-    bool boolSingleLED      = ( zone_led_count == 1 );          //If argb_header_data[zone_idx].count == 1 then the zone is ZONE_TYPE_SINGLE
-
-    zone ARGB_zone;
-    ARGB_zone.name          = std::to_string(zone_idx);
-    ARGB_zone.type          = (boolSingleLED) ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
-    ARGB_zone.leds_min      = CM_SMALL_ARGB_MIN_LEDS;
-    ARGB_zone.leds_max      = CM_SMALL_ARGB_MAX_LEDS;
-    ARGB_zone.leds_count    = zone_led_count;
-    zones.push_back(ARGB_zone);
-}
-
 void RGBController_CMSmallARGBController::SetupZones()
 {
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Only set LED count on the first run                   |
+    \*-----------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
+    {
+        first_run = true;
+    }
+
+    /*-----------------------------------------------------*\
+    | Clear any existing color/LED configuration            |
+    \*-----------------------------------------------------*/
     leds.clear();
     colors.clear();
+    zones.resize(1);
 
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Set up zones and LEDs                                 |
+    \*-----------------------------------------------------*/
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
-        bool boolSingleLED = (zones[zone_idx].type == ZONE_TYPE_SINGLE);    //Calculated for later use
+        zones[zone_idx].leds_min                    = 0;
+        zones[zone_idx].leds_max                    = CM_SMALL_ARGB_MAX_LEDS;
 
-        if (!boolSingleLED)
+        if(first_run)
         {
-            controller->SetLedCount(cm_small_argb_header_data[zone_idx].header, zones[zone_idx].leds_count);
+            zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
+        }
+
+        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
+        {
+            zones[zone_idx].name                    = "Addressable RGB Header";
+            zones[zone_idx].name.append(std::to_string(zone_idx + 1));
+        }
+
+        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
+        {
+            zones[zone_idx].leds_count              = 0;
+        }
+
+        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
+        {
+            zones[zone_idx].type                    = ZONE_TYPE_LINEAR;
+        }
+
+        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
+        {
+            zones[zone_idx].matrix_map.width        = 0;
+            zones[zone_idx].matrix_map.height       = 0;
+            zones[zone_idx].matrix_map.map.resize(0);
         }
 
         for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
         {
-            led     new_led;
-            unsigned int i = std::stoi(zones[zone_idx].name);
-
-            if(boolSingleLED)
-            {
-                new_led.name  = i;
-                new_led.value = cm_small_argb_header_data[i].header;
-            }
-            else
-            {
-                new_led.name = i;
-                new_led.name.append(" LED " + std::to_string(lp_idx));
-                new_led.value = cm_small_argb_header_data[i].header;
-            }
+            led new_led;
+            new_led.name                            = zones[zone_idx].name;
+            new_led.name.append(", LED " + std::to_string(lp_idx));
 
             leds.push_back(new_led);
         }
@@ -243,16 +257,11 @@ void RGBController_CMSmallARGBController::SetupZones()
     SetupColors();
 }
 
-void RGBController_CMSmallARGBController::DeviceResizeZone(int zone, int new_size)
+void RGBController_CMSmallARGBController::DeviceConfigureZone(int zone_idx)
 {
-    if((size_t) zone >= zones.size())
+    if((size_t)zone_idx < zones.size())
     {
-        return;
-    }
-
-    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
-    {
-        zones[zone].leds_count = new_size;
+        controller->SetLedCount(cm_small_argb_header_data[zone_idx].header, zones[zone_idx].leds_count);
 
         SetupZones();
     }

Controllers/CoolerMasterController/CMSmallARGBController/RGBController_CMSmallARGBController.h

@@ -27,7 +27,7 @@ public:
     ~RGBController_CMSmallARGBController();
 
     void        SetupZones();
-    void        DeviceResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -91,19 +91,19 @@ DetectedControllers DetectCoolerMasterARGB(hid_device_info* info, const std::str
 
     if(dev)
     {
-        /*-------------------------------------------------*\
-        | Create mutex to prevent the controllers sharing a |
-        |   receiver from interfering with each other       |
-        \*-------------------------------------------------*/
-        std::shared_ptr<std::mutex>       cm_mutex = std::make_shared<std::mutex>();
+        CMARGBController*                   controller     = new CMARGBController(dev, info->path);
 
-        for(unsigned char i = 0; i < CM_ARGB_HEADER_DATA_SIZE; i++)
+        if(controller->GetVersion() != "Unsupported")
         {
-            CMARGBController*               controller     = new CMARGBController(dev, info->path, i, cm_mutex);
             RGBController_CMARGBController* rgb_controller = new RGBController_CMARGBController(controller);
 
             detected_controllers.push_back(rgb_controller);
         }
+        else
+        {
+            LOG_ERROR("[CMARGBController] Unsupported firmware version");
+            delete controller;
+        }
     }
 
     return(detected_controllers);
@@ -326,7 +326,7 @@ DetectedControllers DetectCoolerMasterSmallARGB(hid_device_info* info, const std
 
     if(dev)
     {
-        CMSmallARGBController*               controller     = new CMSmallARGBController(dev, info->path, 0);
+        CMSmallARGBController*               controller     = new CMSmallARGBController(dev, info->path);
         RGBController_CMSmallARGBController* rgb_controller = new RGBController_CMSmallARGBController(controller);
 
         detected_controllers.push_back(rgb_controller);

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.cpp

@@ -51,56 +51,99 @@ static unsigned int matrix_map24[11][11] =
 
 RGBController_CorsairCommanderCore::RGBController_CorsairCommanderCore(CorsairCommanderCoreController* controller_ptr)
 {
-    controller  = controller_ptr;
+    controller          = controller_ptr;
 
-    name        = controller->GetNameString();
-    vendor      = "Corsair";
-    description = "Corsair Commander Core Device";
-    version     = controller->GetFirmwareString();
-    type        = DEVICE_TYPE_COOLER;
-    location    = controller->GetLocationString();
-    SetupZones();
+    name                = controller->GetNameString();
+    vendor              = "Corsair";
+    description         = "Corsair Commander Core Device";
+    version             = controller->GetFirmwareString();
+    type                = DEVICE_TYPE_COOLER;
+    location            = controller->GetLocationString();
 
     mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name         = "Direct";
+    Direct.value        = 0;
+    Direct.flags        = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode   = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
+
+    SetupZones();
 }
 
 RGBController_CorsairCommanderCore::~RGBController_CorsairCommanderCore()
 {
+    Shutdown();
+
     delete controller;
 }
 
 void RGBController_CorsairCommanderCore::SetupZones()
 {
-    std::atomic<bool> first_run;
-    first_run = 0;
+    /*-----------------------------------------------------*\
+    | Only set LED count on the first run                   |
+    \*-----------------------------------------------------*/
+    bool first_run = false;
 
     if(zones.size() == 0)
     {
-        first_run = 1;
+        first_run = true;
     }
 
-    std::vector<unsigned short int> led_count = controller->GetLedCounts();
+    /*-----------------------------------------------------*\
+    | Clear any existing color/LED configuration            |
+    \*-----------------------------------------------------*/
+    leds.clear();
+    colors.clear();
     zones.resize(7);
+
+    /*-----------------------------------------------------*\
+    | Set up zones                                          |
+    \*-----------------------------------------------------*/
+    std::vector<unsigned short int> led_count = controller->GetLedCounts();
+
     if(controller->GetPidInt() == CORSAIR_COMMANDER_CORE_XT_PID)
     {
-        zones[0].name                   = "External RGB Port";
-        zones[0].type                   = ZONE_TYPE_LINEAR;
-        zones[0].leds_min               = zones[0].leds_min;
-        zones[0].leds_max               = 204;
-        zones[0].leds_count             = zones[0].leds_count;
+        zones[0].leds_min                           = 0;
+        zones[0].leds_max                           = 204;
+
+        if(first_run)
+        {
+            zones[0].flags                          = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
+        }
+
+        if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
+        {
+            zones[0].name                           = "Corsair RGB Header";
+        }
+
+        if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
+        {
+            zones[0].leds_count                     = 0;
+        }
+
+        if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
+        {
+            zones[0].type                           = ZONE_TYPE_LINEAR;
+        }
+
+        if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
+        {
+            zones[0].matrix_map.width               = 0;
+            zones[0].matrix_map.height              = 0;
+            zones[0].matrix_map.map.resize(0);
+        }
     }
     else
     {
-        zones[0].name                   = "Pump";
-        zones[0].type                   = ZONE_TYPE_MATRIX;
-        zones[0].leds_min               = led_count.at(0);
-        zones[0].leds_max               = led_count.at(0);
-        zones[0].leds_count             = led_count.at(0);
+        zones[0].name                               = "Pump";
+        zones[0].type                               = ZONE_TYPE_MATRIX;
+        zones[0].leds_min                           = led_count.at(0);
+        zones[0].leds_max                           = led_count.at(0);
+        zones[0].leds_count                         = led_count.at(0);
 
         if(led_count.at(0) == 24)
         {
@@ -112,28 +155,52 @@ void RGBController_CorsairCommanderCore::SetupZones()
         }
     }
 
-    for(unsigned int i = 1; i < (CORSAIR_COMMANDER_CORE_NUM_CHANNELS + 1); i++)
+    for(unsigned int zone_idx = 1; zone_idx < (CORSAIR_COMMANDER_CORE_NUM_CHANNELS + 1); zone_idx++)
     {
-        zones[i].name               = "RGB Port " + std::to_string(i);
-        zones[i].type               = ZONE_TYPE_LINEAR;
-        zones[i].leds_min           = 0;
-        zones[i].leds_max           = 34;
+        zones[zone_idx].leds_min                    = 0;
+        zones[zone_idx].leds_max                    = 34;
 
         if(first_run)
         {
-            zones[i].leds_count     = (led_count.size() > i) ? led_count.at(i) : 0;
+            zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
+        }
+
+        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
+        {
+            zones[zone_idx].name                    = "Corsair Fan Header " + std::to_string(zone_idx);
+        }
+
+        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
+        {
+            zones[zone_idx].leds_count              = 0;
+        }
+
+        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
+        {
+            zones[zone_idx].type                    = ZONE_TYPE_LINEAR;
+        }
+
+        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
+        {
+            zones[zone_idx].matrix_map.width        = 0;
+            zones[zone_idx].matrix_map.height       = 0;
+            zones[zone_idx].matrix_map.map.resize(0);
         }
     }
 
-    leds.clear();
-    colors.clear();
-
+    /*-----------------------------------------------------*\
+    | Set up LEDs                                           |
+    \*-----------------------------------------------------*/
     for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
         for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
         {
             led new_led;
-            new_led.name            = zones[zone_idx].name + " LED " + std::to_string(led_idx+1);
+            new_led.name            = zones[zone_idx].name + ", LED " + std::to_string(led_idx+1);
 
             leds.push_back(new_led);
         }
@@ -142,28 +209,23 @@ void RGBController_CorsairCommanderCore::SetupZones()
     SetupColors();
 }
 
-void RGBController_CorsairCommanderCore::DeviceResizeZone(int zone, int new_size)
+void RGBController_CorsairCommanderCore::DeviceConfigureZone(int zone_idx)
 {
-    if((size_t) zone >= zones.size())
+    if((size_t)zone_idx < zones.size())
     {
-        return;
-    }
-
-    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
-    {
-        zones[zone].leds_count = new_size;
-        if(zone == 0 && controller->GetPidInt() == CORSAIR_COMMANDER_CORE_XT_PID)
+        if(zone_idx == 0 && controller->GetPidInt() == CORSAIR_COMMANDER_CORE_XT_PID)
         {
-            if(new_size > 0)
+            if(zones[zone_idx].leds_count > 0)
             {
                 controller->SetFanMode(true);
-                controller->SetLedAmount(new_size);
+                controller->SetLedAmount(zones[zone_idx].leds_count);
             }
             else
             {
                 controller->SetFanMode(false);
             }
         }
+
         SetupZones();
     }
 }

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.h

@@ -22,7 +22,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);
     void        DeviceUpdateSingleLED(int led);

Controllers/CorsairDRAMController/CorsairDRAMController.cpp

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

Controllers/CorsairDRAMController/CorsairDRAMController.h

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

Controllers/CorsairDRAMController/CorsairDRAMControllerDetect.cpp

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

Controllers/CorsairDRAMController/CorsairDRAMDevices.cpp

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

Controllers/CorsairDRAMController/CorsairDRAMDevices.h

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

Controllers/CorsairDRAMController/RGBController_CorsairDRAM.cpp

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

Controllers/CorsairDRAMController/RGBController_CorsairDRAM.h

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

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumController.cpp

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

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumController.h

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

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumControllerDetect.cpp

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

Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.cpp

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

Controllers/CorsairHydro2Controller/RGBController_CorsairHydro2.cpp

@@ -44,6 +44,8 @@ RGBController_CorsairHydro2::RGBController_CorsairHydro2(CorsairHydro2Controller
 
 RGBController_CorsairHydro2::~RGBController_CorsairHydro2()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/CorsairHydroController/RGBController_CorsairHydro.cpp

@@ -84,6 +84,8 @@ RGBController_CorsairHydro::RGBController_CorsairHydro(CorsairHydroController* c
 
 RGBController_CorsairHydro::~RGBController_CorsairHydro()
 {
+    Shutdown();
+
     delete controller;
 }
 

Controllers/CorsairHydroPlatinumController/RGBController_CorsairHydroPlatinum.cpp

@@ -51,55 +51,101 @@ RGBController_CorsairHydroPlatinum::RGBController_CorsairHydroPlatinum(CorsairHy
     Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
-    Init_Controller();
     SetupZones();
 }
 
 RGBController_CorsairHydroPlatinum::~RGBController_CorsairHydroPlatinum()
 {
+    Shutdown();
+
     delete controller;
 }
 
-void RGBController_CorsairHydroPlatinum::Init_Controller()
-{
-    zone cpu_block_zone;
-    cpu_block_zone.name               = "CPU Block";
-    cpu_block_zone.type               = ZONE_TYPE_MATRIX;
-    cpu_block_zone.leds_min           = 16;
-    cpu_block_zone.leds_max           = 16;
-    cpu_block_zone.leds_count         = 16;
-    cpu_block_zone.matrix_map.Set(5, 5, (unsigned int *)&matrix_map);
-    zones.push_back(cpu_block_zone);
-
-    /*-----------------------------------------------------*\
-    | If the device is RGB fan-capable, set up fan zones.   |
-    \*-----------------------------------------------------*/
-    if(controller->HaveRgbFan())
-    {
-        zone fans_zone;
-        fans_zone.name       = "Fans";
-        fans_zone.type       = ZONE_TYPE_LINEAR;
-        fans_zone.leds_min   = 0;
-        fans_zone.leds_max   = 32;
-        fans_zone.leds_count = 0;
-        zones.push_back(fans_zone);
-    }
-}
-
 void RGBController_CorsairHydroPlatinum::SetupZones()
 {
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Only set LED count on the first run                   |
+    \*-----------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
+    {
+        first_run = true;
+    }
+
+    /*-----------------------------------------------------*\
+    | Clear any existing color/LED configuration            |
+    \*-----------------------------------------------------*/
     leds.clear();
     colors.clear();
+    if(controller->HaveRgbFan())
+    {
+        zones.resize(2);
+    }
+    else
+    {
+        zones.resize(1);
+    }
 
+    /*-----------------------------------------------------*\
+    | Set up zones                                          |
+    \*-----------------------------------------------------*/
+    zones[0].name                           = "CPU Block";
+    zones[0].type                           = ZONE_TYPE_MATRIX;
+    zones[0].leds_min                       = 16;
+    zones[0].leds_max                       = 16;
+    zones[0].leds_count                     = 16;
+    zones[0].matrix_map.Set(5, 5, (unsigned int *)&matrix_map);
+
+    /*-----------------------------------------------------*\
+    | If the device is RGB fan-capable, set up fan zone.    |
+    \*-----------------------------------------------------*/
+    if(controller->HaveRgbFan())
+    {
+        zones[1].leds_min                   = 0;
+        zones[1].leds_max                   = 32;
+
+        if(first_run)
+        {
+            zones[1].flags                  = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
+                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
+                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
+                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
+        }
+
+        if(!(zones[1].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
+        {
+            zones[1].name                   = "Corsair Fan Header";
+        }
+
+        if(!(zones[1].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
+        {
+            zones[1].leds_count             = 0;
+        }
+
+        if(!(zones[1].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
+        {
+            zones[1].type                   = ZONE_TYPE_LINEAR;
+        }
+
+        if(!(zones[1].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
+        {
+            zones[1].matrix_map.width       = 0;
+            zones[1].matrix_map.height      = 0;
+            zones[1].matrix_map.map.resize(0);
+        }
+    }
+
+    /*-----------------------------------------------------*\
+    | Set up LEDs                                           |
+    \*-----------------------------------------------------*/
     for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
         for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
         {
             led new_led;
-            new_led.name = zones[zone_idx].name + " " + std::to_string(led_idx);;
+            new_led.name = zones[zone_idx].name + ", LED " + std::to_string(led_idx);;
             leds.push_back(new_led);
         }
     }
@@ -107,17 +153,10 @@ void RGBController_CorsairHydroPlatinum::SetupZones()
     SetupColors();
 }
 
-void RGBController_CorsairHydroPlatinum::DeviceResizeZone(int zone, int new_size)
+void RGBController_CorsairHydroPlatinum::DeviceConfigureZone(int zone_idx)
 {
-    if((size_t) zone >= zones.size())
+    if((size_t)zone_idx < zones.size())
     {
-        return;
-    }
-
-    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
-    {
-        zones[zone].leds_count = new_size;
-
         SetupZones();
     }
 }

Controllers/CorsairHydroPlatinumController/RGBController_CorsairHydroPlatinum.h

@@ -23,7 +23,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);