Initial commit for Linux-only controller for Valve Steam Machine using

the leds-valve kernel module and sysfs interface

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -1,66 +0,0 @@
-/*---------------------------------------------------------*\
-| A4TechDetector.cpp                                        |
-|                                                           |
-|   Detector for A4Tech Devices                             |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
-#include "BloodyB820RController.h"
-#include "BloodyMouseController.h"
-#include "DetectionManager.h"
-#include "RGBController_BloodyB820R.h"
-#include "RGBController_BloodyMouse.h"
-
-/*---------------------------------------------------------*\
-| A4 Tech USB vendor ID                                     |
-\*---------------------------------------------------------*/
-#define A4_TECH_VID                                 0x09DA
-
-DetectedControllers DetectA4TechMouseControllers(hid_device_info* info, const std::string& name)
-{
-    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);
-        RGBController_BloodyMouse* rgb_controller   = new RGBController_BloodyMouse(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
-
-DetectedControllers DetectBloodyB820R(hid_device_info* info, const std::string& name)
-{
-    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);
-
-        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);
-REGISTER_HID_DETECTOR_IPU("Bloody W70 Max",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W70_MAX_PID,     2,      0xFF33,     0x0518);
-REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
-REGISTER_HID_DETECTOR_IPU("Bloody W90 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_PRO_PID,     2,      0xFF33,     0x054D);
-REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
-REGISTER_HID_DETECTOR_IPU("Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);

Controllers/A4TechController/BloodyB820RController/BloodyB820RControllerDetect.cpp

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------*\
+| BloodyB820RControllerDetect.cpp                           |
+|                                                           |
+|   Detector for Bloody B820R Devices                       |
+|                                                           |
+|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "BloodyB820RController.h"
+#include "DetectionManager.h"
+#include "RGBController_BloodyB820R.h"
+
+/*---------------------------------------------------------*\
+| A4 Tech USB vendor ID                                     |
+\*---------------------------------------------------------*/
+#define A4_TECH_VID                                 0x09DA
+
+DetectedControllers DetectBloodyB820R(hid_device_info* info, const std::string& name)
+{
+    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);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_IPU("Bloody B820R", DetectBloodyB820R, A4_TECH_VID, BLOODY_B820R_PID, 2, 0xFF52, 0x0210);

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.cpp

@@ -205,6 +205,7 @@ void RGBController_BloodyB820R::SetupZones()
     {
         led new_led;
         new_led.name        = led_names[led_index];
+        new_led.value       = led_index;
         leds.push_back(new_led);
     }
 

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.cpp

@@ -67,13 +67,13 @@ void BloodyMouseController::InitDevice()
     hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
 }
 
-void BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors, std::vector<uint8_t> offsets)
+void BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors)
 {
     uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00 };
 
     for(uint8_t i = 0; i < colors.size(); i++)
     {
-        uint8_t offset                              = 3 * (offsets[i]) + BLOODYMOUSE_DATA_BYTE;
+        uint8_t offset                              = 3 * (colors[i] >> 24) + BLOODYMOUSE_DATA_BYTE;
 
         buffer[offset]                              = RGBGetRValue(colors[i]);
         buffer[offset + 1]                          = RGBGetGValue(colors[i]);

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.h

@@ -58,7 +58,7 @@ public:
     std::string     GetLocation();
     std::string     GetName();
 
-    void            SetLedsDirect(std::vector<RGBColor> colors, std::vector<uint8_t> offsets);
+    void            SetLedsDirect(std::vector<RGBColor> colors);
 
 private:
     uint16_t        pid;

Controllers/A4TechController/BloodyMouseController/BloodyMouseControllerDetect.cpp

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------*\
+| BloodyMouseControllerDetect.cpp                           |
+|                                                           |
+|   Detector for Bloody Mouse Devices                       |
+|                                                           |
+|   Chris M (Dr_No)                             30 Jun 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "BloodyMouseController.h"
+#include "DetectionManager.h"
+#include "RGBController_BloodyMouse.h"
+
+/*---------------------------------------------------------*\
+| A4 Tech USB vendor ID                                     |
+\*---------------------------------------------------------*/
+#define A4_TECH_VID                                 0x09DA
+
+DetectedControllers DetectBloodyMouseControllers(hid_device_info* info, const std::string& name)
+{
+    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);
+        RGBController_BloodyMouse* rgb_controller   = new RGBController_BloodyMouse(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_W60_PRO_PID, 2,  0xFF33, 0x0529);
+REGISTER_HID_DETECTOR_IPU("Bloody W70 Max",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_W70_MAX_PID, 2,  0xFF33, 0x0518);
+REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_W90_MAX_PID, 2,  0xFF33, 0x053D);
+REGISTER_HID_DETECTOR_IPU("Bloody W90 Pro",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_W90_PRO_PID, 2,  0xFF33, 0x054D);
+REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_MP_50RS_PID, 2,  0xFFF2, 0x6009);

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.cpp

@@ -142,7 +142,7 @@ void RGBController_BloodyMouse::SetupZones()
         {
             led new_led;
 
-            offsets.push_back(mz.zone_leds[lp_idx]);
+            new_led.value       = mz.zone_leds[lp_idx];
 
             if(bool_single)
             {
@@ -163,7 +163,14 @@ void RGBController_BloodyMouse::SetupZones()
 
 void RGBController_BloodyMouse::DeviceUpdateLEDs()
 {
-    controller->SetLedsDirect(colors, offsets);
+    std::vector<RGBColor> colour;
+    for(size_t i = 0; i < colors.size(); i++)
+    {
+        RGBColor c = colors[i] | (leds[i].value << 24);
+        colour.push_back(c);
+    }
+
+    controller->SetLedsDirect(colour);
 }
 
 void RGBController_BloodyMouse::DeviceUpdateZoneLEDs(int /*zone*/)

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.h

@@ -39,5 +39,4 @@ public:
 
 private:
     BloodyMouseController*  controller;
-    std::vector<uint8_t>    offsets;
 };

Controllers/AMBXController/AMBXController.cpp

@@ -186,7 +186,7 @@ void AMBXController::SetLEDColor(unsigned int led, RGBColor color)
     std::this_thread::sleep_for(std::chrono::milliseconds(2));
 }
 
-void AMBXController::SetLEDColors(const unsigned int* leds, RGBColor* colors, unsigned int count)
+void AMBXController::SetLEDColors(unsigned int* leds, RGBColor* colors, unsigned int count)
 {
     for(unsigned int i = 0; i < count; i++)
     {

Controllers/AMBXController/AMBXController.h

@@ -44,7 +44,7 @@ public:
 
     bool            IsInitialized();
     void            SetLEDColor(unsigned int led, RGBColor color);
-    void            SetLEDColors(const unsigned int* leds, RGBColor* colors, unsigned int count);
+    void            SetLEDColors(unsigned int* leds, RGBColor* colors, unsigned int count);
 
 private:
     libusb_context*          usb_context;

Controllers/AMBXController/RGBController_AMBX.cpp

@@ -9,15 +9,6 @@
 
 #include "RGBController_AMBX.h"
 
-static const unsigned int led_values[] =
-{
-    AMBX_LIGHT_LEFT,
-    AMBX_LIGHT_RIGHT,
-    AMBX_LIGHT_WALL_LEFT,
-    AMBX_LIGHT_WALL_CENTER,
-    AMBX_LIGHT_WALL_RIGHT
-};
-
 /**------------------------------------------------------------------*\
     @name Philips amBX
     @category Accessory
@@ -80,22 +71,27 @@ void RGBController_AMBX::SetupZones()
     // Set up LEDs
     led left_light;
     left_light.name  = "Left";
+    left_light.value = AMBX_LIGHT_LEFT;
     leds.push_back(left_light);
 
     led right_light;
     right_light.name  = "Right";
+    right_light.value = AMBX_LIGHT_RIGHT;
     leds.push_back(right_light);
 
     led wall_left;
     wall_left.name  = "Wall Left";
+    wall_left.value = AMBX_LIGHT_WALL_LEFT;
     leds.push_back(wall_left);
 
     led wall_center;
     wall_center.name  = "Wall Center";
+    wall_center.value = AMBX_LIGHT_WALL_CENTER;
     leds.push_back(wall_center);
 
     led wall_right;
     wall_right.name  = "Wall Right";
+    wall_right.value = AMBX_LIGHT_WALL_RIGHT;
     leds.push_back(wall_right);
 
     SetupColors();
@@ -108,7 +104,16 @@ void RGBController_AMBX::DeviceUpdateLEDs()
         return;
     }
 
-    controller->SetLEDColors(led_values, colors.data(), static_cast<unsigned int>(colors.size()));
+    unsigned int led_values[5];
+    RGBColor led_colors[5];
+
+    for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        led_values[led_idx] = leds[led_idx].value;
+        led_colors[led_idx] = colors[led_idx];
+    }
+
+    controller->SetLEDColors(led_values, led_colors, static_cast<unsigned int>(leds.size()));
 }
 
 void RGBController_AMBX::DeviceUpdateZoneLEDs(int zone)
@@ -133,17 +138,17 @@ void RGBController_AMBX::DeviceUpdateZoneLEDs(int zone)
         start_idx += zones[z_idx].leds_count;
     }
 
-    unsigned int tmp_values[5];
-    RGBColor     tmp_colors[5];
+    unsigned int led_values[5];
+    RGBColor led_colors[5];
 
     for(unsigned int led_idx = 0; led_idx < zone_size; led_idx++)
     {
         unsigned int current_idx = start_idx + led_idx;
-        tmp_values[led_idx] = led_values[current_idx];
-        tmp_colors[led_idx] = colors[current_idx];
+        led_values[led_idx] = leds[current_idx].value;
+        led_colors[led_idx] = colors[current_idx];
     }
 
-    controller->SetLEDColors(tmp_values, tmp_colors, zone_size);
+    controller->SetLEDColors(led_values, led_colors, zone_size);
 }
 
 void RGBController_AMBX::DeviceUpdateSingleLED(int led)
@@ -153,7 +158,7 @@ void RGBController_AMBX::DeviceUpdateSingleLED(int led)
         return;
     }
 
-    unsigned int led_value = led_values[led];
+    unsigned int led_value = leds[led].value;
     RGBColor color = colors[led];
     controller->SetLEDColor(led_value, color);
 }

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -11,33 +11,6 @@
 
 #include "RGBController_AMDWraithPrism.h"
 
-/*---------------------------------------------------------*\
-| LED maps                                                  |
-\*---------------------------------------------------------*/
-const unsigned char led_values[] =
-{
-    // Logo
-    0x00,
-    // Fan
-    0x01,
-    // Ring
-    0x08,
-    0x07,
-    0x06,
-    0x05,
-    0x04,
-    0x03,
-    0x02,
-    0x10,
-    0x0F,
-    0x0E,
-    0x0D,
-    0x0C,
-    0x0B,
-    0x0A,
-    0x09
-};
-
 /**------------------------------------------------------------------*\
     @name AMD Wraith Prism
     @category Cooler
@@ -166,6 +139,14 @@ RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
 
 void RGBController_AMDWraithPrism::SetupZones()
 {
+    /*-----------------------------------------------------*\
+    | LED maps                                              |
+    \*-----------------------------------------------------*/
+    const unsigned int logo_leds[1]  =  { 0x00 };
+    const unsigned int fan_leds[1]   =  { 0x01 };
+    const unsigned int ring_leds[15] =  { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x10,
+                                          0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09 };
+
     /*-----------------------------------------------------*\
     | Set up zones                                          |
     \*-----------------------------------------------------*/
@@ -200,6 +181,7 @@ void RGBController_AMDWraithPrism::SetupZones()
     {
         led logo_led;
         logo_led.name       = "Logo LED";
+        logo_led.value      = logo_leds[led_idx];
         leds.push_back(logo_led);
     }
 
@@ -207,6 +189,7 @@ void RGBController_AMDWraithPrism::SetupZones()
     {
         led fan_led;
         fan_led.name        = "Fan LED";
+        fan_led.value       = fan_leds[led_idx];
         leds.push_back(fan_led);
     }
 
@@ -214,6 +197,7 @@ void RGBController_AMDWraithPrism::SetupZones()
     {
         led ring_led;
         ring_led.name       = "Ring LED";
+        ring_led.value      = ring_leds[led_idx];
         leds.push_back(ring_led);
     }
 
@@ -234,7 +218,7 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
         leds_count = 0;
         for(std::size_t led_idx = 0; led_idx < 2; led_idx++)
         {
-            led_ids[leds_count]     = led_values[led_idx];
+            led_ids[leds_count]     = (unsigned char)leds[led_idx].value;
             color_buf[leds_count]   = colors[led_idx];
 
             leds_count++;
@@ -247,7 +231,7 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
         leds_count = 0;
         for(std::size_t led_idx = 0; led_idx < ( colors.size() - 2 ); led_idx++)
         {
-            led_ids[leds_count]     = led_values[led_idx + 2];
+            led_ids[leds_count]     = (unsigned char)leds[led_idx + 2].value;
             color_buf[leds_count]   = colors[led_idx + 2];
 
             leds_count++;

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp

@@ -286,7 +286,7 @@ void RGBController_AOCKeyboard::SetupZones()
         led new_led;
 
         new_led.name                = new_kb.GetKeyNameAt(led_idx);
-        led_values.push_back(new_kb.GetKeyValueAt(led_idx));
+        new_led.value               = new_kb.GetKeyValueAt(led_idx);
         leds.push_back(new_led);
     }
 
@@ -303,7 +303,7 @@ void RGBController_AOCKeyboard::DeviceUpdateLEDs()
 
         for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
         {
-            color_buf[led_values[led_idx]] = colors[led_idx];
+            color_buf[leds[led_idx].value] = colors[led_idx];
         }
 
         controller->SetCustom(&color_buf[0]);

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.h

@@ -29,6 +29,5 @@ public:
     void        DeviceUpdateMode();
 
 private:
-    AOCKeyboardController*      controller;
-    std::vector<unsigned int>   led_values;
+    AOCKeyboardController*  controller;
 };

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -269,9 +269,9 @@ void RGBController_PolychromeUSB::SetupZones()
             new_led.name = zones[channel_idx].name;
             new_led.name.append(", LED ");
             new_led.name.append(std::to_string(led_ch_idx + 1));
+            new_led.value = (unsigned int)channel_idx;
 
             leds.push_back(new_led);
-            led_values.push_back(channel_idx);
         }
     }
 
@@ -296,7 +296,7 @@ void RGBController_PolychromeUSB::SetupZones()
      \*---------------------------------------------------------*/
      for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
      {
-         unsigned char led = (unsigned char)led_values[led_idx];
+         unsigned char led = (unsigned char)leds[led_idx].value;
 
          colors[led_idx] = zones_info[led].color;
      }
@@ -334,9 +334,14 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
     }
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
+        if(zones[zone_idx].leds_count == 0)
+        {
+            continue;
+        }
+
         unsigned char set_mode = zones_info[zone_idx].mode;
 
-        if (set_mode>modes.size())
+        if(set_mode>modes.size())
         {
             set_mode = active_mode;
         }
@@ -347,6 +352,11 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
 
 void RGBController_PolychromeUSB::DeviceUpdateZoneLEDs(int zone)
 {
+    if(zones[zone].leds_count == 0)
+    {
+        return;
+    }
+
     unsigned char set_mode=zones_info[zone].mode;
 
     if(set_mode > modes.size())
@@ -354,20 +364,25 @@ void RGBController_PolychromeUSB::DeviceUpdateZoneLEDs(int zone)
         set_mode = active_mode;
     }
 
-    controller->WriteZone(zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
+    controller->WriteZone((unsigned char)zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
 }
 
 void RGBController_PolychromeUSB::DeviceUpdateSingleLED(int led)
 {
-    unsigned int  channel  = led_values[led];
+    unsigned int  channel  = leds[led].value;
     unsigned char set_mode = zones_info[channel].mode;
 
+    if(zones[channel].leds_count == 0)
+    {
+        return;
+    }
+
     if(set_mode > modes.size())
     {
         set_mode = active_mode;
     }
 
-    controller->WriteZone(channel, set_mode, zones_info[channel].speed, zones[channel].colors[0], false);
+    controller->WriteZone((unsigned char)channel, set_mode, zones_info[channel].speed, zones[channel].colors[0], false);
 }
 
 unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -33,7 +33,6 @@ public:
 
 private:
     PolychromeUSBController*        controller;
-    std::vector<unsigned int>       led_values;
     std::vector<PolychromeZoneInfo> zones_info;
 
     unsigned char GetDeviceMode(unsigned char zone);

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.cpp

@@ -158,11 +158,6 @@ void RGBController_ASRockASRRGBSMBus::SetupZones()
     \*---------------------------------------------------------*/
     leds.push_back(*new_led);
 
-    /*---------------------------------------------------------*\
-    | Initialize led_values vector                              |
-    \*---------------------------------------------------------*/
-    led_values.push_back(0);
-
     SetupColors();
 }
 
@@ -189,9 +184,9 @@ void RGBController_ASRockASRRGBSMBus::DeviceUpdateSingleLED(int led)
     | If the LED value is non-zero, this LED overrides the LED  |
     | index                                                     |
     \*---------------------------------------------------------*/
-    if(led_values[led] != 0)
+    if(leds[led].value != 0)
     {
-        led = led_values[led];
+        led = leds[led].value;
     }
 
     controller->SetColorsAndSpeed(led, red, grn, blu);

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.h

@@ -30,5 +30,4 @@ public:
 
 private:
     ASRockASRRGBSMBusController* controller;
-    std::vector<unsigned int>    led_values;
 };

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.cpp

@@ -285,13 +285,13 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
             led*    new_led         = new led();
 
             new_led->name           = polychrome_v1_zone_names[zone_idx];
+            new_led->value          = zone_idx;
 
             /*---------------------------------------------------------*\
             | Push new LED to LEDs vector                               |
             \*---------------------------------------------------------*/
             leds.push_back(*new_led);
             zoneIndexMap.push_back(zone_idx);
-            led_values.push_back(zone_idx);
         }
     }
 

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.h

@@ -32,9 +32,7 @@ public:
     void        DeviceUpdateMode();
 
 private:
-    ASRockPolychromeV1SMBusController*  controller;
-    std::vector<unsigned int>           led_values;
-    std::vector<uint8_t>                zoneIndexMap;
-
-    uint8_t                             getModeIndex(uint8_t mode_value);
+    ASRockPolychromeV1SMBusController* controller;
+    uint8_t                 getModeIndex(uint8_t mode_value);
+    std::vector<uint8_t>    zoneIndexMap;
 };

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

@@ -238,7 +238,6 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
         }
     }
 
-    unsigned int led_count = 0;
     /*---------------------------------------------------------*\
     | Set up LEDs                                               |
     \*---------------------------------------------------------*/
@@ -256,14 +255,11 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                 new_led->name           = polychrome_v2_zone_names[zone_idx];
 
                 new_led->name.append(" " + std::to_string(led_idx + 1));
+                new_led->value = 0;
 
                 if(zone_idx == POLYCHROME_V2_ZONE_ADDRESSABLE)
                 {
-                    led_values.push_back(0x19);
-                }
-                else
-                {
-                    led_values.push_back(0);
+                    new_led->value              = 0x19;
                 }
 
                 /*---------------------------------------------------------*\
@@ -271,8 +267,6 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                 \*---------------------------------------------------------*/
                 leds.push_back(*new_led);
 
-                led_count++;
-
                 if(zone_idx == POLYCHROME_V2_ZONE_ADDRESSABLE)
                 {
                     break;
@@ -314,9 +308,9 @@ void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateSingleLED(int led)
     | If the LED value is non-zero, this LED overrides the LED  |
     | index                                                     |
     \*---------------------------------------------------------*/
-    if(led_values[led] != 0)
+    if(leds[led].value != 0)
     {
-        led = led_values[led];
+        led = leds[led].value;
     }
 
     controller->SetColorsAndSpeed(led, red, grn, blu);

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.h

@@ -32,6 +32,5 @@ public:
     void        DeviceUpdateMode();
 
 private:
-    ASRockPolychromeV2SMBusController*  controller;
-    std::vector<unsigned int>           led_values;
+    ASRockPolychromeV2SMBusController* controller;
 };

Controllers/AlienwareKeyboardController/AlienwareAW410KController/AlienwareAW410KControllerDetect.cpp

@@ -1,7 +1,7 @@
 /*---------------------------------------------------------*\
-| AlienwareKeyboardControllerDetect.cpp                     |
+| AlienwareAW410KControllerDetect.cpp                       |
 |                                                           |
-|   Detector for Alienware Keyboard                         |
+|   Detector for Alienware AW410K Keyboard                  |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -10,38 +10,17 @@
 #include <hidapi.h>
 #include "DetectionManager.h"
 #include "AlienwareAW410KController.h"
-#include "AlienwareAW510KController.h"
 #include "RGBController_AlienwareAW410K.h"
-#include "RGBController_AlienwareAW510K.h"
 
 /*---------------------------------------------------------*\
 | Alienware vendor ID                                       |
 \*---------------------------------------------------------*/
-#define ALIENWARE_VID                           0x04F2
+#define ALIENWARE_VID                               0x04F2
 
 /*---------------------------------------------------------*\
 | Keyboard product IDs                                      |
 \*---------------------------------------------------------*/
-#define ALIENWARE_AW510K_PID                    0x1830
-#define ALIENWARE_AW410K_PID                    0x1968
-
-DetectedControllers DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
-{
-    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);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
+#define ALIENWARE_AW410K_PID                        0x1968
 
 DetectedControllers DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
 {
@@ -61,5 +40,4 @@ DetectedControllers DetectAlienwareAW410KControllers(hid_device_info* info, cons
     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/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.cpp

@@ -313,7 +313,7 @@ void RGBController_AlienwareAW410K::SetupZones()
     {
         led new_led;
         new_led.name  = led_names[led_idx].name;
-        led_values.push_back(led_names[led_idx].idx);
+        new_led.value = led_names[led_idx].idx;
         leds.push_back(new_led);
     }
 
@@ -329,14 +329,14 @@ void RGBController_AlienwareAW410K::DeviceUpdateLEDs()
 
     for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        SelectedButtons key;
+            SelectedButtons key;
 
-        key.idx     = led_values[led_idx];
-        key.red     = RGBGetRValue(colors[led_idx]);
-        key.green   = RGBGetGValue(colors[led_idx]);
-        key.blue    = RGBGetBValue(colors[led_idx]);
+            key.idx     = (unsigned char)leds[led_idx].value;
+            key.red     = RGBGetRValue(colors[led_idx]);
+            key.green   = RGBGetGValue(colors[led_idx]);
+            key.blue    = RGBGetBValue(colors[led_idx]);
 
-        frame_buf_keys.push_back(key);
+            frame_buf_keys.push_back(key);
     }
 
     controller->SendInitialize();
@@ -358,7 +358,7 @@ void RGBController_AlienwareAW410K::DeviceUpdateZoneLEDs(int zone)
 
 void RGBController_AlienwareAW410K::DeviceUpdateSingleLED(int led)
 {
-    controller->DeviceUpdateSingleLED(led_values[led], RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+    controller->DeviceUpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }
 
 void RGBController_AlienwareAW410K::DeviceUpdateMode()

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.h

@@ -32,5 +32,4 @@ public:
 private:
     AlienwareAW410KController*  controller;
     std::vector<RGBColor>       current_colors;
-    std::vector<unsigned char>  led_values;
 };

Controllers/AlienwareKeyboardController/AlienwareAW510KController/AlienwareAW510KControllerDetect.cpp

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------*\
+| AlienwareAW510KControllerDetect.cpp                       |
+|                                                           |
+|   Detector for Alienware AW510K Keyboard                  |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "DetectionManager.h"
+#include "AlienwareAW510KController.h"
+#include "RGBController_AlienwareAW510K.h"
+
+/*---------------------------------------------------------*\
+| Alienware vendor ID                                       |
+\*---------------------------------------------------------*/
+#define ALIENWARE_VID                               0x04F2
+
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+\*---------------------------------------------------------*/
+#define ALIENWARE_AW510K_PID                        0x1830
+
+DetectedControllers DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
+{
+    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);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.cpp

@@ -312,7 +312,7 @@ void RGBController_AlienwareAW510K::SetupZones()
     {
         led new_led;
         new_led.name  = led_names[led_idx].name;
-        led_values.push_back(led_names[led_idx].idx);
+        new_led.value = led_names[led_idx].idx;
         leds.push_back(new_led);
     }
 
@@ -328,7 +328,7 @@ void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
 
     for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        if(current_colors[led_idx] == new_colors[led_idx])
+        if (current_colors[led_idx]==new_colors[led_idx])
         {
             /*-------------------------------------------------*\
             | Don't send if key color is not changed            |
@@ -336,14 +336,28 @@ void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
             continue;
         }
 
-        SelectedKeys key;
+        if(RGBGetRValue(colors[led_idx]) != 0x00 || RGBGetBValue(colors[led_idx]) != 0x00 || RGBGetBValue(colors[led_idx]) != 0x00)
+        {
+            SelectedKeys key;
 
-        key.idx     = led_values[led_idx];
-        key.red     = RGBGetRValue(colors[led_idx]);
-        key.green   = RGBGetGValue(colors[led_idx]);
-        key.blue    = RGBGetBValue(colors[led_idx]);
+            key.idx     = (unsigned char)leds[led_idx].value;
+            key.red     = RGBGetRValue(colors[led_idx]);
+            key.green   = RGBGetGValue(colors[led_idx]);
+            key.blue    = RGBGetBValue(colors[led_idx]);
 
-        frame_buf_keys.push_back(key);
+            frame_buf_keys.push_back(key);
+        }
+        else
+        {
+            SelectedKeys key;
+
+            key.idx     = (unsigned char)leds[led_idx].value;
+            key.red     = RGBGetRValue(colors[led_idx]);
+            key.green   = RGBGetGValue(colors[led_idx]);
+            key.blue    = RGBGetBValue(colors[led_idx]);
+
+            frame_buf_keys.push_back(key);
+        }
     }
 
     controller->SendInitialize();
@@ -365,7 +379,7 @@ void RGBController_AlienwareAW510K::DeviceUpdateZoneLEDs(int zone)
 
 void RGBController_AlienwareAW510K::DeviceUpdateSingleLED(int led)
 {
-    controller->DeviceUpdateSingleLED(led_values[led], RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+    controller->DeviceUpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }
 
 void RGBController_AlienwareAW510K::DeviceUpdateMode()

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.h

@@ -31,5 +31,4 @@ public:
 private:
     AlienwareAW510KController*  controller;
     std::vector<RGBColor>       current_colors;
-    std::vector<unsigned char>  led_values;
 };

Controllers/AlienwareMonitorController/RGBController_AlienwareAW3423DWF.cpp

@@ -11,13 +11,6 @@
 
 #include "RGBController_AlienwareAW3423DWF.h"
 
-static const unsigned char led_values[] =
-{
-    0x01,
-    0x02,
-    0x08
-};
-
 /**------------------------------------------------------------------*\
     @name AW3423DWF
     @category Accessory
@@ -70,6 +63,7 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
 
     led Logo_LED;
     Logo_LED.name           = "Logo";
+    Logo_LED.value          = 0x01;
     leds.push_back(Logo_LED);
 
     zone Number;
@@ -82,6 +76,7 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
 
     led Number_LED;
     Number_LED.name         = "Number";
+    Number_LED.value        = 0x02;
     leds.push_back(Number_LED);
 
     zone PowerButton;
@@ -94,6 +89,7 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
 
     led PowerButton_LED;
     PowerButton_LED.name    = "Power Button";
+    PowerButton_LED.value   = 0x08;
     leds.push_back(PowerButton_LED);
 
     SetupColors();
@@ -132,7 +128,7 @@ void RGBController_AlienwareAW3423DWF::DeviceUpdateSingleLED(int led)
     unsigned char red = RGBGetRValue(colors[led]);
     unsigned char grn = RGBGetGValue(colors[led]);
     unsigned char blu = RGBGetBValue(colors[led]);
-    controller->SendColor(led_values[led], red, grn, blu);
+    controller->SendColor(leds[led].value, red, grn, blu);
 }
 
 void RGBController_AlienwareAW3423DWF::DeviceUpdateMode()

Controllers/AlienwareMonitorController/RGBController_AlienwareMonitor.cpp

@@ -11,13 +11,6 @@
 
 #include "RGBController_AlienwareMonitor.h"
 
-static const unsigned char led_values[] =
-{
-    0x01,
-    0x02,
-    0x08
-};
-
 /**------------------------------------------------------------------*\
     @name Alienware Monitor
     @category Accessory
@@ -70,6 +63,7 @@ void RGBController_AlienwareMonitor::SetupZones()
 
     led Logo_LED;
     Logo_LED.name           = "Logo";
+    Logo_LED.value          = 0x01;
     leds.push_back(Logo_LED);
 
     zone Number;
@@ -82,6 +76,7 @@ void RGBController_AlienwareMonitor::SetupZones()
 
     led Number_LED;
     Number_LED.name         = "Number";
+    Number_LED.value        = 0x02;
     leds.push_back(Number_LED);
 
     zone PowerButton;
@@ -94,6 +89,7 @@ void RGBController_AlienwareMonitor::SetupZones()
 
     led PowerButton_LED;
     PowerButton_LED.name    = "Power Button";
+    PowerButton_LED.value   = 0x08;
     leds.push_back(PowerButton_LED);
 
     SetupColors();
@@ -132,7 +128,7 @@ void RGBController_AlienwareMonitor::DeviceUpdateSingleLED(int led)
     unsigned char red = RGBGetRValue(colors[led]);
     unsigned char grn = RGBGetGValue(colors[led]);
     unsigned char blu = RGBGetBValue(colors[led]);
-    controller->SendColor(led_values[led], red, grn, blu);
+    controller->SendColor(leds[led].value, red, grn, blu);
 }
 
 void RGBController_AlienwareMonitor::DeviceUpdateMode()

Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp

@@ -38,69 +38,76 @@ static const unsigned int zone_sizes[] =
     LED_COUNT,
 };
 
-static const char* led_names[] =
+typedef struct
 {
-    KEY_EN_ESCAPE,
-    KEY_EN_1,
-    KEY_EN_2,
-    KEY_EN_3,
-    KEY_EN_4,
-    KEY_EN_5,
-    KEY_EN_6,
-    KEY_EN_7,
-    KEY_EN_8,
-    KEY_EN_9,
-    KEY_EN_0,
-    KEY_EN_MINUS,
-    KEY_EN_EQUALS,
-    KEY_EN_BACKSPACE,
-    KEY_EN_TAB,
-    KEY_EN_Q,
-    KEY_EN_W,
-    KEY_EN_E,
-    KEY_EN_R,
-    KEY_EN_T,
-    KEY_EN_Y,
-    KEY_EN_U,
-    KEY_EN_I,
-    KEY_EN_O,
-    KEY_EN_P,
-    KEY_EN_LEFT_BRACKET,
-    KEY_EN_RIGHT_BRACKET,
-    KEY_EN_ANSI_BACK_SLASH,
-    KEY_EN_CAPS_LOCK,
-    KEY_EN_A,
-    KEY_EN_S,
-    KEY_EN_D,
-    KEY_EN_F,
-    KEY_EN_G,
-    KEY_EN_H,
-    KEY_EN_J,
-    KEY_EN_K,
-    KEY_EN_L,
-    KEY_EN_SEMICOLON,
-    KEY_EN_QUOTE,
-    KEY_EN_ANSI_ENTER,
-    KEY_EN_LEFT_SHIFT,
-    KEY_EN_Z,
-    KEY_EN_X,
-    KEY_EN_C,
-    KEY_EN_V,
-    KEY_EN_B,
-    KEY_EN_N,
-    KEY_EN_M,
-    KEY_EN_COMMA,
-    KEY_EN_PERIOD,
-    KEY_EN_FORWARD_SLASH,
-    KEY_EN_RIGHT_SHIFT,
-    KEY_EN_LEFT_CONTROL,
-    KEY_EN_LEFT_WINDOWS,
-    KEY_EN_LEFT_ALT,
-    KEY_EN_SPACE,
-    KEY_EN_RIGHT_ALT,
-    KEY_EN_RIGHT_FUNCTION,
-    KEY_EN_MENU,
-    KEY_EN_RIGHT_CONTROL,
+    const char *        name;
+    const unsigned char idx;
+} annepro2_led_type;
+
+static const annepro2_led_type led_names[] =
+{
+    /* Key Label                Index  */
+    { KEY_EN_ESCAPE,            0       },
+    { KEY_EN_1,                 1       },
+    { KEY_EN_2,                 2       },
+    { KEY_EN_3,                 3       },
+    { KEY_EN_4,                 4       },
+    { KEY_EN_5,                 5       },
+    { KEY_EN_6,                 6       },
+    { KEY_EN_7,                 7       },
+    { KEY_EN_8,                 8       },
+    { KEY_EN_9,                 9       },
+    { KEY_EN_0,                 10      },
+    { KEY_EN_MINUS,             11      },
+    { KEY_EN_EQUALS,            12      },
+    { KEY_EN_BACKSPACE,         13      },
+    { KEY_EN_TAB,               14      },
+    { KEY_EN_Q,                 15      },
+    { KEY_EN_W,                 16      },
+    { KEY_EN_E,                 17      },
+    { KEY_EN_R,                 18      },
+    { KEY_EN_T,                 19      },
+    { KEY_EN_Y,                 20      },
+    { KEY_EN_U,                 21      },
+    { KEY_EN_I,                 22      },
+    { KEY_EN_O,                 23      },
+    { KEY_EN_P,                 24      },
+    { KEY_EN_LEFT_BRACKET,      25      },
+    { KEY_EN_RIGHT_BRACKET,     26      },
+    { KEY_EN_ANSI_BACK_SLASH,   27      },
+    { KEY_EN_CAPS_LOCK,         28      },
+    { KEY_EN_A,                 29      },
+    { KEY_EN_S,                 30      },
+    { KEY_EN_D,                 31      },
+    { KEY_EN_F,                 32      },
+    { KEY_EN_G,                 33      },
+    { KEY_EN_H,                 34      },
+    { KEY_EN_J,                 35      },
+    { KEY_EN_K,                 36      },
+    { KEY_EN_L,                 37      },
+    { KEY_EN_SEMICOLON,         38      },
+    { KEY_EN_QUOTE,             39      },
+    { KEY_EN_ANSI_ENTER,        40      },
+    { KEY_EN_LEFT_SHIFT,        41      },
+    { KEY_EN_Z,                 42      },
+    { KEY_EN_X,                 43      },
+    { KEY_EN_C,                 44      },
+    { KEY_EN_V,                 45      },
+    { KEY_EN_B,                 46      },
+    { KEY_EN_N,                 47      },
+    { KEY_EN_M,                 48      },
+    { KEY_EN_COMMA,             49      },
+    { KEY_EN_PERIOD,            50      },
+    { KEY_EN_FORWARD_SLASH,     51      },
+    { KEY_EN_RIGHT_SHIFT,       52      },
+    { KEY_EN_LEFT_CONTROL,      53      },
+    { KEY_EN_LEFT_WINDOWS,      54      },
+    { KEY_EN_LEFT_ALT,          55      },
+    { KEY_EN_SPACE,             56      },
+    { KEY_EN_RIGHT_ALT,         57      },
+    { KEY_EN_RIGHT_FUNCTION,    58      },
+    { KEY_EN_MENU,              59      },
+    { KEY_EN_RIGHT_CONTROL,     60      },
 };
 
 /**------------------------------------------------------------------*\
@@ -170,7 +177,8 @@ void RGBController_AnnePro2::SetupZones()
     for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
     {
         led new_led;
-        new_led.name  = led_names[led_idx];
+        new_led.name  = led_names[led_idx].name;
+        new_led.value = led_names[led_idx].idx;
         leds.push_back(new_led);
     }
 
@@ -186,7 +194,7 @@ void RGBController_AnnePro2::DeviceUpdateLEDs()
     | TODO: Send packets with multiple LED frames               |
     \*---------------------------------------------------------*/
     std::size_t led_real_idx = 0;
-    for(std::size_t led_idx = 0; led_idx < colors.size(); led_idx++)
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
         frame_buf[(led_real_idx * 3) + 0] = RGBGetRValue(colors[led_idx]);
         frame_buf[(led_real_idx * 3) + 1] = RGBGetGValue(colors[led_idx]);

Controllers/ArcticController/ArcticControllerDetect.cpp

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

Controllers/ArcticController/RGBController_Arctic.cpp

@@ -75,6 +75,7 @@ void RGBController_Arctic::SetupZones()
 
         led Led;
         Led.name    = LedZone.name + " LED";
+        Led.value   = channel;
 
         zones.push_back(LedZone);
         leds.push_back(Led);

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.cpp

@@ -351,14 +351,11 @@ void RGBController_AsusAuraCoreLaptop::SetupZones()
                     new_zone.leds_count             = new_kb.GetKeyCount();
                     for(unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
                     {
-                        led             new_led;
-                        unsigned int    new_led_value;
+                        led new_led;
 
                         new_led.name                = new_kb.GetKeyNameAt(led_idx);
-                        new_led_value               = new_kb.GetKeyValueAt(led_idx);
-                        max_led_value               = std::max(max_led_value, new_led_value);
-
-                        led_values.push_back(new_led_value);
+                        new_led.value               = new_kb.GetKeyValueAt(led_idx);
+                        max_led_value               = std::max(max_led_value, new_led.value);
                         leds.push_back(new_led);
                     }
                 }
@@ -388,12 +385,24 @@ void RGBController_AsusAuraCoreLaptop::SetupZones()
 
     for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        buffer_map[led_values[led_idx]] = &colors[led_idx];
+        buffer_map[leds[led_idx].value] = &colors[led_idx];
     }
 }
 
 void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs()
 {
+    for(size_t i = 85; i < leds.size(); i++)
+    {
+        LOG_DEBUG("[%s] Setting %s @ LED index %d and buffer index %d to R: %02X G: %02X B: %02X",
+                  name.c_str(),
+                  leds[i].name.c_str(),
+                  i,
+                  leds[i].value,
+                  RGBGetRValue(colors[i]),
+                  RGBGetGValue(colors[i]),
+                  RGBGetBValue(colors[i]));
+    }
+
     controller->SetLedsDirect(buffer_map);
 }
 

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.h

@@ -33,7 +33,6 @@ public:
 private:
     RGBColor                            null_color              = 0;
     std::vector<RGBColor *>             buffer_map;
-    std::vector<unsigned int>           led_values;
 
     AsusAuraCoreLaptopController*       controller;
 };

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.cpp

@@ -471,8 +471,8 @@ void RGBController_AuraKeyboard::SetupZones()
     {
         led new_led;
         new_led.name  = led_names[led_idx].name;
+        new_led.value = led_names[led_idx].idx;
 
-        led_values.push_back(led_names[led_idx].idx);
         leds.push_back(new_led);
     }
 
@@ -493,7 +493,7 @@ void RGBController_AuraKeyboard::DeviceUpdateLEDs()
     \*---------------------------------------------------------*/
     for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        frame_buf[(led_idx * 4) + 0] = led_values[led_idx];
+        frame_buf[(led_idx * 4) + 0] = leds[led_idx].value;
         frame_buf[(led_idx * 4) + 1] = RGBGetRValue(colors[led_idx]);
         frame_buf[(led_idx * 4) + 2] = RGBGetGValue(colors[led_idx]);
         frame_buf[(led_idx * 4) + 3] = RGBGetBValue(colors[led_idx]);

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.h

@@ -54,5 +54,4 @@ public:
 private:
     AuraKeyboardController*         controller;
     AuraKeyboardMappingLayoutType   layout;
-    std::vector<unsigned char>      led_values;
 };

Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.cpp

@@ -207,8 +207,8 @@ void RGBController_AuraMouse::SetupZones()
         led mouse_led;
 
         mouse_led.name          = mouse_zone.name + " LED";
+        mouse_led.value         = *zone_it;
 
-        led_values.push_back(*zone_it);
         leds.push_back(mouse_led);
     }
 
@@ -247,7 +247,7 @@ void RGBController_AuraMouse::DeviceUpdateSingleLED(int led)
     uint8_t grn = RGBGetGValue(colors[led]);
     uint8_t blu = RGBGetBValue(colors[led]);
 
-    controller->SendUpdate(led_values[led], modes[active_mode].value, red, grn, blu, 0, false, 0, modes[active_mode].brightness);
+    controller->SendUpdate(leds[led].value, modes[active_mode].value, red, grn, blu, 0, false, 0, modes[active_mode].brightness);
 }
 
 void RGBController_AuraMouse::DeviceUpdateMode()

Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.h

@@ -31,6 +31,5 @@ public:
 
 private:
     AuraMouseController*  controller;
-    std::vector<uint8_t>  led_values;
     uint16_t              pid;
 };

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.cpp

@@ -141,6 +141,7 @@ void RGBController_AsusROGSpatha::SetupZones()
         led spatha_led;
 
         spatha_led.name          = zones_names[i];
+        spatha_led.value         = 1;
 
         leds.push_back(spatha_led);
     }

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGStrixEvolve.cpp

@@ -99,6 +99,7 @@ void RGBController_AsusROGStrixEvolve::SetupZones()
     led mouse_led;
 
     mouse_led.name          = "Underglow";
+    mouse_led.value         = 1;
 
     leds.push_back(mouse_led);
 

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.cpp

@@ -163,6 +163,7 @@ void RGBController_AsusAuraRyuoAIO::SetupZones()
 
             new_led.name = zones[zone_idx].name;
             new_led.name.append(" LED " + std::to_string(lp_idx));
+            new_led.value = lp_idx;
 
             leds.push_back(new_led);
         }

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -520,7 +520,7 @@ void RGBController_AuraTUFKeyboard::SetupZones()
     {
         led new_led;
         new_led.name  = keyboard[layout].led_names[led_id].name;
-        led_values.push_back(keyboard[layout].led_names[led_id].id);
+        new_led.value = keyboard[layout].led_names[led_id].id;
         leds.push_back(new_led);
     }
 
@@ -538,7 +538,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
 
     for(size_t i = 0; i < colors.size(); i++)
     {
-        led_color_list.push_back({ led_values[i], colors[i] });
+        led_color_list.push_back({ leds[i].value, colors[i] });
     }
 
     controller->UpdateLeds(led_color_list);
@@ -560,7 +560,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateSingleLED(int led)
     unsigned char green = RGBGetGValue(colors[led]);
     unsigned char blue  = RGBGetBValue(colors[led]);
 
-    controller->UpdateSingleLed(led_values[led], red, green, blue);
+    controller->UpdateSingleLed(leds[led].value, red, green, blue);
 }
 
 static const uint8_t direction_map[2][6] =

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.h

@@ -53,5 +53,4 @@ public:
 private:
     AuraTUFKeyboardController*  controller;
     uint16_t                    pid;
-    std::vector<uint8_t>        led_values;
 };

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

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

Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.cpp

@@ -164,6 +164,7 @@ void RGBController_AsusROGStrixLC::SetupZones()
 
             new_led.name    = zones[zone_idx].name;
             new_led.name.append(" LED " + std::to_string(lp_idx));
+            new_led.value   = lp_idx;
 
             leds.push_back(new_led);
         }

Controllers/AsusLegacyUSBController/AsusStrixClawController/RGBController_AsusStrixClaw.cpp

@@ -71,6 +71,7 @@ void RGBController_StrixClaw::SetupZones()
     led scroll_wheel_led;
 
     scroll_wheel_led.name          = "Scroll Wheel LED";
+    scroll_wheel_led.value         = 1;
 
     leds.push_back(scroll_wheel_led);
 
@@ -87,6 +88,7 @@ void RGBController_StrixClaw::SetupZones()
     led logo_led;
 
     logo_led.name          = "Logo LED";
+    logo_led.value         = 1;
 
     leds.push_back(logo_led);
 

Controllers/BlinkyTapeController/BlinkyTapeControllerDetect.cpp

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

Controllers/ClevoKeyboardController/RGBController_ClevoKeyboard.cpp

@@ -241,9 +241,9 @@ void RGBController_ClevoKeyboard::SetupZones()
         led new_led;
 
         new_led.name    = new_kb.GetKeyNameAt(led_idx);
+        new_led.value   = new_kb.GetKeyValueAt(led_idx);
 
         leds.push_back(new_led);
-        led_values.push_back(new_kb.GetKeyValueAt(led_idx));
     }
 
     SetupColors();
@@ -258,7 +258,7 @@ void RGBController_ClevoKeyboard::SetupZones()
 
     for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        buffer_map[led_values[led_idx]] = &colors[led_idx];
+        buffer_map[leds[led_idx].value] = &colors[led_idx];
     }
 }
 

Controllers/ClevoKeyboardController/RGBController_ClevoKeyboard.h

@@ -32,6 +32,5 @@ public:
 private:
     ClevoKeyboardController*        controller;
     std::vector<RGBColor*>          buffer_map;
-    std::vector<unsigned int>       led_values;
     RGBColor                        null_color;
 };

Controllers/ColorfulGPUController/ColorfulGPUController.cpp

@@ -45,7 +45,8 @@ void ColorfulGPUController::SetDirect(RGBColor color)
     uint8_t g = RGBGetGValue(color);
     uint8_t b = RGBGetBValue(color);
 
-    if(this->bus->info.pci_subsystem_device == COLORFUL_IGAME_RTX_4070_VULCAN_OCV)
+    if(this->bus->info.pci_subsystem_device == COLORFUL_IGAME_RTX_4070_VULCAN_OCV
+    || this->bus->info.pci_subsystem_device == COLORFUL_IGAME_RTX_4090_NEPTUNE_OCV)
     {
         uint8_t data_pkt[COLORFUL_PACKET_LENGTH_V2] = { 0xAA, 0xEF, 0x01, 0x04, 0x88, 0x26 };
         for(int i=6; i < COLORFUL_PACKET_LENGTH_V2 -2; i = i + 3)

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -1,4 +1,4 @@
-/*---------------------------------------------------------*\
+/*---------------------------------------------------------*\
 | ColorfulGPUControllerDetect.cpp                           |
 |                                                           |
 |   Detector for Colorful GPU                               |
@@ -74,10 +74,13 @@ REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Vulcan OC-V",            Detec
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 SUPER Ultra W OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070S_DEV,         COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070S_ULTRAW_OCV,            0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV,             0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2,            0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Neptune OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_NEPTUNE_OCV,            0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV,           0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV2,          0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ultra W OC",             DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060_ULTRAW_OC,              0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ultra W OC",             DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060_ULTRAW_OC_2,            0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ti Ultra W DUO OC",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060TI_ULTRAW_DUO_OC,        0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ti Ultra W DUO OC",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060TI_ULTRAW_DUO_OC_2,      0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV,             0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV2,            0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV2,            0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ti Ultra W OC",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070TI_ULTRAW_OC,            0x61);

Controllers/CoolerMasterController/CMGD160Controller/RGBController_CMGD160Controller.cpp

@@ -159,7 +159,7 @@ void RGBController_CMGD160Controller::SetupZones()
     {
         led l;
         l.name          = "Front LED " + std::to_string(i + 1);
-
+        l.value         = i;
         leds.push_back(l);
     }
 
@@ -175,7 +175,7 @@ void RGBController_CMGD160Controller::SetupZones()
     {
         led l;
         l.name          = "Back LED " + std::to_string(i + 1);
-
+        l.value         = i;
         leds.push_back(l);
     }
 

Controllers/CoolerMasterController/CMMM711Controller/RGBController_CMMM711Controller.cpp

@@ -146,10 +146,12 @@ void RGBController_CMMM711Controller::Init_Controller()
 
     led wheel_led;
     wheel_led.name          = "Scroll Wheel LED";
+    wheel_led.value         = 0;
     leds.push_back(wheel_led);
 
     led logo_led;
     logo_led.name           = "Logo LED";
+    logo_led.value          = 1;
     leds.push_back(logo_led);
 }
 

Controllers/CoolerMasterController/CMMM712Controller/RGBController_CMMM712Controller.cpp

@@ -139,6 +139,7 @@ void RGBController_CMMM712Controller::Init_Controller()
 
     led logo_led;
     logo_led.name           = "Logo LED";
+    logo_led.value          = 0;
     leds.push_back(logo_led);
 }
 

Controllers/CoolerMasterController/CMMMController/RGBController_CMMMController.cpp

@@ -183,24 +183,28 @@ void RGBController_CMMMController::Init_Controller()
     mouse_zone.leds_count   = leds_count;
     zones.push_back(mouse_zone);
 
+    int value               = 0;
     uint16_t pid            = controller->GetProductID();
 
     led wheel_led;
     wheel_led.name          = "Scroll Wheel";
-
+    wheel_led.value         = value;
     leds.push_back(wheel_led);
 
+    value++;
+
     if(pid == 0x0065 || pid == 0x0097)
     {
         led buttons_led;
         buttons_led.name        = "Buttons";
-
+        buttons_led.value       = value;
         leds.push_back(buttons_led);
+        value++;
     }
 
     led logo_led;
     logo_led.name           = "Logo";
-
+    logo_led.value          = value;
     leds.push_back(logo_led);
 }
 

Controllers/CoolerMasterController/CMMonitorController/RGBController_CMMonitorController.cpp

@@ -162,7 +162,7 @@ void RGBController_CMMonitorController::SetupZones()
     {
         led l;
         l.name          = std::to_string(i + 1);
-
+        l.value         = i;
         leds.push_back(l);
     }
 

Controllers/CoolerMasterController/CMR6000Controller/RGBController_CMR6000Controller.cpp

@@ -169,6 +169,7 @@ void RGBController_CMR6000Controller::SetupZones()
 
     led GP_led;
     GP_led.name         = "Logo";
+    GP_led.value        = 0;
     leds.push_back(GP_led);
 
     SetupColors();

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.cpp

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

Controllers/CorsairDRAMController/CorsairDRAMController.cpp

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

Controllers/CorsairDRAMController/CorsairDRAMControllerDetect.cpp

@@ -24,18 +24,15 @@ using namespace std::chrono_literals;
 
 bool TestForCorsairDRAMController(i2c_smbus_interface *bus, unsigned char address)
 {
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-
     LOG_DEBUG("[%s] Trying address %02X", CORSAIR_DRAM_NAME, address);
 
+    int res = bus->i2c_smbus_read_byte_data(address, 0x43);
+
     if(res < 0)
     {
-        LOG_DEBUG("[%s] Failed: res was %04X", CORSAIR_DRAM_NAME, res);
         return false;
     }
 
-    res = bus->i2c_smbus_read_byte_data(address, 0x43);
-
     if(!(res == 0x1A || res == 0x1B || res == 0x1C))
     {
         LOG_DEBUG("[%s] Failed: expected 0x1A, 0x1B, or 0x1C, got %04X", CORSAIR_DRAM_NAME, res);

Controllers/CorsairICueLinkController/RGBController_CorsairICueLink.cpp

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

Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp

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

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -526,27 +526,26 @@ void CorsairPeripheralController::ReadFirmwareInfo()
     char offset = 0;
 
     /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
+    | Some Corsair keyboards (e.g. K70 RGB MK.2) do not     |
+    | answer the firmware-info query on the control         |
+    | interface until several seconds after the host first  |
+    | talks to them following a cold boot.  A single read   |
+    | attempt returns all zeros, the device type comes back |
+    | as 0x00, and the device is discarded as UNKNOWN.      |
+    | Retry the query until a valid device type byte is     |
+    | returned or the attempt cap is reached.  Each failed  |
+    | attempt is paced by the 1s hid_read_timeout below, so |
+    | the cap also bounds the detection stall for a device  |
+    | that opens but never answers.  Observed need          |
+    | on a K70 RGB MK.2 cold boot is 2 attempts; the cap    |
+    | leaves generous headroom.                             |
     \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+    int attempt = 0;
 
-    /*-----------------------------------------------------*\
-    | Set up Read Firmware Info packet                      |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_COMMAND_READ;
-    usb_buf[0x02]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
-
-    /*-----------------------------------------------------*\
-    | Send packet and try reading it using an HID read      |
-    | If that fails, repeat the send and read the reply as  |
-    | a feature report.                                     |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
-    actual = hid_read_timeout(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH, 1000);
-
-    if(actual == 0)
+    do
     {
+        offset = 0;
+
         /*-------------------------------------------------*\
         | Zero out buffer                                   |
         \*-------------------------------------------------*/
@@ -559,10 +558,48 @@ void CorsairPeripheralController::ReadFirmwareInfo()
         usb_buf[0x01]   = CORSAIR_COMMAND_READ;
         usb_buf[0x02]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
 
-        hid_send_feature_report(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
-        actual = hid_get_feature_report(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
-        offset = 1;
-    }
+        /*-------------------------------------------------*\
+        | Send packet and try reading it using an HID read  |
+        | If that fails, repeat the send and read the reply |
+        | as a feature report.                              |
+        \*-------------------------------------------------*/
+        hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+        actual = hid_read_timeout(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH, 1000);
+
+        if(actual == 0)
+        {
+            /*---------------------------------------------*\
+            | Zero out buffer                               |
+            \*---------------------------------------------*/
+            memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+
+            /*---------------------------------------------*\
+            | Set up Read Firmware Info packet              |
+            \*---------------------------------------------*/
+            usb_buf[0x00]   = 0x00;
+            usb_buf[0x01]   = CORSAIR_COMMAND_READ;
+            usb_buf[0x02]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
+
+            hid_send_feature_report(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+            actual = hid_get_feature_report(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+            offset = 1;
+        }
+
+        attempt++;
+
+        LOG_DEBUG("[%s] Firmware info attempt %d/%d: device type %02X", CORSAIR_PERIPHERAL_CONTROLLER_NAME, attempt, CORSAIR_FW_INFO_MAX_ATTEMPTS, usb_buf[0x14 + offset]);
+
+        /*-------------------------------------------------*\
+        | Stop as soon as a valid device type is returned   |
+        |   0xC0 keyboard / 0xC1 mouse / 0xC2 pad or stand  |
+        \*-------------------------------------------------*/
+        if(usb_buf[0x14 + offset] == 0xC0
+        || usb_buf[0x14 + offset] == 0xC1
+        || usb_buf[0x14 + offset] == 0xC2)
+        {
+            break;
+        }
+    } while(attempt < CORSAIR_FW_INFO_MAX_ATTEMPTS);
 
     /*-----------------------------------------------------*\
     | Get device type                                       |
@@ -570,7 +607,7 @@ void CorsairPeripheralController::ReadFirmwareInfo()
     |   0xC1    Device is a mouse                           |
     |   0xC2    Device is a mousepad or headset stand       |
     \*-----------------------------------------------------*/
-    LOG_DEBUG("[%s] Device type %02X", CORSAIR_PERIPHERAL_CONTROLLER_NAME, usb_buf[0x14 + offset]);
+    LOG_DEBUG("[%s] Device type %02X after %d attempt(s)", CORSAIR_PERIPHERAL_CONTROLLER_NAME, usb_buf[0x14 + offset], attempt);
 
     switch(usb_buf[0x14 + offset])
     {

Controllers/CorsairPeripheralController/CorsairPeripheralController.h

@@ -16,6 +16,7 @@
 #include "RGBController.h"
 
 #define CORSAIR_PERIPHERAL_PACKET_LENGTH 65
+#define CORSAIR_FW_INFO_MAX_ATTEMPTS     10
 
 enum
 {

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.cpp

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

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.h

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

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2ControllerDetect.cpp

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

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.cpp

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

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.h

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

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Hardware.cpp

@@ -152,8 +152,8 @@ void RGBController_CorsairV2HW::SetupZones()
                         led new_led;
 
                         new_led.name                = new_kb.GetKeyNameAt(led_idx);
-                        led_values.push_back(new_kb.GetKeyValueAt(led_idx));
-                        max_led_value               = std::max(max_led_value, led_values.back());
+                        new_led.value               = new_kb.GetKeyValueAt(led_idx);
+                        max_led_value               = std::max(max_led_value, new_led.value);
                         leds.push_back(new_led);
                     }
                 }
@@ -176,7 +176,7 @@ void RGBController_CorsairV2HW::SetupZones()
 
                     new_led.name                = new_zone.name + " ";
                     new_led.name.append(std::to_string( led_idx ));
-                    led_values.push_back((unsigned int)leds.size());
+                    new_led.value               = (unsigned int)leds.size();
 
                     leds.push_back(new_led);
                 }
@@ -209,7 +209,7 @@ void RGBController_CorsairV2HW::SetupZones()
 
     for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        buffer_map[led_values[led_idx]] = &colors[led_idx];
+        buffer_map[leds[led_idx].value] = &colors[led_idx];
     }
 }
 

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Hardware.h

@@ -34,7 +34,6 @@ public:
 private:
     CorsairPeripheralV2Controller*          controller;
 
-    std::vector<unsigned int>               led_values;
     RGBColor                                null_color              = 0;
     std::vector<RGBColor *>                 buffer_map;
 

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Software.cpp

@@ -139,8 +139,8 @@ void RGBController_CorsairV2SW::SetupZones()
                         led new_led;
 
                         new_led.name                = new_kb.GetKeyNameAt(led_idx);
-                        led_values.push_back(new_kb.GetKeyValueAt(led_idx));
-                        max_led_value               = std::max(max_led_value, led_values.back());
+                        new_led.value               = new_kb.GetKeyValueAt(led_idx);
+                        max_led_value               = std::max(max_led_value, new_led.value);
                         leds.push_back(new_led);
                     }
                 }
@@ -163,7 +163,7 @@ void RGBController_CorsairV2SW::SetupZones()
 
                     new_led.name                = new_zone.name + " ";
                     new_led.name.append(std::to_string( led_idx ));
-                    led_values.push_back((unsigned int)leds.size());
+                    new_led.value               = (unsigned int)leds.size();
 
                     leds.push_back(new_led);
                 }
@@ -196,7 +196,7 @@ void RGBController_CorsairV2SW::SetupZones()
 
     for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        buffer_map[led_values[led_idx]] = &colors[led_idx];
+        buffer_map[leds[led_idx].value] = &colors[led_idx];
     }
 }
 

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Software.h

@@ -36,7 +36,6 @@ public:
 private:
     CorsairPeripheralV2Controller*          controller;
 
-    std::vector<unsigned int>               led_values;
     RGBColor                                null_color              = 0;
     std::vector<RGBColor *>                 buffer_map;
 

Controllers/CorsairWirelessController/CorsairWirelessController.cpp

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

Controllers/CorsairWirelessController/CorsairWirelessController.h

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

Controllers/CorsairWirelessController/CorsairWirelessControllerDetect.cpp

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

Controllers/CorsairWirelessController/RGBController_CorsairWireless.cpp

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

Controllers/CorsairWirelessController/RGBController_CorsairWireless.h

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

Controllers/CougarController/CougarKeyboardController/RGBController_CougarKeyboard.cpp

@@ -409,7 +409,7 @@ void RGBController_CougarKeyboard::SetupZones()
         {
             led new_led;
             new_led.name        = led_names[led_index];
-
+            new_led.value       = led_index;
             leds.push_back(new_led);
         }
     }

Controllers/CrucialController/CrucialController.cpp

@@ -134,7 +134,14 @@ void CrucialController::CrucialRegisterWriteBlock(crucial_register reg, unsigned
     bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
 
     //Write Crucial block data
-    bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
+    if(bus->i2c_smbus_write_block_data(dev, 0x03, sz, data) == -1)
+    {
+        //Fall back to individual byte operations if the block operation fails
+        for(unsigned int block_byte = 0; block_byte < sz; block_byte++)
+        {
+            bus->i2c_smbus_write_byte_data(dev, 0x01, data[block_byte]);
+        }
+    }
 }
 
 void CrucialController::SendEffectColor

Controllers/CrucialController/CrucialControllerDetect.cpp

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

Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.cpp

@@ -206,7 +206,7 @@ void RGBController_CryorigH7QuadLumi::SetupZones()
             new_led.name = zone_names[zone_idx];
             new_led.name.append(", LED ");
             new_led.name.append(std::to_string(led_idx + 1));
-            led_values.push_back(zone_idx);
+            new_led.value = zone_idx;
 
             leds.push_back(new_led);
         }
@@ -233,7 +233,7 @@ void RGBController_CryorigH7QuadLumi::DeviceUpdateZoneLEDs(int zone)
 
 void RGBController_CryorigH7QuadLumi::DeviceUpdateSingleLED(int led)
 {
-    unsigned int zone_idx = led_values[led];
+    unsigned int zone_idx = leds[led].value;
 
     DeviceUpdateZoneLEDs(zone_idx);
 }

Controllers/CryorigH7QuadLumiController/RGBController_CryorigH7QuadLumi.h

@@ -33,6 +33,5 @@ public:
 private:
     CryorigH7QuadLumiController*    controller;
     std::vector<unsigned int>       leds_channel;
-    std::vector<unsigned int>       led_values;
     std::vector<unsigned int>       zones_channel;
 };

Controllers/DDPController/RGBController_DDP.cpp

@@ -76,6 +76,7 @@ void RGBController_DDP::SetupZones()
         {
             led new_led;
             new_led.name = zones[zone_idx].name + " LED " + std::to_string(led_idx + 1);
+            new_led.value = 0;
             leds.push_back(new_led);
         }
     }

Controllers/DRGBController/RGBController_DRGB.cpp

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

Controllers/DarkProject/RGBController_DarkProjectKeyboard.cpp

@@ -187,6 +187,7 @@ void RGBController_DarkProjectKeyboard::SetupZones()
         {
             led new_led;
             new_led.name        = led_names[led_index];
+            new_led.value       = led_index;
             leds.push_back(new_led);
         }
     }

Controllers/DebugController/RGBController_Debug.cpp

@@ -505,7 +505,7 @@ void RGBController_Debug::SetupZones()
 
             if(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_DEVICE_SPECIFIC)
             {
-                if(configuration_json.contains("zones") && (zone_idx < (int)configuration_json["zones"].size()))
+                if(configuration_json.contains("zones") && (zone_idx < configuration_json["zones"].size()))
                 {
                     if(configuration_json["zones"][zone_idx].contains("configuration"))
                     {
@@ -767,7 +767,7 @@ void RGBController_Debug::DeviceUpdateDeviceSpecificConfiguration()
 
 }
 
-void RGBController_Debug::DeviceUpdateDeviceSpecificZoneConfiguration(int zone)
+void RGBController_Debug::DeviceUpdateDeviceSpecificZoneConfiguration(int /*zone*/)
 {
     SetupZones();
 }

Controllers/DygmaRaiseController/DygmaRaiseControllerDetect.cpp

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

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -160,7 +160,7 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
 
             for(unsigned int slot = 0; slot < 8; slot++)
             {
-                int res = buses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
+                int res = buses[bus]->i2c_smbus_read_byte(0x77);
 
                 if(res < 0)
                 {
@@ -176,7 +176,7 @@ DetectedControllers DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interfac
                     {
                         LOG_DEBUG("[ENE SMBus DRAM] Testing address %02X to see if there is a device there", ene_ram_addresses[address_list_idx]);
 
-                        res = buses[bus]->i2c_smbus_write_quick(ene_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
+                        res = buses[bus]->i2c_smbus_read_byte(ene_ram_addresses[address_list_idx]);
                     }
                     else
                     {
@@ -413,6 +413,7 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG MATRIX PLATINUM GeForce RTX 4090",
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5060 Gaming OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5060_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_5060_O8G_GAMING,                   0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5070 Gaming OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_5070_O12G_GAMING,                  0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5070 Ti Gaming OC",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_5070TI_O16G_GAMING,                0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5070 Ti Gaming BTF White OC",           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_5070TI_O16G_GAMING_BTF_WHITE,      0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5070 Ti Gaming White OC",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_5070TI_O16G_GAMING_WHITE,          0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 5070 Ti Gaming OC",               DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_5070TI_O16G_GAMING_OC,       0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 5080 Gaming OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_5080_O16G_GAMING,                  0x67);
@@ -423,6 +424,7 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5080 OC WHITE",
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5080",                           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5080_16G_GAMING,            0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5080 WHITE",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5080_16G_GAMING_WHITE,      0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090 OC",                        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING,           0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090",                           DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING_2,         0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090 OC BTF",                    DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING_BTF,       0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL GeForce RTX 5090 OC WHITE",                  DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_RTX_5090_O32G_GAMING_WHITE,     0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG ASTRAL LC GeForce RTX 5090 OC",                     DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_ASTRAL_LC_RTX_5090_O32G_GAMING,        0x67);

Controllers/ENESMBusController/ENESMBusInterface/ENESMBusInterface_i2c_smbus.cpp

@@ -61,5 +61,12 @@ void ENESMBusInterface_i2c_smbus::ENERegisterWriteBlock(ene_dev_id dev, ene_regi
     bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
 
     //Write ENE block data
-    bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
+    if(bus->i2c_smbus_write_block_data(dev, 0x03, sz, data) == -1)
+    {
+        //Fall back to individual byte operations if the block operation fails
+        for(unsigned int block_byte = 0; block_byte < sz; block_byte++)
+        {
+            bus->i2c_smbus_write_byte_data(dev, 0x01, data[block_byte]);
+        }
+    }
 }

Controllers/ENESMBusController/RGBController_ENESMBus.cpp

@@ -265,7 +265,7 @@ int RGBController_ENESMBus::GetDeviceMode()
     \*---------------------------------------------------------*/
     for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        unsigned int  led = led_values[led_idx];
+        unsigned int  led = leds[led_idx].value;
         unsigned char red;
         unsigned char grn;
         unsigned char blu;
@@ -306,7 +306,7 @@ void RGBController_ENESMBus::DeviceUpdateZoneLEDs(int zone)
 {
     for(std::size_t led_idx = 0; led_idx < zones[zone].leds_count; led_idx++)
     {
-        int           led   = led_values[zones[zone].start_idx + led_idx];
+        int           led   = zones[zone].leds[led_idx].value;
         RGBColor      color = colors[led];
         unsigned char red   = RGBGetRValue(color);
         unsigned char grn   = RGBGetGValue(color);
@@ -435,7 +435,7 @@ void RGBController_ENESMBus::SetupZones()
             new_led->name = zones[zone_idx].name + " LED ";
             new_led->name.append(std::to_string(zone_led_idx + 1));
 
-            led_values.push_back(led_idx);
+            new_led->value = led_idx;
             led_idx++;
 
             leds.push_back(*new_led);

Controllers/ENESMBusController/RGBController_ENESMBus.h

@@ -30,8 +30,7 @@ public:
     void        DeviceSaveMode();
 
 private:
-    ENESMBusController*         controller;
-    std::vector<unsigned int>   led_values;
+    ENESMBusController* controller;
 
     int         GetDeviceMode();
 };

Controllers/EVGAUSBController/EVGAKeyboardController/EVGAKeyboardControllerDetect.cpp

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------*\
+| EVGAKeyboardControllerDetect.cpp                          |
+|                                                           |
+|   Detector for EVGA keyboard devices                      |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "DetectionManager.h"
+#include "RGBController_EVGAKeyboard.h"
+
+/*---------------------------------------------------------*\
+| EVGA USB vendor ID                                        |
+\*---------------------------------------------------------*/
+#define EVGA_USB_VID                                0x3842
+
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+\*---------------------------------------------------------*/
+#define Z15_ISO_PID                                 0x260E
+#define Z15_ANSI_PID                                0x2608
+#define Z20_ANSI_PID                                0x260A
+#define Z20_UK_PID                                  0x2610
+
+DetectedControllers DetectEVGAKeyboardControllers(hid_device_info* info, const std::string& name)
+{
+    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);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+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);
+REGISTER_HID_DETECTOR_IPU("EVGA Z20 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z20_UK_PID,                 1,  0x08,   0x4B);
+

Controllers/EVGAUSBController/EVGAMouseController/EVGAMouseControllerDetect.cpp

@@ -1,7 +1,7 @@
 /*---------------------------------------------------------*\
-| EVGAUSBControllerDetect.cpp                               |
+| EVGAMouseControllerDetect.cpp                             |
 |                                                           |
-|   Detector for EVGA USB devices                           |
+|   Detector for EVGA mouse devices                         |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -9,45 +9,18 @@
 
 #include <hidapi.h>
 #include "DetectionManager.h"
-#include "RGBController_EVGAKeyboard.h"
 #include "RGBController_EVGAMouse.h"
 
 /*---------------------------------------------------------*\
 | EVGA USB vendor ID                                        |
 \*---------------------------------------------------------*/
-#define EVGA_USB_VID                            0x3842
-
-/*---------------------------------------------------------*\
-| Keyboard product IDs                                      |
-\*---------------------------------------------------------*/
-#define Z15_ISO_PID                             0x260E
-#define Z15_ANSI_PID                            0x2608
-#define Z20_ANSI_PID                            0x260A
-#define Z20_UK_PID                              0x2610
+#define EVGA_USB_VID                                0x3842
 
 /*---------------------------------------------------------*\
 | Mouse product IDs                                         |
 \*---------------------------------------------------------*/
-#define X20_WIRED_PID                           0x2420
-#define X20_WIRELESS_ADAPTER_PID                0x2402
-
-DetectedControllers DetectEVGAKeyboardControllers(hid_device_info* info, const std::string& name)
-{
-    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);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
+#define X20_WIRED_PID                               0x2420
+#define X20_WIRELESS_ADAPTER_PID                    0x2402
 
 DetectedControllers DetectEVGAMouse(hid_device_info* info, const std::string &name, int connection_type)
 {
@@ -77,10 +50,5 @@ DetectedControllers DetectWirelessEVGAMouse(hid_device_info* info, const std::st
     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);
-REGISTER_HID_DETECTOR_IPU("EVGA Z20 Keyboard",     DetectEVGAKeyboardControllers,   EVGA_USB_VID,   Z20_UK_PID,                 1,  0x08,   0x4B);
-
 REGISTER_HID_DETECTOR_IPU("EVGA X20 Gaming Mouse",  DetectWiredEVGAMouse,           EVGA_USB_VID,   X20_WIRED_PID,              2,  0xFFFF, 0);
 REGISTER_HID_DETECTOR_IPU("EVGA X20 USB Receiver",  DetectWirelessEVGAMouse,        EVGA_USB_VID,   X20_WIRELESS_ADAPTER_PID,   2,  0xFFFF, 0);

Controllers/EVGAUSBController/EVGAMouseController/RGBController_EVGAMouse.cpp

@@ -174,14 +174,17 @@ void RGBController_EVGAMouse::Init_Controller()
 
     led front_led;
     front_led.name          = "Front LED";
+    front_led.value         = 0;
     leds.push_back(front_led);
 
     led wheel_led;
     wheel_led.name          = "Scroll Wheel LED";
+    wheel_led.value         = 1;
     leds.push_back(wheel_led);
 
     led back_led;
     back_led.name           = "Back LED";
+    back_led.value          = 2;
     leds.push_back(back_led);
 }
 

Controllers/EVisionKeyboardController/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------*\
+| EVisionKeyboardControllerDetect.cpp                       |
+|                                                           |
+|   Detector for EVision/Huafenda keyboards                 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "DetectionManager.h"
+#include "EVisionKeyboardController.h"
+#include "RGBController_EVisionKeyboard.h"
+#include "ResourceManager.h"
+#include "SettingsManager.h"
+
+/*---------------------------------------------------------*\
+| EVision vendor ID                                         |
+|   NOTE: EVision (and Huafenda) use rebranded Sonix MCUs   |
+|   Some EVision/Huafenda keyboards use the Sonix VID while |
+|   others use EVision's VID                                |
+\*---------------------------------------------------------*/
+#define SONIX_VID                                   0x0C45
+#define EVISION_VID                                 0x320F
+
+/*---------------------------------------------------------*\
+| EVision Usage Page                                        |
+\*---------------------------------------------------------*/
+#define EVISION_KEYBOARD_USAGE_PAGE                 0xFF1C
+
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+\*---------------------------------------------------------*/
+#define EVISION_SONIX_5004_PID                      0x5004
+#define EVISION_SONIX_5104_PID                      0x5104
+#define EVISION_SONIX_5204_PID                      0x5204
+#define EVISION_SONIX_652F_PID                      0x652F
+#define EVISION_SONIX_7672_PID                      0x7672
+#define EVISION_SONIX_7698_PID                      0x7698
+#define EVISION_SONIX_8520_PID                      0x8520
+#define EVISION_5000_PID                            0x5000
+#define EVISION_502A_PID                            0x502A
+#define EVISION_505B_PID                            0x505B
+#define EVISION_5064_PID                            0x5064
+#define EVISION_5078_PID                            0x5078
+#define EVISION_5084_PID                            0x5084
+
+DetectedControllers DetectEVisionKeyboards(hid_device_info* info, const std::string& name)
+{
+    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);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+/*---------------------------------------------------------*\
+| Keyboards                                                 |
+\*---------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5004",  DetectEVisionKeyboards, SONIX_VID,      EVISION_SONIX_5004_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5104",  DetectEVisionKeyboards, SONIX_VID,      EVISION_SONIX_5104_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5204",  DetectEVisionKeyboards, SONIX_VID,      EVISION_SONIX_5204_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:652F",  DetectEVisionKeyboards, SONIX_VID,      EVISION_SONIX_652F_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:7672",  DetectEVisionKeyboards, SONIX_VID,      EVISION_SONIX_7672_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:7698",  DetectEVisionKeyboards, SONIX_VID,      EVISION_SONIX_7698_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:8520",  DetectEVisionKeyboards, SONIX_VID,      EVISION_SONIX_8520_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5000",  DetectEVisionKeyboards, EVISION_VID,    EVISION_5000_PID,       1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:502A",  DetectEVisionKeyboards, EVISION_VID,    EVISION_502A_PID,       1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:505B",  DetectEVisionKeyboards, EVISION_VID,    EVISION_505B_PID,       1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5078",  DetectEVisionKeyboards, EVISION_VID,    EVISION_5078_PID,       1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5064",  DetectEVisionKeyboards, EVISION_VID,    EVISION_5064_PID,       1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5084",  DetectEVisionKeyboards, EVISION_VID,    EVISION_5084_PID,       1, EVISION_KEYBOARD_USAGE_PAGE);

Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp

@@ -1,129 +0,0 @@
-/*---------------------------------------------------------*\
-| EVisionKeyboardControllerDetect.cpp                       |
-|                                                           |
-|   Detector for EVision keyboards                          |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
-#include "DetectionManager.h"
-#include "EVisionKeyboardController.h"
-#include "EVisionV2KeyboardController.h"
-#include "RGBController_EVisionKeyboard.h"
-#include "RGBController_EVisionV2Keyboard.h"
-#include "ResourceManager.h"
-#include "SettingsManager.h"
-
-/*---------------------------------------------------------*\
-| Keyboard product IDs                                      |
-\*---------------------------------------------------------*/
-#define EVISION_KEYBOARD_VID        0x0C45
-#define EVISION_KEYBOARD2_VID       0x320F
-#define EVISION_KEYBOARD3_VID       0x3299
-#define EVISION_KEYBOARD_USAGE_PAGE 0xFF1C
-#define ENDORFY_OMNIS_PID           0x0012
-#define DEXP_BLAZE_PID              0x5084
-#define GLORIOUS_GMMK_TKL_PID       0x5064
-#define REDRAGON_K550_PID           0x5204
-#define MARS_GAMING_MKMINI_PID      0x5078
-#define SKILLKORP_K5_PID            0x505B
-#define REDRAGON_K552_PID           0x5104
-#define REDRAGON_K552_V2_PID        0x5000
-#define REDRAGON_K556_PID           0x5004
-#define TECWARE_PHANTOM_ELITE_PID   0x652F
-#define WARRIOR_KANE_TC235          0x8520
-#define WOMIER_K87_PID              0x502A
-#define WOMIER_K66_PID              0x7698
-#define BYGG_CSB_ICL01_PID          0x5041
-#define GAMEPOWER_OGRE_RGB_PID      0x7672
-
-DetectedControllers DetectEVisionKeyboards(hid_device_info* info, const std::string& name)
-{
-    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);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
-
-DetectedControllers DetectEVisionV2Keyboards(hid_device_info* info, const std::string& name)
-{
-    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);
-
-        detected_controllers.push_back(rgb_controller);
-
-        if(!settings.contains("AdditionalZones") || settings["AdditionalZones"] == true)
-        {
-            rgb_controller                             = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_LOGO);
-
-            detected_controllers.push_back(rgb_controller);
-
-            rgb_controller                             = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_EDGE);
-
-            detected_controllers.push_back(rgb_controller);
-        }
-    }
-
-    return(detected_controllers);
-}
-
-DetectedControllers DetectEndorfyKeyboards(hid_device_info* info, const std::string& name)
-{
-    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);
-
-        detected_controllers.push_back(rgb_controller);
-
-        if(!settings.contains("AdditionalZones") || settings["AdditionalZones"] == true)
-        {
-            rgb_controller                              = new RGBController_EVisionV2Keyboard(controller, ENDORFY_KEYBOARD_PART_EDGE);
-
-            detected_controllers.push_back(rgb_controller);
-        }
-    }
-
-    return(detected_controllers);
-}
-
-/*---------------------------------------------------------------------------------------------------------------------------------------------*\
-| Keyboards                                                                                                                                     |
-\*---------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5078",      DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, MARS_GAMING_MKMINI_PID,    1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5204",      DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  REDRAGON_K550_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5104",      DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  REDRAGON_K552_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5000",      DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, REDRAGON_K552_V2_PID,      1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5004",      DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  REDRAGON_K556_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:652F",      DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  TECWARE_PHANTOM_ELITE_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:8520",      DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  WARRIOR_KANE_TC235,        1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:502A",      DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, WOMIER_K87_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:7698",      DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  WOMIER_K66_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5064",      DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, GLORIOUS_GMMK_TKL_PID,     1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5084",      DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, DEXP_BLAZE_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:505B",      DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, SKILLKORP_K5_PID,          1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Endorfy Omnis",                   DetectEndorfyKeyboards,   EVISION_KEYBOARD3_VID, ENDORFY_OMNIS_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("CSB/ICL01 Keyboard",              DetectEVisionV2Keyboards, EVISION_KEYBOARD2_VID, BYGG_CSB_ICL01_PID,        1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Gamepower Ogre RGB 0C45:7672",    DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  GAMEPOWER_OGRE_RGB_PID,    1, EVISION_KEYBOARD_USAGE_PAGE);