Get rid of zone_based_per_led_data buffer, just use the same configuration buffer for both as it overwrites the original configuration when written to the controller anyways

AutoStart/AutoStart-Flatpak.cpp

@@ -1,158 +0,0 @@
-/*---------------------------------------------------------*\
-| AutoStart-Flatpak.cpp                                     |
-|                                                           |
-|   Autostart implementation for Linux via Flatpak Portal   |
-|                                                           |
-|   Adam Honse <[email protected]>      04 Sep 2026 |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "AutoStart-Flatpak.h"
-#include <gio/gio.h>
-
-AutoStart::AutoStart(std::string name)
-{
-    InitAutoStart(name);
-}
-
-void AutoStart::InitAutoStart(std::string name)
-{
-    app_name = name;
-}
-
-bool AutoStart::CallBackgroundPortal(bool enable, const AutoStartInfo& autostart_info)
-{
-    GError*             error           = nullptr;
-    GDBusConnection*    connection      = g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, &error);
-
-    if(!connection)
-    {
-        if(error)
-        {
-            g_error_free(error);
-        }
-
-        return false;
-    }
-
-    /*-----------------------------------------------------*\
-    | FreeDesktop Background Portal parameters              |
-    \*-----------------------------------------------------*/
-    const char*         bus_name        = "org.freedesktop.portal.Desktop";
-    const char*         object_path     = "/org/freedesktop/portal/desktop";
-    const char*         interface_name  = "org.freedesktop.portal.Background";
-    const char*         method_name     = "RequestBackground";
-
-    /*-----------------------------------------------------*\
-    | Build the options dictionary (vardict) required by    |
-    | the Portal                                            |
-    \*-----------------------------------------------------*/
-    GVariantBuilder     options_builder;
-    g_variant_builder_init(&options_builder, G_VARIANT_TYPE_VARDICT);
-
-    /*-----------------------------------------------------*\
-    | Reason shown to the user in the system settings /     |
-    | permission prompt                                     |
-    \*-----------------------------------------------------*/
-    std::string         reason_str      = "Allow " + app_name + " to launch automatically at startup.";
-    g_variant_builder_add(&options_builder, "{sv}", "reason", g_variant_new_string(reason_str.c_str()));
-
-    /*-----------------------------------------------------*\
-    | Toggle the autostart feature state                    |
-    \*-----------------------------------------------------*/
-    g_variant_builder_add(&options_builder, "{sv}", "autostart", g_variant_new_boolean(enable));
-
-    if(enable)
-    {
-        /*-------------------------------------------------*\
-        | Pass command-line arguments to the background     |
-        | request                                           |
-        \*-------------------------------------------------*/
-        GVariantBuilder arg_builder;
-        g_variant_builder_init(&arg_builder, G_VARIANT_TYPE("as"));
-
-        /*-------------------------------------------------*\
-        | Add the primary executable path inside the        |
-        | Flatpak sandbox                                   |
-        \*-------------------------------------------------*/
-        g_variant_builder_add(&arg_builder, "s", GetExePath().c_str());
-
-        /*-------------------------------------------------*\
-        | Append any additional arguments provided by       |
-        | OpenRGB's autostart config                        |
-        \*-------------------------------------------------*/
-        if(!autostart_info.args.empty())
-        {
-            g_variant_builder_add(&arg_builder, "s", autostart_info.args.c_str());
-        }
-
-        GVariant*   commandline_args    = g_variant_builder_end(&arg_builder);
-        g_variant_builder_add(&options_builder, "{sv}", "commandline", commandline_args);
-    }
-
-    /*-----------------------------------------------------*\
-    | An empty string window handle is used since this is a |
-    | background configuration request                      |
-    \*-----------------------------------------------------*/
-    const char*     parent_window       = "";
-    GVariant*       options             = g_variant_builder_end(&options_builder);
-
-    /*-----------------------------------------------------*\
-    | Bundle parameters: (s a{sv}) -> Parent window handle, |
-    | Options dictionary                                    |
-    \*-----------------------------------------------------*/
-    GVariant*       parameters          = g_variant_new("(s@a{sv})", parent_window, options);
-    GVariant*       reply;
-
-    reply = g_dbus_connection_call_sync(connection, bus_name, object_path, interface_name, method_name, parameters, G_VARIANT_TYPE("(o)"), G_DBUS_CALL_FLAGS_NONE, -1, nullptr, &error);
-
-    g_object_unref(connection);
-
-    if(error)
-    {
-        g_error_free(error);
-        return false;
-    }
-
-    if(reply)
-    {
-        g_variant_unref(reply);
-        return true;
-    }
-
-    return false;
-}
-
-bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
-{
-    return CallBackgroundPortal(true, autostart_info);
-}
-
-bool AutoStart::DisableAutoStart()
-{
-    return CallBackgroundPortal(false);
-}
-
-bool AutoStart::IsAutoStartEnabled()
-{
-    /*-----------------------------------------------------*\
-    | The FreeDesktop Background Portal does not provide a  |
-    | stateless status getter.  Sandbox permissions are     |
-    | securely managed and persisted internally by the      |
-    | host's portal service.  To implement a true state     |
-    | track here, OpenRGB will need to manage a local       |
-    | boolean flag inside its own configuration files (e.g. |
-    | OpenRGB.json).                                        |
-    \*-----------------------------------------------------*/
-    return false;
-}
-
-std::string AutoStart::GetExePath()
-{
-    /*-----------------------------------------------------*\
-    | Flatpak applications always run from this specific    |
-    | exported path hierarchy                               |
-    \*-----------------------------------------------------*/
-    return "/app/bin/openrgb";
-}

AutoStart/AutoStart-Flatpak.h

@@ -1,31 +0,0 @@
-/*---------------------------------------------------------*\
-| AutoStart-Flatpak.h                                       |
-|                                                           |
-|   Autostart implementation for Linux via Flatpak Portal   |
-|                                                           |
-|   Adam Honse <[email protected]>      04 Sep 2026 |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include "AutoStart.h"
-
-class AutoStart : public AutoStartInterface
-{
-public:
-    AutoStart(std::string name);
-
-    bool        DisableAutoStart();
-    bool        EnableAutoStart(AutoStartInfo autostart_info);
-    bool        IsAutoStartEnabled();
-    std::string GetExePath();
-
-private:
-    void        InitAutoStart(std::string name);
-    bool        CallBackgroundPortal(bool enable, const AutoStartInfo& autostart_info = {});
-    
-    std::string app_name;
-};

AutoStart/AutoStart.h

@@ -40,15 +40,9 @@ protected:
 #include "AutoStart-Windows.h"
 #endif
 
-#ifdef FLATPAK_BUILD
-#include "AutoStart-Flatpak.h"
-#endif
-
 #ifdef __linux__
-#ifndef FLATPAK_BUILD
 #include "AutoStart-Linux.h"
 #endif
-#endif
 
 #ifdef __APPLE__
 #include "AutoStart-MacOS.h"

Controllers/ASRockSMBusController/ASRockGPUSMBusController/ASRockGPUSMBusController.cpp

@@ -186,8 +186,8 @@ void ASRockGPUSMBusController::SetChannelColor(uint8_t channel_idx, uint8_t red,
         red,
         green,
         blue,
-        0x80,  // Effect speed
-        0xFF,  // Brightness
+        0x80,  // Brightness
+        0xFF,  // Effect speed
         0x00,  // Effect direction
         0x1A   // Unknown constant
     };

Controllers/ASRockSMBusController/ASRockGPUSMBusController/ASRockGPUSMBusControllerDetect.cpp

@@ -41,7 +41,5 @@ DetectedControllers DetectASRockGPUSMBusControllers(i2c_smbus_interface* bus, ui
     return(detected_controllers);
 }
 
-REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Steel Legend",   DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5403, ASROCK_GPU_SMBUS_ADDRESS);
-REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Steel Legend Dark", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5414, ASROCK_GPU_SMBUS_ADDRESS);
-REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Taichi 16GB OC", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5401, ASROCK_GPU_SMBUS_ADDRESS);
-REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9060 XT Steel Legend",   DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI44_DEV, ASROCK_SUB_VEN, 0x5407, ASROCK_GPU_SMBUS_ADDRESS);
+REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Steel Legend", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5403, ASROCK_GPU_SMBUS_ADDRESS);
+REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9060 XT Steel Legend", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI44_DEV, ASROCK_SUB_VEN, 0x5407, ASROCK_GPU_SMBUS_ADDRESS);

Controllers/ASRockSMBusController/ASRockGPUSMBusController/RGBController_ASRockGPUSMBus.cpp

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

Controllers/AlienwareController/AlienwareController.cpp

@@ -32,7 +32,6 @@ static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
     { 0x0C01,   4 },    // Dell G5 SE 5505
     { 0x0A01,  16 },    // Dell G7 15 7500
     { 0x0E03,   4 },    // Dell G15   5511
-    { 0x0E07,   4 },    // Dell G15   5520
     { 0x0E0A,   4 }     // Dell G15   5530
 
 };
@@ -50,21 +49,9 @@ static const std::map<alienware_platform_id, std::vector<const char*>> zone_name
                   "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
                   "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } },
     { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } },
-    { 0x0E07,   { "Left",           "Middle",       "Right",        "Numpad"    } },
     { 0x0E0A,   { "Left",           "Middle",       "Right",        "Numpad"    } }
 };
 
-/*---------------------------------------------------------*\
-| Mapping the platform ID to the actual hardware zone IDs   |
-\*---------------------------------------------------------*/
-static const std::map<alienware_platform_id, std::vector<uint8_t>> zone_ids_table =
-{
-    { 0x0C01,   { 0x00, 0x01, 0x02, 0x03 } }, // Dell G5 SE 5505
-    { 0x0E03,   { 0x00, 0x01, 0x02, 0x03 } }, // Dell G15   5511
-    { 0x0E07,   { 0x10, 0x11, 0x12, 0x13 } }, // Dell G15   5520
-    { 0x0E0A,   { 0x10, 0x11, 0x12, 0x13 } }  // Dell G15   5530
-};
-
 static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
 {
     using namespace std::chrono_literals;
@@ -151,21 +138,6 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
         }
     }
 
-    /*-----------------------------------------------------*\
-    | Initialize hardware zone IDs                          |
-    \*-----------------------------------------------------*/
-    if(zone_ids_table.count(platform_id))
-    {
-        zone_ids = zone_ids_table.at(platform_id);
-    }
-    else
-    {
-        for(size_t i = 0; i < number_of_zones; i++)
-        {
-            zone_ids.push_back(static_cast<uint8_t>(i));
-        }
-    }
-
     /*-----------------------------------------------------*\
     | Set defaults for all zones                            |
     | It doesn't seem possible to read the controller's     |
@@ -183,7 +155,6 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
         zones[zone_idx].period      = 2000;
         zones[zone_idx].tempo       = ALIENWARE_TEMPO_MAX;
         zones[zone_idx].dim         = 0;
-        zones[zone_idx].direction   = 0;
     }
 
     /*-----------------------------------------------------*\
@@ -702,15 +673,6 @@ void AlienwareController::SetDim(uint8_t zone, uint8_t dim)
     }
 }
 
-void AlienwareController::SetDirection(uint8_t zone, uint8_t direction)
-{
-    if(zone < zones.size())
-    {
-        zones[zone].direction   = direction;
-        dirty                   = true;
-    }
-}
-
 void AlienwareController::UpdateDim()
 {
     if(!dirty_dim)
@@ -726,8 +688,7 @@ void AlienwareController::UpdateDim()
 
     for(size_t i = 0; i < zones.size(); i++)
     {
-        uint8_t hw_zone = (i < zone_ids.size()) ? zone_ids[i] : static_cast<uint8_t>(i);
-        dim_zone_map[zones[i].dim].emplace_back(hw_zone);
+        dim_zone_map[zones[i].dim].emplace_back((uint8_t)i);
     }
 
     for(std::pair<const uint8_t, std::vector<uint8_t>> &pair : dim_zone_map)
@@ -754,8 +715,7 @@ bool AlienwareController::UpdateDirect()
 
     for(size_t i = 0; i < zones.size(); i++)
     {
-        uint8_t hw_zone = (i < zone_ids.size()) ? zone_ids[i] : static_cast<uint8_t>(i);
-        color_zone_map[zones[i].color[0]].emplace_back(hw_zone);
+        color_zone_map[zones[i].color[0]].emplace_back((uint8_t)i);
     }
 
     for(std::pair<const RGBColor, std::vector<uint8_t>> &pair : color_zone_map)
@@ -799,9 +759,8 @@ void AlienwareController::UpdateMode()
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
         alienware_zone zone = zones[zone_idx];
-        uint8_t hw_zone = (zone_idx < zone_ids.size()) ? zone_ids[zone_idx] : static_cast<uint8_t>(zone_idx);
 
-        result = SelectZones({hw_zone});
+        result = SelectZones({static_cast<uint8_t>(zone_idx)});
 
         if(!result)
         {
@@ -824,18 +783,18 @@ void AlienwareController::UpdateMode()
 
             case ALIENWARE_MODE_MORPH:
                 {
-                    uint8_t  modes[2]   = { zone.mode,              zone.mode     };
+                    uint8_t  zones[2]   = { zone.mode,              zone.mode     };
                     uint16_t periods[2] = { zone.period,            zone.period   };
                     uint16_t tempos[2]  = { zone.tempo,             zone.tempo    };
                     RGBColor colors[2]  = { zone.color[0],          zone.color[1] };
 
-                    result = MultiModeAction(modes, periods, tempos, colors, 2);
+                    result = MultiModeAction(zones, periods, tempos, colors, 2);
                 }
                 break;
 
             case ALIENWARE_MODE_SPECTRUM:
                 {
-                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                    uint8_t  zones[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH };
@@ -848,13 +807,13 @@ void AlienwareController::UpdateMode()
                                             zone.tempo,             zone.tempo,
                                             zone.tempo };
 
-                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[0], 7);
+                    result = MultiModeAction(zones, periods, tempos, rainbow_colors[0], 7);
                 }
                 break;
 
             case ALIENWARE_MODE_RAINBOW:
                 {
-                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                    uint8_t  zones[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                             ALIENWARE_MODE_MORPH };
@@ -867,19 +826,18 @@ void AlienwareController::UpdateMode()
                                             zone.tempo,             zone.tempo,
                                             zone.tempo };
 
-                    unsigned int color_idx = (zone.direction == MODE_DIRECTION_LEFT) ? (4 - 1 - (zone_idx % 4)) : (zone_idx % 4);
-                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[color_idx], 7);
+                    result = MultiModeAction(zones, periods, tempos, rainbow_colors[zone_idx], 7);
                 }
                 break;
 
             case ALIENWARE_MODE_BREATHING:
                 {
-                    uint8_t  modes[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
+                    uint8_t  zones[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
                     uint16_t periods[2] = { zone.period,            zone.period          };
                     uint16_t tempos[2]  = { zone.tempo,             zone.tempo           };
                     RGBColor colors[2]  = { zone.color[0],          0x0                  };
 
-                    result = MultiModeAction(modes, periods, tempos, colors, 2);
+                    result = MultiModeAction(zones, periods, tempos, colors, 2);
                 }
                 break;
 
@@ -906,117 +864,6 @@ void AlienwareController::UpdateMode()
     dirty = false;
 }
 
-void AlienwareController::SaveController()
-{
-    /*-----------------------------------------------------*\
-    | Save current mode configuration to EEPROM slot 0x0061 |
-    \*-----------------------------------------------------*/
-    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_REMOVE, ALIENWARE_ANIM_DEFAULT, 0);
-    bool result = UserAnimation(ALIENWARE_COMMAND_USER_ANIM_NEW, ALIENWARE_ANIM_DEFAULT, 0);
-
-    if(!result)
-    {
-        return;
-    }
-
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        alienware_zone zone = zones[zone_idx];
-        uint8_t hw_zone = (zone_idx < zone_ids.size()) ? zone_ids[zone_idx] : static_cast<uint8_t>(zone_idx);
-
-        result = SelectZones({hw_zone});
-
-        if(!result)
-        {
-            return;
-        }
-
-        switch (zone.mode)
-        {
-            case ALIENWARE_MODE_COLOR:
-                result = ModeAction(zone.mode, 2000, ALIENWARE_TEMPO_MAX, zone.color[0]);
-                break;
-
-            case ALIENWARE_MODE_PULSE:
-                result = ModeAction(zone.mode, zone.period, zone.tempo, zone.color[0]);
-                break;
-
-            case ALIENWARE_MODE_MORPH:
-                {
-                    uint8_t  modes[2]   = { zone.mode,              zone.mode     };
-                    uint16_t periods[2] = { zone.period,            zone.period   };
-                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo    };
-                    RGBColor colors[2]  = { zone.color[0],          zone.color[1] };
-
-                    result = MultiModeAction(modes, periods, tempos, colors, 2);
-                }
-                break;
-
-            case ALIENWARE_MODE_SPECTRUM:
-                {
-                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
-                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
-                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
-                                            ALIENWARE_MODE_MORPH };
-                    uint16_t periods[7] = { zone.period,            zone.period,
-                                            zone.period,            zone.period,
-                                            zone.period,            zone.period,
-                                            zone.period };
-                    uint16_t tempos[7] = {  zone.tempo,             zone.tempo,
-                                            zone.tempo,             zone.tempo,
-                                            zone.tempo,             zone.tempo,
-                                            zone.tempo };
-
-                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[0], 7);
-                }
-                break;
-
-            case ALIENWARE_MODE_RAINBOW:
-                {
-                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
-                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
-                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
-                                            ALIENWARE_MODE_MORPH };
-                    uint16_t periods[7] = { zone.period,            zone.period,
-                                            zone.period,            zone.period,
-                                            zone.period,            zone.period,
-                                            zone.period };
-                    uint16_t tempos[7]  = { zone.tempo,             zone.tempo,
-                                            zone.tempo,             zone.tempo,
-                                            zone.tempo,             zone.tempo,
-                                            zone.tempo };
-
-                    unsigned int color_idx = (zone.direction == MODE_DIRECTION_LEFT) ? (4 - 1 - (zone_idx % 4)) : (zone_idx % 4);
-                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[color_idx], 7);
-                }
-                break;
-
-            case ALIENWARE_MODE_BREATHING:
-                {
-                    uint8_t  modes[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
-                    uint16_t periods[2] = { zone.period,            zone.period          };
-                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo           };
-                    RGBColor colors[2]  = { zone.color[0],          0x0                  };
-
-                    result = MultiModeAction(modes, periods, tempos, colors, 2);
-                }
-                break;
-
-            default:
-                result = false;
-        }
-
-        if(!result)
-        {
-            return;
-        }
-    }
-
-    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE, ALIENWARE_ANIM_DEFAULT, 0);
-    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_DEFAULT, ALIENWARE_ANIM_DEFAULT, 0);
-    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_STARTUP, ALIENWARE_ANIM_DEFAULT, 0);
-}
-
 void AlienwareController::UpdateController()
 {
     UpdateMode();

Controllers/AlienwareController/AlienwareController.h

@@ -123,13 +123,11 @@ public:
     void                        SetPeriod(uint8_t zone, uint16_t period);
     void                        SetTempo(uint8_t zone, uint16_t tempo);
     void                        SetDim(uint8_t zone, uint8_t dim);
-    void                        SetDirection(uint8_t zone, uint8_t direction);
     AlienwareReport             GetStatus(uint8_t subcommand);
 
     void                        UpdateDim();
     void                        UpdateMode();
     void                        UpdateController();
-    void                        SaveController();
 
 protected:
     hid_device* dev;
@@ -142,7 +140,6 @@ private:
         uint16_t                period;
         uint16_t                tempo;
         uint8_t                 dim;
-        uint8_t                 direction;
     } alienware_zone;
 
     typedef struct
@@ -156,7 +153,6 @@ private:
     std::string                 serial_number;
     std::string                 version;
     std::vector<const char*>    zone_names;
-    std::vector<uint8_t>        zone_ids;
     bool                        dirty;
     bool                        dirty_dim;
 

Controllers/AlienwareController/RGBController_Alienware.cpp

@@ -39,7 +39,7 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Color;
     Color.name                 = "Static";
     Color.value                = ALIENWARE_MODE_COLOR;
-    Color.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Color.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Color.color_mode           = MODE_COLORS_PER_LED;
     Color.colors_min           = 1;
     Color.colors_max           = 1;
@@ -51,13 +51,13 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Pulse;
     Pulse.name                 = "Flashing";
     Pulse.value                = ALIENWARE_MODE_PULSE;
-    Pulse.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Pulse.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
     Pulse.color_mode           = MODE_COLORS_PER_LED;
     Pulse.colors_min           = 1;
     Pulse.colors_max           = 1;
-    Pulse.speed_min            = ALIENWARE_TEMPO_MAX;
-    Pulse.speed_max            = 50;
-    Pulse.speed                = 150;
+    Pulse.speed_min            = ALIENWARE_TEMPO_MIN;
+    Pulse.speed_max            = ALIENWARE_TEMPO_MAX;
+    Pulse.speed                = ALIENWARE_TEMPO_MIN;
     Pulse.brightness_min       = 100;
     Pulse.brightness_max       = 0;
     Pulse.brightness           = 0;
@@ -66,16 +66,14 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Morph;
     Morph.name                 = "Morph";
     Morph.value                = ALIENWARE_MODE_MORPH;
-    Morph.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Morph.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
     Morph.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Morph.colors_min           = 2;
-    Morph.colors_max           = 2 * controller->GetZoneCount();
-    Morph.colors.resize(2);
-    Morph.colors[0]            = 0x0000FF;
-    Morph.colors[1]            = 0xFF0000;
-    Morph.speed_min            = ALIENWARE_TEMPO_MAX;
-    Morph.speed_max            = 20;
-    Morph.speed                = 100;
+    Morph.colors_min           = 2 * controller->GetZoneCount();
+    Morph.colors_max           = Morph.colors_min;
+    Morph.colors.resize(Morph.colors_max);
+    Morph.speed_min            = ALIENWARE_TEMPO_MIN;
+    Morph.speed_max            = ALIENWARE_TEMPO_MAX;
+    Morph.speed                = ALIENWARE_TEMPO_MIN;
     Morph.brightness_min       = 100;
     Morph.brightness_max       = 0;
     Morph.brightness           = 0;
@@ -84,11 +82,11 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Spectrum;
     Spectrum.name              = "Spectrum Cycle";
     Spectrum.value             = ALIENWARE_MODE_SPECTRUM;
-    Spectrum.flags             = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Spectrum.flags             = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
     Spectrum.color_mode        = MODE_COLORS_NONE;
-    Spectrum.speed_min         = ALIENWARE_TEMPO_MAX;
-    Spectrum.speed_max         = ALIENWARE_TEMPO_SPECTRUM;
-    Spectrum.speed             = 40;
+    Spectrum.speed_min         = ALIENWARE_TEMPO_SPECTRUM;
+    Spectrum.speed_max         = ALIENWARE_TEMPO_MAX;
+    Spectrum.speed             = ALIENWARE_TEMPO_SPECTRUM;
     Spectrum.brightness_min    = 100;
     Spectrum.brightness_max    = 0;
     Spectrum.brightness        = 0;
@@ -97,12 +95,11 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Rainbow;
     Rainbow.name               = "Rainbow Wave";
     Rainbow.value              = ALIENWARE_MODE_RAINBOW;
-    Rainbow.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
+    Rainbow.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
     Rainbow.color_mode         = MODE_COLORS_NONE;
-    Rainbow.speed_min          = ALIENWARE_TEMPO_MAX;
-    Rainbow.speed_max          = ALIENWARE_TEMPO_SPECTRUM;
-    Rainbow.speed              = 40;
-    Rainbow.direction          = MODE_DIRECTION_RIGHT;
+    Rainbow.speed_min          = ALIENWARE_TEMPO_SPECTRUM;
+    Rainbow.speed_max          = ALIENWARE_TEMPO_MAX;
+    Rainbow.speed              = ALIENWARE_TEMPO_SPECTRUM;
     Rainbow.brightness_min     = 100;
     Rainbow.brightness_max     = 0;
     Rainbow.brightness         = 0;
@@ -111,13 +108,13 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     mode Breathing;
     Breathing.name             = "Breathing";
     Breathing.value            = ALIENWARE_MODE_BREATHING;
-    Breathing.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Breathing.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
     Breathing.color_mode       = MODE_COLORS_PER_LED;
     Breathing.colors_min       = 1;
     Breathing.colors_max       = 1;
-    Breathing.speed_min        = ALIENWARE_TEMPO_MAX;
-    Breathing.speed_max        = 50;
-    Breathing.speed            = 150;
+    Breathing.speed_min        = ALIENWARE_TEMPO_MIN;
+    Breathing.speed_max        = ALIENWARE_TEMPO_MAX;
+    Breathing.speed            = ALIENWARE_TEMPO_MIN;
     Breathing.brightness_min   = 100;
     Breathing.brightness_max   = 0;
     Breathing.brightness       = 0;
@@ -227,7 +224,6 @@ void RGBController_Alienware::DeviceUpdateMode()
             uint16_t period = 0x07d0;
 
             controller->SetMode(zone_idx, current_mode.value);
-            controller->SetDirection(zone_idx, current_mode.direction);
 
             switch(current_mode_idx)
             {
@@ -239,7 +235,6 @@ void RGBController_Alienware::DeviceUpdateMode()
                     break;
 
                 case ALIENWARE_MODE_PULSE:
-                    period = std::max<uint16_t>(500, (uint16_t)(current_mode.speed * 10));
                     controller->SetPeriod(zone_idx, period);
                     controller->SetColor( zone_idx, colors[current_zone.start_idx]);
                     controller->SetTempo( zone_idx, current_mode.speed);
@@ -247,22 +242,10 @@ void RGBController_Alienware::DeviceUpdateMode()
                     break;
 
                 case ALIENWARE_MODE_MORPH:
-                    {
-                        RGBColor c1 = (current_mode.colors.size() >= 1) ? current_mode.colors[0] : 0x0000FF;
-                        RGBColor c2 = (current_mode.colors.size() >= 2) ? current_mode.colors[1] : 0xFF0000;
-
-                        if(current_mode.colors.size() >= (std::size_t)((zone_idx + 1) * 2))
-                        {
-                            c1 = current_mode.colors[zone_idx * 2];
-                            c2 = current_mode.colors[(zone_idx * 2) + 1];
-                        }
-
-                        period = std::max<uint16_t>(400, (uint16_t)(current_mode.speed * 10));
-                        controller->SetPeriod(zone_idx, period);
-                        controller->SetColor( zone_idx, c1, c2);
-                        controller->SetTempo( zone_idx, current_mode.speed);
-                        controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
-                    }
+                    controller->SetPeriod(zone_idx, period);
+                    controller->SetColor( zone_idx, current_mode.colors[zone_idx * 2], current_mode.colors[(zone_idx * 2) + 1]);
+                    controller->SetTempo( zone_idx, current_mode.speed);
+                    controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
                     break;
 
                 case ALIENWARE_MODE_SPECTRUM:
@@ -273,7 +256,6 @@ void RGBController_Alienware::DeviceUpdateMode()
                     break;
 
                 case ALIENWARE_MODE_BREATHING:
-                    period = std::max<uint16_t>(500, (uint16_t)(current_mode.speed * 10));
                     controller->SetPeriod(zone_idx, period);
                     controller->SetColor( zone_idx, colors[current_zone.start_idx], 0x0);
                     controller->SetTempo( zone_idx, current_mode.speed);
@@ -300,9 +282,3 @@ void RGBController_Alienware::DeviceUpdateMode()
         current_mode              = new_current_mode;
     }
 }
-
-void RGBController_Alienware::DeviceSaveMode()
-{
-    controller->SaveController();
-}
-

Controllers/AlienwareController/RGBController_Alienware.h

@@ -28,7 +28,6 @@ public:
     void        DeviceUpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
-    void        DeviceSaveMode();
 
 private:
     AlienwareController*                    controller;

Controllers/ClevoKeyboardController/ClevoKeyboardDevices.cpp

@@ -18,79 +18,71 @@
 |                                                           |
 | Based on KEYBOARD_SIZE_TKL with numpad added and          |
 | navigation cluster adjusted to match Clevo's layout.      |
+|                                                           |
+| Hardware LED indices (value field):                       |
+| - Row 5 (F-keys):     105-124                             |
+| - Row 4 (numbers):    84-102                              |
+| - Row 3 (QWERTY):     63-81                               |
+| - Row 2 (home):       42-59                               |
+| - Row 1 (Z row):      22-39                               |
+| - Row 0 (modifiers):  0-18                                |
 \*---------------------------------------------------------*/
 
 /*---------------------------------------------------------*\
-| LED values, in physical (row, then column) order.         |
-|                                                           |
-| This must match the order KeyboardLayoutManager assigns   |
-| default_values against: the structural keymap sorted by   |
-| (row, col) across main+fn_row+extras combined, NOT the    |
-| fn_row-then-main-then-extras order the zone tables below  |
-| are declared in. Getting this wrong silently misassigns   |
-| almost every key from Print Screen onward, not just a few.|
+| LED values in TKL order (fn_row + main + extras)          |
 |                                                           |
+| Values follow the key order in KeyboardLayoutManager.cpp. |
 | For ANSI-only keys (not present on this ISO keyboard),    |
 | use 0 as a placeholder - they won't be displayed.         |
 | Numpad values are added via edit_keys.                    |
 \*---------------------------------------------------------*/
 static const std::vector<unsigned int> clevo_tkl_values =
 {
-    /*-----------------------------------------------------*\
-    | Row 0: fn_row + Print Screen/Scroll Lock/Pause        |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | Function row (keyboard_zone_fn_row)                       |
+    \*---------------------------------------------------------*/
     105,                                                        // Escape
     106, 107, 108, 109,                                         // F1-F4
     110, 111, 112, 113,                                         // F5-F8
     114, 115, 116, 117,                                         // F9-F12
-    118,                                                        // Print Screen
-    0,                                                          // Scroll Lock (removed via edit_keys)
-    0,                                                          // Pause (removed via edit_keys)
 
-    /*-----------------------------------------------------*\
-    | Row 1: numbers row + Insert/Home/Page Up              |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | Main block - Row 1 (keyboard_zone_main)                   |
+    \*---------------------------------------------------------*/
     84,                                                         // Back tick
     85, 86, 87, 88, 89, 90, 91, 92, 93, 94,                     // 1-0
     95, 96,                                                     // Minus, Equals
     98,                                                         // Backspace
-    119,                                                        // Insert
-    121,                                                        // Home
-    122,                                                        // Page Up
 
-    /*-----------------------------------------------------*\
-    | Row 2: Tab/QWERTY row + Delete/End/PageDown           |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | Main block - Row 2                                        |
+    \*---------------------------------------------------------*/
     63,                                                         // Tab
     65, 66, 67, 68, 69, 70, 71, 72, 73, 74,                     // Q-P
     75, 76,                                                     // [ ]
     0,                                                          // ANSI backslash (not on ISO)
-    120,                                                        // Delete
-    124,                                                        // End
-    123,                                                        // Page Down
 
-    /*-----------------------------------------------------*\
-    | Row 3: Caps Lock/home row/Enter                       |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | Main block - Row 3                                        |
+    \*---------------------------------------------------------*/
     42,                                                         // Caps Lock
     44, 45, 46, 47, 48, 49, 50, 51, 52,                         // A-L
     53, 54,                                                     // ; '
     55,                                                         // ISO # (POUND)
-    56,                                                         // Enter
+    77,                                                         // Enter (ANSI/ISO share same LED)
 
-    /*-----------------------------------------------------*\
-    | Row 4: Left Shift/ISO backslash/Z row + Up            |
-    \*-----------------------------------------------------*/
-    21,                                                         // Left Shift
-    77,                                                         // ISO backslash
+    /*---------------------------------------------------------*\
+    | Main block - Row 4                                        |
+    \*---------------------------------------------------------*/
+    22,                                                         // Left Shift
+    23,                                                         // ISO backslash
     24, 25, 26, 27, 28, 29, 30, 31, 32,                         // Z-. (9 keys)
     33,                                                         // /
     35,                                                         // Right Shift
-    14,                                                         // Up
 
-    /*-----------------------------------------------------*\
-    | Row 5: bottom modifier row + Left/Down/Right          |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | Main block - Row 5                                        |
+    \*---------------------------------------------------------*/
     0,                                                          // Left Ctrl
     3,                                                          // Left Win
     4,                                                          // Left Alt
@@ -99,6 +91,24 @@ static const std::vector<unsigned int> clevo_tkl_values =
     0,                                                          // Right Fn (removed via edit_keys)
     0,                                                          // Menu (removed via edit_keys)
     12,                                                         // Right Ctrl
+
+    /*---------------------------------------------------------*\
+    | Extras - Navigation cluster (keyboard_zone_extras)        |
+    \*---------------------------------------------------------*/
+    118,                                                        // Print Screen
+    0,                                                          // Scroll Lock (removed via edit_keys)
+    0,                                                          // Pause (removed via edit_keys)
+    119,                                                        // Insert
+    121,                                                        // Home
+    123,                                                        // Page Up
+    120,                                                        // Delete
+    122,                                                        // End
+    124,                                                        // Page Down
+
+    /*---------------------------------------------------------*\
+    | Extras - Arrow keys                                       |
+    \*---------------------------------------------------------*/
+    14,                                                         // Up
     13,                                                         // Left
     18,                                                         // Down
     15,                                                         // Right

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -232,7 +232,7 @@ void CorsairLightingNodeController::SendFirmwareRequest()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    actual = WriteAndRead(usb_buf, CORSAIR_LIGHTING_NODE_READ_TIMEOUT);
+    actual = WriteAndRead(usb_buf);
 
     if(actual > 0)
     {

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -81,7 +81,6 @@
 #define CORSAIR_SCIMITAR_PRO_RGB_PID    0x1B3E
 #define CORSAIR_SCIMITAR_ELITE_RGB_PID  0x1B8B
 #define CORSAIR_SABRE_RGB_PID           0x1B2F
-#define CORSAIR_SABRE_RGB_OPTICAL_PID   0x1B32
 
 /*---------------------------------------------------------*\
 | Mousepad product IDs                                      |
@@ -216,7 +215,6 @@ REGISTER_HID_DETECTOR_IP("Corsair Scimitar RGB",            DetectCorsairPeriphe
 REGISTER_HID_DETECTOR_IP("Corsair Scimitar PRO RGB",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_PRO_RGB_PID,   1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Scimitar Elite RGB",      DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_ELITE_RGB_PID, 1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Sabre RGB",               DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SABRE_RGB_PID,          1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Sabre RGB Optical",       DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SABRE_RGB_OPTICAL_PID,  1, 0xFFC2);
 
 /*---------------------------------------------------------*\
 | Mousemats                                                 |

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.cpp

@@ -29,18 +29,6 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
     |   If the PID is in the know wireless receivers list       |
     |   switch the write_cmd to talk to the device and retry    |
     \*---------------------------------------------------------*/
-    /*---------------------------------------------------------*\
-    | Establish the packet size before talking to the device.   |
-    \*---------------------------------------------------------*/
-    uint16_t report_size = GetOutputReportSize();
-
-    if(report_size >= CORSAIR_V2_WRITE_SIZE && report_size <= CORSAIR_V2_PACKET_SIZE)
-    {
-        pkt_sze = report_size;
-    }
-
-    LOG_DEBUG("[%s] Packet length set to %d", device_name.c_str(), pkt_sze);
-
     unsigned int pid    = GetAddressRetry(0x12);
 
     switch(pid)
@@ -76,12 +64,14 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
     |   the device being set up.                                |
     \*---------------------------------------------------------*/
     uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
-    memset(buffer, 0, pkt_sze);
     buffer[1] = write_cmd;
     buffer[2] = CORSAIR_V2_CMD_GET;
     buffer[3] = 0x11;
-    hid_write(dev, buffer, pkt_sze);
-    hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT);
+    hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
+    uint16_t result = hid_read_timeout(dev, buffer, CORSAIR_V2_PACKET_SIZE, CORSAIR_V2_TIMEOUT);
+    result++;
+    pkt_sze = std::max(result, (uint16_t)CORSAIR_V2_WRITE_SIZE);
+    LOG_DEBUG("[%s] Packet length set to %d", device_name.c_str(), pkt_sze);
 
     /*---------------------------------------------------------*\
     | NB: If the device is not found in the device list         |
@@ -118,115 +108,22 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
         return;
     }
 
-}
-
-/*---------------------------------------------------------*\
-| Check lighting control endpoints                          |
-|   If lighting control endpoint 2 is unavailable           |
-|   then use endpoint 1.                                    |
-\*---------------------------------------------------------*/
-uint16_t CorsairPeripheralV2Controller::GetOutputReportSize()
-{
-    unsigned char   descriptor[HID_API_MAX_REPORT_DESCRIPTOR_SIZE];
-    int             length          = hid_get_report_descriptor(dev, descriptor, sizeof(descriptor));
-
-    if(length <= 0)
-    {
-        return 0;
-    }
-
-    unsigned int    report_size     = 0;
-    unsigned int    report_count    = 0;
-    int             index           = 0;
-
-    while(index < length)
-    {
-        unsigned char   item        = descriptor[index];
-        unsigned char   tag         = item & 0xFC;
-        unsigned char   item_size   = item & 0x03;
-
-        /*---------------------------------------------------------*\
-        | A size field of 3 means four data bytes follow.           |
-        \*---------------------------------------------------------*/
-        if(item_size == 3)
-        {
-            item_size = 4;
-        }
-
-        if(index + 1 + item_size > length)
-        {
-            break;
-        }
-
-        unsigned int    value       = 0;
-
-        for(unsigned char byte = 0; byte < item_size; byte++)
-        {
-            value |= (unsigned int)descriptor[index + 1 + byte] << (8 * byte);
-        }
-
-        switch(tag)
-        {
-            case 0x74:                              /* Report Size      */
-                report_size     = value;
-                break;
-
-            case 0x94:                              /* Report Count     */
-                report_count    = value;
-                break;
-
-            case 0x90:                              /* Output           */
-                if(report_size > 0 && report_count > 0)
-                {
-                    return (uint16_t)(((report_size * report_count) / 8) + 1);
-                }
-                break;
-        }
-
-        index += 1 + item_size;
-    }
-
-    return 0;
-}
-
-void CorsairPeripheralV2Controller::DetectLightingEndpoint()
-{
     /*---------------------------------------------------------*\
-    | A device that cannot be read from cannot be probed; those |
-    |   carry the endpoint they need already set.               |
+    | Check lighting control endpoints                          |
+    |   If lighting control endpoint 2 is unavailable           |
+    |   then use endpoint 1.                                    |
     \*---------------------------------------------------------*/
-    if(skip_reads)
-    {
-        return;
-    }
-
-    /*---------------------------------------------------------*\
-    | Lighting control 1 is the plain lighting resource and     |
-    |   takes colour block data.  A device that answers         |
-    |   invalid or unsupported for it wants the alternate       |
-    |   lighting resource, which takes RGB triplets.            |
-    \*---------------------------------------------------------*/
-    light_ctrl              = CORSAIR_V2_LIGHT_CTRL1;
-    unsigned char result    = StartTransaction(0);
-
-    /*---------------------------------------------------------*\
-    | A handle left open by an earlier session answers failed;  |
-    |   close it and open it again.                             |
-    \*---------------------------------------------------------*/
-    if(result == CORSAIR_V2_ERR_FAILED)
+    if(light_ctrl == CORSAIR_V2_LIGHT_CTRL2)
     {
+        result = StartTransaction(0);
+        if(result > 0)
+        {
+            light_ctrl = CORSAIR_V2_LIGHT_CTRL1;
+            StartTransaction(0);
+        }
         StopTransaction(0);
-        result              = StartTransaction(0);
+        LOG_DEBUG("[%s] Lighting Endpoint set to %02X", device_name.c_str(), light_ctrl);
     }
-
-    if(result == CORSAIR_V2_ERR_INVALID || result == CORSAIR_V2_ERR_NOT_SUPPORTED)
-    {
-        light_ctrl          = CORSAIR_V2_LIGHT_CTRL2;
-        StartTransaction(0);
-    }
-
-    StopTransaction(0);
-    LOG_DEBUG("[%s] Lighting Endpoint set to %02X", device_name.c_str(), light_ctrl);
 }
 
 CorsairPeripheralV2Controller::~CorsairPeripheralV2Controller()
@@ -294,9 +191,9 @@ std::string CorsairPeripheralV2Controller::GetSerialString()
 
 void CorsairPeripheralV2Controller::SetRenderMode(corsair_v2_device_mode mode)
 {
-    uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
+    uint8_t buffer[CORSAIR_V2_WRITE_SIZE];
 
-    memset(buffer, 0, pkt_sze);
+    memset(buffer, 0, CORSAIR_V2_WRITE_SIZE);
 
     /*---------------------------------------------------------*\
     | Set Mode                                                  |
@@ -306,19 +203,19 @@ void CorsairPeripheralV2Controller::SetRenderMode(corsair_v2_device_mode mode)
     buffer[3]   = CORSAIR_V2_VALUE_MODE;
     buffer[5]   = mode;
 
-    hid_write(dev, buffer, pkt_sze);
+    hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
 
     if(!skip_reads)
     {
-        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT);
+        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
     }
 }
 
 void CorsairPeripheralV2Controller::LightingControl(uint8_t opt1)
 {
-    uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
+    uint8_t buffer[CORSAIR_V2_WRITE_SIZE];
 
-    memset(buffer, 0, pkt_sze);
+    memset(buffer, 0, CORSAIR_V2_WRITE_SIZE);
 
     /*---------------------------------------------------------*\
     | The Corsair command is the same for each initialisation   |
@@ -330,11 +227,11 @@ void CorsairPeripheralV2Controller::LightingControl(uint8_t opt1)
     buffer[3]   = opt1;
     buffer[5]   = 0x00;
 
-    hid_write(dev, buffer, pkt_sze);
+    hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
 
     if(!skip_reads)
     {
-        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT);
+        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
     }
 }
 
@@ -373,18 +270,18 @@ unsigned int CorsairPeripheralV2Controller::GetAddressRetry(uint8_t address)
 
 unsigned int CorsairPeripheralV2Controller::GetAddress(uint8_t address)
 {
-    uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
-    uint8_t read[CORSAIR_V2_PACKET_SIZE];
+    uint8_t buffer[CORSAIR_V2_WRITE_SIZE];
+    uint8_t read[CORSAIR_V2_WRITE_SIZE];
 
-    memset(buffer, 0, pkt_sze);
-    memset(read, 0, pkt_sze);
+    memset(buffer, 0, CORSAIR_V2_WRITE_SIZE);
+    memset(read, 0, CORSAIR_V2_WRITE_SIZE);
 
     buffer[1]   = write_cmd;
     buffer[2]   = CORSAIR_V2_CMD_GET;
     buffer[3]   = address;
 
-    hid_write(dev, buffer, pkt_sze);
-    hid_read_timeout(dev, read, pkt_sze, CORSAIR_V2_TIMEOUT);
+    hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
+    hid_read_timeout(dev, read, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
 
     unsigned int temp = (unsigned int)(read[6] << 24 | read[5] << 16 | read[4] << 8 | read[3]);
     LOG_DEBUG("[%s] GetAddress %02X - %02X %02X - %02X %02X %02X %02X   %02X %02X %02X %02X", device_name.c_str(),
@@ -402,20 +299,20 @@ unsigned int CorsairPeripheralV2Controller::GetAddress(uint8_t address)
 
 unsigned char CorsairPeripheralV2Controller::StartTransaction(uint8_t opt1)
 {
-    uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
+    uint8_t buffer[CORSAIR_V2_WRITE_SIZE];
 
-    memset(buffer, 0, pkt_sze);
+    memset(buffer, 0, CORSAIR_V2_WRITE_SIZE);
 
     buffer[1]   = write_cmd;
     buffer[2]   = CORSAIR_V2_CMD_START_TX;
     buffer[3]   = opt1;
     buffer[4]   = light_ctrl;
 
-    hid_write(dev, buffer, pkt_sze);
+    hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
 
     if(!skip_reads)
     {
-        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT);
+        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
     }
 
     return buffer[2];
@@ -423,20 +320,20 @@ unsigned char CorsairPeripheralV2Controller::StartTransaction(uint8_t opt1)
 
 void CorsairPeripheralV2Controller::StopTransaction(uint8_t opt1)
 {
-    uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
+    uint8_t buffer[CORSAIR_V2_WRITE_SIZE];
 
-    memset(buffer, 0, pkt_sze);
+    memset(buffer, 0, CORSAIR_V2_WRITE_SIZE);
 
     buffer[1]   = write_cmd;
     buffer[2]   = CORSAIR_V2_CMD_STOP_TX;
     buffer[3]   = 0x01;
     buffer[4]   = opt1;
 
-    hid_write(dev, buffer, pkt_sze);
+    hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
 
     if(!skip_reads)
     {
-        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT);
+        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
     }
 }
 
@@ -450,11 +347,6 @@ void CorsairPeripheralV2Controller::ClearPacketBuffer()
     uint8_t result          = 0;
     uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
 
-    /*---------------------------------------------------------*\
-    | Draining expects to find nothing, so the last read here    |
-    |   always waits out the timeout.  Keep it short: this runs  |
-    |   before every LED update.                                 |
-    \*---------------------------------------------------------*/
     do
     {
         result = hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT_SHORT);
@@ -464,8 +356,6 @@ void CorsairPeripheralV2Controller::ClearPacketBuffer()
 
 void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
 {
-    std::lock_guard<std::mutex> lock(device_mutex);
-
     const uint8_t offset1   = 8;
     const uint8_t offset2   = 4;
     uint16_t remaining      = data_size;
@@ -499,7 +389,7 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
 
     if(!skip_reads)
     {
-        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT);
+        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT_SHORT);
     }
 
     remaining              -= copy_bytes;
@@ -524,7 +414,7 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
 
         if(!skip_reads)
         {
-            hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT);
+            hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT_SHORT);
         }
 
         remaining          -= copy_bytes;
@@ -536,8 +426,6 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
 void CorsairPeripheralV2Controller::UpdateHWMode(uint16_t mode, corsair_v2_color /*color_mode*/, uint8_t /*speed*/,
                                                  uint8_t /*direction*/, uint8_t /*brightness*/, std::vector<RGBColor> /*colors*/)
 {
-    std::lock_guard<std::mutex> lock(device_mutex);
-
     /*---------------------------------------------------------*\
     | If we are switching to `Direct` mode                      |
     |   set device in software mode                             |

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.h

@@ -12,7 +12,6 @@
 #pragma once
 
 #include <string>
-#include <mutex>
 #include <vector>
 #include <hidapi.h>
 #include "LogManager.h"
@@ -22,33 +21,13 @@
 #define NA                              0xFFFFFFFF
 #define HID_MAX_STR                     255
 
-/*---------------------------------------------------------*\
-| A jumbo packet device answers a 1KB command in well over  |
-|   50ms.  Missing the reply leaves it queued and the next  |
-|   write to the device then fails outright, so this has to |
-|   be generous.  A reply that does arrive is returned as   |
-|   soon as it lands, so this only costs time on failure.   |
-\*---------------------------------------------------------*/
-#define CORSAIR_V2_TIMEOUT              500
+#define CORSAIR_V2_TIMEOUT              50
 #define CORSAIR_V2_TIMEOUT_SHORT        3
 #define CORSAIR_V2_VALUE_MODE           3
 #define CORSAIR_V2_WRITE_WIRED_ID       8
 #define CORSAIR_V2_WRITE_WIRELESS_ID    9
 #define CORSAIR_V2_WRITE_SIZE           65
-/*---------------------------------------------------------*\
-| Largest packet the protocol uses: 1024 payload bytes      |
-|   plus the leading report ID.  pkt_sze is measured        |
-|   against this, and every stack buffer handed to hidapi   |
-|   with pkt_sze is this size, so the two must agree.       |
-\*---------------------------------------------------------*/
-#define CORSAIR_V2_PACKET_SIZE          1025
-
-/*---------------------------------------------------------*\
-| Error codes the device returns in byte 2 of a reply.      |
-\*---------------------------------------------------------*/
-#define CORSAIR_V2_ERR_INVALID          0x01
-#define CORSAIR_V2_ERR_FAILED           0x03
-#define CORSAIR_V2_ERR_NOT_SUPPORTED    0x06
+#define CORSAIR_V2_PACKET_SIZE          1024
 
 #define CORSAIR_V2_LIGHT_CTRL1          1
 #define CORSAIR_V2_LIGHT_CTRL2          34          /* 0x22                             */
@@ -134,27 +113,6 @@ protected:
     std::string                     device_name;
     uint8_t                         light_ctrl          = CORSAIR_V2_LIGHT_CTRL2;
 
-    /*---------------------------------------------------------*\
-    | Works out which lighting control endpoint the device       |
-    |   accepts.  Must be called only once the device has been   |
-    |   put into software render mode: endpoint 2 rejects the    |
-    |   transaction while the device is still driving its own    |
-    |   lighting, which would pick endpoint 1 for a device that  |
-    |   does not support it.                                     |
-    \*---------------------------------------------------------*/
-    void                            DetectLightingEndpoint();
-
-    /*---------------------------------------------------------*\
-    | Size of one output report, plus the leading report ID.     |
-    |   Read from the HID report descriptor before anything is   |
-    |   sent: these devices come in a 64 byte and a 1024 byte    |
-    |   flavour, and sending a short packet to a 1024 byte       |
-    |   endpoint wedges it until the device is reset, so the     |
-    |   size has to be known before the first write rather than  |
-    |   inferred from a reply.  Returns 0 if it cannot be read.  |
-    \*---------------------------------------------------------*/
-    uint16_t                        GetOutputReportSize();
-
 private:
     void                            ClearPacketBuffer();
     unsigned int                    GetAddress(uint8_t address);
@@ -164,16 +122,6 @@ private:
 
     hid_device*                     dev;
 
-    /*---------------------------------------------------------*\
-    | Serialises device transactions.                           |
-    |   The RGB controllers run a keepalive thread that writes  |
-    |   LEDs independently of the caller, and a Corsair block   |
-    |   write spans several packets.  Letting two of those      |
-    |   interleave on one HID handle corrupts the transaction   |
-    |   and leaves the device unresponsive until it is reset.   |
-    \*---------------------------------------------------------*/
-    std::mutex                      device_mutex;
-
     uint8_t                         write_cmd           = CORSAIR_V2_WRITE_WIRED_ID;
     uint16_t                        pkt_sze             = CORSAIR_V2_WRITE_SIZE;
     bool                            skip_reads          = false;

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2ControllerDetect.cpp

@@ -92,7 +92,6 @@ DetectedControllers DetectCorsairV2SoftwareControllers(hid_device_info* info, co
 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 SE",                  DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_SE_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);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO TKL White",           DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_TKL_W_PID,          1,  0xFF42);

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.cpp

@@ -901,7 +901,7 @@ static const corsair_v2_device k57_rgb_wired_device =
 |                                                               |
 |  Zone "Keyboard"                                              |
 |       Matrix                                                  |
-|       7 Rows, 22 Columns                                      |
+|       6 Rows, 21 Columns                                      |
 \*-------------------------------------------------------------*/
 static const corsair_v2_zone k60_rgb_pro_zone =
 {
@@ -928,34 +928,12 @@ static const corsair_v2_device k60_rgb_pro_device =
     &corsair_K60_layout
 };
 
-/*-------------------------------------------------------------*\
-|  Corsair K60 RGB Pro SE 1B1C:1B8D                             |
-|                                                               |
-|  Initial implementation reuses K60 RGB Pro zone/layout        |
-\*-------------------------------------------------------------*/
-static const corsair_v2_device k60_rgb_pro_se_device =
-{
-    CORSAIR_K60_RGB_PRO_SE_PID,
-    DEVICE_TYPE_KEYBOARD,
-    6,
-    21,
-    {
-        &k60_rgb_pro_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    },
-    &corsair_K60_layout
-};
-
 /*-------------------------------------------------------------*\
 |  Corsair K60 RGB Pro Low Profile 1B1C:1BAD                    |
 |                                                               |
 |  Zone "Keyboard"                                              |
 |       Matrix                                                  |
-|       7 Rows, 22 Columns                                      |
+|       6 Rows, 21 Columns                                      |
 \*-------------------------------------------------------------*/
 static const corsair_v2_zone k60_rgb_pro_lp_zone =
 {
@@ -988,7 +966,7 @@ static const corsair_v2_device k60_rgb_pro_lp_device =
 |                                                               |
 |  Zone "Keyboard"                                              |
 |       Matrix                                                  |
-|       7 Rows, 22 Columns                                      |
+|       6 Rows, 21 Columns                                      |
 \*-------------------------------------------------------------*/
 static const corsair_v2_zone k60_rgb_pro_tkl_zone =
 {
@@ -1038,7 +1016,7 @@ static const corsair_v2_device k60_rgb_pro_tkl_device_w =
 |                                                               |
 |  Zone "Keyboard"                                              |
 |       Matrix                                                  |
-|       7 Rows, 22 Columns                                      |
+|       6 Rows, 21 Columns                                      |
 \*-------------------------------------------------------------*/
 static const corsair_v2_zone k70_core_rgb_zone =
 {
@@ -1167,14 +1145,14 @@ static const corsair_v2_device k70_rgb_tkl_cs_device =
 |                                                               |
 |  Zone "Keyboard"                                              |
 |       Matrix                                                  |
-|       7 Rows, 22 Columns                                      |
+|       6 Rows, 21 Columns                                      |
 \*-------------------------------------------------------------*/
 static const corsair_v2_zone k70_rgb_pro_zone =
 {
     ZONE_EN_KEYBOARD,
     ZONE_TYPE_MATRIX,
     7,
-    22
+    21
 };
 
 static const corsair_v2_device k70_rgb_pro_device =
@@ -1182,7 +1160,7 @@ static const corsair_v2_device k70_rgb_pro_device =
     CORSAIR_K70_RGB_PRO_PID,
     DEVICE_TYPE_KEYBOARD,
     7,
-    22,
+    21,
     {
         &k70_rgb_pro_zone,
         nullptr,
@@ -1199,14 +1177,14 @@ static const corsair_v2_device k70_rgb_pro_device =
 |                                                               |
 |  Zone "Keyboard"                                              |
 |       Matrix                                                  |
-|       7 Rows, 22 Columns                                      |
+|       6 Rows, 21 Columns                                      |
 \*-------------------------------------------------------------*/
 static const corsair_v2_device k70_rgb_pro_v2_device =
     {
         CORSAIR_K70_RGB_PRO_V2_PID,
         DEVICE_TYPE_KEYBOARD,
         7,
-        22,
+        21,
         {
             &k70_rgb_pro_zone,
             nullptr,
@@ -1215,8 +1193,7 @@ static const corsair_v2_device k70_rgb_pro_v2_device =
             nullptr,
             nullptr
         },
-        &corsair_k70_pro_layout,
-        193
+        &corsair_k70_pro_layout
 };
 
 /*-------------------------------------------------------------*\
@@ -1648,7 +1625,6 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
     &k55_rgb_pro_device,
     &k57_rgb_wired_device,
     &k60_rgb_pro_device,
-    &k60_rgb_pro_se_device,
     &k60_rgb_pro_lp_device,
     &k60_rgb_pro_tkl_device_b,
     &k60_rgb_pro_tkl_device_w,

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.h

@@ -63,15 +63,6 @@ typedef struct
     uint8_t                             cols;
     const corsair_v2_zone*              zones[CORSAIR_ZONES_MAX];
     keyboard_keymap_overlay_values*     layout_new;
-    /*-------------------------------------------------------*\
-    | Number of LED slots the device expects in a direct       |
-    |   lighting write.  The keymap only covers the keys that  |
-    |   exist, but the device wants its full slot count and    |
-    |   ignores a short write, so the buffer map is padded up  |
-    |   to this.  Left 0 where the count is not known, which   |
-    |   keeps the keymap derived size.                         |
-    \*-------------------------------------------------------*/
-    uint16_t                            hw_led_count;
 }   corsair_v2_device;
 
 /*-----------------------------------------------------*\
@@ -81,7 +72,6 @@ typedef struct
 #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_SE_PID                  0x1B8D
 #define CORSAIR_K60_RGB_PRO_LP_PID                  0x1BAD
 #define CORSAIR_K60_RGB_PRO_TKL_B_PID               0x1BC7
 #define CORSAIR_K60_RGB_PRO_TKL_W_PID               0x1BED

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2HardwareController.cpp

@@ -16,12 +16,6 @@ CorsairPeripheralV2HWController::CorsairPeripheralV2HWController(hid_device* dev
 {
     SetRenderMode(CORSAIR_V2_MODE_SW);
     LightingControl(0x5F);
-
-    /*---------------------------------------------------------*\
-    | Only now that the device is in software render mode can   |
-    |   its lighting control endpoint be probed reliably.       |
-    \*---------------------------------------------------------*/
-    DetectLightingEndpoint();
 }
 
 CorsairPeripheralV2HWController::~CorsairPeripheralV2HWController()

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2SoftwareController.cpp

@@ -16,12 +16,6 @@ CorsairPeripheralV2SWController::CorsairPeripheralV2SWController(hid_device* dev
 {
     SetRenderMode(CORSAIR_V2_MODE_SW);
     LightingControl(0x5F);
-
-    /*---------------------------------------------------------*\
-    | Only now that the device is in software render mode can   |
-    |   its lighting control endpoint be probed reliably.       |
-    \*---------------------------------------------------------*/
-    DetectLightingEndpoint();
 }
 
 CorsairPeripheralV2SWController::~CorsairPeripheralV2SWController()

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Hardware.cpp

@@ -66,32 +66,21 @@ RGBController_CorsairV2HW::RGBController_CorsairV2HW(CorsairPeripheralV2Controll
     | to not revert back into rainbow mode.  Start a thread |
     | to continuously send a keepalive packet every 50 sec  |
     \*-----------------------------------------------------*/
-    /*-----------------------------------------------------*\
-    | Start the keepalive clock before the thread runs.     |
-    |   A default constructed time_point sits at the clock  |
-    |   epoch, which is always older than the update        |
-    |   period, so the thread would otherwise fire a write  |
-    |   on its first pass - during detection, racing        |
-    |   whatever the caller is doing.                       |
-    \*-----------------------------------------------------*/
-    last_update_time                    = std::chrono::steady_clock::now();
-
     keepalive_thread_run                = true;
     keepalive_thread                    = new std::thread(&RGBController_CorsairV2HW::KeepaliveThread, this);
 }
 
 RGBController_CorsairV2HW::~RGBController_CorsairV2HW()
 {
+    Shutdown();
+
     /*-----------------------------------------------------*\
-    | Close keepalive thread first, so that it cannot issue |
-    |   a write while the device is being shut down.        |
+    | Close keepalive thread                                |
     \*-----------------------------------------------------*/
     keepalive_thread_run = false;
     keepalive_thread->join();
     delete keepalive_thread;
 
-    Shutdown();
-
     delete controller;
 }
 
@@ -209,15 +198,6 @@ void RGBController_CorsairV2HW::SetupZones()
 
     SetupColors();
 
-    /*---------------------------------------------------------*\
-    | Pad out to the slot count the device expects.  A write    |
-    |   that is short of it is ignored by the hardware.         |
-    \*---------------------------------------------------------*/
-    if(corsair->hw_led_count > max_led_value)
-    {
-        max_led_value                   = corsair->hw_led_count;
-    }
-
     /*---------------------------------------------------------*\
     | Create a buffer map of pointers which contains the        |
     |   layout order of colors the device expects.              |

Controllers/CorsairPeripheralV2Controller/RGBController_CorsairV2Software.cpp

@@ -53,32 +53,21 @@ RGBController_CorsairV2SW::RGBController_CorsairV2SW(CorsairPeripheralV2Controll
     | to not revert back into rainbow mode.  Start a thread |
     | to continuously send a keepalive packet every 50 sec  |
     \*-----------------------------------------------------*/
-    /*-----------------------------------------------------*\
-    | Start the keepalive clock before the thread runs.     |
-    |   A default constructed time_point sits at the clock  |
-    |   epoch, which is always older than the update        |
-    |   period, so the thread would otherwise fire a write  |
-    |   on its first pass - during detection, racing        |
-    |   whatever the caller is doing.                       |
-    \*-----------------------------------------------------*/
-    last_update_time                    = std::chrono::steady_clock::now();
-
     keepalive_thread_run                = true;
     keepalive_thread                    = new std::thread(&RGBController_CorsairV2SW::KeepaliveThread, this);
 }
 
 RGBController_CorsairV2SW::~RGBController_CorsairV2SW()
 {
+    Shutdown();
+
     /*-----------------------------------------------------*\
-    | Close keepalive thread first, so that it cannot issue |
-    |   a write while the device is being shut down.        |
+    | Close keepalive thread                                |
     \*-----------------------------------------------------*/
     keepalive_thread_run = false;
     keepalive_thread->join();
     delete keepalive_thread;
 
-    Shutdown();
-
     delete controller;
 }
 
@@ -196,15 +185,6 @@ void RGBController_CorsairV2SW::SetupZones()
 
     SetupColors();
 
-    /*---------------------------------------------------------*\
-    | Pad out to the slot count the device expects.  A write    |
-    |   that is short of it is ignored by the hardware.         |
-    \*---------------------------------------------------------*/
-    if(corsair->hw_led_count > max_led_value)
-    {
-        max_led_value                   = corsair->hw_led_count;
-    }
-
     /*---------------------------------------------------------*\
     | Create a buffer map of pointers which contains the        |
     |   layout order of colors the device expects.              |

Controllers/GainwardGPUController/GainwardGPUControllerDetect.cpp

@@ -0,0 +1,102 @@
+/*---------------------------------------------------------*\
+| GainwardGPUControllerDetect.cpp                           |
+|                                                           |
+|   Detector for Gainward GPU                               |
+|                                                           |
+|   TheRogueZeta                                05 Nov 2020 |
+|   KundaPanda                                  04 Jan 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "DetectionManager.h"
+#include "GainwardGPUv1Controller.h"
+#include "GainwardGPUv2Controller.h"
+#include "i2c_smbus.h"
+#include "pci_ids.h"
+#include "RGBController_GainwardGPUv1.h"
+#include "RGBController_GainwardGPUv2.h"
+
+bool TestForGainwardGPUController(i2c_smbus_interface* bus, uint8_t i2c_addr)
+{
+    bool pass = false;
+
+    switch(i2c_addr)
+    {
+        /*-------------------------------------------------*\
+        | V1 Controller                                     |
+        \*-------------------------------------------------*/
+        case 0x08:
+            pass = bus->i2c_smbus_write_quick(i2c_addr, I2C_SMBUS_WRITE);
+            break;
+
+        /*-------------------------------------------------*\
+        | V2 Controller                                     |
+        \*-------------------------------------------------*/
+        case 0x49:
+            /*---------------------------------------------*\
+            | This detection might need some modifications  |
+            | Reading 0x6F*0x73 and comparing to 0x64 might |
+            | be a possibility                              |
+            \*---------------------------------------------*/
+            s32 data        = bus->i2c_smbus_read_byte_data(i2c_addr, 0x0);
+            s32 mode_data   = bus->i2c_smbus_read_byte_data(i2c_addr, 0xe0);
+            pass            = (data == 0x0) && (mode_data < 0x5);
+            break;
+    }
+
+    return(pass);
+}
+
+DetectedControllers DetectGainwardGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+
+    if(TestForGainwardGPUController(bus, i2c_addr))
+    {
+        switch(i2c_addr)
+        {
+            /*---------------------------------------------*\
+            | V1 Controller                                 |
+            \*---------------------------------------------*/
+            case 0x08:
+                {
+                    GainwardGPUv1Controller*     controller     = new GainwardGPUv1Controller(bus, i2c_addr, name);
+                    RGBController_GainwardGPUv1* rgb_controller = new RGBController_GainwardGPUv1(controller);
+
+                    detected_controllers.push_back(rgb_controller);
+                }
+                break;
+
+            /*---------------------------------------------*\
+            | V2 Controller                                 |
+            \*---------------------------------------------*/
+            case 0x49:
+                {
+                    GainwardGPUv2Controller*     controller     = new GainwardGPUv2Controller(bus, i2c_addr, name);
+                    RGBController_GainwardGPUv2* rgb_controller = new RGBController_GainwardGPUv2(controller);
+
+                    detected_controllers.push_back(rgb_controller);
+                }
+                break;
+        }
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_I2C_PCI_DETECTOR("Gainward GeForce GTX 1080 Phoenix",          DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_GTX1080_DEV,     GAINWARD_SUB_VEN,   GAINWARD_GTX_1080_PHOENIX,      0x08);
+REGISTER_I2C_PCI_DETECTOR("Gainward GeForce GTX 1080 Ti Phoenix",       DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_GTX1080TI_DEV,   GAINWARD_SUB_VEN,   GAINWARD_GTX_1080TI_PHOENIX,    0x08);
+REGISTER_I2C_PCI_DETECTOR("Gainward GeForce GTX 1660 SUPER Ghost",      DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_GTX1660S_DEV,    NVIDIA_SUB_VEN,     NVIDIA_GTX1660S_DEV,            0x49);
+REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 2070 SUPER Phantom",    DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, GAINWARD_SUB_VEN,   NVIDIA_RTX2070S_OC_DEV,         0x49);
+REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 2080 Phoenix GS",       DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX2080_DEV,     GAINWARD_SUB_VEN,   NVIDIA_RTX2080_A_DEV,           0x49);
+REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3060 Pegasus 12G",      DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_DEV,     NVIDIA_SUB_VEN,     NVIDIA_RTX3060_DEV,             0x49);
+REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3070 Phantom",          DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,     GAINWARD_SUB_VEN,   GAINWARD_RTX_3070_PHANTOM,      0x49);
+REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3070 Phoenix",          DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,     GAINWARD_SUB_VEN,   NVIDIA_RTX3070_DEV,             0x49);
+REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3070 Ti Phoenix",       DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,   GAINWARD_SUB_VEN,   NVIDIA_RTX3070TI_DEV,           0x49);
+REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3080 Phoenix",          DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,     GAINWARD_SUB_VEN,   NVIDIA_RTX3080_DEV,             0x49);
+REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3080 Ti Phoenix",       DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,   GAINWARD_SUB_VEN,   NVIDIA_RTX3080TI_DEV,           0x49);
+REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3090 Phoenix",          DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3090_DEV,     GAINWARD_SUB_VEN,   NVIDIA_RTX3090_DEV,             0x49);
+REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3090 Ti Phantom",       DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3090TI_DEV,   GAINWARD_SUB_VEN,   GAINWARD_RTX_3090TI_PHANTOM,    0x49);
+REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 4080 Phantom GS",       DetectGainwardGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,     GAINWARD_SUB_VEN,   GAINWARD_RTX_4080_PHANTOM_GS_SUB_DEV,   0x49);

Controllers/GainwardGPUController/GainwardGPUv1Controller/GainwardGPUv1Controller.cpp

@@ -0,0 +1,78 @@
+/*---------------------------------------------------------*\
+| GainwardGPUv1Controller.cpp                               |
+|                                                           |
+|   Driver for Gainward v1 GPU                              |
+|                                                           |
+|   TheRogueZeta                                05 Nov 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <cstring>
+#include "GainwardGPUv1Controller.h"
+
+GainwardGPUv1Controller::GainwardGPUv1Controller(i2c_smbus_interface* bus, gainward_gpu_dev_id dev, std::string dev_name)
+{
+    this->bus   = bus;
+    this->dev   = dev;
+    this->name  = dev_name;
+}
+
+GainwardGPUv1Controller::~GainwardGPUv1Controller()
+{
+
+}
+
+std::string GainwardGPUv1Controller::GetDeviceLocation()
+{
+    std::string return_string(bus->info.device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+std::string GainwardGPUv1Controller::GetDeviceName()
+{
+    return(name);
+}
+
+unsigned char GainwardGPUv1Controller::GetLEDRed()
+{
+    return(GainwardGPURegisterRead(GAINWARD_RED_REGISTER));
+}
+
+unsigned char GainwardGPUv1Controller::GetLEDGreen()
+{
+    return(GainwardGPURegisterRead(GAINWARD_GREEN_REGISTER));
+}
+
+unsigned char GainwardGPUv1Controller::GetLEDBlue()
+{
+    return(GainwardGPURegisterRead(GAINWARD_BLUE_REGISTER));
+}
+
+void GainwardGPUv1Controller::SetLEDColors(unsigned char red, unsigned char green, unsigned char blue)
+{
+    GainwardGPURegisterWrite(GAINWARD_RED_REGISTER, red);
+    GainwardGPURegisterWrite(GAINWARD_GREEN_REGISTER, green);
+    GainwardGPURegisterWrite(GAINWARD_BLUE_REGISTER, blue);
+    GainwardGPURegisterWrite(GAINWARD_06_REGISTER, 0xFF);
+}
+
+void GainwardGPUv1Controller::SetMode()
+{
+
+}
+
+unsigned char GainwardGPUv1Controller::GainwardGPURegisterRead(unsigned char reg)
+{
+    return(bus->i2c_smbus_read_byte_data(dev, reg));
+}
+
+void GainwardGPUv1Controller::GainwardGPURegisterWrite(unsigned char reg, unsigned char val)
+{
+    bus->i2c_smbus_write_byte_data(dev, reg, val);
+}

Controllers/GainwardGPUController/GainwardGPUv1Controller/GainwardGPUv1Controller.h

@@ -1,10 +1,9 @@
 /*---------------------------------------------------------*\
-| PalitGPUv1Controller.h                                    |
+| GainwardGPUv1Controller.h                                 |
 |                                                           |
-|   Driver for Palit v1 GPU                                 |
+|   Driver for Gainward v1 GPU                              |
 |                                                           |
 |   TheRogueZeta                                05 Nov 2020 |
-|   Manatsawin Hanmongkolchai                   11 Apr 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -15,19 +14,22 @@
 #include <string>
 #include "i2c_smbus.h"
 
-typedef unsigned char palit_gpu_dev_id;
+typedef unsigned char gainward_gpu_dev_id;
 
 enum
 {
     /* RGB Registers */
-    PALIT_V1_RED_REGISTER                       = 0x03, /* Red Register */
+    GAINWARD_RED_REGISTER                       = 0x03, /* Red Register */
+    GAINWARD_GREEN_REGISTER                     = 0x04, /* Green Register */
+    GAINWARD_BLUE_REGISTER                      = 0x05, /* Blue Register */
+    GAINWARD_06_REGISTER                        = 0x06, /* Unknown (Brightness/Mode?) Register */
 };
 
-class PalitGPUv1Controller
+class GainwardGPUv1Controller
 {
 public:
-    PalitGPUv1Controller(i2c_smbus_interface* bus, palit_gpu_dev_id, std::string dev_name);
-    ~PalitGPUv1Controller();
+    GainwardGPUv1Controller(i2c_smbus_interface* bus, gainward_gpu_dev_id, std::string dev_name);
+    ~GainwardGPUv1Controller();
 
     std::string   GetDeviceLocation();
     std::string   GetDeviceName();
@@ -36,9 +38,13 @@ public:
     unsigned char GetLEDGreen();
     unsigned char GetLEDBlue();
     void          SetLEDColors(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetMode();
+
+    unsigned char GainwardGPURegisterRead(unsigned char reg);
+    void          GainwardGPURegisterWrite(unsigned char reg, unsigned char val);
 
 private:
     i2c_smbus_interface *   bus;
-    palit_gpu_dev_id        dev;
+    gainward_gpu_dev_id     dev;
     std::string             name;
 };

Controllers/GainwardGPUController/GainwardGPUv1Controller/RGBController_GainwardGPUv1.cpp

@@ -0,0 +1,115 @@
+/*---------------------------------------------------------*\
+| RGBController_GainwardGPUv1.cpp                           |
+|                                                           |
+|   RGBController for Gainward v1 GPU                       |
+|                                                           |
+|   TheRogueZeta                                05 Nov 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_GainwardGPUv1.h"
+
+int RGBController_GainwardGPUv1::GetDeviceMode()
+{
+    active_mode = 1;
+    return(active_mode);
+}
+
+/**------------------------------------------------------------------*\
+    @name Gainward GPU v1
+    @category GPU
+    @type I2C
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectGainwardGPUControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_GainwardGPUv1::RGBController_GainwardGPUv1(GainwardGPUv1Controller* controller_ptr)
+{
+    controller              = controller_ptr;
+
+    name                    = controller->GetDeviceName();
+    vendor                  = "Gainward";
+    type                    = DEVICE_TYPE_GPU;
+    description             = "Gainward GPU V1 Device";
+    location                = controller->GetDeviceLocation();
+
+    mode Direct;
+    Direct.name             = "Direct";
+    Direct.value            = 1;
+    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_GainwardGPUv1::~RGBController_GainwardGPUv1()
+{
+    Shutdown();
+
+    delete controller;
+}
+
+void RGBController_GainwardGPUv1::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Set up zone                                               |
+    \*---------------------------------------------------------*/
+    zone gainward_gpu_zone;
+    gainward_gpu_zone.name              = "GPU";
+    gainward_gpu_zone.type              = ZONE_TYPE_SINGLE;
+    gainward_gpu_zone.leds_min          = 1;
+    gainward_gpu_zone.leds_max          = 1;
+    gainward_gpu_zone.leds_count        = 1;
+    zones.push_back(gainward_gpu_zone);
+
+    /*---------------------------------------------------------*\
+    | Set up LED                                                |
+    \*---------------------------------------------------------*/
+    led gainward_gpu_led;
+    gainward_gpu_led.name               = "GPU";
+    leds.push_back(gainward_gpu_led);
+
+    SetupColors();
+
+    /*---------------------------------------------------------*\
+    | Initialize color                                          |
+    \*---------------------------------------------------------*/
+    unsigned char red = controller->GetLEDRed();
+    unsigned char grn = controller->GetLEDGreen();
+    unsigned char blu = controller->GetLEDBlue();
+
+    colors[0] =  ToRGBColor(red, grn, blu);
+}
+
+void RGBController_GainwardGPUv1::DeviceUpdateLEDs()
+{
+    for(std::size_t led = 0; led < colors.size(); led++)
+    {
+        unsigned char red = RGBGetRValue(colors[led]);
+        unsigned char grn = RGBGetGValue(colors[led]);
+        unsigned char blu = RGBGetBValue(colors[led]);
+
+        controller->SetLEDColors(red, grn, blu);
+    }
+}
+
+void RGBController_GainwardGPUv1::DeviceUpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_GainwardGPUv1::DeviceUpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_GainwardGPUv1::DeviceUpdateMode()
+{
+
+}

Controllers/GainwardGPUController/GainwardGPUv1Controller/RGBController_GainwardGPUv1.h

@@ -1,36 +1,35 @@
-/*---------------------------------------------------------*\
-| RGBController_PalitGPUv1.h                                |
-|                                                           |
-|   RGBController for Palit v1 GPU                          |
-|                                                           |
-|   TheRogueZeta                                05 Nov 2020 |
-|   Manatsawin Hanmongkolchai                   11 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "PalitGPUv1Controller.h"
-
-class RGBController_PalitGPUv1 : public RGBController
-{
-public:
-    RGBController_PalitGPUv1(PalitGPUv1Controller* controller_ptr);
-    ~RGBController_PalitGPUv1();
-
-    void        SetupZones();
-
-    void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    PalitGPUv1Controller* controller;
-
-    int        GetDeviceMode();
-};
+/*---------------------------------------------------------*\
+| RGBController_GainwardGPUv1.h                             |
+|                                                           |
+|   RGBController for Gainward v1 GPU                       |
+|                                                           |
+|   TheRogueZeta                                05 Nov 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "GainwardGPUv1Controller.h"
+
+class RGBController_GainwardGPUv1 : public RGBController
+{
+public:
+    RGBController_GainwardGPUv1(GainwardGPUv1Controller* controller_ptr);
+    ~RGBController_GainwardGPUv1();
+
+    void        SetupZones();
+
+    void        DeviceUpdateLEDs();
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    GainwardGPUv1Controller* controller;
+
+    int        GetDeviceMode();
+};

Controllers/GainwardGPUController/GainwardGPUv2Controller/GainwardGPUv2Controller.cpp

@@ -0,0 +1,97 @@
+/*---------------------------------------------------------*\
+| GainwardGPUv2Controller.cpp                               |
+|                                                           |
+|   Driver for Gainward v2 GPU                              |
+|                                                           |
+|   KundaPanda                                  04 Jan 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <cstring>
+#include "GainwardGPUv2Controller.h"
+
+GainwardGPUv2Controller::GainwardGPUv2Controller(i2c_smbus_interface* bus, gainward_gpu_dev_id dev, std::string dev_name)
+{
+    this->bus   = bus;
+    this->dev   = dev;
+    this->name  = dev_name;
+}
+
+GainwardGPUv2Controller::~GainwardGPUv2Controller() = default;
+
+std::string GainwardGPUv2Controller::GetDeviceLocation()
+{
+    std::string return_string(bus->info.device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+std::string GainwardGPUv2Controller::GetDeviceName()
+{
+    return(name);
+}
+
+unsigned char GainwardGPUv2Controller::GetLEDRed()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, GAINWARD_V2_RED_REGISTER));
+}
+
+unsigned char GainwardGPUv2Controller::GetLEDGreen()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, GAINWARD_V2_GREEN_REGISTER));
+}
+
+unsigned char GainwardGPUv2Controller::GetLEDBlue()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, GAINWARD_V2_BLUE_REGISTER));
+}
+
+void GainwardGPUv2Controller::SetLEDColors(unsigned char red, unsigned char green, unsigned char blue, unsigned char color_register)
+{
+    switch (color_register)
+    {
+        default:
+            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_RED_REGISTER, red);
+            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_GREEN_REGISTER, green);
+            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BLUE_REGISTER, blue);
+            break;
+        case GAINWARD_V2_COLOR_REGISTER_SECONDARY:
+            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_RED_SECONDARY_REGISTER, red);
+            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_GREEN_SECONDARY_REGISTER, green);
+            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BLUE_SECONDARY_REGISTER, blue);
+            break;
+        case GAINWARD_V2_COLOR_REGISTER_TERTIARY:
+            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_RED_TERTIARY_REGISTER, red);
+            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_GREEN_TERTIARY_REGISTER, green);
+            bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BLUE_TERTIARY_REGISTER, blue);
+            break;
+    }
+}
+
+void GainwardGPUv2Controller::SetMode(unsigned char mode, unsigned char speed, unsigned char static_mode)
+{
+    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_MODE_REGISTER, mode);
+    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_STATIC_CONTROL_REGISTER, static_mode);
+    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_SPEED_REGISTER, speed);
+}
+
+void GainwardGPUv2Controller::SetDirection(unsigned char direction)
+{
+    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_MODE_DIRECTION_REGISTER, direction);
+}
+
+void GainwardGPUv2Controller::SetBreathingSpeed(unsigned int speed)
+{
+    unsigned char lower = speed & 0xFF;
+    unsigned char upper = (speed >> 2 * 4) & 0xFF;
+
+    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BREATHE_SPEED_REGISTER_A, lower);
+    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BREATHE_SPEED_SECONDARY_REGISTER_A, lower);
+    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BREATHE_SPEED_REGISTER_B, upper);
+    bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BREATHE_SPEED_SECONDARY_REGISTER_B, upper);
+}

Controllers/GainwardGPUController/GainwardGPUv2Controller/GainwardGPUv2Controller.h

@@ -0,0 +1,101 @@
+/*---------------------------------------------------------*\
+| GainwardGPUv2Controller.h                                 |
+|                                                           |
+|   Driver for Gainward v2 GPU                              |
+|                                                           |
+|   KundaPanda                                  04 Jan 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include "i2c_smbus.h"
+
+typedef unsigned char gainward_gpu_dev_id;
+
+/*---------------------------------------------------------------------------------*\
+ | Newer Gainward models seem to use addresses very similar to those used by EVGA   |
+ \*-------------------------------------------------------------------------------**/
+
+enum
+{
+    /* RGB Registers */
+    GAINWARD_V2_RED_REGISTER                        = 0x6C, /* Red Register */
+    GAINWARD_V2_GREEN_REGISTER                      = 0x6D, /* Green Register */
+    GAINWARD_V2_BLUE_REGISTER                       = 0x6E, /* Blue Register */
+    GAINWARD_V2_RED_SECONDARY_REGISTER              = 0x70, /* Red Register 2 */
+    GAINWARD_V2_GREEN_SECONDARY_REGISTER            = 0x71, /* Green Register 2 */
+    GAINWARD_V2_BLUE_SECONDARY_REGISTER             = 0x72, /* Blue Register 2 */
+    GAINWARD_V2_RED_TERTIARY_REGISTER               = 0xE4, /* Red Register 3 */
+    GAINWARD_V2_GREEN_TERTIARY_REGISTER             = 0xE5, /* Green Register 3 */
+    GAINWARD_V2_BLUE_TERTIARY_REGISTER              = 0xE6, /* Blue Register 3 */
+    GAINWARD_V2_MODE_REGISTER                       = 0xE0, /* Mode Register */
+    /* Direct mode switch register
+     * 0x1 Software control
+     * 0x22 Breathing */
+    GAINWARD_V2_STATIC_CONTROL_REGISTER             = 0x60,
+    GAINWARD_V2_BREATHE_SPEED_REGISTER_A            = 0x62, /* Lower part of speed control for breathe effect */
+    GAINWARD_V2_BREATHE_SPEED_REGISTER_B            = 0x63, /* Upper part of speed control for breathe effect */
+    GAINWARD_V2_BREATHE_SPEED_SECONDARY_REGISTER_A  = 0x64, /* Lower part of speed control for breathe effect - prob. secondary color */
+    GAINWARD_V2_BREATHE_SPEED_SECONDARY_REGISTER_B  = 0x65, /* Upper part of speed control for breathe effect - prob. secondary color */
+    /* Mode direction Register
+     * 0x0
+     * 0x1 */
+    GAINWARD_V2_MODE_DIRECTION_REGISTER             = 0xE1,
+    /* Mode speed Register
+     * 0x0 MAX
+     * 0xF MIN */
+    GAINWARD_V2_SPEED_REGISTER                      = 0xE2,
+};
+
+enum
+{
+    /* Manual color selection using primary registers */
+    GAINWARD_V2_MODE_STATIC                         = 0x00,
+    /* Rainbow cycling with direction and speed controls */
+    GAINWARD_V2_MODE_CYCLE                          = 0x01,
+    /* One strobing color running around the fan
+     * Color using primary registers, direction and speed control */
+    GAINWARD_V2_MODE_STROBE                         = 0x02,
+};
+
+enum
+{
+    GAINWARD_V2_COLOR_REGISTER_PRIMARY,
+    GAINWARD_V2_COLOR_REGISTER_SECONDARY,
+    GAINWARD_V2_COLOR_REGISTER_TERTIARY,
+};
+
+enum
+{
+    /* Software controlled direct mode */
+    GAINWARD_V2_STATIC_SOFTWARE                     = 0x01,
+    /* GPU controlled direct mode with breathing effect */
+    GAINWARD_V2_STATIC_BREATHING                    = 0x22,
+};
+
+class GainwardGPUv2Controller
+{
+public:
+    GainwardGPUv2Controller(i2c_smbus_interface* bus, gainward_gpu_dev_id, std::string dev_name);
+    ~GainwardGPUv2Controller();
+
+    std::string   GetDeviceLocation();
+    std::string   GetDeviceName();
+
+    unsigned char GetLEDRed();
+    unsigned char GetLEDGreen();
+    unsigned char GetLEDBlue();
+    void          SetLEDColors(unsigned char red, unsigned char green, unsigned char blue, unsigned char color_register = GAINWARD_V2_COLOR_REGISTER_PRIMARY);
+    void          SetMode(unsigned char mode, unsigned char speed, unsigned char direct_mode = GAINWARD_V2_STATIC_SOFTWARE);
+    void          SetBreathingSpeed(unsigned int speed);
+    void          SetDirection(unsigned char direction);
+
+private:
+    i2c_smbus_interface *   bus;
+    gainward_gpu_dev_id     dev;
+    std::string             name;
+};

Controllers/GainwardGPUController/GainwardGPUv2Controller/RGBController_GainwardGPUv2.cpp

@@ -0,0 +1,187 @@
+/*---------------------------------------------------------*\
+| RGBController_GainwardGPUv2.cpp                           |
+|                                                           |
+|   RGBController for Gainward v2 GPU                       |
+|                                                           |
+|   KundaPanda                                  04 Jan 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_GainwardGPUv2.h"
+
+/**------------------------------------------------------------------*\
+    @name Gainward GPU v2
+    @category GPU
+    @type I2C
+    @save :x:
+    @direct :x:
+    @effects :white_check_mark:
+    @detectors DetectGainwardGPUControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_GainwardGPUv2::RGBController_GainwardGPUv2(GainwardGPUv2Controller* controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    name                        = controller->GetDeviceName();
+    vendor                      = "Gainward";
+    type                        = DEVICE_TYPE_GPU;
+    description                 = "Gainward GPU V2 Device";
+    location                    = controller->GetDeviceLocation();
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = GAINWARD_V2_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Static);
+
+    mode Breathe;
+    Breathe.name                = "Breathing";
+    Breathe.value               = GAINWARD_V2_MODE_STATIC;
+    Breathe.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathe.speed_max           = 0x000a;
+    Breathe.speed_min           = 0x1324;
+    Breathe.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+    Breathe.colors_min          = 2;
+    Breathe.colors_max          = 2;
+    Breathe.colors.resize(2);
+    modes.push_back(Breathe);
+
+    mode RainbowWave;
+    RainbowWave.name            = "Rainbow Wave";
+    RainbowWave.value           = GAINWARD_V2_MODE_CYCLE;
+    RainbowWave.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    RainbowWave.speed_max       = 0x0;
+    RainbowWave.speed_min       = 0xF;
+    RainbowWave.color_mode      = MODE_COLORS_NONE;
+    modes.push_back(RainbowWave);
+
+    mode Strobe;
+    Strobe.name                 = "Strobe";
+    Strobe.value                = GAINWARD_V2_MODE_STROBE;
+    Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Strobe.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Strobe.colors_min           = 1;
+    Strobe.colors_max           = 1;
+    Strobe.colors.resize(1);
+    Strobe.speed_max            = 0x0;
+    Strobe.speed_min            = 0xF;
+    modes.push_back(Strobe);
+
+    SetupZones();
+
+    /*-------------------------*\
+    | Initialize active mode    |
+    \*-------------------------*/
+    active_mode = 0;
+}
+
+RGBController_GainwardGPUv2::~RGBController_GainwardGPUv2()
+{
+    Shutdown();
+
+    delete controller;
+}
+
+void RGBController_GainwardGPUv2::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Set up zone                                               |
+    \*---------------------------------------------------------*/
+    zone gainward_gpu_zone;
+    gainward_gpu_zone.name              = "GPU";
+    gainward_gpu_zone.type              = ZONE_TYPE_SINGLE;
+    gainward_gpu_zone.leds_min          = 1;
+    gainward_gpu_zone.leds_max          = 1;
+    gainward_gpu_zone.leds_count        = 1;
+    zones.push_back(gainward_gpu_zone);
+
+    /*---------------------------------------------------------*\
+    | Set up LED                                                |
+    \*---------------------------------------------------------*/
+    led gainward_gpu_led;
+    gainward_gpu_led.name               = "GPU";
+    leds.push_back(gainward_gpu_led);
+
+    SetupColors();
+
+    /*---------------------------------------------------------*\
+    | Initialize color                                          |
+    \*---------------------------------------------------------*/
+    unsigned char red = controller->GetLEDRed();
+    unsigned char grn = controller->GetLEDGreen();
+    unsigned char blu = controller->GetLEDBlue();
+
+    colors[0] =  ToRGBColor(red, grn, blu);
+}
+
+void RGBController_GainwardGPUv2::DeviceUpdateLEDs()
+{
+    for(unsigned int color : colors)
+    {
+        unsigned char red = RGBGetRValue(color);
+        unsigned char grn = RGBGetGValue(color);
+        unsigned char blu = RGBGetBValue(color);
+
+        controller->SetLEDColors(red, grn, blu);
+        controller->SetMode(GAINWARD_V2_MODE_STATIC, 0x2);
+    }
+}
+
+void RGBController_GainwardGPUv2::DeviceUpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_GainwardGPUv2::DeviceUpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_GainwardGPUv2::DeviceUpdateMode()
+{
+    mode current_mode = modes[(unsigned int)active_mode];
+    switch (active_mode)
+    {
+        case 1:
+            {
+                controller->SetBreathingSpeed(current_mode.speed);
+
+                unsigned char r1 = RGBGetRValue(current_mode.colors[0]);
+                unsigned char g1 = RGBGetGValue(current_mode.colors[0]);
+                unsigned char b1 = RGBGetBValue(current_mode.colors[0]);
+                controller->SetLEDColors(r1, g1, b1);
+
+                unsigned char r2 = RGBGetRValue(current_mode.colors[1]);
+                unsigned char g2 = RGBGetGValue(current_mode.colors[1]);
+                unsigned char b2 = RGBGetBValue(current_mode.colors[1]);
+                controller->SetLEDColors(r2, g2, b2, GAINWARD_V2_COLOR_REGISTER_SECONDARY);
+                controller->SetMode(GAINWARD_V2_MODE_STATIC, 0x2, GAINWARD_V2_STATIC_BREATHING);
+            }
+            break;
+
+        /*---------------------------------------------*\
+        | Case 3 intentionally falls through to case 2  |
+        \*---------------------------------------------*/
+        case 3:
+            {
+                unsigned char r = RGBGetRValue(current_mode.colors[0]);
+                unsigned char g = RGBGetGValue(current_mode.colors[0]);
+                unsigned char b = RGBGetBValue(current_mode.colors[0]);
+                controller->SetLEDColors(r, g, b, GAINWARD_V2_COLOR_REGISTER_TERTIARY);
+            }
+
+        case 2:
+            controller->SetMode((unsigned char)(current_mode.value), (unsigned char)(current_mode.speed));
+            controller->SetDirection(current_mode.direction);
+            break;
+
+        default:
+            controller->SetMode((unsigned char)(current_mode.value), (unsigned char)(current_mode.speed));
+            break;
+    }
+}

Controllers/GainwardGPUController/GainwardGPUv2Controller/RGBController_GainwardGPUv2.h

@@ -1,34 +1,33 @@
-/*---------------------------------------------------------*\
-| RGBController_PalitGPUv2.h                                |
-|                                                           |
-|   RGBController for Palit v2 GPU                          |
-|                                                           |
-|   KundaPanda                                  04 Jan 2021 |
-|   KendallMorgan                               17 Oct 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "PalitGPUv2Controller.h"
-
-class RGBController_PalitGPUv2 : public RGBController
-{
-public:
-    RGBController_PalitGPUv2(PalitGPUv2Controller* controller_ptr);
-    ~RGBController_PalitGPUv2();
-
-    void        SetupZones();
-
-    void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    PalitGPUv2Controller* controller;
-};
+/*---------------------------------------------------------*\
+| RGBController_GainwardGPUv2.h                             |
+|                                                           |
+|   RGBController for Gainward v2 GPU                       |
+|                                                           |
+|   KundaPanda                                  04 Jan 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "GainwardGPUv2Controller.h"
+
+class RGBController_GainwardGPUv2 : public RGBController
+{
+public:
+    RGBController_GainwardGPUv2(GainwardGPUv2Controller* controller_ptr);
+    ~RGBController_GainwardGPUv2();
+
+    void        SetupZones();
+
+    void        DeviceUpdateLEDs();
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    GainwardGPUv2Controller* controller;
+};

Controllers/GigabyteRGBFusion2BlackwellGPUController/GigabyteRGBFusion2BlackwellGPUControllerDetect.cpp

@@ -130,8 +130,8 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5080 XTREME WATERFORCE",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5080 XTREME WATERFORCE",            DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers,                NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5080_XTREME_WATERFORCE_16G_SUB_DEV,           0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5080 MASTER ICE",             DetectGigabyteRGBFusion2BlackwellAorusMaster5080LayoutGPUControllers,           NVIDIA_VEN,     NVIDIA_RTX5080_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5080_MASTER_ICE_16G_SUB_DEV,            0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 Gaming OC",                    DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_GAMING_OC_32G_SUB_DEV,                   0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 XTREME WATERFORCE",            DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV,           0x75);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 XTREME WATERFORCE WB",         DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers,                NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_XTREME_WATERFORCE_WB_32G_SUB_DEV,        0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 XTREME WATERFORCE",            DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers,                NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV1,          0x75);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 5090 XTREME WATERFORCE",            DetectGigabyteRGBFusion2BlackwellWaterforceLayoutGPUControllers,                NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV2,          0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 MASTER",                 DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5090_MASTER_32G_SUB_DEV,                0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 MASTER ICE",             DetectGigabyteRGBFusion2BlackwellGamingLayoutGPUControllers,                    NVIDIA_VEN,     NVIDIA_RTX5090_DEV,         GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5090_MASTER_ICE_32G_SUB_DEV,            0x75);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS GeForce RTX 5090 D V2 MASTER ICE",        DetectGigabyteRGBFusion2BlackwellAorusMaster5090DV2IceLayoutGPUControllers,     NVIDIA_VEN,     NVIDIA_RTX5090D_V2_DEV,     GIGABYTE_SUB_VEN, GIGABYTE_AORUS_RTX5090D_V2_MASTER_ICE_24G_SUB_DEV,        0x75);

Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp

@@ -144,8 +144,7 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 GAMING OC",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte Geforce RTX 4070 Aero OC",                         DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070_AERO_OC_12G_SUB_DEV,           0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 SUPER GAMING OC",                 DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_GAMING_OC_12G,                0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 SUPER Aero OC",                   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_AERO_OC_12G,                  0x71);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 SUPER Eagle OC",                  DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_EAGLE_OC_12G,                 0x71);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 SUPER Eagle OC ICE",              DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_EAGLE_OC_ICE_12G,             0x71);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 SUPER Eagle OC",                  DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_EAGLE_OC_ICE_12G,             0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 Ti GAMING",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070TI_GAMING_12G,                  0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 Ti GAMING OC",                    DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070TI_GAMING_OC_12G,               0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GeForce RTX 4070 Ti GAMING OC",                    DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070TI_GAMING_OC_12G_SUB_DEV2,      0x71);

Controllers/GigabyteRGBFusion2USBController/GigabyteRGBFusion2USBController.cpp

@@ -584,11 +584,6 @@ uint8_t RGBFusion2USBController::GetFWID()
     return(fw_id);
 }
 
-uint8_t RGBFusion2USBController::GetFWRevision()
-{
-    return((report.fw_ver >> 16) & 0xFF);
-}
-
 std::string RGBFusion2USBController::GetFWVersion()
 {
     return(version);

Controllers/GigabyteRGBFusion2USBController/GigabyteRGBFusion2USBController.h

@@ -367,7 +367,6 @@ public:
     std::string             GetDeviceLocation();
     std::string             GetFWVersion();
     uint8_t                 GetFWID();
-    uint8_t                 GetFWRevision();
     uint16_t                GetProductID();
     std::string             GetSerial();
     std::vector<Gen2StripInfo> ExportGen2Strips() const;

Controllers/GigabyteRGBFusion2USBController/RGBController_GigabyteRGBFusion2USB.cpp

@@ -25,7 +25,7 @@ struct IT5711ZoneCounts
 /*---------------------------------------------------------*\
 | Sets LED10/11 counts based on firmware series             |
 \*---------------------------------------------------------*/
-static IT5711ZoneCounts GetIT5711ZoneCounts(uint8_t fw_id, uint8_t fw_revision, uint32_t lid)
+static IT5711ZoneCounts GetIT5711ZoneCounts(uint8_t fw_id, uint32_t lid)
 {
     switch(fw_id)
     {
@@ -50,63 +50,31 @@ static IT5711ZoneCounts GetIT5711ZoneCounts(uint8_t fw_id, uint8_t fw_revision,
             return {13, 0};
 
         case 0x05:
+        case 0x0C:
             switch(lid)
             {
-                case 0x017001DF:
-                    return {16, 4};
+                case 0x016001DF:
+                    return {8, 4};
 
                 case 0x028001DF:
                     return {26, 18};
 
                 default:
-                    return {8, 4};
+                    return {16, 4};
             }
 
         case 0x06:
         case 0x09:
             return {12, 0};
 
-        case 0x0C:
-            switch(fw_revision)
-            {
-                case 0x06:
-                    switch(lid)
-                    {
-                        case 0x017001DF:
-                            return {16, 4};
-
-                        case 0x028001DF:
-                            return {26, 18};
-
-                        default:
-                            return {8, 4};
-                    }
-
-                case 0x08:
-                    switch(lid)
-                    {
-                        case 0x017001DF:
-                            return {16, 4};
-
-                        case 0x028001DF:
-                            return {26, 18};
-
-                        default:
-                            return {10, 4};
-                    }
-
-                default:
-                    return {};
-            }
-
         default:
             return {};
     }
 }
 
-static void ApplyIT5711ZoneCounts(gb_fusion2_device* layout, uint8_t fw_id, uint8_t fw_revision, std::vector<gb_fusion2_zone*>& allocated_zones)
+static void ApplyIT5711ZoneCounts(gb_fusion2_device* layout, uint8_t fw_id, std::vector<gb_fusion2_zone*>& allocated_zones)
 {
-    IT5711ZoneCounts counts = GetIT5711ZoneCounts(fw_id, fw_revision, layout->layout_id);
+    IT5711ZoneCounts counts = GetIT5711ZoneCounts(fw_id, layout->layout_id);
 
     for(uint8_t zone_idx = 0; zone_idx < GB_FUSION2_ZONES_MAX; ++zone_idx)
     {
@@ -325,6 +293,7 @@ RGBController_RGBFusion2USB::RGBController_RGBFusion2USB(RGBFusion2USBController
     serial                      = controller->GetSerial();
     product_id                  = controller->GetProductID();
     device_num                  = controller->GetDeviceNum();
+    fw_id                       = controller->GetFWID();
 
 
     mode Direct;
@@ -629,10 +598,7 @@ void RGBController_RGBFusion2USB::Init_Controller()
     \*---------------------------------------------------------*/
     if(product_id == 0x5711)
     {
-        ApplyIT5711ZoneCounts(&instance_layout,
-                                 controller->GetFWID(),
-                                 controller->GetFWRevision(),
-                                 allocated_zones);
+        ApplyIT5711ZoneCounts(&instance_layout, fw_id, allocated_zones);
     }
 
     /*---------------------------------------------------------*\
@@ -1506,12 +1472,8 @@ void RGBController_RGBFusion2USB::DeviceUpdateZoneLEDs(int zone)
             | Apply the mode and color to the zone                      |
             \*---------------------------------------------------------*/
             controller->SetLEDEffect(zones[zone].leds[led_idx].value, led_mode_value, selected_mode->speed, selected_mode->brightness, random, led_color);
+            controller->ApplyEffect();
         }
-
-        /*---------------------------------------------------------*\
-        | Apply once for the whole zone, not once per LED           |
-        \*---------------------------------------------------------*/
-        controller->ApplyEffect();
     }
 
     /*---------------------------------------------------------*\

Controllers/GigabyteRGBFusion2USBController/RGBController_GigabyteRGBFusion2USB.h

@@ -48,6 +48,7 @@ private:
 
     RGBFusion2USBController*    controller;
     uint8_t                     device_num;
+    uint8_t                     fw_id           = 0;
     RGBColor                    null_color      = 0;
     bool                        supports_gen2   = 0;
     uint8_t                     gen2_enabled_headers = 0;

Controllers/HIDLampArrayController/RGBController_HIDLampArray.cpp

@@ -196,7 +196,7 @@ static const char *HIDUsageIDsToKeyNames[HID_KEYBOARD_USAGE_IDS_COUNT] =
     KEY_EN_NUMPAD_0,            // Keypad 0 and Insert
     KEY_EN_NUMPAD_PERIOD,       // Keypad . and Delete
     KEY_EN_BACK_SLASH,          // Keyboard Non-US \ and |
-    KEY_EN_MENU,                // Keyboard Application
+    KEY_EN_UNUSED,              // Keyboard Application
     KEY_EN_POWER,               // Keyboard Power
     KEY_EN_NUMPAD_EQUAL,        // Keypad =
     KEY_EN_F13,                 // Keyboard F13
@@ -260,16 +260,6 @@ static const char *HIDUsageIDsToKeyNames[HID_KEYBOARD_USAGE_IDS_COUNT] =
     KEY_EN_UNUSED,              // Keyboard Clear/Again
     KEY_EN_UNUSED,              // Keyboard CrSel/Props
     KEY_EN_UNUSED,              // Keyboard ExSel
-    KEY_EN_UNUSED,              // A5 Reserved
-    KEY_EN_UNUSED,              // A6 Reserved
-    KEY_EN_UNUSED,              // A7 Reserved
-    KEY_EN_UNUSED,              // A8 Reserved
-    KEY_EN_UNUSED,              // A9 Reserved
-    KEY_EN_UNUSED,              // AA Reserved
-    KEY_EN_UNUSED,              // AB Reserved
-    KEY_EN_UNUSED,              // AC Reserved
-    KEY_EN_UNUSED,              // AD Reserved
-    KEY_EN_UNUSED,              // AE Reserved
     KEY_EN_UNUSED,              // AF Reserved
     KEY_EN_UNUSED,              // Keypad 00
     KEY_EN_UNUSED,              // Keypad 000
@@ -317,7 +307,6 @@ static const char *HIDUsageIDsToKeyNames[HID_KEYBOARD_USAGE_IDS_COUNT] =
     KEY_EN_UNUSED,              // Keypad Octal
     KEY_EN_UNUSED,              // Keypad Decimal
     KEY_EN_UNUSED,              // Keypad Hexadecimal
-    KEY_EN_UNUSED,              // DE Reserved
     KEY_EN_UNUSED,              // DF Reserved
     KEY_EN_LEFT_CONTROL,        // Keyboard LeftControl
     KEY_EN_LEFT_SHIFT,          // Keyboard LeftShift
@@ -368,11 +357,9 @@ void RGBController_HIDLampArray::SetupZones()
     {
         led new_led;
 
-        unsigned char lamp_key = controller->GetLamps()[lamp_idx].LampKey;
-
-        if(lamp_key < HID_KEYBOARD_USAGE_IDS_COUNT && HIDUsageIDsToKeyNames[lamp_key] != nullptr)
+        if(controller->GetLamps()[lamp_idx].LampKey < HID_KEYBOARD_USAGE_IDS_COUNT)
         {
-            new_led.name = HIDUsageIDsToKeyNames[lamp_key];
+            new_led.name = HIDUsageIDsToKeyNames[controller->GetLamps()[lamp_idx].LampKey];
         }
         else
         {

Controllers/HyperXMicrophoneV2Controller/RGBController_HyperXMicrophoneV2.cpp

@@ -85,7 +85,7 @@ void RGBController_HyperXMicrophoneV2::SetupZones()
     Mic.leds_min                = HYPERX_QUADCAST_2S_TOTAL_LEDS;
     Mic.leds_max                = HYPERX_QUADCAST_2S_TOTAL_LEDS;
     Mic.leds_count              = HYPERX_QUADCAST_2S_TOTAL_LEDS;
-    Mic.matrix_map.Set(HYPERX_QUADCAST_2S_MATRIX_HEIGHT, HYPERX_QUADCAST_2S_MATRIX_WIDTH, led_mapping);
+    Mic.matrix_map.Set(HYPERX_QUADCAST_2S_MATRIX_WIDTH, HYPERX_QUADCAST_2S_MATRIX_HEIGHT, led_mapping);
 
     for(unsigned int i = 0; i < HYPERX_QUADCAST_2S_TOTAL_LEDS; i ++)
     {

Controllers/LogitechController/LogitechHIDPP20Controller/LogitechHIDPP20Controller.cpp

@@ -7559,8 +7559,7 @@ void LogitechHIDPP20Controller::ReadActiveProfileSector()
     }
 
     constexpr uint16_t SECTOR_SIZE = 0x63;  // 99 bytes
-    constexpr uint16_t SIZE_OF_PAGE   = 16; 
-
+    constexpr uint16_t PAGE_SIZE   = 16;
 
     /*-----------------------------------------------------*\
     | Step 1: load the sector into the device's read buffer |
@@ -7586,7 +7585,7 @@ void LogitechHIDPP20Controller::ReadActiveProfileSector()
     \*-----------------------------------------------------*/
     uint8_t sector_buf[SECTOR_SIZE] = {};
 
-    for(uint16_t offset = 0; offset < SECTOR_SIZE; offset += SIZE_OF_PAGE)
+    for(uint16_t offset = 0; offset < SECTOR_SIZE; offset += PAGE_SIZE)
     {
         uint8_t read_req[3] = {
             (uint8_t)((offset >> 8) & 0xFF),
@@ -7606,9 +7605,9 @@ void LogitechHIDPP20Controller::ReadActiveProfileSector()
             return;
         }
 
-        size_t copy_len = (offset + SIZE_OF_PAGE > SECTOR_SIZE)
+        size_t copy_len = (offset + PAGE_SIZE > SECTOR_SIZE)
                         ? (size_t)(SECTOR_SIZE - offset)
-                        : SIZE_OF_PAGE;
+                        : PAGE_SIZE;
         memcpy(sector_buf + offset, page_resp, copy_len);
     }
 
@@ -7618,11 +7617,11 @@ void LogitechHIDPP20Controller::ReadActiveProfileSector()
     LOG_DEBUG("%s ProfileSector partition=NVS sector=1 size=%u bytes:",
               LOG_TAG, (unsigned)SECTOR_SIZE);
 
-    for(uint16_t row = 0; row < SECTOR_SIZE; row += SIZE_OF_PAGE)
+    for(uint16_t row = 0; row < SECTOR_SIZE; row += PAGE_SIZE)
     {
-        size_t row_len = (row + SIZE_OF_PAGE > SECTOR_SIZE)
+        size_t row_len = (row + PAGE_SIZE > SECTOR_SIZE)
                        ? (size_t)(SECTOR_SIZE - row)
-                       : SIZE_OF_PAGE;
+                       : PAGE_SIZE;
 
         char hex[64] = {};
         char* p = hex;

Controllers/MSIMotherboardController/MSIMotherboard112Controller/MSIMotherboard112Controller.cpp

@@ -38,24 +38,17 @@ MSIMotherboard112Controller::MSIMotherboard112Controller(hid_device* handle, con
     location    = path;
     name        = dev_name;
 
-    /*-----------------------------------------------------*\
-    | Perform initial reads - get the controller's firmware |
-    | version and then read the controller's active         |
-    | configuration data                                    |
-    \*-----------------------------------------------------*/
-    ReadFwVersion();
-    ReadSettings();
+    if(dev)
+    {
+        ReadFwVersion();
+        ReadSettings();
+    }
 
     /*-----------------------------------------------------*\
-    | The last byte of the packet is the save flag.  This   |
-    | byte is stored as a zero in the data flash, but is    |
-    | set to 1 at the protocol level to tell the firmware   |
-    | to save the active configuration to flash.            |
-    | Also set onboard zone to act as sync master for all   |
-    | of the onboard LEDs.                                  |
+    | Initialize save flag                                  |
     \*-----------------------------------------------------*/
-    data.save_data                  = 0;
-    data.on_board_led.colorFlags    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR | MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD;
+    data.save_data = 0;
+    data.on_board_led.colorFlags = 0x81;    // force MS bit of color flags to 1 to have expected zone control
 
     /*-----------------------------------------------------*\
     | Initialize zone based per LED data                    |
@@ -63,25 +56,25 @@ MSIMotherboard112Controller::MSIMotherboard112Controller(hid_device* handle, con
     numof_onboard_leds = 7;
     supported_zones    = &zones_set;
 
-    zone_based_per_led_data.j_rgb_1.speedAndBrightnessFlags         = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.j_rgb_1.colorFlags                     |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.j_rainbow_1.speedAndBrightnessFlags     = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.j_rainbow_1.colorFlags                 |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led.speedAndBrightnessFlags    = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led.colorFlags                |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_1.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_1.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_2.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_2.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_3.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_3.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_4.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_4.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_5.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_5.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_6.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_6.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.save_data                               = 0;
+    zone_based_per_led_data.j_rgb_1.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
+    zone_based_per_led_data.j_rgb_1.colorFlags = BITSET(zone_based_per_led_data.j_rgb_1.colorFlags, true, 7u);
+    zone_based_per_led_data.j_rainbow_1.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
+    zone_based_per_led_data.j_rainbow_1.colorFlags = BITSET(zone_based_per_led_data.j_rainbow_1.colorFlags, true, 7u);
+    zone_based_per_led_data.on_board_led.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
+    zone_based_per_led_data.on_board_led.colorFlags = BITSET(zone_based_per_led_data.on_board_led.colorFlags, true, 7u);
+    zone_based_per_led_data.on_board_led_1.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
+    zone_based_per_led_data.on_board_led_1.colorFlags = BITSET(zone_based_per_led_data.on_board_led_1.colorFlags, true, 7u);
+    zone_based_per_led_data.on_board_led_2.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
+    zone_based_per_led_data.on_board_led_2.colorFlags = BITSET(zone_based_per_led_data.on_board_led_2.colorFlags, true, 7u);
+    zone_based_per_led_data.on_board_led_3.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
+    zone_based_per_led_data.on_board_led_3.colorFlags = BITSET(zone_based_per_led_data.on_board_led_3.colorFlags, true, 7u);
+    zone_based_per_led_data.on_board_led_4.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
+    zone_based_per_led_data.on_board_led_4.colorFlags = BITSET(zone_based_per_led_data.on_board_led_4.colorFlags, true, 7u);
+    zone_based_per_led_data.on_board_led_5.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
+    zone_based_per_led_data.on_board_led_5.colorFlags = BITSET(zone_based_per_led_data.on_board_led_5.colorFlags, true, 7u);
+    zone_based_per_led_data.on_board_led_6.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2 << 2;
+    zone_based_per_led_data.on_board_led_6.colorFlags = BITSET(zone_based_per_led_data.on_board_led_6.colorFlags, true, 7u);
+    zone_based_per_led_data.save_data = 0;
 
     direct_mode = false;
 }
@@ -100,27 +93,18 @@ void MSIMotherboard112Controller::SetMode
     bool            rainbow_color
     )
 {
-    /*-----------------------------------------------------*\
-    | Get the zone data pointer within the configuration    |
-    | data buffer                                           |
-    \*-----------------------------------------------------*/
     ZoneData* zone_data = GetZoneData(data, zone);
 
-    /*-----------------------------------------------------*\
-    | Return if zone is invalid                             |
-    \*-----------------------------------------------------*/
     if(zone_data == nullptr)
     {
         return;
     }
 
-    if(zone <= MSI_ZONE_ON_BOARD_LED_0)
+    if (zone <= MSI_ZONE_ON_BOARD_LED_0)
     {
         zone_data->effect                    = mode;
-        zone_data->speedAndBrightnessFlags   = ((brightness << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK)
-                                             | ((speed << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)           & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
-        zone_data->colorFlags                = (rainbow_color ? (zone_data->colorFlags & ~MSI_COLOR_FLAG_USE_CUSTOM_COLOR)
-                                                              : (zone_data->colorFlags | MSI_COLOR_FLAG_USE_CUSTOM_COLOR));
+        zone_data->speedAndBrightnessFlags   = (brightness << 2) | (speed & 0x03);
+        zone_data->colorFlags                = (rainbow_color ? 0 : MSI_COLOR_FLAG_USE_CUSTOM_COLOR);
         zone_data->padding                   = 0x00;
 
         if(mode > MSI_MODE_DOUBLE_FLASHING)
@@ -142,10 +126,8 @@ void MSIMotherboard112Controller::SetMode
         if(zone_data != nullptr)
         {
             zone_data->effect                    = mode;
-            zone_data->speedAndBrightnessFlags   = ((brightness << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK)
-                                                 | ((speed << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)           & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
-            zone_data->colorFlags                = (rainbow_color ? (zone_data->colorFlags & ~MSI_COLOR_FLAG_USE_CUSTOM_COLOR)
-                                                                  : (zone_data->colorFlags | MSI_COLOR_FLAG_USE_CUSTOM_COLOR));
+            zone_data->speedAndBrightnessFlags   = (brightness << 2) | (speed & 0x03);
+            zone_data->colorFlags                = (rainbow_color ? 0 : MSI_COLOR_FLAG_USE_CUSTOM_COLOR);
             zone_data->padding                   = 0x00;
         }
     }
@@ -219,21 +201,14 @@ void MSIMotherboard112Controller::SetZoneColor
     unsigned char   blu2
     )
 {
-    /*-----------------------------------------------------*\
-    | Get the zone data pointer within the configuration    |
-    | data buffer                                           |
-    \*-----------------------------------------------------*/
     ZoneData* zone_data = GetZoneData(data, zone);
 
-    /*-----------------------------------------------------*\
-    | Return if zone is invalid                             |
-    \*-----------------------------------------------------*/
     if(zone_data == nullptr)
     {
         return;
     }
 
-    if(zone <= MSI_ZONE_ON_BOARD_LED_0)
+    if (zone <= MSI_ZONE_ON_BOARD_LED_0)
     {
         zone_data->color.R  = red1;
         zone_data->color.G  = grn1;

Controllers/MSIMotherboardController/MSIMotherboard162Controller/MSIMotherboard162Controller.cpp

@@ -12,12 +12,9 @@
 
 #include <algorithm>
 #include <array>
-#include <bitset>
 #include "MSIMotherboard162Controller.h"
 #include "StringUtils.h"
 
-#define BITSET(val, bit, pos)       ((unsigned char)std::bitset<8>(val).set((pos), (bit)).to_ulong())
-
 struct mystic_light_162_config
 {
     unsigned short                  pid;                    // PID of the board
@@ -85,32 +82,24 @@ MSIMotherboard162Controller::MSIMotherboard162Controller(hid_device* handle, con
     location    = path;
     name        = dev_name;
 
-    /*-----------------------------------------------------*\
-    | Perform initial reads - get the controller's firmware |
-    | version and then read the controller's active         |
-    | configuration data                                    |
-    \*-----------------------------------------------------*/
-    ReadFwVersion();
-    ReadSettings();
+    if(dev)
+    {
+        ReadFwVersion();
+        ReadSettings();
+    }
 
     /*-----------------------------------------------------*\
-    | The last byte of the packet is the save flag.  This   |
-    | byte is stored as a zero in the data flash, but is    |
-    | set to 1 at the protocol level to tell the firmware   |
-    | to save the active configuration to flash.            |
-    | Also set onboard zone to act as sync master for all   |
-    | of the onboard LEDs.                                  |
+    | Initialize save flag                                  |
     \*-----------------------------------------------------*/
-    data.save_data                  = 0;
-    data.on_board_led.colorFlags    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR | MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD;
+    data.save_data = 0;
+    data.on_board_led.colorFlags = 0x81;    // force MS bit of color flags to 1 to have expectd zone control
 
     /*-----------------------------------------------------*\
-    | Search for the board configuration matching this      |
-    | board.                                                |
+    | Initialize zone based per LED data                    |
     \*-----------------------------------------------------*/
     const mystic_light_162_config* board_config = nullptr;
 
-    for(std::size_t i = 0; i < NUMOF_CONFIGS; i++)
+    for(std::size_t i = 0; i < NUMOF_CONFIGS; ++i)
     {
         if (board_configs[i].pid == pid)
         {
@@ -119,10 +108,6 @@ MSIMotherboard162Controller::MSIMotherboard162Controller(hid_device* handle, con
         }
     }
 
-    /*-----------------------------------------------------*\
-    | Fill in the number of each zone type based on the     |
-    | board configuration                                   |
-    \*-----------------------------------------------------*/
     if(board_config != nullptr)
     {
         numof_onboard_leds = board_config->numof_onboard_leds;
@@ -149,27 +134,19 @@ void MSIMotherboard162Controller::SetMode
     bool            rainbow_color
     )
 {
-    /*-----------------------------------------------------*\
-    | Get the zone data pointer within the configuration    |
-    | data buffer                                           |
-    \*-----------------------------------------------------*/
     ZoneData* zone_data = GetZoneData(data, zone);
 
-    /*-----------------------------------------------------*\
-    | Return if zone is invalid                             |
-    \*-----------------------------------------------------*/
     if(zone_data == nullptr)
     {
         return;
     }
 
-    if(zone <= MSI_ZONE_ON_BOARD_LED_0)
+    if (zone <= MSI_ZONE_ON_BOARD_LED_0)
     {
         zone_data->effect                    = mode;
         zone_data->speedAndBrightnessFlags   = ((brightness << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK)
                                              | ((speed << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)           & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
-        zone_data->colorFlags                = (rainbow_color ? (zone_data->colorFlags & ~MSI_COLOR_FLAG_USE_CUSTOM_COLOR)
-                                                              : (zone_data->colorFlags | MSI_COLOR_FLAG_USE_CUSTOM_COLOR));
+        zone_data->colorFlags                = (rainbow_color ? 0 : MSI_COLOR_FLAG_USE_CUSTOM_COLOR);
         zone_data->padding                   = 0x00;
 
         if(mode > MSI_MODE_DOUBLE_FLASHING)
@@ -193,8 +170,7 @@ void MSIMotherboard162Controller::SetMode
             zone_data->effect                    = mode;
             zone_data->speedAndBrightnessFlags   = ((brightness << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK)
                                                  | ((speed << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)           & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
-            zone_data->colorFlags                = (rainbow_color ? (zone_data->colorFlags & ~MSI_COLOR_FLAG_USE_CUSTOM_COLOR)
-                                                                  : (zone_data->colorFlags | MSI_COLOR_FLAG_USE_CUSTOM_COLOR));
+            zone_data->colorFlags                = (rainbow_color ? 0 : MSI_COLOR_FLAG_USE_CUSTOM_COLOR);
             zone_data->padding                   = 0x00;
         }
     }
@@ -261,21 +237,14 @@ void MSIMotherboard162Controller::SetZoneColor
     unsigned char   blu2
     )
 {
-    /*-----------------------------------------------------*\
-    | Get the zone data pointer within the configuration    |
-    | data buffer                                           |
-    \*-----------------------------------------------------*/
     ZoneData* zone_data = GetZoneData(data, zone);
 
-    /*-----------------------------------------------------*\
-    | Return if zone is invalid                             |
-    \*-----------------------------------------------------*/
     if(zone_data == nullptr)
     {
         return;
     }
 
-    if(zone <= MSI_ZONE_ON_BOARD_LED_0)
+    if (zone <= MSI_ZONE_ON_BOARD_LED_0)
     {
         zone_data->color.R  = red1;
         zone_data->color.G  = grn1;

Controllers/MSIMotherboardController/MSIMotherboard185Controller/MSIMotherboard185Controller.cpp

@@ -17,15 +17,13 @@
 
 #include <algorithm>
 #include <array>
-#include <bitset>
+#include <cstdio>
 #include "MSIMotherboard185Controller.h"
+#include "LogManager.h"
 #include "StringUtils.h"
 
 using namespace std::chrono_literals;
 
-
-#define BITSET(val, bit, pos)       ((unsigned char)std::bitset<8>(val).set((pos), (bit)).to_ulong())
-
 #define SYNC_PER_LED_MODE_JRAINBOW_LED_COUNT     40
 #define SYNC_PER_LED_MODE_CORSAIR_LED_COUNT     120
 #define JRAINBOW1_MAX_LED_COUNT                 200
@@ -33,19 +31,19 @@ using namespace std::chrono_literals;
 #define JCORSAIR_MAX_LED_COUNT                  240
 
 #define MSI_DIRECT_MODE                         0x25
-#define PER_LED_BASIC_SYNC_MODE                 (MSI_COLOR_FLAG_USE_CUSTOM_COLOR | MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD | MSI_COLOR_FLAG_SYNC_SETTING_JPIPE1 | MSI_COLOR_FLAG_SYNC_SETTING_JPIPE2)
+#define PER_LED_BASIC_SYNC_MODE                 (MSI_SPEED_BRIGHTNESS_FLAG_SYNC_SETTING_JRGB | MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD | MSI_COLOR_FLAG_SYNC_SETTING_JPIPE1 | MSI_COLOR_FLAG_SYNC_SETTING_JPIPE2)
 #define PER_LED_FULL_SYNC_MODE                  (PER_LED_BASIC_SYNC_MODE | MSI_COLOR_FLAG_SYNC_SETTING_JRAINBOW1 | MSI_COLOR_FLAG_SYNC_SETTING_JRAINBOW2 | MSI_COLOR_FLAG_SYNC_SETTING_JCORSAIR)
 
 struct mystic_light_185_config
 {
-    unsigned short                           pid;                       // PID of the board
-    int                                      numof_onboard_leds;        // number of onboard leds
-    int                                      numof_pipe1_leds;          // number of pipe 1 leds (used in per LED mode only)
-    int                                      numof_pipe2_leds;          // number of pipe 2 leds (used in per LED mode only)
-    int                                      numof_JRGBs;               // number of supported JRGB headers (used in per LED mode only)
-    const std::vector<MSI_ZONE>*             supported_zones;           // pointer to vector of supported zones
-    MSIMotherboard185Controller::DIRECT_MODE per_led_mode;              // type of direct mode support
-    unsigned char                            minimum_firmware_version;  // minimum required firmware version for this config (0 = all versions acceptable)
+    unsigned short                           pid;                   // PID of the board
+    const char*                              name;                  // DMI board name for filtering (nullptr = match any name)
+    int                                      numof_onboard_leds;    // number of onboard leds
+    int                                      numof_pipe1_leds;      // number of pipe 1 leds (used in per LED mode only)
+    int                                      numof_pipe2_leds;      // number of pipe 2 leds (used in per LED mode only)
+    int                                      numof_JRGBs;           // number of supported JRGB headers (used in per LED mode only)
+    const std::vector<MSI_ZONE>*             supported_zones;       // pointer to vector of supported zones
+    MSIMotherboard185Controller::DIRECT_MODE per_led_mode;          // type of direct mode support
 };
 
 const std::vector<MSI_ZONE> all_zones =
@@ -258,103 +256,105 @@ const std::vector<MSI_ZONE> zones_set21 =
 
 static const mystic_light_185_config board_configs[] =
 {
-    { 0x7B93, 6,  1,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MPG X570 GAMING PRO CARBON WIFI
-    { 0x7C34, 0,  1,  1, 1, &zones_set8,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MEG X570 GODLIKE
-    { 0x7C35, 0,  1,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MEG X570 ACE
-    { 0x7C36, 6,  1,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // PRESTIGE X570 CREATION
-    { 0x7C37, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MPG X570 GAMING PLUS
-    { 0x7C56, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     6 },    // MPG B550 GAMING PLUS
-    { 0x7C59, 0,  8,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED,    0 },    // CREATOR TRX40
-    { 0x7C60, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // TRX40-A PRO
-    { 0x7C67, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B365M MORTAR
-    { 0x7C71, 6,  6,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z490 ACE
-    { 0x7C73, 6,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z490 GAMING CARBON WIFI
-    { 0x7C75, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z490 GAMING PLUS
-    { 0x7C76, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED,    0 },    // MPG Z490M GAMING EDGE
-    { 0x7C77, 0,  0,  0, 0, &zones_set14, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z490I UNIFY
-    { 0x7C79, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z490 GAMING EDGE WIFI
-    { 0x7C80, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG Z490 TOMAHAWK
-    { 0x7C02, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B450 TOMAHAWK MAX
-    { 0x7C81, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B460 TOMAHAWK
-    { 0x7C82, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B460M MORTAR WIFI
-    { 0x7C83, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED,    0 },    // B460M PRO-VDH WIFI
-    { 0x7C84, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MAG X570 TOMAHAWK WIFI
-    { 0x7C86, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED,    0 },    // MPG B460I GAMING EDGE
-    { 0x7C87, 6,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B450M BAZOOKA MAX WIFI
-    { 0x7C90, 6,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B550 GAMING CARBON WIFI
-    { 0x7C91, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B550 TOMAHAWK
-    { 0x7C92, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B550I GAMING EDGE WIFI
-    { 0x7C94, 6,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B550M MORTAR
-    { 0x7C95, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B550M PRO-VDH WIFI
-    { 0x7C98, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // Z490 PLUS
-    { 0x7D03, 0, 15, 18, 1, &zones_set8,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z590 GODLIKE
-    { 0x7D06, 4,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z590 GAMING FORCE
-    { 0x7D07, 4,  5,  0, 2, &zones_set7,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z590 GAMING EDGE WIFI
-    { 0x7D08, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG Z590 TOMAHAWK
-    { 0x7D09, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // Z590-A PRO WIFI
-    { 0x7D13, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG B550 UNIFY
-    { 0x7D14, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // A520M PRO
-    { 0x7D15, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B560 TOMAHAWK WIFI
-    { 0x7D17, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B560M MORTAR
-    { 0x7D18, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B560M PRO-VDH
-    { 0x7D19, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B560I GAMIING EDGE WIFI
-    { 0x7D20, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B560M PRO
-    { 0x7D25, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z690-A WIFI DDR4
-    { 0x7D27, 6,  0,  0, 2, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z690 ACE
-    { 0x7D28, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z690 UNIFY-X
-    { 0x7D29, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z690I UNIFY
-    { 0x7D30, 6,  6,  0, 2, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z690 CARBON WIFI
-    { 0x7D31, 4,  8,  0, 2, &zones_set12, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG EDGE WIFI DDR4
-    { 0x7D32, 1,  0,  0, 1, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG Z690 TOMAHAWK WIFI DDR4
-    { 0x7D33, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z790-VC WIFI
-    { 0x7D36, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z690-P DDR4
-    { 0x7D37, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B760M-VC WIFI (MS-7D37) - fans on JRAINBOW2
-    { 0x7D38, 0,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z590 UNIFY-X
-    { 0x7D40, 0,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B760i EDGE WIFI DDR4
-    { 0x7D41, 6,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B660M TOMAHAWK WIFI DDR4
-    { 0x7D42, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B660 MORTAR WIFI DDR4
-    { 0x7D43, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B660M-A WIFI DDR4
-    { 0x7D46, 0,  1,  1, 0, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO H610M-G DDR4
-    { 0x7D50, 6, 12,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG X570S ACE MAX
-    { 0x7D51, 6,  0,  0, 2, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG X570S UNIFY-X MAX
-    { 0x7D52, 6, 14,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG X570S CARBON EK X
-    { 0x7D53, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG X570S EDGE MAX WIFI
-    { 0x7D54, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG X570S TOMAHAWK MAX WIFI
-    { 0x7D59, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B660-A DDR4
-    { 0x7D67, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO X670-P WIFI
-    { 0x7D69, 9,  2,  4, 1, &zones_set15, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG X670E ACE
-    { 0x7D70, 0,  6,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG X670E Carbon WIFI
-    { 0x7D73, 1,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B650I EDGE WIFI
-    { 0x7D74, 0,  6,  0, 1, &zones_set18, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B650 CARBON WIFI
-    { 0x7D75, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B650 TOMAHAWK WIFI
-    { 0x7D76, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B650M MORTAR WIFI
-    { 0x7D77, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B650M-A WIFI
-    { 0x7D78, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B650-P WIFI
-    { 0x7D86, 0, 18,  4, 1, &zones_set16, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z790 ACE
-    { 0x7D88, 0,  0,  0, 1, &zones_set20, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z790-S WIFI
-    { 0x7D89, 0,  6,  0, 1, &zones_set18, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z790 CARBON WIFI
-    { 0x7D90, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B760M BOMBER DDR4
-    { 0x7D91, 1,  0,  0, 1, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG Z790 TOMAHAWK WIFI
-    { 0x7D93, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // Z790 GAMING PRO WIFI
-    { 0x7D96, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B760 TOMAHAWK WIFI DDR5
-    { 0x7D97, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B660 MORTAR MAX WIFI DDR4
-    { 0x7D98, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B760-P WIFI DDR4
-    { 0x7D99, 6,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B760M-A WIFI DDR4
-    { 0x7E01, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B760M MORTAR MAX
-    { 0x7E03, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z790I EDGE WIFI
-    { 0x7E06, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z790-P WIFI DDR4
-    { 0x7E07, 0,  0,  0, 2, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z790-A WIFI DDR4
-    { 0x7E09, 0,  0,  0, 0, &zones_set19, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B650M PROJECT ZERO
-    { 0x7E10, 0,  6,  0, 2, &zones_set17, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B650 EDGE WIFI
-    { 0x7E12, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG X670E TOMAHAWK WIFI
-    { 0x0076, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG X670E TOMAHAWK WIFI (Common PID)
-    { 0x7E16, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // X670E GAMING PLUS WIFI
-    { 0x7E24, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B650M GAMING PLUS WIFI
-    { 0x7E26, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B650 GAMING PLUS WIFI
-    { 0x7E27, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B650M-P
-    { 0x7E28, 6,  0,  0, 2, &zones_set21, MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MSI PRO A620M-B (MS-7E28)
+    { 0x7B93, nullptr,                              6,  1,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MPG X570 GAMING PRO CARBON WIFI
+    { 0x7C34, nullptr,                              0,  1,  1, 1, &zones_set8,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MEG X570 GODLIKE
+    { 0x7C35, nullptr,                              0,  1,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MEG X570 ACE
+    { 0x7C36, nullptr,                              6,  1,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // PRESTIGE X570 CREATION
+    { 0x7C37, nullptr,                              6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MPG X570 GAMING PLUS
+    { 0x7C56, "MSI B550-A PRO (MS-7C56)",           6,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B550-A PRO
+    { 0x7C56, "MSI MPG B550 GAMING PLUS (MS-7C56)", 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B550 GAMING PLUS
+    { 0x7C59, nullptr,                              0,  8,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED },      // CREATOR TRX40
+    { 0x7C60, nullptr,                              6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // TRX40-A PRO
+    { 0x7C67, nullptr,                              6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B365M MORTAR
+    { 0x7C71, nullptr,                              6,  6,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z490 ACE
+    { 0x7C73, nullptr,                              6,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z490 GAMING CARBON WIFI
+    { 0x7C75, nullptr,                              6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z490 GAMING PLUS
+    { 0x7C76, nullptr,                              6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED },      // MPG Z490M GAMING EDGE
+    { 0x7C77, nullptr,                              0,  0,  0, 0, &zones_set14, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z490I UNIFY
+    { 0x7C79, nullptr,                              6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z490 GAMING EDGE WIFI
+    { 0x7C80, nullptr,                              6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG Z490 TOMAHAWK
+    { 0x7C02, nullptr,                              6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B450 TOMAHAWK MAX
+    { 0x7C81, nullptr,                              6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B460 TOMAHAWK
+    { 0x7C82, nullptr,                              6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B460M MORTAR WIFI
+    { 0x7C83, nullptr,                              6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED },      // B460M PRO-VDH WIFI
+    { 0x7C84, nullptr,                              6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MAG X570 TOMAHAWK WIFI
+    { 0x7C86, nullptr,                              6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED },      // MPG B460I GAMING EDGE
+    { 0x7C87, nullptr,                              6,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B450M BAZOOKA MAX WIFI
+    { 0x7C90, nullptr,                              6,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B550 GAMING CARBON WIFI
+    { 0x7C91, nullptr,                              6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B550 TOMAHAWK
+    { 0x7C92, nullptr,                              6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B550I GAMING EDGE WIFI
+    { 0x7C94, nullptr,                              6,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B550M MORTAR
+    { 0x7C95, nullptr,                              6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B550M PRO-VDH WIFI
+    { 0x7C98, nullptr,                              6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // Z490 PLUS
+    { 0x7D03, nullptr,                              0, 15, 18, 1, &zones_set8,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z590 GODLIKE
+    { 0x7D06, nullptr,                              4,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z590 GAMING FORCE
+    { 0x7D07, nullptr,                              4,  5,  0, 2, &zones_set7,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z590 GAMING EDGE WIFI
+    { 0x7D08, nullptr,                              6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG Z590 TOMAHAWK
+    { 0x7D09, nullptr,                              6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // Z590-A PRO WIFI
+    { 0x7D13, nullptr,                              6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG B550 UNIFY
+    { 0x7D14, nullptr,                              6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // A520M PRO
+    { 0x7D15, nullptr,                              6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B560 TOMAHAWK WIFI
+    { 0x7D17, nullptr,                              6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B560M MORTAR
+    { 0x7D18, nullptr,                              6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B560M PRO-VDH
+    { 0x7D19, nullptr,                              6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B560I GAMIING EDGE WIFI
+    { 0x7D20, nullptr,                              6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B560M PRO
+    { 0x7D25, nullptr,                              6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z690-A WIFI DDR4
+    { 0x7D27, nullptr,                              6,  0,  0, 2, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z690 ACE
+    { 0x7D28, nullptr,                              6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z690 UNIFY-X
+    { 0x7D29, nullptr,                              6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z690I UNIFY
+    { 0x7D30, nullptr,                              6,  6,  0, 2, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z690 CARBON WIFI
+    { 0x7D31, nullptr,                              4,  8,  0, 2, &zones_set12, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG EDGE WIFI DDR4
+    { 0x7D32, nullptr,                              1,  0,  0, 1, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG Z690 TOMAHAWK WIFI DDR4
+    { 0x7D33, nullptr,                              6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z790-VC WIFI
+    { 0x7D36, nullptr,                              6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z690-P DDR4
+    { 0x7D37, nullptr,                              6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B760M-VC WIFI (MS-7D37) - fans on JRAINBOW2
+    { 0x7D38, nullptr,                              0,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z590 UNIFY-X
+    { 0x7D40, nullptr,                              0,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B760i EDGE WIFI DDR4
+    { 0x7D41, nullptr,                              6,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B660M TOMAHAWK WIFI DDR4
+    { 0x7D42, nullptr,                              6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B660 MORTAR WIFI DDR4
+    { 0x7D43, nullptr,                              0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B660M-A WIFI DDR4
+    { 0x7D46, nullptr,                              0,  1,  1, 0, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO H610M-G DDR4
+    { 0x7D50, nullptr,                              6, 12,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG X570S ACE MAX
+    { 0x7D51, nullptr,                              6,  0,  0, 2, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG X570S UNIFY-X MAX
+    { 0x7D52, nullptr,                              6, 14,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG X570S CARBON EK X
+    { 0x7D53, nullptr,                              6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG X570S EDGE MAX WIFI
+    { 0x7D54, nullptr,                              6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG X570S TOMAHAWK MAX WIFI
+    { 0x7D59, nullptr,                              0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B660-A DDR4
+    { 0x7D67, nullptr,                              0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO X670-P WIFI
+    { 0x7D69, nullptr,                              9,  2,  4, 1, &zones_set15, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG X670E ACE
+    { 0x7D70, nullptr,                              0,  6,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG X670E Carbon WIFI
+    { 0x7D73, nullptr,                              1,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B650I EDGE WIFI
+    { 0x7D74, nullptr,                              0,  6,  0, 1, &zones_set18, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B650 CARBON WIFI
+    { 0x7D75, nullptr,                              0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B650 TOMAHAWK WIFI
+    { 0x7D76, nullptr,                              0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B650M MORTAR WIFI
+    { 0x7D77, nullptr,                              0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B650M-A WIFI
+    { 0x7D78, nullptr,                              0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B650-P WIFI
+    { 0x7D86, nullptr,                              0, 18,  4, 1, &zones_set16, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z790 ACE
+    { 0x7D88, nullptr,                              0,  0,  0, 1, &zones_set20, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z790-S WIFI
+    { 0x7D89, nullptr,                              0,  6,  0, 1, &zones_set18, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z790 CARBON WIFI
+    { 0x7D90, nullptr,                              0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B760M BOMBER DDR4
+    { 0x7D91, nullptr,                              1,  0,  0, 1, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG Z790 TOMAHAWK WIFI
+    { 0x7D93, nullptr,                              6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // Z790 GAMING PRO WIFI
+    { 0x7D96, nullptr,                              0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B760 TOMAHAWK WIFI DDR5
+    { 0x7D97, nullptr,                              6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B660 MORTAR MAX WIFI DDR4
+    { 0x7D98, nullptr,                              0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B760-P WIFI DDR4
+    { 0x7D99, nullptr,                              6,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B760M-A WIFI DDR4
+    { 0x7E01, nullptr,                              0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B760M MORTAR MAX
+    { 0x7E03, nullptr,                              6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z790I EDGE WIFI
+    { 0x7E06, nullptr,                              0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z790-P WIFI DDR4
+    { 0x7E07, nullptr,                              0,  0,  0, 2, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z790-A WIFI DDR4
+    { 0x7E09, nullptr,                              0,  0,  0, 0, &zones_set19, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B650M PROJECT ZERO
+    { 0x7E10, nullptr,                              0,  6,  0, 2, &zones_set17, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B650 EDGE WIFI
+    { 0x7E12, nullptr,                              0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG X670E TOMAHAWK WIFI
+    { 0x0076, nullptr,                              0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG X670E TOMAHAWK WIFI (Common PID)
+    { 0x7E16, nullptr,                              0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // X670E GAMING PLUS WIFI
+    { 0x7E24, nullptr,                              0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B650M GAMING PLUS WIFI
+    { 0x7E26, nullptr,                              0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B650 GAMING PLUS WIFI
+    { 0x7E27, nullptr,                              0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B650M-P
+    { 0x7E28, nullptr,                              6,  0,  0, 2, &zones_set21, MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MSI PRO A620M-B (MS-7E28)
 };
 
+
 FeaturePacket_185 enable_per_led_msg;
 
 Color* per_led_onboard_leds;
@@ -365,17 +365,32 @@ Color* per_led_jrainbow1_sync;
 Color* per_led_jrainbow2_sync;
 Color* per_led_jcorsair_sync;
 
+/*-----------------------------------------------------*\
+| Static helper to check if a zone is supported by the  |
+| given supported_zones vector                          |
+\*-----------------------------------------------------*/
+bool MSIMotherboard185Controller::IsZoneSupported(MSI_ZONE zone, const std::vector<MSI_ZONE>* supported_zones)
+{
+    if(supported_zones == nullptr)
+    {
+        return false;
+    }
+    return std::find(supported_zones->begin(), supported_zones->end(), zone) != supported_zones->end();
+}
+
 MSIMotherboard185Controller::MSIMotherboard185Controller(hid_device* handle, const char* path, unsigned short pid, std::string dev_name)
 {
-    dev             = handle;
-    location        = path;
-    name            = dev_name;
-    version_invalid = false;
+    dev         = handle;
+    location    = path;
+    name        = dev_name;
 
     /*-----------------------------------------------------*\
-    | Read the controller's firmware version                |
+    | Perform initial reads - get the controller's firmware |
+    | version and then read the controller's active         |
+    | configuration data                                    |
     \*-----------------------------------------------------*/
     ReadFwVersion();
+    ReadConfigurationData();
 
     /*-----------------------------------------------------*\
     | Common PID boards embed their virtual PID in the      |
@@ -402,11 +417,10 @@ MSIMotherboard185Controller::MSIMotherboard185Controller(hid_device* handle, con
     | byte is stored as a zero in the data flash, but is    |
     | set to 1 at the protocol level to tell the firmware   |
     | to save the active configuration to flash.            |
-    | Also set onboard zone to act as sync master for all   |
-    | of the onboard LEDs.                                  |
     \*-----------------------------------------------------*/
-    data.save_data                  = 0;
-    data.on_board_led.colorFlags    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR | MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD;
+    configuration_data.save_data = 0;
+
+    configuration_data.on_board_led.colorFlags = MSI_COLOR_FLAG_USE_CUSTOM_COLOR | MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD; // always enable onboard sync flag to have expected zone control
 
     /*-----------------------------------------------------*\
     | Search for the board configuration matching this      |
@@ -414,12 +428,35 @@ MSIMotherboard185Controller::MSIMotherboard185Controller(hid_device* handle, con
     \*-----------------------------------------------------*/
     const mystic_light_185_config* board_config = nullptr;
 
-    for(std::size_t i = 0; i < NUMOF_CONFIGS; i++)
+    /*-----------------------------------------------------*\
+    | First pass: look for a config that matches both PID   |
+    | and board name (when name is specified in the config) |
+    \*-----------------------------------------------------*/
+    for(std::size_t i = 0; i < NUMOF_CONFIGS; ++i)
     {
-        if(board_configs[i].pid == pid)
+        if(board_configs[i].pid == pid && board_configs[i].name != nullptr)
         {
-            board_config = &board_configs[i];
-            break;
+            if(name.find(board_configs[i].name) != std::string::npos)
+            {
+                board_config = &board_configs[i];
+                break;
+            }
+        }
+    }
+
+    /*-----------------------------------------------------*\
+    | Second pass: fall back to PID-only match for entries  |
+    | without a name filter (backward compatible)           |
+    \*-----------------------------------------------------*/
+    if(board_config == nullptr)
+    {
+        for(std::size_t i = 0; i < NUMOF_CONFIGS; ++i)
+        {
+            if(board_configs[i].pid == pid && board_configs[i].name == nullptr)
+            {
+                board_config = &board_configs[i];
+                break;
+            }
         }
     }
 
@@ -429,38 +466,23 @@ MSIMotherboard185Controller::MSIMotherboard185Controller(hid_device* handle, con
     \*-----------------------------------------------------*/
     if(board_config != nullptr)
     {
-        /*-------------------------------------------------*\
-        | If the firmware version is below the minimum, set |
-        | invalid version flag and return                   |
-        \*-------------------------------------------------*/
-        if(version_APROM_val < board_config->minimum_firmware_version)
-        {
-            version_invalid = true;
-            return;
-        }
-
-        numof_onboard_leds  = board_config->numof_onboard_leds;
-        numof_pipe1_leds    = board_config->numof_pipe1_leds;
-        numof_pipe2_leds    = board_config->numof_pipe2_leds;
-        numof_JRGBs         = board_config->numof_JRGBs;
-        supported_zones     = board_config->supported_zones;
-        per_led_mode        = board_config->per_led_mode;
+        numof_onboard_leds = board_config->numof_onboard_leds;
+        numof_pipe1_leds   = board_config->numof_pipe1_leds;
+        numof_pipe2_leds   = board_config->numof_pipe2_leds;
+        numof_JRGBs        = board_config->numof_JRGBs;
+        supported_zones    = board_config->supported_zones;
+        per_led_mode       = board_config->per_led_mode;
     }
     else
     {
-        numof_onboard_leds  = 6;
-        numof_pipe1_leds    = 1;
-        numof_pipe2_leds    = 1;
-        numof_JRGBs         = 2;
-        supported_zones     = &all_zones;
-        per_led_mode        = DIRECT_MODE_DISABLED;
+        numof_onboard_leds = 6;
+        numof_pipe1_leds   = 1;
+        numof_pipe2_leds   = 1;
+        numof_JRGBs        = 2;
+        supported_zones    = &all_zones;
+        per_led_mode       = DIRECT_MODE_DISABLED;
     }
 
-    /*-----------------------------------------------------*\
-    | Read the controller's active configuration data       |
-    \*-----------------------------------------------------*/
-    ReadSettings();
-
     /*-----------------------------------------------------*\
     | Initialize per-LED data                               |
     \*-----------------------------------------------------*/
@@ -516,84 +538,49 @@ MSIMotherboard185Controller::MSIMotherboard185Controller(hid_device* handle, con
     | Set up per-LED switching message for synchronized     |
     | mode.                                                 |
     \*-----------------------------------------------------*/
+    memset(&enable_per_led_msg, 0, sizeof(enable_per_led_msg));
     enable_per_led_msg.j_rgb_1.speedAndBrightnessFlags              = 0x08;
-    enable_per_led_msg.j_rgb_1.colorFlags                           = 0x80;
+    enable_per_led_msg.j_rgb_1.colorFlags                           = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.j_pipe_1.speedAndBrightnessFlags             = 0x2A;
-    enable_per_led_msg.j_pipe_1.colorFlags                          = 0x80;
+    enable_per_led_msg.j_pipe_1.colorFlags                          = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.j_pipe_2.speedAndBrightnessFlags             = 0x2A;
-    enable_per_led_msg.j_pipe_2.colorFlags                          = 0x80;
+    enable_per_led_msg.j_pipe_2.colorFlags                          = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.j_rainbow_1.speedAndBrightnessFlags          = 0x29;
-    enable_per_led_msg.j_rainbow_1.colorFlags                       = 0x80;
+    enable_per_led_msg.j_rainbow_1.colorFlags                       = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.j_rainbow_1.cycle_or_led_num                 = 0x28;
     enable_per_led_msg.j_rainbow_2.speedAndBrightnessFlags          = 0x29;
-    enable_per_led_msg.j_rainbow_2.colorFlags                       = 0x80;
+    enable_per_led_msg.j_rainbow_2.colorFlags                       = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.j_rainbow_2.cycle_or_led_num                 = 0x28;
     enable_per_led_msg.j_corsair.fan_flags                          = 0x29;
     enable_per_led_msg.j_corsair.corsair_quantity                   = 0x00;
     enable_per_led_msg.j_corsair.padding[2]                         = 0x82;
     enable_per_led_msg.j_corsair.is_individual                      = 0x78;
     enable_per_led_msg.j_corsair_outerll120.speedAndBrightnessFlags = 0x28;
-    enable_per_led_msg.j_corsair_outerll120.colorFlags              = 0x80;
+    enable_per_led_msg.j_corsair_outerll120.colorFlags              = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.on_board_led.effect                          = MSI_DIRECT_MODE;
     enable_per_led_msg.on_board_led.speedAndBrightnessFlags         = 0x29 | MSI_SPEED_BRIGHTNESS_FLAG_SYNC_SETTING_JRGB;
     enable_per_led_msg.on_board_led.colorFlags                      = PER_LED_FULL_SYNC_MODE;
     enable_per_led_msg.on_board_led_1.speedAndBrightnessFlags       = 0x28;
-    enable_per_led_msg.on_board_led_1.colorFlags                    = 0x80;
+    enable_per_led_msg.on_board_led_1.colorFlags                    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.on_board_led_2.speedAndBrightnessFlags       = 0x28;
-    enable_per_led_msg.on_board_led_2.colorFlags                    = 0x80;
+    enable_per_led_msg.on_board_led_2.colorFlags                    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.on_board_led_3.speedAndBrightnessFlags       = 0x28;
-    enable_per_led_msg.on_board_led_3.colorFlags                    = 0x80;
+    enable_per_led_msg.on_board_led_3.colorFlags                    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.on_board_led_4.speedAndBrightnessFlags       = 0x28;
-    enable_per_led_msg.on_board_led_4.colorFlags                    = 0x80;
+    enable_per_led_msg.on_board_led_4.colorFlags                    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.on_board_led_5.speedAndBrightnessFlags       = 0x28;
-    enable_per_led_msg.on_board_led_5.colorFlags                    = 0x80;
+    enable_per_led_msg.on_board_led_5.colorFlags                    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.on_board_led_6.speedAndBrightnessFlags       = 0x28;
-    enable_per_led_msg.on_board_led_6.colorFlags                    = 0x80;
+    enable_per_led_msg.on_board_led_6.colorFlags                    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.on_board_led_7.speedAndBrightnessFlags       = 0x28;
-    enable_per_led_msg.on_board_led_7.colorFlags                    = 0x80;
+    enable_per_led_msg.on_board_led_7.colorFlags                    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.on_board_led_8.speedAndBrightnessFlags       = 0x28;
-    enable_per_led_msg.on_board_led_8.colorFlags                    = 0x80;
+    enable_per_led_msg.on_board_led_8.colorFlags                    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.on_board_led_9.speedAndBrightnessFlags       = 0x28;
-    enable_per_led_msg.on_board_led_9.colorFlags                    = 0x80;
+    enable_per_led_msg.on_board_led_9.colorFlags                    = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
     enable_per_led_msg.j_rgb_2.speedAndBrightnessFlags              = 0x2A;
-    enable_per_led_msg.j_rgb_2.colorFlags                           = 0x80;
-
-    /*-----------------------------------------------------*\
-    | Initialize zone based per LED data                    |
-    \*-----------------------------------------------------*/
-    zone_based_per_led_data.j_rgb_1.speedAndBrightnessFlags         = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.j_rgb_1.colorFlags                     |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.j_pipe_1.speedAndBrightnessFlags        = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.j_pipe_1.colorFlags                    |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.j_pipe_2.speedAndBrightnessFlags        = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.j_pipe_2.colorFlags                    |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.j_rainbow_1.speedAndBrightnessFlags     = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.j_rainbow_1.colorFlags                 |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.j_rainbow_2.speedAndBrightnessFlags     = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.j_rainbow_2.colorFlags                 |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led.speedAndBrightnessFlags    = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led.colorFlags                |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_1.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_1.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_2.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_2.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_3.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_3.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_4.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_4.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_5.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_5.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_6.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_6.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_7.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_7.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_8.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_8.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.on_board_led_9.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.on_board_led_9.colorFlags              |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.j_rgb_2.speedAndBrightnessFlags         = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
-    zone_based_per_led_data.j_rgb_2.colorFlags                     |= MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
-    zone_based_per_led_data.save_data                               = 0;
+    enable_per_led_msg.j_rgb_2.colorFlags                           = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+    enable_per_led_msg.save_data                                    = 0;
 
     direct_mode             = false;
     direct_mode_configured  = false;
@@ -605,11 +592,6 @@ MSIMotherboard185Controller::~MSIMotherboard185Controller()
     hid_close(dev);
 }
 
-bool MSIMotherboard185Controller::GetFirmwareVersionInvalid()
-{
-    return(version_invalid);
-}
-
 void MSIMotherboard185Controller::SetMode
     (
     MSI_ZONE        zone,
@@ -628,7 +610,7 @@ void MSIMotherboard185Controller::SetMode
     | Get the zone data pointer within the configuration    |
     | data buffer                                           |
     \*-----------------------------------------------------*/
-    ZoneData* zone_data = GetZoneData(data, zone);
+    ZoneData* zone_data = GetZoneData(configuration_data, zone);
 
     /*-----------------------------------------------------*\
     | Return if zone is invalid                             |
@@ -644,8 +626,7 @@ void MSIMotherboard185Controller::SetMode
     zone_data->effect                    = mode;
     zone_data->speedAndBrightnessFlags   = ((brightness << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK)
                                          | ((speed << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)           & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
-    zone_data->colorFlags                = (rainbow_color ? (zone_data->colorFlags & ~MSI_COLOR_FLAG_USE_CUSTOM_COLOR)
-                                                          : (zone_data->colorFlags | MSI_COLOR_FLAG_USE_CUSTOM_COLOR));
+    zone_data->colorFlags                = (rainbow_color ? 0 : MSI_COLOR_FLAG_USE_CUSTOM_COLOR);
 
     /*-----------------------------------------------------*\
     | J_RAINBOW_3 zone needs padding of 4                   |
@@ -655,7 +636,7 @@ void MSIMotherboard185Controller::SetMode
     /*-----------------------------------------------------*\
     | Get the zone data pointer to the on-board LED 0 zone  |
     \*-----------------------------------------------------*/
-    ZoneData* on_board_zone = GetZoneData(data, MSI_ZONE_ON_BOARD_LED_0);
+    ZoneData* on_board_zone = GetZoneData(configuration_data, MSI_ZONE_ON_BOARD_LED_0);
 
     /*-----------------------------------------------------*\
     | If the zone is JRGB or JPIPE and the board has no     |
@@ -664,13 +645,11 @@ void MSIMotherboard185Controller::SetMode
     \*-----------------------------------------------------*/
     if(no_onboards && ((zone == MSI_ZONE_J_RGB_1) || (zone == MSI_ZONE_J_RGB_2) || (zone == MSI_ZONE_J_PIPE_1) || (zone == MSI_ZONE_J_PIPE_2)))
     {
-        on_board_zone->effect                   =  zone_data->effect;
-        zone_data->speedAndBrightnessFlags      = ((brightness << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK)
-                                                | ((speed << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)           & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
-        zone_data->colorFlags                   = (rainbow_color ? (zone_data->colorFlags & ~MSI_COLOR_FLAG_USE_CUSTOM_COLOR)
-                                                                 : (zone_data->colorFlags | MSI_COLOR_FLAG_USE_CUSTOM_COLOR));
-        on_board_zone->colorFlags              |= MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD;
-        on_board_zone->padding                  = 0x00;
+        on_board_zone->effect                  = zone_data->effect;
+        on_board_zone->speedAndBrightnessFlags = zone_data->speedAndBrightnessFlags;
+        on_board_zone->colorFlags              = zone_data->colorFlags;
+        on_board_zone->colorFlags             |= MSI_COLOR_FLAG_SYNC_SETTING_ONBOARD;
+        on_board_zone->padding                 = 0x00;
     }
 
     /*-----------------------------------------------------*\
@@ -696,15 +675,14 @@ void MSIMotherboard185Controller::SetMode
     {
         for(int i = 0; i < numof_onboard_leds; ++i)
         {
-            zone_data = GetZoneData(data, (MSI_ZONE)((int)MSI_ZONE_ON_BOARD_LED_1 + i));
+            zone_data = GetZoneData(configuration_data, (MSI_ZONE)((int)MSI_ZONE_ON_BOARD_LED_1 + i));
 
             if(zone_data != nullptr)
             {
                 zone_data->effect                    = mode;
                 zone_data->speedAndBrightnessFlags   = ((brightness << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT) & MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_MASK)
                                                      | ((speed << MSI_SPEED_BRIGHTNESS_FLAG_SPEED_SHIFT)           & MSI_SPEED_BRIGHTNESS_FLAG_SPEED_MASK);
-                zone_data->colorFlags                = (rainbow_color ? (zone_data->colorFlags & ~MSI_COLOR_FLAG_USE_CUSTOM_COLOR)
-                                                                      : (zone_data->colorFlags | MSI_COLOR_FLAG_USE_CUSTOM_COLOR));
+                zone_data->colorFlags                = (rainbow_color ? 0 : MSI_COLOR_FLAG_USE_CUSTOM_COLOR);
                 zone_data->padding                   = 0x00;
             }
         }
@@ -739,12 +717,33 @@ std::string MSIMotherboard185Controller::GetSerial()
     return(StringUtils::wstring_to_string(serial_string));
 }
 
-bool MSIMotherboard185Controller::ReadSettings()
+bool MSIMotherboard185Controller::ReadConfigurationData()
 {
     /*-----------------------------------------------------*\
     | Read packet from hardware, return true if successful  |
     \*-----------------------------------------------------*/
-    return(hid_get_feature_report(dev, (unsigned char*)&data, sizeof(data)) == sizeof data);
+    int ret = hid_get_feature_report(dev, (unsigned char*)&configuration_data, sizeof(configuration_data));
+
+    /*-----------------------------------------------------*\
+    | Log the configuration data in hex at TRACE level      |
+    \*-----------------------------------------------------*/
+    if(LogManager::get()->GetLogLevel() >= LL_TRACE)
+    {
+        LOG_TRACE("[MSIMotherboard185Controller] Read configuration data packet (%zu bytes):", sizeof(configuration_data));
+        for(size_t i = 0; i < sizeof(configuration_data); i += 16)
+        {
+            std::string hex_line = "";
+            for(size_t j = i; j < i + 16 && j < sizeof(configuration_data); j++)
+            {
+                char buf[4];
+                snprintf(buf, sizeof(buf), "%02X ", ((unsigned char*)&configuration_data)[j]);
+                hex_line += buf;
+            }
+            LOG_TRACE("    %04zX: %s", i, hex_line.c_str());
+        }
+    }
+
+    return(ret == sizeof configuration_data);
 }
 
 bool MSIMotherboard185Controller::Update
@@ -825,27 +824,43 @@ bool MSIMotherboard185Controller::Update
         }
         else
         {
-            return(hid_send_feature_report(dev, (unsigned char*)&zone_based_per_led_data, sizeof(zone_based_per_led_data)) == sizeof(zone_based_per_led_data));
+            return(hid_send_feature_report(dev, (unsigned char*)&configuration_data, sizeof(configuration_data)) == sizeof(configuration_data));
         }
     }
     else
     {
         /*-------------------------------------------------*\
-        | Save new state, read current state from board,    |
-        | send old state first, then new state.             |
-        | Windows Mystic Light sends two consecutive        |
-        | reports.                                          |
+        | Set the save flag                                 |
         \*-------------------------------------------------*/
-        FeaturePacket_185 new_data = data;
-        memcpy((unsigned char*)&new_data, (unsigned char*)&data, sizeof(data));
+        configuration_data.save_data = save;
 
-        ReadSettings();
-        data.save_data = save;
-        hid_send_feature_report(dev, (unsigned char*)&data, sizeof(data));
+        /*-------------------------------------------------*\
+        | Save a copy of the new configuration data         |
+        \*-------------------------------------------------*/
+        FeaturePacket_185 new_configuration;
 
-        memcpy((unsigned char*)&data, (unsigned char*)&new_data, sizeof(data));
-        data.save_data = save;
-        return(hid_send_feature_report(dev, (unsigned char*)&data, sizeof(data)) == sizeof(data));
+        memcpy((unsigned char*)&new_configuration, (unsigned char*)&configuration_data, sizeof(configuration_data));
+
+        /*-------------------------------------------------*\
+        | Read the existing configuration data              |
+        \*-------------------------------------------------*/
+        ReadConfigurationData();
+
+        /*-------------------------------------------------*\
+        | First, send a copy of the existing configuration  |
+        | data                                              |
+        \*-------------------------------------------------*/
+        hid_send_feature_report(dev, (unsigned char*)&configuration_data, sizeof(configuration_data));
+
+        /*-------------------------------------------------*\
+        | Second, restore the new configuration data into   |
+        | the buffer and then send it.  MSI software on     |
+        | Windows sends the old data followed by new data   |
+        | so this mimics that flow.                         |
+        \*-------------------------------------------------*/
+        memcpy((unsigned char*)&configuration_data, (unsigned char*)&new_configuration, sizeof(new_configuration));
+
+        return(hid_send_feature_report(dev, (unsigned char*)&configuration_data, sizeof(configuration_data)) == sizeof(configuration_data));
     }
 }
 
@@ -869,7 +884,7 @@ void MSIMotherboard185Controller::SetZoneColor
     | Get the zone data pointer within the configuration    |
     | data buffer                                           |
     \*-----------------------------------------------------*/
-    ZoneData* zone_data = GetZoneData(data, zone);
+    ZoneData* zone_data = GetZoneData(configuration_data, zone);
 
     /*-----------------------------------------------------*\
     | Return if zone is invalid                             |
@@ -896,7 +911,7 @@ void MSIMotherboard185Controller::SetZoneColor
     \*-----------------------------------------------------*/
     if(no_onboards && ((zone == MSI_ZONE_J_RGB_1) || (zone == MSI_ZONE_J_RGB_2) || (zone == MSI_ZONE_J_PIPE_1) || (zone == MSI_ZONE_J_PIPE_2)))
     {
-        ZoneData* on_board_zone = GetZoneData(data, MSI_ZONE_ON_BOARD_LED_0);
+        ZoneData* on_board_zone = GetZoneData(configuration_data, MSI_ZONE_ON_BOARD_LED_0);
 
         on_board_zone->color.R  = red1;
         on_board_zone->color.G  = grn1;
@@ -914,7 +929,7 @@ void MSIMotherboard185Controller::SetZoneColor
     {
         for(int i = 0; i < numof_onboard_leds; ++i)
         {
-            zone_data = GetZoneData(data, (MSI_ZONE)((int)MSI_ZONE_ON_BOARD_LED_1 + i));
+            zone_data = GetZoneData(configuration_data, (MSI_ZONE)((int)MSI_ZONE_ON_BOARD_LED_1 + i));
 
             if(zone_data != nullptr)
             {
@@ -982,17 +997,27 @@ void MSIMotherboard185Controller::SetLedColor
     \*-----------------------------------------------------*/
     else
     {
+        /*-------------------------------------------------*\
+        | The JRAINBOW and JPIPE zones have a single LED    |
+        | each at the RGBController layer, so index must be |
+        | 0.                                                |
+        \*-------------------------------------------------*/
         if(((zone == MSI_ZONE_J_RAINBOW_1) || (zone == MSI_ZONE_J_RAINBOW_2) || (zone == MSI_ZONE_J_PIPE_1) || (zone == MSI_ZONE_J_PIPE_2)) && (index != 0))
         {
             return;
         }
-
+        /*-------------------------------------------------*\
+        | The onboard LEDs are treated as a single zone by  |
+        | the RGBController layer, so LED index is used to  |
+        | select which onboard LED zone in the              |
+        | configuration data to update with the given color.|
+        \*-------------------------------------------------*/
         if(zone >= MSI_ZONE_ON_BOARD_LED_0)
         {
             zone = (MSI_ZONE)((int)zone + index + 1);
         }
 
-        ZoneData *zone_data = GetZoneData(zone_based_per_led_data, zone);
+        ZoneData *zone_data = GetZoneData(configuration_data, zone);
 
         if(zone_data == nullptr)
         {
@@ -1135,11 +1160,11 @@ RainbowZoneData *MSIMotherboard185Controller::GetRainbowZoneData
     switch(zone)
     {
         case MSI_ZONE_J_RAINBOW_1:
-            return &data.j_rainbow_1;
+            return &configuration_data.j_rainbow_1;
         case MSI_ZONE_J_RAINBOW_2:
-            return &data.j_rainbow_2;
+            return &configuration_data.j_rainbow_2;
         case MSI_ZONE_J_RAINBOW_3:
-            return (RainbowZoneData*)&data.j_corsair;
+            return (RainbowZoneData*)&configuration_data.j_corsair;
         case MSI_ZONE_J_CORSAIR:
         default:
             return nullptr;
@@ -1181,8 +1206,6 @@ bool MSIMotherboard185Controller::ReadFwVersion()
     ret_val &= hid_write(dev, request, 64);
     ret_val &= hid_read(dev, response, 64);
 
-    version_APROM_val = response[2];
-
     /*-----------------------------------------------------*\
     | Extract high and low values from response             |
     \*-----------------------------------------------------*/
@@ -1232,14 +1255,14 @@ bool MSIMotherboard185Controller::ReadFwVersion()
 
 MSI_MODE MSIMotherboard185Controller::GetMode()
 {
-    if(data.on_board_led.effect == MSI_DIRECT_MODE)
+    if(configuration_data.on_board_led.effect == MSI_DIRECT_MODE)
     {
         direct_mode = true;
         return MSI_MODE_DIRECT_DUMMY;
     }
     else
     {
-        return (MSI_MODE)data.j_rainbow_1.effect;
+        return (MSI_MODE)configuration_data.j_rainbow_1.effect;
     }
 }
 
@@ -1254,9 +1277,10 @@ void MSIMotherboard185Controller::GetMode
     )
 {
     /*-----------------------------------------------------*\
-    | Get data for given zone                               |
+    | Get the zone data pointer within the configuration    |
+    | data buffer                                           |
     \*-----------------------------------------------------*/
-    ZoneData *zone_data = GetZoneData(data, zone);
+    ZoneData *zone_data = GetZoneData(configuration_data, zone);
 
     /*-----------------------------------------------------*\
     | Return if zone is invalid                             |
@@ -1426,6 +1450,48 @@ bool MSIMotherboard185Controller::SelectPerLedProtocol()
 
     if(direct_mode)
     {
+        /*-------------------------------------------------*\
+        | Initialize configuration data for direct mode.    |
+        | This sets up brightness and color flags for all   |
+        | zones, which is only done when actually entering  |
+        | direct mode to preserve the state read from the   |
+        | controller for normal (non-direct) mode           |
+        | operation.                                        |
+        \*-------------------------------------------------*/
+        configuration_data.j_rgb_1.speedAndBrightnessFlags         = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.j_rgb_1.colorFlags                      = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.j_pipe_1.speedAndBrightnessFlags        = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.j_pipe_1.colorFlags                     = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.j_pipe_2.speedAndBrightnessFlags        = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.j_pipe_2.colorFlags                     = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.j_rainbow_1.speedAndBrightnessFlags     = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.j_rainbow_1.colorFlags                  = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.j_rainbow_2.speedAndBrightnessFlags     = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.j_rainbow_2.colorFlags                  = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.on_board_led.speedAndBrightnessFlags    = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.on_board_led.colorFlags                 = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.on_board_led_1.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.on_board_led_1.colorFlags               = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.on_board_led_2.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.on_board_led_2.colorFlags               = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.on_board_led_3.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.on_board_led_3.colorFlags               = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.on_board_led_4.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.on_board_led_4.colorFlags               = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.on_board_led_5.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.on_board_led_5.colorFlags               = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.on_board_led_6.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.on_board_led_6.colorFlags               = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.on_board_led_7.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.on_board_led_7.colorFlags               = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.on_board_led_8.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.on_board_led_8.colorFlags               = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.on_board_led_9.speedAndBrightnessFlags  = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.on_board_led_9.colorFlags               = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.j_rgb_2.speedAndBrightnessFlags         = MSI_BRIGHTNESS_LEVEL_100 << MSI_SPEED_BRIGHTNESS_FLAG_BRIGHTNESS_SHIFT;
+        configuration_data.j_rgb_2.colorFlags                      = MSI_COLOR_FLAG_USE_CUSTOM_COLOR;
+        configuration_data.save_data                               = 0;
+
         if(per_led_mode == DIRECT_MODE_PER_LED)
         {
             if(hid_send_feature_report(dev, (unsigned char*)&enable_per_led_msg, sizeof(enable_per_led_msg)) != sizeof(enable_per_led_msg))

Controllers/MSIMotherboardController/MSIMotherboard185Controller/MSIMotherboard185Controller.h

@@ -46,7 +46,6 @@ public:
                         );
 
     MSI_MODE        GetMode();
-    bool            GetFirmwareVersionInvalid();
 
     void            GetMode
                         (
@@ -120,16 +119,21 @@ private:
     std::string                     name;
     std::string                     location;
     std::string                     version_APROM;
-    unsigned char                   version_APROM_val;
-    bool                            version_invalid;
     std::string                     version_LDROM;
 
-    FeaturePacket_185               data;
+    /*-----------------------------------------------------*\
+    | Configuration Data, mirrors the configuration block   |
+    | stored in the microcontroller's data flash            |
+    \*-----------------------------------------------------*/
+    FeaturePacket_185               configuration_data;
+
+    /*-----------------------------------------------------*\
+    | Per-LED Direct Mode packet buffers for each zone      |
+    \*-----------------------------------------------------*/
     FeaturePacket_PerLED_185        per_led_data_onboard_and_sync;
     FeaturePacket_PerLED_185        per_led_data_jrainbow1;
     FeaturePacket_PerLED_185        per_led_data_jrainbow2;
     FeaturePacket_PerLED_185        per_led_data_jcorsair;
-    FeaturePacket_185               zone_based_per_led_data;
     bool                            direct_mode;
     bool                            direct_mode_configured;
     bool                            sync_direct_mode;
@@ -145,7 +149,7 @@ private:
     const std::vector<MSI_ZONE>*    supported_zones;
     DIRECT_MODE                     per_led_mode;
 
-    bool            ReadSettings();
+    bool            ReadConfigurationData();
     bool            ReadFwVersion();
     ZoneData*       GetZoneData
                         (
@@ -158,4 +162,6 @@ private:
                         MSI_ZONE zone
                         );
     bool            SelectPerLedProtocol();
+    static bool     IsZoneSupported(MSI_ZONE zone, const std::vector<MSI_ZONE>* supported_zones);
 };
+

Controllers/MSIMotherboardController/MSIMotherboard185Controller/RGBController_MSIMotherboard185.cpp

@@ -119,6 +119,59 @@ int RGBController_MSIMotherboard185::GetDeviceMode()
     return 0;
 }
 
+void RGBController_MSIMotherboard185::SetupModes()
+{
+    constexpr unsigned int COMMON       = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE;
+    constexpr unsigned int MODE_SPECIFIC_ONLY = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
+    constexpr unsigned int RANDOM_ONLY  = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE;
+
+    if(controller->GetSupportedDirectMode() != MSIMotherboard185Controller::DIRECT_MODE_DISABLED)
+    {
+        SetupMode("Direct",                 MSI_MODE_DIRECT_DUMMY,                  MODE_FLAG_HAS_PER_LED_COLOR);
+    }
+
+    SetupMode("Static",                     MSI_MODE_STATIC,                        MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE);
+    // SetupMode("Off",                        MSI_MODE_DISABLE,                       0);
+    SetupMode("Breathing",                  MSI_MODE_BREATHING,                     MODE_SPECIFIC_ONLY);
+    SetupMode("Flashing",                   MSI_MODE_FLASHING,                      COMMON);
+    SetupMode("Double flashing",            MSI_MODE_DOUBLE_FLASHING,               COMMON);
+    SetupMode("Lightning",                  MSI_MODE_LIGHTNING,                     MODE_SPECIFIC_ONLY);
+    // SetupMode("MSI Marquee",                MSI_MODE_MSI_MARQUEE,                   COMMON);
+    SetupMode("Meteor",                     MSI_MODE_METEOR,                        COMMON);
+    // SetupMode("Water drop",                 MSI_MODE_WATER_DROP,                    COMMON);
+    // SetupMode("MSI Rainbow",                MSI_MODE_MSI_RAINBOW,                   RANDOM_ONLY);
+    // SetupMode("Pop",                        MSI_MODE_POP,                           COMMON);
+    // SetupMode("Rap",                        MSI_MODE_RAP,                           COMMON);
+    // SetupMode("Jazz",                       MSI_MODE_JAZZ,                          COMMON);
+    // SetupMode("Play",                       MSI_MODE_PLAY,                          COMMON);
+    // SetupMode("Movie",                      MSI_MODE_MOVIE,                         COMMON);
+    SetupMode("Color ring",                 MSI_MODE_COLOR_RING,                    RANDOM_ONLY);
+    SetupMode("Planetary",                  MSI_MODE_PLANETARY,                     RANDOM_ONLY);
+    SetupMode("Double meteor",              MSI_MODE_DOUBLE_METEOR,                 RANDOM_ONLY);
+    SetupMode("Energy",                     MSI_MODE_ENERGY,                        RANDOM_ONLY);
+    SetupMode("Blink",                      MSI_MODE_BLINK,                         COMMON);
+    SetupMode("Clock",                      MSI_MODE_CLOCK,                         RANDOM_ONLY);
+    SetupMode("Color pulse",                MSI_MODE_COLOR_PULSE,                   COMMON);
+    SetupMode("Color shift",                MSI_MODE_COLOR_SHIFT,                   RANDOM_ONLY);
+    SetupMode("Color wave",                 MSI_MODE_COLOR_WAVE,                    COMMON);
+    SetupMode("Marquee",                    MSI_MODE_MARQUEE,                       MODE_SPECIFIC_ONLY);
+    // SetupMode("Rainbow",                    MSI_MODE_RAINBOW,                       COMMON);
+    SetupMode("Rainbow wave",               MSI_MODE_RAINBOW_WAVE,                  RANDOM_ONLY);
+    SetupMode("Visor",                      MSI_MODE_VISOR,                         COMMON);
+    // SetupMode("JRainbow",                   MSI_MODE_JRAINBOW,                      COMMON);
+    SetupMode("Rainbow flashing",           MSI_MODE_RAINBOW_FLASHING,              RANDOM_ONLY);
+    // SetupMode("Rainbow double flashing",    MSI_MODE_RAINBOW_DOUBLE_FLASHING,       COMMON);
+    // SetupMode("Random",                     MSI_MODE_RANDOM,                        COMMON);
+    // SetupMode("Fan control",                MSI_MODE_FAN_CONTROL,                   COMMON);
+    // SetupMode("Off 2",                      MSI_MODE_DISABLE_2,                     COMMON);
+    // SetupMode("Color ring flashing",        MSI_MODE_COLOR_RING_FLASHING,           COMMON);
+    SetupMode("Color ring double flashing", MSI_MODE_COLOR_RING_DOUBLE_FLASHING,    RANDOM_ONLY);
+    SetupMode("Stack",                      MSI_MODE_STACK,                         COMMON);
+    // SetupMode("Corsair Que",                MSI_MODE_CORSAIR_QUE,                   COMMON);
+    SetupMode("Fire",                       MSI_MODE_FIRE,                          RANDOM_ONLY);
+    // SetupMode("Lava",                       MSI_MODE_LAVA,                          COMMON);
+}
+
 void RGBController_MSIMotherboard185::SetupZones()
 {
     /*-----------------------------------------------------*\
@@ -279,7 +332,8 @@ void RGBController_MSIMotherboard185::DeviceUpdateLEDs()
             UpdateLed((int)zone_idx, led_idx);
         }
     }
-    controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
+
+    controller->Update(false);
 }
 
 void RGBController_MSIMotherboard185::DeviceUpdateZoneLEDs(int zone)
@@ -293,7 +347,8 @@ void RGBController_MSIMotherboard185::DeviceUpdateZoneLEDs(int zone)
     {
         UpdateLed(zone, led_idx);
     }
-    controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
+
+    controller->Update(false);
 }
 
 void RGBController_MSIMotherboard185::DeviceUpdateSingleLED
@@ -316,7 +371,8 @@ void RGBController_MSIMotherboard185::DeviceUpdateSingleLED
 
     int led_index = led - zones[zone_index].start_idx;
     UpdateLed(zone_index, led_index);
-    controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
+
+    controller->Update(false);
 }
 
 void RGBController_MSIMotherboard185::DeviceUpdateMode()
@@ -328,8 +384,40 @@ void RGBController_MSIMotherboard185::DeviceUpdateMode()
     else
     {
         controller->SetDirectMode(false);
-        DeviceUpdateLEDs();
+
+        /*-------------------------------------------------*\
+        | Set mode configuration for all zones              |
+        \*-------------------------------------------------*/
+        for(std::size_t zone_idx = 0; zone_idx < zones.size(); ++zone_idx)
+        {
+            if(zones[zone_idx].leds_count > 0)
+            {
+                bool           random     = modes[active_mode].color_mode == MODE_COLORS_RANDOM;
+                MSI_MODE       mode       = (MSI_MODE)modes[active_mode].value;
+                MSI_SPEED      speed      = (MSI_SPEED)modes[active_mode].speed;
+                MSI_BRIGHTNESS brightness = (MSI_BRIGHTNESS)modes[active_mode].brightness;
+
+                controller->SetMode((MSI_ZONE)zones[zone_idx].leds[0].value, mode, speed, brightness, random);
+
+                /*-----------------------------------------*\
+                | Set mode-specific colors if available     |
+                \*-----------------------------------------*/
+                if(modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
+                {
+                    unsigned char red = 0, grn = 0, blu = 0;
+                    if(modes[active_mode].colors.size() > 0)
+                    {
+                        red = RGBGetRValue(modes[active_mode].colors[0]);
+                        grn = RGBGetGValue(modes[active_mode].colors[0]);
+                        blu = RGBGetBValue(modes[active_mode].colors[0]);
+                    }
+                    controller->SetZoneColor((MSI_ZONE)zones[zone_idx].leds[0].value, red, grn, blu, red, grn, blu);
+                }
+            }
+        }
     }
+
+    controller->Update(false);
 }
 
 void RGBController_MSIMotherboard185::DeviceSaveMode()
@@ -337,59 +425,6 @@ void RGBController_MSIMotherboard185::DeviceSaveMode()
     controller->Update(true);
 }
 
-void RGBController_MSIMotherboard185::SetupModes()
-{
-    constexpr unsigned int PER_LED_ONLY = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
-    constexpr unsigned int RANDOM_ONLY  = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE;
-    constexpr unsigned int COMMON       = RANDOM_ONLY | MODE_FLAG_HAS_PER_LED_COLOR;
-
-    if(controller->GetSupportedDirectMode() != MSIMotherboard185Controller::DIRECT_MODE_DISABLED)
-    {
-        SetupMode("Direct",                 MSI_MODE_DIRECT_DUMMY,                  MODE_FLAG_HAS_PER_LED_COLOR);
-    }
-
-    SetupMode("Static",                     MSI_MODE_STATIC,                        MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE);
-    // SetupMode("Off",                        MSI_MODE_DISABLE,                       0);
-    SetupMode("Breathing",                  MSI_MODE_BREATHING,                     PER_LED_ONLY);
-    SetupMode("Flashing",                   MSI_MODE_FLASHING,                      COMMON);
-    SetupMode("Double flashing",            MSI_MODE_DOUBLE_FLASHING,               COMMON);
-    SetupMode("Lightning",                  MSI_MODE_LIGHTNING,                     PER_LED_ONLY);
-    // SetupMode("MSI Marquee",                MSI_MODE_MSI_MARQUEE,                   COMMON);
-    SetupMode("Meteor",                     MSI_MODE_METEOR,                        COMMON);
-    // SetupMode("Water drop",                 MSI_MODE_WATER_DROP,                    COMMON);
-    // SetupMode("MSI Rainbow",                MSI_MODE_MSI_RAINBOW,                   RANDOM_ONLY);
-    // SetupMode("Pop",                        MSI_MODE_POP,                           COMMON);
-    // SetupMode("Rap",                        MSI_MODE_RAP,                           COMMON);
-    // SetupMode("Jazz",                       MSI_MODE_JAZZ,                          COMMON);
-    // SetupMode("Play",                       MSI_MODE_PLAY,                          COMMON);
-    // SetupMode("Movie",                      MSI_MODE_MOVIE,                         COMMON);
-    SetupMode("Color ring",                 MSI_MODE_COLOR_RING,                    RANDOM_ONLY);
-    SetupMode("Planetary",                  MSI_MODE_PLANETARY,                     RANDOM_ONLY);
-    SetupMode("Double meteor",              MSI_MODE_DOUBLE_METEOR,                 RANDOM_ONLY);
-    SetupMode("Energy",                     MSI_MODE_ENERGY,                        RANDOM_ONLY);
-    SetupMode("Blink",                      MSI_MODE_BLINK,                         COMMON);
-    SetupMode("Clock",                      MSI_MODE_CLOCK,                         RANDOM_ONLY);
-    SetupMode("Color pulse",                MSI_MODE_COLOR_PULSE,                   COMMON);
-    SetupMode("Color shift",                MSI_MODE_COLOR_SHIFT,                   RANDOM_ONLY);
-    SetupMode("Color wave",                 MSI_MODE_COLOR_WAVE,                    COMMON);
-    SetupMode("Marquee",                    MSI_MODE_MARQUEE,                       PER_LED_ONLY);
-    // SetupMode("Rainbow",                    MSI_MODE_RAINBOW,                       COMMON);
-    SetupMode("Rainbow wave",               MSI_MODE_RAINBOW_WAVE,                  RANDOM_ONLY);
-    SetupMode("Visor",                      MSI_MODE_VISOR,                         COMMON);
-    // SetupMode("JRainbow",                   MSI_MODE_JRAINBOW,                      COMMON);
-    SetupMode("Rainbow flashing",           MSI_MODE_RAINBOW_FLASHING,              RANDOM_ONLY);
-    // SetupMode("Rainbow double flashing",    MSI_MODE_RAINBOW_DOUBLE_FLASHING,       COMMON);
-    // SetupMode("Random",                     MSI_MODE_RANDOM,                        COMMON);
-    // SetupMode("Fan control",                MSI_MODE_FAN_CONTROL,                   COMMON);
-    // SetupMode("Off 2",                      MSI_MODE_DISABLE_2,                     COMMON);
-    // SetupMode("Color ring flashing",        MSI_MODE_COLOR_RING_FLASHING,           COMMON);
-    SetupMode("Color ring double flashing", MSI_MODE_COLOR_RING_DOUBLE_FLASHING,    RANDOM_ONLY);
-    SetupMode("Stack",                      MSI_MODE_STACK,                         COMMON);
-    // SetupMode("Corsair Que",                MSI_MODE_CORSAIR_QUE,                   COMMON);
-    SetupMode("Fire",                       MSI_MODE_FIRE,                          RANDOM_ONLY);
-    // SetupMode("Lava",                       MSI_MODE_LAVA,                          COMMON);
-}
-
 void RGBController_MSIMotherboard185::UpdateLed
     (
     int zone,
@@ -404,19 +439,6 @@ void RGBController_MSIMotherboard185::UpdateLed
     {
         controller->SetLedColor((MSI_ZONE)(zones[zone].leds[led].value), led, red, grn, blu);
     }
-    else
-    {
-        if(led == 0)
-        {
-            bool           random     = modes[active_mode].color_mode == MODE_COLORS_RANDOM;
-            MSI_MODE       mode       = (MSI_MODE)modes[active_mode].value;
-            MSI_SPEED      speed      = (MSI_SPEED)modes[active_mode].speed;
-            MSI_BRIGHTNESS brightness = (MSI_BRIGHTNESS)modes[active_mode].brightness;
-
-            controller->SetMode((MSI_ZONE)zones[zone].leds[led].value, mode, speed, brightness, random);
-            controller->SetZoneColor((MSI_ZONE)zones[zone].leds[led].value, red, grn, blu, red, grn, blu);
-        }
-    }
 }
 
 void RGBController_MSIMotherboard185::SetupMode
@@ -435,6 +457,14 @@ void RGBController_MSIMotherboard185::SetupMode
     {
         Mode.color_mode = MODE_COLORS_PER_LED;
     }
+    else if(flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
+    {
+        Mode.color_mode = MODE_COLORS_MODE_SPECIFIC;
+        Mode.colors_min = 1;
+        Mode.colors_max = 1;
+        Mode.colors.resize(1);
+        Mode.colors[0]  = ToRGBColor(255, 255, 255);
+    }
     else
     {
         Mode.color_mode = MODE_COLORS_RANDOM;
@@ -512,19 +542,24 @@ void RGBController_MSIMotherboard185::GetDeviceConfig()
                 {
                    modes[i].brightness = brightness;
                 }
-                if(rainbow)
+                if(modes[i].flags & (MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR))
                 {
-                    if(modes[i].flags & (MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR))
+                    if(rainbow && (modes[i].flags & MODE_FLAG_HAS_RANDOM_COLOR))
                     {
-                        if(rainbow)
+                        modes[i].color_mode = MODE_COLORS_RANDOM;
+                    }
+                    else if(modes[i].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
+                    {
+                        modes[i].color_mode = MODE_COLORS_MODE_SPECIFIC;
+                        if(modes[i].colors.size() > 0)
                         {
-                            modes[i].color_mode = MODE_COLORS_RANDOM;
-                        }
-                        else
-                        {
-                            modes[i].color_mode = MODE_COLORS_PER_LED;
+                            modes[i].colors[0] = color;
                         }
                     }
+                    else
+                    {
+                        modes[i].color_mode = MODE_COLORS_PER_LED;
+                    }
                 }
                 break;
             }

Controllers/MSIMotherboardController/MSIMotherboard761Controller/MSIMotherboard761Controller.cpp

@@ -72,15 +72,10 @@ static const std::string board_names[] =
     "MSI MAG B850 TOMAHAWK WIFI (MS-7E53)",
     "MSI MEG Z890 UNIFY-X (MS-7E20)",
     "MSI PRO X870E-S EVO WIFI (MS-7E86)",
-    "MSI MAG X870E GAMING MAX WIFI (MS-7E86)",
     "MSI PRO Z890-P WIFI (MS-7E34)",
     "MSI B850 GAMING PLUS WIFI PZ (MS-7E75)",
     "MSI MAG X870E TOMAHAWK MAX WIFI PZ (MS-7E84)",
     "MSI PRO B850M-A WIFI PZ (MS-7E78)",
-    "MSI B850MPOWER (MS-7E83)",
-    "MSI B840M GAMING WIFI6E (MS-7E76)",
-    "MSI PRO B850M-A WIFI (MS-7E66)",
-    "MSI PRO B850-S WIFI6E (MS-7E80)"
 };
 
 static const mystic_light_761_config board_configs[] =
@@ -110,15 +105,10 @@ static const mystic_light_761_config board_configs[] =
     { &(board_names[22]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MAG B850 TOMAHAWK WIFI (MS-7E53)
     { &(board_names[23]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MEG Z890 UNIFY-X (MS-7E20)
     { &(board_names[24]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO X870E-S EVO WIFI (MS-7E86)
-    { &(board_names[25]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MAG X870E GAMING MAX WIFI (MS-7E86)
-    { &(board_names[26]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO Z890-P WIFI (MS-7E34)
-    { &(board_names[27]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI B850 GAMING PLUS WIFI PZ (MS-7E75)
-    { &(board_names[28]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MAG X870E TOMAHAWK MAX WIFI PZ (MS-7E84)
-    { &(board_names[29]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO B850M-A WIFI PZ (MS-7E78)
-    { &(board_names[30]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI B850MPOWER (MS-7E83)
-    { &(board_names[31]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI B840M GAMING WIFI6E (MS-7E76)
-    { &(board_names[32]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO B850M-A WIFI (MS-7E66)
-    { &(board_names[33]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO B850-S WIFI6E (MS-7E80)
+    { &(board_names[25]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO Z890-P WIFI (MS-7E34)
+    { &(board_names[26]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI B850 GAMING PLUS WIFI PZ (MS-7E75)
+    { &(board_names[27]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MAG X870E TOMAHAWK MAX WIFI PZ (MS-7E84)
+    { &(board_names[28]), 0,  0,  0, 1, &zone_set1,  MSIMotherboard761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO B850M-A WIFI PZ (MS-7E78)
 };
 
 enum MSI_ZONE setup_map [] =

Controllers/MSIMotherboardController/MSIMotherboardControllerDetect.cpp

@@ -54,17 +54,9 @@ DetectedControllers DetectMSIMotherboardControllers(hid_device_info* info, const
         if((packet_length >= sizeof(FeaturePacket_185)) && (packet_length <= (sizeof(FeaturePacket_185) + 1)))  //WHY r we doing this ? why not ==
         {
             MSIMotherboard185Controller*     controller     = new MSIMotherboard185Controller(dev, info->path, info->product_id, dmi_name);
+            RGBController_MSIMotherboard185* rgb_controller = new RGBController_MSIMotherboard185(controller);
 
-            if(controller->GetFirmwareVersionInvalid())
-            {
-                LOG_WARNING("[MSIMotherboard185] Controller firmware below minimum supported version, skipping");
-            }
-            else
-            {
-                RGBController_MSIMotherboard185* rgb_controller = new RGBController_MSIMotherboard185(controller);
-
-                detected_controllers.push_back(rgb_controller);
-            }
+            detected_controllers.push_back(rgb_controller);
         }
         else if((packet_length >= sizeof(FeaturePacket_162)) && (packet_length <= (sizeof(FeaturePacket_162) + 1)))
         {
@@ -231,12 +223,9 @@ REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E70",    DetectMSIMotherboardCont
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E59",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E59,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E80",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E80,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E81",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E81,   0x0001, 0x00);
-REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E86",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E86,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E34",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E34,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E32",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E32,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E20",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E20,   0x0001, 0x00);
-REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E76",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E76,   0x0001, 0x00);
-REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E66",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x7E66,   0x0001, 0x00);
 // Detector for the set of common boards
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light Common",     DetectMSIMotherboardControllers,   MSI_USB_VID_COMMON,  MSI_USB_PID_COMMON, 0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light X870",       DetectMSIMotherboardControllers,   MSI_USB_VID_COMMON,  MSI_USB_PID_COMMON, 0xFF00, 0x01);
@@ -247,7 +236,6 @@ REGISTER_CUSTOM_UDEV_RULE(msi_7e24, "MSI Mystic Light MS_7E24", "SUBSYSTEMS==\"u
 REGISTER_CUSTOM_UDEV_RULE(msi_7e26, "MSI Mystic Light MS_7E26", "SUBSYSTEMS==\"usb|hidraw\", ATTRS{idVendor}==\"1462\", ATTRS{idProduct}==\"7e26\", TAG+=\"uaccess\", TAG+=\"MSI_Mystic_Light_MS_7E26\"");
 REGISTER_CUSTOM_UDEV_RULE(msi_7e27, "MSI Mystic Light MS_7E27", "SUBSYSTEMS==\"usb|hidraw\", ATTRS{idVendor}==\"1462\", ATTRS{idProduct}==\"7e27\", TAG+=\"uaccess\", TAG+=\"MSI_Mystic_Light_MS_7E27\"");
 REGISTER_CUSTOM_UDEV_RULE(msi_7e49, "MSI Mystic Light MS_7E49", "SUBSYSTEMS==\"usb|hidraw\", ATTRS{idVendor}==\"1462\", ATTRS{idProduct}==\"7e49\", TAG+=\"uaccess\", TAG+=\"MSI_Mystic_Light_MS_7E49\"");
-REGISTER_CUSTOM_UDEV_RULE(msi_7e76, "MSI Mystic Light MS_7E76", "SUBSYSTEMS==\"usb|hidraw\", ATTRS{idVendor}==\"1462\", ATTRS{idProduct}==\"7e76\", TAG+=\"uaccess\", TAG+=\"MSI_Mystic_Light_MS_7E76\"");
 
 #ifdef ENABLE_UNTESTED_MYSTIC_LIGHT
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_3EA4",    DetectMSIMotherboardControllers,   MSI_USB_VID,    0x3EA4,   0x0001, 0x00);

Controllers/NVIDIAIlluminationController/NVIDIAIlluminationControllerDetect_Windows_Linux.cpp

@@ -56,7 +56,6 @@ static const nv_gpu_pci_device device_list[] =
     {NVIDIA_VEN,    NVIDIA_RTX3060_8G_DEV,          NVIDIA_SUB_VEN,   NVIDIA_RTX3060_8G_DEV,                          NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Gainward GeForce RTX 3060 Pegasus"           },
     {NVIDIA_VEN,    NVIDIA_RTX3060_LHR_DEV,         NVIDIA_SUB_VEN,   NVIDIA_RTX3060_LHR_DEV,                         NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Palit GeForce RTX 3060 LHR"                  },
     {NVIDIA_VEN,    NVIDIA_RTX3060_LHR_DEV,         PNY_SUB_VEN,      PNY_RTX_3060_XLR8_REVEL_EPIC_X_SUB_DEV,         NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY GeForce RTX 3060 XLR8 REVEL EPIC-X"      },
-    {NVIDIA_VEN,    NVIDIA_RTX3060_LHR_DEV,         PNY_SUB_VEN,      PNY_RTX_3060_XLR8_REVEL_EPIC_X_LHR_SUB_DEV,     NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY GeForce RTX 3060 XLR8 REVEL EPIC-X LHR"  },
     {NVIDIA_VEN,    NVIDIA_RTX3060_GA104_DEV,       PNY_SUB_VEN,      PNY_RTX_3060_XLR8_REVEL_EPIC_X_SUB_DEV,         NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY GeForce RTX 3060 XLR8 REVEL EPIC-X"      },
     {NVIDIA_VEN,    NVIDIA_RTX3060_GA104_DEV,       NVIDIA_SUB_VEN,   NVIDIA_RTX3060_GA104_DEV,                       NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Palit GeForce RTX 3060 LHR"                  },
     {NVIDIA_VEN,    NVIDIA_RTX3060TI_LHR_DEV,       PNY_SUB_VEN,      PNY_RTX_3060TI_XLR8_REVEL_EPIC_X_SUB_DEV,       NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY GeForce RTX 3060 Ti XLR8 REVEL EPIC-X"   },

Controllers/PNYARGBEpicXGPUController/PNYARGBEpicXGPUControllerDetect.cpp

@@ -47,10 +47,9 @@ DetectedControllers DetectPNYARGBEpicXGPULargeControllers(i2c_smbus_interface* b
     return(detected_controllers);
 }
 
-REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 5060Ti ARGB Epic-X OC", DetectPNYARGBEpicXGPUSmallControllers, NVIDIA_VEN, NVIDIA_RTX5060TI_DEV, PNY_SUB_VEN, PNY_RTX_5060TI_ARGB_EPIC_X_OC_SUB_DEV,     0x60);
-REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 5070 ARGB Epic-X OC",   DetectPNYARGBEpicXGPUSmallControllers, NVIDIA_VEN, NVIDIA_RTX5070_DEV,   PNY_SUB_VEN, PNY_RTX_5070_ARGB_EPIC_X_OC_SUB_DEV,       0x60);
-REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 5070Ti ARGB Epic-X",    DetectPNYARGBEpicXGPUSmallControllers, NVIDIA_VEN, NVIDIA_RTX5070TI_DEV, PNY_SUB_VEN, PNY_RTX_5070TI_ARGB_EPIC_X_SUB_DEV,        0x60);
-REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 5070Ti ARGB Epic-X OC", DetectPNYARGBEpicXGPUSmallControllers, NVIDIA_VEN, NVIDIA_RTX5070TI_DEV, PNY_SUB_VEN, PNY_RTX_5070TI_ARGB_EPIC_X_OC_SUB_DEV,     0x60);
-REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 5070Ti ARGB Epic-X OC", DetectPNYARGBEpicXGPUSmallControllers, NVIDIA_VEN, NVIDIA_RTX5070TI_DEV, PNY_SUB_VEN, PNY_RTX_5070TI_ARGB_EPIC_X_OC_SUB_DEV2,    0x60);
-REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 5080 ARGB Epic-X OC",   DetectPNYARGBEpicXGPULargeControllers, NVIDIA_VEN, NVIDIA_RTX5080_DEV,   PNY_SUB_VEN, PNY_RTX_5080_ARGB_EPIC_X_OC_SUB_DEV,       0x60);
-REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 5090 ARGB Epic-X OC",   DetectPNYARGBEpicXGPULargeControllers, NVIDIA_VEN, NVIDIA_RTX5090_DEV,   PNY_SUB_VEN, PNY_RTX_5090_ARGB_EPIC_X_OC_SUB_DEV,       0x60);
+REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 5060Ti ARGB Epic-X OC", DetectPNYARGBEpicXGPUSmallControllers, NVIDIA_VEN, NVIDIA_RTX5060TI_DEV, PNY_SUB_VEN, PNY_RTX_5060TI_ARGB_EPIC_X_OC_SUB_DEV, 0x60);
+REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 5070 ARGB Epic-X OC",   DetectPNYARGBEpicXGPUSmallControllers, NVIDIA_VEN, NVIDIA_RTX5070_DEV,   PNY_SUB_VEN, PNY_RTX_5070_ARGB_EPIC_X_OC_SUB_DEV,   0x60);
+REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 5070Ti ARGB Epic-X",    DetectPNYARGBEpicXGPUSmallControllers, NVIDIA_VEN, NVIDIA_RTX5070TI_DEV, PNY_SUB_VEN, PNY_RTX_5070TI_ARGB_EPIC_X_SUB_DEV,    0x60);
+REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 5070Ti ARGB Epic-X OC", DetectPNYARGBEpicXGPUSmallControllers, NVIDIA_VEN, NVIDIA_RTX5070TI_DEV, PNY_SUB_VEN, PNY_RTX_5070TI_ARGB_EPIC_X_OC_SUB_DEV, 0x60);
+REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 5080 ARGB Epic-X OC",   DetectPNYARGBEpicXGPULargeControllers, NVIDIA_VEN, NVIDIA_RTX5080_DEV,   PNY_SUB_VEN, PNY_RTX_5080_ARGB_EPIC_X_OC_SUB_DEV,   0x60);
+REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 5090 ARGB Epic-X OC",   DetectPNYARGBEpicXGPULargeControllers, NVIDIA_VEN, NVIDIA_RTX5090_DEV,   PNY_SUB_VEN, PNY_RTX_5090_ARGB_EPIC_X_OC_SUB_DEV,   0x60);

Controllers/PNYGPUController/PNYGPUController.cpp

@@ -0,0 +1,112 @@
+/*---------------------------------------------------------*\
+| PNYGPUController.cpp                                      |
+|                                                           |
+|   Driver for PNY Turing GPU                               |
+|                                                           |
+|   KendallMorgan                               17 Oct 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "PNYGPUController.h"
+
+PNYGPUController::PNYGPUController(i2c_smbus_interface* bus, pny_dev_id dev, std::string name)
+{
+    this->bus   = bus;
+    this->dev   = dev;
+    this->name  = name;
+}
+
+PNYGPUController::~PNYGPUController()
+{
+
+}
+
+std::string PNYGPUController::GetDeviceName()
+{
+    return(name);
+}
+
+std::string PNYGPUController::GetDeviceLocation()
+{
+    std::string return_string(bus->info.device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+void PNYGPUController::WriteI2CData(u8 command, u8 length, u8* data)
+{
+    //Simulating i2c_smbus_write_i2c_block_data(command, length, data);
+    for (u8 i = 0; i < length; i++)
+    {
+        bus->i2c_smbus_write_byte_data(dev, command+i, data[i]);
+    }
+}
+
+unsigned char PNYGPUController::GetMode()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, PNY_GPU_MODE_OFF));
+}
+
+unsigned char PNYGPUController::GetRed()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, PNY_GPU_REG_COLOR_RED));
+}
+
+unsigned char PNYGPUController::GetGreen()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, PNY_GPU_REG_COLOR_GREEN));
+}
+
+unsigned char PNYGPUController::GetBlue()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, PNY_GPU_REG_COLOR_BLUE));
+}
+
+void PNYGPUController::SetOff()
+{
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_CONTROL,                0);
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_MODE,                   0x00);
+}
+
+void PNYGPUController::SetCycle(unsigned char speed)
+{
+    u8 loop[] = {
+        0x01,  // Direction
+        0x00,  // ??
+        speed, // Speed
+        0x1F   // Somehow related to speed
+    };
+    loop[2] = speed;
+    WriteI2CData(PNY_GPU_REG_CONTROL, sizeof(loop), loop);
+}
+
+void PNYGPUController::SetStrobe(unsigned char r, unsigned char g, unsigned char b, unsigned char speed, unsigned char brightness)
+{
+    u8 strobe[] = {
+        0x02,       // Strobe
+        0x00,       // Rise speed
+        speed,      // Cycle length/2
+        0x00,       // Off delay
+        r,          // R
+        g,          // G
+        b,          // B
+        brightness, // Peak brightness
+        0x05        // Fade speed
+    };
+    WriteI2CData(PNY_GPU_REG_CONTROL, sizeof(strobe), strobe);
+}
+
+void PNYGPUController::SetDirect(unsigned char red, unsigned char green, unsigned char blue, unsigned char brightness)
+{
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_CONTROL,                0);
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_MODE,                   0x01);
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_COLOR_RED,              red);
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_COLOR_BLUE,             blue);
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_COLOR_GREEN,            green);
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_COLOR_BRIGHTNESS,       brightness);
+}

Controllers/PNYGPUController/PNYGPUController.h

@@ -0,0 +1,62 @@
+/*---------------------------------------------------------*\
+| PNYGPUController.h                                        |
+|                                                           |
+|   Driver for PNY Turing GPU                               |
+|                                                           |
+|   KendallMorgan                               17 Oct 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include "i2c_smbus.h"
+
+typedef unsigned char   pny_dev_id;
+
+enum
+{
+    PNY_GPU_REG_CONTROL                 = 0xE0,
+    PNY_GPU_REG_MODE                    = 0x60,
+    PNY_GPU_REG_COLOR_RED               = 0x6C,
+    PNY_GPU_REG_COLOR_GREEN             = 0x6D,
+    PNY_GPU_REG_COLOR_BLUE              = 0x6E,
+    PNY_GPU_REG_COLOR_BRIGHTNESS        = 0x6F,
+};
+
+enum
+{
+    PNY_GPU_MODE_OFF                    = 0x00,
+    PNY_GPU_MODE_DIRECT                 = 0x01,
+    PNY_GPU_MODE_CYCLE                  = 0x02,
+    PNY_GPU_MODE_STROBE                 = 0x03,
+};
+
+class PNYGPUController
+{
+public:
+	PNYGPUController(i2c_smbus_interface* bus, pny_dev_id dev, std::string name);
+	~PNYGPUController();
+
+    std::string     GetDeviceName();
+	std::string     GetDeviceLocation();
+
+    void SetOff();
+    void SetCycle(unsigned char speed);
+    void SetStrobe(unsigned char r, unsigned char g, unsigned char b, unsigned char speed, unsigned char brightness);
+    void SetDirect(unsigned char red, unsigned char green, unsigned char blue, unsigned char brightness);
+
+private:
+	i2c_smbus_interface*    bus;
+	pny_dev_id              dev;
+    std::string             name;
+
+    void            WriteI2CData(u8 command, u8 length, u8* data);
+    unsigned char   GetMode();
+    unsigned char   GetRed();
+    unsigned char   GetGreen();
+    unsigned char   GetBlue();
+
+};

Controllers/PNYGPUController/PNYGPUControllerDetect.cpp

@@ -0,0 +1,76 @@
+/*---------------------------------------------------------*\
+| PNYGPUControllerDetect.cpp                                |
+|                                                           |
+|   Detector for PNY Turing GPU                             |
+|                                                           |
+|   KendallMorgan                               17 Oct 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "DetectionManager.h"
+#include "i2c_smbus.h"
+#include "pci_ids.h"
+#include "PNYGPUController.h"
+#include "RGBController_PNYGPU.h"
+
+DetectedControllers DetectPNYGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+
+    if(bus->info.port_id == 1)
+    {
+        PNYGPUController*     controller        = new PNYGPUController(bus, i2c_addr, name);
+        RGBController_PNYGPU* rgb_controller    = new RGBController_PNYGPU(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 2060 XLR8 OC EDITION",       DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX2060_TU104_DEV,   PNY_SUB_VEN,    PNY_RTX_2060_XLR8_OC_SUB_DEV,               0x49);
+REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 3060 XLR8 Revel EPIC-X",     DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3060_DEV,         PNY_SUB_VEN,    PNY_RTX_3060_XLR8_REVEL_EPIC_X_SUB_DEV,     0x49);
+REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 3070 XLR8 Revel EPIC-X",     DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3070_DEV,         PNY_SUB_VEN,    PNY_RTX_3070_XLR8_REVEL_EPIC_X_SUB_DEV,     0x49);
+REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 3070 XLR8 Revel EPIC-X LHR", DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     PNY_SUB_VEN,    PNY_RTX_3070_XLR8_REVEL_EPIC_X_LHR_SUB_DEV, 0x49);
+REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 3080 XLR8 Revel EPIC-X",     DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3080_DEV,         PNY_SUB_VEN,    PNY_RTX_3080_XLR8_REVEL_EPIC_X_SUB_DEV,     0x49);
+REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 3080 Ti XLR8 Revel EPIC-X",  DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       PNY_SUB_VEN,    PNY_RTX_3080TI_XLR8_REVEL_EPIC_X_SUB_DEV,   0x49);
+REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 3090 XLR8 Revel EPIC-X",     DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3090_DEV,         PNY_SUB_VEN,    PNY_RTX_3090_XLR8_REVEL_EPIC_X_SUB_DEV,     0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 2070 SUPER Jetstream",     DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,     NVIDIA_SUB_VEN, NVIDIA_RTX2070S_OC_DEV,                     0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3060",                     DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3060_DEV,         PALIT_SUB_VEN,  PALIT_RTX3060_SUB_DEV,                      0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3060 LHR",                 DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     PALIT_SUB_VEN,  PALIT_RTX3060_LHR_SUB_DEV,                  0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3060 Ti",                  DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3060TI_DEV,       PALIT_SUB_VEN,  PALIT_RTX3060TI_SUB_DEV,                    0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3060 Ti LHR",              DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,   PALIT_SUB_VEN,  NVIDIA_RTX3060TI_LHR_DEV,                   0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3060 Ti Dual",             DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3060TI_DEV,       NVIDIA_SUB_VEN, PALIT_RTX3060TI_SUB_DEV,                    0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3070",                     DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3070_DEV,         PALIT_SUB_VEN,  PALIT_RTX3070_SUB_DEV,                      0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3070 LHR",                 DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     PALIT_SUB_VEN,  PALIT_RTX3070_LHR_SUB_DEV,                  0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3070 Gamerock LHR",        DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     PALIT_SUB_VEN,  PALIT_RTX3070_GAMEROCK_SUB_DEV,             0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3070 Ti",                  DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       PALIT_SUB_VEN,  PALIT_RTX3070TI_SUB_DEV,                    0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3070 Ti GamingPro",        DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       PALIT_SUB_VEN,  PALIT_RTX3070TI_GAMING_PRO_SUB_DEV,         0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3080",                     DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3080_DEV,         PALIT_SUB_VEN,  PALIT_RTX3080_SUB_DEV,                      0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3080 LHR",                 DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,     PALIT_SUB_VEN,  PALIT_RTX3080_LHR_SUB_DEV,                  0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3080 Gamerock",            DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3080_DEV,         PALIT_SUB_VEN,  PALIT_RTX3080_GAMEROCK_SUB_DEV,             0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3080 Gamerock LHR",        DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,     PALIT_SUB_VEN,  PALIT_RTX3080_GAMEROCK_SUB_DEV,             0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3080 12GB GamingPro",      DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3080_12G_LHR_DEV, PALIT_SUB_VEN,  PALIT_RTX3080_GAMINGPRO_12G_SUB_DEV,        0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3080 Ti",                  DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       PALIT_SUB_VEN,  PALIT_RTX3080TI_SUB_DEV,                    0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3080 Ti Gamerock",         DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       PALIT_SUB_VEN,  PALIT_RTX3080TI_GAMEROCK_SUB_DEV,           0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3090",                     DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3090_DEV,         PALIT_SUB_VEN,  PALIT_RTX3090_SUB_DEV,                      0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3090 Gamerock",            DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3090_DEV,         PALIT_SUB_VEN,  PALIT_RTX3090_GAMEROCK_SUB_DEV,             0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3090 Ti Gamerock",         DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX3090TI_DEV,       PALIT_SUB_VEN,  PALIT_RTX3090TI_GAMEROCK_SUB_DEV,           0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 4070 Ti",                  DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,       PALIT_SUB_VEN,  PALIT_RTX4070TI_SUB_DEV,                    0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 4070 Ti Gamerock",         DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,       PALIT_SUB_VEN,  PALIT_RTX4070TI_GAMEROCK_SUB_DEV,           0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 4070 Ti SUPER GamingPro",  DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX4070TIS_DEV,      PALIT_SUB_VEN,  PALIT_RTX4080_GAMINGPRO_SUB_DEV,            0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 4080 GamingPro",           DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX4080_DEV,         PALIT_SUB_VEN,  PALIT_RTX4080_GAMINGPRO_SUB_DEV,            0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 4080 SUPER GamingPro",     DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX4080S_DEV,        PALIT_SUB_VEN,  PALIT_RTX4080_GAMINGPRO_SUB_DEV,            0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 4090 Gamerock",            DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX4090_DEV,         PALIT_SUB_VEN,  PALIT_RTX4090_GAMEROCK_SUB_DEV,             0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5060 Ti White OC 16GB",    DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,       PALIT_SUB_VEN,  PALIT_RTX5060TI_WHITE_OC_16G_SUB_DEV,       0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5070 GamingPro",           DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX5070_DEV,         PALIT_SUB_VEN,  PALIT_RTX5070_GAMINGPRO_SUB_DEV,            0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5070 Ti GameRock",         DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX5070TI_DEV,       PALIT_SUB_VEN,  PALIT_RTX5070TI_GAMEROCK_SUB_DEV,           0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5070 Ti GamingPro",        DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX5070TI_DEV,       PALIT_SUB_VEN,  PALIT_RTX5070TI_GAMINGPRO_SUB_DEV,          0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5070 Ti GamingPro-S",      DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX5070TI_DEV,       PALIT_SUB_VEN,  PALIT_RTX5070TI_GAMINGPRO_S_SUB_DEV,        0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5080 GameRock",            DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX5080_DEV,         PALIT_SUB_VEN,  PALIT_RTX5080_GAMEROCK_SUB_DEV,             0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5080 GamingPro",           DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX5080_DEV,         PALIT_SUB_VEN,  PALIT_RTX5080_GAMINGPRO_SUB_DEV,            0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5090 Gamerock",            DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX5090_DEV,         PALIT_SUB_VEN,  PALIT_RTX5090_GAMEROCK_SUB_DEV,             0x49);
+REGISTER_I2C_PCI_DETECTOR("NVIDIA GeForce RTX 2060 SUPER",              DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX2060_TU106_DEV,   NVIDIA_SUB_VEN, NVIDIA_RTX2060_TU106_DEV,                   0x49);
+REGISTER_I2C_PCI_DETECTOR("NVIDIA GeForce RTX 2080 SUPER",              DetectPNYGPUControllers,    NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        NVIDIA_SUB_VEN, NVIDIA_RTX2080S_DEV,                        0x49);

Controllers/PNYGPUController/RGBController_PNYGPU.cpp

@@ -0,0 +1,161 @@
+/*---------------------------------------------------------*\
+| RGBController_PNYGPU.cpp                                  |
+|                                                           |
+|   RGBController for PNY Turing GPU                        |
+|                                                           |
+|   KendallMorgan                               17 Oct 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_PNYGPU.h"
+
+/**------------------------------------------------------------------*\
+    @name PNY GPU
+    @category GPU
+    @type I2C
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectPNYGPUControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_PNYGPU::RGBController_PNYGPU(PNYGPUController* controller_ptr)
+{
+    controller              = controller_ptr;
+
+    name                    = controller->GetDeviceName();
+    vendor                  = name.substr(0, name.find(' '));
+    description             = "PNY/Palit RGB GPU Device";
+    location                = controller->GetDeviceLocation();
+
+    type                    = DEVICE_TYPE_GPU;
+
+    mode Off;
+    Off.name                = "Off";
+    Off.value               = PNY_GPU_MODE_OFF;
+    Off.flags               = 0;
+    Off.color_mode          = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Direct;
+    Direct.name             = "Direct";
+    Direct.value            = PNY_GPU_MODE_DIRECT;
+    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR| MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.brightness       = 255;
+    Direct.brightness_min   = 0;
+    Direct.brightness_max   = 100;
+    Direct.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Cycle;
+    Cycle.name             = "Cycle";
+    Cycle.value            = PNY_GPU_MODE_CYCLE;
+    Cycle.flags            = MODE_FLAG_HAS_SPEED;
+    Cycle.speed            = 3;
+    Cycle.speed_max        = 0;
+    Cycle.speed_max        = 100;
+    Cycle.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Cycle);
+
+    mode Strobe;
+    Strobe.name             = "Strobe";
+    Strobe.value            = PNY_GPU_MODE_STROBE;
+    Strobe.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Strobe.speed            = 2;
+    Strobe.speed_max        = 0;
+    Strobe.speed_max        = 255;
+    Strobe.brightness       = 255;
+    Strobe.brightness_min   = 0;
+    Strobe.brightness_max   = 100;
+    Strobe.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Strobe);
+
+
+    SetupZones();
+
+    // Initialize active mode
+    active_mode = 0;
+}
+
+RGBController_PNYGPU::~RGBController_PNYGPU()
+{
+    Shutdown();
+
+    delete controller;
+}
+
+void RGBController_PNYGPU::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | This device only has one LED, so create a single zone and |
+    | LED for it                                                |
+    \*---------------------------------------------------------*/
+    zone* new_zone = new zone();
+    led*  new_led  = new led();
+
+    new_zone->name          = "GPU Zone";
+    new_zone->type          = ZONE_TYPE_SINGLE;
+    new_zone->leds_min      = 1;
+    new_zone->leds_max      = 1;
+    new_zone->leds_count    = 1;
+
+    new_led->name           = "GPU LED";
+
+    /*---------------------------------------------------------*\
+    | Push the zone and LED on to device vectors                |
+    \*---------------------------------------------------------*/
+    leds.push_back(*new_led);
+    zones.push_back(*new_zone);
+    SetupColors();
+}
+
+void RGBController_PNYGPU::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_PNYGPU::DeviceUpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_PNYGPU::DeviceUpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_PNYGPU::DeviceUpdateMode()
+{
+    RGBColor      color = colors[0];
+    unsigned char r   = RGBGetRValue(color);
+    unsigned char g   = RGBGetGValue(color);
+    unsigned char b   = RGBGetBValue(color);
+    unsigned char speed, brightness;
+    switch(modes[active_mode].value)
+    {
+        case PNY_GPU_MODE_OFF:
+            controller->SetOff();
+            break;
+
+        case PNY_GPU_MODE_DIRECT:
+            brightness = modes[active_mode].brightness;
+            controller->SetDirect(r, g, b, brightness);
+            break;
+
+        case PNY_GPU_MODE_CYCLE:
+            speed = modes[active_mode].speed;
+            controller->SetCycle(speed);
+            break;
+
+        case PNY_GPU_MODE_STROBE:
+            speed      = modes[active_mode].speed;
+            brightness = modes[active_mode].brightness;
+            controller->SetStrobe(r, g, b, speed, brightness);
+            break;
+        default:
+        break;
+    }
+}

Controllers/PNYGPUController/RGBController_PNYGPU.h

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------*\
+| RGBController_PNYGPU.h                                    |
+|                                                           |
+|   RGBController for PNY Turing GPU                        |
+|                                                           |
+|   KendallMorgan                               17 Oct 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "PNYGPUController.h"
+
+class RGBController_PNYGPU : public RGBController
+{
+public:
+    RGBController_PNYGPU(PNYGPUController* controller_ptr);
+    ~RGBController_PNYGPU();
+
+    void        SetupZones();
+
+    void        DeviceUpdateLEDs();
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    PNYGPUController* controller;
+};

Controllers/PalitGPUController/PalitGPUController.cpp

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------*\
+| PalitGPUController.cpp                                    |
+|                                                           |
+|   Driver for Palit GPU                                    |
+|                                                           |
+|   Manatsawin Hanmongkolchai                   11 Apr 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "PalitGPUController.h"
+
+PalitGPUController::PalitGPUController(i2c_smbus_interface* bus, palit_dev_id dev, std::string dev_name)
+{
+    this->bus   = bus;
+    this->dev   = dev;
+    this->name  = dev_name;
+}
+
+PalitGPUController::~PalitGPUController()
+{
+
+}
+
+std::string PalitGPUController::GetDeviceLocation()
+{
+    std::string return_string(bus->info.device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+std::string PalitGPUController::GetName()
+{
+    return(name);
+}
+
+void PalitGPUController::SetDirect(unsigned char red, unsigned char green, unsigned char blue)
+{
+    // NvAPI_I2CWriteEx:  Dev: 0x08 RegSize: 0x01 Reg: 0x03 Size: 0x04 Data: 0xFF 0x00 0x00 0xFF
+    uint8_t values[] = {red, green, blue, 0xFF};
+    bus->i2c_smbus_write_i2c_block_data(dev, PALIT_GPU_REG_LED, sizeof(values), values);
+}

Controllers/PalitGPUController/PalitGPUController.h

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------*\
+| PalitGPUController.h                                      |
+|                                                           |
+|   Driver for Palit GPU                                    |
+|                                                           |
+|   Manatsawin Hanmongkolchai                   11 Apr 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include "i2c_smbus.h"
+
+typedef unsigned char       palit_dev_id;
+
+enum
+{
+    PALIT_GPU_MODE_DIRECT   = 0x00,
+};
+
+enum
+{
+    PALIT_GPU_REG_LED       = 0x03,
+};
+
+class PalitGPUController
+{
+public:
+	PalitGPUController(i2c_smbus_interface* bus, palit_dev_id dev, std::string dev_name);
+	~PalitGPUController();
+
+	std::string             GetDeviceLocation();
+    std::string             GetName();
+
+    void                    SetDirect(unsigned char red, unsigned char green, unsigned char blue);
+
+private:
+	i2c_smbus_interface*    bus;
+	palit_dev_id            dev;
+    std::string             name;
+};

Controllers/PalitGPUController/PalitGPUControllerDetect.cpp

@@ -4,9 +4,6 @@
 |   Detector for Palit GPU                                  |
 |                                                           |
 |   Manatsawin Hanmongkolchai                   11 Apr 2023 |
-|   TheRogueZeta                                05 Nov 2020 |
-|   KundaPanda                                  04 Jan 2021 |
-|   KendallMorgan                               17 Oct 2021 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -16,24 +13,21 @@
 #include <stdlib.h>
 #include "DetectionManager.h"
 #include "i2c_smbus.h"
-#include "PalitGPUv1Controller.h"
-#include "PalitGPUv2Controller.h"
+#include "PalitGPUController.h"
 #include "pci_ids.h"
-#include "RGBController_PalitGPUv1.h"
-#include "RGBController_PalitGPUv2.h"
+#include "RGBController_PalitGPU.h"
 
-bool TestForPalitGPUv1Controller(i2c_smbus_interface* bus, uint8_t i2c_addr)
+DetectedControllers DetectPalitGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
-    bool pass = false;
+    DetectedControllers detected_controllers;
 
     if(bus->info.port_id == 1)
     {
-        /*-------------------------------------------------*\
-        | Check for PALIT string, which is known to work    |
-        | for Palit variants                                |
-        \*-------------------------------------------------*/
+        /*-----------------------------------------------------*\
+        | Check for PALIT string                                |
+        \*-----------------------------------------------------*/
         const uint8_t   palit[] = {'P', 'A', 'L', 'I', 'T'};
-        bool            match   = true;
+        bool            match = true;
 
         for(size_t i = 0; i < sizeof(palit); i++)
         {
@@ -45,151 +39,20 @@ bool TestForPalitGPUv1Controller(i2c_smbus_interface* bus, uint8_t i2c_addr)
             }
         }
 
-        /*-------------------------------------------------*\
-        | If PALIT string fails, try a quick write to the   |
-        | target address, which is known to work for        |
-        | Gainward variants                                 |
-        \*-------------------------------------------------*/
         if(match)
         {
-            pass = true;
+            PalitGPUController*     controller      = new PalitGPUController(bus, i2c_addr, name);
+            RGBController_PalitGPU* rgb_controller  = new RGBController_PalitGPU(controller);
+
+            DetectionManager::get()->RegisterRGBController(rgb_controller);
         }
-        else
-        {
-            switch(i2c_addr)
-            {
-                case 0x08:
-                    pass = bus->i2c_smbus_write_quick(i2c_addr, I2C_SMBUS_WRITE);
-                    break;
-            }
-        }
-    }
-
-    return(pass);
-}
-
-bool TestForPalitGPUv2Controller(i2c_smbus_interface* bus, uint8_t i2c_addr)
-{
-    bool pass = false;
-
-    if(bus->info.port_id == 1)
-    {
-        switch(i2c_addr)
-        {
-            case 0x49:
-                s32 data        = bus->i2c_smbus_read_byte_data(i2c_addr, 0x0);
-                s32 mode_data   = bus->i2c_smbus_read_byte_data(i2c_addr, 0xe0);
-                pass            = (data == 0x0) && (mode_data < 0x5);
-                break;
-        }
-    }
-
-    return(pass);
-}
-
-DetectedControllers DetectPalitGPUv1Controllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-
-    if(TestForPalitGPUv1Controller(bus, i2c_addr))
-    {
-        PalitGPUv1Controller*     controller     = new PalitGPUv1Controller(bus, i2c_addr, name);
-        RGBController_PalitGPUv1* rgb_controller = new RGBController_PalitGPUv1(controller);
-
-        detected_controllers.push_back(rgb_controller);
     }
 
     return(detected_controllers);
 }
 
-DetectedControllers DetectPalitGPUv2Controllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-
-    if(TestForPalitGPUv2Controller(bus, i2c_addr))
-    {
-        PalitGPUv2Controller*     controller     = new PalitGPUv2Controller(bus, i2c_addr, name);
-        RGBController_PalitGPUv2* rgb_controller = new RGBController_PalitGPUv2(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
-
-/*---------------------------------------------------------*\
-| Register detectors for Palit GPU controllers              |
-| Uses the unified PalitGPUv1Controllers for all V1 protocol|
-| devices ( Gainward and Palit branded)                     |
-\*---------------------------------------------------------*/
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce GTX 1060",                     DetectPalitGPUv1Controllers,    NVIDIA_VEN, NVIDIA_GTX1060_DEV,         NVIDIA_SUB_VEN,     NVIDIA_GTX1060_DEV,                         0x08);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce GTX 1070",                     DetectPalitGPUv1Controllers,    NVIDIA_VEN, NVIDIA_GTX1070_DEV,         NVIDIA_SUB_VEN,     NVIDIA_GTX1070_DEV,                         0x08);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce GTX 1070 Ti",                  DetectPalitGPUv1Controllers,    NVIDIA_VEN, NVIDIA_GTX1070TI_DEV,       NVIDIA_SUB_VEN,     NVIDIA_GTX1070TI_DEV,                       0x08);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce GTX 1080",                     DetectPalitGPUv1Controllers,    NVIDIA_VEN, NVIDIA_GTX1080_DEV,         NVIDIA_SUB_VEN,     NVIDIA_GTX1080_DEV,                         0x08);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce GTX 1080 Ti",                  DetectPalitGPUv1Controllers,    NVIDIA_VEN, NVIDIA_GTX1080TI_DEV,       NVIDIA_SUB_VEN,     NVIDIA_GTX1080TI_DEV,                       0x08);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce GTX 1080 Phoenix",          DetectPalitGPUv1Controllers,    NVIDIA_VEN, NVIDIA_GTX1080_DEV,         GAINWARD_SUB_VEN,   GAINWARD_GTX_1080_PHOENIX,                  0x08);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce GTX 1080 Ti Phoenix",       DetectPalitGPUv1Controllers,    NVIDIA_VEN, NVIDIA_GTX1080TI_DEV,       GAINWARD_SUB_VEN,   GAINWARD_GTX_1080TI_PHOENIX,                0x08);
-
-/*---------------------------------------------------------*\
-| Register detectors for Palit V2 GPU controllers           |
-| (Gainward and PNY branded cards)                          |
-\*---------------------------------------------------------*/
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce GTX 1660 SUPER Ghost",      DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_GTX1660S_DEV,        NVIDIA_SUB_VEN,     NVIDIA_GTX1660S_DEV,                        0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 2070 SUPER Phantom",    DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,     GAINWARD_SUB_VEN,   NVIDIA_RTX2070S_OC_DEV,                     0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 2080 Phoenix GS",       DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX2080_DEV,         GAINWARD_SUB_VEN,   NVIDIA_RTX2080_A_DEV,                       0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3060 Pegasus 12G",      DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3060_DEV,         NVIDIA_SUB_VEN,     NVIDIA_RTX3060_DEV,                         0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3070 Phantom",          DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3070_DEV,         GAINWARD_SUB_VEN,   GAINWARD_RTX_3070_PHANTOM,                  0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3070 Phoenix",          DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3070_DEV,         GAINWARD_SUB_VEN,   NVIDIA_RTX3070_DEV,                         0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3070 Ti Phoenix",       DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       GAINWARD_SUB_VEN,   NVIDIA_RTX3070TI_DEV,                       0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3080 Phoenix",          DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3080_DEV,         GAINWARD_SUB_VEN,   NVIDIA_RTX3080_DEV,                         0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3080 Ti Phoenix",       DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       GAINWARD_SUB_VEN,   NVIDIA_RTX3080TI_DEV,                       0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3090 Phoenix",          DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3090_DEV,         GAINWARD_SUB_VEN,   NVIDIA_RTX3090_DEV,                         0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3090 Ti Phantom",       DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3090TI_DEV,       GAINWARD_SUB_VEN,   GAINWARD_RTX_3090TI_PHANTOM,                0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 4080 Phantom GS",       DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX4080_DEV,         GAINWARD_SUB_VEN,   GAINWARD_RTX_4080_PHANTOM_GS_SUB_DEV,       0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 4090 Phantom",          DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX4090_DEV,         GAINWARD_SUB_VEN,   GAINWARD_RTX_4090_PHANTOM_SUB_DEV,          0x49);
-REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 5080 Phoenix",          DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX5080_DEV,         GAINWARD_SUB_VEN,   GAINWARD_RTX_5080_PHOENIX_SUB_DEV,          0x49);
-
-/*---------------------------------------------------------*\
-| PNY GPU controllers (also Palit-manufactured)             |
-\*---------------------------------------------------------*/
-REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 2060 XLR8 OC EDITION",       DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX2060_TU104_DEV,   PNY_SUB_VEN,        PNY_RTX_2060_XLR8_OC_SUB_DEV,               0x49);
-REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 3060 XLR8 Revel EPIC-X",     DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3060_DEV,         PNY_SUB_VEN,        PNY_RTX_3060_XLR8_REVEL_EPIC_X_SUB_DEV,     0x49);
-REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 3070 XLR8 Revel EPIC-X",     DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3070_DEV,         PNY_SUB_VEN,        PNY_RTX_3070_XLR8_REVEL_EPIC_X_SUB_DEV,     0x49);
-REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 3070 XLR8 Revel EPIC-X LHR", DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     PNY_SUB_VEN,        PNY_RTX_3070_XLR8_REVEL_EPIC_X_LHR_SUB_DEV, 0x49);
-REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 3080 XLR8 Revel EPIC-X",     DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3080_DEV,         PNY_SUB_VEN,        PNY_RTX_3080_XLR8_REVEL_EPIC_X_SUB_DEV,     0x49);
-REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 3080 Ti XLR8 Revel EPIC-X",  DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       PNY_SUB_VEN,        PNY_RTX_3080TI_XLR8_REVEL_EPIC_X_SUB_DEV,   0x49);
-REGISTER_I2C_PCI_DETECTOR("PNY GeForce RTX 3090 XLR8 Revel EPIC-X",     DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3090_DEV,         PNY_SUB_VEN,        PNY_RTX_3090_XLR8_REVEL_EPIC_X_SUB_DEV,     0x49);
-
-/*---------------------------------------------------------*\
-| Palit GPU controllers detected via PNY detector           |
-\*---------------------------------------------------------*/
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 2070 SUPER Jetstream",     DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,     NVIDIA_SUB_VEN,     NVIDIA_RTX2070S_OC_DEV,                     0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3060",                     DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3060_DEV,         PALIT_SUB_VEN,      PALIT_RTX3060_SUB_DEV,                      0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3060 LHR",                 DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     PALIT_SUB_VEN,      PALIT_RTX3060_LHR_SUB_DEV,                  0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3060 Ti",                  DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3060TI_DEV,       PALIT_SUB_VEN,      PALIT_RTX3060TI_SUB_DEV,                    0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3060 Ti LHR",              DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,   PALIT_SUB_VEN,      NVIDIA_RTX3060TI_LHR_DEV,                   0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3070",                     DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3070_DEV,         PALIT_SUB_VEN,      PALIT_RTX3070_SUB_DEV,                      0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3070 LHR",                 DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     PALIT_SUB_VEN,      PALIT_RTX3070_LHR_SUB_DEV,                  0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3070 Ti",                  DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       PALIT_SUB_VEN,      PALIT_RTX3070TI_SUB_DEV,                    0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3080",                     DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3080_DEV,         PALIT_SUB_VEN,      PALIT_RTX3080_SUB_DEV,                      0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3080 LHR",                 DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,     PALIT_SUB_VEN,      PALIT_RTX3080_LHR_SUB_DEV,                  0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3080 Ti",                  DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       PALIT_SUB_VEN,      PALIT_RTX3080TI_SUB_DEV,                    0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3090",                     DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3090_DEV,         PALIT_SUB_VEN,      PALIT_RTX3090_SUB_DEV,                      0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3090 Gamerock",            DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3090_DEV,         PALIT_SUB_VEN,      PALIT_RTX3090_GAMEROCK_SUB_DEV,             0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 3090 Ti Gamerock",         DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX3090TI_DEV,       PALIT_SUB_VEN,      PALIT_RTX3090TI_GAMEROCK_SUB_DEV,           0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 4070 Ti",                  DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,       PALIT_SUB_VEN,      PALIT_RTX4070TI_SUB_DEV,                    0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 4070 Ti Gamerock",         DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,       PALIT_SUB_VEN,      PALIT_RTX4070TI_GAMEROCK_SUB_DEV,           0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 4070 Ti SUPER GamingPro",  DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX4070TIS_DEV,      PALIT_SUB_VEN,      PALIT_RTX4080_GAMINGPRO_SUB_DEV,            0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 4080 GamingPro",           DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX4080_DEV,         PALIT_SUB_VEN,      PALIT_RTX4080_GAMINGPRO_SUB_DEV,            0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 4080 SUPER GamingPro",     DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX4080S_DEV,        PALIT_SUB_VEN,      PALIT_RTX4080_GAMINGPRO_SUB_DEV,            0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 4090 Gamerock",            DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX4090_DEV,         PALIT_SUB_VEN,      PALIT_RTX4090_GAMEROCK_SUB_DEV,             0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5060 Ti White OC 16GB",    DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,       PALIT_SUB_VEN,      PALIT_RTX5060TI_WHITE_OC_16G_SUB_DEV,       0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5070 GamingPro",           DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX5070_DEV,         PALIT_SUB_VEN,      PALIT_RTX5070_GAMINGPRO_SUB_DEV,            0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5070 Ti GameRock",         DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX5070TI_DEV,       PALIT_SUB_VEN,      PALIT_RTX5070TI_GAMEROCK_SUB_DEV,           0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5070 Ti GamingPro",        DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX5070TI_DEV,       PALIT_SUB_VEN,      PALIT_RTX5070TI_GAMINGPRO_SUB_DEV,          0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5070 Ti GamingPro-S",      DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX5070TI_DEV,       PALIT_SUB_VEN,      PALIT_RTX5070TI_GAMINGPRO_S_SUB_DEV,        0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5080 GameRock",            DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX5080_DEV,         PALIT_SUB_VEN,      PALIT_RTX5080_GAMEROCK_SUB_DEV,             0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5080 GamingPro",           DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX5080_DEV,         PALIT_SUB_VEN,      PALIT_RTX5080_GAMINGPRO_SUB_DEV,            0x49);
-REGISTER_I2C_PCI_DETECTOR("Palit GeForce RTX 5090 Gamerock",            DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX5090_DEV,         PALIT_SUB_VEN,      PALIT_RTX5090_GAMEROCK_SUB_DEV,             0x49);
-REGISTER_I2C_PCI_DETECTOR("NVIDIA GeForce RTX 2060 SUPER",              DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX2060_TU106_DEV,   NVIDIA_SUB_VEN,     NVIDIA_RTX2060_TU106_DEV,                   0x49);
-REGISTER_I2C_PCI_DETECTOR("NVIDIA GeForce RTX 2080 SUPER",              DetectPalitGPUv2Controllers,    NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        NVIDIA_SUB_VEN,     NVIDIA_RTX2080S_DEV,                        0x49);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce GTX 1060",    DetectPalitGPUControllers, NVIDIA_VEN, NVIDIA_GTX1060_DEV, NVIDIA_SUB_VEN, NVIDIA_GTX1060_DEV,     0x08);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce GTX 1070",    DetectPalitGPUControllers, NVIDIA_VEN, NVIDIA_GTX1070_DEV, NVIDIA_SUB_VEN, NVIDIA_GTX1070_DEV,     0x08);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce GTX 1070 Ti", DetectPalitGPUControllers, NVIDIA_VEN, NVIDIA_GTX1070TI_DEV, NVIDIA_SUB_VEN, NVIDIA_GTX1070TI_DEV, 0x08);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce GTX 1080",    DetectPalitGPUControllers, NVIDIA_VEN, NVIDIA_GTX1080_DEV, NVIDIA_SUB_VEN, NVIDIA_GTX1080_DEV,     0x08);
+REGISTER_I2C_PCI_DETECTOR("Palit GeForce GTX 1080 Ti", DetectPalitGPUControllers, NVIDIA_VEN, NVIDIA_GTX1080TI_DEV, NVIDIA_SUB_VEN, NVIDIA_GTX1080TI_DEV, 0x08);

Controllers/PalitGPUController/PalitGPUv1Controller.cpp

@@ -1,77 +0,0 @@
-/*---------------------------------------------------------*\
-| PalitGPUv1Controller.cpp                                  |
-|                                                           |
-|   Driver for Palit v1 GPU                                 |
-|                                                           |
-|   TheRogueZeta                                05 Nov 2020 |
-|   Manatsawin Hanmongkolchai                   11 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include "PalitGPUv1Controller.h"
-
-PalitGPUv1Controller::PalitGPUv1Controller(i2c_smbus_interface* bus, palit_gpu_dev_id dev, std::string dev_name)
-{
-    this->bus   = bus;
-    this->dev   = dev;
-    this->name  = dev_name;
-}
-
-PalitGPUv1Controller::~PalitGPUv1Controller()
-{
-
-}
-
-std::string PalitGPUv1Controller::GetDeviceLocation()
-{
-    std::string return_string(bus->info.device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-std::string PalitGPUv1Controller::GetDeviceName()
-{
-    return(name);
-}
-
-unsigned char PalitGPUv1Controller::GetLEDRed()
-{
-    /*-----------------------------------------------------*\
-    | Read red color from register 0x03                     |
-    \*-----------------------------------------------------*/
-    return(bus->i2c_smbus_read_byte_data(dev, PALIT_V1_RED_REGISTER));
-}
-
-unsigned char PalitGPUv1Controller::GetLEDGreen()
-{
-    /*-----------------------------------------------------*\
-    | Read green color from register 0x04                   |
-    \*-----------------------------------------------------*/
-    return(bus->i2c_smbus_read_byte_data(dev, PALIT_V1_RED_REGISTER + 1));
-}
-
-unsigned char PalitGPUv1Controller::GetLEDBlue()
-{
-    /*-----------------------------------------------------*\
-    | Read blue color from register 0x05                    |
-    \*-----------------------------------------------------*/
-    return(bus->i2c_smbus_read_byte_data(dev, PALIT_V1_RED_REGISTER + 2));
-}
-
-void PalitGPUv1Controller::SetLEDColors(unsigned char red, unsigned char green, unsigned char blue)
-{
-    /*-----------------------------------------------------*\
-    | Write RGB colors and control byte using individual    |
-    | writes to registers 0x03, 0x04, 0x05, 0x06            |
-    \*-----------------------------------------------------*/
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V1_RED_REGISTER, red);
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V1_RED_REGISTER + 1, green);
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V1_RED_REGISTER + 2, blue);
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V1_RED_REGISTER + 3, 0xFF);
-}

Controllers/PalitGPUController/PalitGPUv2Controller.cpp

@@ -1,154 +0,0 @@
-/*---------------------------------------------------------*\
-| PalitGPUv2Controller.cpp                                  |
-|                                                           |
-|   Driver for Palit v2 GPU (merged from Gainward v2 and    |
-|   PNY controllers)                                        |
-|                                                           |
-|   KundaPanda                                  04 Jan 2021 |
-|   KendallMorgan                               17 Oct 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include "PalitGPUv2Controller.h"
-
-PalitGPUv2Controller::PalitGPUv2Controller(i2c_smbus_interface* bus, palit_gpu_dev_id dev, std::string dev_name)
-{
-    this->bus   = bus;
-    this->dev   = dev;
-    this->name  = dev_name;
-}
-
-PalitGPUv2Controller::~PalitGPUv2Controller()
-{
-
-}
-
-std::string PalitGPUv2Controller::GetDeviceLocation()
-{
-    std::string return_string(bus->info.device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-std::string PalitGPUv2Controller::GetDeviceName()
-{
-    return(name);
-}
-
-unsigned char PalitGPUv2Controller::GetLEDRed()
-{
-    return(bus->i2c_smbus_read_byte_data(dev, PALIT_V2_RED_REGISTER));
-}
-
-unsigned char PalitGPUv2Controller::GetLEDGreen()
-{
-    return(bus->i2c_smbus_read_byte_data(dev, PALIT_V2_GREEN_REGISTER));
-}
-
-unsigned char PalitGPUv2Controller::GetLEDBlue()
-{
-    return(bus->i2c_smbus_read_byte_data(dev, PALIT_V2_BLUE_REGISTER));
-}
-
-void PalitGPUv2Controller::WriteI2CData(u8 command, u8 length, u8* data)
-{
-    for (u8 i = 0; i < length; i++)
-    {
-        bus->i2c_smbus_write_byte_data(dev, command + i, data[i]);
-    }
-}
-
-void PalitGPUv2Controller::SetLEDColors(unsigned char red, unsigned char green, unsigned char blue, unsigned char color_register)
-{
-    switch (color_register)
-    {
-        default:
-            bus->i2c_smbus_write_byte_data(dev, PALIT_V2_RED_REGISTER, red);
-            bus->i2c_smbus_write_byte_data(dev, PALIT_V2_GREEN_REGISTER, green);
-            bus->i2c_smbus_write_byte_data(dev, PALIT_V2_BLUE_REGISTER, blue);
-            break;
-        case PALIT_V2_COLOR_REGISTER_SECONDARY:
-            bus->i2c_smbus_write_byte_data(dev, PALIT_V2_RED_SECONDARY_REGISTER, red);
-            bus->i2c_smbus_write_byte_data(dev, PALIT_V2_GREEN_SECONDARY_REGISTER, green);
-            bus->i2c_smbus_write_byte_data(dev, PALIT_V2_BLUE_SECONDARY_REGISTER, blue);
-            break;
-        case PALIT_V2_COLOR_REGISTER_TERTIARY:
-            bus->i2c_smbus_write_byte_data(dev, PALIT_V2_RED_TERTIARY_REGISTER, red);
-            bus->i2c_smbus_write_byte_data(dev, PALIT_V2_GREEN_TERTIARY_REGISTER, green);
-            bus->i2c_smbus_write_byte_data(dev, PALIT_V2_BLUE_TERTIARY_REGISTER, blue);
-            break;
-    }
-}
-
-void PalitGPUv2Controller::SetMode(unsigned char mode, unsigned char speed, unsigned char control_mode)
-{
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_MODE_REGISTER, mode);
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_CONTROL_REGISTER, control_mode);
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_SPEED_REGISTER, speed);
-}
-
-void PalitGPUv2Controller::SetDirection(unsigned char direction)
-{
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_MODE_DIRECTION_REGISTER, direction);
-}
-
-void PalitGPUv2Controller::SetBreathingSpeed(unsigned int speed)
-{
-    unsigned char lower = speed & 0xFF;
-    unsigned char upper = (speed >> 2 * 4) & 0xFF;
-
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_BREATHE_SPEED_REGISTER_A, lower);
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_BREATHE_SPEED_SECONDARY_REGISTER_A, lower);
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_BREATHE_SPEED_REGISTER_B, upper);
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_BREATHE_SPEED_SECONDARY_REGISTER_B, upper);
-}
-
-void PalitGPUv2Controller::SetOff()
-{
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_MODE_REGISTER, 0);
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_CONTROL_REGISTER, 0x00);
-}
-
-void PalitGPUv2Controller::SetCycle(unsigned char speed)
-{
-    u8 loop[] = {
-        0x01,  // Direction
-        0x00,  // ??
-        speed, // Speed
-        0x1F   // Somehow related to speed
-    };
-    loop[2] = speed;
-    WriteI2CData(PALIT_V2_MODE_REGISTER, sizeof(loop), loop);
-}
-
-void PalitGPUv2Controller::SetStrobe(unsigned char r, unsigned char g, unsigned char b, unsigned char speed, unsigned char brightness)
-{
-    u8 strobe[] = {
-        0x02,       // Strobe
-        0x00,       // Rise speed
-        speed,      // Cycle length/2
-        0x00,       // Off delay
-        r,          // R
-        g,          // G
-        b,          // B
-        brightness, // Peak brightness
-        0x05        // Fade speed
-    };
-    WriteI2CData(PALIT_V2_MODE_REGISTER, sizeof(strobe), strobe);
-}
-
-void PalitGPUv2Controller::SetDirect(unsigned char red, unsigned char green, unsigned char blue, unsigned char brightness)
-{
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_MODE_REGISTER, 0);
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_CONTROL_REGISTER, 0x01);
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_RED_REGISTER, red);
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_BLUE_REGISTER, blue);
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_GREEN_REGISTER, green);
-    bus->i2c_smbus_write_byte_data(dev, PALIT_V2_BRIGHTNESS_REGISTER, brightness);
-}

Controllers/PalitGPUController/PalitGPUv2Controller.h

@@ -1,115 +0,0 @@
-/*---------------------------------------------------------*\
-| PalitGPUv2Controller.h                                    |
-|                                                           |
-|   Driver for Palit v2 GPU (merged from Gainward v2 and    |
-|   PNY controllers)                                        |
-|                                                           |
-|   KundaPanda                                  04 Jan 2021 |
-|   KendallMorgan                               17 Oct 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include "i2c_smbus.h"
-
-typedef unsigned char palit_gpu_dev_id;
-
-enum
-{
-    /* Control Registers */
-    PALIT_V2_CONTROL_REGISTER                    = 0x60, /* Control Register (direct mode / software control) */
-
-    /* Breathing speed registers */
-    PALIT_V2_BREATHE_SPEED_REGISTER_A            = 0x62, /* Lower part of speed control for breathe effect */
-    PALIT_V2_BREATHE_SPEED_REGISTER_B            = 0x63, /* Upper part of speed control for breathe effect */
-    PALIT_V2_BREATHE_SPEED_SECONDARY_REGISTER_A  = 0x64, /* Lower part of speed control for breathe effect - prob. secondary color */
-    PALIT_V2_BREATHE_SPEED_SECONDARY_REGISTER_B  = 0x65, /* Upper part of speed control for breathe effect - prob. secondary color */
-
-    /* RGB Registers - Primary color */
-    PALIT_V2_RED_REGISTER                        = 0x6C, /* Red Register */
-    PALIT_V2_GREEN_REGISTER                      = 0x6D, /* Green Register */
-    PALIT_V2_BLUE_REGISTER                       = 0x6E, /* Blue Register */
-    PALIT_V2_BRIGHTNESS_REGISTER                 = 0x6F, /* Brightness Register */
-
-    /* RGB Registers - Secondary color */
-    PALIT_V2_RED_SECONDARY_REGISTER              = 0x70, /* Red Register 2 */
-    PALIT_V2_GREEN_SECONDARY_REGISTER            = 0x71, /* Green Register 2 */
-    PALIT_V2_BLUE_SECONDARY_REGISTER             = 0x72, /* Blue Register 2 */
-
-    /* Mode Registers */
-    PALIT_V2_MODE_REGISTER                       = 0xE0, /* Mode Register */
-    PALIT_V2_MODE_DIRECTION_REGISTER             = 0xE1, /* Mode direction Register */
-    PALIT_V2_SPEED_REGISTER                      = 0xE2, /* Mode speed Register */
-
-    /* RGB Registers - Tertiary color */
-    PALIT_V2_RED_TERTIARY_REGISTER               = 0xE4, /* Red Register 3 */
-    PALIT_V2_GREEN_TERTIARY_REGISTER             = 0xE5, /* Green Register 3 */
-    PALIT_V2_BLUE_TERTIARY_REGISTER              = 0xE6, /* Blue Register 3 */
-};
-
-/* Mode values for the hardware mode register */
-enum
-{
-    PALIT_V2_MODE_OFF                            = 0x00,
-    PALIT_V2_MODE_STATIC                         = 0x00,
-    PALIT_V2_MODE_CYCLE                          = 0x01,
-    PALIT_V2_MODE_STROBE                         = 0x02,
-};
-
-/* Mode identifiers for RGBController (unique values for switch statements) */
-enum
-{
-    PALIT_V2_MODE_ID_OFF                         = 0,
-    PALIT_V2_MODE_ID_DIRECT                      = 1,
-    PALIT_V2_MODE_ID_BREATHING                   = 2,
-    PALIT_V2_MODE_ID_CYCLE                       = 3,
-    PALIT_V2_MODE_ID_STROBE                      = 4,
-};
-
-enum
-{
-    PALIT_V2_COLOR_REGISTER_PRIMARY,
-    PALIT_V2_COLOR_REGISTER_SECONDARY,
-    PALIT_V2_COLOR_REGISTER_TERTIARY,
-};
-
-enum
-{
-    /* Software controlled direct mode */
-    PALIT_V2_STATIC_SOFTWARE                     = 0x01,
-    /* GPU controlled direct mode with breathing effect */
-    PALIT_V2_STATIC_BREATHING                    = 0x22,
-};
-
-class PalitGPUv2Controller
-{
-public:
-    PalitGPUv2Controller(i2c_smbus_interface* bus, palit_gpu_dev_id, std::string dev_name);
-    ~PalitGPUv2Controller();
-
-    std::string   GetDeviceLocation();
-    std::string   GetDeviceName();
-
-    unsigned char GetLEDRed();
-    unsigned char GetLEDGreen();
-    unsigned char GetLEDBlue();
-    void          SetLEDColors(unsigned char red, unsigned char green, unsigned char blue, unsigned char color_register = PALIT_V2_COLOR_REGISTER_PRIMARY);
-    void          SetMode(unsigned char mode, unsigned char speed, unsigned char direct_mode = PALIT_V2_STATIC_SOFTWARE);
-    void          SetBreathingSpeed(unsigned int speed);
-    void          SetDirection(unsigned char direction);
-    void          SetOff();
-    void          SetCycle(unsigned char speed);
-    void          SetStrobe(unsigned char r, unsigned char g, unsigned char b, unsigned char speed, unsigned char brightness);
-    void          SetDirect(unsigned char red, unsigned char green, unsigned char blue, unsigned char brightness);
-
-private:
-    i2c_smbus_interface *   bus;
-    palit_gpu_dev_id        dev;
-    std::string             name;
-
-    void            WriteI2CData(u8 command, u8 length, u8* data);
-};

Controllers/PalitGPUController/RGBController_PalitGPU.cpp

@@ -0,0 +1,112 @@
+/*---------------------------------------------------------*\
+| RGBController_PalitGPU.cpp                                |
+|                                                           |
+|   RGBController for Palit GPU                             |
+|                                                           |
+|   Manatsawin Hanmongkolchai                   11 Apr 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_PalitGPU.h"
+
+/**------------------------------------------------------------------*\
+    @name Palit GPU
+    @category GPU
+    @type I2C
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectPalitGPUControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_PalitGPU::RGBController_PalitGPU(PalitGPUController* controller_ptr)
+{
+    controller              = controller_ptr;
+
+    name                    = controller->GetName();
+    vendor                  = "Palit";
+    description             = "Legacy Palit RGB GPU Device";
+    location                = controller->GetDeviceLocation();
+
+    type                    = DEVICE_TYPE_GPU;
+
+    mode Direct;
+    Direct.name             = "Direct";
+    Direct.value            = PALIT_GPU_MODE_DIRECT;
+    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+
+    // Initialize active mode
+    active_mode = 0;
+}
+
+RGBController_PalitGPU::~RGBController_PalitGPU()
+{
+    Shutdown();
+
+    delete controller;
+}
+
+void RGBController_PalitGPU::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | This device only has one LED, so create a single zone and |
+    | LED for it                                                |
+    \*---------------------------------------------------------*/
+    zone* new_zone          = new zone();
+    led*  new_led           = new led();
+
+    new_zone->name          = "GPU Zone";
+    new_zone->type          = ZONE_TYPE_SINGLE;
+    new_zone->leds_min      = 1;
+    new_zone->leds_max      = 1;
+    new_zone->leds_count    = 1;
+
+    new_led->name           = "GPU LED";
+
+    /*---------------------------------------------------------*\
+    | Push the zone and LED on to device vectors                |
+    \*---------------------------------------------------------*/
+    leds.push_back(*new_led);
+    zones.push_back(*new_zone);
+    SetupColors();
+}
+
+void RGBController_PalitGPU::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_PalitGPU::DeviceUpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_PalitGPU::DeviceUpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_PalitGPU::DeviceUpdateMode()
+{
+    RGBColor      color = colors[0];
+    unsigned char r     = RGBGetRValue(color);
+    unsigned char g     = RGBGetGValue(color);
+    unsigned char b     = RGBGetBValue(color);
+
+    switch(modes[active_mode].value)
+    {
+        case PALIT_GPU_MODE_DIRECT:
+            controller->SetDirect(r, g, b);
+            break;
+
+        default:
+            break;
+    }
+}

Controllers/PalitGPUController/RGBController_PalitGPU.h

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------*\
+| RGBController_PalitGPU.h                                  |
+|                                                           |
+|   RGBController for Palit GPU                             |
+|                                                           |
+|   Manatsawin Hanmongkolchai                   11 Apr 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "PalitGPUController.h"
+
+class RGBController_PalitGPU : public RGBController
+{
+public:
+    RGBController_PalitGPU(PalitGPUController* controller_ptr);
+    ~RGBController_PalitGPU();
+
+    void        SetupZones();
+
+    void        DeviceUpdateLEDs();
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    PalitGPUController* controller;
+};

Controllers/PalitGPUController/RGBController_PalitGPUv1.cpp

@@ -1,110 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_PalitGPUv1.cpp                              |
-|                                                           |
-|   RGBController for Palit v1 GPU                          |
-|                                                           |
-|   TheRogueZeta                                05 Nov 2020 |
-|   Manatsawin Hanmongkolchai                   11 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBController_PalitGPUv1.h"
-
-/**------------------------------------------------------------------*\
-    @name Palit GPU v1
-    @category GPU
-    @type I2C
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectPalitGPUControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_PalitGPUv1::RGBController_PalitGPUv1(PalitGPUv1Controller* controller_ptr)
-{
-    controller              = controller_ptr;
-
-    name                    = controller->GetDeviceName();
-    vendor                  = "Palit";
-    type                    = DEVICE_TYPE_GPU;
-    description             = "Palit GPU V1 Device";
-    location                = controller->GetDeviceLocation();
-
-    mode Direct;
-    Direct.name             = "Direct";
-    Direct.value            = 1;
-    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode       = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-}
-
-RGBController_PalitGPUv1::~RGBController_PalitGPUv1()
-{
-    Shutdown();
-
-    delete controller;
-}
-
-void RGBController_PalitGPUv1::SetupZones()
-{
-    /*-----------------------------------------------------*\
-    | Set up zone                                           |
-    \*-----------------------------------------------------*/
-    zone palit_gpu_zone;
-    palit_gpu_zone.name              = "GPU";
-    palit_gpu_zone.type              = ZONE_TYPE_SINGLE;
-    palit_gpu_zone.leds_min          = 1;
-    palit_gpu_zone.leds_max          = 1;
-    palit_gpu_zone.leds_count        = 1;
-    zones.push_back(palit_gpu_zone);
-
-    /*-----------------------------------------------------*\
-    | Set up LED                                            |
-    \*-----------------------------------------------------*/
-    led palit_gpu_led;
-    palit_gpu_led.name               = "GPU";
-    leds.push_back(palit_gpu_led);
-
-    SetupColors();
-
-    /*-----------------------------------------------------*\
-    | Initialize color                                      |
-    \*-----------------------------------------------------*/
-    unsigned char red = controller->GetLEDRed();
-    unsigned char grn = controller->GetLEDGreen();
-    unsigned char blu = controller->GetLEDBlue();
-
-    colors[0] =  ToRGBColor(red, grn, blu);
-}
-
-void RGBController_PalitGPUv1::DeviceUpdateLEDs()
-{
-    for(std::size_t led = 0; led < colors.size(); led++)
-    {
-        unsigned char red = RGBGetRValue(colors[led]);
-        unsigned char grn = RGBGetGValue(colors[led]);
-        unsigned char blu = RGBGetBValue(colors[led]);
-
-        controller->SetLEDColors(red, grn, blu);
-    }
-}
-
-void RGBController_PalitGPUv1::DeviceUpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_PalitGPUv1::DeviceUpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_PalitGPUv1::DeviceUpdateMode()
-{
-
-}

Controllers/PalitGPUController/RGBController_PalitGPUv2.cpp

@@ -1,217 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_PalitGPUv2.cpp                              |
-|                                                           |
-|   RGBController for Palit v2 GPU                          |
-|                                                           |
-|   KundaPanda                                  04 Jan 2021 |
-|   KendallMorgan                               17 Oct 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBController_PalitGPUv2.h"
-
-/**------------------------------------------------------------------*\
-    @name Palit GPU v2
-    @category GPU
-    @type I2C
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectPalitGPUControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_PalitGPUv2::RGBController_PalitGPUv2(PalitGPUv2Controller* controller_ptr)
-{
-    controller                  = controller_ptr;
-
-    name                        = controller->GetDeviceName();
-    vendor                      = "Palit";
-    type                        = DEVICE_TYPE_GPU;
-    description                 = "Palit GPU V2 Device";
-    location                    = controller->GetDeviceLocation();
-
-    /*-----------------------------------------------------*\
-    | Off mode                                              |
-    \*-----------------------------------------------------*/
-    mode Off;
-    Off.name                    = "Off";
-    Off.value                   = PALIT_V2_MODE_ID_OFF;
-    Off.flags                   = 0;
-    Off.color_mode              = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    /*-----------------------------------------------------*\
-    | Direct mode                                           |
-    \*-----------------------------------------------------*/
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = PALIT_V2_MODE_ID_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.brightness           = 255;
-    Direct.brightness_min       = 0;
-    Direct.brightness_max       = 100;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    /*-----------------------------------------------------*\
-    | Breathing mode                                        |
-    \*-----------------------------------------------------*/
-    mode Breathe;
-    Breathe.name                = "Breathing";
-    Breathe.value               = PALIT_V2_MODE_ID_BREATHING;
-    Breathe.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathe.speed_max           = 0x000a;
-    Breathe.speed_min           = 0x1324;
-    Breathe.color_mode          = MODE_COLORS_MODE_SPECIFIC;
-    Breathe.colors_min          = 2;
-    Breathe.colors_max          = 2;
-    Breathe.colors.resize(2);
-    modes.push_back(Breathe);
-
-    /*-----------------------------------------------------*\
-    | Spectrum Cycle mode                                   |
-    \*-----------------------------------------------------*/
-    mode SpectrumCycle;
-    SpectrumCycle.name          = "Spectrum Cycle";
-    SpectrumCycle.value         = PALIT_V2_MODE_ID_CYCLE;
-    SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    SpectrumCycle.speed         = 3;
-    SpectrumCycle.speed_max     = 0;
-    SpectrumCycle.speed_min     = 100;
-    SpectrumCycle.color_mode    = MODE_COLORS_NONE;
-    modes.push_back(SpectrumCycle);
-
-    /*-----------------------------------------------------*\
-    | Strobe mode                                           |
-    \*-----------------------------------------------------*/
-    mode Strobe;
-    Strobe.name                 = "Strobe";
-    Strobe.value                = PALIT_V2_MODE_ID_STROBE;
-    Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Strobe.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Strobe.colors_min           = 1;
-    Strobe.colors_max           = 1;
-    Strobe.colors.resize(1);
-    Strobe.speed_max            = 0x0;
-    Strobe.speed_min            = 0xF;
-    modes.push_back(Strobe);
-
-    SetupZones();
-
-    active_mode = 0;
-}
-
-RGBController_PalitGPUv2::~RGBController_PalitGPUv2()
-{
-    Shutdown();
-
-    delete controller;
-}
-
-void RGBController_PalitGPUv2::SetupZones()
-{
-    zone* new_zone = new zone();
-    led*  new_led  = new led();
-
-    new_zone->name          = "GPU Zone";
-    new_zone->type          = ZONE_TYPE_SINGLE;
-    new_zone->leds_min      = 1;
-    new_zone->leds_max      = 1;
-    new_zone->leds_count    = 1;
-
-    new_led->name           = "GPU LED";
-
-    leds.push_back(*new_led);
-    zones.push_back(*new_zone);
-    SetupColors();
-
-    unsigned char red = controller->GetLEDRed();
-    unsigned char grn = controller->GetLEDGreen();
-    unsigned char blu = controller->GetLEDBlue();
-
-    colors[0] =  ToRGBColor(red, grn, blu);
-}
-
-void RGBController_PalitGPUv2::DeviceUpdateLEDs()
-{
-    for(unsigned int color : colors)
-    {
-        unsigned char red = RGBGetRValue(color);
-        unsigned char grn = RGBGetGValue(color);
-        unsigned char blu = RGBGetBValue(color);
-
-        controller->SetLEDColors(red, grn, blu);
-        controller->SetMode(PALIT_V2_MODE_STATIC, 0x2);
-    }
-}
-
-void RGBController_PalitGPUv2::DeviceUpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_PalitGPUv2::DeviceUpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_PalitGPUv2::DeviceUpdateMode()
-{
-    RGBColor      color = colors[0];
-    unsigned char r     = RGBGetRValue(color);
-    unsigned char g     = RGBGetGValue(color);
-    unsigned char b     = RGBGetBValue(color);
-
-    switch(modes[active_mode].value)
-    {
-        case PALIT_V2_MODE_ID_OFF:
-            controller->SetOff();
-            break;
-
-        case PALIT_V2_MODE_ID_DIRECT:
-            controller->SetDirect(r, g, b, modes[active_mode].brightness);
-            break;
-
-        case PALIT_V2_MODE_ID_BREATHING:
-            {
-                controller->SetBreathingSpeed(modes[active_mode].speed);
-
-                unsigned char r1 = RGBGetRValue(modes[active_mode].colors[0]);
-                unsigned char g1 = RGBGetGValue(modes[active_mode].colors[0]);
-                unsigned char b1 = RGBGetBValue(modes[active_mode].colors[0]);
-                controller->SetLEDColors(r1, g1, b1);
-
-                unsigned char r2 = RGBGetRValue(modes[active_mode].colors[1]);
-                unsigned char g2 = RGBGetGValue(modes[active_mode].colors[1]);
-                unsigned char b2 = RGBGetBValue(modes[active_mode].colors[1]);
-                controller->SetLEDColors(r2, g2, b2, PALIT_V2_COLOR_REGISTER_SECONDARY);
-                controller->SetMode(PALIT_V2_MODE_STATIC, 0x2, PALIT_V2_STATIC_BREATHING);
-            }
-            break;
-
-        case PALIT_V2_MODE_ID_CYCLE:
-            controller->SetMode(PALIT_V2_MODE_CYCLE, (unsigned char)(modes[active_mode].speed));
-            controller->SetDirection(modes[active_mode].direction);
-            break;
-
-        case PALIT_V2_MODE_ID_STROBE:
-            {
-                mode current_mode = modes[(unsigned int)active_mode];
-
-                unsigned char r_strobe = RGBGetRValue(current_mode.colors[0]);
-                unsigned char g_strobe = RGBGetGValue(current_mode.colors[0]);
-                unsigned char b_strobe = RGBGetBValue(current_mode.colors[0]);
-                controller->SetLEDColors(r_strobe, g_strobe, b_strobe, PALIT_V2_COLOR_REGISTER_TERTIARY);
-
-                controller->SetMode(PALIT_V2_MODE_STROBE, (unsigned char)(current_mode.speed));
-                controller->SetDirection(current_mode.direction);
-            }
-            break;
-
-        default:
-            break;
-    }
-}

Controllers/RazerController/RazerController/RazerController.cpp

@@ -127,8 +127,6 @@ RazerController::RazerController(hid_device* dev_handle, hid_device* dev_argb_ha
         case RAZER_NAGA_LEFT_HANDED_PID:
         case RAZER_NAGA_PRO_V2_WIRED_PID:
         case RAZER_NAGA_PRO_V2_WIRELESS_PID:
-        case RAZER_NAGA_PRO_V3_WIRED_PID:
-        case RAZER_NAGA_PRO_V3_WIRELESS_PID:
         case RAZER_O11_DYNAMIC_PID:
         case RAZER_STRIDER_CHROMA_PID:
         case RAZER_TARTARUS_PRO_PID:

Controllers/RazerController/RazerControllerDetect.cpp

@@ -260,7 +260,6 @@ REGISTER_HID_DETECTOR_IPU("Razer Huntsman V2 TKL",                           Det
 REGISTER_HID_DETECTOR_IPU("Razer Huntsman V2",                               DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_V2_PID,                          0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Huntsman V3 Pro",                           DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_V3_PRO_PID,                      0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Huntsman V3 Pro TKL White",                 DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_V3_PRO_TKL_WHITE_PID,            0x03,   0x0C,   0x01);
-REGISTER_HID_DETECTOR_IPU("Razer Huntsman V3 HE Magnetic Mini",              DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_V3_HE_MAGNETIC_MINI_PID,         0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Ornata Chroma",                             DetectRazerControllers,        RAZER_VID,  RAZER_ORNATA_CHROMA_PID,                        0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Ornata Chroma V2",                          DetectRazerControllers,        RAZER_VID,  RAZER_ORNATA_CHROMA_V2_PID,                     0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Ornata V3",                                 DetectRazerControllers,        RAZER_VID,  RAZER_ORNATA_V3_PID,                            0x02,   0x01,   0x02);
@@ -366,8 +365,6 @@ REGISTER_HID_DETECTOR_IPU("Razer Naga Pro (Wired)",                          Det
 REGISTER_HID_DETECTOR_IPU("Razer Naga Pro (Wireless)",                       DetectRazerControllers,        RAZER_VID,  RAZER_NAGA_PRO_WIRELESS_PID,                    0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Naga Pro V2 (Wired)",                       DetectRazerControllers,        RAZER_VID,  RAZER_NAGA_PRO_V2_WIRED_PID,                    0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Naga Pro V2 (Wireless)",                    DetectRazerControllers,        RAZER_VID,  RAZER_NAGA_PRO_V2_WIRELESS_PID,                 0x00,   0x01,   0x02);
-REGISTER_HID_DETECTOR_PU("Razer Naga Pro V3 (Wired)",                        DetectRazerControllers,        RAZER_VID,  RAZER_NAGA_PRO_V3_WIRED_PID,                            0x01,   0x03);
-REGISTER_HID_DETECTOR_PU("Razer Naga Pro V3 (Wireless)",                     DetectRazerControllers,        RAZER_VID,  RAZER_NAGA_PRO_V3_WIRELESS_PID,                         0x01,   0x03);
 REGISTER_HID_DETECTOR_IPU("Razer Viper",                                     DetectRazerControllers,        RAZER_VID,  RAZER_VIPER_PID,                                0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Viper 8kHz",                                DetectRazerControllers,        RAZER_VID,  RAZER_VIPER_8KHZ_PID,                           0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Viper Mini",                                DetectRazerControllers,        RAZER_VID,  RAZER_VIPER_MINI_PID,                           0x00,   0x01,   0x02);

Controllers/RazerController/RazerDevices.cpp

@@ -3141,45 +3141,6 @@ static const razer_device huntsman_v3_pro_tkl_device =
     &razer_huntsman_v3_pro_tkl_layout
 };
 
-/*-------------------------------------------------------------*\
-|  Razer Huntsman V3 HE Magnetic Mini 1532:02E4                 |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       6 Rows, 22 Columns (matrix dims borrowed from Huntsman  |
-|       V3 Pro pending confirmation on real hardware -- extra   |
-|       columns beyond the physical 65% board are simply inert. |
-|       No layout overlay yet: key names fall back to raw       |
-|       matrix positions until the mapping is verified.)        |
-\*-------------------------------------------------------------*/
-static const razer_zone huntsman_v3_he_magnetic_mini_keyboard_zone =
-{
-    ZONE_EN_KEYBOARD,
-    ZONE_TYPE_MATRIX,
-    6,
-    22
-};
-
-static const razer_device huntsman_v3_he_magnetic_mini_device =
-{
-    "Razer Huntsman V3 HE Magnetic Mini",
-    RAZER_HUNTSMAN_V3_HE_MAGNETIC_MINI_PID,
-    DEVICE_TYPE_KEYBOARD,
-    RAZER_MATRIX_TYPE_EXTENDED,
-    0x3F,
-    6,
-    22,
-    {
-        &huntsman_v3_he_magnetic_mini_keyboard_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    },
-    NULL
-};
-
 /*-------------------------------------------------------------------------*\
 |  LAPTOPS                                                                  |
 \*-------------------------------------------------------------------------*/
@@ -7222,81 +7183,6 @@ static const razer_device naga_pro_v2_wireless_device =
     NULL
 };
 
-/*-------------------------------------------------------------*\
-|  Razer Naga Pro V3   1532:00E7 (wired)   1532:00E8 (wireless) |
-|                                                               |
-|  Zone "Logo"                                                  |
-|       Single                                                  |
-|       1 LED                                                   |
-|                                                               |
-|  Zone "Numpad"                                                |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone naga_pro_v3_scroll_wheel_zone =
-{
-    "Scroll Wheel",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_zone naga_pro_v3_logo_zone =
-{
-    "Logo",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_zone naga_pro_v3_numpad_zone =
-{
-    "Numpad",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device naga_pro_v3_wired_device =
-{
-    "Razer Naga Pro V3 (Wired)",
-    RAZER_NAGA_PRO_V3_WIRED_PID,
-    DEVICE_TYPE_MOUSE,
-    RAZER_MATRIX_TYPE_EXTENDED,
-    0x1F,
-    1,
-    3,
-    {
-        &naga_pro_v3_logo_zone,
-        &naga_pro_v3_scroll_wheel_zone,
-        &naga_pro_v3_numpad_zone,
-        NULL,
-        NULL,
-        NULL
-    },
-    NULL
-};
-
-static const razer_device naga_pro_v3_wireless_device =
-{
-    "Razer Naga Pro V3 (Wireless)",
-    RAZER_NAGA_PRO_V3_WIRELESS_PID,
-    DEVICE_TYPE_MOUSE,
-    RAZER_MATRIX_TYPE_EXTENDED,
-    0x1F,
-    1,
-    3,
-    {
-        &naga_pro_v3_logo_zone,
-        &naga_pro_v3_scroll_wheel_zone,
-        &naga_pro_v3_numpad_zone,
-        NULL,
-        NULL,
-        NULL
-    },
-    NULL
-};
-
 /*-------------------------------------------------------------*\
 |  Razer Viper 8kHz 1532:0091                                   |
 |                                                               |
@@ -9560,7 +9446,6 @@ const razer_device* razer_device_list[] =
     &huntsman_v2_tkl_device,
     &huntsman_v3_pro_device,
     &huntsman_v3_pro_tkl_device,
-    &huntsman_v3_he_magnetic_mini_device,
     &ornata_chroma_device,
     &ornata_chroma_v2_device,
     &ornata_v3_device,
@@ -9665,8 +9550,6 @@ const razer_device* razer_device_list[] =
     &naga_pro_wireless_device,
     &naga_pro_v2_wired_device,
     &naga_pro_v2_wireless_device,
-    &naga_pro_v3_wired_device,
-    &naga_pro_v3_wireless_device,
     &viper_8khz_device,
     &viper_mini_device,
     &viper_ultimate_wired_device,

Controllers/RazerController/RazerDevices.h

@@ -124,7 +124,6 @@
 #define RAZER_HUNTSMAN_V2_PID                           0x026C
 #define RAZER_HUNTSMAN_V3_PRO_PID                       0x02A6
 #define RAZER_HUNTSMAN_V3_PRO_TKL_WHITE_PID             0x02A7
-#define RAZER_HUNTSMAN_V3_HE_MAGNETIC_MINI_PID          0x02E4
 #define RAZER_ORBWEAVER_CHROMA_PID                      0x0207
 #define RAZER_ORNATA_CHROMA_PID                         0x021E
 #define RAZER_ORNATA_CHROMA_V2_PID                      0x025D
@@ -213,8 +212,6 @@
 #define RAZER_NAGA_PRO_WIRELESS_PID                     0x0090
 #define RAZER_NAGA_PRO_V2_WIRED_PID                     0x00A7
 #define RAZER_NAGA_PRO_V2_WIRELESS_PID                  0x00A8
-#define RAZER_NAGA_PRO_V3_WIRED_PID                     0x00E7
-#define RAZER_NAGA_PRO_V3_WIRELESS_PID                  0x00E8
 #define RAZER_OROCHI_2011_PID                           0x0013
 #define RAZER_OROCHI_2013_PID                           0x0039
 #define RAZER_OROCHI_CHROMA_PID                         0x0048

Controllers/SapphireGPUController/SapphireGPUControllerDetect.cpp

@@ -97,5 +97,4 @@ REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 9060 XT Pure",
 REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 9060 XT Nitro+",                     DetectSapphireV3Controllers,    AMD_GPU_VEN,    AMD_NAVI48_DEV1,        SAPPHIRE_SUB_VEN,           SAPPHIRE_NAVI48_NITRO_PLUS_SUB_DEV1,            SAPPHIRE_NITRO_GLOW_V3_ADDR);
 REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 9070 Pure",                          DetectSapphireV3Controllers,    AMD_GPU_VEN,    AMD_NAVI48_DEV,         SAPPHIRE_SUB_VEN,           SAPPHIRE_NAVI48_PURE_SUB_DEV,                   SAPPHIRE_NITRO_GLOW_V3_ADDR);
 REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 9070 XT Nitro+",                     DetectSapphireV3Controllers,    AMD_GPU_VEN,    AMD_NAVI48_DEV,         SAPPHIRE_SUB_VEN,           SAPPHIRE_NAVI48_NITRO_PLUS_SUB_DEV,             SAPPHIRE_NITRO_GLOW_V3_ADDR);
-REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 9070 XT Nitro+",                     DetectSapphireV3Controllers,    AMD_GPU_VEN,    AMD_NAVI48_DEV,         SAPPHIRE_SUB_VEN,           SAPPHIRE_NAVI48_NITRO_PLUS_SUB_DEV2,            SAPPHIRE_NITRO_GLOW_V3_ADDR);
 REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 9070 XT Pure",                       DetectSapphireV3Controllers,    AMD_GPU_VEN,    AMD_NAVI48_DEV,         SAPPHIRE_SUB_VEN,           SAPPHIRE_NAVI48_PURE_XT_SUB_DEV,                SAPPHIRE_NITRO_GLOW_V3_ADDR);

Controllers/TurtleBeachKP7Controller/RGBController_TurtleBeachKP7.cpp

@@ -11,66 +11,29 @@
 
 #include <string>
 #include "RGBController_TurtleBeachKP7.h"
-#include "RGBControllerKeyNames.h"
 
+/*---------------------------------------------------------*\
+| Physical LED grid, mapped against the real device.  Six   |
+| columns by ten rows, [y][x] holds the LED index and NA    |
+| marks a grid cell with no LED behind it.                  |
+\*---------------------------------------------------------*/
 #define NA                                          0xFFFFFFFF
 
-/*---------------------------------------------------------*\
-| The 33 LEDs are exposed as three zones: the Num Lock and  |
-| Shift Mode indicators along the top, the main keypad, and |
-| the two wrist rest LEDs, mirroring the split used for the |
-| KB7.                                                      |
-\*---------------------------------------------------------*/
-#define TURTLE_BEACH_KP7_INDICATOR_COUNT            3
-#define TURTLE_BEACH_KP7_KEYPAD_COUNT               28
-#define TURTLE_BEACH_KP7_WRIST_COUNT                2
-
-/*---------------------------------------------------------*\
-| The device numbers its LEDs 0-32 in an order that does    |
-| not follow the zone layout, so this table maps each LED   |
-| in zone/presentation order to its slot in the device's    |
-| color buffer.  Order: the three indicator LEDs, then the  |
-| keypad (the F13-F15 / profile row, then the number grid   |
-| row by row with that row's mode key last, then 0 / . /    |
-| Enter, then the space bar), then the two wrist rest LEDs. |
-\*---------------------------------------------------------*/
-static const unsigned int turtle_beach_kp7_led_order[TURTLE_BEACH_KP7_LED_COUNT] =
-{
-    28, 29, 30,
-    21,  0,  7, 14,
-     8, 22, 15,  1, 11,
-    23,  2,  9,  4, 18,
-    10, 24, 16, 25,  5,
-    17,  3, 13, 12, 19,
-    27,  6, 20,
-    26,
-    31, 32,
-};
-
-/*---------------------------------------------------------*\
-| Physical grid for the keypad zone.  [y][x] holds the LED  |
-| index within that zone (0-27, an index into the keypad    |
-| slice of the LED list, not the device LED number) and NA  |
-| marks a cell with no LED behind it.  Row 0 is the F13-F15 |
-| and profile switch row; the mode keys form the rightmost  |
-| column.  The two + keys and the two Enter keys are each   |
-| a stacked pair in one column, all normal size; the space  |
-| bar sits directly under the lower Enter so the device     |
-| view does not auto-grow that Enter downward.  The 0 key   |
-| is double width, filling the empty cell to its right.     |
-\*---------------------------------------------------------*/
-#define TURTLE_BEACH_KP7_MATRIX_HEIGHT              7
-#define TURTLE_BEACH_KP7_MATRIX_WIDTH               5
+#define TURTLE_BEACH_KP7_MATRIX_HEIGHT              10
+#define TURTLE_BEACH_KP7_MATRIX_WIDTH               6
 
 static unsigned int turtle_beach_kp7_matrix_map[TURTLE_BEACH_KP7_MATRIX_HEIGHT][TURTLE_BEACH_KP7_MATRIX_WIDTH] =
 {
-    {   0,   1,   2,   3,  NA },
-    {   4,   5,   6,   7,   8 },
-    {   9,  10,  11,  12,  13 },
-    {  14,  15,  16,  17,  18 },
-    {  19,  20,  21,  22,  23 },
-    {  24,  NA,  25,  26,  NA },
-    {  NA,  NA,  NA,  27,  NA },
+    {  28,  NA,  29,  NA,  NA,  30 },
+    {  NA,  NA,  NA,  NA,  NA,  NA },
+    {  21,   0,   7,  14,  NA,  NA },
+    {  NA,  NA,  NA,  NA,  NA,  NA },
+    {   8,  22,  15,   1,  NA,  11 },
+    {  23,   2,   9,   4,  NA,  18 },
+    {  10,  24,  16,  25,  NA,   5 },
+    {  17,   3,  13,  12,  NA,  19 },
+    {  27,  NA,   6,  20,  NA,  NA },
+    {  31,  32,  NA,  26,  NA,  NA },
 };
 
 /**------------------------------------------------------------------*\
@@ -84,9 +47,7 @@ static unsigned int turtle_beach_kp7_matrix_map[TURTLE_BEACH_KP7_MATRIX_HEIGHT][
     @comment Only the raw per-LED color stream is implemented.  The
              onboard effects, the macro and profile feature report
              channel on report ID 0x11, and the internal hub the KB7
-             dock exposes as PID 0x503E are not handled.  LEDs are
-             split into Indicators, Keypad, and Wrist Rest zones; the
-             keypad zone carries a matrix map.
+             dock exposes as PID 0x503E are not handled.
 \*-------------------------------------------------------------------*/
 
 RGBController_TurtleBeachKP7::RGBController_TurtleBeachKP7(TurtleBeachKP7Controller* controller_ptr)
@@ -119,100 +80,28 @@ RGBController_TurtleBeachKP7::~RGBController_TurtleBeachKP7()
 
 void RGBController_TurtleBeachKP7::SetupZones()
 {
-    /*-----------------------------------------------------*\
-    | LED names in zone/presentation order.  Local arrays   |
-    | rather than file scope ones because the KEY_EN_       |
-    | values live in another translation unit and are not   |
-    | safe to read during static initialization.  The two   |
-    | indicator LEDs and the shift mode key are status      |
-    | lights rather than typing keys, so they get plain     |
-    | names.                                                |
-    \*-----------------------------------------------------*/
-    const char* indicator_names[TURTLE_BEACH_KP7_INDICATOR_COUNT] =
-    {
-        "Num Lock Indicator", "Shift Mode Indicator", "Key: Shift Mode",
-    };
+    zone kp7_zone;
 
-    const char* keypad_names[TURTLE_BEACH_KP7_KEYPAD_COUNT] =
-    {
-        KEY_EN_F13,         KEY_EN_F14,          KEY_EN_F15,          "Key: Profile Switch",
+    kp7_zone.name               = "Keypad";
+    kp7_zone.type               = ZONE_TYPE_MATRIX;
+    kp7_zone.leds_min           = TURTLE_BEACH_KP7_LED_COUNT;
+    kp7_zone.leds_max           = TURTLE_BEACH_KP7_LED_COUNT;
+    kp7_zone.leds_count         = TURTLE_BEACH_KP7_LED_COUNT;
 
-        KEY_EN_NUMPAD_LOCK, KEY_EN_NUMPAD_DIVIDE, KEY_EN_NUMPAD_TIMES, KEY_EN_NUMPAD_MINUS, "Key: Mode 1",
-        KEY_EN_NUMPAD_7,    KEY_EN_NUMPAD_8,     KEY_EN_NUMPAD_9,     KEY_EN_NUMPAD_PLUS,   "Key: Mode 2",
-        KEY_EN_NUMPAD_4,    KEY_EN_NUMPAD_5,     KEY_EN_NUMPAD_6,     KEY_EN_NUMPAD_PLUS,   "Key: Mode 3",
-        KEY_EN_NUMPAD_1,    KEY_EN_NUMPAD_2,     KEY_EN_NUMPAD_3,     KEY_EN_NUMPAD_ENTER,  "Key: Mode 4",
-        KEY_EN_NUMPAD_0,    KEY_EN_NUMPAD_PERIOD, KEY_EN_NUMPAD_ENTER,
+    kp7_zone.matrix_map.Set(TURTLE_BEACH_KP7_MATRIX_HEIGHT, TURTLE_BEACH_KP7_MATRIX_WIDTH, (unsigned int*)&turtle_beach_kp7_matrix_map);
 
-        KEY_EN_SPACE,
-    };
+    zones.push_back(kp7_zone);
 
-    /*-----------------------------------------------------*\
-    | Three zones: the indicator LEDs, the keypad, and the  |
-    | wrist rest.  Only the keypad carries a matrix map;    |
-    | the other two are short linear strips.                |
-    \*-----------------------------------------------------*/
-    zone indicator_zone;
-
-    indicator_zone.name         = "Indicators";
-    indicator_zone.type         = ZONE_TYPE_LINEAR;
-    indicator_zone.leds_min     = TURTLE_BEACH_KP7_INDICATOR_COUNT;
-    indicator_zone.leds_max     = TURTLE_BEACH_KP7_INDICATOR_COUNT;
-    indicator_zone.leds_count   = TURTLE_BEACH_KP7_INDICATOR_COUNT;
-
-    zones.push_back(indicator_zone);
-
-    zone keypad_zone;
-
-    keypad_zone.name            = "Keypad";
-    keypad_zone.type            = ZONE_TYPE_MATRIX;
-    keypad_zone.leds_min        = TURTLE_BEACH_KP7_KEYPAD_COUNT;
-    keypad_zone.leds_max        = TURTLE_BEACH_KP7_KEYPAD_COUNT;
-    keypad_zone.leds_count      = TURTLE_BEACH_KP7_KEYPAD_COUNT;
-
-    keypad_zone.matrix_map.Set(TURTLE_BEACH_KP7_MATRIX_HEIGHT, TURTLE_BEACH_KP7_MATRIX_WIDTH, (unsigned int*)&turtle_beach_kp7_matrix_map);
-
-    zones.push_back(keypad_zone);
-
-    zone wrist_zone;
-
-    wrist_zone.name             = "Wrist Rest";
-    wrist_zone.type             = ZONE_TYPE_LINEAR;
-    wrist_zone.leds_min         = TURTLE_BEACH_KP7_WRIST_COUNT;
-    wrist_zone.leds_max         = TURTLE_BEACH_KP7_WRIST_COUNT;
-    wrist_zone.leds_count       = TURTLE_BEACH_KP7_WRIST_COUNT;
-
-    zones.push_back(wrist_zone);
-
-    for(unsigned int led_idx = 0; led_idx < TURTLE_BEACH_KP7_INDICATOR_COUNT; led_idx++)
+    for(unsigned int led_idx = 0; led_idx < TURTLE_BEACH_KP7_LED_COUNT; led_idx++)
     {
         led new_led;
 
-        new_led.name            = indicator_names[led_idx];
+        new_led.name            = "LED " + std::to_string(led_idx + 1);
         new_led.value           = led_idx;
 
         leds.push_back(new_led);
     }
 
-    for(unsigned int led_idx = 0; led_idx < TURTLE_BEACH_KP7_KEYPAD_COUNT; led_idx++)
-    {
-        led new_led;
-
-        new_led.name            = keypad_names[led_idx];
-        new_led.value           = TURTLE_BEACH_KP7_INDICATOR_COUNT + led_idx;
-
-        leds.push_back(new_led);
-    }
-
-    for(unsigned int led_idx = 0; led_idx < TURTLE_BEACH_KP7_WRIST_COUNT; led_idx++)
-    {
-        led new_led;
-
-        new_led.name            = "Wrist Rest " + std::to_string(led_idx + 1);
-        new_led.value           = TURTLE_BEACH_KP7_INDICATOR_COUNT + TURTLE_BEACH_KP7_KEYPAD_COUNT + led_idx;
-
-        leds.push_back(new_led);
-    }
-
     SetupColors();
 }
 
@@ -220,17 +109,11 @@ void RGBController_TurtleBeachKP7::DeviceUpdateLEDs()
 {
     unsigned char led_data[TURTLE_BEACH_KP7_LED_COUNT * 3] = { 0 };
 
-    /*-----------------------------------------------------*\
-    | colors[] is in zone order; turtle_beach_kp7_led_order |
-    | gives the device color-buffer slot for each one.      |
-    \*-----------------------------------------------------*/
     for(unsigned int led_idx = 0; (led_idx < colors.size()) && (led_idx < TURTLE_BEACH_KP7_LED_COUNT); led_idx++)
     {
-        unsigned int dev_led = turtle_beach_kp7_led_order[led_idx];
-
-        led_data[(dev_led * 3) + 0] = RGBGetRValue(colors[led_idx]);
-        led_data[(dev_led * 3) + 1] = RGBGetGValue(colors[led_idx]);
-        led_data[(dev_led * 3) + 2] = RGBGetBValue(colors[led_idx]);
+        led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx]);
+        led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx]);
+        led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx]);
     }
 
     controller->SendDirect(led_data, sizeof(led_data));

DetectionManager.cpp

@@ -1428,7 +1428,7 @@ void DetectionManager::BackgroundHIDInit()
             .hid_enumerate                      = (hidapi_wrapper_enumerate)                    dlsym(hidapi_libusb_handle,"hid_enumerate"),
             .hid_free_enumeration               = (hidapi_wrapper_free_enumeration)             dlsym(hidapi_libusb_handle,"hid_free_enumeration"),
             .hid_close                          = (hidapi_wrapper_close)                        dlsym(hidapi_libusb_handle,"hid_close"),
-            .hid_error                          = (hidapi_wrapper_error)                        dlsym(hidapi_libusb_handle,"hid_error"),
+            .hid_error                          = (hidapi_wrapper_error)                        dlsym(hidapi_libusb_handle,"hid_free_enumeration"),
 #if(HID_HOTPLUG_ENABLED)
             .hid_hotplug_register_callback      = (hidapi_wrapper_hotplug_register_callback)    dlsym(hidapi_libusb_handle,"hid_hotplug_register_callback"),
             .hid_hotplug_deregister_callback    = (hidapi_wrapper_hotplug_deregister_callback)  dlsym(hidapi_libusb_handle,"hid_hotplug_deregister_callback"),

NetworkClient.cpp

@@ -86,7 +86,6 @@ NetworkClient::NetworkClient()
     client_is_local_client              = false;
     client_string_sent                  = false;
     client_sock                         = -1;
-    connect_timeout                     = 4000;
     detection_percent                   = 100;
     detection_string                    = "";
     protocol_initialized                = false;
@@ -404,11 +403,6 @@ void NetworkClient::RequestLocalClient(bool request_local)
     }
 }
 
-void NetworkClient::SetConnectTimeout(unsigned int timeout_ms)
-{
-    connect_timeout = timeout_ms;
-}
-
 void NetworkClient::SetIP(std::string new_ip)
 {
     if(server_connected == false)
@@ -1724,7 +1718,7 @@ void NetworkClient::ConnectionThreadFunction()
             /*---------------------------------------------*\
             | Try to connect to server                      |
             \*---------------------------------------------*/
-            if(port.tcp_client_connect(connect_timeout) == true)
+            if(port.tcp_client_connect() == true)
             {
                 client_sock = port.sock;
                 LOG_INFO("[%s] Connected to server", NETWORKCLIENT);

NetworkClient.h

@@ -97,7 +97,6 @@ public:
     | Client Control functions                              |
     \*-----------------------------------------------------*/
     void                                RequestLocalClient(bool request_local);
-    void                                SetConnectTimeout(unsigned int timeout_ms);
     void                                SetIP(std::string new_ip);
     void                                SetName(std::string new_name);
     void                                SetPort(unsigned short new_port);
@@ -199,7 +198,6 @@ private:
     bool                                client_flags_sent;
     bool                                client_is_local_client;
     bool                                client_string_sent;
-    unsigned int                        connect_timeout;
     bool                                controller_data_received;
     bool                                controller_data_requested;
     bool                                protocol_initialized;

NetworkServer.cpp

@@ -3793,19 +3793,18 @@ void NetworkServer::SendReply_ServerString(NetworkClientInfo* client_info)
 
 void NetworkServer::SendReply_PluginList(NetworkClientInfo* client_info)
 {
-    unsigned int    data_ptr    = 0;
-    unsigned int    data_size   = 0;
-    unsigned short  num_plugins = 0;
-
-    /*-----------------------------------------------------*\
-    | Calculate data size                                   |
-    \*-----------------------------------------------------*/
-    data_size += sizeof(data_size);
-    data_size += sizeof(num_plugins);
-
     if(plugin_manager)
     {
-        num_plugins = (unsigned short)plugin_manager->GetPluginCount();
+        unsigned int data_size = 0;
+        unsigned int data_ptr = 0;
+
+        /*-------------------------------------------------*\
+        | Calculate data size                               |
+        \*-------------------------------------------------*/
+        unsigned short num_plugins = (unsigned short)plugin_manager->GetPluginCount();
+
+        data_size += sizeof(data_size);
+        data_size += sizeof(num_plugins);
 
         for(unsigned int i = 0; i < num_plugins; i++)
         {
@@ -3815,27 +3814,24 @@ void NetworkServer::SendReply_PluginList(NetworkClientInfo* client_info)
             data_size += (unsigned int)strlen(plugin_manager->GetPluginVersion(i).c_str()) + 1;
             data_size += sizeof(unsigned int) * 2;
         }
-    }
 
-    /*-----------------------------------------------------*\
-    | Create data buffer                                    |
-    \*-----------------------------------------------------*/
-    unsigned char* data_buf = new unsigned char[data_size];
+        /*-------------------------------------------------*\
+        | Create data buffer                                |
+        \*-------------------------------------------------*/
+        unsigned char* data_buf = new unsigned char[data_size];
 
-    /*-----------------------------------------------------*\
-    | Copy in data size                                     |
-    \*-----------------------------------------------------*/
-    memcpy(&data_buf[data_ptr], &data_size, sizeof(data_size));
-    data_ptr += sizeof(data_size);
+        /*-------------------------------------------------*\
+        | Copy in data size                                 |
+        \*-------------------------------------------------*/
+        memcpy(&data_buf[data_ptr], &data_size, sizeof(data_size));
+        data_ptr += sizeof(data_size);
 
-    /*-----------------------------------------------------*\
-    | Copy in num_plugins                                   |
-    \*-----------------------------------------------------*/
-    memcpy(&data_buf[data_ptr], &num_plugins, sizeof(num_plugins));
-    data_ptr += sizeof(num_plugins);
+        /*-------------------------------------------------*\
+        | Copy in num_plugins                               |
+        \*-------------------------------------------------*/
+        memcpy(&data_buf[data_ptr], &num_plugins, sizeof(num_plugins));
+        data_ptr += sizeof(num_plugins);
 
-    if(plugin_manager)
-    {
         for(unsigned int i = 0; i < num_plugins; i++)
         {
             /*---------------------------------------------*\
@@ -3884,21 +3880,21 @@ void NetworkServer::SendReply_PluginList(NetworkClientInfo* client_info)
             memcpy(&data_buf[data_ptr], &protocol_version, sizeof(unsigned int));
             data_ptr += sizeof(unsigned int);
         }
+
+        NetPacketHeader reply_hdr;
+        unsigned int reply_size;
+
+        memcpy(&reply_size, data_buf, sizeof(reply_size));
+
+        InitNetPacketHeader(&reply_hdr, 0, NET_PACKET_ID_PLUGINMANAGER_GET_PLUGIN_LIST, reply_size);
+
+        send_in_progress.lock();
+        send(client_info->client_sock, (const char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
+        send(client_info->client_sock, (const char *)data_buf, reply_size, MSG_NOSIGNAL);
+        send_in_progress.unlock();
+
+        delete [] data_buf;
     }
-
-    NetPacketHeader reply_hdr;
-    unsigned int reply_size;
-
-    memcpy(&reply_size, data_buf, sizeof(reply_size));
-
-    InitNetPacketHeader(&reply_hdr, 0, NET_PACKET_ID_PLUGINMANAGER_GET_PLUGIN_LIST, reply_size);
-
-    send_in_progress.lock();
-    send(client_info->client_sock, (const char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
-    send(client_info->client_sock, (const char *)data_buf, reply_size, MSG_NOSIGNAL);
-    send_in_progress.unlock();
-
-    delete [] data_buf;
 }
 
 void NetworkServer::SendReply_PluginSpecific(NetworkClientInfo* client_info, unsigned int data_size, unsigned char* data_ptr, unsigned int pkt_id)

OpenRGB.pro

@@ -24,8 +24,8 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 #-----------------------------------------------------------------------------------------------#
 # Application Configuration                                                                     #
 #-----------------------------------------------------------------------------------------------#
-MAJOR       = 1
-MINOR       = 0
+MAJOR       = 0
+MINOR       = 9
 SUFFIX      = git
 
 SHORTHASH   = $$system("git rev-parse --short=7 HEAD")
@@ -489,23 +489,12 @@ contains(QMAKE_PLATFORM, linux) {
     HEADERS +=                                                                                  \
     dependencies/NVFC/nvapi.h                                                                   \
     i2c_smbus/Linux/i2c_smbus_linux.h                                                           \
+    AutoStart/AutoStart-Linux.h                                                                 \
     SPDAccessor/EE1004Accessor_Linux.h                                                          \
     SPDAccessor/SPD5118Accessor_Linux.h                                                         \
     SuspendResume/SuspendResume_Linux_FreeBSD.h                                                 \
     super_io/super_io.h                                                                         \
 
-    #-------------------------------------------------------------------------------------------#
-    # AutoStart implementation - Flatpak uses portal-based autostart, Linux uses desktop files  #
-    #   Auto-detect Flatpak build environment via /.flatpak-info file                           #
-    #-------------------------------------------------------------------------------------------#
-    exists(/.flatpak-info) {
-        HEADERS += AutoStart/AutoStart-Flatpak.h
-        DEFINES += FLATPAK_BUILD
-        PKGCONFIG += gio-2.0
-    } else {
-        HEADERS += AutoStart/AutoStart-Linux.h
-    }
-
     INCLUDEPATH +=                                                                              \
     dependencies/NVFC                                                                           \
     i2c_smbus/Linux                                                                             \
@@ -570,22 +559,13 @@ contains(QMAKE_PLATFORM, linux) {
     i2c_smbus/Linux/i2c_smbus_linux.cpp                                                         \
     scsiapi/scsiapi_linux.c                                                                     \
     serial_port/find_usb_serial_port_linux.cpp                                                  \
+    AutoStart/AutoStart-Linux.cpp                                                               \
     SPDAccessor/EE1004Accessor_Linux.cpp                                                        \
     SPDAccessor/SPD5118Accessor_Linux.cpp                                                       \
     SuspendResume/SuspendResume_Linux_FreeBSD.cpp                                               \
     startup/main_FreeBSD_Linux_MacOS.cpp                                                        \
     super_io/super_io.cpp                                                                       \
 
-    #-------------------------------------------------------------------------------------------#
-    # AutoStart implementation - Flatpak uses portal-based autostart, Linux uses desktop files  #
-    #   Auto-detect Flatpak build environment via /.flatpak-info file                           #
-    #-------------------------------------------------------------------------------------------#
-    exists(/.flatpak-info) {
-        SOURCES += AutoStart/AutoStart-Flatpak.cpp
-    } else {
-        SOURCES += AutoStart/AutoStart-Linux.cpp
-    }
-
     #-------------------------------------------------------------------------------------------#
     # Set up install paths                                                                      #
     # These install paths are used for AppImage and .deb packaging                              #

ProfileManager.cpp

@@ -163,21 +163,6 @@ ProfileManager::~ProfileManager()
 
 }
 
-void ProfileManager::ApplyActiveProfilePluginData()
-{
-    /*-----------------------------------------------------*\
-    | The server only sends profile data to the clients     |
-    | connected at the time it loads, and plugins only      |
-    | exist in the GUI, so read it back here                |
-    \*-----------------------------------------------------*/
-    if(!active_profile.empty() && ResourceManager::get()->IsLocalClient() && (ResourceManager::get()->GetLocalClient()->GetSupportsProfileManagerAPI()))
-    {
-        LOG_DEBUG("[%s] Reading active profile for plugin data: %s", PROFILEMANAGER, active_profile.c_str());
-
-        OnProfileLoaded(ResourceManager::get()->GetLocalClient()->ProfileManager_DownloadProfile(active_profile));
-    }
-}
-
 void ProfileManager::ClearActiveProfile()
 {
     /*-------------------------------------------------*\
@@ -918,8 +903,6 @@ bool ProfileManager::SaveConfiguration()
     \*-----------------------------------------------------*/
     std::vector<RGBController *> controllers = ResourceManager::get()->GetRGBControllers();
 
-    configuration_save_mutex.lock();
-    
     /*-----------------------------------------------------*\
     | Open an output file in the profile directory          |
     \*-----------------------------------------------------*/
@@ -1022,8 +1005,6 @@ bool ProfileManager::SaveConfiguration()
     \*-----------------------------------------------------*/
     controller_file.close();
 
-    configuration_save_mutex.unlock();
-
     /*-----------------------------------------------------*\
     | Reinitialize manually configured controllers list     |
     \*-----------------------------------------------------*/
@@ -1293,8 +1274,6 @@ bool ProfileManager::LoadAutoProfile(std::string setting_name)
     \*-----------------------------------------------------*/
     if(!profile_name.empty())
     {
-        LOG_INFO("[%s] Loading %s: %s", PROFILEMANAGER, setting_name.c_str(), profile_name.c_str());
-
         return(LoadProfile(profile_name));
     }
     else
@@ -1569,23 +1548,6 @@ bool ProfileManager::LoadProfileWithOptions
     bool            load_state
     )
 {
-    /*-------------------------------------------------*\
-    | Get JSON data for given profile name              |
-    \*-------------------------------------------------*/
-    nlohmann::json profile_json = ReadProfileJSON(profile_name);
-
-    /*-------------------------------------------------*\
-    | Stop here if the profile could not be read.       |
-    | Carrying on would clear the active profile and    |
-    | send an empty profile to connected clients.       |
-    \*-------------------------------------------------*/
-    if(profile_json.empty())
-    {
-        LOG_WARNING("[%s] Profile not found or empty, nothing to load: %s", PROFILEMANAGER, profile_name.c_str());
-
-        return(false);
-    }
-
     /*-------------------------------------------------*\
     | Clear stored active profile data                  |
     \*-------------------------------------------------*/
@@ -1600,6 +1562,11 @@ bool ProfileManager::LoadProfileWithOptions
         delete active_rgb_controllers_copy[controller_idx];
     }
 
+    /*-------------------------------------------------*\
+    | Get JSON data for given profile name              |
+    \*-------------------------------------------------*/
+    nlohmann::json profile_json = ReadProfileJSON(profile_name);
+
     /*-------------------------------------------------*\
     | Load the controller state data for this profile   |
     | into the active profile data                      |

ProfileManager.h

@@ -78,8 +78,6 @@ public:
     ProfileManager(const filesystem::path& config_dir);
     ~ProfileManager();
 
-    void                        ApplyActiveProfilePluginData();
-
     void                        ClearActiveProfile();
 
     void                        DeleteProfile(std::string profile_name);
@@ -158,8 +156,6 @@ private:
     filesystem::path            configuration_directory;
     filesystem::path            profile_directory;
 
-    std::mutex                  configuration_save_mutex;
-    
     /*-----------------------------------------------------*\
     | ProfileManager Callbacks                              |
     \*-----------------------------------------------------*/

RGBController/RGBController.cpp

@@ -3094,31 +3094,9 @@ unsigned char * RGBController::GetZoneDescriptionData(unsigned char* data_ptr, z
 
     /*-----------------------------------------------------*\
     | Copy in zone type                                     |
-    | For protocols below 6, convert the new zone types     |
     \*-----------------------------------------------------*/
-    zone_type type = zone.type;
-
-    if(protocol_version < 6)
-    {
-        switch(type)
-        {
-            case ZONE_TYPE_LINEAR_LOOP:
-                type = ZONE_TYPE_LINEAR;
-                break;
-
-            case ZONE_TYPE_MATRIX_LOOP_X:
-            case ZONE_TYPE_MATRIX_LOOP_Y:
-                type = ZONE_TYPE_MATRIX;
-                break;
-
-            case ZONE_TYPE_SEGMENTED:
-                type = ZONE_TYPE_LINEAR;
-                break;
-        }
-    }
-
-    memcpy(data_ptr, &type, sizeof(type));
-    data_ptr += sizeof(type);
+    memcpy(data_ptr, &zone.type, sizeof(zone.type));
+    data_ptr += sizeof(zone.type);
 
     /*-----------------------------------------------------*\
     | Check for resizable effects-only zone.  For protocol  |

ResourceManager.cpp

@@ -280,12 +280,6 @@ ResourceManager::ResourceManager()
     logmanager_settings_schema["file_count_limit"]["default"]               = 10;
     logmanager_settings_schema["file_count_limit"]["minimum"]               = 0;
 
-    logmanager_settings_schema["dialog_no_show_hashes"]["title"]            = QT_TRANSLATE_NOOP("Settings", "Dialog No-Show Hashes");
-    logmanager_settings_schema["dialog_no_show_hashes"]["type"]             = "array";
-    logmanager_settings_schema["dialog_no_show_hashes"]["description"]      = QT_TRANSLATE_NOOP("Settings", "A list of hashes of dialog text that should not be shown.  Selecting \"Do Not Show Again\" on a dialog adds it to this list.");
-    logmanager_settings_schema["dialog_no_show_hashes"]["items"]["type"]    = "integer";
-    logmanager_settings_schema["dialog_no_show_hashes"]["visible"]          = false;
-
     settings_manager->RegisterSettingsSchema("LogManager", QT_TRANSLATE_NOOP("Settings", "Log Manager"), logmanager_settings_schema);
 
     /*-----------------------------------------------------*\
@@ -1164,7 +1158,6 @@ bool ResourceManager::AttemptLocalConnection()
     titleString.append(VERSION_STRING);
 
     auto_connection_client->RequestLocalClient(true);
-    auto_connection_client->SetConnectTimeout(1000);
     auto_connection_client->SetName(titleString.c_str());
     auto_connection_client->StartClient();
 

SPDAccessor/SPDAccessor.cpp

@@ -66,8 +66,7 @@ const char *spd_memory_type_name[] =
     "LPDDR4",
     "LPDDR4X",
     "DDR5",
-    "LPDDR5",
-    "Unknown"
+    "LPDDR5"
 };
 
 SPDAccessor::SPDAccessor(i2c_smbus_interface *bus, uint8_t spd_addr)
@@ -162,16 +161,7 @@ DDR4Accessor::~DDR4Accessor()
 
 SPDMemoryType DDR4Accessor::memory_type()
 {
-    SPDMemoryType type = (SPDMemoryType)(this->at(BASIC_MEMORY_TYPE_ADDR));
-
-    if(type <= SPD_UNKNOWN)
-    {
-        return(type);
-    }
-    else
-    {
-        return(SPD_UNKNOWN);
-    }
+    return((SPDMemoryType)(this->at(BASIC_MEMORY_TYPE_ADDR)));
 }
 
 uint16_t DDR4Accessor::jedec_id()
@@ -205,16 +195,7 @@ DDR5Accessor::~DDR5Accessor()
 
 SPDMemoryType DDR5Accessor::memory_type()
 {
-    SPDMemoryType type = (SPDMemoryType)(this->at(BASIC_MEMORY_TYPE_ADDR));
-
-    if(type <= SPD_UNKNOWN)
-    {
-        return(type);
-    }
-    else
-    {
-        return(SPD_UNKNOWN);
-    }
+    return((SPDMemoryType)(this->at(BASIC_MEMORY_TYPE_ADDR)));
 }
 
 uint16_t DDR5Accessor::jedec_id()

SPDAccessor/SPDCommon.h

@@ -48,8 +48,7 @@ typedef enum
     SPD_LPDDR4_SDRAM  = 16,
     SPD_LPDDR4X_SDRAM = 17,
     SPD_DDR5_SDRAM    = 18,
-    SPD_LPDDR5_SDRAM  = 19,
-    SPD_UNKNOWN       = 20,
+    SPD_LPDDR5_SDRAM  = 19
 } SPDMemoryType;
 
 #define SPD_IO_DELAY   1ms

SPDAccessor/SPDDetector.cpp

@@ -30,14 +30,7 @@ bool SPDDetector::is_valid() const
 
 SPDMemoryType SPDDetector::memory_type() const
 {
-    if(mem_type <= SPD_UNKNOWN)
-    {
-        return(mem_type);
-    }
-    else
-    {
-        return(SPD_UNKNOWN);
-    }
+    return(mem_type);
 }
 
 void SPDDetector::detect_memory_type()

SPDAccessor/SPDWrapper.cpp

@@ -65,14 +65,7 @@ SPDWrapper::~SPDWrapper()
 
 SPDMemoryType SPDWrapper::memory_type()
 {
-    if(mem_type <= SPD_UNKNOWN)
-    {
-        return(mem_type);
-    }
-    else
-    {
-        return(SPD_UNKNOWN);
-    }
+    return mem_type;
 }
 
 uint8_t SPDWrapper::address()

debian/control

@@ -9,7 +9,7 @@ Build-Depends:
  qt6-base-dev,
  qt6-base-dev-tools,
  qt6-tools-dev-tools,
- qmake6,
+ qt5-qmake,
  libusb-1.0-0-dev,
  libhidapi-hotplug-dev,
  libmbedtls-dev,
@@ -21,7 +21,6 @@ Depends:
  ${shlibs:Depends},
  ${misc:Depends},
  udev,
- libhidapi-hotplug-libusb0,
 Recommends:
  openrgb-dkms-drivers,
 Conflicts:

fedora/OpenRGB.spec.in

@@ -10,10 +10,6 @@ URL:            https://gitlab.com/CalcProgrammer1/%{_name}
 
 BuildRequires:  gcc-c++ libusbx-devel libstdc++-devel qt6-qtbase-devel qt6-linguist desktop-file-utils hidapi-hotplug-devel mbedtls-devel systemd-rpm-macros
 Requires:       hicolor-icon-theme
-Requires:       qt6-qtbase
-Requires:       mbedtls
-Requires:       hidapi-hotplug
-Requires:       libusbx
 
 %description
 Open source RGB lighting control that doesn't depend on manufacturer software. Supports Windows and Linux.
@@ -57,9 +53,6 @@ fi
 %doc README.md
 
 %changelog
-* Fri Sep 11 2026 Adam Honse <[email protected]> - 1.0-0
-- Updated to 1.0
-
 * Sun Jul 9 2023 Adam Honse <[email protected]> - 0.9-0
 - Updated to 0.9
 

i2c_smbus/Linux/i2c_smbus_linux.cpp

@@ -101,7 +101,7 @@ bool i2c_smbus_linux_detect()
     {
         if(ent->d_type == DT_DIR || ent->d_type == DT_LNK)
         {
-            if((strncmp(ent->d_name, "i2c-", 4) == 0) && (ent->d_name[4] != '\0') && (strspn(ent->d_name + 4, "0123456789") == strlen(ent->d_name + 4)))
+            if(strncmp(ent->d_name, "i2c-", 4) == 0)
             {
                 strncpy(device_string, driver_path, sizeof(device_string) - 1);
                 device_string[sizeof(device_string) - 1] = '\0';
@@ -148,18 +148,6 @@ bool i2c_smbus_linux_detect()
                     // Get the Linux Bus ID
                     sscanf(ent->d_name, "i2c-%hu", &bus_id);
 
-                    /*-----------------------------------------------------*\
-                    | DPMST adapters are created by AMD GPUs for DisplayPort|
-                    | MST (Multi-Stream Transport).  These are removable    |
-                    | devices and we don't have hotplug detection for i2c   |
-                    | interfaces, so we should ignore them.                 |
-                    \*-----------------------------------------------------*/
-                    if(strcmp(device_string, "DPMST") == 0)
-                    {
-                        LOG_INFO("[%s] Skipping DPMST i2c device", ent->d_name);
-                        continue;
-                    }
-
                     // Get device path
                     strncpy(path, driver_path, sizeof(path) - 1);
                     path[sizeof(path) - 1] = '\0';
@@ -175,38 +163,18 @@ bool i2c_smbus_linux_detect()
                         path[sizeof(path) - 1] = '\0';
                         free(ptr);
 
-                        /*-----------------------------------------------------*\
-                        | Walk up sysfs to the nearest PCI device.              |
-                        | Some I2C adapters sit below an intermediate device.    |
-                        \*-----------------------------------------------------*/
-                        while(true)
-                        {
-                            char pci_vendor_path[PATH_MAX];
-                            char pci_device_path[PATH_MAX];
-
-                            snprintf(pci_vendor_path, sizeof(pci_vendor_path), "%s/vendor", path);
-                            snprintf(pci_device_path, sizeof(pci_device_path), "%s/device", path);
-
-                            if(access(pci_vendor_path, R_OK) == 0 && access(pci_device_path, R_OK) == 0)
-                            {
-                                break;
-                            }
-
-                            char* last_slash = strrchr(path, '/');
-
-                            if(last_slash == NULL || last_slash == path)
-                            {
-                                path[0] = '\0';
-                                break;
-                            }
-
-                            *last_slash = '\0';
-                        }
-
-                        if(path[0] == '\0')
-                        {
+                        /*-------------------------------------------------------------*\
+                        | Truncate at last '/' to get the parent PCI device directory.  |
+                        | For AMDGPU i2c buses the realpath resolves to something like:  |
+                        |   /sys/devices/pci.../0000:03:00.0/i2c-4                      |
+                        | The parent (0000:03:00.0) contains vendor/device/subsystem    |
+                        | files. Using /..' traversal is unreliable in sysfs; directly  |
+                        | truncating the path is correct and portable.                   |
+                        \*-------------------------------------------------------------*/
+                        char* last_slash = strrchr(path, '/');
+                        if(last_slash == NULL || last_slash == path)
                             continue;
-                        }
+                        *last_slash = '\0';
                     }
                     else
                     {
@@ -278,7 +246,7 @@ bool i2c_smbus_linux_detect()
                     // Get PCI Subsystem Device
                     strcpy(ptr, "/subsystem_device");
                     test_fd = open(path, O_RDONLY);
-                    if(test_fd >= 0)
+                    if (test_fd >= 0)
                     {
                         memset(buff, 0x00, sizeof(buff));
 
@@ -301,11 +269,9 @@ bool i2c_smbus_linux_detect()
                     device_path[sizeof(device_path) - 1] = '\0';
                     test_fd = open(device_path, O_RDWR);
 
-                    if(test_fd < 0)
+                    if (test_fd < 0)
                     {
-                        LOG_INFO("[i2c_smbus_linux] Failed to open %s", device_path);
                         ret = false;
-                        continue;
                     }
 
                     bus = new i2c_smbus_linux();
@@ -321,7 +287,6 @@ bool i2c_smbus_linux_detect()
                 }
                 else
                 {
-                    LOG_INFO("[i2c_smbus_linux] Failed to open %s", device_string);
                     ret = false;
                 }
             }

i2c_smbus/MacOS/i2c_smbus_i801.cpp

@@ -506,9 +506,9 @@ s32 i2c_smbus_i801::i2c_xfer(u8 /*addr*/, char /*read_write*/, int* /*size*/, u8
 
 bool i2c_smbus_i801_detect()
 {
-    if(!InitMacUSPCIODriver())
+    if(!GetMacUSPCIODriverStatus())
     {
-        LOG_INFO("macUSPCIO initialization failed, i801 I2C bus detection aborted");
+        LOG_INFO("macUSPCIO is not loaded, i801 I2C bus detection aborted");
         return(false);
     }
 

i2c_smbus/MacOS/i2c_smbus_nct6775.cpp

@@ -213,9 +213,9 @@ s32 i2c_smbus_nct6775::i2c_xfer(u8 /*addr*/, char /*read_write*/, int* /*size*/,
 
 bool i2c_smbus_nct6775_detect()
 {
-    if(!InitMacUSPCIODriver())
+    if(!GetMacUSPCIODriverStatus())
     {
-        LOG_INFO("macUSPCIO initialization failed, nct6775 I2C bus detection aborted");
+        LOG_INFO("macUSPCIO is not loaded, nct6775 I2C bus detection aborted");
         return(false);
     }
 

i2c_smbus/MacOS/i2c_smbus_piix4.cpp

@@ -245,9 +245,9 @@ s32 i2c_smbus_piix4::i2c_xfer(u8 /*addr*/, char /*read_write*/, int* /*size*/, u
 
 bool i2c_smbus_piix4_detect()
 {
-    if(!InitMacUSPCIODriver())
+    if(!GetMacUSPCIODriverStatus())
     {
-        LOG_INFO("macUSPCIO initialization failed, piix4 I2C bus detection aborted");
+        LOG_INFO("macUSPCIO is not loaded, piix4 I2C bus detection aborted");
         return(false);
     }
 

i2c_smbus/i2c_intel_gpu.h

@@ -1,50 +0,0 @@
-/*---------------------------------------------------------*\
-| i2c_intel_gpu.h                                           |
-|                                                           |
-|   Bits specific to Intel GPUs to reliably detect          |
-|   the I2C bus that has RGB control                        |
-|                                                           |
-|   Jan Dvořák                                  13 Sep 2026 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <cstring>
-
-#include "i2c_smbus.h"
-#include "pci_ids.h"
-
-inline constexpr const char * RECOGNIZED_INTEL_I2C_BUS_NAMES[] =
-{
-    /*-----------------------------------------------------*\
-    | Linux Intel discrete GPU internal I2C controller      |
-    \*-----------------------------------------------------*/
-    "Synopsys DesignWare I2C adapter",
-    nullptr
-};
-
-inline bool is_intel_gpu_i2c_bus(const i2c_smbus_interface *bus)
-{
-    if(bus->info.pci_vendor != INTEL_VEN)
-    {
-        return false;
-    }
-
-    const char *name;
-    size_t idx = 0;
-
-    while((name = RECOGNIZED_INTEL_I2C_BUS_NAMES[idx++]) != nullptr)
-    {
-        const char *pos = std::strstr(bus->info.device_name, name);
-
-        if(pos == bus->info.device_name)
-        {
-            return true;
-        }
-    }
-
-    return false;
-}

net_port/net_port.cpp

@@ -171,7 +171,7 @@ bool net_port::tcp_client(const char * client_name, const char * port)
     return(true);
 }
 
-bool net_port::tcp_client_connect(unsigned int timeout_ms)
+bool net_port::tcp_client_connect()
 {
     struct addrinfo *res;
     connected = false;
@@ -201,11 +201,8 @@ bool net_port::tcp_client_connect(unsigned int timeout_ms)
         FD_ZERO(&fdset);
         FD_SET(sock, &fdset);
 
-        /*-------------------------------------------------*\
-        | Convert millisecond timeout to timeval sec/usec   |
-        \*-------------------------------------------------*/
-        tv.tv_sec   = (timeout_ms / 1000);
-        tv.tv_usec  = (timeout_ms % 1000) * 1000;
+        tv.tv_sec =  4;
+        tv.tv_usec = 0;
 
         /*-------------------------------------------------*\
         | Set socket options - no delay                     |

net_port/net_port.h

@@ -61,7 +61,7 @@ public:
     bool udp_client(const char* client_name, const char * port);
     bool udp_client(const char * client_name, const char * send_port, const char * recv_port);
     bool tcp_client(const char* client_name, const char * port);
-    bool tcp_client_connect(unsigned int timeout_ms = 4000);
+    bool tcp_client_connect();
 
     //Function to open a server
     bool        tcp_server(const char * port);

pci_ids/pci_ids.h

@@ -576,8 +576,6 @@
 #define GAINWARD_RTX_3090TI_PHANTOM                             0xF295
 #define GAINWARD_RTX_4070_GHOST_SUB_DEV                         0xF303
 #define GAINWARD_RTX_4080_PHANTOM_GS_SUB_DEV                    0xF297
-#define GAINWARD_RTX_4090_PHANTOM_SUB_DEV                       0xF297
-#define GAINWARD_RTX_5080_PHOENIX_SUB_DEV                       0xF323
 
 /*-----------------------------------------------------*\
 | GALAX / KFA2 Sub-Device IDs                           |
@@ -707,7 +705,6 @@
 #define GIGABYTE_RTX4070_AERO_OC_12G_SUB_DEV                    0x40E6
 #define GIGABYTE_RTX4070S_GAMING_OC_12G                         0x4138
 #define GIGABYTE_RTX4070S_AERO_OC_12G                           0x4139
-#define GIGABYTE_RTX4070S_EAGLE_OC_12G                          0x413A
 #define GIGABYTE_RTX4070S_EAGLE_OC_ICE_12G                      0x4148
 #define GIGABYTE_RTX4070TI_GAMING_12G                           0x40DF
 #define GIGABYTE_RTX4070TI_GAMING_OC_12G                        0x40C6
@@ -752,8 +749,8 @@
 #define GIGABYTE_AORUS_RTX5090_MASTER_ICE_32G_SUB_DEV           0x4199
 #define GIGABYTE_AORUS_RTX5090D_MASTER_32G_SUB_DEV              0x4188
 #define GIGABYTE_AORUS_RTX5090D_V2_MASTER_ICE_24G_SUB_DEV       0x41CA
-#define GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV          0x4171
-#define GIGABYTE_RTX5090_XTREME_WATERFORCE_WB_32G_SUB_DEV       0x4172
+#define GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV1         0x4171
+#define GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV2         0x4172
 #define GIGABYTE_RX6700XT_GAMING_OC_12G_SUB_DEV                 0x232D
 #define GIGABYTE_RX6700XT_EAGLE_12G_SUB_DEV                     0x2331
 #define GIGABYTE_AORUS_RX_6750_XT_ELITE_12G_SUB_DEV             0x2407
@@ -889,7 +886,6 @@
 \*-----------------------------------------------------*/
 #define PNY_RTX_2060_XLR8_OC_SUB_DEV                            0x1363
 #define PNY_RTX_3060_XLR8_REVEL_EPIC_X_SUB_DEV                  0x138E
-#define PNY_RTX_3060_XLR8_REVEL_EPIC_X_LHR_SUB_DEV              0x138F
 #define PNY_RTX_3070_XLR8_REVEL_EPIC_X_SUB_DEV                  0x136E
 #define PNY_RTX_3070_XLR8_REVEL_EPIC_X_LHR_SUB_DEV              0x138A
 #define PNY_RTX_3070TI_XLR8_UPRISING_EPIC_X_SUB_DEV             0x138D
@@ -913,7 +909,6 @@
 #define PNY_RTX_5070_ARGB_EPIC_X_OC_SUB_DEV                     0x1439
 #define PNY_RTX_5070TI_ARGB_EPIC_X_SUB_DEV                      0x143B
 #define PNY_RTX_5070TI_ARGB_EPIC_X_OC_SUB_DEV                   0x143A
-#define PNY_RTX_5070TI_ARGB_EPIC_X_OC_SUB_DEV2                  0x144A
 #define PNY_RTX_5060TI_ARGB_EPIC_X_OC_SUB_DEV                   0x143E
 #define PNY_RTX_5080_ARGB_EPIC_X_OC_SUB_DEV                     0x1435
 #define PNY_RTX_5090_ARGB_EPIC_X_OC_SUB_DEV                     0x1446
@@ -1004,7 +999,6 @@
 #define SAPPHIRE_NAVI44_PURE_XT_SUB_DEV                         0x493E
 #define SAPPHIRE_NAVI48_NITRO_PLUS_SUB_DEV                      0xE489
 #define SAPPHIRE_NAVI48_NITRO_PLUS_SUB_DEV1                     0xE493
-#define SAPPHIRE_NAVI48_NITRO_PLUS_SUB_DEV2                     0x4892
 #define SAPPHIRE_NAVI48_PURE_SUB_DEV                            0x4499
 #define SAPPHIRE_NAVI48_PURE_XT_SUB_DEV                         0x3490
 #define SAPPHIRE_NAVI31_GRE_NITRO_PLUS_SUB_DEV                  0xE475

qt/DeviceView.cpp

@@ -1146,9 +1146,7 @@ void DeviceView::InitDeviceView()
         /*-------------------------------------------------*\
         | For matrix zones, use matrix height from the map  |
         \*-------------------------------------------------*/
-        if((controller->GetZoneType(zone_idx) == ZONE_TYPE_MATRIX)
-        || (controller->GetZoneType(zone_idx) == ZONE_TYPE_MATRIX_LOOP_X)
-        || (controller->GetZoneType(zone_idx) == ZONE_TYPE_MATRIX_LOOP_Y))
+        if(controller->GetZoneType(zone_idx) == ZONE_TYPE_MATRIX)
         {
             total_height                   += controller->GetZoneMatrixMapHeight(zone_idx);
             zone_pos[zone_idx].matrix_w     = controller->GetZoneMatrixMapWidth(zone_idx);
@@ -1161,9 +1159,7 @@ void DeviceView::InitDeviceView()
         {
             for(unsigned int segment_idx = 0; segment_idx < controller->GetZoneSegmentCount(zone_idx); segment_idx++)
             {
-                if((controller->GetZoneSegmentType(zone_idx, segment_idx) == ZONE_TYPE_MATRIX)
-                || (controller->GetZoneSegmentType(zone_idx, segment_idx) == ZONE_TYPE_MATRIX_LOOP_X)
-                || (controller->GetZoneSegmentType(zone_idx, segment_idx) == ZONE_TYPE_MATRIX_LOOP_Y))
+                if(controller->GetZoneSegmentType(zone_idx, segment_idx) == ZONE_TYPE_MATRIX)
                 {
                     total_height               += controller->GetZoneSegmentMatrixMapHeight(zone_idx, segment_idx);
                     zone_pos[zone_idx].matrix_w = controller->GetZoneSegmentMatrixMapWidth(zone_idx, segment_idx);
@@ -1222,9 +1218,7 @@ void DeviceView::InitDeviceView()
         /*-------------------------------------------------*\
         | Calculate LEDs position and size for zone         |
         \*-------------------------------------------------*/
-        if((controller->GetZoneType(zone_idx) == ZONE_TYPE_MATRIX)
-        || (controller->GetZoneType(zone_idx) == ZONE_TYPE_MATRIX_LOOP_X)
-        || (controller->GetZoneType(zone_idx) == ZONE_TYPE_MATRIX_LOOP_Y))
+        if(controller->GetZoneType(zone_idx) == ZONE_TYPE_MATRIX)
         {
             for(unsigned int led_x = 0; led_x < controller->GetZoneMatrixMapWidth(zone_idx); led_x++)
             {
@@ -1329,9 +1323,7 @@ void DeviceView::InitDeviceView()
 
                 segment_count++;
 
-                if((controller->GetZoneSegmentType(zone_idx, segment_idx) == ZONE_TYPE_MATRIX)
-                || (controller->GetZoneSegmentType(zone_idx, segment_idx) == ZONE_TYPE_MATRIX_LOOP_X)
-                || (controller->GetZoneSegmentType(zone_idx, segment_idx) == ZONE_TYPE_MATRIX_LOOP_Y))
+                if(controller->GetZoneSegmentType(zone_idx, segment_idx) == ZONE_TYPE_MATRIX)
                 {
                     for(unsigned int led_x = 0; led_x < controller->GetZoneSegmentMatrixMapWidth(zone_idx, segment_idx); led_x++)
                     {

qt/OpenRGBClientInfoPage/OpenRGBClientInfoPage.cpp

@@ -267,35 +267,15 @@ void OpenRGBClientInfoPage::UpdateInfo()
                 {
                     case ZONE_TYPE_SINGLE:
                         zone_str.append("Single");
-                        break;
+                    break;
 
                     case ZONE_TYPE_LINEAR:
                         zone_str.append("Linear");
                         break;
 
-                    case ZONE_TYPE_LINEAR_LOOP:
-                        zone_str.append("Linear Loop");
-                        break;
-
                     case ZONE_TYPE_MATRIX:
                         zone_str.append("Matrix");
                         break;
-
-                    case ZONE_TYPE_MATRIX_LOOP_X:
-                        zone_str.append("Matrix Loop X");
-                        break;
-
-                    case ZONE_TYPE_MATRIX_LOOP_Y:
-                        zone_str.append("Matrix Loop Y");
-                        break;
-
-                    case ZONE_TYPE_SEGMENTED:
-                        zone_str.append("Segmented");
-                        break;
-
-                    default:
-                        zone_str.append("Unknown");
-                        break;
                 }
 
                 new_child->setText(0, QString::fromStdString(zone_str));

qt/OpenRGBDeviceEditorDialog/OpenRGBDeviceEditorDialog.cpp

@@ -9,7 +9,6 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "JsonUtils.h"
 #include "OpenRGBDynamicSettingsWidget.h"
 #include "OpenRGBDeviceEditorDialog.h"
 #include "ProfileManager.h"
@@ -126,11 +125,6 @@ OpenRGBDeviceEditorDialog::OpenRGBDeviceEditorDialog(RGBController *dev, QWidget
         \*-----------------------------------------------------*/
         for(std::size_t configuration_idx = 0; configuration_idx < configuration_entries.size(); configuration_idx++)
         {
-            if(JsonUtils::JsonGetBool(configuration_entries[configuration_idx].value, "visible", true) == false)
-            {
-                continue;
-            }
-
             OpenRGBDynamicSettingsWidget*   item_widget     = new OpenRGBDynamicSettingsWidget(configuration_entries[configuration_idx].key, configuration_entries[configuration_idx].value, configuration_value);
 
             item_widget->SetCallback(Callback, this);

qt/OpenRGBDevicePage/OpenRGBDevicePage.cpp

@@ -7,8 +7,6 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include <QTimer>
-
 #include "OpenRGBDevicePage.h"
 #include "OpenRGBDeviceEditorDialog.h"
 #include "OpenRGBZoneEditorDialog.h"
@@ -1629,6 +1627,11 @@ void OpenRGBDevicePage::UpdateModeUi()
         ui->PerLEDCheck->setEnabled(enable_controls);
         ui->PerLEDCheck->setChecked(per_led);
         ui->PerLEDCheck->blockSignals(false);
+
+        if(DeviceViewShowing)
+        {
+            ui->DeviceViewBoxFrame->show();
+        }
     }
     else
     {
@@ -1642,22 +1645,6 @@ void OpenRGBDevicePage::UpdateModeUi()
         ui->DeviceViewBoxFrame->hide();
     }
 
-    /*-----------------------------------------------------*\
-    | Show the device view if the selected mode is a per-   |
-    | LED mode or if the selected zone mode is following    |
-    | entire device and the device mode is per-LED.         |
-    \*-----------------------------------------------------*/
-    if((per_led)
-    || ((selected_zone_mode)
-     && (selected_mode == -1)
-     && (device->GetModeColorMode(device->GetActiveMode()) == MODE_COLORS_PER_LED)))
-    {
-        if(DeviceViewShowing)
-        {
-            ui->DeviceViewBoxFrame->show();
-        }
-    }
-
     if(supports_mode_specific)
     {
         ui->ModeSpecificCheck->blockSignals(true);
@@ -1817,19 +1804,7 @@ void OpenRGBDevicePage::ColorChanged()
 
     if(AutoUpdateEnabled())
     {
-        /*-----------------------------------------------------*\
-        | Coalesce rapid signals into one deferred update        |
-        \*-----------------------------------------------------*/
-        if(!color_update_pending)
-        {
-            color_update_pending = true;
-
-            QTimer::singleShot(0, this, [this]()
-            {
-                UpdateColor();
-                color_update_pending = false;
-            });
-        }
+        UpdateColor();
     }
 }
 

qt/OpenRGBDevicePage/OpenRGBDevicePage.h

@@ -64,11 +64,6 @@ private:
     bool MultipleSelected   = false;
     bool UpdateHex          = true;
 
-    /*-----------------------------------------------------*\
-    | Coalesces rapid ColorChanged() calls into one update   |
-    \*-----------------------------------------------------*/
-    bool color_update_pending = false;
-
     /*-----------------------------------------------------*\
     | UI Update Functions                                   |
     \*-----------------------------------------------------*/

qt/OpenRGBDialog/OpenRGBDialog.cpp

@@ -54,7 +54,8 @@ static void OpenRGBDialogLogManagerCallback(void * this_ptr, unsigned int update
     switch(update_reason)
     {
         case LOGMANAGER_UPDATE_REASON_SHOW_DIALOG:
-            QMetaObject::invokeMethod(this_obj, "onShowDialogMessage", Qt::QueuedConnection, Q_ARG(QString, QString::fromStdString(message->text)));
+            this_obj->SetDialogMessage(message);
+            QMetaObject::invokeMethod(this_obj, "onShowDialogMessage", Qt::QueuedConnection);
             break;
     }
 }
@@ -132,11 +133,6 @@ static void DeletePluginCallback(void * this_ptr, OpenRGBPluginEntry* plugin)
     this_obj->RemovePlugin(plugin);
 }
 
-static bool AutoProfileIsSet(json& profilemanager_settings, std::string key)
-{
-    return(profilemanager_settings.contains(key) && (JsonUtils::JsonGetString(profilemanager_settings[key], "name") != ""));
-}
-
 bool OpenRGBDialog::IsMinimizeOnClose()
 {
     json ui_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("UserInterface");
@@ -283,7 +279,6 @@ OpenRGBDialog::OpenRGBDialog(QWidget *parent) : QMainWindow(parent), ui(new Ui::
 #if defined(_WIN32)
     drivers_settings_schema["shared_smbus_acces"]["title"]                          = QT_TRANSLATE_NOOP("Settings", "Shared SMBus Access (restart required)");
     drivers_settings_schema["shared_smbus_acces"]["type"]                           = "bool";
-    drivers_settings_schema["shared_smbus_access"]["default"]                       = true;
 
     drivers_settings_schema["smbus_sleep_mode"]["title"]                            = QT_TRANSLATE_NOOP("Settings", "SMBus Sleep Mode (restart required)");
     drivers_settings_schema["smbus_sleep_mode"]["type"]                             = "integer";
@@ -293,7 +288,6 @@ OpenRGBDialog::OpenRGBDialog(QWidget *parent) : QMainWindow(parent), ui(new Ui::
     drivers_settings_schema["smbus_sleep_mode"]["enumNames"][1]                     = "Short Busy";
     drivers_settings_schema["smbus_sleep_mode"]["enum"][2]                          = 2;
     drivers_settings_schema["smbus_sleep_mode"]["enumNames"][2]                     = "Always Sleep";
-    drivers_settings_schema["smbus_sleep_mode"]["default"]                          = 2;
 #else
     drivers_settings_schema["amd_smbus_reduce_cpu"]["title"]                        = QT_TRANSLATE_NOOP("Settings", "AMD SMBus: Reduce CPU Usage (restart required)");
     drivers_settings_schema["amd_smbus_reduce_cpu"]["type"]                         = "bool";
@@ -302,11 +296,6 @@ OpenRGBDialog::OpenRGBDialog(QWidget *parent) : QMainWindow(parent), ui(new Ui::
     ResourceManager::get()->GetSettingsManager()->RegisterSettingsSchema("Drivers", QT_TRANSLATE_NOOP("Settings", "Drivers"), drivers_settings_schema);
 #endif
 
-    /*-----------------------------------------------------*\
-    | Migrate settings from pre-1.0 versions                |
-    \*-----------------------------------------------------*/
-    MigrateLegacySettings();
-
     /*-----------------------------------------------------*\
     | Register resource manager callbacks                   |
     \*-----------------------------------------------------*/
@@ -891,7 +880,7 @@ void OpenRGBDialog::RemovePlugin(OpenRGBPluginEntry* plugin)
             plugin_parent_widget = ui->InformationTabBar;
             break;
         case OPENRGB_PLUGIN_LOCATION_SETTINGS:
-            plugin_parent_widget = ui->SettingsTabBar;
+            plugin_parent_widget = ui->InformationTabBar;
             break;
         default:
             break;
@@ -1414,6 +1403,11 @@ void OpenRGBDialog::UpdateDevicesList()
     }
 }
 
+void OpenRGBDialog::SetDialogMessage(PLogMessage msg)
+{
+    dialog_message = QString::fromStdString(msg->text);
+}
+
 void OpenRGBDialog::SetLanguage(std::string locale)
 {
     QApplication*           app             = static_cast<QApplication *>(QApplication::instance());
@@ -1633,13 +1627,10 @@ void OpenRGBDialog::onDetectionEnded()
     | Load plugins after the first detection (ONLY the      |
     | first)                                                |
     \*-----------------------------------------------------*/
-    bool plugins_just_loaded = false;
-
     if(!plugins_loaded)
     {
         plugin_manager->ScanAndLoadPlugins();
         plugins_loaded = true;
-        plugins_just_loaded = true;
         PluginsPage->RefreshList();
     }
 
@@ -1651,173 +1642,7 @@ void OpenRGBDialog::onDetectionEnded()
     /*-----------------------------------------------------*\
     | Load the on open automatic profile                    |
     \*-----------------------------------------------------*/
-    bool open_profile_loaded = ResourceManager::get()->GetProfileManager()->LoadAutoProfileOpen();
-
-    /*-----------------------------------------------------*\
-    | With no profile to open, the plugins that were just   |
-    | loaded still need the active profile's plugin data    |
-    \*-----------------------------------------------------*/
-    if(plugins_just_loaded && !open_profile_loaded)
-    {
-        ResourceManager::get()->GetProfileManager()->ApplyActiveProfilePluginData();
-    }
-}
-
-void OpenRGBDialog::MigrateLegacySettings()
-{
-    /*-----------------------------------------------------*\
-    | Legacy AutoStart argument flags and value keys        |
-    \*-----------------------------------------------------*/
-    static const char* legacy_arguments[][3] =
-    {
-        { "setserver",      "--server",         ""          },
-        { "setserverhost",  "--server-host",    "host"      },
-        { "setserverport",  "--server-port",    "port"      },
-        { "setclient",      "--client",         "client"    },
-        { "setcustom",      "",                 "custom"    },
-    };
-
-    static const char* legacy_profiles[] =
-    {
-        "exit_profile",
-        "resume_profile",
-        "suspend_profile",
-    };
-
-    SettingsManager*    settings_manager        = ResourceManager::get()->GetSettingsManager();
-    json                autostart_settings      = settings_manager->GetSettings("AutoStart");
-    json                ui_settings             = settings_manager->GetSettings("UserInterface");
-    json                profilemanager_settings = settings_manager->GetSettings("ProfileManager");
-    bool                settings_migrated       = false;
-    bool                ui_migrated             = false;
-    bool                profiles_migrated       = false;
-
-    /*-----------------------------------------------------*\
-    | Migrate pre-1.0 AutoStart keys                        |
-    \*-----------------------------------------------------*/
-    if(autostart_settings.contains("setminimized"))
-    {
-        std::string     arguments;
-        std::string     profile_name            = JsonUtils::JsonGetString(autostart_settings, "profile");
-
-        for(unsigned int arg_idx = 0; arg_idx < (sizeof(legacy_arguments) / sizeof(legacy_arguments[0])); arg_idx++)
-        {
-            if(JsonUtils::JsonGetBool(autostart_settings, legacy_arguments[arg_idx][0]))
-            {
-                std::string argument    = legacy_arguments[arg_idx][1];
-                std::string value       = JsonUtils::JsonGetString(autostart_settings, legacy_arguments[arg_idx][2]);
-
-                if(value != "")
-                {
-                    if(argument != "")
-                    {
-                        argument += " ";
-                    }
-
-                    argument += value;
-                }
-
-                if(argument != "")
-                {
-                    if(arguments != "")
-                    {
-                        arguments += " ";
-                    }
-
-                    arguments += argument;
-                }
-            }
-
-            autostart_settings.erase(legacy_arguments[arg_idx][0]);
-            autostart_settings.erase(legacy_arguments[arg_idx][2]);
-        }
-
-        if(!autostart_settings.contains("start_minimized"))
-        {
-            autostart_settings["start_minimized"]   = JsonUtils::JsonGetBool(autostart_settings, "setminimized");
-        }
-
-        if(!autostart_settings.contains("custom_arguments"))
-        {
-            autostart_settings["custom_arguments"]  = arguments;
-        }
-
-        if(JsonUtils::JsonGetBool(autostart_settings, "setprofile") && (profile_name != ""))
-        {
-            if(!AutoProfileIsSet(profilemanager_settings, "open_profile"))
-            {
-                profilemanager_settings["open_profile"]["enabled"]              = true;
-                profilemanager_settings["open_profile"]["name"]                 = profile_name;
-                profiles_migrated                                               = true;
-            }
-
-            if(!AutoProfileIsSet(profilemanager_settings, "service_startup_profile"))
-            {
-                profilemanager_settings["service_startup_profile"]["enabled"]   = true;
-                profilemanager_settings["service_startup_profile"]["name"]      = profile_name;
-                profiles_migrated                                               = true;
-            }
-        }
-
-        autostart_settings.erase("setminimized");
-        autostart_settings.erase("setprofile");
-        autostart_settings.erase("profile");
-
-        settings_manager->SetSettings("AutoStart", autostart_settings);
-        settings_migrated                           = true;
-    }
-
-    /*-----------------------------------------------------*\
-    | Migrate pre-1.0 tray icon and autoload profile keys   |
-    \*-----------------------------------------------------*/
-    if(ui_settings.contains("greyscale_tray_icon"))
-    {
-        if(!ui_settings.contains("monochrome_tray_icon"))
-        {
-            ui_settings["monochrome_tray_icon"]     = JsonUtils::JsonGetBool(ui_settings, "greyscale_tray_icon");
-        }
-
-        ui_settings.erase("greyscale_tray_icon");
-        ui_migrated                                 = true;
-    }
-
-    if(ui_settings.contains("autoload_profiles"))
-    {
-        for(unsigned int profile_idx = 0; profile_idx < (sizeof(legacy_profiles) / sizeof(legacy_profiles[0])); profile_idx++)
-        {
-            std::string key = legacy_profiles[profile_idx];
-
-            if(ui_settings["autoload_profiles"].contains(key) && !AutoProfileIsSet(profilemanager_settings, key))
-            {
-                json legacy_profile = ui_settings["autoload_profiles"][key];
-
-                profilemanager_settings[key]["enabled"] = JsonUtils::JsonGetBool(legacy_profile, "enabled");
-                profilemanager_settings[key]["name"]    = JsonUtils::JsonGetString(legacy_profile, "name");
-                profiles_migrated                       = true;
-            }
-        }
-
-        ui_settings.erase("autoload_profiles");
-        ui_migrated                                 = true;
-    }
-
-    if(ui_migrated)
-    {
-        settings_manager->SetSettings("UserInterface", ui_settings);
-        settings_migrated                           = true;
-    }
-
-    if(settings_migrated)
-    {
-        if(profiles_migrated)
-        {
-            settings_manager->SetSettings("ProfileManager", profilemanager_settings);
-        }
-
-        settings_manager->SaveSettings();
-
-        LOG_INFO("[OpenRGBDialog] Migrated legacy AutoStart and profile settings");
-    }
+    ResourceManager::get()->GetProfileManager()->LoadAutoProfileOpen();
 }
 
 void OpenRGBDialog::onSettingsUpdated()
@@ -1994,9 +1819,9 @@ void OpenRGBDialog::on_ShowHide()
     }
 }
 
-void OpenRGBDialog::onShowDialogMessage(QString message)
+void OpenRGBDialog::onShowDialogMessage()
 {
-    std::size_t hash = std::hash<std::string>{}(message.toStdString());
+    std::size_t hash = std::hash<std::string>{}(dialog_message.toStdString());
 
     /*-----------------------------------------------------*\
     | Load the LogManager settings and check if the hash of |
@@ -2018,6 +1843,7 @@ void OpenRGBDialog::onShowDialogMessage(QString message)
         {
             if(log_manager_settings["dialog_no_show_hashes"][list_idx] == hash)
             {
+                dialog_message.clear();
                 return;
             }
         }
@@ -2025,21 +1851,21 @@ void OpenRGBDialog::onShowDialogMessage(QString message)
 
     QMessageBox box;
 
-    box.setInformativeText(QCoreApplication::translate("ResourceManager", message.toUtf8()));
+    box.setInformativeText(QCoreApplication::translate("ResourceManager", dialog_message.toUtf8()));
 
     QCheckBox* CheckBox_DontShowAgain = new QCheckBox("Don't show this message again");
 
-    bool DontShowAgain = false;
+    DontShowAgain = false;
 
     #if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
-        QObject::connect(CheckBox_DontShowAgain, &QCheckBox::checkStateChanged, [&DontShowAgain](Qt::CheckState state)
+        QObject::connect(CheckBox_DontShowAgain, &QCheckBox::checkStateChanged, [this](Qt::CheckState state)
     #else
-        QObject::connect(CheckBox_DontShowAgain, &QCheckBox::stateChanged, [&DontShowAgain](int state)
+        QObject::connect(CheckBox_DontShowAgain, &QCheckBox::stateChanged, [this](int state)
     #endif
     {
         if(static_cast<Qt::CheckState>(state) == Qt::CheckState::Checked)
         {
-            DontShowAgain = true;
+            this->DontShowAgain = true;
         }
     });
 
@@ -2062,6 +1888,8 @@ void OpenRGBDialog::onShowDialogMessage(QString message)
     }
 
     DontShowAgain = false;
+
+    dialog_message.clear();
 }
 
 void OpenRGBDialog::on_ReShow(QSystemTrayIcon::ActivationReason reason)