TEST: increment above latest firmware to verify it works

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

@@ -42,6 +42,5 @@ DetectedControllers DetectASRockGPUSMBusControllers(i2c_smbus_interface* bus, ui
 }
 
 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);

Controllers/ASRockSMBusController/ASRockGPUSMBusController/RGBController_ASRockGPUSMBus.cpp

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

Controllers/AlienwareController/RGBController_Alienware.cpp

@@ -251,7 +251,7 @@ void RGBController_Alienware::DeviceUpdateMode()
                         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))
+                        if(current_mode.colors.size() >= (zone_idx + 1) * 2)
                         {
                             c1 = current_mode.colors[zone_idx * 2];
                             c2 = current_mode.colors[(zone_idx * 2) + 1];

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

@@ -263,7 +263,7 @@ static const mystic_light_185_config board_configs[] =
     { 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
+    { 0x7C56, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     7 },    // 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
@@ -423,37 +423,37 @@ MSIMotherboard185Controller::MSIMotherboard185Controller(hid_device* handle, con
         }
     }
 
+    /*-----------------------------------------------------*\
+    | 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;
+    }
+
     /*-----------------------------------------------------*\
     | Fill in the number of each zone type based on the     |
     | board configuration                                   |
     \*-----------------------------------------------------*/
     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;
     }
 
     /*-----------------------------------------------------*\

Controllers/MSIMotherboardController/MSIMotherboard761Controller/MSIMotherboard761Controller.cpp

@@ -77,10 +77,6 @@ static const std::string board_names[] =
     "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[] =
@@ -115,10 +111,6 @@ static const mystic_light_761_config board_configs[] =
     { &(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)
 };
 
 enum MSI_ZONE setup_map [] =

Controllers/MSIMotherboardController/MSIMotherboardControllerDetect.cpp

@@ -235,8 +235,6 @@ REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E86",    DetectMSIMotherboardCont
 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 +245,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/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

@@ -366,8 +366,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

@@ -7222,81 +7222,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                                   |
 |                                                               |
@@ -9665,8 +9590,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

@@ -213,8 +213,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);

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/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
@@ -913,7 +910,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 +1000,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)

qt/OpenRGBDialog/OpenRGBDialog.h

@@ -59,8 +59,11 @@ public:
 
     static bool IsMinimizeOnClose();
 
+    void SetDialogMessage(PLogMessage msg);
     void SetLanguage(std::string locale);
 
+    bool DontShowAgain;
+
 signals:
     void ProfileListChanged();
 
@@ -123,6 +126,8 @@ private:
     QAction *                       trayActionRescan;
     QAction *                       trayActionExit;
 
+    QString                         dialog_message;
+
     /*-----------------------------------------------------*\
     | User interface                                        |
     \*-----------------------------------------------------*/
@@ -146,7 +151,6 @@ private:
     void ShowHideDevicesList();
     void closeEvent(QCloseEvent *event) override;
     bool SelectConfigProfile(const std::string name);
-    void MigrateLegacySettings();
 
     void SetDetectionViewState(bool detection_showing);
     void SaveProfile();
@@ -181,7 +185,7 @@ private slots:
     void onSettingsUpdated();
     void on_SetAllDevices(unsigned char red, unsigned char green, unsigned char blue);
     void on_ShowHide();
-    void onShowDialogMessage(QString message);
+    void onShowDialogMessage();
     void on_ReShow(QSystemTrayIcon::ActivationReason reason);
     void on_ProfileSelected();
     void on_ProfileBox_currentIndexChanged(int index);

qt/OpenRGBDynamicSettingsWidget/OpenRGBDynamicSettingsWidget.cpp

@@ -146,11 +146,6 @@ OpenRGBDynamicSettingsWidget::OpenRGBDynamicSettingsWidget(std::string key, nloh
             \*---------------------------------------------*/
             for(std::size_t setting_idx = 0; setting_idx < setting_entries.size(); setting_idx++)
             {
-                if(JsonUtils::JsonGetBool(setting_entries[setting_idx].value, "visible", true) == false)
-                {
-                    continue;
-                }
-
                 OpenRGBDynamicSettingsWidget*   item_widget = new OpenRGBDynamicSettingsWidget(setting_entries[setting_idx].key, setting_entries[setting_idx].value, settings_json);
 
                 item_widget->SetCallback(&OpenRGBDynamicSettingsWidget::NestedCallback, this);

qt/OpenRGBSettingsPage/OpenRGBSettingsPage.cpp

@@ -13,7 +13,6 @@
 #include <QLayoutItem>
 #include <QSpacerItem>
 #include <QVBoxLayout>
-#include "JsonUtils.h"
 #include "OpenRGBDynamicSettingsWidget.h"
 #include "OpenRGBSettingsPage.h"
 #include "ResourceManager.h"
@@ -140,11 +139,6 @@ void OpenRGBSettingsPage::UpdateInterface()
     \*-----------------------------------------------------*/
     for(std::size_t setting_idx = 0; setting_idx < setting_entries.size(); setting_idx++)
     {
-        if(JsonUtils::JsonGetBool(setting_entries[setting_idx].value, "visible", true) == false)
-        {
-            continue;
-        }
-
         nlohmann::json                  setting_value;
         setting_value[setting_entries[setting_idx].key] = ResourceManager::get()->GetSettingsManager()->GetSettings(setting_entries[setting_idx].key);
         OpenRGBDynamicSettingsWidget*   item_widget     = new OpenRGBDynamicSettingsWidget(setting_entries[setting_idx].key, setting_entries[setting_idx].value, setting_value);

qt/i18n/OpenRGB_de_DE.ts

@@ -59,7 +59,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/DMXSettingsEntry/DMXSettingsEntry.ui" line="32"/>
         <source>Brightness Channel:</source>
-        <translation>Helligkeitskanal:</translation>
+        <translation>Helligkeits Kanal:</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/DMXSettingsEntry/DMXSettingsEntry.ui" line="42"/>
@@ -160,12 +160,12 @@
     <message>
         <location filename="../../DetectionManager.cpp" line="48"/>
         <source>&lt;h2&gt;Warning:&lt;/h2&gt;&lt;p&gt;One or more I2C/SMBus interfaces failed to initialize.&lt;/p&gt;&lt;p&gt;Depending on which interfaces failed to initialize, some RGB DRAM modules, some motherboards&apos; onboard RGB lighting, and RGB graphics cards may not be available in OpenRGB.&lt;/p&gt;&lt;p&gt;On Windows, this is usually caused by a failure to load the PawnIO driver.&lt;/p&gt;&lt;p&gt;For OpenRGB to access these devices, you must install PawnIO from &lt;a href=&apos;https://pawnio.eu/&apos;&gt;https://pawnio.eu&lt;/a&gt; and run OpenRGB as administrator or as a system service.&lt;/p&gt;&lt;p&gt;If you are not using any of the devices listed above, you can safely ignore this message.&lt;/p&gt;</source>
-        <translation>&lt;h2&gt;Warnung:&lt;/h2&gt;&lt;p&gt;Eine oder mehrere I2C/SMBus-Schnittstellen konnten nicht initialisiert werden.&lt;/p&gt;&lt;p&gt;Abhänging davon, welche Schnittstellen nicht initialisiert wurden, können einige RGB-DRAM-Module, RGB-Beleuchtung auf der Hauptplatine und RGB-Grafikkarten in OpenRGB nicht verfügbar sein.&lt;/p&gt;&lt;p&gt;Unter Windows ist dies in der Regel auf einen Fehler beim Laden des PawnIO-Treibers zurückzuführen.&lt;/p&gt;&lt;p&gt;Um OpenRGB auf diese Geräte zugreifen zu lassen, müssen Sie PawnIO von &lt;a href=&apos;https://pawnio.eu/&apos;&gt;https://pawnio.eu&lt;/a&gt; installieren und OpenRGB als Administrator oder als Systemdienst ausführen.&lt;/p&gt;&lt;p&gt;Wenn Sie keines der oben genannten Geräte verwenden, können Sie diese Meldung sicher ignorieren.&lt;/p&gt;</translation>
+        <translation>&lt;h2&gt;Warnung:&lt;/h2&gt;&lt;p&gt;Eine oder mehrere I2C/SMBus-Schnittstellen konnten nicht initialisiert werden.&lt;/p&gt;&lt;p&gt;Je nachdem, welche Schnittstellen nicht initialisiert wurden, können einige RGB-DRAM-Module, einige RGB-Beleuchtung auf der Hauptplatine und RGB-Grafikkarten in OpenRGB nicht verfügbar sein.&lt;/p&gt;&lt;p&gt;Unter Windows ist dies in der Regel auf einen Fehler beim Laden des PawnIO-Treibers zurückzuführen.&lt;/p&gt;&lt;p&gt;Um OpenRGB auf diese Geräte zugreifen zu lassen, müssen Sie PawnIO von &lt;a href=&apos;https://pawnio.eu/&apos;&gt;https://pawnio.eu&lt;/a&gt; installieren und OpenRGB als Administrator oder als Systemdienst ausführen.&lt;/p&gt;&lt;p&gt;Wenn Sie keines der oben genannten Geräte verwenden, können Sie diese Meldung sicher ignorieren.&lt;/p&gt;</translation>
     </message>
     <message>
         <location filename="../../DetectionManager.cpp" line="55"/>
         <source>&lt;h2&gt;Warning:&lt;/h2&gt;&lt;p&gt;One or more I2C/SMBus interfaces failed to initialize.&lt;/p&gt;&lt;p&gt;Depending on which interfaces failed to initialize, some RGB DRAM modules, some motherboards&apos; onboard RGB lighting, and RGB graphics cards may not be available in OpenRGB.&lt;/p&gt;&lt;p&gt;On Linux, this is usually because the i2c-dev module is not loaded.&lt;/p&gt;&lt;p&gt;For OpenRGB to access these devices, you must load the i2c-dev module along with the correct I2C driver module for your motherboard. This is usually i2c-piix4 for AMD systems and i2c-i801 for Intel systems.&lt;/p&gt;&lt;p&gt;If you are not using any of the devices listed above, you can safely ignore this message.&lt;/p&gt;</source>
-        <translation>&lt;h2&gt;Warnung:&lt;/h2&gt;&lt;p&gt;Eine oder mehrere I2C/SMBus-Schnittstellen konnten nicht initialisiert werden.&lt;/p&gt;&lt;p&gt;Abhänging davon, welche Schnittstellen nicht initialisiert wurden, können einige RGB-DRAM-Module, RGB-Beleuchtungseinheiten auf der Hauptplatine und RGB-Grafikkarten in OpenRGB nicht verfügbar sein.&lt;/p&gt;&lt;p&gt;Unter Linux liegt dies in der Regel daran, dass das Modul i2c-dev nicht geladen ist.&lt;/p&gt;&lt;p&gt;Um diese Geräte mit OpenRGB zugreifen zu können, müssen Sie das Modul i2c-dev sowie das richtige I2C-Treibermodul für Ihre Hauptplatine laden. Dies ist in der Regel i2c-piix4 für AMD-Systeme und i2c-i801 für Intel-Systeme.&lt;/p&gt;&lt;p&gt;Wenn Sie keines der oben genannten Geräte verwenden, können Sie diese Meldung sicher ignorieren.&lt;/p&gt;</translation>
+        <translation>&lt;h2&gt;Warnung:&lt;/h2&gt;&lt;p&gt;Eine oder mehrere I2C/SMBus-Schnittstellen konnten nicht initialisiert werden.&lt;/p&gt;&lt;p&gt;Je nachdem, welche Schnittstellen nicht initialisiert wurden, können einige RGB-DRAM-Module, einige RGB-Beleuchtungseinheiten auf der Hauptplatine und RGB-Grafikkarten in OpenRGB nicht verfügbar sein.&lt;/p&gt;&lt;p&gt;Unter Linux liegt dies in der Regel daran, dass das Modul i2c-dev nicht geladen ist.&lt;/p&gt;&lt;p&gt;Um diese Geräte mit OpenRGB zugreifen zu können, müssen Sie das Modul i2c-dev sowie das richtige I2C-Treibermodul für Ihre Hauptplatine laden. Dies ist in der Regel i2c-piix4 für AMD-Systeme und i2c-i801 für Intel-Systeme.&lt;/p&gt;&lt;p&gt;Wenn Sie keines der oben genannten Geräte verwenden, können Sie diese Meldung sicher ignorieren.&lt;/p&gt;</translation>
     </message>
     <message>
         <location filename="../../DetectionManager.cpp" line="64"/>
@@ -175,7 +175,7 @@
     <message>
         <location filename="../../DetectionManager.cpp" line="70"/>
         <source>&lt;h2&gt;Warning:&lt;/h2&gt;&lt;p&gt;Multiple OpenRGB udev rules are installed.&lt;/p&gt;&lt;p&gt;The udev rules file 60-openrgb.rules is installed in both /etc/udev/rules.d and /usr/lib/udev/rules.d.&lt;/p&gt;&lt;p&gt;Multiple udev rules files can conflict, it is recommended to remove one of them.&lt;/p&gt;</source>
-        <translation>&lt;h2&gt;Warnung:&lt;/h2&gt;&lt;p&gt;Mehrere OpenRGB udev-Regeldateien sind installiert.&lt;/p&gt;&lt;p&gt;Die udev-Regeldatei 60-openrgb.rules ist in /etc/udev/rules.d und /usr/lib/udev/rules.d installiert.&lt;/p&gt;&lt;p&gt;Mehrere udev-Regeldateien können sich gegenseitig beeinflussen. Es wird empfohlen, eine von ihnen zu entfernen.&lt;/p&gt;</translation>
+        <translation>&lt;h2&gt;Warnung:&lt;/h2&gt;&lt;p&gt;Mehrere OpenRGB udev-Regeldateien sind installiert.&lt;/p&gt;&lt;p&gt;Die udev-Regeldatei 60-openrgb.rules ist in beiden /etc/udev/rules.d und /usr/lib/udev/rules.d installiert.&lt;/p&gt;&lt;p&gt;Mehrere udev-Regeldateien können sich gegenseitig beeinflussen. Es wird empfohlen, eine von ihnen zu entfernen.&lt;/p&gt;</translation>
     </message>
 </context>
 <context>
@@ -221,17 +221,17 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/E131SettingsEntry/E131SettingsEntry.ui" line="72"/>
         <source>Universe Size:</source>
-        <translation>Universe Größe:</translation>
+        <translation>Univerumsgröße:</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/E131SettingsEntry/E131SettingsEntry.ui" line="79"/>
         <source>Number of LEDs:</source>
-        <translation>LED-Anzahl:</translation>
+        <translation>LED Anzahl:</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/E131SettingsEntry/E131SettingsEntry.ui" line="92"/>
         <source>Start Universe:</source>
-        <translation>Starte Universe:</translation>
+        <translation>Anfangsuniversum:</translation>
     </message>
 </context>
 <context>
@@ -324,7 +324,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/DDPSettingsEntry/DDPSettingsEntry.cpp" line="98"/>
         <source>DDP (Distributed Display Protocol)</source>
-        <translation>DDP (Distributed Display Protocol)</translation>
+        <translation>DDP (verteiltes Anzeigeprotokoll)</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/DebugSettingsEntry/DebugSettingsEntry.cpp" line="143"/>
@@ -373,7 +373,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/ManualDevicesSettingsPage.ui" line="66"/>
         <source>Save without Rescan</source>
-        <translation>Speichern ohne erneute scannung</translation>
+        <translation>Speichern ohne Neuerfassen</translation>
     </message>
 </context>
 <context>
@@ -811,7 +811,7 @@
     <message>
         <location filename="../OpenRGBDevicePage/OpenRGBDevicePage.cpp" line="1667"/>
         <source>Saving Not Supported</source>
-        <translation>Speichern nicht unterstützt</translation>
+        <translation>Speichern wird nicht unterstützt</translation>
     </message>
     <message>
         <location filename="../OpenRGBDevicePage/OpenRGBDevicePage.cpp" line="1727"/>
@@ -899,7 +899,7 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.ui" line="203"/>
         <source>Save Profile with custom name</source>
-        <translation>Profil mit benutzerdefinierten Namen speichern</translation>
+        <translation>Profil mit eigenem Namen speichern</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="342"/>
@@ -917,7 +917,7 @@
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="350"/>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="559"/>
         <source>Quick Colors</source>
-        <translation>Schnelle Farbenauswahl</translation>
+        <translation>Schnelle Farben</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="352"/>
@@ -997,7 +997,7 @@
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="737"/>
         <source>General Settings</source>
         <translatorcomment>Using &quot;Allg.&quot; as shorthand for &quot;Allgemeine&quot;. &quot;Allgemeine&quot; would be too long for the UI. So until text size is handled differently this should do it.</translatorcomment>
-        <translation>Allgemeine Einstellungen</translation>
+        <translation>Allg. Einstellungen</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="917"/>
@@ -1071,7 +1071,7 @@
     <message>
         <location filename="../OpenRGBLogConsolePage/OpenRGBLogConsolePage.ui" line="39"/>
         <source>Log Level:</source>
-        <translation>Log Level:</translation>
+        <translation>Log Level</translation>
     </message>
     <message>
         <location filename="../OpenRGBLogConsolePage/OpenRGBLogConsolePage.ui" line="32"/>
@@ -1099,7 +1099,9 @@
     <message>
         <location filename="../OpenRGBMatrixMapEditorDialog/OpenRGBMatrixMapEditorDialog.ui" line="72"/>
         <source>Width:</source>
-        <translation>Breite:</translation>
+        <translation>
+
+Breite:</translation>
     </message>
 </context>
 <context>
@@ -1191,7 +1193,7 @@
     <message>
         <location filename="../OpenRGBPluginsPage/OpenRGBPluginsPage.cpp" line="224"/>
         <source>Restart Needed</source>
-        <translation>Neustart Erforderlich</translation>
+        <translation>Programmneustart Erforderlich</translation>
     </message>
     <message>
         <location filename="../OpenRGBPluginsPage/OpenRGBPluginsPage.cpp" line="224"/>
@@ -1229,7 +1231,7 @@
     <message>
         <location filename="../OpenRGBProfileEditorDialog/OpenRGBProfileEditorDialog.ui" line="72"/>
         <source>Device States</source>
-        <translation>Gerätzustände</translation>
+        <translation>Gerätezustände</translation>
     </message>
     <message>
         <location filename="../OpenRGBProfileEditorDialog/OpenRGBProfileEditorDialog.ui" line="78"/>
@@ -1361,7 +1363,7 @@
     <message>
         <location filename="../OpenRGBServerInfoPage/OpenRGBServerInfoPage.cpp" line="65"/>
         <source>Stopping...</source>
-        <translation>Beendet...</translation>
+        <translation>Beenden...</translation>
     </message>
     <message>
         <location filename="../OpenRGBServerInfoPage/OpenRGBServerInfoPage.cpp" line="73"/>
@@ -1692,7 +1694,7 @@
     <message>
         <location filename="../OpenRGBZoneInitializationDialog/OpenRGBZoneInitializationDialog.ui" line="39"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;One or more manually configurable zones have not been configured.  Manually configurable zones are most commonly used for addressable RGB headers where the number of LEDs in the connected device(s) cannot be detected automatically.&lt;/p&gt;&lt;p&gt;Please enter the number of LEDs in each zone below.&lt;/p&gt;&lt;p&gt;For more information about calcuating the correct size, please check &lt;a href=&quot;https://openrgb.org/resize.html&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#0000ff;&quot;&gt;this link.&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
-        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Eine oder mehrere manuell konfigurierbare Zonen wurden nicht konfiguriert. Manuell konfigurierbare Zonen werden normalerweise für adressierbare RGB-Header verwendet, bei denen die Anzahl der LEDs in den angeschlossenen Geräten nicht automatisch erkannt werden kann.&lt;/p&gt;&lt;p&gt;Bitte gebe die Anzahl der LEDs in jeder Zone unten ein.&lt;/p&gt;&lt;p&gt;Weitere Informationen zur Berechnung der richtigen Größe finden Sie &lt;a href=&quot;https://openrgb.org/resize.html&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#0000ff;&quot;&gt;hier.&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Eine oder mehrere manuell konfigurierbare Zonen wurden nicht konfiguriert. Manuell konfigurierbare Zonen werden am häufigsten für adressierbare RGB-Header verwendet, bei denen die Anzahl der LEDs in den angeschlossenen Geräten nicht automatisch erkannt werden kann.&lt;/p&gt;&lt;p&gt;Bitte geben Sie die Anzahl der LEDs in jeder Zone unten ein.&lt;/p&gt;&lt;p&gt;Weitere Informationen zur Berechnung der richtigen Größe finden Sie &lt;a href=&quot;https://openrgb.org/resize.html&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#0000ff;&quot;&gt;hier.&lt;/span&gt;&lt;/a&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneInitializationDialog/OpenRGBZoneInitializationDialog.ui" line="49"/>
@@ -1793,7 +1795,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/PhilipsWizSettingsEntry/PhilipsWizSettingsEntry.ui" line="59"/>
         <source>White Strategy:</source>
-        <translation>Weiß-Strategie:</translation>
+        <translation>Weiß Strategie:</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/PhilipsWizSettingsEntry/PhilipsWizSettingsEntry.cpp" line="19"/>
@@ -1895,7 +1897,7 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="238"/>
         <source>Load Window Geometry</source>
-        <translation>Fenstergeometrie laden</translation>
+        <translation>Fenster Geometrie laden</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="230"/>
@@ -1905,12 +1907,12 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="226"/>
         <source>Disable Key Expansion</source>
-        <translation>Deaktiviere Key-Erweiterung in der Geräteansicht</translation>
+        <translation>Deaktiviere Schlüsselerweiterung in der Geräteansicht</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="217"/>
         <source>Show LED View by Default</source>
-        <translation>LED Anzeige standardmäßig zeigen</translation>
+        <translation>LED anzeige standardmäßig zeigen</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="163"/>
@@ -1950,7 +1952,7 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="195"/>
         <source>Monochrome Tray Icon</source>
-        <translation>Monochromes Tray Icon</translation>
+        <translation>Graues Icon</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="178"/>
@@ -1970,7 +1972,7 @@
     <message>
         <location filename="../../ResourceManager.cpp" line="201"/>
         <source>Initial Detection Delay (ms)</source>
-        <translation>Initiale Erkennungsverzögerung (ms)</translation>
+        <translation>Anfangserkennungsverzögerung (ms)</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="203"/>
@@ -1985,27 +1987,27 @@
     <message>
         <location filename="../../ResourceManager.cpp" line="215"/>
         <source>Enable Log File</source>
-        <translation>Logdatei aktivieren</translation>
+        <translation>Log Datei aktivieren</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="219"/>
         <source>Log Level</source>
-        <translation>Log Level</translation>
+        <translation>Protokollierungsstufe</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="237"/>
         <source>Log File Count Limit</source>
-        <translation>Logdatei-Anzahl-Limit</translation>
+        <translation>Logdateien Anzahl Limit</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="239"/>
         <source>Maximum number of log files to keep, 0 for no limit</source>
-        <translation>Maximale Anzahl der zu behaltenden Logdateien, 0 für keine Begrenzung</translation>
+        <translation>Maximale Anzahl der zu behaltenden Protokolldateien, 0 für keine Begrenzung</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="243"/>
         <source>Log Manager</source>
-        <translation>Log-Manager</translation>
+        <translation>Protokoll-Manager</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="250"/>
@@ -2035,7 +2037,7 @@
     <message>
         <location filename="../../ResourceManager.cpp" line="266"/>
         <source>Workaround for some older SDK implementations that sent incorrect packet size for certain packets</source>
-        <translation>Workaround für einige ältere SDK-Implementierungen, die falsche Paketgrößen für bestimmte Pakete gesendet haben</translation>
+        <translation>Umgehungsmethode für einige ältere SDK-Implementierungen, die falsche Paketgrößen für bestimmte Pakete gesendet haben</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="268"/>
@@ -2060,22 +2062,22 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="207"/>
         <source>Compact Tabs</source>
-        <translation>Kompakte Tabs</translation>
+        <translation>Kompakte Registerkarten</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="209"/>
         <source>Display sidebar tabs as icons only</source>
-        <translation>Seitenleisten-Tabs nur als Icons anzeigen</translation>
+        <translation>Seitenleisten-Registerkarten nur als Icons anzeigen</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="212"/>
         <source>Tabs on Top</source>
-        <translation>Tabs oben</translation>
+        <translation>Registerkarten oben</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="214"/>
         <source>Display tabs on top instead of on the left</source>
-        <translation>Tabs oben anstelle von Links anzeigen</translation>
+        <translation>Registerkarten oben anstelle von links anzeigen</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="221"/>
@@ -2095,7 +2097,7 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="242"/>
         <source>Save on Exit</source>
-        <translation>Beim Schließen speichern</translation>
+        <translation>Geometrie beim Schließen beibehalten</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="244"/>
@@ -2145,17 +2147,17 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="284"/>
         <source>AMD SMBus: Reduce CPU Usage (restart required)</source>
-        <translation>AMD SMBus: CPU-Auslastung reduzieren (Neustart erfoderlich)</translation>
+        <translation>AMD SMBus: CPU-Auslastung reduzieren (Programmneustart erfoderlich)</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="173"/>
         <source>Custom Arguments</source>
-        <translation>Benutzerdefinierte Argumente</translation>
+        <translation>Eigene Argumente</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="272"/>
         <source>Shared SMBus Access (restart required)</source>
-        <translation>Gemeinsamer SMBus-Zugriff (Neustart erforderlich)</translation>
+        <translation>Gemeinsamer SMBus-Zugriff (Programmneustart erforderlich)</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="185"/>

qt/i18n/OpenRGB_nb_NO.ts

@@ -6,7 +6,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/DDPSettingsEntry/DDPSettingsEntry.ui" line="26"/>
         <source>DDP Device</source>
-        <translation>DDP-Enhet</translation>
+        <translation>DDP-enhet</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/DDPSettingsEntry/DDPSettingsEntry.ui" line="32"/>
@@ -41,7 +41,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/DDPSettingsEntry/DDPSettingsEntry.ui" line="100"/>
         <source>Keepalive Time (ms):</source>
-        <translation>Levetid (ms):</translation>
+        <translation>Holdvakttid (ms):</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/DDPSettingsEntry/DDPSettingsEntry.ui" line="116"/>
@@ -54,7 +54,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/DMXSettingsEntry/DMXSettingsEntry.ui" line="26"/>
         <source>DMX Device</source>
-        <translation>DMX-Enhet</translation>
+        <translation>DMX-enhet</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/DMXSettingsEntry/DMXSettingsEntry.ui" line="32"/>
@@ -84,7 +84,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/DMXSettingsEntry/DMXSettingsEntry.ui" line="82"/>
         <source>Keepalive Time:</source>
-        <translation>Levetid:</translation>
+        <translation>Keepalive Time:</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/DMXSettingsEntry/DMXSettingsEntry.ui" line="92"/>
@@ -117,7 +117,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/DebugSettingsEntry/DebugSettingsEntry.ui" line="49"/>
         <source>Zones</source>
-        <translation>Soner</translation>
+        <translation>Zoner</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/DebugSettingsEntry/DebugSettingsEntry.ui" line="55"/>
@@ -137,7 +137,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/DebugSettingsEntry/DebugSettingsEntry.ui" line="76"/>
         <source>Resizable</source>
-        <translation>Størrelsesredigerbar</translation>
+        <translation>Størrelsesendrbar</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/DebugSettingsEntry/DebugSettingsEntry.ui" line="83"/>
@@ -160,17 +160,17 @@
     <message>
         <location filename="../../DetectionManager.cpp" line="48"/>
         <source>&lt;h2&gt;Warning:&lt;/h2&gt;&lt;p&gt;One or more I2C/SMBus interfaces failed to initialize.&lt;/p&gt;&lt;p&gt;Depending on which interfaces failed to initialize, some RGB DRAM modules, some motherboards&apos; onboard RGB lighting, and RGB graphics cards may not be available in OpenRGB.&lt;/p&gt;&lt;p&gt;On Windows, this is usually caused by a failure to load the PawnIO driver.&lt;/p&gt;&lt;p&gt;For OpenRGB to access these devices, you must install PawnIO from &lt;a href=&apos;https://pawnio.eu/&apos;&gt;https://pawnio.eu&lt;/a&gt; and run OpenRGB as administrator or as a system service.&lt;/p&gt;&lt;p&gt;If you are not using any of the devices listed above, you can safely ignore this message.&lt;/p&gt;</source>
-        <translation>&lt;h2&gt;Advarsel:&lt;/h2&gt;&lt;p&gt;Ett eller flere I2C/SMBus-grensesnitt har feilet å initalisere.&lt;/p&gt;&lt;p&gt;Avhengig av hvilke grensesnitt som feilet å initalisere, kan noen RGB DRAM-moduler, RGB-belysning på hovedkort og RGB-grafikkort ikke være tilgjengelige i OpenRGB.&lt;/p&gt;&lt;p&gt;På Windows er dette vanligvis grunnet en feil ved lasting av PawnIO-driveren.&lt;/p&gt;&lt;p&gt;For at OpenRGB skal kunne få tilgang til disse enhetene, må du installere PawnIO fra &lt;a href=&apos;https://pawnio.eu/&apos;&gt;https://pawnio.eu&lt;/a&gt; og kjøre OpenRGB som administrator eller som systemtjeneste.&lt;/p&gt;&lt;p&gt;Hvis du ikke bruker noen av enhetene som er nevnt ovenfor, kan du trygt ignorere denne meldingen.&lt;/p&gt;</translation>
+        <translation>&lt;h2&gt;Advarsel:&lt;/h2&gt;&lt;p&gt;Én eller flere I2C/SMBus-flater feilet under oppstart.&lt;/p&gt;&lt;p&gt;Avhengig av hvilke flater som feilet under oppstart, kan visse RGB DRAM-moduler, visse RGB-belysning på hovedkort og RGB-grafikkort ikke være tilgjengelige i OpenRGB.&lt;/p&gt;&lt;p&gt;På Windows er dette vanligvis forårsaket av en feil ved lasting av PawnIO-drevet.&lt;/p&gt;&lt;p&gt;For at OpenRGB skal kunne få tilgang til disse enhetene, må du installere PawnIO fra &lt;a href=&apos;https://pawnio.eu/&apos;&gt;https://pawnio.eu&lt;/a&gt; og kjøre OpenRGB som administrator eller som systemtjeneste.&lt;/p&gt;&lt;p&gt;Hvis du ikke bruker noen av enhetene som er nevnt ovenfor, kan du trygt ignorere denne meldingen.&lt;/p&gt;</translation>
     </message>
     <message>
         <location filename="../../DetectionManager.cpp" line="55"/>
         <source>&lt;h2&gt;Warning:&lt;/h2&gt;&lt;p&gt;One or more I2C/SMBus interfaces failed to initialize.&lt;/p&gt;&lt;p&gt;Depending on which interfaces failed to initialize, some RGB DRAM modules, some motherboards&apos; onboard RGB lighting, and RGB graphics cards may not be available in OpenRGB.&lt;/p&gt;&lt;p&gt;On Linux, this is usually because the i2c-dev module is not loaded.&lt;/p&gt;&lt;p&gt;For OpenRGB to access these devices, you must load the i2c-dev module along with the correct I2C driver module for your motherboard. This is usually i2c-piix4 for AMD systems and i2c-i801 for Intel systems.&lt;/p&gt;&lt;p&gt;If you are not using any of the devices listed above, you can safely ignore this message.&lt;/p&gt;</source>
-        <translation>&lt;h2&gt;Advarsel:&lt;/h2&gt;&lt;p&gt;Ett eller flere I2C/SMBus-grensesnitt har feilet å initialisere.&lt;/p&gt;&lt;p&gt;Avhengig av hvilke grensesnitt som feilet å initialisere, kan noen RGB DRAM-moduler, RGB-belysning på hovedkortet og RGB-grafikkort ikke være tilgjengelige i OpenRGB.&lt;/p&gt;&lt;p&gt;På Linux er dette vanligvis fordi modulen i2c-dev ikke er lastet.&lt;/p&gt;&lt;p&gt;For at OpenRGB skal kunne tilgå disse enhetene, må du laste modulen i2c-dev sammen med den riktige I2C-drivermodulen for hovedkortet ditt. Dette er vanligvis i2c-piix4 for AMD-systemer og i2c-i801 for Intel-systemer.&lt;/p&gt;&lt;p&gt;Hvis du ikke bruker noen av enhetene som er nevnt ovenfor, kan du trygt ignorere denne meldingen.&lt;/p&gt;</translation>
+        <translation>&lt;h2&gt;Advarsel:&lt;/h2&gt;&lt;p&gt;Én eller flere I2C/SMBus-interfaces har ikke klart å initialisere.&lt;/p&gt;&lt;p&gt;Avhengig av hvilke grensesnitt som ikke klarte å initialisere, kan noen RGB DRAM-moduler, noen RGB-belysning på hovedkortet og RGB-grafikkort være utilgjengelige i OpenRGB.&lt;/p&gt;&lt;p&gt;På Linux er dette vanligvis fordi modulen i2c-dev ikke er lastet.&lt;/p&gt;&lt;p&gt;For at OpenRGB skal kunne tilgå disse enhetene, må du laste modulen i2c-dev sammen med den riktige I2C-drevmodulen for hovedkortet ditt. Dette er vanligvis i2c-piix4 for AMD-systemer og i2c-i801 for Intel-systemer.&lt;/p&gt;&lt;p&gt;Hvis du ikke bruker noen av enhetene som er nevnt ovenfor, kan du trygt ignorere denne meldingen.&lt;/p&gt;</translation>
     </message>
     <message>
         <location filename="../../DetectionManager.cpp" line="64"/>
         <source>&lt;h2&gt;Warning:&lt;/h2&gt;&lt;p&gt;The OpenRGB udev rules are not installed.&lt;/p&gt;&lt;p&gt;Most devices will not be available unless running OpenRGB as as a system service or as root.&lt;/p&gt;&lt;p&gt;If using AppImage, Flatpak, or self-compiled versions of OpenRGB you must install the udev rules manually&lt;/p&gt;&lt;p&gt;See &lt;a href=&apos;https://openrgb.org/udev&apos;&gt;https://openrgb.org/udev&lt;/a&gt; to install the udev rules manually&lt;/p&gt;</source>
-        <translation>&lt;h2&gt;Advarsel:&lt;/h2&gt;&lt;p&gt;OpenRGBs udev-regler er ikke installert.&lt;/p&gt;&lt;p&gt;De fleste enhetene vil ikke være tilgjengelige med mindre du kjører OpenRGB som systemtjeneste eller som rotbruker.&lt;/p&gt;&lt;p&gt;Hvis du bruker AppImage, Flatpak eller selvbygde versjoner av OpenRGB, må du installere udev-reglene manuelt.&lt;/p&gt;&lt;p&gt;Se &lt;a href=&apos;https://openrgb.org/udev&apos;&gt;https://openrgb.org/udev&lt;/a&gt; for å installere udev-reglene manuelt.&lt;/p&gt;</translation>
+        <translation>&lt;h2&gt;Advarsel:&lt;/h2&gt;&lt;p&gt;OpenRGBs udev-regler er ikke installert.&lt;/p&gt;&lt;p&gt;De fleste enheter vil ikke være tilgjengelige med mindre du kjører OpenRGB som systemtjeneste eller som rotbruker.&lt;/p&gt;&lt;p&gt;Hvis du bruker AppImage, Flatpak eller selvbygde versjoner av OpenRGB, må du installere udev-reglene manuelt.&lt;/p&gt;&lt;p&gt;Se &lt;a href=&apos;https://openrgb.org/udev&apos;&gt;https://openrgb.org/udev&lt;/a&gt; for å installere udev-reglene manuelt.&lt;/p&gt;</translation>
     </message>
     <message>
         <location filename="../../DetectionManager.cpp" line="70"/>
@@ -196,12 +196,12 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/E131SettingsEntry/E131SettingsEntry.ui" line="26"/>
         <source>E1.31 Device</source>
-        <translation>E1.31-Enhet</translation>
+        <translation>E1.31-enhet</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/E131SettingsEntry/E131SettingsEntry.ui" line="32"/>
         <source>Keepalive Time:</source>
-        <translation>Levetid:</translation>
+        <translation>Keepalive Time:</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/E131SettingsEntry/E131SettingsEntry.ui" line="39"/>
@@ -221,7 +221,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/E131SettingsEntry/E131SettingsEntry.ui" line="72"/>
         <source>Universe Size:</source>
-        <translation>Universe Størrelse:</translation>
+        <translation>Univers størrelse:</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/E131SettingsEntry/E131SettingsEntry.ui" line="79"/>
@@ -231,7 +231,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/E131SettingsEntry/E131SettingsEntry.ui" line="92"/>
         <source>Start Universe:</source>
-        <translation>Start Universe:</translation>
+        <translation>Start univers:</translation>
     </message>
 </context>
 <context>
@@ -265,7 +265,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/GoveeSettingsEntry/GoveeSettingsEntry.ui" line="26"/>
         <source>Govee Device</source>
-        <translation>Govee-Enhet</translation>
+        <translation>Govee-enhet</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/GoveeSettingsEntry/GoveeSettingsEntry.ui" line="32"/>
@@ -278,7 +278,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/KasaSmartSettingsEntry/KasaSmartSettingsEntry.ui" line="26"/>
         <source>Kasa Smart Device</source>
-        <translation>Kasa Smart-Enhet</translation>
+        <translation>Kasa Smart-enhet</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/KasaSmartSettingsEntry/KasaSmartSettingsEntry.ui" line="35"/>
@@ -296,12 +296,12 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/LIFXSettingsEntry/LIFXSettingsEntry.ui" line="26"/>
         <source>LIFX Device</source>
-        <translation>LIFX-Enhet</translation>
+        <translation>LIFX-enhet</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/LIFXSettingsEntry/LIFXSettingsEntry.ui" line="35"/>
         <source>Multizone</source>
-        <translation>Multisone</translation>
+        <translation>Multizon</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/LIFXSettingsEntry/LIFXSettingsEntry.ui" line="42"/>
@@ -316,7 +316,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/LIFXSettingsEntry/LIFXSettingsEntry.ui" line="62"/>
         <source>Extended Multizone</source>
-        <translation>Utvidet multisone</translation>
+        <translation>Utvidet multizon</translation>
     </message>
 </context>
 <context>
@@ -324,12 +324,12 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/DDPSettingsEntry/DDPSettingsEntry.cpp" line="98"/>
         <source>DDP (Distributed Display Protocol)</source>
-        <translation>DDP (Distributed Display Protocol)</translation>
+        <translation>DDP (fordelt visningsprotokoll)</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/DebugSettingsEntry/DebugSettingsEntry.cpp" line="143"/>
         <source>Debug Device</source>
-        <translation>Feilsøkingsenhet</translation>
+        <translation>Feilsøk enhet</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/E131SettingsEntry/E131SettingsEntry.cpp" line="116"/>
@@ -349,7 +349,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/SerialSettingsEntry/SerialSettingsEntry.cpp" line="163"/>
         <source>Serial Device</source>
-        <translation>Seriell Enhet</translation>
+        <translation>Seriell enhet</translation>
     </message>
 </context>
 <context>
@@ -368,7 +368,7 @@
         <location filename="../ManualDevicesSettingsPage/ManualDevicesSettingsPage.ui" line="49"/>
         <location filename="../ManualDevicesSettingsPage/ManualDevicesSettingsPage.ui" line="61"/>
         <source>Save and Rescan</source>
-        <translation>Lagre og skann på nytt</translation>
+        <translation>Lagre og skann igjen</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/ManualDevicesSettingsPage.ui" line="66"/>
@@ -399,7 +399,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/NanoleafSettingsEntry/NanoleafScanDialog.ui" line="20"/>
         <source>To pair, hold the on-off button down for 5-7 seconds until the LED starts flashing in a pattern, a new entry should appear in the list below, then click the &quot;Pair&quot; button on the entry within 30 seconds.</source>
-        <translation>For å pare, hold på på/av-knappen i 5-7 sekunder til LED-en begynner å blinke i et mønster. En ny oppføring bør vises i listen under, deretter klikk på &quot;Parre&quot;-knappen på oppføringen innen 30 sekunder.</translation>
+        <translation>For å parre, hold på på/av-knappen i 5-7 sekunder til LED-en begynner å blinke i et mønster. En ny oppføring bør vises i listen under, deretter klikk på &quot;Parre&quot;-knappen for oppføringen innen 30 sekunder.</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/NanoleafSettingsEntry/NanoleafScanDialog.ui" line="42"/>
@@ -422,7 +422,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/NanoleafSettingsEntry/NanoleafSettingsEntry.ui" line="26"/>
         <source>Nanoleaf Device</source>
-        <translation>Nanoleaf-Enhet</translation>
+        <translation>Nanoleaf-enhet</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/NanoleafSettingsEntry/NanoleafSettingsEntry.ui" line="32"/>
@@ -437,7 +437,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/NanoleafSettingsEntry/NanoleafSettingsEntry.ui" line="60"/>
         <source>Auth Key:</source>
-        <translation>Auth Nøkkel:</translation>
+        <translation>Auth Key:</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/NanoleafSettingsEntry/NanoleafSettingsEntry.ui" line="74"/>
@@ -1612,7 +1612,7 @@
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="14"/>
         <source>Zone Editor</source>
-        <translation>Soneredigerer</translation>
+        <translation>Zoneredigerer</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="20"/>
@@ -1647,37 +1647,37 @@
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="99"/>
         <source>Reset Zone Configuration</source>
-        <translation>Nullstill konfigurasjon for soner</translation>
+        <translation>Nullstill konfigurasjon for område</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="124"/>
         <source>Device-Specific Zone Configuration</source>
-        <translation>Enhetspesifikk sonekonfigurasjon</translation>
+        <translation>Enhetspesifikk zonkonfigurasjon</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="151"/>
         <source>Zone Configuration</source>
-        <translation>Sonekonfigurasjon</translation>
+        <translation>Zonkonfigurasjon</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="159"/>
         <source>Zone Type:</source>
-        <translation>Sonetype:</translation>
+        <translation>Zonetype:</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="176"/>
         <source>Zone Matrix Map:</source>
-        <translation>Sonematrisekart:</translation>
+        <translation>Zonematrisekart:</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="185"/>
         <source>Zone Name:</source>
-        <translation>Sonenummer:</translation>
+        <translation>Zonenummer:</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="192"/>
         <source>Zone Size:</source>
-        <translation>Størrelse på sone:</translation>
+        <translation>Størrelse på zone:</translation>
     </message>
 </context>
 <context>
@@ -1686,7 +1686,7 @@
         <location filename="../OpenRGBZoneInitializationDialog/OpenRGBZoneInitializationDialog.ui" line="14"/>
         <location filename="../OpenRGBZoneInitializationDialog/OpenRGBZoneInitializationDialog.cpp" line="81"/>
         <source>Zone Initialization</source>
-        <translation>Sonestart</translation>
+        <translation>Zonestart</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneInitializationDialog/OpenRGBZoneInitializationDialog.ui" line="39"/>
@@ -1739,7 +1739,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/PhilipsHueSettingsEntry/PhilipsHueSettingsEntry.ui" line="46"/>
         <source>Auto Connect Group:</source>
-        <translation>Auto-connect-gruppe:</translation>
+        <translation>Auto connect gruppe:</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/PhilipsHueSettingsEntry/PhilipsHueSettingsEntry.ui" line="60"/>
@@ -1749,7 +1749,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/PhilipsHueSettingsEntry/PhilipsHueSettingsEntry.ui" line="74"/>
         <source>Client Key:</source>
-        <translation>Klientnøkkel:</translation>
+        <translation>Klient nøkkel:</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/PhilipsHueSettingsEntry/PhilipsHueSettingsEntry.ui" line="81"/>
@@ -1772,7 +1772,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/PhilipsWizSettingsEntry/PhilipsWizSettingsEntry.ui" line="26"/>
         <source>Philips Wiz Device</source>
-        <translation>Philips Wiz-Enhet</translation>
+        <translation>Philips Wiz-enhet</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/PhilipsWizSettingsEntry/PhilipsWizSettingsEntry.ui" line="32"/>
@@ -1810,7 +1810,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/QMKORGBSettingsEntry/QMKORGBSettingsEntry.ui" line="26"/>
         <source>QMK OpenRGB Device</source>
-        <translation>QMK OpenRGB-Enhet</translation>
+        <translation>QMK OpenRGB-enhet</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/QMKORGBSettingsEntry/QMKORGBSettingsEntry.ui" line="38"/>
@@ -1833,7 +1833,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/QMKVialRGBSettingsEntry/QMKVialRGBSettingsEntry.ui" line="26"/>
         <source>QMK VialRGB Device</source>
-        <translation>QMK VialRGB-Enhet</translation>
+        <translation>QMK VialRGB-enhet</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/QMKVialRGBSettingsEntry/QMKVialRGBSettingsEntry.ui" line="38"/>
@@ -1904,7 +1904,7 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="226"/>
         <source>Disable Key Expansion</source>
-        <translation>Deaktiver Key-utvidelse i enhetsvisning</translation>
+        <translation>Deaktiver nøkkelutvidelse i enhetsvisning</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="217"/>
@@ -1929,7 +1929,7 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="170"/>
         <source>Start minimized to the system tray</source>
-        <translation>Start minimeret til systemtrayet</translation>
+        <translation>Start minimeret til systemtrayen</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="175"/>
@@ -1944,12 +1944,12 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="191"/>
         <source>Keep OpenRGB active in the system tray when closing the main window</source>
-        <translation>Hold OpenRGB aktiv i systemtrayet når hovedvinduet lukkes</translation>
+        <translation>Hold OpenRGB aktiv i systemtrayen når hovedvinduet lukkes</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="195"/>
         <source>Monochrome Tray Icon</source>
-        <translation>Monokromt tray icon</translation>
+        <translation>Grått icon</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="178"/>
@@ -1959,7 +1959,7 @@
     <message>
         <location filename="../../ResourceManager.cpp" line="197"/>
         <source>HID Safe Mode</source>
-        <translation>HID tryggmodus</translation>
+        <translation>HID trygge modus</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="199"/>
@@ -1974,7 +1974,7 @@
     <message>
         <location filename="../../ResourceManager.cpp" line="203"/>
         <source>Amount of time, in milliseconds, to wait before detecting devices when started</source>
-        <translation>Antall millisekunder som skal ventes før enheter oppdages når programmet startes</translation>
+        <translation>Antall millisekunder som skal vente før enheter oppdages når programmet startes</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="205"/>
@@ -1994,17 +1994,17 @@
     <message>
         <location filename="../../ResourceManager.cpp" line="237"/>
         <source>Log File Count Limit</source>
-        <translation>Loggfil antallsgrense</translation>
+        <translation>Antall loggfiler grense</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="239"/>
         <source>Maximum number of log files to keep, 0 for no limit</source>
-        <translation>Maksimalt antall loggfiler som skal beholdes, 0 for ubegrenset</translation>
+        <translation>Maksimal antall loggfiler som skal beholdes, 0 for ubegrenset</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="243"/>
         <source>Log Manager</source>
-        <translation>Loggmanager</translation>
+        <translation>Loggadministrator</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="250"/>
@@ -2029,7 +2029,7 @@
     <message>
         <location filename="../../ResourceManager.cpp" line="264"/>
         <source>Legacy Workaround</source>
-        <translation>Workaround for eldre systemer</translation>
+        <translation>Tilbakeholdelse for eldre systemer</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="266"/>
@@ -2049,7 +2049,7 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="196"/>
         <source>Use a monochrome icon in the system tray instead of a full color icon</source>
-        <translation>Bruk et monokromt ikon i systemtrayet istedenfor et farget ikon</translation>
+        <translation>Bruk en monokrom ikon i systemlåsen istedenfor et fargelagt ikon</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="202"/>
@@ -2059,7 +2059,7 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="207"/>
         <source>Compact Tabs</source>
-        <translation>Kompakte faner</translation>
+        <translation>Kompakte faneinnhold</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="209"/>
@@ -2069,12 +2069,12 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="212"/>
         <source>Tabs on Top</source>
-        <translation>Faner på toppen</translation>
+        <translation>Fanebånd på toppen</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="214"/>
         <source>Display tabs on top instead of on the left</source>
-        <translation>Vis faner øverst istedenfor på venstre side</translation>
+        <translation>Vis faneinnholdet øverst istedenfor på venstre side</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="221"/>
@@ -2089,7 +2089,7 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="234"/>
         <source>Window Geometry</source>
-        <translation>Vindugeometri</translation>
+        <translation>Vindu geometri</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="242"/>
@@ -2099,7 +2099,7 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="244"/>
         <source>Save window geometry on exit</source>
-        <translation>Lagre vindugeometri ved avslutting</translation>
+        <translation>Lagre vinduets geometri ved avslutt</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="247"/>
@@ -2124,17 +2124,17 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="263"/>
         <source>User Interface</source>
-        <translation>Brukergrensesnitt</translation>
+        <translation>Bruker grensesnitt</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="275"/>
         <source>SMBus Sleep Mode (restart required)</source>
-        <translation>SMBus-Søvnmodus (omstart kreves)</translation>
+        <translation>SMBus-søvnmodus (omstart kreves)</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="288"/>
         <source>Drivers</source>
-        <translation>Drivere</translation>
+        <translation>Journaler</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="212"/>
@@ -2144,12 +2144,12 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="284"/>
         <source>AMD SMBus: Reduce CPU Usage (restart required)</source>
-        <translation>AMD SMBus: Reduser CPU bruk (omstart kreves)</translation>
+        <translation>AMD SMBus: reduser CPU bruk (omstart kreves)</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="173"/>
         <source>Custom Arguments</source>
-        <translation>Egene Argumenter</translation>
+        <translation>Eigene Argumente</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="272"/>
@@ -2164,7 +2164,7 @@
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="200"/>
         <source>Hex Format</source>
-        <translation>Hex Format</translation>
+        <translation>Hex format</translation>
     </message>
     <message>
         <location filename="../OpenRGBDynamicSettingsWidget/OpenRGBDynamicSettingsWidget.cpp" line="357"/>
@@ -2174,7 +2174,7 @@
     <message>
         <location filename="../../ProfileManager.cpp" line="51"/>
         <source>Load Profile on Exit</source>
-        <translation>Last profil ved avslutting</translation>
+        <translation>Last ned profil ved avslutt</translation>
     </message>
     <message>
         <location filename="../../ProfileManager.cpp" line="53"/>
@@ -2184,7 +2184,7 @@
     <message>
         <location filename="../../ProfileManager.cpp" line="55"/>
         <source>Load Profile on Open</source>
-        <translation>Last profil ved åpning</translation>
+        <translation>Last inn profil ved åpning</translation>
     </message>
     <message>
         <location filename="../../ProfileManager.cpp" line="57"/>
@@ -2194,7 +2194,7 @@
     <message>
         <location filename="../../ProfileManager.cpp" line="59"/>
         <source>Load Profile on Resume</source>
-        <translation>Last profil ved våkning</translation>
+        <translation>Last ned profil ved gjenoppretting</translation>
     </message>
     <message>
         <location filename="../../ProfileManager.cpp" line="61"/>
@@ -2204,17 +2204,17 @@
     <message>
         <location filename="../../ProfileManager.cpp" line="63"/>
         <source>Load Profile on Service Shutdown</source>
-        <translation>Last profil ved tjenestestopp</translation>
+        <translation>Last ned profil ved tjenestestopp</translation>
     </message>
     <message>
         <location filename="../../ProfileManager.cpp" line="65"/>
         <source>Profile to load when the OpenRGB background service shuts down</source>
-        <translation>Profil som skal lastes når OpenRGB bakgrunnstjenesten slutter</translation>
+        <translation>Profil som skal lastes når OpenRGB bakgrunns-tjenesten slutter</translation>
     </message>
     <message>
         <location filename="../../ProfileManager.cpp" line="67"/>
         <source>Load Profile on Service Startup</source>
-        <translation>Last profil ved tjenestestart</translation>
+        <translation>Last ned profil ved tjenestestart</translation>
     </message>
     <message>
         <location filename="../../ProfileManager.cpp" line="69"/>
@@ -2224,7 +2224,7 @@
     <message>
         <location filename="../../ProfileManager.cpp" line="71"/>
         <source>Load Profile on Suspend</source>
-        <translation>Last profil ved suspendering</translation>
+        <translation>Last ned profil ved å sette på pause</translation>
     </message>
     <message>
         <location filename="../../ProfileManager.cpp" line="73"/>
@@ -2234,7 +2234,7 @@
     <message>
         <location filename="../../ProfileManager.cpp" line="75"/>
         <source>Profile Manager</source>
-        <translation>Profilmanager</translation>
+        <translation>Profilhåndterer</translation>
     </message>
 </context>
 <context>
@@ -2250,7 +2250,7 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/YeelightSettingsEntry/YeelightSettingsEntry.ui" line="26"/>
         <source>Yeelight Device</source>
-        <translation>Yeelight-Enhet</translation>
+        <translation>Yeelight-enhet</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/YeelightSettingsEntry/YeelightSettingsEntry.ui" line="39"/>

qt/org.openrgb.OpenRGB.metainfo.xml

@@ -48,11 +48,10 @@
   </description>
 
   <releases>
-    <release version="1.0" date="2026-09-11"></release>
-    <release version="1.0~rc3.1" date="2026-08-23" type="development"></release>
-    <release version="1.0~rc3" date="2026-06-28" type="development"></release>
-    <release version="1.0~rc2" date="2025-09-14" type="development"></release>
-    <release version="1.0~rc1" date="2025-02-22" type="development"></release>
+    <release version="1.0rc3.1" date="2026-08-23"></release>
+    <release version="1.0rc3" date="2026-06-28"></release>
+    <release version="1.0rc2" date="2025-09-14"></release>
+    <release version="1.0rc1" date="2025-02-22"></release>
     <release version="0.9" date="2023-06-09"></release>
     <release version="0.8" date="2022-11-27"></release>
     <release version="0.7" date="2021-12-30"></release>

scripts/build-msi.sh

@@ -107,7 +107,6 @@ XML_FILE+="        <Icon Id='OpenRGBIcon' SourceFile='${ICONFILE}'/>\r\n"
 XML_FILE+="        <Property Id='ARPPRODUCTICON' Value='OpenRGBIcon'/>\r\n"
 XML_FILE+="        <Property Id='ARPURLINFOABOUT' Value='https://www.openrgb.org'/>\r\n"
 XML_FILE+="        <Property Id='WIXUI_INSTALLDIR' Value='INSTALLDIR'/>\r\n"
-XML_FILE+="        <Property Id='INSTALLLEVEL' Value='2' />\r\n"
 XML_FILE+="        <WixVariable Id='WixUILicenseRtf' Value='${LICENSEFILE}'/>\r\n"
 XML_FILE+="        <WixVariable Id='WixUIBannerBmp' Value='${BANNERIMAGE}'/>\r\n"
 XML_FILE+="        <WixVariable Id='WixUIDialogBmp' Value='${DIALOGBACKGROUND}'/>\r\n"
@@ -128,7 +127,7 @@ XML_FILE+="                <Control Id='BannerBitmap' Type='Bitmap' X='0' Y='0'
 XML_FILE+="                <Control Id='BannerLine' Type='Line' X='0' Y='44' Width='373' Height='0' />\r\n"
 XML_FILE+="                <Control Id='BottomLine' Type='Line' X='0' Y='234' Width='373' Height='0' />\r\n"
 XML_FILE+="                <Control Id='MainText' Type='Text' X='40' Y='60' Width='300' Height='40' Text='This project interacts directly with hardware using reverse engineered protocols.  While we do our best to make sure we&apos;re sending the right data, there is always some risk in sending data to hardware when we don&apos;t understand exactly how that hardware works.' />\r\n"
-XML_FILE+="                <Control Id='SecondText' Type='Text' X='40' Y='100' Width='300' Height='80' Text='There have been issues in the past with certain hardware getting damaged/bricked and we have either disabled or fixed the offending code.  That said, with OpenRGB always changing and the landscape of RGB devices being of widely varying quality, we can&apos;t guarantee it won&apos;t happen again.  By installing and using OpenRGB you accept this risk.' />\r\n"
+XML_FILE+="                <Control Id='SecondText' Type='Text' X='40' Y='100' Width='300' Height='40' Text='There have been issues in the past with certain hardware getting damaged/bricked and we have either disabled or fixed the offending code.  That said, with OpenRGB always changing and the landscape of RGB devices being of widely varying quality, we can&apos;t guarantee it won&apos;t happen again.  By installing and using OpenRGB you accept this risk.' />\r\n"
 XML_FILE+="            </Dialog>\r\n"
 XML_FILE+="\r\n"
 XML_FILE+="            <Dialog Id='PawnIODialog' Width='370' Height='270' Title='!(loc.InstallDirDlg_Title)'>\r\n"

scripts/prepare-artifacts.py

@@ -12,12 +12,12 @@ import os
 #############################################
 # OpenRGB version                           #
 #############################################
-version = "1.0"
+version = "1.0rc3"
 
 #############################################
 # Git version (tag, branch, or commit)      #
 #############################################
-git_id = "release_1.0"
+git_id = "release_candidate_1.0rc3"
 
 command = "git rev-list -n 1 " + git_id
 print(command)
@@ -36,27 +36,19 @@ artifacts = [
     [ "Windows%2064%20MSI",                         "OpenRGB_" + version + "_Windows_64_"     + commit, ".msi"      ],
     [ "Windows%2064",                               "OpenRGB_" + version + "_Windows_64_"     + commit, ".zip"      ],
     [ "Windows%2032",                               "OpenRGB_" + version + "_Windows_32_"     + commit, ".zip"      ],
-
-    [ "Linux%20amd64%20AppImage",                   "OpenRGB_" + version + "_x86_64_"         + commit, ".AppImage" ],
-    [ "Linux%20arm64%20AppImage",                   "OpenRGB_" + version + "_arm64_"          + commit, ".AppImage" ],
-    [ "Linux%20i386%20AppImage",                    "OpenRGB_" + version + "_i386_"           + commit, ".AppImage" ],
-    [ "Linux%20armhf%20AppImage",                   "OpenRGB_" + version + "_armhf_"          + commit, ".AppImage" ],
-
-    [ "Linux%20amd64%20Flatpak",                    "openrgb_" + version + "_x86_64_"         + commit, ".flatpak"  ],
-    [ "Linux%20arm64%20Flatpak",                    "openrgb_" + version + "_arm64_"          + commit, ".flatpak"  ],
-
     [ "Linux+amd64+.deb+%28Debian+Bookworm%29",     "openrgb_" + version + "_amd64_bookworm_" + commit, ".deb"      ],
-    [ "Linux+arm64+.deb+%28Debian%20Bookworm%29",   "openrgb_" + version + "_arm64_bookworm_" + commit, ".deb"      ],
     [ "Linux+i386+.deb+%28Debian+Bookworm%29",      "openrgb_" + version + "_i386_bookworm_"  + commit, ".deb"      ],
-    [ "Linux+armhf+.deb+%28Debian%20Bookworm%29",   "openrgb_" + version + "_armhf_bookworm_" + commit, ".deb"      ],
-
     [ "Linux+amd64+.deb+%28Debian+Trixie%29",       "openrgb_" + version + "_amd64_trixie_"   + commit, ".deb"      ],
-    [ "Linux+arm64+.deb+%28Debian%20Trixie%29",     "openrgb_" + version + "_arm64_trixie_"   + commit, ".deb"      ],
     [ "Linux+i386+.deb+%28Debian+Trixie%29",        "openrgb_" + version + "_i386_trixie_"    + commit, ".deb"      ],
+    [ "Linux%20amd64%20AppImage",                   "OpenRGB_" + version + "_x86_64_"         + commit, ".AppImage" ],
+    [ "Linux%20i386%20AppImage",                    "OpenRGB_" + version + "_i386_"           + commit, ".AppImage" ],
+    [ "Linux+64+F43+rpm",                           "openrgb_" + version + "_x86_64_f43_"     + commit, ".rpm"      ],
+    [ "Linux+arm64+.deb+%28Debian%20Bookworm%29",   "openrgb_" + version + "_arm64_bookworm_" + commit, ".deb"      ],
+    [ "Linux+armhf+.deb+%28Debian%20Bookworm%29",   "openrgb_" + version + "_armhf_bookworm_" + commit, ".deb"      ],
+    [ "Linux+arm64+.deb+%28Debian%20Trixie%29",     "openrgb_" + version + "_arm64_trixie_"   + commit, ".deb"      ],
     [ "Linux+armhf+.deb+%28Debian%20Trixie%29",     "openrgb_" + version + "_armhf_trixie_"   + commit, ".deb"      ],
-
-    [ "Linux+amd64+.rpm+%28Fedora+44%29",           "openrgb_" + version + "_x86_64_f44_"     + commit, ".rpm"      ],
-
+    [ "Linux%20arm64%20AppImage",                   "OpenRGB_" + version + "_arm64_"          + commit, ".AppImage" ],
+    [ "Linux%20armhf%20AppImage",                   "OpenRGB_" + version + "_armhf_"          + commit, ".AppImage" ],
     [ "MacOS%20Intel",                              "OpenRGB_" + version + "_MacOS_Intel_"    + commit, ".zip"      ],
     [ "MacOS%20ARM64",                              "OpenRGB_" + version + "_MacOS_ARM64_"    + commit, ".zip"      ]
 ]
@@ -117,4 +109,4 @@ for artifact in artifacts:
         #########################################
         command = "mv download.zip artifacts/" + artifact[1] + artifact[2]
         print(command)
-        os.system(command)
+        os.system(command)