Add ignore parameter for schema entries that should be ignored by the UI and allowed regardless of content by settings validator

AutoStart/AutoStart-Flatpak.cpp

@@ -0,0 +1,158 @@
+/*---------------------------------------------------------*\
+| 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

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------*\
+| 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,9 +40,15 @@ 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/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() >= (zone_idx + 1) * 2)
+                        if(current_mode.colors.size() >= (std::size_t)((zone_idx + 1) * 2))
                         {
                             c1 = current_mode.colors[zone_idx * 2];
                             c2 = current_mode.colors[(zone_idx * 2) + 1];

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

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

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -81,6 +81,7 @@
 #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                                      |
@@ -215,6 +216,7 @@ 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/GainwardGPUController/GainwardGPUControllerDetect.cpp

@@ -1,102 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,78 +0,0 @@
-/*---------------------------------------------------------*\
-| 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/RGBController_GainwardGPUv1.cpp

@@ -1,115 +0,0 @@
-/*---------------------------------------------------------*\
-| 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/GainwardGPUv2Controller/GainwardGPUv2Controller.cpp

@@ -1,97 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,101 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,187 +0,0 @@
-/*---------------------------------------------------------*\
-| 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,33 +0,0 @@
-/*---------------------------------------------------------*\
-| 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",            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 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 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/GigabyteRGBFusion2USBController/GigabyteRGBFusion2USBController.cpp

@@ -584,6 +584,11 @@ 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,6 +367,7 @@ 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, uint32_t lid)
+static IT5711ZoneCounts GetIT5711ZoneCounts(uint8_t fw_id, uint8_t fw_revision, uint32_t lid)
 {
     switch(fw_id)
     {
@@ -50,31 +50,63 @@ static IT5711ZoneCounts GetIT5711ZoneCounts(uint8_t fw_id, uint32_t lid)
             return {13, 0};
 
         case 0x05:
-        case 0x0C:
             switch(lid)
             {
-                case 0x016001DF:
-                    return {8, 4};
+                case 0x017001DF:
+                    return {16, 4};
 
                 case 0x028001DF:
                     return {26, 18};
 
                 default:
-                    return {16, 4};
+                    return {8, 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, std::vector<gb_fusion2_zone*>& allocated_zones)
+static void ApplyIT5711ZoneCounts(gb_fusion2_device* layout, uint8_t fw_id, uint8_t fw_revision, std::vector<gb_fusion2_zone*>& allocated_zones)
 {
-    IT5711ZoneCounts counts = GetIT5711ZoneCounts(fw_id, layout->layout_id);
+    IT5711ZoneCounts counts = GetIT5711ZoneCounts(fw_id, fw_revision, layout->layout_id);
 
     for(uint8_t zone_idx = 0; zone_idx < GB_FUSION2_ZONES_MAX; ++zone_idx)
     {
@@ -293,7 +325,6 @@ RGBController_RGBFusion2USB::RGBController_RGBFusion2USB(RGBFusion2USBController
     serial                      = controller->GetSerial();
     product_id                  = controller->GetProductID();
     device_num                  = controller->GetDeviceNum();
-    fw_id                       = controller->GetFWID();
 
 
     mode Direct;
@@ -598,7 +629,10 @@ void RGBController_RGBFusion2USB::Init_Controller()
     \*---------------------------------------------------------*/
     if(product_id == 0x5711)
     {
-        ApplyIT5711ZoneCounts(&instance_layout, fw_id, allocated_zones);
+        ApplyIT5711ZoneCounts(&instance_layout,
+                                 controller->GetFWID(),
+                                 controller->GetFWRevision(),
+                                 allocated_zones);
     }
 
     /*---------------------------------------------------------*\
@@ -1472,8 +1506,12 @@ 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,7 +48,6 @@ 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_WIDTH, HYPERX_QUADCAST_2S_MATRIX_HEIGHT, led_mapping);
+    Mic.matrix_map.Set(HYPERX_QUADCAST_2S_MATRIX_HEIGHT, HYPERX_QUADCAST_2S_MATRIX_WIDTH, led_mapping);
 
     for(unsigned int i = 0; i < HYPERX_QUADCAST_2S_TOTAL_LEDS; i ++)
     {

Controllers/MSIMotherboardController/MSIMotherboard185Controller/MSIMotherboard185Controller.cpp

@@ -38,13 +38,14 @@ using namespace std::chrono_literals;
 
 struct mystic_light_185_config
 {
-    unsigned short                           pid;                   // PID of the board
-    int                                      numof_onboard_leds;    // number of onboard leds
-    int                                      numof_pipe1_leds;      // number of pipe 1 leds (used in per LED mode only)
-    int                                      numof_pipe2_leds;      // number of pipe 2 leds (used in per LED mode only)
-    int                                      numof_JRGBs;           // number of supported JRGB headers (used in per LED mode only)
-    const std::vector<MSI_ZONE>*             supported_zones;       // pointer to vector of supported zones
-    MSIMotherboard185Controller::DIRECT_MODE per_led_mode;          // type of direct mode support
+    unsigned short                           pid;                       // PID of the board
+    int                                      numof_onboard_leds;        // number of onboard leds
+    int                                      numof_pipe1_leds;          // number of pipe 1 leds (used in per LED mode only)
+    int                                      numof_pipe2_leds;          // number of pipe 2 leds (used in per LED mode only)
+    int                                      numof_JRGBs;               // number of supported JRGB headers (used in per LED mode only)
+    const std::vector<MSI_ZONE>*             supported_zones;           // pointer to vector of supported zones
+    MSIMotherboard185Controller::DIRECT_MODE per_led_mode;              // type of direct mode support
+    unsigned char                            minimum_firmware_version;  // minimum required firmware version for this config (0 = all versions acceptable)
 };
 
 const std::vector<MSI_ZONE> all_zones =
@@ -257,104 +258,103 @@ const std::vector<MSI_ZONE> zones_set21 =
 
 static const mystic_light_185_config board_configs[] =
 {
-    { 0x7B93, 6,  1,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MPG X570 GAMING PRO CARBON WIFI
-    { 0x7C34, 0,  1,  1, 1, &zones_set8,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MEG X570 GODLIKE
-    { 0x7C35, 0,  1,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MEG X570 ACE
-    { 0x7C36, 6,  1,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // PRESTIGE X570 CREATION
-    { 0x7C37, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MPG X570 GAMING PLUS
-    { 0x7C56, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B550 GAMING PLUS
-    { 0x7C59, 0,  8,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED },      // CREATOR TRX40
-    { 0x7C60, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // TRX40-A PRO
-    { 0x7C67, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B365M MORTAR
-    { 0x7C71, 6,  6,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z490 ACE
-    { 0x7C73, 6,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z490 GAMING CARBON WIFI
-    { 0x7C75, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z490 GAMING PLUS
-    { 0x7C76, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED },      // MPG Z490M GAMING EDGE
-    { 0x7C77, 0,  0,  0, 0, &zones_set14, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z490I UNIFY
-    { 0x7C79, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z490 GAMING EDGE WIFI
-    { 0x7C80, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG Z490 TOMAHAWK
-    { 0x7C02, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B450 TOMAHAWK MAX
-    { 0x7C81, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B460 TOMAHAWK
-    { 0x7C82, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B460M MORTAR WIFI
-    { 0x7C83, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED },      // B460M PRO-VDH WIFI
-    { 0x7C84, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MAG X570 TOMAHAWK WIFI
-    { 0x7C86, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED },      // MPG B460I GAMING EDGE
-    { 0x7C87, 6,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B450M BAZOOKA MAX WIFI
-    { 0x7C90, 6,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B550 GAMING CARBON WIFI
-    { 0x7C91, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B550 TOMAHAWK
-    { 0x7C92, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B550I GAMING EDGE WIFI
-    { 0x7C94, 6,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B550M MORTAR
-    { 0x7C95, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B550M PRO-VDH WIFI
-    { 0x7C98, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // Z490 PLUS
-    { 0x7D03, 0, 15, 18, 1, &zones_set8,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z590 GODLIKE
-    { 0x7D06, 4,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z590 GAMING FORCE
-    { 0x7D07, 4,  5,  0, 2, &zones_set7,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z590 GAMING EDGE WIFI
-    { 0x7D08, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG Z590 TOMAHAWK
-    { 0x7D09, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // Z590-A PRO WIFI
-    { 0x7D13, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG B550 UNIFY
-    { 0x7D14, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // A520M PRO
-    { 0x7D15, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B560 TOMAHAWK WIFI
-    { 0x7D17, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B560M MORTAR
-    { 0x7D18, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B560M PRO-VDH
-    { 0x7D19, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B560I GAMIING EDGE WIFI
-    { 0x7D20, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B560M PRO
-    { 0x7D25, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z690-A WIFI DDR4
-    { 0x7D27, 6,  0,  0, 2, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z690 ACE
-    { 0x7D28, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z690 UNIFY-X
-    { 0x7D29, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z690I UNIFY
-    { 0x7D30, 6,  6,  0, 2, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z690 CARBON WIFI
-    { 0x7D31, 4,  8,  0, 2, &zones_set12, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG EDGE WIFI DDR4
-    { 0x7D32, 1,  0,  0, 1, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG Z690 TOMAHAWK WIFI DDR4
-    { 0x7D33, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z790-VC WIFI
-    { 0x7D36, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z690-P DDR4
-    { 0x7D37, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B760M-VC WIFI (MS-7D37) - fans on JRAINBOW2
-    { 0x7D38, 0,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z590 UNIFY-X
-    { 0x7D40, 0,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B760i EDGE WIFI DDR4
-    { 0x7D41, 6,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B660M TOMAHAWK WIFI DDR4
-    { 0x7D42, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B660 MORTAR WIFI DDR4
-    { 0x7D43, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B660M-A WIFI DDR4
-    { 0x7D46, 0,  1,  1, 0, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO H610M-G DDR4
-    { 0x7D50, 6, 12,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG X570S ACE MAX
-    { 0x7D51, 6,  0,  0, 2, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG X570S UNIFY-X MAX
-    { 0x7D52, 6, 14,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG X570S CARBON EK X
-    { 0x7D53, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG X570S EDGE MAX WIFI
-    { 0x7D54, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG X570S TOMAHAWK MAX WIFI
-    { 0x7D59, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B660-A DDR4
-    { 0x7D67, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO X670-P WIFI
-    { 0x7D69, 9,  2,  4, 1, &zones_set15, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG X670E ACE
-    { 0x7D70, 0,  6,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG X670E Carbon WIFI
-    { 0x7D73, 1,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B650I EDGE WIFI
-    { 0x7D74, 0,  6,  0, 1, &zones_set18, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B650 CARBON WIFI
-    { 0x7D75, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B650 TOMAHAWK WIFI
-    { 0x7D76, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B650M MORTAR WIFI
-    { 0x7D77, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B650M-A WIFI
-    { 0x7D78, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B650-P WIFI
-    { 0x7D86, 0, 18,  4, 1, &zones_set16, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MEG Z790 ACE
-    { 0x7D88, 0,  0,  0, 1, &zones_set20, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z790-S WIFI
-    { 0x7D89, 0,  6,  0, 1, &zones_set18, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z790 CARBON WIFI
-    { 0x7D90, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B760M BOMBER DDR4
-    { 0x7D91, 1,  0,  0, 1, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG Z790 TOMAHAWK WIFI
-    { 0x7D93, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // Z790 GAMING PRO WIFI
-    { 0x7D96, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B760 TOMAHAWK WIFI DDR5
-    { 0x7D97, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B660 MORTAR MAX WIFI DDR4
-    { 0x7D98, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B760-P WIFI DDR4
-    { 0x7D99, 6,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B760M-A WIFI DDR4
-    { 0x7E01, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG B760M MORTAR MAX
-    { 0x7E03, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG Z790I EDGE WIFI
-    { 0x7E06, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z790-P WIFI DDR4
-    { 0x7E07, 0,  0,  0, 2, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO Z790-A WIFI DDR4
-    { 0x7E09, 0,  0,  0, 0, &zones_set19, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B650M PROJECT ZERO
-    { 0x7E10, 0,  6,  0, 2, &zones_set17, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MPG B650 EDGE WIFI
-    { 0x7E12, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG X670E TOMAHAWK WIFI
-    { 0x0076, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // MAG X670E TOMAHAWK WIFI (Common PID)
-    { 0x7E16, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // X670E GAMING PLUS WIFI
-    { 0x7E24, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B650M GAMING PLUS WIFI
-    { 0x7E26, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // B650 GAMING PLUS WIFI
-    { 0x7E27, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED },       // PRO B650M-P
-    { 0x7E28, 6,  0,  0, 2, &zones_set21, MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED },    // MSI PRO A620M-B (MS-7E28)
+    { 0x7B93, 6,  1,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MPG X570 GAMING PRO CARBON WIFI
+    { 0x7C34, 0,  1,  1, 1, &zones_set8,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MEG X570 GODLIKE
+    { 0x7C35, 0,  1,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MEG X570 ACE
+    { 0x7C36, 6,  1,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // PRESTIGE X570 CREATION
+    { 0x7C37, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MPG X570 GAMING PLUS
+    { 0x7C56, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     6 },    // MPG B550 GAMING PLUS
+    { 0x7C59, 0,  8,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED,    0 },    // CREATOR TRX40
+    { 0x7C60, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // TRX40-A PRO
+    { 0x7C67, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B365M MORTAR
+    { 0x7C71, 6,  6,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z490 ACE
+    { 0x7C73, 6,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z490 GAMING CARBON WIFI
+    { 0x7C75, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z490 GAMING PLUS
+    { 0x7C76, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED,    0 },    // MPG Z490M GAMING EDGE
+    { 0x7C77, 0,  0,  0, 0, &zones_set14, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z490I UNIFY
+    { 0x7C79, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z490 GAMING EDGE WIFI
+    { 0x7C80, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG Z490 TOMAHAWK
+    { 0x7C02, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B450 TOMAHAWK MAX
+    { 0x7C81, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B460 TOMAHAWK
+    { 0x7C82, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B460M MORTAR WIFI
+    { 0x7C83, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED,    0 },    // B460M PRO-VDH WIFI
+    { 0x7C84, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MAG X570 TOMAHAWK WIFI
+    { 0x7C86, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_DISABLED,    0 },    // MPG B460I GAMING EDGE
+    { 0x7C87, 6,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B450M BAZOOKA MAX WIFI
+    { 0x7C90, 6,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B550 GAMING CARBON WIFI
+    { 0x7C91, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B550 TOMAHAWK
+    { 0x7C92, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B550I GAMING EDGE WIFI
+    { 0x7C94, 6,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B550M MORTAR
+    { 0x7C95, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B550M PRO-VDH WIFI
+    { 0x7C98, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // Z490 PLUS
+    { 0x7D03, 0, 15, 18, 1, &zones_set8,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z590 GODLIKE
+    { 0x7D06, 4,  4,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z590 GAMING FORCE
+    { 0x7D07, 4,  5,  0, 2, &zones_set7,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z590 GAMING EDGE WIFI
+    { 0x7D08, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG Z590 TOMAHAWK
+    { 0x7D09, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // Z590-A PRO WIFI
+    { 0x7D13, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG B550 UNIFY
+    { 0x7D14, 6,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // A520M PRO
+    { 0x7D15, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B560 TOMAHAWK WIFI
+    { 0x7D17, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B560M MORTAR
+    { 0x7D18, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B560M PRO-VDH
+    { 0x7D19, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B560I GAMIING EDGE WIFI
+    { 0x7D20, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B560M PRO
+    { 0x7D25, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z690-A WIFI DDR4
+    { 0x7D27, 6,  0,  0, 2, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z690 ACE
+    { 0x7D28, 6,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z690 UNIFY-X
+    { 0x7D29, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z690I UNIFY
+    { 0x7D30, 6,  6,  0, 2, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z690 CARBON WIFI
+    { 0x7D31, 4,  8,  0, 2, &zones_set12, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG EDGE WIFI DDR4
+    { 0x7D32, 1,  0,  0, 1, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG Z690 TOMAHAWK WIFI DDR4
+    { 0x7D33, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z790-VC WIFI
+    { 0x7D36, 6,  0,  0, 2, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z690-P DDR4
+    { 0x7D37, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B760M-VC WIFI (MS-7D37) - fans on JRAINBOW2
+    { 0x7D38, 0,  0,  0, 1, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z590 UNIFY-X
+    { 0x7D40, 0,  0,  0, 1, &zones_set5,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B760i EDGE WIFI DDR4
+    { 0x7D41, 6,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B660M TOMAHAWK WIFI DDR4
+    { 0x7D42, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B660 MORTAR WIFI DDR4
+    { 0x7D43, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B660M-A WIFI DDR4
+    { 0x7D46, 0,  1,  1, 0, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO H610M-G DDR4
+    { 0x7D50, 6, 12,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG X570S ACE MAX
+    { 0x7D51, 6,  0,  0, 2, &zones_set1,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG X570S UNIFY-X MAX
+    { 0x7D52, 6, 14,  0, 1, &zones_set3,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG X570S CARBON EK X
+    { 0x7D53, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG X570S EDGE MAX WIFI
+    { 0x7D54, 6,  0,  0, 2, &zones_set0,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG X570S TOMAHAWK MAX WIFI
+    { 0x7D59, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B660-A DDR4
+    { 0x7D67, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO X670-P WIFI
+    { 0x7D69, 9,  2,  4, 1, &zones_set15, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG X670E ACE
+    { 0x7D70, 0,  6,  0, 1, &zones_set9,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG X670E Carbon WIFI
+    { 0x7D73, 1,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B650I EDGE WIFI
+    { 0x7D74, 0,  6,  0, 1, &zones_set18, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B650 CARBON WIFI
+    { 0x7D75, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B650 TOMAHAWK WIFI
+    { 0x7D76, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B650M MORTAR WIFI
+    { 0x7D77, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B650M-A WIFI
+    { 0x7D78, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B650-P WIFI
+    { 0x7D86, 0, 18,  4, 1, &zones_set16, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MEG Z790 ACE
+    { 0x7D88, 0,  0,  0, 1, &zones_set20, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z790-S WIFI
+    { 0x7D89, 0,  6,  0, 1, &zones_set18, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z790 CARBON WIFI
+    { 0x7D90, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B760M BOMBER DDR4
+    { 0x7D91, 1,  0,  0, 1, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG Z790 TOMAHAWK WIFI
+    { 0x7D93, 6,  0,  0, 1, &zones_set2,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // Z790 GAMING PRO WIFI
+    { 0x7D96, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B760 TOMAHAWK WIFI DDR5
+    { 0x7D97, 6,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B660 MORTAR MAX WIFI DDR4
+    { 0x7D98, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B760-P WIFI DDR4
+    { 0x7D99, 6,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B760M-A WIFI DDR4
+    { 0x7E01, 0,  0,  0, 1, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG B760M MORTAR MAX
+    { 0x7E03, 6,  0,  0, 0, &zones_set6,  MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG Z790I EDGE WIFI
+    { 0x7E06, 0,  0,  0, 2, &zones_set11, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z790-P WIFI DDR4
+    { 0x7E07, 0,  0,  0, 2, &zones_set10, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO Z790-A WIFI DDR4
+    { 0x7E09, 0,  0,  0, 0, &zones_set19, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B650M PROJECT ZERO
+    { 0x7E10, 0,  6,  0, 2, &zones_set17, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MPG B650 EDGE WIFI
+    { 0x7E12, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG X670E TOMAHAWK WIFI
+    { 0x0076, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // MAG X670E TOMAHAWK WIFI (Common PID)
+    { 0x7E16, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // X670E GAMING PLUS WIFI
+    { 0x7E24, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B650M GAMING PLUS WIFI
+    { 0x7E26, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // B650 GAMING PLUS WIFI
+    { 0x7E27, 0,  0,  0, 2, &zones_set13, MSIMotherboard185Controller::DIRECT_MODE_PER_LED,     0 },    // PRO B650M-P
+    { 0x7E28, 6,  0,  0, 2, &zones_set21, MSIMotherboard185Controller::DIRECT_MODE_ZONE_BASED,  0 },    // MSI PRO A620M-B (MS-7E28)
 };
 
-
 FeaturePacket_185 enable_per_led_msg;
 
 Color* per_led_onboard_leds;
@@ -367,17 +367,15 @@ Color* per_led_jcorsair_sync;
 
 MSIMotherboard185Controller::MSIMotherboard185Controller(hid_device* handle, const char* path, unsigned short pid, std::string dev_name)
 {
-    dev         = handle;
-    location    = path;
-    name        = dev_name;
+    dev             = handle;
+    location        = path;
+    name            = dev_name;
+    version_invalid = false;
 
     /*-----------------------------------------------------*\
-    | Perform initial reads - get the controller's firmware |
-    | version and then read the controller's active         |
-    | configuration data                                    |
+    | Read the controller's firmware version                |
     \*-----------------------------------------------------*/
     ReadFwVersion();
-    ReadSettings();
 
     /*-----------------------------------------------------*\
     | Common PID boards embed their virtual PID in the      |
@@ -425,6 +423,16 @@ 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                                   |
@@ -448,6 +456,11 @@ MSIMotherboard185Controller::MSIMotherboard185Controller(hid_device* handle, con
         per_led_mode       = DIRECT_MODE_DISABLED;
     }
 
+    /*-----------------------------------------------------*\
+    | Read the controller's active configuration data       |
+    \*-----------------------------------------------------*/
+    ReadSettings();
+
     /*-----------------------------------------------------*\
     | Initialize per-LED data                               |
     \*-----------------------------------------------------*/
@@ -592,6 +605,11 @@ MSIMotherboard185Controller::~MSIMotherboard185Controller()
     hid_close(dev);
 }
 
+bool MSIMotherboard185Controller::GetFirmwareVersionInvalid()
+{
+    return(version_invalid);
+}
+
 void MSIMotherboard185Controller::SetMode
     (
     MSI_ZONE        zone,
@@ -1163,6 +1181,8 @@ bool MSIMotherboard185Controller::ReadFwVersion()
     ret_val &= hid_write(dev, request, 64);
     ret_val &= hid_read(dev, response, 64);
 
+    version_APROM_val = response[2];
+
     /*-----------------------------------------------------*\
     | Extract high and low values from response             |
     \*-----------------------------------------------------*/

Controllers/MSIMotherboardController/MSIMotherboard185Controller/MSIMotherboard185Controller.h

@@ -46,6 +46,7 @@ public:
                         );
 
     MSI_MODE        GetMode();
+    bool            GetFirmwareVersionInvalid();
 
     void            GetMode
                         (
@@ -119,6 +120,8 @@ private:
     std::string                     name;
     std::string                     location;
     std::string                     version_APROM;
+    unsigned char                   version_APROM_val;
+    bool                            version_invalid;
     std::string                     version_LDROM;
 
     FeaturePacket_185               data;

Controllers/MSIMotherboardController/MSIMotherboard761Controller/MSIMotherboard761Controller.cpp

@@ -77,6 +77,8 @@ 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)"
 };
 
 static const mystic_light_761_config board_configs[] =
@@ -111,6 +113,8 @@ 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)
 };
 
 enum MSI_ZONE setup_map [] =

Controllers/MSIMotherboardController/MSIMotherboardControllerDetect.cpp

@@ -54,9 +54,17 @@ DetectedControllers DetectMSIMotherboardControllers(hid_device_info* info, const
         if((packet_length >= sizeof(FeaturePacket_185)) && (packet_length <= (sizeof(FeaturePacket_185) + 1)))  //WHY r we doing this ? why not ==
         {
             MSIMotherboard185Controller*     controller     = new MSIMotherboard185Controller(dev, info->path, info->product_id, dmi_name);
-            RGBController_MSIMotherboard185* rgb_controller = new RGBController_MSIMotherboard185(controller);
 
-            detected_controllers.push_back(rgb_controller);
+            if(controller->GetFirmwareVersionInvalid())
+            {
+                LOG_WARNING("[MSIMotherboard185] Controller firmware below minimum supported version, skipping");
+            }
+            else
+            {
+                RGBController_MSIMotherboard185* rgb_controller = new RGBController_MSIMotherboard185(controller);
+
+                detected_controllers.push_back(rgb_controller);
+            }
         }
         else if((packet_length >= sizeof(FeaturePacket_162)) && (packet_length <= (sizeof(FeaturePacket_162) + 1)))
         {
@@ -227,6 +235,7 @@ 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);
 // 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);
@@ -237,6 +246,7 @@ 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/PNYGPUController/PNYGPUController.cpp

@@ -1,112 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,62 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,76 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,161 +0,0 @@
-/*---------------------------------------------------------*\
-| 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/PalitGPUController/PalitGPUController.cpp

@@ -1,46 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,44 +0,0 @@
-/*---------------------------------------------------------*\
-| 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,6 +4,9 @@
 |   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               |
@@ -13,46 +16,145 @@
 #include <stdlib.h>
 #include "DetectionManager.h"
 #include "i2c_smbus.h"
-#include "PalitGPUController.h"
+#include "PalitGPUv1Controller.h"
+#include "PalitGPUv2Controller.h"
 #include "pci_ids.h"
-#include "RGBController_PalitGPU.h"
+#include "RGBController_PalitGPUv1.h"
+#include "RGBController_PalitGPUv2.h"
 
-DetectedControllers DetectPalitGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+bool TestForPalitGPUv1Controller(i2c_smbus_interface* bus, uint8_t i2c_addr)
+{
+    bool pass = false;
+
+    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;
+
+    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(bus->info.port_id == 1)
+    if(TestForPalitGPUv1Controller(bus, i2c_addr))
     {
-        /*-----------------------------------------------------*\
-        | Check for PALIT string                                |
-        \*-----------------------------------------------------*/
-        const uint8_t   palit[] = {'P', 'A', 'L', 'I', 'T'};
-        bool            match = true;
+        PalitGPUv1Controller*     controller     = new PalitGPUv1Controller(bus, i2c_addr, name);
+        RGBController_PalitGPUv1* rgb_controller = new RGBController_PalitGPUv1(controller);
 
-        for(size_t i = 0; i < sizeof(palit); i++)
-        {
-            int32_t letter = bus->i2c_smbus_read_byte_data(i2c_addr, 0x07 + (u8)i);
-
-            if(palit[i] != letter)
-            {
-                match = false;
-            }
-        }
-
-        if(match)
-        {
-            PalitGPUController*     controller      = new PalitGPUController(bus, i2c_addr, name);
-            RGBController_PalitGPU* rgb_controller  = new RGBController_PalitGPU(controller);
-
-            DetectionManager::get()->RegisterRGBController(rgb_controller);
-        }
+        detected_controllers.push_back(rgb_controller);
     }
 
     return(detected_controllers);
 }
 
-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);
+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);

Controllers/PalitGPUController/PalitGPUv1Controller.cpp

@@ -0,0 +1,77 @@
+/*---------------------------------------------------------*\
+| 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/PalitGPUv1Controller.h

@@ -1,9 +1,10 @@
 /*---------------------------------------------------------*\
-| GainwardGPUv1Controller.h                                 |
+| PalitGPUv1Controller.h                                    |
 |                                                           |
-|   Driver for Gainward v1 GPU                              |
+|   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               |
@@ -14,22 +15,19 @@
 #include <string>
 #include "i2c_smbus.h"
 
-typedef unsigned char gainward_gpu_dev_id;
+typedef unsigned char palit_gpu_dev_id;
 
 enum
 {
     /* RGB Registers */
-    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 */
+    PALIT_V1_RED_REGISTER                       = 0x03, /* Red Register */
 };
 
-class GainwardGPUv1Controller
+class PalitGPUv1Controller
 {
 public:
-    GainwardGPUv1Controller(i2c_smbus_interface* bus, gainward_gpu_dev_id, std::string dev_name);
-    ~GainwardGPUv1Controller();
+    PalitGPUv1Controller(i2c_smbus_interface* bus, palit_gpu_dev_id, std::string dev_name);
+    ~PalitGPUv1Controller();
 
     std::string   GetDeviceLocation();
     std::string   GetDeviceName();
@@ -38,13 +36,9 @@ 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;
-    gainward_gpu_dev_id     dev;
+    palit_gpu_dev_id        dev;
     std::string             name;
 };

Controllers/PalitGPUController/PalitGPUv2Controller.cpp

@@ -0,0 +1,154 @@
+/*---------------------------------------------------------*\
+| 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

@@ -0,0 +1,115 @@
+/*---------------------------------------------------------*\
+| 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

@@ -1,112 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,33 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -0,0 +1,110 @@
+/*---------------------------------------------------------*\
+| 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_PalitGPUv1.h

@@ -1,35 +1,36 @@
-/*---------------------------------------------------------*\
-| 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();
-};
+/*---------------------------------------------------------*\
+| 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();
+};

Controllers/PalitGPUController/RGBController_PalitGPUv2.cpp

@@ -0,0 +1,217 @@
+/*---------------------------------------------------------*\
+| 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/PalitGPUController/RGBController_PalitGPUv2.h

@@ -1,8 +1,9 @@
 /*---------------------------------------------------------*\
-| RGBController_PNYGPU.h                                    |
+| RGBController_PalitGPUv2.h                                |
 |                                                           |
-|   RGBController for PNY Turing GPU                        |
+|   RGBController for Palit v2 GPU                          |
 |                                                           |
+|   KundaPanda                                  04 Jan 2021 |
 |   KendallMorgan                               17 Oct 2021 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
@@ -12,13 +13,13 @@
 #pragma once
 
 #include "RGBController.h"
-#include "PNYGPUController.h"
+#include "PalitGPUv2Controller.h"
 
-class RGBController_PNYGPU : public RGBController
+class RGBController_PalitGPUv2 : public RGBController
 {
 public:
-    RGBController_PNYGPU(PNYGPUController* controller_ptr);
-    ~RGBController_PNYGPU();
+    RGBController_PalitGPUv2(PalitGPUv2Controller* controller_ptr);
+    ~RGBController_PalitGPUv2();
 
     void        SetupZones();
 
@@ -29,5 +30,5 @@ public:
     void        DeviceUpdateMode();
 
 private:
-    PNYGPUController* controller;
-};
+    PalitGPUv2Controller* controller;
+};

Controllers/SapphireGPUController/SapphireGPUControllerDetect.cpp

@@ -97,4 +97,5 @@ 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,6 +86,7 @@ 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;
@@ -403,6 +404,11 @@ 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)
@@ -1718,7 +1724,7 @@ void NetworkClient::ConnectionThreadFunction()
             /*---------------------------------------------*\
             | Try to connect to server                      |
             \*---------------------------------------------*/
-            if(port.tcp_client_connect() == true)
+            if(port.tcp_client_connect(connect_timeout) == true)
             {
                 client_sock = port.sock;
                 LOG_INFO("[%s] Connected to server", NETWORKCLIENT);

NetworkClient.h

@@ -97,6 +97,7 @@ 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);
@@ -198,6 +199,7 @@ 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,19 @@ void NetworkServer::SendReply_ServerString(NetworkClientInfo* client_info)
 
 void NetworkServer::SendReply_PluginList(NetworkClientInfo* client_info)
 {
+    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);
+
     if(plugin_manager)
     {
-        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++)
         {
             data_size += sizeof(unsigned short) * 3;
@@ -3814,24 +3814,27 @@ 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++)
         {
             /*---------------------------------------------*\
@@ -3880,21 +3883,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       = 0
-MINOR       = 9
+MAJOR       = 1
+MINOR       = 0
 SUFFIX      = git
 
 SHORTHASH   = $$system("git rev-parse --short=7 HEAD")
@@ -489,12 +489,23 @@ 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                                                                             \
@@ -559,13 +570,22 @@ 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                              #

RGBController/RGBController.cpp

@@ -3094,9 +3094,31 @@ unsigned char * RGBController::GetZoneDescriptionData(unsigned char* data_ptr, z
 
     /*-----------------------------------------------------*\
     | Copy in zone type                                     |
+    | For protocols below 6, convert the new zone types     |
     \*-----------------------------------------------------*/
-    memcpy(data_ptr, &zone.type, sizeof(zone.type));
-    data_ptr += sizeof(zone.type);
+    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);
 
     /*-----------------------------------------------------*\
     | Check for resizable effects-only zone.  For protocol  |

ResourceManager.cpp

@@ -280,6 +280,8 @@ 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"]["ignore"]           = true;
+
     settings_manager->RegisterSettingsSchema("LogManager", QT_TRANSLATE_NOOP("Settings", "Log Manager"), logmanager_settings_schema);
 
     /*-----------------------------------------------------*\
@@ -1158,6 +1160,7 @@ 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,7 +66,8 @@ const char *spd_memory_type_name[] =
     "LPDDR4",
     "LPDDR4X",
     "DDR5",
-    "LPDDR5"
+    "LPDDR5",
+    "Unknown"
 };
 
 SPDAccessor::SPDAccessor(i2c_smbus_interface *bus, uint8_t spd_addr)
@@ -161,7 +162,16 @@ DDR4Accessor::~DDR4Accessor()
 
 SPDMemoryType DDR4Accessor::memory_type()
 {
-    return((SPDMemoryType)(this->at(BASIC_MEMORY_TYPE_ADDR)));
+    SPDMemoryType type = (SPDMemoryType)(this->at(BASIC_MEMORY_TYPE_ADDR));
+
+    if(type <= SPD_UNKNOWN)
+    {
+        return(type);
+    }
+    else
+    {
+        return(SPD_UNKNOWN);
+    }
 }
 
 uint16_t DDR4Accessor::jedec_id()
@@ -195,7 +205,16 @@ DDR5Accessor::~DDR5Accessor()
 
 SPDMemoryType DDR5Accessor::memory_type()
 {
-    return((SPDMemoryType)(this->at(BASIC_MEMORY_TYPE_ADDR)));
+    SPDMemoryType type = (SPDMemoryType)(this->at(BASIC_MEMORY_TYPE_ADDR));
+
+    if(type <= SPD_UNKNOWN)
+    {
+        return(type);
+    }
+    else
+    {
+        return(SPD_UNKNOWN);
+    }
 }
 
 uint16_t DDR5Accessor::jedec_id()

SPDAccessor/SPDCommon.h

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

SPDAccessor/SPDDetector.cpp

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

SPDAccessor/SPDWrapper.cpp

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

SettingsManager.cpp

@@ -555,18 +555,25 @@ json SettingsManager::FilterSettingsAgainstSchema(std::string& settings_key, jso
             continue;
         }
 
-        /*-------------------------------------------------*\
-        | Check if the value type matches the schema's      |
-        | declared type                                     |
-        \*-------------------------------------------------*/
-        if(schema_properties[key].contains("type"))
+        if(!schema_properties[key].contains("ignore"))
         {
-            std::string schema_type = schema_properties[key]["type"];
-
-            if(!SettingsValueMatchesType(value, schema_type))
+            /*-------------------------------------------------*\
+            | Check if the value type matches the schema's      |
+            | declared type                                     |
+            \*-------------------------------------------------*/
+            if(schema_properties[key].contains("type"))
             {
-                LOG_WARNING("[%s] Settings key \"%s\" has incorrect type (expected %s), skipping", SETTINGSMANAGER, key.c_str(), schema_type.c_str());
-                continue;
+                std::string schema_type = schema_properties[key]["type"];
+
+                if(!SettingsValueMatchesType(value, schema_type))
+                {
+                    LOG_WARNING("[%s] Settings key \"%s\" has incorrect type (expected %s), skipping", SETTINGSMANAGER, key.c_str(), schema_type.c_str());
+                    continue;
+                }
+            }
+            else
+            {
+                LOG_WARNING("[%s] Settings key \"%s\" is missing type field, skipping", SETTINGSMANAGER, key.c_str());
             }
         }
 

debian/control

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

fedora/OpenRGB.spec.in

@@ -10,6 +10,10 @@ 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.
@@ -53,6 +57,9 @@ 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)
+            if((strncmp(ent->d_name, "i2c-", 4) == 0) && (ent->d_name[4] != '\0') && (strspn(ent->d_name + 4, "0123456789") == strlen(ent->d_name + 4)))
             {
                 strncpy(device_string, driver_path, sizeof(device_string) - 1);
                 device_string[sizeof(device_string) - 1] = '\0';
@@ -148,6 +148,18 @@ 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';
@@ -165,11 +177,11 @@ bool i2c_smbus_linux_detect()
 
                         /*-------------------------------------------------------------*\
                         | Truncate at last '/' to get the parent PCI device directory.  |
-                        | For AMDGPU i2c buses the realpath resolves to something like:  |
+                        | 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.                   |
+                        | truncating the path is correct and portable.                  |
                         \*-------------------------------------------------------------*/
                         char* last_slash = strrchr(path, '/');
                         if(last_slash == NULL || last_slash == path)
@@ -246,7 +258,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));
 
@@ -269,9 +281,11 @@ 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();
@@ -287,6 +301,7 @@ bool i2c_smbus_linux_detect()
                 }
                 else
                 {
+                    LOG_INFO("[i2c_smbus_linux] Failed to open %s", device_string);
                     ret = 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()
+bool net_port::tcp_client_connect(unsigned int timeout_ms)
 {
     struct addrinfo *res;
     connected = false;
@@ -201,8 +201,11 @@ bool net_port::tcp_client_connect()
         FD_ZERO(&fdset);
         FD_SET(sock, &fdset);
 
-        tv.tv_sec =  4;
-        tv.tv_usec = 0;
+        /*-------------------------------------------------*\
+        | Convert millisecond timeout to timeval sec/usec   |
+        \*-------------------------------------------------*/
+        tv.tv_sec   = (timeout_ms / 1000);
+        tv.tv_usec  = (timeout_ms % 1000) * 1000;
 
         /*-------------------------------------------------*\
         | 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();
+    bool tcp_client_connect(unsigned int timeout_ms = 4000);
 
     //Function to open a server
     bool        tcp_server(const char * port);

pci_ids/pci_ids.h

@@ -576,6 +576,8 @@
 #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                           |
@@ -749,8 +751,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_DEV1         0x4171
-#define GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV2         0x4172
+#define GIGABYTE_RTX5090_XTREME_WATERFORCE_32G_SUB_DEV          0x4171
+#define GIGABYTE_RTX5090_XTREME_WATERFORCE_WB_32G_SUB_DEV       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
@@ -1000,6 +1002,7 @@
 #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,7 +1146,9 @@ void DeviceView::InitDeviceView()
         /*-------------------------------------------------*\
         | For matrix zones, use matrix height from the map  |
         \*-------------------------------------------------*/
-        if(controller->GetZoneType(zone_idx) == ZONE_TYPE_MATRIX)
+        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))
         {
             total_height                   += controller->GetZoneMatrixMapHeight(zone_idx);
             zone_pos[zone_idx].matrix_w     = controller->GetZoneMatrixMapWidth(zone_idx);
@@ -1159,7 +1161,9 @@ 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)
+                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))
                 {
                     total_height               += controller->GetZoneSegmentMatrixMapHeight(zone_idx, segment_idx);
                     zone_pos[zone_idx].matrix_w = controller->GetZoneSegmentMatrixMapWidth(zone_idx, segment_idx);
@@ -1218,7 +1222,9 @@ void DeviceView::InitDeviceView()
         /*-------------------------------------------------*\
         | Calculate LEDs position and size for zone         |
         \*-------------------------------------------------*/
-        if(controller->GetZoneType(zone_idx) == ZONE_TYPE_MATRIX)
+        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))
         {
             for(unsigned int led_x = 0; led_x < controller->GetZoneMatrixMapWidth(zone_idx); led_x++)
             {
@@ -1323,7 +1329,9 @@ void DeviceView::InitDeviceView()
 
                 segment_count++;
 
-                if(controller->GetZoneSegmentType(zone_idx, segment_idx) == ZONE_TYPE_MATRIX)
+                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))
                 {
                     for(unsigned int led_x = 0; led_x < controller->GetZoneSegmentMatrixMapWidth(zone_idx, segment_idx); led_x++)
                     {

qt/OpenRGBClientInfoPage/OpenRGBClientInfoPage.cpp

@@ -267,15 +267,35 @@ 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

@@ -125,6 +125,11 @@ OpenRGBDeviceEditorDialog::OpenRGBDeviceEditorDialog(RGBController *dev, QWidget
         \*-----------------------------------------------------*/
         for(std::size_t configuration_idx = 0; configuration_idx < configuration_entries.size(); configuration_idx++)
         {
+            if(configuration_entries[configuration_idx].value[configuration_entries[configuration_idxsetting_idx].key].contains("ignore"))
+            {
+                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,6 +7,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
+#include <QTimer>
+
 #include "OpenRGBDevicePage.h"
 #include "OpenRGBDeviceEditorDialog.h"
 #include "OpenRGBZoneEditorDialog.h"
@@ -1804,7 +1806,19 @@ void OpenRGBDevicePage::ColorChanged()
 
     if(AutoUpdateEnabled())
     {
-        UpdateColor();
+        /*-----------------------------------------------------*\
+        | 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;
+            });
+        }
     }
 }
 

qt/OpenRGBDevicePage/OpenRGBDevicePage.h

@@ -64,6 +64,11 @@ 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

@@ -880,7 +880,7 @@ void OpenRGBDialog::RemovePlugin(OpenRGBPluginEntry* plugin)
             plugin_parent_widget = ui->InformationTabBar;
             break;
         case OPENRGB_PLUGIN_LOCATION_SETTINGS:
-            plugin_parent_widget = ui->InformationTabBar;
+            plugin_parent_widget = ui->SettingsTabBar;
             break;
         default:
             break;

qt/OpenRGBSettingsPage/OpenRGBSettingsPage.cpp

@@ -139,6 +139,11 @@ void OpenRGBSettingsPage::UpdateInterface()
     \*-----------------------------------------------------*/
     for(std::size_t setting_idx = 0; setting_idx < setting_entries.size(); setting_idx++)
     {
+        if(setting_entries[setting_idx].value[setting_entries[setting_idx].key].contains("ignore"))
+        {
+            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>Helligkeits Kanal:</translation>
+        <translation>Helligkeitskanal:</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;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>
+        <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>
     </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;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>
+        <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>
     </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 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>
+        <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>
     </message>
 </context>
 <context>
@@ -221,17 +221,17 @@
     <message>
         <location filename="../ManualDevicesSettingsPage/E131SettingsEntry/E131SettingsEntry.ui" line="72"/>
         <source>Universe Size:</source>
-        <translation>Univerumsgröße:</translation>
+        <translation>Universe Größ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>Anfangsuniversum:</translation>
+        <translation>Starte Universe:</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 (verteiltes Anzeigeprotokoll)</translation>
+        <translation>DDP (Distributed Display Protocol)</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 Neuerfassen</translation>
+        <translation>Speichern ohne erneute scannung</translation>
     </message>
 </context>
 <context>
@@ -811,7 +811,7 @@
     <message>
         <location filename="../OpenRGBDevicePage/OpenRGBDevicePage.cpp" line="1667"/>
         <source>Saving Not Supported</source>
-        <translation>Speichern wird nicht unterstützt</translation>
+        <translation>Speichern 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 eigenem Namen speichern</translation>
+        <translation>Profil mit benutzerdefinierten 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 Farben</translation>
+        <translation>Schnelle Farbenauswahl</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>Allg. Einstellungen</translation>
+        <translation>Allgemeine 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,9 +1099,7 @@
     <message>
         <location filename="../OpenRGBMatrixMapEditorDialog/OpenRGBMatrixMapEditorDialog.ui" line="72"/>
         <source>Width:</source>
-        <translation>
-
-Breite:</translation>
+        <translation>Breite:</translation>
     </message>
 </context>
 <context>
@@ -1193,7 +1191,7 @@ Breite:</translation>
     <message>
         <location filename="../OpenRGBPluginsPage/OpenRGBPluginsPage.cpp" line="224"/>
         <source>Restart Needed</source>
-        <translation>Programmneustart Erforderlich</translation>
+        <translation>Neustart Erforderlich</translation>
     </message>
     <message>
         <location filename="../OpenRGBPluginsPage/OpenRGBPluginsPage.cpp" line="224"/>
@@ -1231,7 +1229,7 @@ Breite:</translation>
     <message>
         <location filename="../OpenRGBProfileEditorDialog/OpenRGBProfileEditorDialog.ui" line="72"/>
         <source>Device States</source>
-        <translation>Gerätezustände</translation>
+        <translation>Gerätzustände</translation>
     </message>
     <message>
         <location filename="../OpenRGBProfileEditorDialog/OpenRGBProfileEditorDialog.ui" line="78"/>
@@ -1363,7 +1361,7 @@ Breite:</translation>
     <message>
         <location filename="../OpenRGBServerInfoPage/OpenRGBServerInfoPage.cpp" line="65"/>
         <source>Stopping...</source>
-        <translation>Beenden...</translation>
+        <translation>Beendet...</translation>
     </message>
     <message>
         <location filename="../OpenRGBServerInfoPage/OpenRGBServerInfoPage.cpp" line="73"/>
@@ -1694,7 +1692,7 @@ Breite:</translation>
     <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 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>
+        <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>
     </message>
     <message>
         <location filename="../OpenRGBZoneInitializationDialog/OpenRGBZoneInitializationDialog.ui" line="49"/>
@@ -1795,7 +1793,7 @@ Breite:</translation>
     <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"/>
@@ -1897,7 +1895,7 @@ Breite:</translation>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="238"/>
         <source>Load Window Geometry</source>
-        <translation>Fenster Geometrie laden</translation>
+        <translation>Fenstergeometrie laden</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="230"/>
@@ -1907,12 +1905,12 @@ Breite:</translation>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="226"/>
         <source>Disable Key Expansion</source>
-        <translation>Deaktiviere Schlüsselerweiterung in der Geräteansicht</translation>
+        <translation>Deaktiviere Key-Erweiterung 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"/>
@@ -1952,7 +1950,7 @@ Breite:</translation>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="195"/>
         <source>Monochrome Tray Icon</source>
-        <translation>Graues Icon</translation>
+        <translation>Monochromes Tray Icon</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="178"/>
@@ -1972,7 +1970,7 @@ Breite:</translation>
     <message>
         <location filename="../../ResourceManager.cpp" line="201"/>
         <source>Initial Detection Delay (ms)</source>
-        <translation>Anfangserkennungsverzögerung (ms)</translation>
+        <translation>Initiale Erkennungsverzögerung (ms)</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="203"/>
@@ -1987,27 +1985,27 @@ Breite:</translation>
     <message>
         <location filename="../../ResourceManager.cpp" line="215"/>
         <source>Enable Log File</source>
-        <translation>Log Datei aktivieren</translation>
+        <translation>Logdatei aktivieren</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="219"/>
         <source>Log Level</source>
-        <translation>Protokollierungsstufe</translation>
+        <translation>Log Level</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="237"/>
         <source>Log File Count Limit</source>
-        <translation>Logdateien Anzahl Limit</translation>
+        <translation>Logdatei-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 Protokolldateien, 0 für keine Begrenzung</translation>
+        <translation>Maximale Anzahl der zu behaltenden Logdateien, 0 für keine Begrenzung</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="243"/>
         <source>Log Manager</source>
-        <translation>Protokoll-Manager</translation>
+        <translation>Log-Manager</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="250"/>
@@ -2037,7 +2035,7 @@ Breite:</translation>
     <message>
         <location filename="../../ResourceManager.cpp" line="266"/>
         <source>Workaround for some older SDK implementations that sent incorrect packet size for certain packets</source>
-        <translation>Umgehungsmethode für einige ältere SDK-Implementierungen, die falsche Paketgrößen für bestimmte Pakete gesendet haben</translation>
+        <translation>Workaround 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"/>
@@ -2062,22 +2060,22 @@ Breite:</translation>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="207"/>
         <source>Compact Tabs</source>
-        <translation>Kompakte Registerkarten</translation>
+        <translation>Kompakte Tabs</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="209"/>
         <source>Display sidebar tabs as icons only</source>
-        <translation>Seitenleisten-Registerkarten nur als Icons anzeigen</translation>
+        <translation>Seitenleisten-Tabs nur als Icons anzeigen</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="212"/>
         <source>Tabs on Top</source>
-        <translation>Registerkarten oben</translation>
+        <translation>Tabs oben</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="214"/>
         <source>Display tabs on top instead of on the left</source>
-        <translation>Registerkarten oben anstelle von links anzeigen</translation>
+        <translation>Tabs oben anstelle von Links anzeigen</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="221"/>
@@ -2097,7 +2095,7 @@ Breite:</translation>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="242"/>
         <source>Save on Exit</source>
-        <translation>Geometrie beim Schließen beibehalten</translation>
+        <translation>Beim Schließen speichern</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="244"/>
@@ -2147,17 +2145,17 @@ Breite:</translation>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="284"/>
         <source>AMD SMBus: Reduce CPU Usage (restart required)</source>
-        <translation>AMD SMBus: CPU-Auslastung reduzieren (Programmneustart erfoderlich)</translation>
+        <translation>AMD SMBus: CPU-Auslastung reduzieren (Neustart erfoderlich)</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="173"/>
         <source>Custom Arguments</source>
-        <translation>Eigene Argumente</translation>
+        <translation>Benutzerdefinierte Argumente</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="272"/>
         <source>Shared SMBus Access (restart required)</source>
-        <translation>Gemeinsamer SMBus-Zugriff (Programmneustart erforderlich)</translation>
+        <translation>Gemeinsamer SMBus-Zugriff (Neustart 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>Holdvakttid (ms):</translation>
+        <translation>Levetid (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>Keepalive Time:</translation>
+        <translation>Levetid:</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>Zoner</translation>
+        <translation>Soner</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ørrelsesendrbar</translation>
+        <translation>Størrelsesredigerbar</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;É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>
+        <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>
     </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;É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>
+        <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>
     </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 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>
+        <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>
     </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>Keepalive Time:</translation>
+        <translation>Levetid:</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>Univers størrelse:</translation>
+        <translation>Universe 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 univers:</translation>
+        <translation>Start Universe:</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>Multizon</translation>
+        <translation>Multisone</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 multizon</translation>
+        <translation>Utvidet multisone</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 (fordelt visningsprotokoll)</translation>
+        <translation>DDP (Distributed Display Protocol)</translation>
     </message>
     <message>
         <location filename="../ManualDevicesSettingsPage/DebugSettingsEntry/DebugSettingsEntry.cpp" line="143"/>
         <source>Debug Device</source>
-        <translation>Feilsøk enhet</translation>
+        <translation>Feilsøkingsenhet</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 igjen</translation>
+        <translation>Lagre og skann på nytt</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 å 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>
+        <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>
     </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 Key:</translation>
+        <translation>Auth Nøkkel:</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>Zoneredigerer</translation>
+        <translation>Soneredigerer</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 område</translation>
+        <translation>Nullstill konfigurasjon for soner</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="124"/>
         <source>Device-Specific Zone Configuration</source>
-        <translation>Enhetspesifikk zonkonfigurasjon</translation>
+        <translation>Enhetspesifikk sonekonfigurasjon</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="151"/>
         <source>Zone Configuration</source>
-        <translation>Zonkonfigurasjon</translation>
+        <translation>Sonekonfigurasjon</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="159"/>
         <source>Zone Type:</source>
-        <translation>Zonetype:</translation>
+        <translation>Sonetype:</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="176"/>
         <source>Zone Matrix Map:</source>
-        <translation>Zonematrisekart:</translation>
+        <translation>Sonematrisekart:</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="185"/>
         <source>Zone Name:</source>
-        <translation>Zonenummer:</translation>
+        <translation>Sonenummer:</translation>
     </message>
     <message>
         <location filename="../OpenRGBZoneEditorDialog/OpenRGBZoneEditorDialog.ui" line="192"/>
         <source>Zone Size:</source>
-        <translation>Størrelse på zone:</translation>
+        <translation>Størrelse på sone:</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>Zonestart</translation>
+        <translation>Sonestart</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>Klient nøkkel:</translation>
+        <translation>Klientnø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 nøkkelutvidelse i enhetsvisning</translation>
+        <translation>Deaktiver Key-utvidelse 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 systemtrayen</translation>
+        <translation>Start minimeret til systemtrayet</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 systemtrayen når hovedvinduet lukkes</translation>
+        <translation>Hold OpenRGB aktiv i systemtrayet når hovedvinduet lukkes</translation>
     </message>
     <message>
         <location filename="../OpenRGBDialog/OpenRGBDialog.cpp" line="195"/>
         <source>Monochrome Tray Icon</source>
-        <translation>Grått icon</translation>
+        <translation>Monokromt tray 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 trygge modus</translation>
+        <translation>HID tryggmodus</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 vente før enheter oppdages når programmet startes</translation>
+        <translation>Antall millisekunder som skal ventes 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>Antall loggfiler grense</translation>
+        <translation>Loggfil antallsgrense</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="239"/>
         <source>Maximum number of log files to keep, 0 for no limit</source>
-        <translation>Maksimal antall loggfiler som skal beholdes, 0 for ubegrenset</translation>
+        <translation>Maksimalt antall loggfiler som skal beholdes, 0 for ubegrenset</translation>
     </message>
     <message>
         <location filename="../../ResourceManager.cpp" line="243"/>
         <source>Log Manager</source>
-        <translation>Loggadministrator</translation>
+        <translation>Loggmanager</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>Tilbakeholdelse for eldre systemer</translation>
+        <translation>Workaround 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 en monokrom ikon i systemlåsen istedenfor et fargelagt ikon</translation>
+        <translation>Bruk et monokromt ikon i systemtrayet istedenfor et farget 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 faneinnhold</translation>
+        <translation>Kompakte faner</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>Fanebånd på toppen</translation>
+        <translation>Faner 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 faneinnholdet øverst istedenfor på venstre side</translation>
+        <translation>Vis faner ø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>Vindu geometri</translation>
+        <translation>Vindugeometri</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 vinduets geometri ved avslutt</translation>
+        <translation>Lagre vindugeometri ved avslutting</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>Bruker grensesnitt</translation>
+        <translation>Brukergrensesnitt</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>Journaler</translation>
+        <translation>Drivere</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>Eigene Argumente</translation>
+        <translation>Egene Argumenter</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 ned profil ved avslutt</translation>
+        <translation>Last profil ved avslutting</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 inn profil ved åpning</translation>
+        <translation>Last 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 ned profil ved gjenoppretting</translation>
+        <translation>Last profil ved våkning</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 ned profil ved tjenestestopp</translation>
+        <translation>Last 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 bakgrunns-tjenesten slutter</translation>
+        <translation>Profil som skal lastes når OpenRGB bakgrunnstjenesten slutter</translation>
     </message>
     <message>
         <location filename="../../ProfileManager.cpp" line="67"/>
         <source>Load Profile on Service Startup</source>
-        <translation>Last ned profil ved tjenestestart</translation>
+        <translation>Last 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 ned profil ved å sette på pause</translation>
+        <translation>Last profil ved suspendering</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>Profilhåndterer</translation>
+        <translation>Profilmanager</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,10 +48,11 @@
   </description>
 
   <releases>
-    <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="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="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,6 +107,7 @@ 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"
@@ -127,7 +128,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='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+="                <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+="            </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.0rc3"
+version = "1.0"
 
 #############################################
 # Git version (tag, branch, or commit)      #
 #############################################
-git_id = "release_candidate_1.0rc3"
+git_id = "release_1.0"
 
 command = "git rev-list -n 1 " + git_id
 print(command)
@@ -36,19 +36,27 @@ 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+amd64+.deb+%28Debian+Bookworm%29",     "openrgb_" + version + "_amd64_bookworm_" + commit, ".deb"      ],
-    [ "Linux+i386+.deb+%28Debian+Bookworm%29",      "openrgb_" + version + "_i386_bookworm_"  + commit, ".deb"      ],
-    [ "Linux+amd64+.deb+%28Debian+Trixie%29",       "openrgb_" + version + "_amd64_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%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+armhf+.deb+%28Debian%20Trixie%29",     "openrgb_" + version + "_armhf_trixie_"   + commit, ".deb"      ],
+
+    [ "Linux+amd64+.rpm+%28Fedora+44%29",           "openrgb_" + version + "_x86_64_f44_"     + commit, ".rpm"      ],
+
     [ "MacOS%20Intel",                              "OpenRGB_" + version + "_MacOS_Intel_"    + commit, ".zip"      ],
     [ "MacOS%20ARM64",                              "OpenRGB_" + version + "_MacOS_ARM64_"    + commit, ".zip"      ]
 ]
@@ -109,4 +117,4 @@ for artifact in artifacts:
         #########################################
         command = "mv download.zip artifacts/" + artifact[1] + artifact[2]
         print(command)
-        os.system(command)
+        os.system(command)