Move HID detector calls to RunHIDDetector/RunHIDWrappedDetector functions and return controller list from detector functions

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -10,47 +10,52 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-/*-----------------------------------------------------*\
-| OpenRGB includes                                      |
-\*-----------------------------------------------------*/
 #include <hidapi.h>
+#include "BloodyB820RController.h"
+#include "BloodyMouseController.h"
 #include "DetectionManager.h"
-
-/*-----------------------------------------------------*\
-| A4 Tech specific includes                             |
-\*-----------------------------------------------------*/
-#include "RGBController_BloodyMouse.h"
 #include "RGBController_BloodyB820R.h"
+#include "RGBController_BloodyMouse.h"
 
-/*-----------------------------------------------------*\
-| A4 Tech USB vendor ID                                 |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| A4 Tech USB vendor ID                                     |
+\*---------------------------------------------------------*/
 #define A4_TECH_VID                                 0x09DA
 
-void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectA4TechMouseControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
-        BloodyMouseController* controller           = new BloodyMouseController(dev, info->path, info->product_id, name);
+        BloodyMouseController*     controller       = new BloodyMouseController(dev, info->path, info->product_id, name);
         RGBController_BloodyMouse* rgb_controller   = new RGBController_BloodyMouse(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectBloodyB820R(hid_device_info* info, const std::string& name)
+DetectedControllers DetectBloodyB820R(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path, name);
         RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);

Controllers/AMBXController/AMBXControllerDetect.cpp

@@ -7,8 +7,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
 #include "AMBXController.h"
+#include "DetectionManager.h"
 #include "RGBController.h"
 #include "RGBController_AMBX.h"
 
@@ -18,66 +18,60 @@
 #include <libusb.h>
 #endif
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAMBXControllers                                                                  *
-*                                                                                          *
-*       Detect Philips amBX Gaming devices                                                 *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAMBXControllers()
+DetectedControllers DetectAMBXControllers()
 {
-    libusb_context* ctx = NULL;
+    DetectedControllers detected_controllers;
+    libusb_context*     ctx = NULL;
 
-    if(libusb_init(&ctx) < 0)
+    if(libusb_init(&ctx) >= 0)
     {
-        return;
-    }
+        libusb_device** devs;
+        ssize_t num_devs = libusb_get_device_list(ctx, &devs);
 
-    libusb_device** devs;
-    ssize_t num_devs = libusb_get_device_list(ctx, &devs);
-
-    if(num_devs <= 0)
-    {
-        libusb_exit(ctx);
-        return;
-    }
-
-    for(ssize_t i = 0; i < num_devs; i++)
-    {
-        libusb_device* dev = devs[i];
-        libusb_device_descriptor desc;
-
-        if(libusb_get_device_descriptor(dev, &desc) != 0)
+        if(num_devs > 0)
         {
-            continue;
+            for(ssize_t i = 0; i < num_devs; i++)
+            {
+                libusb_device* dev = devs[i];
+                libusb_device_descriptor desc;
+
+                if(libusb_get_device_descriptor(dev, &desc) != 0)
+                {
+                    continue;
+                }
+
+                if(desc.idVendor == AMBX_VID && desc.idProduct == AMBX_PID)
+                {
+                    uint8_t bus = libusb_get_bus_number(dev);
+                    uint8_t address = libusb_get_device_address(dev);
+                    char device_path[32];
+                    snprintf(device_path, sizeof(device_path), "%d-%d", bus, address);
+
+                    // Use the AMBXController to handle opening and initializing
+                    AMBXController* controller = new AMBXController(device_path);
+
+                    if(controller->IsInitialized())
+                    {
+                        RGBController_AMBX* rgb_controller = new RGBController_AMBX(controller);
+                        detected_controllers.push_back(rgb_controller);
+                    }
+                    else
+                    {
+                        delete controller;
+                    }
+                }
+            }
+
+            libusb_free_device_list(devs, 1);
+            libusb_exit(ctx);
         }
-
-        if(desc.idVendor == AMBX_VID && desc.idProduct == AMBX_PID)
+        else
         {
-            uint8_t bus = libusb_get_bus_number(dev);
-            uint8_t address = libusb_get_device_address(dev);
-            char device_path[32];
-            snprintf(device_path, sizeof(device_path), "%d-%d", bus, address);
-
-            // Use the AMBXController to handle opening and initializing
-            AMBXController* controller = new AMBXController(device_path);
-
-            if(controller->IsInitialized())
-            {
-                RGBController_AMBX* rgb_controller = new RGBController_AMBX(controller);
-                DetectionManager::get()->RegisterRGBController(rgb_controller);
-            }
-            else
-            {
-                delete controller;
-            }
+            libusb_exit(ctx);
         }
     }
 
-    libusb_free_device_list(devs, 1);
-    libusb_exit(ctx);
+    return(detected_controllers);
 }
 
 REGISTER_DETECTOR("Philips amBX", DetectAMBXControllers);

Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp

@@ -10,8 +10,8 @@
 \*---------------------------------------------------------*/
 
 #include <hidapi.h>
-#include "DetectionManager.h"
 #include "AMDWraithPrismController.h"
+#include "DetectionManager.h"
 #include "RGBController_AMDWraithPrism.h"
 
 /*---------------------------------------------------------*\
@@ -24,25 +24,22 @@
 \*---------------------------------------------------------*/
 #define AMD_WRAITH_PRISM_PID                        0x0051
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAMDWraithPrismControllers                                                        *
-*                                                                                          *
-*       Tests the USB address to see if an AMD Wraith Prism controller exists there.       *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
+DetectedControllers DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AMDWraithPrismController*     controller     = new AMDWraithPrismController(dev, info->path);
         RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IP("AMD Wraith Prism", DetectAMDWraithPrismControllers, AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID, 1, 0xFF00);

Controllers/AOCKeyboardController/AOCKeyboardControllerDetect.cpp

@@ -13,32 +13,29 @@
 #include "AOCKeyboardController.h"
 #include "RGBController_AOCKeyboard.h"
 
-/*-----------------------------------------------------*\
-| AOC Keyboard IDs                                      |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| AOC Keyboard IDs                                          |
+\*---------------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GK500_PID                               0x1178
 #define AOC_GK500_PID_2                             0x1229
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCKeyboardControllers                                                           *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Keyboard controller exists there.           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AOCKeyboardController*     controller     = new AOCKeyboardController(dev, info->path, name);
         RGBController_AOCKeyboard* rgb_controller = new RGBController_AOCKeyboard(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID,   0xFF19, 0xFF19);

Controllers/AOCMouseController/AOCMouseControllerDetect.cpp

@@ -13,31 +13,28 @@
 #include "AOCMouseController.h"
 #include "RGBController_AOCMouse.h"
 
-/*-----------------------------------------------------*\
-| AOC Mouse IDs                                         |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| AOC Mouse IDs                                             |
+\*---------------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GM500_PID                               0x1179
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCMouseControllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Mouse controller exists there.              *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCMouseControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAOCMouseControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AOCMouseController*     controller     = new AOCMouseController(dev, info->path, name);
         RGBController_AOCMouse* rgb_controller = new RGBController_AOCMouse(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("AOC GM500",  DetectAOCMouseControllers,  AOC_VID,    AOC_GM500_PID,  1,  0xFF19, 0xFF19);

Controllers/AOCMousematController/AOCMousematControllerDetect.cpp

@@ -13,31 +13,28 @@
 #include "AOCMousematController.h"
 #include "RGBController_AOCMousemat.h"
 
-/*-----------------------------------------------------*\
-| AOC Mousemat IDs                                      |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| AOC Mousemat IDs                                          |
+\*---------------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_AMM700_PID                              0x1162
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCMousematControllers                                                           *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Mousemat controller exists there.           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCMousematControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAOCMousematControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AOCMousematController*     controller     = new AOCMousematController(dev, info->path, name);
         RGBController_AOCMousemat* rgb_controller = new RGBController_AOCMousemat(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("AOC AGON AMM700",    DetectAOCMousematControllers,   AOC_VID,    AOC_AMM700_PID, 1,  0xFF19,  0xFF19);

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBControllerDetect.cpp

@@ -11,8 +11,8 @@
 \*---------------------------------------------------------*/
 
 #include <hidapi.h>
-#include "DetectionManager.h"
 #include "ASRockPolychromeUSBController.h"
+#include "DetectionManager.h"
 #include "RGBController_ASRockPolychromeUSB.h"
 
 /*---------------------------------------------------------*\
@@ -26,16 +26,22 @@
 #define ASROCK_MOTHERBOARD_1_PID                    0x01A2
 #define ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID   0x01A6
 
-void DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*name*/)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         PolychromeUSBController*     controller     = new PolychromeUSBController(dev, info->path);
         RGBController_PolychromeUSB* rgb_controller = new RGBController_PolychromeUSB(controller);
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR("ASRock Polychrome USB",                  DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);

Controllers/ASRockSMBusController/ASRockSMBusControllerDetect.cpp

@@ -22,15 +22,6 @@
 #include "i2c_smbus.h"
 #include "pci_ids.h"
 
-/*******************************************************************************************\
-*                                                                                           *
-*   TestForPolychromeSMBusController                                                        *
-*                                                                                           *
-*       Tests the given address to see if an ASRock RGB controller exists there.            *
-*       First does a quick write to test for a response                                     *
-*                                                                                           *
-\*******************************************************************************************/
-
 #define ASROCK_DETECTOR_NAME        "ASRock SMBus Detectector"
 #define VENDOR_NAME                 "ASRock"
 #define SMBUS_ADDRESS               0x6A
@@ -67,7 +58,7 @@ bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, uint8_t address)
 
     return(pass);
 
-}   /* TestForPolychromeController() */
+}
 
 uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
 {
@@ -94,20 +85,10 @@ uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
     }
 }
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectPolychromeControllers                                                            *
-*                                                                                          *
-*       Detect ASRock Polychrome RGB SMBus controllers on the enumerated I2C busses at     *
-*       address 0x6A.                                                                      *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Polychrome device is connected      *
-*           dev - I2C address of Polychrome device                                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
+DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
 {
+    DetectedControllers detected_controllers;
+
     for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
@@ -123,7 +104,7 @@ void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
                     u16_to_u8 version;
                     version.u16 = GetFirmwareVersion(busses[bus], SMBUS_ADDRESS);
 
-                    switch (version.msb)
+                    switch(version.msb)
                     {
                         case ASROCK_TYPE_ASRLED:
                             {
@@ -131,7 +112,7 @@ void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
                                 ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(busses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockASRRGBSMBus* rgb_controller = new RGBController_ASRockASRRGBSMBus(controller);
-                                DetectionManager::get()->RegisterRGBController(rgb_controller);
+                                detected_controllers.push_back(rgb_controller);
                             }
                             break;
 
@@ -141,7 +122,7 @@ void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
                                 ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(busses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockPolychromeV1SMBus* rgb_controller = new RGBController_ASRockPolychromeV1SMBus(controller);
-                                DetectionManager::get()->RegisterRGBController(rgb_controller);
+                                detected_controllers.push_back(rgb_controller);
                             }
                             break;
 
@@ -151,7 +132,7 @@ void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
                                 ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(busses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockPolychromeV2SMBus* rgb_controller = new RGBController_ASRockPolychromeV2SMBus(controller);
-                                DetectionManager::get()->RegisterRGBController(rgb_controller);
+                                detected_controllers.push_back(rgb_controller);
                             }
                             break;
 
@@ -172,6 +153,7 @@ void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
         }
     }
 
-}   /* DetectSMBusPolychromeControllers() */
+    return(detected_controllers);
+}
 
 REGISTER_I2C_DETECTOR("ASRock Motherboard SMBus Controllers", DetectASRockSMBusControllers);

Controllers/AlienwareController/AlienwareControllerDetect.cpp

@@ -7,8 +7,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
 #include "AlienwareController.h"
+#include "DetectionManager.h"
 #include "RGBController_Alienware.h"
 
 /*---------------------------------------------------------*\
@@ -22,17 +22,22 @@
 #define ALIENWARE_G_SERIES_PID1                      0x0550
 #define ALIENWARE_G_SERIES_PID2                      0x0551
 
-void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAlienwareControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AlienwareController*     controller     = new AlienwareController(dev, *info, name);
         RGBController_Alienware* rgb_controller = new RGBController_Alienware(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID1);

Controllers/AlienwareKeyboardController/AlienwareKeyboardControllerDetect.cpp

@@ -9,54 +9,57 @@
 
 #include <hidapi.h>
 #include "DetectionManager.h"
-#include "AlienwareAW510KController.h"
 #include "AlienwareAW410KController.h"
-#include "RGBController_AlienwareAW510K.h"
+#include "AlienwareAW510KController.h"
 #include "RGBController_AlienwareAW410K.h"
+#include "RGBController_AlienwareAW510K.h"
 
-/*-----------------------------------------------------*\
-| Alienware vendor ID                                   |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Alienware vendor ID                                       |
+\*---------------------------------------------------------*/
 #define ALIENWARE_VID                           0x04F2
 
-/*-----------------------------------------------------*\
-| Keyboard product IDs                                  |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+\*---------------------------------------------------------*/
 #define ALIENWARE_AW510K_PID                    0x1830
 #define ALIENWARE_AW410K_PID                    0x1968
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAlienwareKeyboardControllers                                                     *
-*                                                                                          *
-*       Tests the USB address to see if a Alienware RGB Keyboard controller exists there.  *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
     {
         AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path, name);
         RGBController_AlienwareAW510K* rgb_controller = new RGBController_AlienwareAW510K(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
     {
         AlienwareAW410KController*     controller     = new AlienwareAW410KController(dev, info->path, name);
         RGBController_AlienwareAW410K* rgb_controller = new RGBController_AlienwareAW410K(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-}/* DetectAlienwareKeyboardControllers() */
 
+    return(detected_controllers);
+}
 
 REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);
 REGISTER_HID_DETECTOR_IPU("Alienware AW410K",   DetectAlienwareAW410KControllers,   ALIENWARE_VID,  ALIENWARE_AW410K_PID,   0x02,   0xFF00, 0x01);

Controllers/AlienwareMonitorController/AlienwareMonitorControllerDetect.cpp

@@ -9,12 +9,12 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
+#include <hidapi.h>
 #include "AlienwareAW3423DWFController.h"
 #include "AlienwareMonitorController.h"
+#include "DetectionManager.h"
 #include "RGBController_AlienwareAW3423DWF.h"
 #include "RGBController_AlienwareMonitor.h"
-#include <hidapi.h>
 
 /*---------------------------------------------------------*\
 | Alienware Vendor ID                                       |
@@ -29,37 +29,40 @@
 #define ALIENWARE_USAGE_PAGE                        0xFFDA
 #define ALIENWARE_USAGE                             0x00DA
 
-/******************************************************************************************\
-*                                                                                          *
-*   AlienwareAW3423DWFControllerDetect                                                     *
-*                                                                                          *
-*       Tests the USB address to see if an Alienware AW3423DWF exists there.               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAlienwareAW3423DWFControllers(hid_device_info* info, const std::string&)
+DetectedControllers DetectAlienwareAW3423DWFControllers(hid_device_info* info, const std::string&)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
     if(dev)
     {
         AlienwareAW3423DWFController*     controller     = new AlienwareAW3423DWFController(dev, info->path);
         RGBController_AlienwareAW3423DWF* rgb_controller = new RGBController_AlienwareAW3423DWF(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAlienwareMonitorControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAlienwareMonitorControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AlienwareMonitorController*     controller     = new AlienwareMonitorController(dev, info->path, name);
         RGBController_AlienwareMonitor* rgb_controller = new RGBController_AlienwareMonitor(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR("Alienware AW3423DWF", DetectAlienwareAW3423DWFControllers, ALIENWARE_VID, ALIENWARE_AW3423DWF_PID);

Controllers/AnnePro2Controller/AnnePro2ControllerDetect.cpp

@@ -9,10 +9,10 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
-#include "AnnePro2Controller.h"
-#include "RGBController_AnnePro2.h"
 #include <hidapi.h>
+#include "AnnePro2Controller.h"
+#include "DetectionManager.h"
+#include "RGBController_AnnePro2.h"
 
 /*---------------------------------------------------------*\
 | Anne Pro 2 vendor IDs                                     |
@@ -29,25 +29,22 @@
 #define ANNE_PRO_2_PID_4                            0xA293
 #define ANNE_PRO_2_PID_5                            0xA297
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAnnePro2Controllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an Obins Lab AnnePro2 keyboard exists there.       *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
+DetectedControllers DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AnnePro2Controller*     controller     = new AnnePro2Controller(dev, info->path);
         RGBController_AnnePro2* rgb_controller = new RGBController_AnnePro2(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_1, 1);

Controllers/ArcticController/ArcticControllerDetect.cpp

@@ -10,17 +10,20 @@
 \*---------------------------------------------------------*/
 
 #include <vector>
-#include "DetectionManager.h"
 #include "ArcticController.h"
-#include "RGBController_Arctic.h"
+#include "DetectionManager.h"
 #include "find_usb_serial_port.h"
+#include "RGBController_Arctic.h"
 
 #define CH341_VID   0x1A86
 #define CH341_PID   0x7523
 
-void DetectArcticControllers()
+DetectedControllers DetectArcticControllers()
 {
-    std::vector<std::string *> ports = find_usb_serial_port(CH341_VID, CH341_PID);
+    DetectedControllers         detected_controllers;
+    std::vector<std::string *>  ports;
+
+    ports = find_usb_serial_port(CH341_VID, CH341_PID);
 
     for(unsigned int device = 0; device < ports.size(); device++)
     {
@@ -29,7 +32,7 @@ void DetectArcticControllers()
         if(controller->IsPresent())
         {
             RGBController_Arctic *rgb_controller = new RGBController_Arctic(controller);
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
         else
         {
@@ -38,6 +41,8 @@ void DetectArcticControllers()
 
         delete ports[device];
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_DETECTOR("Arctic RGB controller", DetectArcticControllers);

Controllers/AresonController/AresonControllerDetect.cpp

@@ -28,17 +28,22 @@
 #define REDRAGON_M914_PID                              0xFA7B
 #define REDRAGON_M914_WIRELESS_PID                     0xFA7C
 
-void DetectAresonControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAresonControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AresonController*     controller      = new AresonController(dev, *info, name);
         RGBController_Areson* rgb_controller  = new RGBController_Areson(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("ZET GAMING Edge Air Pro (Wireless)",     DetectAresonControllers, ARESON_VID, ZET_GAMING_EDGE_AIR_PRO_WIRELESS_PID,      1, 0xFF02, 2);

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

@@ -19,17 +19,12 @@
 
 #define AURA_CORE_VID                   0x0B05
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAuraCoreControllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an Asus ROG Aura Core controller exists there      *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectAsusAuraCoreControllers(hid_device_info* info, const std::string& /*name*/)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -38,26 +33,33 @@ void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string& /*n
 
         if(rgb_controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
         {
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
         else
         {
             delete rgb_controller;
         }
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusAuraCoreLaptopControllers(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectAsusAuraCoreLaptopControllers(hid_device_info* info, const std::string& /*name*/)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AsusAuraCoreLaptopController*     controller        = new AsusAuraCoreLaptopController(dev, info->path);
         RGBController_AsusAuraCoreLaptop* rgb_controller    = new RGBController_AsusAuraCoreLaptop(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -19,14 +19,6 @@
 
 #define ASUSGPU_CONTROLLER_NAME "ASUS Aura GPU"
 
-/******************************************************************************************\
-*                                                                                          *
-*   TestForAuraGPUController                                                               *
-*                                                                                          *
-*       Tests the given address to see if an Aura GPU controller exists there.             *
-*                                                                                          *
-\******************************************************************************************/
-
 bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
 {
     if(bus->pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
@@ -48,31 +40,26 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres
 
     return(pass);
 
-}   /* TestForAuraGPUController() */
+}
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAuraGPUControllers                                                               *
-*                                                                                          *
-*       Detect Aura GPU controllers on the enumerated I2C busses.                          *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+DetectedControllers DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
+    DetectedControllers detected_controllers;
+
     if(TestForAsusAuraGPUController(bus, i2c_addr))
     {
         AuraGPUController*     controller     = new AuraGPUController(bus, i2c_addr, name);
         RGBController_AuraGPU* rgb_controller = new RGBController_AuraGPU(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-} /* DetectAsusAuraGPUControllers() */
 
-/*-----------------------------------------*\
-|  Nvidia GPUs                              |
-\*-----------------------------------------*/
+    return(detected_controllers);
+}
 
+/*---------------------------------------------------------*\
+|  Nvidia GPUs                                              |
+\*---------------------------------------------------------*/
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
@@ -131,10 +118,9 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Ti A11G Gaming",
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 3060 Ti Gaming OC",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060TI_O8G_OC,                 0x2A);
 
-/*-----------------------------------------*\
-|  AMD GPUs                                 |
-\*-----------------------------------------*/
-
+/*---------------------------------------------------------*\
+|  AMD GPUs                                                 |
+\*---------------------------------------------------------*/
 REGISTER_I2C_PCI_DETECTOR("ASUS AREZ STRIX Radeon RX Vega 56 Gaming OC",           DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon Vega 64",                         DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 470 Gaming OC",                DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -143,22 +143,30 @@ AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
     }
 }
 
-void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AuraAddressableController* controller               = new AuraAddressableController(dev, info->path, name);
         RGBController_AuraUSB*     rgb_controller           = new RGBController_AuraUSB(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*name*/)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -166,13 +174,18 @@ void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*na
         AuraAddressableController* controller               = new AuraAddressableController(dev, info->path, "ASUS " + dmi.getMainboard() + " Addressable");
         RGBController_AuraUSB*     rgb_controller           = new RGBController_AuraUSB(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*name*/)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -182,7 +195,7 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*n
             AuraMainboardController*     controller         = new AuraMainboardController(dev, info->path, "ASUS " + dmi.getMainboard());
             RGBController_AuraMainboard* rgb_controller     = new RGBController_AuraMainboard(controller);
 
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
         catch(const std::runtime_error& ex)
         {
@@ -190,11 +203,16 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*n
             LOG_ERROR("[AsusAuraUSB] An error occured while reading the config table: %s", ex.what());
         }
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -202,13 +220,18 @@ void DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
         AuraKeyboardMappingLayoutType layout                = GetKeyboardMappingLayoutType(info->product_id);
         RGBController_AuraKeyboard*   rgb_controller        = new RGBController_AuraKeyboard(controller, layout);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -216,125 +239,172 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
         AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, pid, name);
         RGBController_AuraMouse* rgb_controller             = new RGBController_AuraMouse(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusAuraUSBMousemats(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusAuraUSBMousemats(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AuraMousematController*     controller              = new AuraMousematController(dev, info->path, name);
         RGBController_AuraMousemat* rgb_controller          = new RGBController_AuraMousemat(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusAuraUSBROGStrixLC(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusAuraUSBROGStrixLC(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AsusROGStrixLCController*     controller     = new AsusROGStrixLCController(dev, info->path, name);
         RGBController_AsusROGStrixLC* rgb_controller = new RGBController_AsusROGStrixLC(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusAuraUSBRyuoAIO(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusAuraUSBRyuoAIO(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
-        AsusAuraRyuoAIOController* controller         = new AsusAuraRyuoAIOController(dev, info->path, name);
+        AsusAuraRyuoAIOController*     controller     = new AsusAuraRyuoAIOController(dev, info->path, name);
         RGBController_AsusAuraRyuoAIO* rgb_controller = new RGBController_AsusAuraRyuoAIO(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
-        AsusAuraMouseGen1Controller*     controller         = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
+        AsusAuraMouseGen1Controller*      controller        = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
         RGBController_AsusROGStrixEvolve* rgb_controller    = new RGBController_AsusROGStrixEvolve(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusAuraUSBSpatha(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusAuraUSBSpatha(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
-        AsusAuraMouseGen1Controller*     controller         = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
-        RGBController_AsusROGSpatha* rgb_controller         = new RGBController_AsusROGSpatha(controller);
+        AsusAuraMouseGen1Controller* controller     = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
+        RGBController_AsusROGSpatha* rgb_controller = new RGBController_AsusROGSpatha(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AuraHeadsetStandController*     controller          = new AuraHeadsetStandController(dev, info->path, name);
         RGBController_AuraHeadsetStand* rgb_controller      = new RGBController_AuraHeadsetStand(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number, name);
         RGBController_AuraTUFKeyboard* rgb_controller       = new RGBController_AuraTUFKeyboard(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AuraMonitorController*     controller           = new AuraMonitorController(dev, info->path, info->product_id, name);
         RGBController_AuraMonitor* rgb_controller       = new RGBController_AuraMonitor(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusROGAlly(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusROGAlly(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         ROGAllyController*         controller           = new ROGAllyController(dev, info->path, name);
         RGBController_AsusROGAlly* rgb_controller       = new RGBController_AsusROGAlly(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 /*-----------------------------------------------------------------*\

Controllers/AsusLegacyUSBController/AsusLegacyUSBControllerDetect.cpp

@@ -23,43 +23,58 @@
 #define ASUS_SAGARIS_GK1100_PID     0x1835
 #define ASUS_ROG_STRIX_CLAW_PID     0x1016
 
-void DetectAsusCerberusMech(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusCerberusMech(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AsusCerberusKeyboardController*     controller          = new AsusCerberusKeyboardController(dev, info->path, info->release_number, name);
         RGBController_AsusCerberusKeyboard* rgb_controller      = new RGBController_AsusCerberusKeyboard(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusSagarisKeyboard(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusSagarisKeyboard(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AsusSagarisKeyboardController*     controller          = new AsusSagarisKeyboardController(dev, info->path, info->release_number, name);
         RGBController_AsusSagarisKeyboard* rgb_controller      = new RGBController_AsusSagarisKeyboard(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         StrixClawController*     controller          = new StrixClawController(dev, info->path, name);
         RGBController_StrixClaw* rgb_controller      = new RGBController_StrixClaw(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("ASUS Cerberus Mech",  DetectAsusCerberusMech,    ASUS_LEGACY_USB_VID, ASUS_CERBERUS_MECH_PID,  1, 0xFF01, 1);

Controllers/AsusMonitorController/AsusMonitorControllerDetect.cpp

@@ -25,17 +25,22 @@
 #define ASUS_ROG_SWIFT_XG27UCG_PID                     0x1BB4
 #define ASUS_ROG_SWIFT_PG32UCDM_PID                    0x1B2B
 
-void DetectAsusMonitorControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusMonitorControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AsusMonitorController*     controller      = new AsusMonitorController(dev, *info, name);
         RGBController_AsusMonitor* rgb_controller  = new RGBController_AsusMonitor(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("Asus ROG STRIX XG27AQDMG",   DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_STRIX_XG27AQDMG_PID,   1, 0xFF72, 0x00A1);

Controllers/AsusTUFLaptopController/AsusTUFLaptopDetect_Linux.cpp

@@ -12,14 +12,15 @@
 #include "DetectionManager.h"
 #include "RGBController_AsusTUFLaptop_Linux.h"
 
-static void DetectAsusTUFLaptopLinuxControllers()
+DetectedControllers DetectAsusTUFLaptopLinuxControllers()
 {
     /*-------------------------------------------------------------------------------------*\
     | If /sys/devices/platform/asus-nb-wmi/leds/asus::kbd_backlight/kbd_rgb_mode exists,    |
     |   the kernel support TUF Laptop keyboard LED controlling.                             |
     \*-------------------------------------------------------------------------------------*/
+    DetectedControllers detected_controllers;
+    std::string         s = "";
 
-    std::string s = "";
     s.append(ASUS_KBD_BACKLIGHT_BASE_PATH);
     s.append(ASUS_KBD_BACKLIGHT_MODE_PATH);
 
@@ -27,9 +28,11 @@ static void DetectAsusTUFLaptopLinuxControllers()
     {
         AsusTUFLaptopLinuxController*       controller     = new AsusTUFLaptopLinuxController();
         RGBController_AsusTUFLaptopLinux*   rgb_controller = new RGBController_AsusTUFLaptopLinux(controller);
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+
+        detected_controllers.push_back(rgb_controller);
     }
-    return;
+
+    return(detected_controllers);
 }
 
 REGISTER_DETECTOR("ASUS TUF Laptop", DetectAsusTUFLaptopLinuxControllers);

Controllers/AsusTUFLaptopController/AsusTUFLaptopDetect_Windows.cpp

@@ -12,41 +12,38 @@
 #include "RGBController_AsusTUFLaptop_Windows.h"
 #include "wmi.h"
 
-static void DetectAsusTUFLaptopWMIControllers()
+DetectedControllers DetectAsusTUFLaptopWMIControllers()
 {
     // Try to retrieve ProductID / Device name from WMI; Possibly can be rewritten to use wmi.cpp
     // IF you encounter false detection ( e.g. if your laptop keyboard backlight uses USB interface
     // instead of ACPI WMI) please add a WHITELIST by checking the
     // `name` variable for model substrings like "FX505DU"
     // For now, checking for "TUF Gaming" should suffice
+    DetectedControllers     detected_controllers;
+    Wmi                     wmi;
+    std::vector<QueryObj>   systemProduct;
 
-    Wmi wmi;
-
-    std::vector<QueryObj> systemProduct;
-    if (wmi.query("SELECT * FROM Win32_ComputerSystemProduct", systemProduct))
+    if(wmi.query("SELECT * FROM Win32_ComputerSystemProduct", systemProduct) != 0)
     {
-        return;
+        // There should only be one, a cycle is a precaution
+        if(systemProduct.size() == 1)
+        {
+            std::string& name = systemProduct[0]["Name"];
+
+            if(name.find("TUF Gaming") != name.npos)
+            {
+                AsusTUFLaptopController* controller = AsusTUFLaptopController::checkAndCreate();
+                if(controller)
+                {
+                    RGBController* rgb_controller = new RGBController_AsusTUFLaptopWMI(controller);
+
+                    detected_controllers.push_back(rgb_controller);
+                }
+            }
+        }
     }
 
-    // There should only be one, a cycle is a precaution
-    if(systemProduct.size() != 1)
-    {
-        return;
-    }
-    std::string& name = systemProduct[0]["Name"];
-
-    if(name.find("TUF Gaming") == name.npos)
-    {
-        return;
-    }
-
-    AsusTUFLaptopController* controller = AsusTUFLaptopController::checkAndCreate();
-    if(controller)
-    {
-        RGBController* new_controller = new RGBController_AsusTUFLaptopWMI(controller);
-
-        DetectionManager::get()->RegisterRGBController(new_controller);
-    }
+    return(detected_controllers);
 }   /* DetectAsusTUFLaptopWMIControllers() */
 
 REGISTER_DETECTOR("ASUS TUF Laptop", DetectAsusTUFLaptopWMIControllers);

Controllers/BlinkyTapeController/BlinkyTapeControllerDetect.cpp

@@ -15,23 +15,16 @@
 #include "RGBController_BlinkyTape.h"
 #include "find_usb_serial_port.h"
 
-/*-----------------------------------------------------*\
-| BlinkyTape VID and PID                                |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| BlinkyTape VID and PID                                    |
+\*---------------------------------------------------------*/
 #define BLINKINLABS_VID                         0x1D50
 #define BLINKYTAPE_PID                          0x605E
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectBlinkyTapeControllers                                                            *
-*                                                                                          *
-*       Detect BlinkyTape devices                                                          *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectBlinkyTapeControllers()
+DetectedControllers DetectBlinkyTapeControllers()
 {
-    std::vector<std::string *> device_locations = find_usb_serial_port(BLINKINLABS_VID, BLINKYTAPE_PID);
+    DetectedControllers         detected_controllers;
+    std::vector<std::string *>  device_locations = find_usb_serial_port(BLINKINLABS_VID, BLINKYTAPE_PID);
 
     for(unsigned int device_idx = 0; device_idx < device_locations.size(); device_idx++)
     {
@@ -39,8 +32,11 @@ void DetectBlinkyTapeControllers()
         controller->Initialize(*device_locations[device_idx]);
 
         RGBController_BlinkyTape* rgb_controller = new RGBController_BlinkyTape(controller);
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_DETECTOR("BlinkyTape", DetectBlinkyTapeControllers);

Controllers/CherryKeyboardController/CherryKeyboardControllerDetect.cpp

@@ -14,35 +14,33 @@
 #include "CherryKeyboardController.h"
 #include "RGBController_CherryKeyboard.h"
 
-/*-----------------------------------------------------*\
-| Cherry keyboard VID and usage page                    |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Cherry keyboard VID and usage page                        |
+\*---------------------------------------------------------*/
 #define CHERRY_KEYBOARD_VID                     0x046A
 #define CHERRY_KEYBOARD_USAGE_PAGE              0xFF1C
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCherryKeyboards                                                                 *
-*                                                                                          *
-*       Tests the USB address to see if an Cherry RGB Keyboard controller exists there.   *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCherryKeyboards(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCherryKeyboards(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
     {
         CherryKeyboardController*     controller     = new CherryKeyboardController(dev, info->path, name);
         RGBController_CherryKeyboard* rgb_controller = new RGBController_CherryKeyboard(controller, info->product_id);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-/*---------------------------------------------------------------------------------------------------------------------------------------------*\
-| Keyboards                                                                                                                                     |
-\*---------------------------------------------------------------------------------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Keyboards                                                 |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 3.0S FL NBL",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_3_0S_FL_NBL_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 3.0S FL RGB",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_3_0S_FL_RGB_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 3.0S FL RGB KOREAN", DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_3_0S_FL_RGB_KOR_PID, 1, CHERRY_KEYBOARD_USAGE_PAGE);

Controllers/ClevoKeyboardController/ClevoKeyboardControllerDetect.cpp

@@ -9,34 +9,39 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "Detector.h"
+#include "DetectionManager.h"
 #include "ClevoKeyboardController.h"
 #include "RGBController_ClevoKeyboard.h"
 #include "RGBController.h"
 #include <hidapi.h>
 
-/*-----------------------------------------------------*\
-| ITE Tech vendor ID                                    |
-\*-----------------------------------------------------*/
-#define ITE_VID                         0x048D
+/*---------------------------------------------------------*\
+| ITE Tech vendor ID                                        |
+\*---------------------------------------------------------*/
+#define ITE_VID                                 0x048D
 
-/*-----------------------------------------------------*\
-| Clevo Keyboard product IDs                            |
-| These are ITE 8291 per-key RGB keyboard controllers   |
-\*-----------------------------------------------------*/
-#define CLEVO_KEYBOARD_PID_600B        0x600B
+/*---------------------------------------------------------*\
+| Clevo Keyboard product IDs                                |
+| These are ITE 8291 per-key RGB keyboard controllers       |
+\*---------------------------------------------------------*/
+#define CLEVO_KEYBOARD_PID_600B                 0x600B
 
-void DetectClevoKeyboardControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectClevoKeyboardControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         ClevoKeyboardController*     controller     = new ClevoKeyboardController(dev, *info);
         RGBController_ClevoKeyboard* rgb_controller = new RGBController_ClevoKeyboard(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_PU("CLEVO Keyboard", DetectClevoKeyboardControllers, 0x048D, 0x600B, 0xFF03, 0x01);

Controllers/ClevoLightbarController/ClevoLightbarControllerDetect.cpp

@@ -9,33 +9,38 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "Detector.h"
+#include "DetectionManager.h"
 #include "ClevoLightbarController.h"
 #include "RGBController_ClevoLightbar.h"
 #include "RGBController.h"
 #include <hidapi.h>
 
-/*-----------------------------------------------------*\
-| ITE Tech vendor ID                                    |
-\*-----------------------------------------------------*/
-#define ITE_VID                         0x048D
+/*---------------------------------------------------------*\
+| ITE Tech vendor ID                                        |
+\*---------------------------------------------------------*/
+#define ITE_VID                                 0x048D
 
-/*-----------------------------------------------------*\
-| CLEVO Lightbar product ID                            |
-\*-----------------------------------------------------*/
-#define CLEVO_LIGHTBAR_PID             0x7001
+/*---------------------------------------------------------*\
+| CLEVO Lightbar product ID                                 |
+\*---------------------------------------------------------*/
+#define CLEVO_LIGHTBAR_PID                      0x7001
 
-void DetectClevoLightbarControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectClevoLightbarControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         ClevoLightbarController*     controller     = new ClevoLightbarController(dev, *info);
         RGBController_ClevoLightbar* rgb_controller = new RGBController_ClevoLightbar(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_PU("CLEVO Lightbar", DetectClevoLightbarControllers, ITE_VID, CLEVO_LIGHTBAR_PID, 0xFF03, 0x02);

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -7,12 +7,12 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
-#include "LogManager.h"
 #include "ColorfulGPUController.h"
-#include "RGBController_ColorfulGPU.h"
+#include "DetectionManager.h"
 #include "i2c_smbus.h"
+#include "LogManager.h"
 #include "pci_ids.h"
+#include "RGBController_ColorfulGPU.h"
 
 bool TestForColorfulGPU(i2c_smbus_interface* bus, uint8_t i2c_addr)
 {
@@ -33,15 +33,19 @@ bool TestForColorfulGPU(i2c_smbus_interface* bus, uint8_t i2c_addr)
     return res >= 0 && (read_pkt[0] == 0xAA && read_pkt[1] == 0xEF && read_pkt[2] == 0x81);
 }
 
-void DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+DetectedControllers DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
+    DetectedControllers detected_controllers;
+
     if(TestForColorfulGPU(bus, i2c_addr))
     {
         ColorfulGPUController*     controller     = new ColorfulGPUController(bus, i2c_addr, name);
         RGBController_ColorfulGPU* rgb_controller = new RGBController_ColorfulGPU(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Advanced OC 12G L-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ADVANCED_OC_12G_LV,     0x61);

Controllers/ColorfulTuringGPUController/ColorfulTuringGPUControllerDetect.cpp

@@ -7,21 +7,25 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
 #include "ColorfulTuringGPUController.h"
-#include "RGBController_ColorfulTuringGPU.h"
+#include "DetectionManager.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
+#include "RGBController_ColorfulTuringGPU.h"
 
-void DetectColorfulTuringGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+DetectedControllers DetectColorfulTuringGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
+    DetectedControllers detected_controllers;
+
     if(bus->port_id == 1)
     {
-        ColorfulTuringGPUController* controller         = new ColorfulTuringGPUController(bus, i2c_addr, name);
+        ColorfulTuringGPUController*     controller     = new ColorfulTuringGPUController(bus, i2c_addr, name);
         RGBController_ColorfulTuringGPU* rgb_controller = new RGBController_ColorfulTuringGPU(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 2070 SUPER Advanced OC-V", DetectColorfulTuringGPUControllers,   NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_2070_SUPER_ADVANCED_OCV,  0x50);

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -7,16 +7,16 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-/*-----------------------------------------------------*\
-| OpenRGB includes                                      |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| OpenRGB includes                                          |
+\*---------------------------------------------------------*/
 #include <hidapi.h>
 #include "DetectionManager.h"
 #include "LogManager.h"
 
-/*-----------------------------------------------------*\
-| Coolermaster specific includes                        |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster specific includes                            |
+\*---------------------------------------------------------*/
 #include "RGBController_CMMMController.h"
 #include "RGBController_CMMM711Controller.h"
 #include "RGBController_CMMM712Controller.h"
@@ -30,24 +30,24 @@
 #include "RGBController_CMGD160Controller.h"
 #include "RGBController_CMKeyboardController.h"
 
-/*-----------------------------------------------------*\
-| Coolermaster USB vendor ID                            |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster USB vendor ID                                |
+\*---------------------------------------------------------*/
 #define COOLERMASTER_VID                            0x2516
 
-/*-----------------------------------------------------*\
-| Coolermaster Keyboards                                |
-|   PIDs defined in `CMMKControllerV2.h`                |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster Keyboards                                    |
+|   PIDs defined in `CMMKControllerV2.h`                    |
+\*---------------------------------------------------------*/
 
-/*-----------------------------------------------------*\
-| Coolermaster GPUs                                     |
-|   PIDs defined in `CMR6000Controller.h`               |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster GPUs                                         |
+|   PIDs defined in `CMR6000Controller.h`                   |
+\*---------------------------------------------------------*/
 
-/*-----------------------------------------------------*\
-| Coolermaster LEDstrip controllers                     |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster LEDstrip controllers                         |
+\*---------------------------------------------------------*/
 #define COOLERMASTER_ARGB_PID                       0x1011
 #define COOLERMASTER_ARGB_GEN2_A1_PID               0x0173
 #define COOLERMASTER_ARGB_GEN2_A1_V2_PID            0x01C9
@@ -55,9 +55,9 @@
 #define COOLERMASTER_SMALL_ARGB_PID                 0x1000
 #define COOLERMASTER_RGB_PID                        0x004F
 
-/*-----------------------------------------------------*\
-| Coolermaster Mice                                     |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster Mice                                         |
+\*---------------------------------------------------------*/
 #define COOLERMASTER_MM530_PID                      0x0065
 #define COOLERMASTER_MM531_PID                      0x0097
 #define COOLERMASTER_MM711_PID                      0x0101
@@ -65,34 +65,29 @@
 #define COOLERMASTER_MM720_PID                      0x0141
 #define COOLERMASTER_MM730_PID                      0x0165
 
-/*-----------------------------------------------------*\
-| Coolermaster Mousemats                                |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster Mousemats                                    |
+\*---------------------------------------------------------*/
 #define COOLERMASTER_MP750_XL_PID                   0x0109
 #define COOLERMASTER_MP750_L_PID                    0x0107
 #define COOLERMASTER_MP750_MEDIUM_PID               0x0105
 
-/*-----------------------------------------------------*\
-| Coolermaster Monitors                                 |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster Monitors                                     |
+\*---------------------------------------------------------*/
 #define COOLERMASTER_GM27_FQS_PID                   0x01BB
 
-/*-----------------------------------------------------*\
-| Coolermaster Desks                                    |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster Desks                                        |
+\*---------------------------------------------------------*/
 #define COOLERMASTER_GD160_PID                      0x01A9
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCoolerMasterControllers                                                          *
-*                                                                                          *
-*       Tests the USB address to see if any CoolerMaster controllers exists there.         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
+DetectedControllers DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -107,40 +102,55 @@ void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
             CMARGBController*               controller     = new CMARGBController(dev, info->path, i, cm_mutex);
             RGBController_CMARGBController* rgb_controller = new RGBController_CMARGBController(controller);
 
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
     }
+
+    return(detected_controllers);
 }
 
-void DetectCoolerMasterARGBGen2A1(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCoolerMasterARGBGen2A1(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CMARGBGen2A1controller*               controller     = new CMARGBGen2A1controller(dev, *info, name);
         RGBController_CMARGBGen2A1Controller* rgb_controller = new RGBController_CMARGBGen2A1Controller(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectCoolerMasterGPU(hid_device_info* info, const std::string&)
+DetectedControllers DetectCoolerMasterGPU(hid_device_info* info, const std::string&)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CMR6000Controller*               controller     = new CMR6000Controller(dev, info->path, info->product_id);
         RGBController_CMR6000Controller* rgb_controller = new RGBController_CMR6000Controller(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectCoolerMasterV1Keyboards(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCoolerMasterV1Keyboards(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -149,24 +159,29 @@ void DetectCoolerMasterV1Keyboards(hid_device_info* info, const std::string& nam
             case COOLERMASTER_KEYBOARD_PRO_L_PID:
             case COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID:
             case COOLERMASTER_KEYBOARD_PRO_S_PID:
-            {
-                CMKeyboardV1Controller*             controller     = new CMKeyboardV1Controller(dev, info, name);
-                RGBController_CMKeyboardController* rgb_controller = new RGBController_CMKeyboardController(controller);
+                {
+                    CMKeyboardV1Controller*             controller     = new CMKeyboardV1Controller(dev, info, name);
+                    RGBController_CMKeyboardController* rgb_controller = new RGBController_CMKeyboardController(controller);
 
-                DetectionManager::get()->RegisterRGBController(rgb_controller);
-            }
-            break;
+                    detected_controllers.push_back(rgb_controller);
+                }
+                break;
 
             default:
                 LOG_DEBUG("[%s] Controller not created as the product ID %04X is missing from detector switch", name.c_str(), info->product_id);
-            break;
+                break;
         }
     }
+
+    return(detected_controllers);
 }
 
-void DetectCoolerMasterV2Keyboards(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCoolerMasterV2Keyboards(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -175,13 +190,13 @@ void DetectCoolerMasterV2Keyboards(hid_device_info* info, const std::string& nam
             case COOLERMASTER_KEYBOARD_PRO_L_PID:
             case COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID:
             case COOLERMASTER_KEYBOARD_PRO_S_PID:
-            {
-                CMKeyboardV1Controller*             controller     = new CMKeyboardV1Controller(dev, info, name);
-                RGBController_CMKeyboardController* rgb_controller = new RGBController_CMKeyboardController(controller);
+                {
+                    CMKeyboardV1Controller*             controller     = new CMKeyboardV1Controller(dev, info, name);
+                    RGBController_CMKeyboardController* rgb_controller = new RGBController_CMKeyboardController(controller);
 
-                DetectionManager::get()->RegisterRGBController(rgb_controller);
-            }
-            break;
+                    detected_controllers.push_back(rgb_controller);
+                }
+                break;
 
             case COOLERMASTER_KEYBOARD_SK622B_PID:
             case COOLERMASTER_KEYBOARD_SK622W_PID:
@@ -195,130 +210,172 @@ void DetectCoolerMasterV2Keyboards(hid_device_info* info, const std::string& nam
             case COOLERMASTER_KEYBOARD_CK552_V2_PID:
             case COOLERMASTER_KEYBOARD_MK730_PID:
             case COOLERMASTER_KEYBOARD_MK750_PID:
-            {
-                CMKeyboardV2Controller*             controller     = new CMKeyboardV2Controller(dev, info, name);
-                RGBController_CMKeyboardController* rgb_controller = new RGBController_CMKeyboardController(controller);
+                {
+                    CMKeyboardV2Controller*             controller     = new CMKeyboardV2Controller(dev, info, name);
+                    RGBController_CMKeyboardController* rgb_controller = new RGBController_CMKeyboardController(controller);
 
-                DetectionManager::get()->RegisterRGBController(rgb_controller);
-            }
-            break;
+                    detected_controllers.push_back(rgb_controller);
+                }
+                break;
 
             default:
                 LOG_DEBUG("[%s] Controller not created as the product ID %04X is missing from detector switch", name.c_str(), info->product_id);
-            break;
+                break;
         }
     }
+
+    return(detected_controllers);
 }
 
-void DetectCoolerMasterMouse(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCoolerMasterMouse(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CMMMController*               controller        = new CMMMController(dev, info->path, info->product_id, name);
         RGBController_CMMMController* rgb_controller    = new RGBController_CMMMController(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectCoolerMasterMouse711(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectCoolerMasterMouse711(hid_device_info* info, const std::string& /*name*/)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CMMM711Controller*               controller     = new CMMM711Controller(dev, info->path);
         RGBController_CMMM711Controller* rgb_controller = new RGBController_CMMM711Controller(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectCoolerMasterMouse712(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectCoolerMasterMouse712(hid_device_info* info, const std::string& /*name*/)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CMMM712Controller*               controller     = new CMMM712Controller(dev, info->path);
         RGBController_CMMM712Controller* rgb_controller = new RGBController_CMMM712Controller(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectCoolerMasterMousemats(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectCoolerMasterMousemats(hid_device_info* info, const std::string& /*name*/)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CMMP750Controller*               controller     = new CMMP750Controller(dev, info->path);
         RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectCoolerMasterRGB(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectCoolerMasterRGB(hid_device_info* info, const std::string& /*name*/)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CMRGBController*               controller     = new CMRGBController(dev, info->path);
         RGBController_CMRGBController* rgb_controller = new RGBController_CMRGBController(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectCoolerMasterSmallARGB(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectCoolerMasterSmallARGB(hid_device_info* info, const std::string& /*name*/)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CMSmallARGBController*               controller     = new CMSmallARGBController(dev, info->path, 0);
         RGBController_CMSmallARGBController* rgb_controller = new RGBController_CMSmallARGBController(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectCoolerMasterMonitor(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCoolerMasterMonitor(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CMMonitorController*               controller     = new CMMonitorController(dev, *info, name);
         RGBController_CMMonitorController* rgb_controller = new RGBController_CMMonitorController(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectCoolerMasterGD160(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCoolerMasterGD160(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CMGD160Controller*               controller     = new CMGD160Controller(dev, *info, name);
         RGBController_CMGD160Controller* rgb_controller = new RGBController_CMGD160Controller(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 
-/*-----------------------------------------------------*\
-| Coolermaster Keyboards                                |
-|   PIDs defined in `CMKeyboardDevices.h`               |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster Keyboards                                    |
+|   PIDs defined in `CMKeyboardDevices.h`                   |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro S",         DetectCoolerMasterV1Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_PRO_S_PID,          1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L",         DetectCoolerMasterV1Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_PRO_L_PID,          1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L White",   DetectCoolerMasterV1Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID,    1,      0xFF00, 1);
@@ -338,9 +395,9 @@ REGISTER_HID_DETECTOR_IPU("Cooler Master CK530 V2",                 DetectCooler
 REGISTER_HID_DETECTOR_IPU("Cooler Master CK550 V2",                 DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_CK550_V2_PID,       1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master CK550 V1 / CK552",         DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_CK552_V2_PID,       1,      0xFF00, 1);
 
-/*-----------------------------------------------------*\
-| Coolermaster LEDstrip controllers                     |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster LEDstrip controllers                         |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB",                     DetectCoolerMasterARGB,         COOLERMASTER_VID,   COOLERMASTER_ARGB_PID,                      0,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB Gen 2 A1",            DetectCoolerMasterARGBGen2A1,   COOLERMASTER_VID,   COOLERMASTER_ARGB_GEN2_A1_PID,              1,      0xFF01, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB Gen 2 A1 V2",         DetectCoolerMasterARGBGen2A1,   COOLERMASTER_VID,   COOLERMASTER_ARGB_GEN2_A1_V2_PID,           1,      0xFF01, 1);
@@ -348,9 +405,9 @@ REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB Gen 2 A1 Mini",       DetectCooler
 REGISTER_HID_DETECTOR_IPU("Cooler Master RGB",                      DetectCoolerMasterRGB,          COOLERMASTER_VID,   COOLERMASTER_RGB_PID,                       1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master Small ARGB",               DetectCoolerMasterSmallARGB,    COOLERMASTER_VID,   COOLERMASTER_SMALL_ARGB_PID,                0,      0xFF00, 1);
 
-/*-----------------------------------------------------*\
-| Coolermaster Mice                                     |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster Mice                                         |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IPU("Cooler Master MM530",                    DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM530_PID,                     1,      0xFF00, 1);
 //REGISTER_HID_DETECTOR_IPU("Cooler Master MM531",                  DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM531_PID,                     1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MM711",                    DetectCoolerMasterMouse711,     COOLERMASTER_VID,   COOLERMASTER_MM711_PID,                     1,      0xFF00, 1);
@@ -358,26 +415,26 @@ REGISTER_HID_DETECTOR_IPU("Cooler Master MM712",                    DetectCooler
 REGISTER_HID_DETECTOR_IPU("Cooler Master MM720",                    DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM720_PID,                     1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MM730",                    DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM730_PID,                     1,      0xFF00, 1);
 
-/*-----------------------------------------------------*\
-| Coolermaster Mousemats                                |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster Mousemats                                    |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 XL",                 DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_XL_PID,                          0xFF00, 1);
 REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 Large",              DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_L_PID,                           0xFF00, 1);
 REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 Medium",             DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_MEDIUM_PID,                      0xFF00, 1);
 
-/*-----------------------------------------------------*\
-| Coolermaster GPUs                                     |
-|   PIDs defined in `CMR6000Controller.h`               |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster GPUs                                         |
+|   PIDs defined in `CMR6000Controller.h`                   |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_I  ("Cooler Master Radeon RX 6000 GPU",        DetectCoolerMasterGPU,          COOLERMASTER_VID,   COOLERMASTER_RADEON_6000_PID,               1                );
 REGISTER_HID_DETECTOR_I  ("Cooler Master Radeon RX 6900 GPU",        DetectCoolerMasterGPU,          COOLERMASTER_VID,   COOLERMASTER_RADEON_6900_PID,               1                );
 
-/*-----------------------------------------------------*\
-| Coolermaster Monitors                                 |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster Monitors                                     |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IPU("Cooler Master GM27-FQS ARGB Monitor",    DetectCoolerMasterMonitor,      COOLERMASTER_VID,   COOLERMASTER_GM27_FQS_PID,                   0,      0xFF00, 1);
 
-/*-----------------------------------------------------*\
-| Coolermaster Desks                                    |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Coolermaster Desks                                        |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IPU("Cooler Master GD160 ARGB Gaming Desk",   DetectCoolerMasterGD160,        COOLERMASTER_VID,   COOLERMASTER_GD160_PID,                   0,      0xFF00, 1);

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreControllerDetect.cpp

@@ -10,8 +10,8 @@
 \*---------------------------------------------------------*/
 
 #include <hidapi.h>
-#include "DetectionManager.h"
 #include "CorsairCommanderCoreController.h"
+#include "DetectionManager.h"
 #include "RGBController_CorsairCommanderCore.h"
 
 /*-----------------------------------------------------*\
@@ -19,25 +19,22 @@
 \*-----------------------------------------------------*/
 #define CORSAIR_VID                         0x1B1C
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairCommanderCoreControllers                                                  *
-*                                                                                          *
-*       Tests the USB address to see if a Corsair RGB Cooler controller exists there.      *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairCommanderCoreControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCorsairCommanderCoreControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CorsairCommanderCoreController*     controller     = new CorsairCommanderCoreController(dev, info->path, info->product_id, name);
         RGBController_CorsairCommanderCore* rgb_controller = new RGBController_CorsairCommanderCore(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("Corsair Commander Core", DetectCorsairCommanderCoreControllers, CORSAIR_VID, CORSAIR_COMMANDER_CORE_PID,  0x00, 0xFF42, 0x01);

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumControllerDetect.cpp

@@ -93,22 +93,11 @@ bool TestForCorsairDominatorPlatinumController(i2c_smbus_interface *bus, unsigne
     return true;
 }
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairDominatorPlatinumControllers                                              *
-*                                                                                          *
-*       Detect Corsair Dominator Platinum controllers on the enumerated I2C busses.        *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           dev - I2C address of Aura device                                               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *> &busses)
+DetectedControllers DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *> &busses)
 {
-    SettingsManager* settings_manager = ResourceManager::get()->GetSettingsManager();
-
-    json corsair_dominator_settings = settings_manager->GetSettings("CorsairDominatorSettings");
+    DetectedControllers detected_controllers;
+    SettingsManager*    settings_manager            = ResourceManager::get()->GetSettingsManager();
+    json                corsair_dominator_settings  = settings_manager->GetSettings("CorsairDominatorSettings");
 
     if(!corsair_dominator_settings.contains("model"))
     {
@@ -158,10 +147,10 @@ void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *
 
                     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* rgbcontroller = new RGBController_CorsairDominatorPlatinum(controller);
+                    CorsairDominatorPlatinumController*     controller     = new CorsairDominatorPlatinumController(busses[bus], addr, leds, name);
+                    RGBController_CorsairDominatorPlatinum* rgb_controller = new RGBController_CorsairDominatorPlatinum(controller);
 
-                    DetectionManager::get()->RegisterRGBController(rgbcontroller);
+                    detected_controllers.push_back(rgb_controller);
                 }
 
                 std::this_thread::sleep_for(10ms);
@@ -172,6 +161,8 @@ void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *
             LOG_DEBUG("[%s] Bus %d is not a DRAM bus", CORSAIR_DOMINATOR_PLATINUM_NAME, bus);
         }
     }
-}   /* DetectCorsairDominatorPlatinumControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_I2C_DETECTOR(CORSAIR_DOMINATOR_PLATINUM_NAME, DetectCorsairDominatorPlatinumControllers);

Controllers/CorsairHydro2Controller/CorsairHydro2ControllerDetect.cpp

@@ -17,8 +17,10 @@
 #define CORSAIR_VID     0x1B1C
 #define H100I_V2_PID    0x0C09
 
-void DetectCorsairHydro2Controllers()
+DetectedControllers DetectCorsairHydro2Controllers()
 {
+    DetectedControllers detected_controllers;
+
     libusb_init(NULL);
 
     #ifdef _WIN32
@@ -35,8 +37,10 @@ void DetectCorsairHydro2Controllers()
         CorsairHydro2Controller*     controller     = new CorsairHydro2Controller(dev);
         RGBController_CorsairHydro2* rgb_controller = new RGBController_CorsairHydro2(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_DETECTOR("Corsair H100i v2", DetectCorsairHydro2Controllers);

Controllers/CorsairHydroController/CorsairHydroControllerDetect.cpp

@@ -14,14 +14,14 @@
 #include "CorsairHydroController.h"
 #include "RGBController_CorsairHydro.h"
 
-/*-----------------------------------------------------*\
-| Corsair vendor ID                                     |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Corsair vendor ID                                         |
+\*---------------------------------------------------------*/
 #define CORSAIR_VID                     0x1B1C
 
-/*-----------------------------------------------------*\
-| Keyboard Hydro Series product IDs                     |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Keyboard Hydro Series product IDs                         |
+\*---------------------------------------------------------*/
 #define CORSAIR_H115I_PRO_RGB_PID       0x0C13
 #define CORSAIR_H100I_PRO_RGB_PID       0x0C15
 #define CORSAIR_H150I_PRO_RGB_PID       0x0C12
@@ -46,16 +46,10 @@ static const corsair_hydro_device device_list[] =
     { CORSAIR_VID,          CORSAIR_H150I_PRO_RGB_PID,          0,      "Corsair H150i PRO RGB"             },
 };
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairHydroControllers                                                          *
-*                                                                                          *
-*       Tests the USB address to see if a Corsair RGB Cooler controller exists there.      *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairHydroControllers()
+DetectedControllers DetectCorsairHydroControllers()
 {
+    DetectedControllers detected_controllers;
+
     libusb_init(NULL);
 
     #ifdef _WIN32
@@ -75,10 +69,12 @@ void DetectCorsairHydroControllers()
             CorsairHydroController*     controller     = new CorsairHydroController(dev, device_list[device_idx].name);
             RGBController_CorsairHydro* rgb_controller = new RGBController_CorsairHydro(controller);
 
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
     }
-}   /* DetectCorsairHydroControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR("Corsair Hydro Series", DetectCorsairHydroControllers);
 /*---------------------------------------------------------------------------------------------------------*\

Controllers/CorsairHydroPlatinumController/CorsairHydroPlatinumControllerDetect.cpp

@@ -11,18 +11,18 @@
 \*---------------------------------------------------------*/
 
 #include <hidapi.h>
-#include "DetectionManager.h"
 #include "CorsairHydroPlatinumController.h"
+#include "DetectionManager.h"
 #include "RGBController_CorsairHydroPlatinum.h"
 
-/*-----------------------------------------------------*\
-| Corsair vendor ID                                     |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Corsair vendor ID                                         |
+\*---------------------------------------------------------*/
 #define CORSAIR_VID                         0x1B1C
 
-/*-----------------------------------------------------*\
-| Product IDs                                           |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Product IDs                                               |
+\*---------------------------------------------------------*/
 #define CORSAIR_HYDRO_H100I_PLATINUM_PID    	0x0C18
 #define CORSAIR_HYDRO_H100I_PLATINUM_SE_PID 	0x0C19
 #define CORSAIR_HYDRO_H115I_PLATINUM_PID    	0x0C17
@@ -37,7 +37,7 @@
 #define CORSAIR_HYDRO_H100I_ELITE_RGB_PID_WHITE	0x0C40
 #define CORSAIR_HYDRO_H150I_ELITE_RGB_PID_WHITE 0x0C41
 
-void DetectCorsairHydroPlatinumControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCorsairHydroPlatinumControllers(hid_device_info* info, const std::string& name)
 {
     uint16_t no_rgb_fan_models[] =
     {
@@ -48,7 +48,10 @@ void DetectCorsairHydroPlatinumControllers(hid_device_info* info, const std::str
         CORSAIR_HYDRO_H150I_ELITE_RGB_PID_WHITE
     };
 
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -65,8 +68,10 @@ void DetectCorsairHydroPlatinumControllers(hid_device_info* info, const std::str
         CorsairHydroPlatinumController*     controller     = new CorsairHydroPlatinumController(dev, info->path, dev_rgb_fan, name);
         RGBController_CorsairHydroPlatinum* rgb_controller = new RGBController_CorsairHydroPlatinum(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR("Corsair Hydro H100i Platinum",       DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H100I_PLATINUM_PID    	);

Controllers/CorsairICueLinkController/CorsairICueLinkControllerDetect.cpp

@@ -19,17 +19,22 @@
 #define CORSAIR_VID                         0x1B1C
 #define CORSAIR_ICUE_LINK_SYSTEM_HUB_PID    0x0C3F
 
-void DetectCorsairICueLinkControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCorsairICueLinkControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CorsairICueLinkController*     controller     = new CorsairICueLinkController(dev, info->path, name);
         RGBController_CorsairICueLink* rgb_controller = new RGBController_CorsairICueLink(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("Corsair iCUE Link System Hub", DetectCorsairICueLinkControllers, CORSAIR_VID, CORSAIR_ICUE_LINK_SYSTEM_HUB_PID, 0x00, 0xFF42, 0x01);

Controllers/CorsairLightingNodeController/CorsairLightingNodeControllerDetect.cpp

@@ -10,8 +10,8 @@
 \*---------------------------------------------------------*/
 
 #include <hidapi.h>
-#include "DetectionManager.h"
 #include "CorsairLightingNodeController.h"
+#include "DetectionManager.h"
 #include "RGBController_CorsairLightingNode.h"
 
 #define CORSAIR_VID                     0x1B1C
@@ -23,26 +23,23 @@
 #define CORSAIR_SPEC_OMEGA_RGB_PID      0x1D04
 #define CORSAIR_LT100_PID               0x0C23
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairLightingNodeControllers                                                   *
-*                                                                                          *
-*       Detect devices supported by the Corsair Lighting Node Pro driver                   *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairLightingNodeControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCorsairLightingNodeControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CorsairLightingNodeController*     controller     = new CorsairLightingNodeController(dev, info->path, name);
         RGBController_CorsairLightingNode* rgb_controller = new RGBController_CorsairLightingNode(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectCorsairLightingNodeControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_HID_DETECTOR("Corsair Lighting Node Core", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_CORE_PID); // 1 channel
 REGISTER_HID_DETECTOR("Corsair Lighting Node Pro",  DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_PRO_PID);  // 2 channels

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -7,33 +7,33 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-/*-----------------------------------------------------*\
-| OpenRGB includes                                      |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| OpenRGB includes                                          |
+\*---------------------------------------------------------*/
 #include <hidapi.h>
 #include "DetectionManager.h"
 #include "LogManager.h"
 #include "RGBController.h"
 
-/*-----------------------------------------------------*\
-| Corsair Peripheral specific includes                  |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Corsair Peripheral specific includes                      |
+\*---------------------------------------------------------*/
 #include "RGBController_CorsairPeripheral.h"
 #include "RGBController_CorsairK55RGBPROXT.h"
 #include "RGBController_CorsairK65Mini.h"
 
 #define CORSAIR_PERIPHERAL_CONTROLLER_NAME "Corsair peripheral"
 
-/*-----------------------------------------------------*\
-| Corsair vendor ID                                     |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Corsair vendor ID                                         |
+\*---------------------------------------------------------*/
 #define CORSAIR_VID                     0x1B1C
 
-/*-----------------------------------------------------*\
-| Keyboard product IDs                                  |
-|   List taken from ckb-next                            |
-|   Non-RGB keyboards were omitted from this list       |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+|   List taken from ckb-next                                |
+|   Non-RGB keyboards were omitted from this list           |
+\*---------------------------------------------------------*/
 #define CORSAIR_K55_RGB_PID             0x1B3D
 
 #define CORSAIR_K65_RGB_PID             0x1B17
@@ -57,17 +57,17 @@
 #define CORSAIR_STRAFE_RED_PID          0x1B44
 #define CORSAIR_STRAFE_MK2_PID          0x1B48
 
-/*-----------------------------------------------------*\
-| Non-RGB Keyboard product IDs                          |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Non-RGB Keyboard product IDs                              |
+\*---------------------------------------------------------*/
 #define CORSAIR_K70_LUX_PID             0x1B36
 #define CORSAIR_K68_RED_PID             0x1B3F
 #define CORSAIR_K68_RED_SHADOW_PID      0x1BA5
 
-/*-----------------------------------------------------*\
-| Mouse product IDs                                     |
-|   List taken from ckb-next                            |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Mouse product IDs                                         |
+|   List taken from ckb-next                                |
+\*---------------------------------------------------------*/
 #define CORSAIR_GLAIVE_RGB_PID          0x1B34
 #define CORSAIR_GLAIVE_RGB_PRO_PID      0x1B74
 #define CORSAIR_HARPOON_RGB_PID         0x1B3C
@@ -82,66 +82,72 @@
 #define CORSAIR_SCIMITAR_ELITE_RGB_PID  0x1B8B
 #define CORSAIR_SABRE_RGB_PID           0x1B2F
 
-/*-----------------------------------------------------*\
-| Mousepad product IDs                                  |
-|   List taken from ckb-next                            |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Mousepad product IDs                                      |
+|   List taken from ckb-next                                |
+\*---------------------------------------------------------*/
 #define CORSAIR_MM800_RGB_POLARIS_PID   0x1B3B
 
-/*-----------------------------------------------------*\
-| Headset Stand product IDs                             |
-|   List taken from ckb-next                            |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Headset Stand product IDs                                 |
+|   List taken from ckb-next                                |
+\*---------------------------------------------------------*/
 #define CORSAIR_ST100_PID               0x0A34
 
-/*-----------------------------------------------------*\
-| Corsair K55 RGB PRO XT Keyboard product ID            |
-| This keyboard uses a separate driver                  |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Corsair K55 RGB PRO XT Keyboard product ID                |
+| This keyboard uses a separate driver                      |
+\*---------------------------------------------------------*/
 #define CORSAIR_K55_RGB_PRO_XT_PID      0x1BA1
 
-/*-----------------------------------------------------*\
-| Corsair K65 Mini Keyboard product ID                  |
-| This keyboard uses a separate driver                  |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Corsair K65 Mini Keyboard product ID                      |
+| This keyboard uses a separate driver                      |
+\*---------------------------------------------------------*/
 #define CORSAIR_K65_MINI_PID            0x1BAF
 
-void DetectCorsairK55RGBPROXTControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCorsairK55RGBPROXTControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
-        CorsairK55RGBPROXTController*   controller       = new CorsairK55RGBPROXTController(dev, info->path, name);
+        CorsairK55RGBPROXTController*     controller     = new CorsairK55RGBPROXTController(dev, info->path, name);
         RGBController_CorsairK55RGBPROXT* rgb_controller = new RGBController_CorsairK55RGBPROXT(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectCorsairK55RGBPROXTControllers() */
 
-void DetectCorsairK65MiniControllers(hid_device_info* info, const std::string& name)
+    return(detected_controllers);
+}
+
+DetectedControllers DetectCorsairK65MiniControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CorsairK65MiniController*     controller        = new CorsairK65MiniController(dev, info->path, name);
         RGBController_CorsairK65Mini* rgb_controller    = new RGBController_CorsairK65Mini(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectCorsairK65MiniControllers() */
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairPeripheralControllers                                                     *
-*                                                                                          *
-*       Tests the USB address to see if a Corsair RGB Keyboard controller exists there.    *
-*                                                                                          *
-\******************************************************************************************/
-void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string& name)
+    return(detected_controllers);
+}
+
+DetectedControllers DetectCorsairPeripheralControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -156,7 +162,8 @@ void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string
                     (info->product_id == CORSAIR_K70_RGB_MK2_LP_PID);
 
             RGBController_CorsairPeripheral* rgb_controller = new RGBController_CorsairPeripheral(controller, supports_hardware_modes);
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+
+            detected_controllers.push_back(rgb_controller);
         }
         else
         {
@@ -164,11 +171,13 @@ void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string
             delete controller;
         }
     }
-}   /* DetectCorsairPeripheralControllers() */
 
-/*-----------------------------------------------------------------------------------------------------*\
-| Keyboards                                                                                             |
-\*-----------------------------------------------------------------------------------------------------*/
+    return(detected_controllers);
+}
+
+/*---------------------------------------------------------*\
+| Keyboards                                                 |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID,            1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K65 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_PID,            1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K65 LUX RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_LUX_RGB_PID,        1, 0xFFC2);
@@ -189,9 +198,9 @@ REGISTER_HID_DETECTOR_IP("Corsair K95 RGB PLATINUM SE",     DetectCorsairPeriphe
 REGISTER_HID_DETECTOR_IP("Corsair Strafe",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_PID,             1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Strafe Red",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_RED_PID,         1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Strafe MK.2",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_MK2_PID,         1, 0xFFC2);
-/*-----------------------------------------------------------------------------------------------------*\
-| Mice                                                                                                  |
-\*-----------------------------------------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Mice                                                      |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PID,         1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB PRO",          DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PRO_PID,     1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PID,        1, 0xFFC2);
@@ -206,29 +215,29 @@ REGISTER_HID_DETECTOR_IP("Corsair Scimitar PRO RGB",        DetectCorsairPeriphe
 REGISTER_HID_DETECTOR_IP("Corsair Scimitar Elite RGB",      DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_ELITE_RGB_PID, 1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Sabre RGB",               DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SABRE_RGB_PID,          1, 0xFFC2);
 
-/*-----------------------------------------------------------------------------------------------------*\
-| Mousemats                                                                                             |
-\*-----------------------------------------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Mousemats                                                 |
+\*---------------------------------------------------------*/
 #ifdef USE_HID_USAGE
 REGISTER_HID_DETECTOR_P("Corsair MM800 RGB Polaris",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_MM800_RGB_POLARIS_PID,  0xFFC2);
 #else
 REGISTER_HID_DETECTOR_I("Corsair MM800 RGB Polaris",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_MM800_RGB_POLARIS_PID,  0);
 #endif
-/*-----------------------------------------------------------------------------------------------------*\
-| Headset Stands                                                                                        |
-\*-----------------------------------------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Headset Stands                                            |
+\*---------------------------------------------------------*/
 #ifdef USE_HID_USAGE
 REGISTER_HID_DETECTOR_P("Corsair ST100 RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID,              0xFFC2);
 #else
 REGISTER_HID_DETECTOR_I("Corsair ST100 RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID,              0);
 #endif
 
-/*-----------------------------------------------------------------------------------------------------*\
-| Corsair K65 Mini Keyboard                                                                             |
-\*-----------------------------------------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Corsair K65 Mini Keyboard                                 |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_I("Corsair K65 Mini",                 DetectCorsairK65MiniControllers,    CORSAIR_VID, CORSAIR_K65_MINI_PID,           1);
 
-/*-----------------------------------------------------------------------------------------------------*\
-| Corsair K55 RGB PRO XT Keyboard                                                                       |
-\*-----------------------------------------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Corsair K55 RGB PRO XT Keyboard                           |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO XT",          DetectCorsairK55RGBPROXTControllers, CORSAIR_VID, CORSAIR_K55_RGB_PRO_XT_PID,    1, 0xFF42);

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2ControllerDetect.cpp

@@ -7,55 +7,65 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-/*-----------------------------------------------------*\
-| OpenRGB includes                                      |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| OpenRGB includes                                          |
+\*---------------------------------------------------------*/
 #include <hidapi.h>
 #include "DetectionManager.h"
 
-/*-----------------------------------------------------*\
-| Corsair Peripheral specific includes                  |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Corsair Peripheral specific includes                      |
+\*---------------------------------------------------------*/
 #include "CorsairPeripheralV2Devices.h"
 #include "RGBController_CorsairV2Hardware.h"
 #include "RGBController_CorsairV2Software.h"
 
 #define CORSAIR_PERIPHERAL_CONTROLLER_NAME "Corsair V2 Peripheral"
 
-/*-----------------------------------------------------*\
-| Corsair vendor ID                                     |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Corsair vendor ID                                         |
+\*---------------------------------------------------------*/
 #define CORSAIR_VID                                 0x1B1C
 
-void DetectCorsairV2HardwareControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCorsairV2HardwareControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CorsairPeripheralV2HWController*    controller      = new CorsairPeripheralV2HWController(dev, info->path, name);
         RGBController_CorsairV2HW*          rgb_controller  = new RGBController_CorsairV2HW(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectCorsairV2HardwareControllers() */
 
-void DetectCorsairV2SoftwareControllers(hid_device_info* info, const std::string& name)
+    return(detected_controllers);
+}
+
+DetectedControllers DetectCorsairV2SoftwareControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CorsairPeripheralV2SWController*    controller      = new CorsairPeripheralV2SWController(dev, info->path, name);
         RGBController_CorsairV2SW*          rgb_controller  = new RGBController_CorsairV2SW(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectCorsairV2SoftwareControllers() */
 
-/*-----------------------------------------------------------------------------------------------------*\
-| Keyboards                                                                                             |
-\*-----------------------------------------------------------------------------------------------------*/
+    return(detected_controllers);
+}
+
+/*---------------------------------------------------------*\
+| Keyboards                                                 |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K55_RGB_PRO_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO Low Profile",         DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_LP_PID,             1,  0xFF42);
@@ -71,9 +81,9 @@ REGISTER_HID_DETECTOR_IP("Corsair K100 RGB Optical",                DetectCorsai
 REGISTER_HID_DETECTOR_IP("Corsair K100 RGB Optical",                DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K100_OPTICAL_V2_PID,            1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K100 MX Red",                     DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K100_MXRED_PID,                 1,  0xFF42);
 
-/*-----------------------------------------------------------------------------------------------------*\
-| Mice                                                                                                  |
-\*-----------------------------------------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Mice                                                      |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("Corsair Dark Core RGB SE (Wired)",        DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_DARK_CORE_RGB_PID,              1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Dark Core RGB Pro SE (Wired)",    DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_DARK_CORE_RGB_PRO_PID,          1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Harpoon Wireless (Wired)",        DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_HARPOON_WIRELESS_PID,           1,  0xFF42);
@@ -89,9 +99,8 @@ REGISTER_HID_DETECTOR_IP("Corsair Slipstream Wireless Receiver HW", DetectCorsai
 REGISTER_HID_DETECTOR_IP("Corsair Slipstream Wireless Receiver SW", DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_SLIPSTREAM_WIRELESS_PID2,       1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Slipstream Wireless Receiver HW", DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_SLIPSTREAM_WIRELESS_V2_PID1,    1,  0xFF42);
 
-
-/*-----------------------------------------------------------------------------------------------------*\
-| Mousemat                                                                                              |
-\*-----------------------------------------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Mousemat                                                  |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("Corsair MM700",                           DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_MM700_PID,                      1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair MM700 3XL",                       DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_MM700_3XL_PID,                  1,  0xFF42);

Controllers/CorsairVengeanceController/CorsairVengeanceControllerDetect.cpp

@@ -11,19 +11,11 @@
 \*---------------------------------------------------------*/
 
 #include <vector>
-#include "DetectionManager.h"
 #include "CorsairVengeanceController.h"
-#include "RGBController_CorsairVengeance.h"
+#include "DetectionManager.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForCorsairVengeanceController                                                      *
-*                                                                                          *
-*       Tests the given address to see if a Corsair controller exists there.               *
-*                                                                                          *
-\******************************************************************************************/
+#include "RGBController_CorsairVengeance.h"
 
 bool TestForCorsairVengeanceController(i2c_smbus_interface* bus, unsigned char address)
 {
@@ -48,21 +40,12 @@ bool TestForCorsairVengeanceController(i2c_smbus_interface* bus, unsigned char a
 
     return(pass);
 
-}   /* TestForCorsairVengeanceController() */
+}
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairVengeanceControllers                                                      *
-*                                                                                          *
-*       Detect Corsair controllers on the enumerated I2C busses.                           *
-*                                                                                          *
-*           bus   - pointer to i2c_smbus_interface where device is connected               *
-*           slots - list of SPD entries with matching JEDEC ID                             *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairVengeanceControllers(i2c_smbus_interface* bus, std::vector<SPDWrapper*> &slots, const std::string &/*name*/)
+DetectedControllers DetectCorsairVengeanceControllers(i2c_smbus_interface* bus, std::vector<SPDWrapper*> &slots, const std::string &/*name*/)
 {
+    DetectedControllers detected_controllers;
+
     for(SPDWrapper *slot : slots)
     {
         /*-------------------------------------------------*\
@@ -72,10 +55,10 @@ void DetectCorsairVengeanceControllers(i2c_smbus_interface* bus, std::vector<SPD
 
         if(TestForCorsairVengeanceController(bus, address))
         {
-            CorsairVengeanceController*     new_controller    = new CorsairVengeanceController(bus, address);
-            RGBController_CorsairVengeance* new_rgbcontroller = new RGBController_CorsairVengeance(new_controller);
+            CorsairVengeanceController*     controller     = new CorsairVengeanceController(bus, address);
+            RGBController_CorsairVengeance* rgb_controller = new RGBController_CorsairVengeance(controller);
 
-            DetectionManager::get()->RegisterRGBController(new_rgbcontroller);
+            detected_controllers.push_back(rgb_controller);
         }
 
         /*-------------------------------------------------*\
@@ -85,12 +68,14 @@ void DetectCorsairVengeanceControllers(i2c_smbus_interface* bus, std::vector<SPD
 
         if(TestForCorsairVengeanceController(bus, address))
         {
-            CorsairVengeanceController*     new_controller    = new CorsairVengeanceController(bus, address);
-            RGBController_CorsairVengeance* new_rgbcontroller = new RGBController_CorsairVengeance(new_controller);
+            CorsairVengeanceController*     controller     = new CorsairVengeanceController(bus, address);
+            RGBController_CorsairVengeance* rgb_controller = new RGBController_CorsairVengeance(controller);
 
-            DetectionManager::get()->RegisterRGBController(new_rgbcontroller);
+            detected_controllers.push_back(rgb_controller);
         }
     }
-}   /* DetectCorsairVengeanceControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_I2C_DRAM_DETECTOR("Corsair Vengeance RGB DRAM", DetectCorsairVengeanceControllers, JEDEC_CORSAIR, SPD_DDR4_SDRAM);

Controllers/CorsairVengeanceProController/CorsairVengeanceProControllerDetect.cpp

@@ -19,14 +19,6 @@
 
 using namespace std::chrono_literals;
 
-/******************************************************************************************\
-*                                                                                          *
-*   TestForCorsairVengeanceProController                                                   *
-*                                                                                          *
-*       Tests the given address to see if a Corsair Pro controller exists there.           *
-*                                                                                          *
-\******************************************************************************************/
-
 bool TestForCorsairVengeanceProController(i2c_smbus_interface* bus, unsigned char address)
 {
     bool pass = false;
@@ -63,22 +55,11 @@ bool TestForCorsairVengeanceProController(i2c_smbus_interface* bus, unsigned cha
     std::this_thread::sleep_for(10ms);
 
     return(pass);
+}
 
-}   /* TestForCorsairVengeanceProController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairVengeanceProControllers                                                   *
-*                                                                                          *
-*       Detect Corsair Vengeance Pro controllers on the enumerated I2C busses.             *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           dev - I2C address of Aura device                                               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &busses)
+DetectedControllers DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &busses)
 {
+    DetectedControllers detected_controllers;
     for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         LOG_DEBUG("[%s] Testing bus %d", CORSAIR_VENGEANCE_RGB_PRO_NAME, bus);
@@ -89,10 +70,10 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
             {
                 if(TestForCorsairVengeanceProController(busses[bus], addr))
                 {
-                    CorsairVengeanceProController*     new_controller    = new CorsairVengeanceProController(busses[bus], addr);
-                    RGBController_CorsairVengeancePro* new_rgbcontroller = new RGBController_CorsairVengeancePro(new_controller);
+                    CorsairVengeanceProController*     controller     = new CorsairVengeanceProController(busses[bus], addr);
+                    RGBController_CorsairVengeancePro* rgb_controller = new RGBController_CorsairVengeancePro(controller);
 
-                    DetectionManager::get()->RegisterRGBController(new_rgbcontroller);
+                    detected_controllers.push_back(rgb_controller);
                 }
             }
         }
@@ -102,6 +83,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
         }
     }
 
-}   /* DetectCorsairVengeanceProControllers() */
+    return(detected_controllers);
+}
 
 REGISTER_I2C_DETECTOR("Corsair Vengeance Pro", DetectCorsairVengeanceProControllers);

Controllers/CorsairWirelessController/CorsairWirelessControllerDetect.cpp

@@ -15,28 +15,23 @@
 #include "RGBController.h"
 #include "RGBController_CorsairWireless.h"
 
-/*-----------------------------------------------------*\
-| Corsair vendor ID                                     |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Corsair vendor ID                                         |
+\*---------------------------------------------------------*/
 #define CORSAIR_VID                     0x1B1C
 
-/*-----------------------------------------------------*\
-| Keyboard product IDs                                  |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+\*---------------------------------------------------------*/
 #define CORSAIR_K57_RGB_WIRED_PID       0x1B6E
 #define CORSAIR_K57_RGB_WIRELESS_PID    0x1B62
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairWirelessControllers                                                       *
-*                                                                                          *
-*       Tests the USB address to see if a Corsair RGB Keyboard controller exists there.    *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairWirelessControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCorsairWirelessControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -46,17 +41,19 @@ void DetectCorsairWirelessControllers(hid_device_info* info, const std::string&
         if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
         {
             RGBController_CorsairWireless* rgb_controller = new RGBController_CorsairWireless(controller);
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
         else
         {
             delete controller;
         }
     }
-}   /* DetectCorsairWirelessControllers() */
 
-/*-----------------------------------------------------------------------------------------------------*\
-| Keyboards                                                                                             |
-\*-----------------------------------------------------------------------------------------------------*/
+    return(detected_controllers);
+}
+
+/*---------------------------------------------------------*\
+| Keyboards                                                 |
+\*---------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IPU("Corsair K57 RGB (Wired)",         DetectCorsairWirelessControllers,   CORSAIR_VID,    CORSAIR_K57_RGB_WIRED_PID,     1,  0xFF42, 1);
 //REGISTER_HID_DETECTOR_IPU("Corsair K57 RGB (Wireless)",      DetectCorsairWirelessControllers,   CORSAIR_VID,    CORSAIR_K57_RGB_WIRELESS_PID,  1,  0xFF42, 1);

Controllers/CougarController/CougarControllerDetect.cpp

@@ -7,46 +7,58 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
+#include "CougarKeyboardController.h"
+#include "CougarRevengerSTController.h"
 #include "DetectionManager.h"
 #include "RGBController_CougarKeyboard.h"
 #include "RGBController_CougarRevengerST.h"
 
-/*----------------------------------------------------------*\
-| Cougar vendor ID                                           |
-\*----------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Cougar vendor ID                                          |
+\*---------------------------------------------------------*/
 #define COUGAR_VID                                      0x12CF
 #define COUGAR_VID_2                                    0x060B
 
-/*----------------------------------------------------------*\
-| Product ID                                                 |
-\*----------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Product ID                                                |
+\*---------------------------------------------------------*/
 #define COUGAR_700K_EVO_PID                             0x7010
 #define COUGAR_REVENGER_ST_PID                          0x0412
 
-void DetectCougarRevengerSTControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCougarRevengerSTControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CougarRevengerSTController*     controller      = new CougarRevengerSTController(dev, *info, name);
         RGBController_CougarRevengerST* rgb_controller  = new RGBController_CougarRevengerST(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectCougar700kEvo(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCougar700kEvo(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
 
-    if (dev)
+    dev = hid_open_path(info->path);
+
+    if(dev)
     {
         CougarKeyboardController*     controller        = new CougarKeyboardController(dev, info->path, name);
         RGBController_CougarKeyboard* rgb_controller    = new RGBController_CougarKeyboard(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("Cougar 700K EVO Gaming Keyboard",        DetectCougar700kEvo,                COUGAR_VID_2,   COUGAR_700K_EVO_PID,    3, 0xFF00, 1);

Controllers/CreativeController/CreativeControllerDetect.cpp

@@ -9,29 +9,35 @@
 
 #include <hidapi.h>
 #include "CreativeSoundBlasterXG6Controller.h"
-#include "RGBController_CreativeSoundBlasterXG6.h"
 #include "DetectionManager.h"
+#include "RGBController_CreativeSoundBlasterXG6.h"
 
-/*-----------------------------------------------------*\
-| Creative vendor ID                                    |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Creative vendor ID                                        |
+\*---------------------------------------------------------*/
 #define CREATIVE_VID                            0x041E
-/*-----------------------------------------------------*\
-| SoundCards                                            |
-\*-----------------------------------------------------*/
+
+/*---------------------------------------------------------*\
+| SoundCards                                                |
+\*---------------------------------------------------------*/
 #define CREATIVE_SOUNDBLASTERX_G6_PID           0x3256
 
-void DetectCreativeDevice(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCreativeDevice(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CreativeSoundBlasterXG6Controller*     controller     = new CreativeSoundBlasterXG6Controller(dev, info->path, name);
         RGBController_CreativeSoundBlasterXG6* rgb_controller = new RGBController_CreativeSoundBlasterXG6(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 /*-------------------------------------------------------------------------------------------------------------------------------------------------*\

Controllers/CreativeController/CreativeSoundBlasterAE5ControllerDetect_Windows.cpp

@@ -9,11 +9,13 @@
 
 #include "DetectionManager.h"
 #include "CreativeSoundBlasterAE5Controller_Windows.h"
-#include "RGBController_CreativeSoundBlasterAE5_Windows.h"
 #include "LogManager.h"
+#include "RGBController_CreativeSoundBlasterAE5_Windows.h"
 
-void DetectCreativeAE5Device()
+DetectedControllers DetectCreativeAE5Device()
 {
+    DetectedControllers detected_controllers;
+
     LOG_INFO("[Creative SoundBlaster AE-5] Windows detection function called");
 
     CreativeSoundBlasterAE5Controller_Windows* controller = new CreativeSoundBlasterAE5Controller_Windows();
@@ -22,13 +24,16 @@ void DetectCreativeAE5Device()
     {
         LOG_INFO("[Creative SoundBlaster AE-5] Device initialized successfully, registering controller");
         RGBController_CreativeSoundBlasterAE5* rgb_controller = new RGBController_CreativeSoundBlasterAE5(controller);
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+
+        detected_controllers.push_back(rgb_controller);
     }
     else
     {
         LOG_WARNING("[Creative SoundBlaster AE-5] Device initialization failed");
         delete controller;
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_DETECTOR("Creative SoundBlaster AE-5", DetectCreativeAE5Device);

Controllers/CrucialController/CrucialControllerDetect.cpp

@@ -20,19 +20,20 @@
 
 using namespace std::chrono_literals;
 
-/*----------------------------------------------------------------------*\
-| This list contains the available SMBus addresses for Crucial RAM       |
-\*----------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| This list contains the available SMBus addresses for      |
+| Crucial RAM                                               |
+\*---------------------------------------------------------*/
 #define CRUCIAL_ADDRESS_COUNT  8
 
 static const unsigned char crucial_addresses[] =
 {
-/*-----------------------------------------------------*\
-| These addresses have been disabled due to conflict    |
-| with ASUS Aura DRAM.  Since the detection scheme is   |
-| the same, Aura RAM will be detected as Crucial.       |
-| We need to improve the Crucial detection scheme.      |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| These addresses have been disabled due to conflict with   |
+| ENE DRAM.  Since the detection scheme is the same, ENE    |
+| RAM will be detected as Crucial.  We need to improve the  |
+| Crucial detection scheme.                                 |
+\*---------------------------------------------------------*/
     0x39,
     0x3A,
     0x3B,
@@ -57,16 +58,6 @@ std::string concatHexArray(const unsigned char array[], int count, const char sp
 }
 #define TESTING_ADDRESSES concatHexArray(crucial_addresses, CRUCIAL_ADDRESS_COUNT, "|").c_str()
 
-/******************************************************************************************\
-*                                                                                          *
-*   CrucialRegisterRead                                                                    *
-*                                                                                          *
-*       A standalone version of the AuraSMBusController::AuraRegisterRead function for     *
-*       access to Aura devices without instancing the AuraSMBusController class or reading *
-*       the config table from the device.                                                  *
-*                                                                                          *
-\******************************************************************************************/
-
 unsigned char CrucialRegisterRead(i2c_smbus_interface* bus, crucial_dev_id dev, crucial_register reg)
 {
     //Write Aura register
@@ -76,16 +67,6 @@ unsigned char CrucialRegisterRead(i2c_smbus_interface* bus, crucial_dev_id dev,
     return(bus->i2c_smbus_read_byte_data(dev, 0x81));
 }
 
-/******************************************************************************************\
-*                                                                                          *
-*   TestForCrucialController                                                               *
-*                                                                                          *
-*       Tests the given address to see if an Crucial controller exists there.  First does a*
-*       quick write to test for a response, and if so does a simple read at 0xA0 to test   *
-*       for incrementing values 0...F which was observed at this location during data dump *
-*                                                                                          *
-\******************************************************************************************/
-
 bool TestForCrucialController(i2c_smbus_interface* bus, unsigned char address)
 {
     bool pass = false;
@@ -145,8 +126,7 @@ bool TestForCrucialController(i2c_smbus_interface* bus, unsigned char address)
     }
 
     return(pass);
-
-}   /* TestForCrucialController() */
+}
 
 void CrucialRegisterWrite(i2c_smbus_interface* bus, unsigned char dev, unsigned short reg, unsigned char val)
 {
@@ -157,19 +137,10 @@ void CrucialRegisterWrite(i2c_smbus_interface* bus, unsigned char dev, unsigned
     bus->i2c_smbus_write_byte_data(dev, 0x01, val);
 }
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCrucialControllers                                                               *
-*                                                                                          *
-*       Detect Crucial controllers on the enumerated I2C busses.                           *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           dev - I2C address of Aura device                                               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses)
+DetectedControllers DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses)
 {
+    DetectedControllers detected_controllers;
+
     for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         int address_list_idx = -1;
@@ -223,7 +194,7 @@ void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses)
                     CrucialController*     controller     = new CrucialController(busses[bus], crucial_addresses[address_list_idx]);
                     RGBController_Crucial* rgb_controller = new RGBController_Crucial(controller);
 
-                    DetectionManager::get()->RegisterRGBController(rgb_controller);
+                    detected_controllers.push_back(rgb_controller);
                 }
 
                 std::this_thread::sleep_for(1ms);
@@ -231,6 +202,7 @@ void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses)
         }
     }
 
-}   /* DetectCrucialControllers() */
+    return(detected_controllers);
+}
 
 REGISTER_I2C_DETECTOR("Crucial Ballistix", DetectCrucialControllers);

Controllers/CryorigH7QuadLumiController/CryorigH7QuadLumiControllerDetect.cpp

@@ -10,27 +10,32 @@
 \*---------------------------------------------------------*/
 
 #include <hidapi.h>
-#include "DetectionManager.h"
 #include "CryorigH7QuadLumiController.h"
+#include "DetectionManager.h"
 #include "RGBController_CryorigH7QuadLumi.h"
 
-/*-----------------------------------------------------*\
-| CRYORIG/NZXT USB IDs                                  |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| CRYORIG/NZXT USB IDs                                      |
+\*---------------------------------------------------------*/
 #define NZXT_VID                    0x1E71
 #define CRYORIG_H7_QUAD_LUMI_PID    0x1712
 
-static void DetectCryorigH7QuadLumi(hid_device_info* info, const std::string& name)
+DetectedControllers DetectCryorigH7QuadLumi(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         CryorigH7QuadLumiController*     controller     = new CryorigH7QuadLumiController(dev, info->path, name);
         RGBController_CryorigH7QuadLumi* rgb_controller = new RGBController_CryorigH7QuadLumi(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR("CRYORIG H7 Quad Lumi",   DetectCryorigH7QuadLumi, NZXT_VID,   CRYORIG_H7_QUAD_LUMI_PID);

Controllers/DDPController/DDPControllerDetect.cpp

@@ -19,11 +19,12 @@
 
 using json = nlohmann::json;
 
-void DetectDDPControllers()
+DetectedControllers DetectDDPControllers()
 {
-    json ddp_settings;
+    DetectedControllers                 detected_controllers;
+    json                                ddp_settings;
     std::vector<std::vector<DDPDevice>> device_lists;
-    DDPDevice dev;
+    DDPDevice                           dev;
 
     ddp_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("DDPDevices");
 
@@ -85,9 +86,11 @@ void DetectDDPControllers()
         for(unsigned int list_idx = 0; list_idx < device_lists.size(); list_idx++)
         {
             RGBController_DDP* rgb_controller = new RGBController_DDP(device_lists[list_idx]);
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_DETECTOR("DDP", DetectDDPControllers);

Controllers/DMXController/DMXControllerDetect.cpp

@@ -15,36 +15,29 @@
 #include "RGBController_DMX.h"
 #include "SettingsManager.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectDMXControllers                                                                   *
-*                                                                                          *
-*       Detect devices supported by the DMX driver                                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectDMXControllers()
+DetectedControllers DetectDMXControllers()
 {
+    DetectedControllers detected_controllers;
     json                dmx_settings;
 
     std::vector<std::vector<DMXDevice>> device_lists;
 	DMXDevice dev;
 
-    /*-------------------------------------------------*\
-    | Get DMX settings from settings manager            |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Get DMX settings from settings manager                |
+    \*-----------------------------------------------------*/
     dmx_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("DMXDevices");
 
-    /*-------------------------------------------------*\
-    | If the DMX settings contains devices, process     |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | If the DMX settings contains devices, process         |
+    \*-----------------------------------------------------*/
     if(dmx_settings.contains("devices"))
     {
         for(unsigned int device_idx = 0; device_idx < dmx_settings["devices"].size(); device_idx++)
         {
-            /*-------------------------------------------------*\
-            | Clear DMX device data                             |
-            \*-------------------------------------------------*/
+            /*---------------------------------------------*\
+            | Clear DMX device data                         |
+            \*---------------------------------------------*/
             dev.name           = "";
             dev.keepalive_time = 0;
 
@@ -83,26 +76,28 @@ void DetectDMXControllers()
                 dev.brightness_channel = dmx_settings["devices"][device_idx]["brightness_channel"];
             }
 
-            /*---------------------------------------------------------*\
-            | Determine whether to create a new list or add this device |
-            | to an existing list.  A device is added to an existing    |
-            | list if both devices share one or more universes for the  |
-            | same output destination                                   |
-            \*---------------------------------------------------------*/
+            /*---------------------------------------------*\
+            | Determine whether to create a new list or add |
+            | this device to an existing list.  A device is |
+            | added to an existing list if both devices     |
+            | share one or more universes for the same      |
+            | output destination                            |
+            \*---------------------------------------------*/
             bool device_added_to_existing_list = false;
 
-            /*---------------------------------------------------------*\
-            | Track grouping for all controllers.                       |
-            \*---------------------------------------------------------*/
+            /*---------------------------------------------*\
+            | Track grouping for all controllers.           |
+            \*---------------------------------------------*/
             for(unsigned int list_idx = 0; list_idx < device_lists.size(); list_idx++)
             {
                 for(unsigned int device_idx = 0; device_idx < device_lists[list_idx].size(); device_idx++)
                 {
-                    /*---------------------------------------------------------*\
-                    | Check if the port used by this new device is the same as  |
-                    | in the existing device.  If so, add the new device to the |
-                    | existing list.                                            |
-                    \*---------------------------------------------------------*/
+                    /*-------------------------------------*\
+                    | Check if the port used by this new    |
+                    | device is the same as in the existing |
+                    | device.  If so, add the new device to |
+                    | the existing list.                    |
+                    \*-------------------------------------*/
                     if(1)
                     {
                         device_lists[list_idx].push_back(dev);
@@ -131,15 +126,16 @@ void DetectDMXControllers()
             }
         }
 
-
         for(unsigned int list_idx = 0; list_idx < device_lists.size(); list_idx++)
         {
             RGBController_DMX* rgb_controller;
             rgb_controller = new RGBController_DMX(device_lists[list_idx]);
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+
+            detected_controllers.push_back(rgb_controller);
         }
     }
 
-}   /* DetectDMXControllers() */
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR("DMX", DetectDMXControllers);

Controllers/DRGBController/DRGBControllerDetect.cpp

@@ -14,9 +14,12 @@
 #include "DRGBController.h"
 #include "RGBController_DRGB.h"
 
-void DetectDRGBControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectDRGBControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -27,8 +30,10 @@ void DetectDRGBControllers(hid_device_info* info, const std::string& name)
         DRGBController*     controller              = new DRGBController(dev, info->path, info->product_id, name);
         RGBController_DRGB* rgb_controller          = new RGBController_DRGB(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR("DeepRGB LED V4",             DetectDRGBControllers, DRGBV4_VID,  DRGB_LED_V4_PID);

Controllers/DarkProject/DarkProjectControllerDetect.cpp

@@ -22,17 +22,22 @@
 \*---------------------------------------------------------*/
 #define KD3B_V2_PID                                    0x2061
 
-void DetectDarkProjectKeyboardControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectDarkProjectKeyboardControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         DarkProjectKeyboardController*     controller       = new DarkProjectKeyboardController(dev, info->path, name);
         RGBController_DarkProjectKeyboard* rgb_controller   = new RGBController_DarkProjectKeyboard(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("Dark Project KD3B V2", DetectDarkProjectKeyboardControllers, DARKPROJECT_VID, KD3B_V2_PID, 2, 0xFFC2, 4);

Controllers/DasKeyboardController/DasKeyboardControllerDetect.cpp

@@ -14,34 +14,28 @@
 #include "RGBController_DasKeyboard.h"
 #include <hidapi.h>
 
-/*-----------------------------------------------------*\
-| Das Keyboard vendor ID                                |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Das Keyboard vendor ID                                    |
+\*---------------------------------------------------------*/
 #define DAS_KEYBOARD_VID                0x24F0
 
-/*-----------------------------------------------------*\
-| Keyboard product IDs                                  |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+\*---------------------------------------------------------*/
 #define DAS_KEYBOARD_Q4_PID             0x2037
 #define DAS_KEYBOARD_Q5_PID             0x2020
 #define DAS_KEYBOARD_Q5S_PID            0x209A
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectDasKeyboardControllers                                                           *
-*                                                                                          *
-*       Tests the USB address to see if a Das Keyboard RGB controller exists there.        *
-*       We need the second interface to communicate with the keyboard                      *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectDasKeyboardControllers(hid_device_info *info, const std::string &name)
+DetectedControllers DetectDasKeyboardControllers(hid_device_info *info, const std::string &name)
 {
-    hid_device *dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
-        DasKeyboardController *controller = new DasKeyboardController(dev, info->path, name);
+        DasKeyboardController* controller = new DasKeyboardController(dev, info->path, name);
 
         if(controller->GetLayoutString() == "NONE")
         {
@@ -49,12 +43,14 @@ void DetectDasKeyboardControllers(hid_device_info *info, const std::string &name
         }
         else
         {
-            RGBController_DasKeyboard *rgb_controller = new RGBController_DasKeyboard(controller);
+            RGBController_DasKeyboard* rgb_controller = new RGBController_DasKeyboard(controller);
 
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
     }
-}   /* DetectDasKeyboardControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_HID_DETECTOR_IPU("Das Keyboard Q4 RGB",  DetectDasKeyboardControllers, DAS_KEYBOARD_VID, DAS_KEYBOARD_Q4_PID,  1,    0x01,   0x80);
 REGISTER_HID_DETECTOR_I  ("Das Keyboard Q5 RGB",  DetectDasKeyboardControllers, DAS_KEYBOARD_VID, DAS_KEYBOARD_Q5_PID,  1);

Controllers/DebugController/DebugControllerDetect.cpp

@@ -15,17 +15,10 @@
 #include "RGBController_Debug.h"
 #include "SettingsManager.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectDebugControllers                                                                 *
-*                                                                                          *
-*       Add debug controllers based on the DebugDevices key in the settings json           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectDebugControllers()
+DetectedControllers DetectDebugControllers()
 {
-    json            debug_settings;
+    DetectedControllers detected_controllers;
+    json                debug_settings;
 
     /*-----------------------------------------------------*\
     | Get Debug Device settings from settings manager       |
@@ -39,12 +32,13 @@ void DetectDebugControllers()
     {
         for(unsigned int device_idx = 0; device_idx < debug_settings["devices"].size(); device_idx++)
         {
-            RGBController_Debug * debug_controller = new RGBController_Debug(false, debug_settings["devices"][device_idx]);
-            DetectionManager::get()->RegisterRGBController(debug_controller);
+            RGBController_Debug * rgb_controller = new RGBController_Debug(false, debug_settings["devices"][device_idx]);
+
+            detected_controllers.push_back(rgb_controller);
         }
     }
 
-    if (debug_settings.contains("CustomDevices"))
+    if(debug_settings.contains("CustomDevices"))
     {
         for(unsigned int device_idx = 0; device_idx < debug_settings["CustomDevices"].size(); device_idx++)
         {
@@ -68,12 +62,14 @@ void DetectDebugControllers()
             }
             else
             {
-                RGBController_Debug * debug_controller = new RGBController_Debug(true, custom_device_settings);
-                DetectionManager::get()->RegisterRGBController(debug_controller);
+                RGBController_Debug * rgb_controller = new RGBController_Debug(true, custom_device_settings);
+
+                detected_controllers.push_back(rgb_controller);
             }
         }
     }
 
-}   /* DetectDebugControllers() */
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR("Debug Controllers", DetectDebugControllers);

Controllers/DreamCheekyController/DreamCheekyControllerDetect.cpp

@@ -23,17 +23,22 @@
 \*---------------------------------------------------------*/
 #define DREAM_CHEEKY_WEBMAIL_NOTIFIER_PID           0x0004
 
-void DetectDreamCheekyControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectDreamCheekyControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         DreamCheekyController*     controller     = new DreamCheekyController(dev, info->path, name);
         RGBController_DreamCheeky* rgb_controller = new RGBController_DreamCheeky(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR( "Dream Cheeky Webmail Notifier", DetectDreamCheekyControllers, DREAM_CHEEKY_VID, DREAM_CHEEKY_WEBMAIL_NOTIFIER_PID );

Controllers/DuckyKeyboardController/DuckyKeyboardControllerDetect.cpp

@@ -9,31 +9,28 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
+#include <hidapi.h>
 #include "DetectionManager.h"
 #include "DuckyKeyboardController.h"
 #include "RGBController_DuckyKeyboard.h"
-#include <hidapi.h>
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectDuckyKeyboardControllers                                                         *
-*                                                                                          *
-*       Tests the USB address to see if a Ducky RGB Keyboard controller exists there.      *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectDuckyKeyboardControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectDuckyKeyboardControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         DuckyKeyboardController*     controller     = new DuckyKeyboardController(dev, info->path, info->product_id, name);
         RGBController_DuckyKeyboard* rgb_controller = new RGBController_DuckyKeyboard(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectDuckyKeyboardControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_HID_DETECTOR_I("Ducky Shine 7/Ducky One 2 RGB", DetectDuckyKeyboardControllers, DUCKY_VID, DUCKY_SHINE_7_ONE_2_RGB_PID, 1);
 REGISTER_HID_DETECTOR_I("Ducky One 2 RGB TKL",           DetectDuckyKeyboardControllers, DUCKY_VID, DUCKY_ONE_2_RGB_TKL_PID,     1);

Controllers/DygmaRaiseController/DygmaRaiseControllerDetect.cpp

@@ -9,27 +9,19 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
+#include <vector>
 #include "DetectionManager.h"
 #include "DygmaRaiseController.h"
-#include "RGBController_DygmaRaise.h"
 #include "find_usb_serial_port.h"
-#include <vector>
+#include "RGBController_DygmaRaise.h"
 
 #define DYGMA_RAISE_VID 0x1209
 #define DYGMA_RAISE_PID 0x2201
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectDygmaRaiseControllers                                                            *
-*                                                                                          *
-*       Tests the USB address to see if a DygmaRaise keyboard exists there.                *
-*       Then opens a serial port to communicate with the KB                                *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectDygmaRaiseControllers()
+DetectedControllers DetectDygmaRaiseControllers()
 {
-    std::vector<std::string *> ports = find_usb_serial_port(DYGMA_RAISE_VID, DYGMA_RAISE_PID);
+    DetectedControllers         detected_controllers;
+    std::vector<std::string *>  ports = find_usb_serial_port(DYGMA_RAISE_VID, DYGMA_RAISE_PID);
 
     for(std::size_t i = 0; i < ports.size(); i++)
     {
@@ -39,9 +31,12 @@ void DetectDygmaRaiseControllers()
             controller->Initialize((char *)ports[i]->c_str());
 
             RGBController_DygmaRaise* rgb_controller = new RGBController_DygmaRaise(controller);
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+
+            detected_controllers.push_back(rgb_controller);
         }
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_DETECTOR("Dygma Raise", DetectDygmaRaiseControllers);

Controllers/E131Controller/E131ControllerDetect.cpp

@@ -16,36 +16,29 @@
 #include "RGBController_E131.h"
 #include "SettingsManager.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectE131Controllers                                                                  *
-*                                                                                          *
-*       Detect devices supported by the E131 driver                                        *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectE131Controllers()
+DetectedControllers DetectE131Controllers()
 {
+    DetectedControllers detected_controllers;
     json                e131_settings;
 
     std::vector<std::vector<E131Device>> device_lists;
 	E131Device dev;
 
-    /*-------------------------------------------------*\
-    | Get E1.31 settings from settings manager          |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Get E1.31 settings from settings manager              |
+    \*-----------------------------------------------------*/
     e131_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("E131Devices");
 
-    /*-------------------------------------------------*\
-    | If the E1.31 settings contains devices, process   |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | If the E1.31 settings contains devices, process       |
+    \*-----------------------------------------------------*/
     if(e131_settings.contains("devices"))
     {
         for(unsigned int device_idx = 0; device_idx < e131_settings["devices"].size(); device_idx++)
         {
-            /*-------------------------------------------------*\
-            | Clear E1.31 device data                           |
-            \*-------------------------------------------------*/
+            /*---------------------------------------------*\
+            | Clear E1.31 device data                       |
+            \*---------------------------------------------*/
             dev.name           = "";
             dev.ip             = "";
             dev.type           = ZONE_TYPE_SINGLE;
@@ -211,28 +204,32 @@ void DetectE131Controllers()
                 }
             }
 
-            /*---------------------------------------------------------*\
-            | Determine whether to create a new list or add this device |
-            | to an existing list.  A device is added to an existing    |
-            | list if both devices share one or more universes for the  |
-            | same output destination                                   |
-            \*---------------------------------------------------------*/
+            /*---------------------------------------------*\
+            | Determine whether to create a new list or add |
+            | this device to an existing list.  A device is |
+            | added to an existing list if both devices     |
+            | share one or more universes for the same      |
+            |output destination                             |
+            \*---------------------------------------------*/
             bool device_added_to_existing_list = false;
 
-            /*---------------------------------------------------------*\
-            | Track grouping for all controllers.                       |
-            \*---------------------------------------------------------*/
+            /*---------------------------------------------*\
+            | Track grouping for all controllers.           |
+            \*---------------------------------------------*/
             for(unsigned int list_idx = 0; list_idx < device_lists.size(); list_idx++)
             {
                 for(unsigned int device_idx = 0; device_idx < device_lists[list_idx].size(); device_idx++)
                 {
-                    /*---------------------------------------------------------*\
-                    | Determine if there is any overlap between this device and |
-                    | any existing device list                                  |
-                    | Offset the end by two - one because the range is 1-512    |
-                    | rather than 0-511, and one because the start channel is   |
-                    | included in the first set of 3 channels.                  |
-                    \*---------------------------------------------------------*/
+                    /*-------------------------------------*\
+                    | Determine if there is any overlap     |
+                    | between this device and any existing  |
+                    | device list                           |
+                    | Offset the end by two - one because   |
+                    | the range is 1-512 rather than 0-511, |
+                    | and one because the start channel is  |
+                    | included in the first set of 3        |
+                    | channels.                             |
+                    \*-------------------------------------*/
                     unsigned int dev_start  = dev.start_universe;
                     unsigned int list_start = device_lists[list_idx][device_idx].start_universe;
                     unsigned int dev_end    = dev.start_universe + ((dev.start_channel + (3 * dev.num_leds) - 2) / 512);
@@ -242,11 +239,12 @@ void DetectE131Controllers()
 
                     bool overlap = dev_ip == list_ip && !(dev_end < list_start || list_end < dev_start);
 
-                    /*---------------------------------------------------------*\
-                    | Check if any universes used by this new device exist in   |
-                    | the existing device.  If so, add the new device to the    |
-                    | existing list.                                            |
-                    \*---------------------------------------------------------*/
+                    /*-------------------------------------*\
+                    | Check if any universes used by this   |
+                    | new device exist in the existing      |
+                    | device.  If so, add the new device to |
+                    | the existing list.                    |
+                    \*-------------------------------------*/
                     if(overlap)
                     {
                         device_lists[list_idx].push_back(dev);
@@ -261,10 +259,10 @@ void DetectE131Controllers()
                 }
             }
 
-            /*---------------------------------------------------------*\
-            | If the device did not overlap with existing devices,      |
-            | create a new list for it                                  |
-            \*---------------------------------------------------------*/
+            /*---------------------------------------------*\
+            | If the device did not overlap with existing   |
+            | devices, create a new list for it             |
+            \*---------------------------------------------*/
             if(!device_added_to_existing_list)
             {
                 std::vector<E131Device> new_list;
@@ -279,10 +277,12 @@ void DetectE131Controllers()
         {
             RGBController_E131* rgb_controller;
             rgb_controller = new RGBController_E131(device_lists[list_idx]);
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+
+            detected_controllers.push_back(rgb_controller);
         }
     }
 
-}   /* DetectE131Controllers() */
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR("E1.31", DetectE131Controllers);

Controllers/EKController/EKControllerDetect.cpp

@@ -17,25 +17,22 @@
 #define EK_VID                0x0483
 #define EK_LOOP_CONNECT       0x5750
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectEKControllers                                                                    *
-*                                                                                          *
-*       Tests the USB address to see if any EK Controllers exists there.                   *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectEKControllers(hid_device_info* info, const std::string&)
+DetectedControllers DetectEKControllers(hid_device_info* info, const std::string&)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         EKController*               controller     = new EKController(dev, info->path);
         RGBController_EKController* rgb_controller = new RGBController_EKController(controller);
-        // Constructor sets the name
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectEKControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_HID_DETECTOR_IPU("EK Loop Connect", DetectEKControllers, EK_VID, EK_LOOP_CONNECT, 0, 0xFFA0, 1);

Controllers/ENESMBusController/ENESMBusController.h

@@ -15,6 +15,14 @@
 #include "ENESMBusInterface.h"
 #include "RGBController.h"
 
+/*---------------------------------------------------------*\
+| Windows defines "interface" for some reason. Work around  |
+| this                                                      |
+\*---------------------------------------------------------*/
+#ifdef interface
+#undef interface
+#endif
+
 #define ENE_APPLY_VAL                   0x01        /* Value for Apply Changes Register     */
 #define ENE_SAVE_VAL                    0xAA        /* Value for Save Changes               */
 #define ENE_NUM_ZONES                   8           /* Number of ENE config table zones     */

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -9,30 +9,33 @@
 
 #include <vector>
 #include "DetectionManager.h"
+#include "dmiinfo.h"
 #include "ENESMBusController.h"
 #include "ENESMBusInterface_i2c_smbus.h"
+#include "i2c_smbus.h"
 #include "LogManager.h"
+#include "pci_ids.h"
 #include "RGBController.h"
 #include "RGBController_ENESMBus.h"
-#include "i2c_smbus.h"
-#include "pci_ids.h"
-#include "dmiinfo.h"
-
-#define DETECTOR_NAME   "ENE (ASUS Aura) SMBus Controller"
-#define VENDOR_NAME     "ASUS"                                  //This should match the Vendor name from DMI
 
 using namespace std::chrono_literals;
 
-/*----------------------------------------------------------------------*\
-| Windows defines "interface" for some reason. Work around this          |
-\*----------------------------------------------------------------------*/
+#define DETECTOR_NAME                   "ENE (ASUS Aura) SMBus Controller"
+#define VENDOR_NAME                     "ASUS"                                  //This should match the Vendor name from DMI
+#define GPU_CHECK_DEVICE_MESSAGE_EN     "[%s] Bus %02d is a GPU and the subvendor matches the one for %s, looking for a device at 0x%02X"
+
+/*---------------------------------------------------------*\
+| Windows defines "interface" for some reason. Work around  |
+| this                                                      |
+\*---------------------------------------------------------*/
 #ifdef interface
 #undef interface
 #endif
 
-/*----------------------------------------------------------------------*\
-| This list contains the available SMBus addresses for mapping ENE RAM   |
-\*----------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| This list contains the available SMBus addresses for      |
+| mapping ENE RAM                                           |
+\*---------------------------------------------------------*/
 #define ENE_RAM_ADDRESS_COUNT  23
 
 static const unsigned char ene_ram_addresses[] =
@@ -62,9 +65,10 @@ static const unsigned char ene_ram_addresses[] =
     0x3D
 };
 
-/*---------------------------------------------------------------------------------*\
-| This list contains the available SMBus addresses for mapping Aura motherboards    |
-\*---------------------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| This list contains the available SMBus addresses for      |
+| mapping Aura motherboards                                 |
+\*---------------------------------------------------------*/
 #define AURA_MOBO_ADDRESS_COUNT 3
 
 static const unsigned char aura_mobo_addresses[] =
@@ -74,16 +78,6 @@ static const unsigned char aura_mobo_addresses[] =
     0x4F
 };
 
-/******************************************************************************************\
-*                                                                                          *
-*   ENERegisterRead                                                                        *
-*                                                                                          *
-*       A standalone version of the ENESMBusController::ENERegisterRead function for       *
-*       access to ENE devices without instancing the ENESMBusController class or reading   *
-*       the config table from the device.                                                  *
-*                                                                                          *
-\******************************************************************************************/
-
 static unsigned char ENERegisterRead(i2c_smbus_interface* bus, ene_dev_id dev, ene_register reg)
 {
     //Write ENE register
@@ -93,16 +87,6 @@ static unsigned char ENERegisterRead(i2c_smbus_interface* bus, ene_dev_id dev, e
     return(bus->i2c_smbus_read_byte_data(dev, 0x81));
 }
 
-/******************************************************************************************\
-*                                                                                          *
-*   ENERegisterWrite                                                                       *
-*                                                                                          *
-*       A standalone version of the ENESMBusController::ENERegisterWrite function for      *
-*       access to ENE devices without instancing the ENESMBusController class or reading   *
-*       the config table from the device.                                                  *
-*                                                                                          *
-\******************************************************************************************/
-
 static void ENERegisterWrite(i2c_smbus_interface* bus, ene_dev_id dev, ene_register reg, unsigned char val)
 {
     //Write ENE register
@@ -112,20 +96,6 @@ static void ENERegisterWrite(i2c_smbus_interface* bus, ene_dev_id dev, ene_regis
     bus->i2c_smbus_write_byte_data(dev, 0x01, val);
 }
 
-/******************************************************************************************\
-*                                                                                          *
-*   TestForENESMBusController                                                              *
-*                                                                                          *
-*       Tests the given address to see if an ENE controller exists there.  First does a    *
-*       quick write to test for a response, and if so does a simple read at 0xA0 to test   *
-*       for incrementing values 0...F which was observed at this location during data dump *
-*                                                                                          *
-*       Also tests for the string "Micron" in the ENE register space.  Crucial (Micron)    *
-*       DRAM modules use an ENE controller with custom, incompatible firmware and must     *
-*       be excluded from this controller.                                                  *
-*                                                                                          *
-\******************************************************************************************/
-
 bool TestForENESMBusController(i2c_smbus_interface* bus, unsigned char address)
 {
     bool pass = false;
@@ -181,23 +151,13 @@ bool TestForENESMBusController(i2c_smbus_interface* bus, unsigned char address)
     }
 
     return(pass);
+}
 
-}   /* TestForENESMBusController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectENESMBusDRAMControllers                                                          *
-*                                                                                          *
-*           Detects ENE SMBus controllers on DRAM devices                                  *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where device is connected                 *
-*           dev - I2C address of device                                                    *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
+DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
 {
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    DetectedControllers detected_controllers;
+
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         int address_list_idx = -1;
 
@@ -205,14 +165,13 @@ void DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
         {
             LOG_DEBUG("[ENE SMBus DRAM] Remapping ENE SMBus RAM modules on 0x77");
 
-            for (unsigned int slot = 0; slot < 8; slot++)
+            for(unsigned int slot = 0; slot < 8; slot++)
             {
                 int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
 
                 if(res < 0)
                 {
                     LOG_DEBUG("[ENE SMBus DRAM] No device detected at 0x77, aborting remap");
-
                     break;
                 }
 
@@ -230,7 +189,7 @@ void DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
                     {
                         break;
                     }
-                } while (res >= 0);
+                } while(res >= 0);
 
                 if(address_list_idx < ENE_RAM_ADDRESS_COUNT)
                 {
@@ -242,48 +201,41 @@ void DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
             }
 
             // Add ENE controllers at their remapped addresses
-            for (unsigned int address_list_idx = 0; address_list_idx < ENE_RAM_ADDRESS_COUNT; address_list_idx++)
+            for(unsigned int address_list_idx = 0; address_list_idx < ENE_RAM_ADDRESS_COUNT; address_list_idx++)
             {
-                if (TestForENESMBusController(busses[bus], ene_ram_addresses[address_list_idx]))
+                if(TestForENESMBusController(busses[bus], ene_ram_addresses[address_list_idx]))
                 {
                     ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(busses[bus]);
                     ENESMBusController*          controller     = new ENESMBusController(interface, ene_ram_addresses[address_list_idx], "ENE DRAM", DEVICE_TYPE_DRAM);
                     RGBController_ENESMBus*      rgb_controller = new RGBController_ENESMBus(controller);
 
-                    DetectionManager::get()->RegisterRGBController(rgb_controller);
+                    detected_controllers.push_back(rgb_controller);
                 }
 
                 std::this_thread::sleep_for(1ms);
             }
         }
     }
-}   /* DetectENESMBusDRAMControllers() */
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectENESMBusMotherboardControllers                                                   *
-*                                                                                          *
-*           Detects ENE (ASUS Aura) SMBus controllers on ASUS motherboard devices          *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           dev - I2C address of Aura device                                               *
-*                                                                                          *
-\******************************************************************************************/
+    return(detected_controllers);
+}
 
-void DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &busses)
+DetectedControllers DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &busses)
 {
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    DetectedControllers detected_controllers;
+
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         // Add ENE (ASUS Aura) motherboard controllers
         IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
             if(busses[bus]->pci_subsystem_vendor == ASUS_SUB_VEN || busses[bus]->pci_subsystem_vendor == 0 || busses[bus]->pci_subsystem_vendor == 0xFFFF)
             {
-                for (unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
+                for(unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
                 {
                     LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, aura_mobo_addresses[address_list_idx]);
 
-                    if (TestForENESMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
+                    if(TestForENESMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
                     {
                         DMIInfo dmi;
 
@@ -291,7 +243,7 @@ void DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &bus
                         ENESMBusController*          controller     = new ENESMBusController(interface, aura_mobo_addresses[address_list_idx], "ASUS " + dmi.getMainboard(), DEVICE_TYPE_MOTHERBOARD);
                         RGBController_ENESMBus*      rgb_controller = new RGBController_ENESMBus(controller);
 
-                        DetectionManager::get()->RegisterRGBController(rgb_controller);
+                        detected_controllers.push_back(rgb_controller);
                     }
 
                     std::this_thread::sleep_for(1ms);
@@ -303,41 +255,43 @@ void DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &bus
             }
         }
     }
-}   /* DetectENESMBusMotherboardControllers() */
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectENESMBusGPUControllers                                                           *
-*                                                                                          *
-*           Detects ENE (ASUS Aura) SMBus controllers on ASUS GPU devices                  *
-*                                                                                          *
-\******************************************************************************************/
+    return(detected_controllers);
+}
 
-#define GPU_CHECK_DEVICE_MESSAGE_EN     "[%s] Bus %02d is a GPU and the subvendor matches the one for %s, looking for a device at 0x%02X"
-
-void DetectENESMBusGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+DetectedControllers DetectENESMBusGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
+    DetectedControllers detected_controllers;
+
     if(TestForENESMBusController(bus, i2c_addr))
     {
         ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(bus);
         ENESMBusController*          controller     = new ENESMBusController(interface, i2c_addr, name, DEVICE_TYPE_GPU);
         RGBController_ENESMBus*      rgb_controller = new RGBController_ENESMBus(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
     else
     {
         LOG_DEBUG("[ENE SMBus ASUS GPU] Testing for controller at %d failed", i2c_addr);
     }
-} /* DetectENESMBusGPUControllers() */
 
+    return(detected_controllers);
+}
+
+/*---------------------------------------------------------*\
+| ENE RAM                                                   |
+\*---------------------------------------------------------*/
 REGISTER_I2C_DETECTOR("ENE SMBus DRAM",                 DetectENESMBusDRAMControllers);
+
+/*---------------------------------------------------------*\
+| ASUS Motherboards                                         |
+\*---------------------------------------------------------*/
 REGISTER_I2C_DETECTOR("ASUS Aura SMBus Motherboard",    DetectENESMBusMotherboardControllers);
 
-/*-----------------------------------------*\
-|  Nvidia GPUs                              |
-\*-----------------------------------------*/
-
+/*---------------------------------------------------------*\
+|  Nvidia GPUs                                              |
+\*---------------------------------------------------------*/
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 3050 Gaming",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3050_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX3050_8G_GAMING,               0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS KO GeForce RTX 3060 Gaming OC",                         DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_KO_RTX_3060_OC_O12G_GAMING,                0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 3060 Gaming OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_O12G_GAMING,                  0x67);
@@ -478,10 +432,9 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL LC GeForce RTX 5090 OC",
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL LC OC GeForce RTX 5090 OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_LC_OC_RTX_5090_O32G_GAMING,     0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG MATRIX PLATINUM GeForce RTX 5090",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_MATRIX_PLATINUM_RTX_5090_P32G,         0x67);
 
-/*-----------------------------------------*\
-|  AMD GPUs                                 |
-\*-----------------------------------------*/
-
+/*---------------------------------------------------------*\
+|  AMD GPUs                                                 |
+\*---------------------------------------------------------*/
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 6600 XT Gaming OC",                 DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI23_DEV,             ASUS_SUB_VEN,   ASUS_ROG_STRIX_RX_6600XT_O8G_GAMING,            0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 6650 XT Gaming",                    DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI23_DEV1,            ASUS_SUB_VEN,   ASUS_ROG_STRIX_RX_6650XT_O8G_GAMING,            0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF Radeon RX 6700 XT Gaming OC",                       DetectENESMBusGPUControllers,   AMD_GPU_VEN,    AMD_NAVI22_DEV,             ASUS_SUB_VEN,   ASUS_TUF_RX_6700XT_O12G_GAMING,                 0x67);

Controllers/ENESMBusController/ROGArionDetect.cpp

@@ -13,17 +13,12 @@
 #include "RGBController_ENESMBus.h"
 #include "scsiapi.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectROGArionControllers                                                              *
-*                                                                                          *
-*           Detects ENE SMBus controllers on ASUS ROG Arion devices                        *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectROGArionControllers()
+DetectedControllers DetectROGArionControllers()
 {
-    scsi_device_info * info = scsi_enumerate(NULL, NULL);
+    DetectedControllers detected_controllers;
+    scsi_device_info *  info;
+
+    info = scsi_enumerate(NULL, NULL);
 
     while(info)
     {
@@ -37,7 +32,7 @@ void DetectROGArionControllers()
                 ENESMBusController*         controller     = new ENESMBusController(interface, 0x67, "Asus ROG Strix Arion", DEVICE_TYPE_STORAGE);
                 RGBController_ENESMBus*     rgb_controller = new RGBController_ENESMBus(controller);
 
-                DetectionManager::get()->RegisterRGBController(rgb_controller);
+                detected_controllers.push_back(rgb_controller);
             }
         }
         info = info->next;
@@ -45,6 +40,7 @@ void DetectROGArionControllers()
 
     scsi_free_enumeration(info);
 
-}   /* DetectROGArionControllers() */
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR("ASUS ROG Arion", DetectROGArionControllers);

Controllers/ENESMBusController/XPGSpectrixS40GDetect_Linux.cpp

@@ -20,20 +20,15 @@
 #include "RGBController.h"
 #include "RGBController_ENESMBus.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectSpectrixS40GControllers                                                          *
-*                                                                                          *
-*           Detects ENE SMBus controllers on XPG Spectrix S40G NVMe devices                *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectSpectrixS40GControllers()
+DetectedControllers DetectSpectrixS40GControllers()
 {
-    /*---------------------------------------------------------------------*\
-    | Search for /dev/nvmeX nodes with model matching "XPG SPECTRIX S40G"   |
-    \*---------------------------------------------------------------------*/
-    unsigned int nvme_idx = 0;
+    DetectedControllers detected_controllers;
+
+    /*-----------------------------------------------------*\
+    | Search for /dev/nvmeX nodes with model matching       |
+    | "XPG SPECTRIX S40G"                                   |
+    \*-----------------------------------------------------*/
+    unsigned int        nvme_idx = 0;
 
     while(1)
     {
@@ -82,12 +77,14 @@ void DetectSpectrixS40GControllers()
                 ENESMBusController*             controller     = new ENESMBusController(interface, 0x67, "XPG Spectrix S40G", DEVICE_TYPE_STORAGE);
                 RGBController_ENESMBus*         rgb_controller = new RGBController_ENESMBus(controller);
 
-                DetectionManager::get()->RegisterRGBController(rgb_controller);
+                detected_controllers.push_back(rgb_controller);
             }
         }
 
         nvme_idx++;
     }
-}   /* DetectSpectrixS40GControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR(    "XPG Spectrix S40G",              DetectSpectrixS40GControllers);

Controllers/ENESMBusController/XPGSpectrixS40GDetect_Windows.cpp

@@ -19,21 +19,14 @@
 
 #define DEVBUFSIZE (128 * 1024)
 
-/*----------------------------------------------------------------------*\
-| Windows defines "interface" for some reason.  Work around this         |
-\*----------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Windows defines "interface" for some reason.  Work around |
+| this                                                      |
+\*---------------------------------------------------------*/
 #ifdef interface
 #undef interface
 #endif
 
-/******************************************************************************************\
-*                                                                                          *
-*   Search                                                                                 *
-*                                                                                          *
-*           Search for an NVMe device matching "XPG SPECTRIX S40G"                         *
-*                                                                                          *
-\******************************************************************************************/
-
 int Search(wchar_t *dev_name)
 {
     wchar_t buff[DEVBUFSIZE]  = L"";
@@ -61,14 +54,6 @@ int Search(wchar_t *dev_name)
     return 0;
 }
 
-/******************************************************************************************\
-*                                                                                          *
-*   OpenDevice                                                                             *
-*                                                                                          *
-*           Open a handle to the given device path                                         *
-*                                                                                          *
-\******************************************************************************************/
-
 HANDLE OpenDevice(wchar_t buff[MAX_PATH])
 {
     wchar_t path[MAX_PATH];
@@ -88,23 +73,14 @@ HANDLE OpenDevice(wchar_t buff[MAX_PATH])
     return(hDevice);
 }
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectSpectrixS40GControllers                                                          *
-*                                                                                          *
-*           Detects ENE SMBus controllers on XPG Spectrix S40G NVMe devices                *
-*                                                                                          *
-*           Tests for the existance of a file descriptor matching                          *
-*           SCSI#Disk&Ven_NVMe&Prod_XPG_SPECTRIX_S40# on Windows machines                  *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectSpectrixS40GControllers()
+DetectedControllers DetectSpectrixS40GControllers()
 {
+    DetectedControllers detected_controllers;
+
     /*-------------------------------------------------------------------------------------------------*\
     | https://docs.microsoft.com/en-us/windows-hardware/drivers/install/identifiers-for-scsi-devices    |
     \*-------------------------------------------------------------------------------------------------*/
-    wchar_t dev_name[MAX_PATH];
+    wchar_t             dev_name[MAX_PATH];
 
     if(Search(dev_name))
     {
@@ -116,10 +92,11 @@ void DetectSpectrixS40GControllers()
             ENESMBusController*             controller     = new ENESMBusController(interface, 0x67, "XPG Spectrix S40G", DEVICE_TYPE_STORAGE);
             RGBController_ENESMBus*         rgb_controller = new RGBController_ENESMBus(controller);
 
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
     }
-}   /* DetectSpectrixS40GControllers() */
 
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR(    "XPG Spectrix S40G",              DetectSpectrixS40GControllers);

Controllers/EVGAAmpereGPUController/EVGAAmpereGPUControllerDetect.cpp

@@ -11,24 +11,15 @@
 
 #include "DetectionManager.h"
 #include "EVGAGPUv3Controller.h"
-#include "LogManager.h"
-#include "RGBController_EVGAGPUv3.h"
 #include "i2c_smbus.h"
+#include "LogManager.h"
 #include "pci_ids.h"
+#include "RGBController_EVGAGPUv3.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectEVGAAmpereGPUControllers                                                         *
-*                                                                                          *
-*       Detect EVGA Ampere GPU controllers on the enumerated I2C busses at address 0x2D.   *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where EVGA GPU device is connected        *
-*           dev - I2C address of EVGA GPU device                                           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectEVGAAmpereGPUControllers(i2c_smbus_interface* bus, uint8_t address, const std::string& name)
+DetectedControllers DetectEVGAAmpereGPUControllers(i2c_smbus_interface* bus, uint8_t address, const std::string& name)
 {
+    DetectedControllers detected_controllers;
+
     if(bus->port_id == 1)
     {
         EVGAGPUv3Controller*     controller;
@@ -40,7 +31,7 @@ void DetectEVGAAmpereGPUControllers(i2c_smbus_interface* bus, uint8_t address, c
         {
             rgb_controller = new RGBController_EVGAGPUv3(controller);
 
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
         else
         {
@@ -48,7 +39,9 @@ void DetectEVGAAmpereGPUControllers(i2c_smbus_interface* bus, uint8_t address, c
             delete controller;
         }
     }
-}   /* DetectEVGAAmpereGPUControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3060 Ti FTW3 Gaming"                , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3060TI_FTW3_GAMING_SUB_DEV,             0x2D);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3060 Ti FTW3 Ultra"                 , DetectEVGAAmpereGPUControllers, NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3060TI_FTW3_ULTRA_SUB_DEV,              0x2D);

Controllers/EVGAGP102GPUController/EVGAGP102GPUControllerDetect.cpp

@@ -12,28 +12,17 @@
 #include <vector>
 #include "DetectionManager.h"
 #include "EVGAGP102Controller.h"
-#include "LogManager.h"
-#include "RGBController_EVGAGP102.h"
 #include "i2c_smbus.h"
+#include "LogManager.h"
 #include "pci_ids.h"
+#include "RGBController_EVGAGP102.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectEVGAGP102GPUControllers                                                          *
-*                                                                                          *
-*       Detect EVGA GP102 GPU controllers on the enumerated I2C busses at address 0x49.    *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where EVGA GPU device is connected        *
-*           address - unused, the address comes from the GPU zone info table               *
-*           name - name string of detected PCI device                                      *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectEVGAGP102GPUControllers(i2c_smbus_interface* bus, uint8_t /*address*/, const std::string& name)
+DetectedControllers DetectEVGAGP102GPUControllers(i2c_smbus_interface* bus, uint8_t /*address*/, const std::string& name)
 {
+    DetectedControllers detected_controllers;
+
     if(bus->port_id == 1)
     {
-        RGBController_EVGAGP102*            new_rgbcontroller;
         std::vector<EVGAGP102Controller*>   controllers;
 
         for(unsigned int i = 0; i < sizeof(gpuzoneinfos) / sizeof(zoneinfo); i++)
@@ -52,12 +41,14 @@ void DetectEVGAGP102GPUControllers(i2c_smbus_interface* bus, uint8_t /*address*/
 
         if(controllers.size() != 0)
         {
-            new_rgbcontroller = new RGBController_EVGAGP102(controllers);
+            RGBController_EVGAGP102* rgb_controller = new RGBController_EVGAGP102(controllers);
 
-            DetectionManager::get()->RegisterRGBController(new_rgbcontroller);
+            detected_controllers.push_back(rgb_controller);
         }
     }
-}   /* DetectEVGAGP102GPUControllers() */
+
+    return(detected_controllers);
+}
 
 /*---------------------------------------------------------*\
 | The I2C address is provided by the GPU Zone Info table,   |

Controllers/EVGAPascalGPUController/EVGAPascalGPUControllerDetect.cpp

@@ -11,32 +11,25 @@
 
 #include "DetectionManager.h"
 #include "EVGAGPUv1Controller.h"
-#include "LogManager.h"
-#include "RGBController_EVGAGPUv1.h"
 #include "i2c_smbus.h"
+#include "LogManager.h"
 #include "pci_ids.h"
+#include "RGBController_EVGAGPUv1.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectEVGAGPUControllers                                                               *
-*                                                                                          *
-*       Detect EVGA Pascal GPU controllers on the enumerated I2C busses at address 0x49.   *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where EVGA GPU device is connected        *
-*           dev - I2C address of EVGA GPU device                                           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectEVGAPascalGPUControllers(i2c_smbus_interface* bus, uint8_t address, const std::string& name)
+DetectedControllers DetectEVGAPascalGPUControllers(i2c_smbus_interface* bus, uint8_t address, const std::string& name)
 {
+    DetectedControllers detected_controllers;
+
     if(bus->port_id == 1)
     {
         EVGAGPUv1Controller*     controller     = new EVGAGPUv1Controller(bus, address, name);
         RGBController_EVGAGPUv1* rgb_controller = new RGBController_EVGAGPUv1(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectEVGAPascalGPUControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce GTX 1070 FTW DT Gaming",    DetectEVGAPascalGPUControllers, NVIDIA_VEN, NVIDIA_GTX1070_DEV,     EVGA_SUB_VEN,   EVGA_GTX1070_FTW_DT_GAMING_SUB_DEV, 0x49);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce GTX 1070 FTW",              DetectEVGAPascalGPUControllers, NVIDIA_VEN, NVIDIA_GTX1070_DEV,     EVGA_SUB_VEN,   EVGA_GTX1070_FTW_SUB_DEV,           0x49);

Controllers/EVGASMBusController/EVGASMBusControllerDetect.cpp

@@ -12,22 +12,12 @@
 #include <vector>
 #include "DetectionManager.h"
 #include "EVGAACX30SMBusController.h"
-#include "LogManager.h"
-#include "RGBController_EVGAACX30SMBus.h"
 #include "i2c_smbus.h"
+#include "LogManager.h"
 #include "pci_ids.h"
+#include "RGBController_EVGAACX30SMBus.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   TestForAcx30SMBusController                                                            *
-*                                                                                          *
-*       Tests the given address to see if an EVGA ACX 30 controller exists there.          *
-*       First does a quick write to test for a response                                    *
-*       Then checks if it has 1st bit set in register 1                                    *
-*                                                                                          *
-\******************************************************************************************/
-
-#define EVGA_DETECTOR_NAME        "EVGA SMBus Detectector"
+#define EVGA_DETECTOR_NAME          "EVGA SMBus Detector"
 #define VENDOR_NAME                 "EVGA"
 #define SMBUS_ADDRESS               0x28
 
@@ -48,18 +38,12 @@ bool TestForAcx30SMBusController(i2c_smbus_interface *bus, uint8_t address)
     }
 
     return(pass);
-} /* TestForAcx30SMBusController() */
+}
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAcx30SMBusControllers                                                            *
-*                                                                                          *
-*       Detect EVGA ACX 30 SMBus controllers on the enumerated I2C busses at address 0x28. *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAcx30SMBusControllers(std::vector<i2c_smbus_interface *> &busses)
+DetectedControllers DetectAcx30SMBusControllers(std::vector<i2c_smbus_interface *> &busses)
 {
+    DetectedControllers detected_controllers;
+
     for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
@@ -70,10 +54,10 @@ void DetectAcx30SMBusControllers(std::vector<i2c_smbus_interface *> &busses)
                 // Check for ACX 30 controller at 0x28
                 if(TestForAcx30SMBusController(busses[bus], SMBUS_ADDRESS))
                 {
-                    EVGAACX30SMBusController *controller = new EVGAACX30SMBusController(busses[bus], SMBUS_ADDRESS);
-                    RGBController_EVGAACX30SMBus *rgb_controller = new RGBController_EVGAACX30SMBus(controller);
+                    EVGAACX30SMBusController *     controller     = new EVGAACX30SMBusController(busses[bus], SMBUS_ADDRESS);
+                    RGBController_EVGAACX30SMBus * rgb_controller = new RGBController_EVGAACX30SMBus(controller);
 
-                    DetectionManager::get()->RegisterRGBController(rgb_controller);
+                    detected_controllers.push_back(rgb_controller);
                 }
             }
             else
@@ -82,6 +66,8 @@ void DetectAcx30SMBusControllers(std::vector<i2c_smbus_interface *> &busses)
             }
         }
     }
-} /* DetectAcx30SMBusControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_I2C_DETECTOR("EVGA Motherboard SMBus Controllers", DetectAcx30SMBusControllers);

Controllers/EVGATuringGPUController/EVGATuringGPUControllerDetect.cpp

@@ -11,31 +11,24 @@
 
 #include "DetectionManager.h"
 #include "EVGAGPUv2Controller.h"
-#include "RGBController_EVGAGPUv2.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
+#include "RGBController_EVGAGPUv2.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectEVGATuringGPUControllers                                                         *
-*                                                                                          *
-*       Detect EVGA Turing GPU controllers on the enumerated I2C busses at address 0x49.   *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where EVGA GPU device is connected        *
-*           dev - I2C address of EVGA GPU device                                           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectEVGATuringGPUControllers(i2c_smbus_interface* bus, uint8_t address, const std::string& name)
+DetectedControllers DetectEVGATuringGPUControllers(i2c_smbus_interface* bus, uint8_t address, const std::string& name)
 {
+    DetectedControllers detected_controllers;
+
     if(bus->port_id == 1)
     {
         EVGAGPUv2Controller*     controller     = new EVGAGPUv2Controller(bus, address, name);
         RGBController_EVGAGPUv2* rgb_controller = new RGBController_EVGAGPUv2(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectEVGATuringGPUControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 XC Black"                        , DetectEVGATuringGPUControllers, NVIDIA_VEN,     NVIDIA_RTX2070_DEV,     EVGA_SUB_VEN,   EVGA_RTX2070_XC_BLACK_SUB_DEV,                  0x49);
 REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 XC Gaming"                       , DetectEVGATuringGPUControllers, NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,  EVGA_SUB_VEN,   EVGA_RTX2070_XC_GAMING_SUB_DEV,                 0x49);

Controllers/EVGAUSBController/EVGAUSBControllerDetect.cpp

@@ -12,62 +12,71 @@
 #include "RGBController_EVGAKeyboard.h"
 #include "RGBController_EVGAMouse.h"
 
-/*-----------------------------------------------------*\
-| EVGA USB vendor ID                                    |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| EVGA USB vendor ID                                        |
+\*---------------------------------------------------------*/
 #define EVGA_USB_VID                            0x3842
 
-/*-----------------------------------------------------*\
-| Keyboard product IDs                                  |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+\*---------------------------------------------------------*/
 #define Z15_ISO_PID                             0x260E
 #define Z15_ANSI_PID                            0x2608
 #define Z20_ANSI_PID                            0x260A
 #define Z20_UK_PID                              0x2610
 
-/*-----------------------------------------------------*\
-| Mouse product IDs                                     |
-\*-----------------------------------------------------*/
-#define X20_WIRED_PID              0x2420
-#define X20_WIRELESS_ADAPTER_PID   0x2402
+/*---------------------------------------------------------*\
+| Mouse product IDs                                         |
+\*---------------------------------------------------------*/
+#define X20_WIRED_PID                           0x2420
+#define X20_WIRELESS_ADAPTER_PID                0x2402
 
-void DetectEVGAKeyboardControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectEVGAKeyboardControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         EVGAKeyboardController*     controller      = new EVGAKeyboardController(dev, info->path, info->product_id, name);
         RGBController_EVGAKeyboard* rgb_controller  = new RGBController_EVGAKeyboard(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectEVGAMouse(hid_device_info* info, const std::string &name, int connection_type)
+DetectedControllers DetectEVGAMouse(hid_device_info* info, const std::string &name, int connection_type)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         EVGAMouseController*     controller     = new EVGAMouseController(dev, info->path, connection_type, name);
         RGBController_EVGAMouse* rgb_controller = new RGBController_EVGAMouse(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectWiredEVGAMouse(hid_device_info* info, const std::string &name)
+DetectedControllers DetectWiredEVGAMouse(hid_device_info* info, const std::string &name)
 {
-    DetectEVGAMouse(info, name, EVGA_PERIPHERAL_CONNECTION_TYPE_WIRED);
+    return(DetectEVGAMouse(info, name, EVGA_PERIPHERAL_CONNECTION_TYPE_WIRED));
 }
 
-void DetectWirelessEVGAMouse(hid_device_info* info, const std::string &name)
+DetectedControllers DetectWirelessEVGAMouse(hid_device_info* info, const std::string &name)
 {
-    DetectEVGAMouse(info, name, EVGA_PERIPHERAL_CONNECTION_TYPE_WIRELESS);
+    return(DetectEVGAMouse(info, name, EVGA_PERIPHERAL_CONNECTION_TYPE_WIRELESS));
 }
 
-
 REGISTER_HID_DETECTOR_IPU("EVGA Z15 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z15_ISO_PID,                1,  0x08,   0x4B);
 REGISTER_HID_DETECTOR_IPU("EVGA Z15 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z15_ANSI_PID,               1,  0x08,   0x4B);
 REGISTER_HID_DETECTOR_IPU("EVGA Z20 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z20_ANSI_PID,               1,  0x08,   0x4B);

Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp

@@ -16,9 +16,9 @@
 #include "ResourceManager.h"
 #include "SettingsManager.h"
 
-/*-----------------------------------------------------*\
-| Keyboard product IDs                                  |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+\*---------------------------------------------------------*/
 #define EVISION_KEYBOARD_VID        0x0C45
 #define EVISION_KEYBOARD2_VID       0x320F
 #define EVISION_KEYBOARD3_VID       0x3299
@@ -39,71 +39,74 @@
 #define BYGG_CSB_ICL01_PID          0x5041
 #define GAMEPOWER_OGRE_RGB_PID      0x7672
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectEVisionKeyboards                                                                 *
-*                                                                                          *
-*       Tests the USB address to see if an EVision RGB Keyboard controller exists there.   *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectEVisionKeyboards(hid_device_info* info, const std::string& name)
+DetectedControllers DetectEVisionKeyboards(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         EVisionKeyboardController*     controller     = new EVisionKeyboardController(dev, info->path, name);
         RGBController_EVisionKeyboard* rgb_controller = new RGBController_EVisionKeyboard(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectEVisionV2Keyboards(hid_device_info* info, const std::string& name)
+DetectedControllers DetectEVisionV2Keyboards(hid_device_info* info, const std::string& name)
 {
-    json settings   = ResourceManager::get()->GetSettingsManager()->GetSettings("EVision2Settings");
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    json                settings    = ResourceManager::get()->GetSettingsManager()->GetSettings("EVision2Settings");
+    hid_device*         dev         = hid_open_path(info->path);
 
     if(dev)
     {
         EVisionV2KeyboardController*     controller     = new EVisionV2KeyboardController(dev, info->path, EVISION_V2_KEYBOARD_LAYOUT, name);
         RGBController_EVisionV2Keyboard* rgb_controller = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_KEYBOARD);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
 
         if(!settings.contains("AdditionalZones") || settings["AdditionalZones"] == true)
         {
             rgb_controller                             = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_LOGO);
 
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
 
             rgb_controller                             = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_EDGE);
 
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
     }
+
+    return(detected_controllers);
 }
 
-void DetectEndorfyKeyboards(hid_device_info* info, const std::string& name)
+DetectedControllers DetectEndorfyKeyboards(hid_device_info* info, const std::string& name)
 {
-    json settings   = ResourceManager::get()->GetSettingsManager()->GetSettings("EndorfySettings");
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    json                settings    = ResourceManager::get()->GetSettingsManager()->GetSettings("EndorfySettings");
+    hid_device*         dev         = hid_open_path(info->path);
 
     if(dev)
     {
         EVisionV2KeyboardController*     controller     = new EVisionV2KeyboardController(dev, info->path, ENDORFY_KEYBOARD_LAYOUT, name);
         RGBController_EVisionV2Keyboard* rgb_controller = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_KEYBOARD);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
 
         if(!settings.contains("AdditionalZones") || settings["AdditionalZones"] == true)
         {
             rgb_controller                              = new RGBController_EVisionV2Keyboard(controller, ENDORFY_KEYBOARD_PART_EDGE);
 
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
     }
+
+    return(detected_controllers);
 }
 
 /*---------------------------------------------------------------------------------------------------------------------------------------------*\

Controllers/ElgatoKeyLightController/ElgatoKeyLightControllerDetect.cpp

@@ -13,26 +13,20 @@
 #include "RGBController_ElgatoKeyLight.h"
 #include "SettingsManager.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectElgatoKeyLightControllers                                                        *
-*                                                                                          *
-*       Detect Elgato KeyLight devices                                                     *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectElgatoKeyLightControllers()
+DetectedControllers DetectElgatoKeyLightControllers()
 {
-    json                    elgato_keylight_settings;
+    DetectedControllers detected_controllers;
+    json                elgato_keylight_settings;
 
-    /*-------------------------------------------------*\
-    | Get KeyLight settings from settings manager      |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Get KeyLight settings from settings manager           |
+    \*-----------------------------------------------------*/
     elgato_keylight_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("ElgatoKeyLightDevices");
 
-    /*----------------------------------------------------------*\
-    | If the Elgato Key Light settings contains devices, process|
-    \*----------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | If the Elgato Key Light settings contains devices,    |
+    | process                                               |
+    \*-----------------------------------------------------*/
     if(elgato_keylight_settings.contains("devices"))
     {
         for(unsigned int device_idx = 0; device_idx < elgato_keylight_settings["devices"].size(); device_idx++)
@@ -44,11 +38,12 @@ void DetectElgatoKeyLightControllers()
                 ElgatoKeyLightController*     controller     = new ElgatoKeyLightController(elgato_keylight_ip);
                 RGBController_ElgatoKeyLight* rgb_controller = new RGBController_ElgatoKeyLight(controller);
 
-                DetectionManager::get()->RegisterRGBController(rgb_controller);
+                detected_controllers.push_back(rgb_controller);
             }
         }
     }
 
-}   /* DetectElgatoKeyLightControllers() */
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR("ElgatoKeyLight", DetectElgatoKeyLightControllers);

Controllers/ElgatoLightStripController/ElgatoLightStripControllerDetect.cpp

@@ -13,24 +13,20 @@
 #include "RGBController_ElgatoLightStrip.h"
 #include "SettingsManager.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   Detect Elgato LightStrip devices                                                       *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectElgatoLightStripControllers()
+DetectedControllers DetectElgatoLightStripControllers()
 {
-    json elgato_lightstrip_settings;
+    DetectedControllers detected_controllers;
+    json                elgato_lightstrip_settings;
 
-    /*-------------------------------------------------*\
-    | Get LightStrip settings from settings manager     |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Get LightStrip settings from settings manager         |
+    \*-----------------------------------------------------*/
     elgato_lightstrip_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("ElgatoLightStripDevices");
 
-    /*------------------------------------------------------------*\
-    | If the Elgato Light Strip settings contains devices, process |
-    \*------------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | If the Elgato Light Strip settings contains devices,  |
+    | process                                               |
+    \*-----------------------------------------------------*/
     if(elgato_lightstrip_settings.contains("devices"))
     {
         for(unsigned int device_idx = 0; device_idx < elgato_lightstrip_settings["devices"].size(); device_idx++)
@@ -42,10 +38,12 @@ void DetectElgatoLightStripControllers()
                 ElgatoLightStripController*     controller     = new ElgatoLightStripController(elgato_lightstrip_ip);
                 RGBController_ElgatoLightStrip* rgb_controller = new RGBController_ElgatoLightStrip(controller);
 
-                DetectionManager::get()->RegisterRGBController(rgb_controller);
+                detected_controllers.push_back(rgb_controller);
             }
         }
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_DETECTOR("Elgato Light Strip", DetectElgatoLightStripControllers);

Controllers/EpomakerController/EpomakerControllerDetect.cpp

@@ -19,28 +19,25 @@
 #define ATTACKSHARK_K86_USB_PID         0x4015
 #define EPOMAKER_TH80_Pro_Dongle_PID    0x4011 /* Attack shark's Dongle is the same. */
 #define EPOMAKER_TH80_Pro_BT_PID        0x4013
-#define ATTACKSHARK_K86_BT_PID          0x4012
+#define ATTACKSHARK_K86_BT_PID          0x401
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectEpomakerControllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if any Epomaker Controllers exists there.             *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectEpomakerControllers(hid_device_info* info, const std::string&)
+DetectedControllers DetectEpomakerControllers(hid_device_info* info, const std::string&)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         EpomakerController*               controller     = new EpomakerController(dev, info->path);
         RGBController_EpomakerController* rgb_controller = new RGBController_EpomakerController(controller);
-        // Constructor sets the name
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectEpomakerControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_HID_DETECTOR_I("Epomaker TH80 Pro (USB Cable)", DetectEpomakerControllers, EPOMAKER_VID, EPOMAKER_TH80_Pro_USB_PID, 2);
 REGISTER_HID_DETECTOR_I("Epomaker TH80 Pro (USB Dongle)", DetectEpomakerControllers, EPOMAKER_VID, EPOMAKER_TH80_Pro_Dongle_PID, 2);

Controllers/EspurnaController/EspurnaControllerDetect.cpp

@@ -16,26 +16,19 @@
 #include "RGBController.h"
 #include "SettingsManager.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectEspurnaControllers                                                               *
-*                                                                                          *
-*       Detect devices supported by the Espurna driver                                     *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectEspurnaControllers()
+DetectedControllers DetectEspurnaControllers()
 {
-    json espurna_settings;
+    DetectedControllers detected_controllers;
+    json                espurna_settings;
 
-    /*-------------------------------------------------*\
-    | Get Espurna settings from settings manager        |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Get Espurna settings from settings manager            |
+    \*-----------------------------------------------------*/
     espurna_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("EspurnaDevices");
 
-    /*-------------------------------------------------*\
-    | If the Espurna settings contains devices, process |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | If the Espurna settings contains devices, process     |
+    \*-----------------------------------------------------*/
     if(espurna_settings.contains("devices"))
     {
         for(unsigned int device_idx = 0; device_idx < espurna_settings["devices"].size(); device_idx++)
@@ -73,10 +66,11 @@ void DetectEspurnaControllers()
 
             RGBController_Espurna* rgb_controller = new RGBController_Espurna(controller);
 
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
     }
 
-}   /* DetectEspurnaControllers() */
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR("Espurna", DetectEspurnaControllers);

Controllers/FanBusController/FanBusControllerDetect.cpp

@@ -15,19 +15,20 @@
 #include "ResourceManager.h"
 #include "SettingsManager.h"
 
-void DetectFanBusControllers()
+DetectedControllers DetectFanBusControllers()
 {
+    DetectedControllers detected_controllers;
     FanBusInterface*    new_interface;
     json                fanbus_settings;
 
-    /*-------------------------------------------------*\
-    | Get LED Strip settings from settings manager      |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Get FanBus settings from settings manager             |
+    \*-----------------------------------------------------*/
     fanbus_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("FanBusDevices");
 
-    /*-------------------------------------------------*\
-    | If the LEDStrip settings contains devices, process|
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | If the FanBus settings contains devices, process      |
+    \*-----------------------------------------------------*/
     if(fanbus_settings.contains("devices"))
     {
         for(unsigned int device_idx = 0; device_idx < fanbus_settings["devices"].size(); device_idx++)
@@ -38,18 +39,20 @@ void DetectFanBusControllers()
 
                 new_interface     = new FanBusInterface(port_val.c_str());
 
-                std::vector<unsigned char> detected_controllers = new_interface->DetectControllers();
+                std::vector<unsigned char> detected_fanbus_controllers = new_interface->DetectControllers();
 
-                for(unsigned int controller_idx = 0; controller_idx < detected_controllers.size(); controller_idx++)
+                for(unsigned int controller_idx = 0; controller_idx < detected_fanbus_controllers.size(); controller_idx++)
                 {
-                    FanBusController*     controller     = new FanBusController(new_interface, detected_controllers[controller_idx]);
+                    FanBusController*     controller     = new FanBusController(new_interface, detected_fanbus_controllers[controller_idx]);
                     RGBController_FanBus* rgb_controller = new RGBController_FanBus(controller);
 
-                    DetectionManager::get()->RegisterRGBController(rgb_controller);
+                    detected_controllers.push_back(rgb_controller);
                 }
             }
         }
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_DETECTOR("FanBus", DetectFanBusControllers);

Controllers/FaustusController/RGBController_Faustus_Linux.cpp

@@ -154,43 +154,41 @@ void RGBController_Faustus::DeviceUpdateMode()
     DeviceUpdateLEDs();
 }
 
-void DetectFaustusControllers()
+DetectedControllers DetectFaustusControllers()
 {
-    const char* base_path = "/sys/devices/platform/faustus/kbbl";
-    DIR* dir = opendir(base_path);
+    DetectedControllers detected_controllers;
+    const char*         base_path   = "/sys/devices/platform/faustus/kbbl";
+    DIR*                dir         = opendir(base_path);
 
-    if(!dir)
+    if(dir)
     {
-        return;
-    }
+        // Directory is present - we pretty much have a driver confirmation already, but double check for all files required just in case
+        struct dirent* dent = readdir(dir);
 
-    // Directory is present - we pretty much have a driver confirmation already, but double check for all files required just in case
-    struct dirent* dent = readdir(dir);
-
-    if(!dent)
-    {
-        return;
-    }
-
-    int found = 0;
-    while(dent)
-    {
-        const char* fname = dent->d_name;
-        if(!strcmp(fname, "kbbl_red") || !strcmp(fname, "kbbl_green") || !strcmp(fname, "kbbl_blue") || !strcmp(fname, "kbbl_mode") || !strcmp(fname, "kbbl_flags") || !strcmp(fname, "kbbl_set"))
+        if(dent)
         {
-            ++found;
+            int found = 0;
+            while(dent)
+            {
+                const char* fname = dent->d_name;
+                if(!strcmp(fname, "kbbl_red") || !strcmp(fname, "kbbl_green") || !strcmp(fname, "kbbl_blue") || !strcmp(fname, "kbbl_mode") || !strcmp(fname, "kbbl_flags") || !strcmp(fname, "kbbl_set"))
+                {
+                    ++found;
+                }
+                dent = readdir(dir);
+            }
+
+            closedir(dir);
+
+            if(found == 6)
+            {
+                RGBController_Faustus * rgb_controller = new RGBController_Faustus(base_path);
+                detected_controllers.push_back(rgb_controller);
+            }
         }
-        dent = readdir(dir);
     }
 
-    closedir(dir);
-
-    if(found != 6)
-    {
-        return;
-    }
-
-    DetectionManager::get()->RegisterRGBController(new RGBController_Faustus(base_path));
-}   /* DetectFaustusControllers() */
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR("Faustus", DetectFaustusControllers);

Controllers/FnaticStreakController/FnaticStreakControllerDetect.cpp

@@ -14,22 +14,25 @@
 #include "FnaticStreakController.h"
 #include "RGBController_FnaticStreak.h"
 
-/*-----------------------------------------------------*\
-| Fnatic keyboard vendor and product IDs                |
-| Based on leddy project keyboard.rs                    |
-| VID: 0x2f0e                                           |
-| PID: 0x0101 (Streak full)                             |
-| PID: 0x0102 (miniStreak)                              |
-| Interface: 1                                          |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Fnatic keyboard vendor and product IDs                    |
+| Based on leddy project keyboard.rs                        |
+| VID: 0x2f0e                                               |
+| PID: 0x0101 (Streak full)                                 |
+| PID: 0x0102 (miniStreak)                                  |
+| Interface: 1                                              |
+\*---------------------------------------------------------*/
 #define FNATIC_VID                                  0x2F0E
 
 #define FNATIC_STREAK_PID                           0x0101
 #define FNATIC_MINISTREAK_PID                       0x0102
 
-void DetectFnaticStreakKeyboard(hid_device_info* info, const std::string& name)
+DetectedControllers DetectFnaticStreakKeyboard(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -47,8 +50,10 @@ void DetectFnaticStreakKeyboard(hid_device_info* info, const std::string& name)
         FnaticStreakController*     controller     = new FnaticStreakController(dev, info, name, kb_type);
         RGBController_FnaticStreak* rgb_controller = new RGBController_FnaticStreak(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_I("Fnatic Streak",      DetectFnaticStreakKeyboard, FNATIC_VID, FNATIC_STREAK_PID,      1);

Controllers/GaiZongGaiKeyboardController/GaiZhongGaiControllerDetect.cpp

@@ -14,26 +14,23 @@
 #include "GaiZhongGaiController.h"
 #include "RGBController_GaiZhongGai.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectGaiZhongGaiKeyboardControllers                                                   *
-*                                                                                          *
-*       Tests the USB address to see if a GaiZhongGai RGB Keyboard controller exists there.*
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectGaiZhongGaiKeyboardControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectGaiZhongGaiKeyboardControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
-        GaiZhongGaiKeyboardController* controller           = new GaiZhongGaiKeyboardController(dev, info, name);
+        GaiZhongGaiKeyboardController*     controller       = new GaiZhongGaiKeyboardController(dev, info, name);
         RGBController_GaiZhongGaiKeyboard* rgb_controller   = new RGBController_GaiZhongGaiKeyboard(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectGaiZhongGaiKeyboardControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_HID_DETECTOR_I("GaiZhongGai 68+4 PRO",         DetectGaiZhongGaiKeyboardControllers, GAIZHONGGAI_VID, GAIZHONGGAI_68_PRO_PID,          3);
 REGISTER_HID_DETECTOR_I("GaiZhongGai 42 PRO",           DetectGaiZhongGaiKeyboardControllers, GAIZHONGGAI_VID, GAIZHONGGAI_42_PRO_PID,          3);

Controllers/GainwardGPUController/GainwardGPUControllerDetect.cpp

@@ -13,18 +13,10 @@
 #include "DetectionManager.h"
 #include "GainwardGPUv1Controller.h"
 #include "GainwardGPUv2Controller.h"
-#include "RGBController_GainwardGPUv1.h"
-#include "RGBController_GainwardGPUv2.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForGainwardGPUController                                                           *
-*                                                                                          *
-*       Tests the given address to see if a Gainward GPU controller exists there.          *
-*                                                                                          *
-\******************************************************************************************/
+#include "RGBController_GainwardGPUv1.h"
+#include "RGBController_GainwardGPUv2.h"
 
 bool TestForGainwardGPUController(i2c_smbus_interface* bus, uint8_t i2c_addr)
 {
@@ -32,21 +24,22 @@ bool TestForGainwardGPUController(i2c_smbus_interface* bus, uint8_t i2c_addr)
 
     switch(i2c_addr)
     {
-        /*-----------------------------------------------------------------*\
-        | V1 Controller                                                     |
-        \*-----------------------------------------------------------------*/
+        /*-------------------------------------------------*\
+        | V1 Controller                                     |
+        \*-------------------------------------------------*/
         case 0x08:
             pass = bus->i2c_smbus_write_quick(i2c_addr, I2C_SMBUS_WRITE);
             break;
 
-        /*-----------------------------------------------------------------*\
-        | V2 Controller                                                     |
-        \*-----------------------------------------------------------------*/
+        /*-------------------------------------------------*\
+        | V2 Controller                                     |
+        \*-------------------------------------------------*/
         case 0x49:
-            /*-------------------------------------------------------------*\
-            | This detection might need some modifications                  |
-            | Reading 0x6F*0x73 and comparing to 0x64 might be a possibility|
-            \*-------------------------------------------------------------*/
+            /*---------------------------------------------*\
+            | This detection might need some modifications  |
+            | Reading 0x6F*0x73 and comparing to 0x64 might |
+            | be a possibility                              |
+            \*---------------------------------------------*/
             s32 data        = bus->i2c_smbus_read_byte_data(i2c_addr, 0x0);
             s32 mode_data   = bus->i2c_smbus_read_byte_data(i2c_addr, 0xe0);
             pass            = (data == 0x0) && (mode_data < 0x5);
@@ -54,50 +47,44 @@ bool TestForGainwardGPUController(i2c_smbus_interface* bus, uint8_t i2c_addr)
     }
 
     return(pass);
+}
 
-}   /* TestForGainwardGPUController() */
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectGainwardGPUControllers                                                           *
-*                                                                                          *
-*       Detect Gainward GPU controllers on the enumerated I2C busses.                      *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectGainwardGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+DetectedControllers DetectGainwardGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
+    DetectedControllers detected_controllers;
+
     if(TestForGainwardGPUController(bus, i2c_addr))
     {
         switch(i2c_addr)
         {
-            /*-----------------------------------------------------------------*\
-            | V1 Controller                                                     |
-            \*-----------------------------------------------------------------*/
+            /*---------------------------------------------*\
+            | V1 Controller                                 |
+            \*---------------------------------------------*/
             case 0x08:
                 {
                     GainwardGPUv1Controller*     controller     = new GainwardGPUv1Controller(bus, i2c_addr, name);
                     RGBController_GainwardGPUv1* rgb_controller = new RGBController_GainwardGPUv1(controller);
 
-                    DetectionManager::get()->RegisterRGBController(rgb_controller);
+                    detected_controllers.push_back(rgb_controller);
                 }
                 break;
 
-            /*-----------------------------------------------------------------*\
-            | V2 Controller                                                     |
-            \*-----------------------------------------------------------------*/
+            /*---------------------------------------------*\
+            | V2 Controller                                 |
+            \*---------------------------------------------*/
             case 0x49:
                 {
                     GainwardGPUv2Controller*     controller     = new GainwardGPUv2Controller(bus, i2c_addr, name);
                     RGBController_GainwardGPUv2* rgb_controller = new RGBController_GainwardGPUv2(controller);
 
-                    DetectionManager::get()->RegisterRGBController(rgb_controller);
+                    detected_controllers.push_back(rgb_controller);
                 }
                 break;
         }
     }
-} /* DetectGainwardGPUControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_I2C_PCI_DETECTOR("Gainward GeForce GTX 1080 Phoenix",          DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_GTX1080_DEV,     GAINWARD_SUB_VEN,   GAINWARD_GTX_1080_PHOENIX,      0x08);
 REGISTER_I2C_PCI_DETECTOR("Gainward GeForce GTX 1080 Ti Phoenix",       DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_GTX1080TI_DEV,   GAINWARD_SUB_VEN,   GAINWARD_GTX_1080TI_PHOENIX,    0x08);

Controllers/GalaxGPUController/GalaxGPUControllerDetect.cpp

@@ -12,18 +12,10 @@
 #include "DetectionManager.h"
 #include "GalaxGPUv1Controller.h"
 #include "GalaxGPUv2Controller.h"
-#include "RGBController_GalaxGPUv1.h"
-#include "RGBController_GalaxGPUv2.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForGalaxGPUController                                                              *
-*                                                                                          *
-*       Tests the given address to see if a Galax GPU controller exists there.             *
-*                                                                                          *
-\******************************************************************************************/
+#include "RGBController_GalaxGPUv1.h"
+#include "RGBController_GalaxGPUv2.h"
 
 bool TestForGalaxGPUController(i2c_smbus_interface* bus, unsigned char address)
 {
@@ -32,9 +24,9 @@ bool TestForGalaxGPUController(i2c_smbus_interface* bus, unsigned char address)
 
     switch (address)
     {
-        /*-----------------------------------------------------------------*\
-        | V1 Controller                                                     |
-        \*-----------------------------------------------------------------*/
+        /*-------------------------------------------------*\
+        | V1 Controller                                     |
+        \*-------------------------------------------------*/
         case 0x32:
             res  = bus->i2c_smbus_read_byte_data(address, 0x00);
             if(res == 0x27 || res == 0x26) {
@@ -44,9 +36,9 @@ bool TestForGalaxGPUController(i2c_smbus_interface* bus, unsigned char address)
             }
             break;
 
-        /*-----------------------------------------------------------------*\
-        | V1 Controller - RTX 3080                                          |
-        \*-----------------------------------------------------------------*/
+        /*-------------------------------------------------*\
+        | V1 Controller - RTX 3080                          |
+        \*-------------------------------------------------*/
         case 0x23:
             res = bus->i2c_smbus_read_byte_data(address, 0x00);
             if(res == 0x30)
@@ -55,9 +47,9 @@ bool TestForGalaxGPUController(i2c_smbus_interface* bus, unsigned char address)
             }
             break;
 
-        /*-----------------------------------------------------------------*\
-        | V2 Controller                                                     |
-        \*-----------------------------------------------------------------*/
+        /*-------------------------------------------------*\
+        | V2 Controller                                     |
+        \*-------------------------------------------------*/
         case 0x51:
             res = bus->i2c_smbus_read_byte_data(address, 0x00);
             if (res == 0x80)
@@ -66,26 +58,19 @@ bool TestForGalaxGPUController(i2c_smbus_interface* bus, unsigned char address)
     }
 
     return(pass);
-}   /* TestForGalaxGPUController() */
+}
 
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectGalaxGPUControllers                                                              *
-*                                                                                          *
-*       Detect Galax GPU controllers on the enumerated I2C busses.                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectGalaxGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+DetectedControllers DetectGalaxGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
+    DetectedControllers detected_controllers;
+
     if(TestForGalaxGPUController(bus, i2c_addr))
     {
         switch(i2c_addr)
         {
-            /*-----------------------------------------------------------------*\
-            | V1 Controller                                                     |
-            \*-----------------------------------------------------------------*/
+            /*---------------------------------------------*\
+            | V1 Controller                                 |
+            \*---------------------------------------------*/
             case 0x32:
             case 0x23:
                 {
@@ -96,20 +81,22 @@ void DetectGalaxGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const
                 }
                 break;
 
-            /*-----------------------------------------------------------------*\
-            | V2 Controller                                                     |
-            \*-----------------------------------------------------------------*/
+            /*---------------------------------------------*\
+            | V2 Controller                                 |
+            \*---------------------------------------------*/
             case 0x51:
                 {
                     GalaxGPUv2Controller*     controller     = new GalaxGPUv2Controller(bus, i2c_addr, name);
                     RGBController_GalaxGPUv2* rgb_controller = new RGBController_GalaxGPUv2(controller);
 
-                    DetectionManager::get()->RegisterRGBController(rgb_controller);
+                    detected_controllers.push_back(rgb_controller);
                 }
                 break;
         }
     }
-} /* DetectGalaxGPUControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_I2C_PCI_DETECTOR("KFA2 GeForce RTX 2070 EX",                       DetectGalaxGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070_DEV,     NVIDIA_SUB_VEN, KFA2_RTX_2070_EX_SUB_DEV,               0x23);
 REGISTER_I2C_PCI_DETECTOR("KFA2 GeForce RTX 2070 OC",                       DetectGalaxGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV,  NVIDIA_SUB_VEN, KFA2_RTX_2070_OC_SUB_DEV,               0x23);

Controllers/GigabyteAorusCPUCoolerController/GigabyteAorusCPUCoolerControllerDetect.cpp

@@ -12,35 +12,32 @@
 #include "ATC800Controller.h"
 #include "RGBController_AorusATC800.h"
 
-/*-----------------------------------------------------*\
-| Vendor ID                                             |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Vendor ID                                                 |
+\*---------------------------------------------------------*/
 #define HOLTEK_VID                            0x1044
 
-/*-----------------------------------------------------*\
-| Controller product ids                                |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Controller product ids                                    |
+\*---------------------------------------------------------*/
 #define ATC_800_CONTROLLER_PID                0x7A42
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAorusCPUCoolerControllers                                                        *
-*                                                                                          *
-*       Tests the USB address to see if a Aorus RGB CPU Cooler exists there.               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectGigabyteAorusCPUCoolerControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectGigabyteAorusCPUCoolerControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         ATC800Controller*          controller     = new ATC800Controller(dev, info->path, name);
         RGBController_AorusATC800* rgb_controller = new RGBController_AorusATC800(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("Gigabyte AORUS ATC800", DetectGigabyteAorusCPUCoolerControllers, HOLTEK_VID, ATC_800_CONTROLLER_PID, 0, 0xFF01, 1);

Controllers/GigabyteAorusLaptopController/GigabyteAorusLaptopControllerDetect.cpp

@@ -27,27 +27,32 @@
 #define AORUS_15BKF_BACKLIGHT_PID                      0x7A44
 #define AORUS_15BKF_KEYBOARD_PID                       0x7A43
 
-void DetectGigabyteAorusLaptopControllers(hid_device_info* info, const std::string& name, GIGABYTE_AORUS_LAPTOP_DEV_TYPE dev_type)
+DetectedControllers DetectGigabyteAorusLaptopControllers(hid_device_info* info, const std::string& name, GIGABYTE_AORUS_LAPTOP_DEV_TYPE dev_type)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         GigabyteAorusLaptopController*     controller       = new GigabyteAorusLaptopController(dev, *info, name);
         RGBController_GigabyteAorusLaptop* rgb_controller   = new RGBController_GigabyteAorusLaptop(controller, dev_type);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectGigabyteAorusLaptopKeyboardControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectGigabyteAorusLaptopKeyboardControllers(hid_device_info* info, const std::string& name)
 {
-    DetectGigabyteAorusLaptopControllers(info, name, GIGABYTE_AORUS_LAPTOP_KEYBOARD_TYPE);
+    return(DetectGigabyteAorusLaptopControllers(info, name, GIGABYTE_AORUS_LAPTOP_KEYBOARD_TYPE));
 }
 
-void DetectGigabyteAorusLaptopBacklightControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectGigabyteAorusLaptopBacklightControllers(hid_device_info* info, const std::string& name)
 {
-    DetectGigabyteAorusLaptopControllers(info, name, GIGABYTE_AORUS_LAPTOP_BACKLIGHT_TYPE);
+    return(DetectGigabyteAorusLaptopControllers(info, name, GIGABYTE_AORUS_LAPTOP_BACKLIGHT_TYPE));
 }
 
 REGISTER_HID_DETECTOR_IPU("Gigabyte Aorus 17X Keyboard",    DetectGigabyteAorusLaptopKeyboardControllers,  GIGABYTE_AORUS_LAPTOP_VID, AORUS_17X_KEYBOARD_PID,    3, 0xFF01, 0x01);

Controllers/GigabyteAorusMouseController/GigabyteAorusMouseControllerDetect.cpp

@@ -14,27 +14,32 @@
 #include "GigabyteAorusMouseController.h"
 #include "RGBController_GigabyteAorusMouse.h"
 
-/*-----------------------------------------------------*\
-| Vendor ID                                             |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Vendor ID                                                 |
+\*---------------------------------------------------------*/
 #define HOLTEK_VID                                 0x1044
 
-/*-----------------------------------------------------*\
-| Controller product ids                                |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Controller product ids                                    |
+\*---------------------------------------------------------*/
 #define AORUS_M2_PID                               0x7A40
 
-void DetectGigabyteAorusMouseControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectGigabyteAorusMouseControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         GigabyteAorusMouseController*     controller     = new GigabyteAorusMouseController(dev, *info, name);
         RGBController_GigabyteAorusMouse* rgb_controller = new RGBController_GigabyteAorusMouse(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("Gigabyte Aorus M2", DetectGigabyteAorusMouseControllers, HOLTEK_VID, AORUS_M2_PID, 3, 0xFF01, 0x01);

Controllers/GigabyteAorusPCCaseController/GigabyteAorusPCCaseControllerDetect.cpp

@@ -14,34 +14,32 @@
 #include "GigabyteAorusPCCaseController.h"
 #include "RGBController_GigabyteAorusPCCase.h"
 
-/*-----------------------------------------------------*\
-| Vendor ID                                             |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Vendor ID                                                 |
+\*---------------------------------------------------------*/
 #define HOLTEK_VID                          0x1044
 
-/*-----------------------------------------------------*\
-| Controller product ids                                |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Controller product ids                                    |
+\*---------------------------------------------------------*/
 #define C300_GLASS_PID                      0x7A30
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectGigabyteAorusPCCaseControllers                                                   *
-*                                                                                          *
-*       Tests the USB address to see if a Gigabyte Aorus PC Case exists there.             *
-*                                                                                          *
-\******************************************************************************************/
-void DetectGigabyteAorusPCCaseControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectGigabyteAorusPCCaseControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         GigabyteAorusPCCaseController*      controller      = new GigabyteAorusPCCaseController(dev, info->path, name);
         RGBController_GigabyteAorusPCCase*  rgb_controller  = new RGBController_GigabyteAorusPCCase(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("Gigabyte AORUS C300 GLASS",  DetectGigabyteAorusPCCaseControllers,   HOLTEK_VID, C300_GLASS_PID, 0,  0xFF01, 0x01);

Controllers/GigabyteRGBFusion2AorusMasterGPUController/GigabyteRGBFusion2AorusMasterGPUControllerDetect.cpp

@@ -8,14 +8,13 @@
 \*---------------------------------------------------------*/
 
 #include <stdio.h>
-#include "Detector.h"
+#include "DetectionManager.h"
 #include "GigabyteRGBFusion2AorusMasterGPUController.h"
 #include "i2c_smbus.h"
 #include "LogManager.h"
 #include "pci_ids.h"
 #include "RGBController_GigabyteRGBFusion2AorusMasterGPU.h"
 
-
 #define GIGABYTEGPU_CONTROLLER_NAME_AORUS_MASTER    "Gigabyte RGB Fusion2 AORUS MASTER GPU"
 
 bool TestForGigabyteRGBFusion2AorusMasterGPUController(i2c_smbus_interface* bus, unsigned char address)
@@ -65,15 +64,19 @@ bool TestForGigabyteRGBFusion2AorusMasterGPUController(i2c_smbus_interface* bus,
     return(pass);
 }
 
-void DetectGigabyteRGBFusion2AorusMasterGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+DetectedControllers DetectGigabyteRGBFusion2AorusMasterGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
+    DetectedControllers detected_controllers;
+
     if(TestForGigabyteRGBFusion2AorusMasterGPUController(bus, i2c_addr))
     {
         RGBFusion2AorusMasterGPUController*     controller     = new RGBFusion2AorusMasterGPUController(bus, i2c_addr, name);
         RGBController_RGBFusion2AorusMasterGPU* rgb_controller = new RGBController_RGBFusion2AorusMasterGPU(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 /*---------------------------------------------------------*\

Controllers/GigabyteRGBFusion2BlackwellGPUController/GigabyteRGBFusion2BlackwellGPUControllerDetect.cpp

@@ -10,23 +10,14 @@
 #include <stdio.h>
 #include "DetectionManager.h"
 #include "GigabyteRGBFusion2BlackwellGPUController.h"
-#include "LogManager.h"
-#include "RGBController_GigabyteRGBFusion2BlackwellGPU.h"
 #include "i2c_amd_gpu.h"
 #include "i2c_smbus.h"
+#include "LogManager.h"
 #include "pci_ids.h"
+#include "RGBController_GigabyteRGBFusion2BlackwellGPU.h"
 
 #define GIGABYTEGPU_CONTROLLER_NAME3    "Gigabyte RGB Fusion2 Blackwell GPU"
 
-/******************************************************************************************\
-*                                                                                          *
-*   TestForGigabyteRGBFusion2BlackwellGPUController                                        *
-*                                                                                          *
-*       Tests the given address to see if an RGB Fusion2 controller exists there.  First   *
-*       does a quick write to test for a response                                          *
-*                                                                                          *
-\******************************************************************************************/
-
 bool TestForGigabyteRGBFusion2BlackwellGPUController(i2c_smbus_interface* bus, unsigned char address)
 {
     if(bus->pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
@@ -70,103 +61,47 @@ bool TestForGigabyteRGBFusion2BlackwellGPUController(i2c_smbus_interface* bus, u
     }
 
     return(pass);
-}   /* TestForRGBFusion2BlackwellGPUController() */
+}
 
-/*******************************************************************************************\
-*                                                                                           *
-*   DetectGigabyteRGBFusion2BlackwellGPUControllers                                         *
-*                                                                                           *
-*       Detect GigabyteRGB Fusion2 controllers with a specified layout on the enumerated    *
-*       I2C busses.                                                                         *
-*                                                                                           *
-*           bus - pointer to i2c_smbus_interface where RGB Fusion2 device is connected      *
-*           dev - I2C address of RGB Fusion2 device                                         *
-*                                                                                           *
-\*******************************************************************************************/
-
-void DetectGigabyteRGBFusion2BlackwellGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name, uint8_t led_zones)
+DetectedControllers DetectGigabyteRGBFusion2BlackwellGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name, uint8_t led_zones)
 {
+    DetectedControllers detected_controllers;
+
     // Check for RGB Fusion2 controller
     if(TestForGigabyteRGBFusion2BlackwellGPUController(bus, i2c_addr))
     {
         RGBFusion2BlackwellGPUController*     controller     = new RGBFusion2BlackwellGPUController(bus, i2c_addr, name);
         RGBController_RGBFusion2BlackwellGPU* rgb_controller = new RGBController_RGBFusion2BlackwellGPU(controller, led_zones);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectGigabyteRGBFusion2BlackwellGPUControllers() */
 
-/*******************************************************************************************\
-*                                                                                           *
-*   DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers                               *
-*                                                                                           *
-*       Detect GigabyteRGB Fusion2 controllers with one zone on the enumerated I2C busses.  *
-*                                                                                           *
-*           bus - pointer to i2c_smbus_interface where RGB Fusion2 device is connected      *
-*           dev - I2C address of RGB Fusion2 device                                         *
-*                                                                                           *
-\*******************************************************************************************/
+    return(detected_controllers);
+}
 
-void DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+DetectedControllers DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
-    DetectGigabyteRGBFusion2BlackwellGPUControllers(bus, i2c_addr, name, RGB_FUSION2_BLACKWELL_GPU_SINGLE_ZONE);
-}   /* DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers() */
+    return(DetectGigabyteRGBFusion2BlackwellGPUControllers(bus, i2c_addr, name, RGB_FUSION2_BLACKWELL_GPU_SINGLE_ZONE));
+}
 
-/*******************************************************************************************\
-*                                                                                           *
-*   DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers                             *
-*                                                                                           *
-*       Detect GigabyteRGB Fusion2 controllers with gaming layouts on the enumerated I2C    *
-*       busses.                                                                             *
-*                                                                                           *
-*           bus - pointer to i2c_smbus_interface where RGB Fusion2 device is connected      *
-*           dev - I2C address of RGB Fusion2 device                                         *
-*                                                                                           *
-\*******************************************************************************************/
-
-void DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+DetectedControllers DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
-    DetectGigabyteRGBFusion2BlackwellGPUControllers(bus, i2c_addr, name, RGB_FUSION2_BLACKWELL_GPU_GAMING_LAYOUT);
-}   /* DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers() */
+    return(DetectGigabyteRGBFusion2BlackwellGPUControllers(bus, i2c_addr, name, RGB_FUSION2_BLACKWELL_GPU_GAMING_LAYOUT));
+}
 
-/*******************************************************************************************\
-*                                                                                           *
-*   DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers                         *
-*                                                                                           *
-*       Detect GigabyteRGB Fusion2 controllers with waterforce layouts on the enumerated    *
-*       I2C busses.                                                                         *
-*                                                                                           *
-*           bus - pointer to i2c_smbus_interface where RGB Fusion2 device is connected      *
-*           dev - I2C address of RGB Fusion2 device                                         *
-*                                                                                           *
-\*******************************************************************************************/
-
-void DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+DetectedControllers DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
-    DetectGigabyteRGBFusion2BlackwellGPUControllers(bus, i2c_addr, name, RGB_FUSION2_BLACKWELL_GPU_WATERFORCE_LAYOUT);
-}   /* DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers() */
+    return(DetectGigabyteRGBFusion2BlackwellGPUControllers(bus, i2c_addr, name, RGB_FUSION2_BLACKWELL_GPU_WATERFORCE_LAYOUT));
+}
 
-/*******************************************************************************************\
-*                                                                                           *
-*   DetectGigabyteRGBFusion2BlackwellAorusWaterforceLayoutGPUControllers                    *
-*                                                                                           *
-*       Detect GigabyteRGB Fusion2 controllers with AORUS waterforce layout on the          *
-*       enumerated I2C busses.                                                              *
-*                                                                                           *
-*           bus - pointer to i2c_smbus_interface where RGB Fusion2 device is connected      *
-*           dev - I2C address of RGB Fusion2 device                                         *
-*                                                                                           *
-\*******************************************************************************************/
-
-void DetectGigabyteRGBFusion2BlackwellAorusWaterforceLayoutGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+DetectedControllers DetectGigabyteRGBFusion2BlackwellAorusWaterforceLayoutGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
-    DetectGigabyteRGBFusion2BlackwellGPUControllers(bus, i2c_addr, name, RGB_FUSION2_BLACKWELL_GPU_AORUS_WATERFORCE_LAYOUT);
-}   /* DetectGigabyteRGBFusion2BlackwellAorusWaterforceLayoutGPUControllers() */
-
-/*-----------------------------------------*\
-|  Nvidia GPUs                              |
-\*-----------------------------------------*/
+    return(DetectGigabyteRGBFusion2BlackwellGPUControllers(bus, i2c_addr, name, RGB_FUSION2_BLACKWELL_GPU_AORUS_WATERFORCE_LAYOUT));
+}
 
+/*---------------------------------------------------------*\
+|  Nvidia GPUs                                              |
+\*---------------------------------------------------------*/
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5060 Ti Gaming OC",                 DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,          NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,   GIGABYTE_SUB_VEN, GIGABYTE_RTX5060TI_GAMING_OC_16G_SUB_DEV,         0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Aero OC",                      DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,          NVIDIA_VEN, NVIDIA_RTX5070_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_RTX5070_AERO_OC_12G_SUB_DEV,             0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5070 Eagle OC",                     DetectGigabyteRGBFusion2BlackwellSingleZoneGPUControllers,          NVIDIA_VEN, NVIDIA_RTX5070_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_RTX5070_EAGLE_OC_12G_SUB_DEV,            0x75);
@@ -185,14 +120,11 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 XTREME WATERFORCE",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 MASTER",                 DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        NVIDIA_VEN, NVIDIA_RTX5090_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5090_MASTER_32G_SUB_DEV,        0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 MASTER ICE",             DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        NVIDIA_VEN, NVIDIA_RTX5090_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5090_MASTER_ICE_32G_SUB_DEV,    0x75);
 
-/*-----------------------------------------*\
-|  AMD GPUs                                 |
-\*-----------------------------------------*/
-
+/*---------------------------------------------------------*\
+|  AMD GPUs                                                 |
+\*---------------------------------------------------------*/
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9060 XT GAMING",                      DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        AMD_GPU_VEN, AMD_NAVI44_DEV,        GIGABYTE_SUB_VEN, GIGABYTE_RX9060XT_GAMING_16G_SUB_DEV,             0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9060 XT GAMING OC",                   DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        AMD_GPU_VEN, AMD_NAVI44_DEV,        GIGABYTE_SUB_VEN, GIGABYTE_RX9060XT_GAMING_OC_16G_SUB_DEV,          0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS Radeon RX 9070 XT Elite",                 DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        AMD_GPU_VEN, AMD_NAVI48_DEV,        GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RX9070XT_ELITE_16G_SUB_DEV,        0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9070 XT GAMING OC",                   DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        AMD_GPU_VEN, AMD_NAVI48_DEV,        GIGABYTE_SUB_VEN, GIGABYTE_RX9070XT_GAMING_OC_16G_SUB_DEV,          0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 9070 XT GAMING",                      DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,        AMD_GPU_VEN, AMD_NAVI48_DEV,        GIGABYTE_SUB_VEN, GIGABYTE_RX9070XT_GAMING_16G_SUB_DEV,             0x75);
-
-

Controllers/GigabyteRGBFusion2DRAMController/GigabyteRGBFusion2DRAMControllerDetect.cpp

@@ -12,20 +12,11 @@
 #include <string>
 #include <vector>
 #include "DetectionManager.h"
-#include "LogManager.h"
 #include "GigabyteRGBFusion2DRAMController.h"
-#include "RGBController_GigabyteRGBFusion2DRAM.h"
 #include "i2c_smbus.h"
+#include "LogManager.h"
 #include "pci_ids.h"
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForGigabyteRGBFusion2DRAMController                                                *
-*                                                                                          *
-*       Tests the given address to see if an RGB 2 Fusion DRAMcontroller exists there.     *
-*       First does a quick write to test for a response                                    *
-*                                                                                          *
-\******************************************************************************************/
+#include "RGBController_GigabyteRGBFusion2DRAM.h"
 
 bool TestForGigabyteRGBFusion2DRAMController(i2c_smbus_interface* bus, unsigned char address)
 {
@@ -55,22 +46,12 @@ bool TestForGigabyteRGBFusion2DRAMController(i2c_smbus_interface* bus, unsigned
     }
 
     return(pass);
+}
 
-}   /* TestForGigabyteRGBFusion2DRAMController() */
-
-/***********************************************************************************************\
-*                                                                                               *
-*   DetectGigabyteRGBFusion2DRAMControllers                                                     *
-*                                                                                               *
-*       Detect Gigabyte RGB Fusion 2 controllers on the enumerated I2C buses at address 0x67.   *
-*                                                                                               *
-*           bus - pointer to i2c_smbus_interface where RGB Fusion device is connected           *
-*           dev - I2C address of RGB Fusion device                                              *
-*                                                                                               *
-\***********************************************************************************************/
-
-void DetectGigabyteRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>& busses)
+DetectedControllers DetectGigabyteRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>& busses)
 {
+    DetectedControllers detected_controllers;
+
     for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
@@ -81,11 +62,12 @@ void DetectGigabyteRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>&
                 RGBFusion2DRAMController*     controller     = new RGBFusion2DRAMController(busses[bus], 0x67);
                 RGBController_RGBFusion2DRAM* rgb_controller = new RGBController_RGBFusion2DRAM(controller);
 
-                DetectionManager::get()->RegisterRGBController(rgb_controller);
+                detected_controllers.push_back(rgb_controller);
             }
         }
     }
 
-}   /* DetectGigabyteRGBFusion2DRAMControllers() */
+    return(detected_controllers);
+}
 
 REGISTER_I2C_DETECTOR("Gigabyte RGB Fusion 2 DRAM", DetectGigabyteRGBFusion2DRAMControllers);

Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp

@@ -10,23 +10,14 @@
 #include <stdio.h>
 #include "DetectionManager.h"
 #include "GigabyteRGBFusion2GPUController.h"
-#include "LogManager.h"
-#include "RGBController_GigabyteRGBFusion2GPU.h"
 #include "i2c_amd_gpu.h"
 #include "i2c_smbus.h"
+#include "LogManager.h"
 #include "pci_ids.h"
+#include "RGBController_GigabyteRGBFusion2GPU.h"
 
 #define GIGABYTEGPU_CONTROLLER_NAME2    "Gigabyte RGB Fusion2 GPU"
 
-/******************************************************************************************\
-*                                                                                          *
-*   TestForGigabyteRGBFusion2GPUController                                                 *
-*                                                                                          *
-*       Tests the given address to see if an RGB Fusion2 controller exists there.  First   *
-*       does a quick write to test for a response                                          *
-*                                                                                          *
-\******************************************************************************************/
-
 bool TestForGigabyteRGBFusion2GPUController(i2c_smbus_interface* bus, unsigned char address)
 {
     if(bus->pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
@@ -79,35 +70,27 @@ bool TestForGigabyteRGBFusion2GPUController(i2c_smbus_interface* bus, unsigned c
     }
 
     return(pass);
-}   /* TestForRGBFusion2GPUController() */
+}
 
-/*******************************************************************************************\
-*                                                                                           *
-*   DetectRGBFusion2GPUControllers                                                          *
-*                                                                                           *
-*       Detect GigabyteRGB Fusion2 controllers on the enumerated I2C busses at address 0x70.*
-*                                                                                           *
-*           bus - pointer to i2c_smbus_interface where RGB Fusion2 device is connected      *
-*           dev - I2C address of RGB Fusion2 device                                         *
-*                                                                                           *
-\*******************************************************************************************/
-
-void DetectGigabyteRGBFusion2GPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+DetectedControllers DetectGigabyteRGBFusion2GPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
+    DetectedControllers detected_controllers;
+
     // Check for RGB Fusion2 controller
     if(TestForGigabyteRGBFusion2GPUController(bus, i2c_addr))
     {
         RGBFusion2GPUController*     controller     = new RGBFusion2GPUController(bus, i2c_addr, name);
         RGBController_RGBFusion2GPU* rgb_controller = new RGBController_RGBFusion2GPU(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectGigabyteRGBFusion2GPUControllers() */
 
-/*-----------------------------------------*\
-|  Nvidia GPUs                              |
-\*-----------------------------------------*/
+    return(detected_controllers);
+}
 
+/*---------------------------------------------------------*\
+|  Nvidia GPUs                                              |
+\*---------------------------------------------------------*/
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 2060 SUPER",                     DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2060S_V1_SUB_DEV_H,           0x50);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 2060 SUPER",                     DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2060S_V1_SUB_DEV_P,           0x50);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 2070",                           DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2070_SUB_DEV,                 0x50);
@@ -180,10 +163,9 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 GAMING OC",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 MASTER",                    DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX5090_MASTER_32G_SUB_DEV,      0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 MASTER ICE",                DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX5090_MASTER_ICE_32G_SUB_DEV,  0x71);
 
-/*-----------------------------------------*\
-|  AMD GPUs                                 |
-\*-----------------------------------------*/
-
+/*---------------------------------------------------------*\
+|  AMD GPUs                                                 |
+\*---------------------------------------------------------*/
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 7600 GAMING OC 8G",                      DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI33_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX7600_GAMING_OC_8G_SUB_DEV,           0x55);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 7600 GAMING OC 8G",                      DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI33_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX7600_GAMING_OC_8G_SUB_DEV2,          0x55);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Radeon RX 7600 XT GAMING OC 16G",                  DetectGigabyteRGBFusion2GPUControllers, AMD_GPU_VEN, AMD_NAVI33_DEV,            GIGABYTE_SUB_VEN,   GIGABYTE_RX7600XT_GAMING_OC_16G_SUB_DEV,        0x55);

Controllers/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusControllerDetect.cpp

@@ -60,15 +60,6 @@ json rgb_fusion_2_smbus_motherboards[] =
     "Z370 AORUS Ultra Gaming-CF"
 };
 
-/******************************************************************************************\
-*                                                                                          *
-*   TestForGigabyteRGBFusion2SMBusController                                               *
-*                                                                                          *
-*       Tests the given address to see if an RGB 2 Fusion controller exists there.  First  *
-*       does a quick write to test for a response                                          *
-*                                                                                          *
-\******************************************************************************************/
-
 bool TestForGigabyteRGBFusion2SMBusController(i2c_smbus_interface* bus, unsigned char address)
 {
     bool pass = false;
@@ -81,36 +72,28 @@ bool TestForGigabyteRGBFusion2SMBusController(i2c_smbus_interface* bus, unsigned
     }
 
     return(pass);
+}
 
-}   /* TestForRGBFusion2SMBusController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectGigabyteRGBFusion2SMBusControllers                                               *
-*                                                                                          *
-*       Detect RGB Fusion 2 controllers on the enumerated I2C busses at address 0x68.      *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where RGB Fusion device is connected      *
-*           dev - I2C address of RGB Fusion device                                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses)
+DetectedControllers DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses)
 {
+    DetectedControllers                 detected_controllers;
     SettingsManager*                    set_man = ResourceManager::get()->GetSettingsManager();
     json                                device_settings;
 
     DMIInfo                             dmi;
     bool                                found = false;
 
-    /*-------------------------------------------------*\
-    | Get Linux LED settings from settings manager      |
-    \*-------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Get Linux LED settings from settings manager          |
+    \*-----------------------------------------------------*/
     device_settings = set_man->GetSettings(DETECTOR_NAME);
 
     if(!device_settings.contains("SupportedDevices"))
     {
-        //If supported devices is not found then write it to settings
+        /*-------------------------------------------------*\
+        | If supported devices is not found then write it   |
+        | to settings                                       |
+        \*-------------------------------------------------*/
         device_settings["SupportedDevices"] = rgb_fusion_2_smbus_motherboards;
         set_man->SetSettings(DETECTOR_NAME, device_settings);
         set_man->SaveSettings();
@@ -135,21 +118,27 @@ void DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>&
             {
                 if(busses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
                 {
-                    // TODO - Is this necessary? Or an artifact of my own system?
-                    // Skip dmcd devices
+                    /*-------------------------------------*\
+                    | TODO - Is this necessary? Or an       |
+                    | artifact of my own system?  Skip dmcd |
+                    | devices                               |
+                    \*-------------------------------------*/
                     std::string device_name = std::string(busses[bus]->device_name);
 
                     if(device_name.find("dmdc") == std::string::npos)
                     {
                         LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
 
-                        // Check for RGB Fusion 2 controller at 0x68
+                        /*---------------------------------*\
+                        | Check for RGB Fusion 2 controller |
+                        | at 0x68                           |
+                        \*---------------------------------*/
                         if(TestForGigabyteRGBFusion2SMBusController(busses[bus], SMBUS_ADDRESS))
                         {
                             RGBFusion2SMBusController*     controller     = new RGBFusion2SMBusController(busses[bus], SMBUS_ADDRESS, dmi.getMainboard() );
                             RGBController_RGBFusion2SMBus* rgb_controller = new RGBController_RGBFusion2SMBus(controller);
 
-                            DetectionManager::get()->RegisterRGBController(rgb_controller);
+                            detected_controllers.push_back(rgb_controller);
                         }
                     }
                 }
@@ -165,6 +154,7 @@ void DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>&
         LOG_DEBUG(GIGABYTE_NOT_FOUND_MB_MESSAGE_EN, DETECTOR_NAME, dmi.getMainboard().c_str());
     }
 
-}   /* DetectRGBFusion2SMBusControllers() */
+    return(detected_controllers);
+}
 
 REGISTER_I2C_DETECTOR(DETECTOR_NAME, DetectGigabyteRGBFusion2SMBusControllers);

Controllers/GigabyteRGBFusion2USBController/GigabyteRGBFusion2USBControllerDetect.cpp

@@ -12,9 +12,9 @@
 \*---------------------------------------------------------*/
 
 #include "DetectionManager.h"
+#include "dmiinfo.h"
 #include "GigabyteRGBFusion2USBController.h"
 #include "RGBController_GigabyteRGBFusion2USB.h"
-#include "dmiinfo.h"
 
 #define DETECTOR_NAME "Gigabyte RGB Fusion 2 USB"
 
@@ -26,18 +26,21 @@
 /*---------------------------------------------------------*\
 | Detector for Gigabyte RGB Fusion USB controllers          |
 \*---------------------------------------------------------*/
-void DetectGigabyteRGBFusion2USBControllers(hid_device_info* info, const std::string&)
+DetectedControllers DetectGigabyteRGBFusion2USBControllers(hid_device_info* info, const std::string&)
 {
-    DMIInfo     MB_info;
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    DMIInfo             MB_info;
+    hid_device*         dev = hid_open_path(info->path);
 
     if(dev)
     {
         RGBFusion2USBController*     controller     = new RGBFusion2USBController(dev, info->path, MB_info.getMainboard(), info->product_id);
         RGBController_RGBFusion2USB* rgb_controller = new RGBController_RGBFusion2USB(controller, DETECTOR_NAME);
-        // Constructor sets the name
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 #ifdef USE_HID_USAGE

Controllers/GigabyteRGBFusionController/GigabyteRGBFusionControllerDetect.cpp

@@ -22,15 +22,6 @@
 #define VENDOR_NAME     "Gigabyte Technology Co., Ltd."
 #define SMBUS_ADDRESS   0x28
 
-/******************************************************************************************\
-*                                                                                          *
-*   TestForGigabyteRGBFusionController                                                     *
-*                                                                                          *
-*       Tests the given address to see if an RGB Fusion controller exists there.  First    *
-*       does a quick write to test for a response                                          *
-*                                                                                          *
-\******************************************************************************************/
-
 bool TestForGigabyteRGBFusionController(i2c_smbus_interface* bus, unsigned char address)
 {
     bool pass = false;
@@ -50,22 +41,12 @@ bool TestForGigabyteRGBFusionController(i2c_smbus_interface* bus, unsigned char
     }
 
     return(pass);
+}
 
-}   /* TestForGigabyteRGBFusionController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectGigabyteRGBFusionControllers                                                     *
-*                                                                                          *
-*       Detect RGB Fusion controllers on the enumerated I2C busses at address 0x28.        *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where RGB Fusion device is connected      *
-*           dev - I2C address of RGB Fusion device                                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectGigabyteRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses)
+DetectedControllers DetectGigabyteRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses)
 {
+    DetectedControllers detected_controllers;
+
     for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
@@ -74,13 +55,15 @@ void DetectGigabyteRGBFusionControllers(std::vector<i2c_smbus_interface*>& busse
             {
                 LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
 
-                // Check for RGB Fusion controller at 0x28
+                /*-----------------------------------------*\
+                | Check for RGB Fusion controller at 0x28   |
+                \*-----------------------------------------*/
                 if(TestForGigabyteRGBFusionController(busses[bus], SMBUS_ADDRESS))
                 {
                     RGBFusionController*     controller     = new RGBFusionController(busses[bus], SMBUS_ADDRESS);
                     RGBController_RGBFusion* rgb_controller = new RGBController_RGBFusion(controller);
 
-                    DetectionManager::get()->RegisterRGBController(rgb_controller);
+                    detected_controllers.push_back(rgb_controller);
                 }
             }
             else
@@ -89,6 +72,8 @@ void DetectGigabyteRGBFusionControllers(std::vector<i2c_smbus_interface*>& busse
             }
         }
     }
-}   /* DetectGigabyteRGBFusionControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_I2C_DETECTOR("Gigabyte RGB Fusion", DetectGigabyteRGBFusionControllers);

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUControllerDetect.cpp

@@ -18,21 +18,14 @@
 
 #define GIGABYTEGPU_CONTROLLER_NAME "Gigabyte RGB Fusion GPU"
 
-/******************************************************************************************\
-*                                                                                          *
-*   TestForGigabyteRGBFusionGPUController                                                  *
-*                                                                                          *
-*       Tests the given address to see if an RGB Fusion controller exists there.  First    *
-*       does a quick write to test for a response                                          *
-*                                                                                          *
-\******************************************************************************************/
-
 bool TestForGigabyteRGBFusionGPUController(i2c_smbus_interface* bus, unsigned char address)
 {
     bool pass = false;
     int res;
 
-    //Write out 0xAB 0x00 0x00 0x00 sequence
+    /*-----------------------------------------------------*\
+    | Write out 0xAB 0x00 0x00 0x00 sequence                |
+    \*-----------------------------------------------------*/
     res = bus->i2c_smbus_write_byte(address, 0xAB);
 
     if (res >= 0)
@@ -41,7 +34,10 @@ bool TestForGigabyteRGBFusionGPUController(i2c_smbus_interface* bus, unsigned ch
         bus->i2c_smbus_write_byte(address, 0x00);
         bus->i2c_smbus_write_byte(address, 0x00);
 
-        // NVIDIA_RTX3060_DEV requires additional bytes to initialise
+        /*-------------------------------------------------*\
+        | NVIDIA_RTX3060_DEV requires additional bytes to   |
+        | initialise                                        |
+        \*-------------------------------------------------*/
         if (address == 0x62)
         {
             bus->i2c_smbus_write_byte(address, 0x00);
@@ -71,7 +67,10 @@ bool TestForGigabyteRGBFusionGPUController(i2c_smbus_interface* bus, unsigned ch
         bus->i2c_smbus_read_byte(address);
         bus->i2c_smbus_read_byte(address);
 
-        //We don't know what the 0x48 controller returns, so for now just assume it exists
+        /*-------------------------------------------------*\
+        | We don't know what the 0x48 controller returns,   |
+        | so for now just assume it exists                  |
+        \*-------------------------------------------------*/
         if(address == 0x48)
         {
             pass = true;
@@ -79,31 +78,25 @@ bool TestForGigabyteRGBFusionGPUController(i2c_smbus_interface* bus, unsigned ch
     }
 
     return(pass);
+}
 
-}   /* TestForRGBFusionGPUController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectRGBFusionGPUControllers                                                          *
-*                                                                                          *
-*       Detect GigabyteRGB Fusion controllers on the enumerated I2C busses at address 0x47.*
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where RGB Fusion device is connected      *
-*           dev - I2C address of RGB Fusion device                                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectGigabyteRGBFusionGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+DetectedControllers DetectGigabyteRGBFusionGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
-    // Check for RGB Fusion controller
+    DetectedControllers detected_controllers;
+
+    /*-----------------------------------------------------*\
+    | Check for RGB Fusion controller                       |
+    \*-----------------------------------------------------*/
     if(TestForGigabyteRGBFusionGPUController(bus, i2c_addr))
     {
         RGBFusionGPUController*     controller     = new RGBFusionGPUController(bus, i2c_addr, name);
         RGBController_RGBFusionGPU* rgb_controller = new RGBController_RGBFusionGPU(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectGigabyteRGBFusionGPUControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce GTX 1050 Ti G1 Gaming Rev A1",           DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1050TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1050TI_G1_GAMING_SUB_DEV,           0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce GTX 1050 Ti G1 Gaming",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1050TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1050TI_G1_GAMING_SUB_DEV,           0x48);

Controllers/GigabyteSuperIORGBController/GigabyteSuperIORGBControllerDetect.cpp

@@ -10,10 +10,10 @@
 \*---------------------------------------------------------*/
 
 #include "DetectionManager.h"
+#include "dmiinfo.h"
 #include "GigabyteSuperIORGBController.h"
 #include "RGBController_GigabyteSuperIORGB.h"
 #include "super_io.h"
-#include "dmiinfo.h"
 
 #define NUM_COMPATIBLE_DEVICES (sizeof(compatible_devices) / sizeof(compatible_devices[0]))
 
@@ -27,44 +27,44 @@ static gig_device compatible_devices[] =
     {"X570 UD"}
 };
 
-void DetectGigabyteSuperIORGBControllers()
+DetectedControllers DetectGigabyteSuperIORGBControllers()
 {
-    int sio_addrs[2]            = {0x2E, 0x4E};
+    DetectedControllers detected_controllers;
+    int                 sio_addrs[2]    = {0x2E, 0x4E};
+    DMIInfo             board;
+    std::string         board_dmi       = board.getMainboard();
+    std::string         manufacturer    = board.getManufacturer();
 
-    DMIInfo board;
-    std::string board_dmi       = board.getMainboard();
-    std::string manufacturer    = board.getManufacturer();
-
-    if(manufacturer != "Gigabyte Technology Co., Ltd.")
+    if(manufacturer == "Gigabyte Technology Co., Ltd.")
     {
-        return;
-    }
-
-    for(int sioaddr_idx = 0; sioaddr_idx < 2; sioaddr_idx++)
-    {
-        int sioaddr = sio_addrs[sioaddr_idx];
-
-        superio_enter(sioaddr);
-
-        int val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8) | superio_inb(sioaddr, SIO_REG_DEVID + 1);
-
-        switch(val & SIO_ID_MASK)
+        for(int sioaddr_idx = 0; sioaddr_idx < 2; sioaddr_idx++)
         {
-            case SIO_ITE8688_ID:
-                for(unsigned int i = 0; i < NUM_COMPATIBLE_DEVICES; i++)
-                {
-                    if(board_dmi.find(std::string(compatible_devices[i].name)) != std::string::npos)
-                    {
-                        GigabyteSuperIORGBController*     controller     = new GigabyteSuperIORGBController(sioaddr, "Gigabyte " + board_dmi);
-                        RGBController_GigabyteSuperIORGB* rgb_controller = new RGBController_GigabyteSuperIORGB(controller);
+            int sioaddr = sio_addrs[sioaddr_idx];
 
-                        DetectionManager::get()->RegisterRGBController(rgb_controller);
-                        break;
+            superio_enter(sioaddr);
+
+            int val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8) | superio_inb(sioaddr, SIO_REG_DEVID + 1);
+
+            switch(val & SIO_ID_MASK)
+            {
+                case SIO_ITE8688_ID:
+                    for(unsigned int i = 0; i < NUM_COMPATIBLE_DEVICES; i++)
+                    {
+                        if(board_dmi.find(std::string(compatible_devices[i].name)) != std::string::npos)
+                        {
+                            GigabyteSuperIORGBController*     controller     = new GigabyteSuperIORGBController(sioaddr, "Gigabyte " + board_dmi);
+                            RGBController_GigabyteSuperIORGB* rgb_controller = new RGBController_GigabyteSuperIORGB(controller);
+
+                            detected_controllers.push_back(rgb_controller);
+                            break;
+                        }
                     }
-                }
-                break;
+                    break;
+            }
         }
     }
-}   /* DetectGigabyteSuperIORGBControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR("Gigabyte RGB", DetectGigabyteSuperIORGBControllers);

Controllers/GoveeController/GoveeControllerDetect.cpp

@@ -19,17 +19,10 @@
 #include "ResourceManager.h"
 #include "SettingsManager.h"
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectGoveeControllers                                                                 *
-*                                                                                          *
-*       Detect Govee devices                                                               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectGoveeControllers()
+DetectedControllers DetectGoveeControllers()
 {
-    json                    govee_settings;
+    DetectedControllers detected_controllers;
+    json                govee_settings;
 
     /*-----------------------------------------------------*\
     | Get Govee settings from settings manager              |
@@ -70,7 +63,7 @@ void DetectGoveeControllers()
                 GoveeController*     controller     = new GoveeController(govee_ip);
                 RGBController_Govee* rgb_controller = new RGBController_Govee(controller);
 
-                DetectionManager::get()->RegisterRGBController(rgb_controller);
+                detected_controllers.push_back(rgb_controller);
             }
         }
 
@@ -88,6 +81,7 @@ void DetectGoveeControllers()
         }
     }
 
-}   /* DetectGoveeControllers() */
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR("Govee", DetectGoveeControllers);

Controllers/HPOmen30LController/HPOmen30LControllerDetect.cpp

@@ -15,25 +15,22 @@
 #define HP_OMEN_30L_VID 0x103C
 #define HP_OMEN_30L_PID 0x84FD
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectHPOmen30LController                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an HP Omen 30L controller exists there.            *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectHPOmen30LController(hid_device_info* info, const std::string&)
+DetectedControllers DetectHPOmen30LController(hid_device_info* info, const std::string&)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         HPOmen30LController*     controller     = new HPOmen30LController(dev, info->path);
         RGBController_HPOmen30L* rgb_controller = new RGBController_HPOmen30L(controller);
-        // Constructor sets the name
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR("HP Omen 30L", DetectHPOmen30LController, HP_OMEN_30L_VID, HP_OMEN_30L_PID);

Controllers/HPOmenLaptopController/HPOmenLaptopWMIDetect_Windows.cpp

@@ -7,22 +7,28 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "RGBController_HPOmenLaptopWMI_Windows.h"
+#include "DetectionManager.h"
 #include "HPOmenLaptopController_Windows.h"
-#include "Detector.h"
+#include "RGBController_HPOmenLaptopWMI_Windows.h"
 
-static void DetectHPOmenLaptopWMIControllers()
+DetectedControllers DetectHPOmenLaptopWMIControllers()
 {
-    HPOmenLaptopController_Windows *controller = new HPOmenLaptopController_Windows();
+    DetectedControllers detected_controllers;
+
+    HPOmenLaptopController_Windows * controller = new HPOmenLaptopController_Windows();
 
     if(!controller->isLightingSupported() || controller->getKeyboardType() != KeyboardType::WITHOUT_NUMPAD)
     {
         delete controller;
-        return;
+    }
+    else
+    {
+        RGBController * rgb_controller = new RGBController_HPOmenLaptopWMI_Windows(controller);
+
+        detected_controllers.push_back(rgb_controller);
     }
 
-    RGBController *hp_omen_controller = new RGBController_HPOmenLaptopWMI_Windows(controller);
-    ResourceManager::get()->RegisterRGBController(hp_omen_controller);
+    return(detected_controllers);
 }
 
 REGISTER_DETECTOR("HP Omen 4-Zone Laptop Keyboard", DetectHPOmenLaptopWMIControllers);

Controllers/HYTEKeyboardController/HYTEKeyboardControllerDetect.cpp

@@ -24,17 +24,22 @@
 \*---------------------------------------------------------*/
 #define HYTE_KEEB_TKL_PID                           0x0300
 
-void DetectHYTEKeyboard(hid_device_info* info, const std::string& name)
+DetectedControllers DetectHYTEKeyboard(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         HYTEKeyboardController*     controller     = new HYTEKeyboardController(dev, info->path, name);
         RGBController_HYTEKeyboard* rgb_controller = new RGBController_HYTEKeyboard(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_PU("HYTE Keeb TKL", DetectHYTEKeyboard, HYTE_VID, HYTE_KEEB_TKL_PID, 0xFF11, 0xF0);

Controllers/HYTEMousematController/HYTEMousematController_FreeBSD_Linux/HYTEMousematControllerDetect_FreeBSD_Linux.cpp

@@ -14,14 +14,14 @@
 #include "DetectionManager.h"
 #include "RGBController_HYTEMousemat.h"
 
-/*-----------------------------------------------------*\
-| HYTE vendor ID                                        |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| HYTE vendor ID                                            |
+\*---------------------------------------------------------*/
 #define HYTE_VID                        0x3402
 
-/*-----------------------------------------------------*\
-| HYTE CNVS product IDs                                 |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| HYTE CNVS product IDs                                     |
+\*---------------------------------------------------------*/
 #define HYTE_CNVS_HW_VER_1_PID          0x0B00
 #define HYTE_CNVS_HW_VER_2_PID          0x0B01
 
@@ -37,23 +37,17 @@ typedef struct
 
 static const hyte_mousemat_device device_list[] =
 {
-    /*-----------------------------------------------------------------------------------------------------*\
-    | Mousemats                                                                                              |
-    \*-----------------------------------------------------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Mousemats                                             |
+    \*-----------------------------------------------------*/
     { HYTE_VID, HYTE_CNVS_HW_VER_1_PID, 0,  "HYTE CNVS" },
     { HYTE_VID, HYTE_CNVS_HW_VER_2_PID, 0,  "HYTE CNVS" },
 };
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectHYTEMousematControllers                                                          *
-*                                                                                          *
-*       Detect devices supported by the HyteMousemat driver                                *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectHYTEMousematControllers()
+DetectedControllers DetectHYTEMousematControllers()
 {
+    DetectedControllers detected_controllers;
+
     libusb_init(NULL);
 
     #ifdef _WIN32
@@ -73,11 +67,12 @@ void DetectHYTEMousematControllers()
             HYTEMousematController *     controller     = new HYTEMousematController(dev, device_list[device_idx].name);
             RGBController_HYTEMousemat * rgb_controller = new RGBController_HYTEMousemat(controller);
 
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
     }
 
-}   /* DetectHYTEMousematControllers() */
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR("HYTE Mousemat", DetectHYTEMousematControllers);
 /*---------------------------------------------------------------------------------------------------------*\

Controllers/HYTEMousematController/HYTEMousematController_Windows_MacOS/HYTEMousematControllerDetect_Windows_MacOS.cpp

@@ -12,9 +12,9 @@
 
 #include <vector>
 #include "DetectionManager.h"
+#include "find_usb_serial_port.h"
 #include "HYTEMousematController_Windows_MacOS.h"
 #include "RGBController_HYTEMousemat.h"
-#include "find_usb_serial_port.h"
 
 #define HYTE_VID                0x3402
 
@@ -36,16 +36,10 @@ static const hyte_mousemat_type hyte_mousemat_devices[] =
     { HYTE_VID, HYTE_CNVS_HW_VER_2_PID, "HYTE CNVS" },
 };
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectHYTEMousematControllers                                                          *
-*                                                                                          *
-*       Detect devices supported by the HyteMousemat driver                                *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectHYTEMousematControllers()
+DetectedControllers DetectHYTEMousematControllers()
 {
+    DetectedControllers detected_controllers;
+
     for(unsigned int device_id = 0; device_id < HYTE_MOUSEMAT_NUM_DEVICES; device_id++)
     {
         std::vector<std::string *> ports = find_usb_serial_port(hyte_mousemat_devices[device_id].vid, hyte_mousemat_devices[device_id].pid);
@@ -57,11 +51,13 @@ void DetectHYTEMousematControllers()
                 HYTEMousematController *     controller     = new HYTEMousematController((char *)ports[i]->c_str(), hyte_mousemat_devices[device_id].name);
                 RGBController_HYTEMousemat * rgb_controller = new RGBController_HYTEMousemat(controller);
 
-                DetectionManager::get()->RegisterRGBController(rgb_controller);
+                detected_controllers.push_back(rgb_controller);
             }
         }
     }
-}   /* DetectHYTEMousematControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR("HYTE Mousemat", DetectHYTEMousematControllers);
 /*---------------------------------------------------------------------------------------------------------*\

Controllers/HYTENexusController/HYTENexusControllerDetect.cpp

@@ -32,16 +32,10 @@ static const hyte_nexus_type hyte_nexus_devices[] =
     { HYTE_VID, HYTE_NEXUS_PORTAL_NP50_PID, "HYTE Nexus Portal NP50" },
 };
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectHYTENexusControllers                                                             *
-*                                                                                          *
-*       Detect devices supported by the HYTENexus driver                                   *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectHYTENexusControllers()
+DetectedControllers DetectHYTENexusControllers()
 {
+    DetectedControllers detected_controllers;
+
     for(unsigned int device_id = 0; device_id < HYTE_NEXUS_NUM_DEVICES; device_id++)
     {
         std::vector<std::string *> ports = find_usb_serial_port(hyte_nexus_devices[device_id].vid, hyte_nexus_devices[device_id].pid);
@@ -53,11 +47,13 @@ void DetectHYTENexusControllers()
                 HYTENexusController *     controller     = new HYTENexusController((char *)ports[i]->c_str(), hyte_nexus_devices[device_id].pid, hyte_nexus_devices[device_id].name);
                 RGBController_HYTENexus * rgb_controller = new RGBController_HYTENexus(controller);
 
-                DetectionManager::get()->RegisterRGBController(rgb_controller);
+                detected_controllers.push_back(rgb_controller);
             }
         }
     }
-}   /* DetectHYTENexusControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_DETECTOR("HYTE Nexus", DetectHYTENexusControllers);
 /*---------------------------------------------------------------------------------------------------------*\

Controllers/HoltekController/HoltekControllerDetect.cpp

@@ -14,44 +14,54 @@
 #include "HoltekA1FAController.h"
 #include "RGBController_HoltekA1FA.h"
 
-/*-----------------------------------------------------*\
-| Holtek Semiconductor Inc. vendor ID                   |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Holtek Semiconductor Inc. vendor ID                       |
+\*---------------------------------------------------------*/
 #define HOLTEK_VID                    0x04D9
-/*-----------------------------------------------------*\
-| Mouse product IDs                                     |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Mouse product IDs                                         |
+\*---------------------------------------------------------*/
 #define HOLTEK_A070_PID               0xA070
-/*-----------------------------------------------------*\
-| Mousemats product IDs                                 |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| Mousemats product IDs                                     |
+\*---------------------------------------------------------*/
 #define HOLTEK_A1FA_PID               0xA1FA
 
-void DetectHoltekControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectHoltekControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         HoltekA070Controller*     controller     = new HoltekA070Controller(dev, info->path, name);
         RGBController_HoltekA070* rgb_controller = new RGBController_HoltekA070(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-}   /* DetectHoltekControllers() */
 
-void DetectHoltekMousemats(hid_device_info *info, const std::string &name)
+    return(detected_controllers);
+}
+
+DetectedControllers DetectHoltekMousemats(hid_device_info *info, const std::string &name)
 {
-    hid_device *dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         HoltekA1FAController*     controller     = new HoltekA1FAController(dev, info->path, name);
         RGBController_HoltekA1FA* rgb_controller = new RGBController_HoltekA1FA(controller);
 
-        DetectionManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-} /* DetectHoltekMousemats() */
+
+    return(detected_controllers);
+}
 
 REGISTER_HID_DETECTOR_IPU("Holtek USB Gaming Mouse", DetectHoltekControllers, HOLTEK_VID, HOLTEK_A070_PID, 1, 0xFF00, 2);
 REGISTER_HID_DETECTOR_IPU("Holtek Mousemat",         DetectHoltekMousemats,   HOLTEK_VID, HOLTEK_A1FA_PID, 2, 0xFF00, 0xFF00);

Controllers/HyperXDRAMController/HyperXDRAMControllerDetect.cpp

@@ -12,20 +12,13 @@
 #include <vector>
 #include "DetectionManager.h"
 #include "HyperXDRAMController.h"
-#include "LogManager.h"
-#include "RGBController_HyperXDRAM.h"
 #include "i2c_smbus.h"
+#include "LogManager.h"
 #include "pci_ids.h"
+#include "RGBController_HyperXDRAM.h"
 
 using namespace std::chrono_literals;
 
-/******************************************************************************************\
-*                                                                                          *
-*   TestForHyperXDRAMController                                                            *
-*                                                                                          *
-*       Tests the given address to see if a HyperX controller exists there.                *
-*                                                                                          *
-\******************************************************************************************/
 #define HYPERX_CONTROLLER_NAME "HyperX DRAM"
 
 bool TestForHyperXDRAMController(i2c_smbus_interface* bus, unsigned char address)
@@ -52,26 +45,14 @@ bool TestForHyperXDRAMController(i2c_smbus_interface* bus, unsigned char address
     }
 
     return(pass);
+}
 
-}   /* TestForHyperXDRAMController() */
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectHyperXDRAMControllers                                                            *
-*                                                                                          *
-*       Detect HyperX DRAM controllers on the enumerated I2C busses.                       *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           slots - accessors to SPD information of the occupied slots                     *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectHyperXDRAMControllers(i2c_smbus_interface* bus, std::vector<SPDWrapper*> &slots, const std::string &/*name*/)
+DetectedControllers DetectHyperXDRAMControllers(i2c_smbus_interface* bus, std::vector<SPDWrapper*> &slots, const std::string &/*name*/)
 {
-    unsigned char slots_valid   = 0x00;
-    bool          fury_detected = false;
-    bool          pred_detected = false;
+    DetectedControllers detected_controllers;
+    bool                fury_detected = false;
+    bool                pred_detected = false;
+    unsigned char       slots_valid   = 0x00;
 
     // Check for HyperX controller at 0x27
     LOG_DEBUG("[%s] Testing bus %d at address 0x27", HYPERX_CONTROLLER_NAME, bus->port_id);
@@ -115,9 +96,11 @@ void DetectHyperXDRAMControllers(i2c_smbus_interface* bus, std::vector<SPDWrappe
             HyperXDRAMController*     controller     = new HyperXDRAMController(bus, 0x27, slots_valid, name);
             RGBController_HyperXDRAM* rgb_controller = new RGBController_HyperXDRAM(controller);
 
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
     }
-}   /* DetectHyperXDRAMControllers() */
+
+    return(detected_controllers);
+}
 
 REGISTER_I2C_DRAM_DETECTOR("HyperX DRAM", DetectHyperXDRAMControllers, JEDEC_KINGSTON, SPD_DDR4_SDRAM);