Add razer kitty black edition PID

* Added card ID
* Registered detector in `EVGAGPUControllerDetect.cpp`
* Link to [webpage](https://au.evga.com/products/product.aspx?pn=08G-P4-3287-KR)

60-openrgb.rules

@@ -240,6 +240,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b5d", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b12", TAG+="uaccess", TAG+="M65"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b2e", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b5a", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b5c", TAG+="uaccess", TAG+="Nightsword"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b3e", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b2f", TAG+="uaccess"
 
@@ -582,7 +583,8 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0226", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0227", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0257", TAG+="uaccess", TAG+="Huntsman_Mini"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0243", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="026B", TAG+="uaccess", TAG+="Huntsman_V2_TKL"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="026b", TAG+="uaccess", TAG+="Huntsman_V2_TKL"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="026c", TAG+="uaccess", TAG+="Huntsman_V2"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0207", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0266", TAG+="uaccess", TAG+="Huntsman V2 Analog"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="021e", TAG+="uaccess"
@@ -646,6 +648,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0039", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0048", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0032", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0034", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0091", TAG+="uaccess", TAG+="Viper_8kHz"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="008a", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0078", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007a", TAG+="uaccess"

Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.cpp

@@ -628,7 +628,7 @@ void RGBController_Polychrome::DeviceUpdateMode()
 {
     if(polychrome->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
     {
-        for(unsigned int led_idx = 0; led_idx <= leds.size(); led_idx++)
+        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
         {
             polychrome->SetMode(led_idx, modes[active_mode].value, modes[active_mode].speed);
         }

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -52,6 +52,9 @@ static const gpu_pci_device device_list[] =
     { NVIDIA_VEN,       NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A,   "ASUS ROG Strix GTX 1660S O6G Gaming"       },
     { NVIDIA_VEN,       NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_GTX1660TI_OC,                      0x2A,   "ASUS ROG GTX 1660 Ti OC 6G"                },
     { NVIDIA_VEN,       NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     },
+    { NVIDIA_VEN,       NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2060 O6G Gaming 6G"     },
+    { NVIDIA_VEN,       NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2060 O6G EVO Gaming"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2060S 8G Gaming 8G"     },
     { NVIDIA_VEN,       NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2060S A8G EVO Gaming 8G"},
     { NVIDIA_VEN,       NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2060S O8G Gaming 8G"    },
     { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2070 A8G Gaming 8G"     },
@@ -68,9 +71,11 @@ static const gpu_pci_device device_list[] =
     { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A,   "ASUS RX 5600XT Strix O6G Gaming"           },
     { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A,   "ASUS RX 5700XT Strix Gaming OC"            },
     { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX480_STRIX_GAMING_OC,                 0x29,   "ASUS ROG STRIX RX480 Gaming OC"            },
+    { AMD_GPU_VEN,      AMD_POLARIS11,              ASUS_SUB_VEN,       ASUS_RX560_STRIX_4G_GAMING,                 0x29,   "ASUS ROG STRIX RX560 Gaming"               },
     { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29,   "ASUS RX 570 Strix O4G Gaming OC"           },
     { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_OC,                 0x29,   "ASUS RX 580 Strix Gaming OC"               },
     { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_TOP,                0x29,   "ASUS RX 580 Strix Gaming TOP"              },
+    { NVIDIA_VEN,       NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,       ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A,   "ASUS TUF RTX 3060 Ti 8G Gaming OC"         },
 };  
 
 /******************************************************************************************\

Controllers/AsusAuraUSBController/AsusAuraMousematController.cpp

@@ -0,0 +1,130 @@
+/*-----------------------------------------*\
+|  AsusAuraMousematController.cpp           |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/10/2022   |
+\*-----------------------------------------*/
+
+#include "AsusAuraMousematController.h"
+#include <cstring>
+
+AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AuraMousematController::~AuraMousematController()
+{
+	hid_close(dev);
+}
+
+std::string AuraMousematController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AuraMousematController::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+std::string AuraMousematController::GetVersion()
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    usb_buf[0x00]   = 0xEE;
+    usb_buf[0x01]   = 0x12;
+    usb_buf[0x02]   = 0x00;
+
+    hid_write(dev, usb_buf, 65);
+
+    unsigned char usb_buf_out[65];
+    hid_read(dev, usb_buf_out, 65);
+
+    char version[5];
+    snprintf(version, 5, "%04X", (usb_buf_out[6] << 8) | usb_buf_out[7]);
+    return std::string(version);
+}
+
+void AuraMousematController::UpdateLeds
+    (
+    std::vector<RGBColor>    colors
+    )
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0xEE;
+    usb_buf[0x01]   = 0xC0;
+    usb_buf[0x02]   = 0x81;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = 0x00;
+
+    for(unsigned int i = 0; i < 60; i += 4)
+    {
+        usb_buf[5 + i]   = 0x00;
+        usb_buf[6 + i]   = RGBGetRValue(colors[i / 4]);
+        usb_buf[7 + i]   = RGBGetGValue(colors[i / 4]);
+        usb_buf[8 + i]   = RGBGetBValue(colors[i / 4]);
+    }
+
+    hid_write(dev, usb_buf, 65);
+}
+
+void AuraMousematController::UpdateDevice
+    (
+    unsigned char   mode,
+    unsigned char   red,
+    unsigned char   grn,
+    unsigned char   blu,
+    unsigned char   speed,
+    unsigned char   brightness
+    )
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0xEE;
+    usb_buf[0x01]   = 0x51;
+    usb_buf[0x02]   = 0x28;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = mode;
+    usb_buf[0x06]   = speed;
+    usb_buf[0x07]   = brightness;
+    usb_buf[0x08]   = 0x00;
+    usb_buf[0x09]   = 0x00;
+    usb_buf[0x0a]   = red;
+    usb_buf[0x0b]   = grn;
+    usb_buf[0x0c]   = blu;
+    hid_write(dev, usb_buf, 65);
+}
+
+void AuraMousematController::SaveMode()
+{
+    unsigned char usb_save_buf[65];
+
+    memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
+
+    usb_save_buf[0x00]   = 0xEE;
+    usb_save_buf[0x01]   = 0x50;
+    usb_save_buf[0x02]   = 0x55;
+
+    hid_write(dev, usb_save_buf, 65);
+}

Controllers/AsusAuraUSBController/AsusAuraMousematController.h

@@ -0,0 +1,53 @@
+/*-----------------------------------------*\
+|  AsusAuraMousematController.h             |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/10/2022   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+
+enum
+{
+    AURA_MOUSEMAT_MODE_DIRECT           = 0,
+    AURA_MOUSEMAT_MODE_BREATHING        = 1,
+    AURA_MOUSEMAT_MODE_CHASING          = 3,
+};
+
+class AuraMousematController
+{
+public:
+    AuraMousematController(hid_device* dev_handle, const char* path);
+    virtual ~AuraMousematController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+    std::string GetVersion();
+
+    void UpdateLeds
+        (
+        std::vector<RGBColor>    colors
+        );
+
+    void UpdateDevice
+        (
+        unsigned char   mode,
+        unsigned char   red,
+        unsigned char   grn,
+        unsigned char   blu,
+        unsigned char   speed,
+        unsigned char   brightness
+        );
+
+    void SaveMode();
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -5,6 +5,7 @@
 #include "AsusAuraTUFKeyboardController.h"
 #include "AsusAuraMainboardController.h"
 #include "AsusAuraMouseController.h"
+#include "AsusAuraMousematController.h"
 #include "AsusAuraStrixEvolveController.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraUSB.h"
@@ -12,6 +13,7 @@
 #include "RGBController_AsusAuraKeyboard.h"
 #include "RGBController_AsusAuraTUFKeyboard.h"
 #include "RGBController_AsusAuraMouse.h"
+#include "RGBController_AsusAuraMousemat.h"
 #include "RGBController_AsusAuraStrixEvolve.h"
 #include <stdexcept>
 #include <hidapi/hidapi.h>
@@ -48,6 +50,12 @@
 
 #define AURA_ROG_STRIX_EVOLVE_PID               0x185B
 
+/*-----------------------------------------------------------------*\
+| MOUSEMATS                                                         |
+\*-----------------------------------------------------------------*/
+#define AURA_ROG_BALTEUS_PID                    0x1891
+#define AURA_ROG_BALTEUS_QI_PID                 0x1890
+
 /*-----------------------------------------------------------------*\
 |  OTHER                                                            |
 \*-----------------------------------------------------------------*/
@@ -154,6 +162,18 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
     }
 }
 
+void DetectAsusAuraUSBMousemats(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        AuraMousematController* controller = new AuraMousematController(dev, info->path);
+        RGBController_AuraMousemat* rgb_controller = new RGBController_AuraMousemat(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -235,6 +255,12 @@ REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                  DetectAsusAuraUS
 
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Evolve",               DetectAsusAuraUSBStrixEvolve,   AURA_USB_VID, AURA_ROG_STRIX_EVOLVE_PID,                1,  0x0008);
 
+/*-----------------------------------------------------------------*\
+| MOUSEMATS                                                         |
+\*-----------------------------------------------------------------*/
+REGISTER_HID_DETECTOR ("ASUS ROG Balteus",                    DetectAsusAuraUSBMousemats,     AURA_USB_VID, AURA_ROG_BALTEUS_PID                     );
+REGISTER_HID_DETECTOR ("ASUS ROG Balteus Qi",                 DetectAsusAuraUSBMousemats,     AURA_USB_VID, AURA_ROG_BALTEUS_QI_PID                  );
+
 /*-----------------------------------------------------------------*\
 |  OTHER                                                            |
 \*-----------------------------------------------------------------*/

Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.cpp

@@ -0,0 +1,147 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraMousemat.cpp       |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/10/2022   |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraMousemat.h"
+
+RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "ASUS Aura Mousemat";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_MOUSEMAT;
+    description = "ASUS Aura Mousemat Device";
+    version     = controller->GetVersion();
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = AURA_MOUSEMAT_MODE_DIRECT;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    // mode Breathing;
+    // Breathing.name           = "Breathing";
+    // Breathing.value          = AURA_MOUSEMAT_MODE_BREATHING;
+    // Breathing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    // Breathing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    // Breathing.speed_min      = AURA_MOUSEMAT_SPEED_MIN;
+    // Breathing.speed_max      = AURA_MOUSEMAT_SPEED_MAX;
+    // Breathing.speed          = AURA_MOUSEMAT_SPEED_DEFAULT;
+    // Breathing.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
+    // Breathing.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
+    // Breathing.brightness     = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
+    // Breathing.colors_min     = 1;
+    // Breathing.colors_max     = 1;
+    // Breathing.colors.resize(1);
+    // modes.push_back(Breathing);
+
+    // mode Chasing;
+    // Chasing.name           = "Chasing";
+    // Chasing.value          = AURA_MOUSEMAT_MODE_CHASING;
+    // Chasing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    // Chasing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    // Chasing.speed_min      = AURA_MOUSEMAT_SPEED_MIN;
+    // Chasing.speed_max      = AURA_MOUSEMAT_SPEED_MAX;
+    // Chasing.speed          = AURA_MOUSEMAT_SPEED_DEFAULT;
+    // Chasing.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
+    // Chasing.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
+    // Chasing.brightness     = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
+    // Chasing.colors_min     = 1;
+    // Chasing.colors_max     = 1;
+    // Chasing.colors.resize(1);
+    // modes.push_back(Chasing);
+
+    SetupZones();
+}
+
+RGBController_AuraMousemat::~RGBController_AuraMousemat()
+{
+	delete controller;
+}
+
+void RGBController_AuraMousemat::SetupZones()
+{
+    zone mousemat_zone;
+
+    mousemat_zone.name         = "Mousemat";
+    mousemat_zone.type         = ZONE_TYPE_LINEAR;
+    mousemat_zone.leds_min     = 15;
+    mousemat_zone.leds_max     = 15;
+    mousemat_zone.leds_count   = 15;
+    mousemat_zone.matrix_map   = NULL;
+
+    zones.push_back(mousemat_zone);
+
+    for(unsigned int i = 0; i < 15; i++)
+    {
+        led mousemat_led;
+
+        mousemat_led.name      = "Mousemat LED " + std::to_string(i);
+
+        leds.push_back(mousemat_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AuraMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AuraMousemat::DeviceUpdateLEDs()
+{
+    controller->UpdateLeds(std::vector<RGBColor>(colors));
+}
+
+void RGBController_AuraMousemat::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraMousemat::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraMousemat::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_AuraMousemat::DeviceUpdateMode()
+{
+    unsigned char red = 0;
+    unsigned char grn = 0;
+    unsigned char blu = 0;
+    switch(modes[active_mode].value)
+    {
+        case AURA_MOUSEMAT_MODE_DIRECT:
+            controller->UpdateLeds(std::vector<RGBColor>(colors));
+            break;
+        case AURA_MOUSEMAT_MODE_BREATHING:
+        case AURA_MOUSEMAT_MODE_CHASING:
+            red = RGBGetRValue(modes[active_mode].colors[0]);
+            grn = RGBGetGValue(modes[active_mode].colors[0]);
+            blu = RGBGetBValue(modes[active_mode].colors[0]);
+            controller->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, modes[active_mode].brightness);
+            break;
+    }
+}
+
+void RGBController_AuraMousemat::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    controller->SaveMode();
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.h

@@ -0,0 +1,44 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraMousemat.h         |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraMousematController.h"
+
+enum
+{
+    AURA_MOUSEMAT_BRIGHTNESS_MIN        = 0,
+    AURA_MOUSEMAT_BRIGHTNESS_MAX        = 4,
+    AURA_MOUSEMAT_BRIGHTNESS_DEFAULT    = 4,
+    AURA_MOUSEMAT_SPEED_MIN             = 0,
+    AURA_MOUSEMAT_SPEED_MAX             = 255,
+    AURA_MOUSEMAT_SPEED_DEFAULT         = 127,
+};
+
+class RGBController_AuraMousemat : public RGBController
+{
+public:
+    RGBController_AuraMousemat(AuraMousematController* controller_ptr);
+    ~RGBController_AuraMousemat();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    AuraMousematController* controller;
+};

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -265,7 +265,7 @@ void CorsairLightingNodeController::SendDirect
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
-    hid_read_timeout(dev, usb_buf, 17, 1);
+    hid_read_timeout(dev, usb_buf, 17, 5);
 }
 
 void CorsairLightingNodeController::SendCommit()
@@ -293,7 +293,7 @@ void CorsairLightingNodeController::SendCommit()
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
-    hid_read_timeout(dev, usb_buf, 17, 1);
+    hid_read_timeout(dev, usb_buf, 17, 5);
 }
 
 void CorsairLightingNodeController::SendBegin
@@ -456,7 +456,7 @@ void CorsairLightingNodeController::SendPortState
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
-    hid_read_timeout(dev, usb_buf, 17, 1);
+    hid_read_timeout(dev, usb_buf, 17, 5);
 }
 
 void CorsairLightingNodeController::SendBrightness

Controllers/CorsairPeripheralController/CorsairK55RGBPROController.cpp

@@ -0,0 +1,106 @@
+#include "CorsairK55RGBPROController.h"
+/*-----------------------------------------*\
+|  CorsairK55RGBPROController.cpp           |
+|                                           |
+|  Driver for Corsair K55 RGB PRO Keyboard  |
+\*-----------------------------------------*/
+
+#include "LogManager.h"
+
+CorsairK55RGBPROController::CorsairK55RGBPROController(hid_device* dev_handle, const char* path)
+{
+    dev             = dev_handle;
+    location        = path;
+
+    LightingControl();
+}
+
+CorsairK55RGBPROController::~CorsairK55RGBPROController()
+{
+    hid_close(dev);
+}
+
+std::string CorsairK55RGBPROController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string CorsairK55RGBPROController::GetFirmwareString()
+{
+    return "";
+}
+
+std::string CorsairK55RGBPROController::GetName()
+{
+    return name;
+}
+
+void CorsairK55RGBPROController::SetName(std::string device_name)
+{
+    name = device_name;
+}
+
+std::string CorsairK55RGBPROController::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+void CorsairK55RGBPROController::LightingControl()
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    //This is requered
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x01;
+    usb_buf[0x03] = 0x03;
+    usb_buf[0x05] = 0x02;
+
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x02;
+    usb_buf[0x03] = 0x5F;
+
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x0D;
+    usb_buf[0x04] = 0x01;
+
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+}
+
+void CorsairK55RGBPROController::SetLEDs(std::vector<RGBColor>colors)
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x06;
+    usb_buf[0x04] = 0x12;
+
+    for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        RGBColor color = colors[color_idx];
+        usb_buf[9  + color_idx] = RGBGetRValue(color);
+        usb_buf[15 + color_idx] = RGBGetGValue(color);
+        usb_buf[21 + color_idx] = RGBGetBValue(color);
+    }
+
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+}

Controllers/CorsairPeripheralController/CorsairK55RGBPROController.h

@@ -0,0 +1,35 @@
+#ifndef CORSAIRK55RGBPROCONTROLLER_H
+#define CORSAIRK55RGBPROCONTROLLER_H
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+class CorsairK55RGBPROController
+{
+public:
+    CorsairK55RGBPROController(hid_device* dev_handle, const char* path);
+    ~CorsairK55RGBPROController();
+    std::string                     GetDeviceLocation();
+    std::string                     GetFirmwareString();
+    std::string                     GetName();
+    std::string                     GetSerialString();
+
+    void                            SetLEDs(std::vector<RGBColor> colors);
+    void                            SetLEDsKeyboardLimited(std::vector<RGBColor> colors);
+    void                            SetName(std::string device_name);
+
+private:
+    hid_device*             dev;
+
+    std::string             firmware_version;
+    std::string             location;
+    std::string             name;
+    device_type             type;
+
+    void                    LightingControl();
+    void                    SetLEDsKeyboardFull(std::vector<RGBColor> colors);
+};
+
+#endif // CORSAIRK55RGBPROCONTROLLER_H

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -60,6 +60,7 @@ static unsigned int st100[] = { 0x00, 0x01, 0x02, 0x03, 0x05, 0x06, 0x07, 0x08,
 
 static unsigned int key_mapping_k95_plat_ansi[] = { 0x31, 0x3f, 0x41, 0x42, 0x51, 0x53, 0x55, 0x6f, 0x7e, 0x7f, 0x80, 0x81 };
 static unsigned int key_mapping_k95_plat_iso[] = { 0x3f, 0x41, 0x42, 0x48, 0x50, 0x53, 0x55, 0x6f, 0x7e, 0x7f, 0x80, 0x81 };
+static unsigned int key_mapping_k70_mk2_plat_iso[] = { 0x3f, 0x41, 0x42, 0x50, 0x53, 0x55, 0x6f, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81 };
 
 #define CORSAIR_PERIPHERAL_CONTROLLER_NAME "Corsair peripheral"
 
@@ -421,8 +422,16 @@ void CorsairPeripheralController::SetupK55AndK95LightingControl()
     
     if (physical_layout == CORSAIR_LAYOUT_ISO)
     {
-        skipped_identifiers = key_mapping_k95_plat_iso;
-        skipped_identifiers_count = sizeof(key_mapping_k95_plat_iso) / sizeof(key_mapping_k95_plat_iso[0]);
+        if(logical_layout == CORSAIR_TYPE_K70_MK2)
+        {
+            skipped_identifiers = key_mapping_k70_mk2_plat_iso;
+            skipped_identifiers_count = sizeof(key_mapping_k70_mk2_plat_iso) / sizeof(key_mapping_k70_mk2_plat_iso[0]);
+        }
+        else
+        {
+            skipped_identifiers = key_mapping_k95_plat_iso;
+            skipped_identifiers_count = sizeof(key_mapping_k95_plat_iso) / sizeof(key_mapping_k95_plat_iso[0]);
+        }
     }
 
     unsigned int identifier = 0;

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -1,10 +1,12 @@
 #include "Detector.h"
 #include "CorsairPeripheralController.h"
 #include "CorsairK100Controller.h"
+#include "CorsairK55RGBPROController.h"
 #include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_CorsairPeripheral.h"
 #include "RGBController_CorsairK100.h"
+#include "RGBController_CorsairK55RGBPRO.h"
 #include <hidapi/hidapi.h>
 
 #define CORSAIR_PERIPHERAL_CONTROLLER_NAME "Corsair peripheral"
@@ -53,6 +55,7 @@
 #define CORSAIR_M65_PID                 0x1B12
 #define CORSAIR_M65_PRO_PID             0x1B2E
 #define CORSAIR_M65_RGB_ELITE_PID       0x1B5A
+#define CORSAIR_NIGHTSWORD_PID          0x1B5C
 #define CORSAIR_SCIMITAR_PRO_RGB_PID    0x1B3E
 #define CORSAIR_SABRE_RGB_PID           0x1B2F
 
@@ -95,6 +98,25 @@ void DetectCorsairK100Controllers(hid_device_info* info, const std::string& name
     }
 }   /* DetectCorsairPeripheralControllers() */
 
+/*-----------------------------------------------------*\
+| Corsair K55 RGB PRO Keyboard product ID               |
+| This keyboard uses a separate driver                  |
+\*-----------------------------------------------------*/
+#define CORSAIR_K55_RGB_PRO_PID         0x1BA4
+
+void DetectCorsairK55RGBPROControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        CorsairK55RGBPROController* controller = new CorsairK55RGBPROController(dev, info->path);
+        controller->SetName(name);
+        RGBController_CorsairK55RGBPRO* rgb_controller = new RGBController_CorsairK55RGBPRO(controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}   /* DetectCorsairK55RGBPROControllers() */
+
 /******************************************************************************************\
 *                                                                                          *
 *   DetectCorsairPeripheralControllers                                                     *
@@ -129,35 +151,36 @@ void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string
 /*-----------------------------------------------------------------------------------------------------*\
 | Keyboards                                                                                             |
 \*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID,           1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K65 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_PID,           1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K65 LUX RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_LUX_RGB_PID,       1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K65 RGB RAPIDFIRE",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_RAPIDFIRE_PID, 1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K68 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K68_RGB,               1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_PID,           1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 LUX RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_LUX_RGB_PID,       1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB RAPIDFIRE",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_RAPIDFIRE_PID, 1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_PID,       1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2 SE",          DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_SE_PID,    1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2 Low Profile", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_LP_PID,    1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K95 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_RGB_PID,           1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K95 RGB PLATINUM",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_PLATINUM_PID,      1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Strafe",                   DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_PID,            1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Strafe Red",               DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_RED_PID,        1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Strafe MK.2",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_MK2_PID,        1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID,           1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K65 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_PID,           1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K65 LUX RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_LUX_RGB_PID,       1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K65 RGB RAPIDFIRE",       DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_RAPIDFIRE_PID, 1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K68 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K68_RGB,               1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_PID,           1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 LUX RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_LUX_RGB_PID,       1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB RAPIDFIRE",       DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_RAPIDFIRE_PID, 1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2",            DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_PID,       1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2 SE",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_SE_PID,    1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2 Low Profile",DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_LP_PID,    1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K95 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_RGB_PID,           1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K95 RGB PLATINUM",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_PLATINUM_PID,      1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Strafe",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_PID,            1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Strafe Red",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_RED_PID,        1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Strafe MK.2",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_MK2_PID,        1, 0xFFC2);
 /*-----------------------------------------------------------------------------------------------------*\
 | Mice                                                                                                  |
 \*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB",               DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PID,        1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB PRO",           DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PRO_PID,    1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PID,       1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB PRO",          DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PRO_PID,   1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Ironclaw RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_IRONCLAW_RGB_PID,      1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair M65",                      DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_PID,               1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair M65 PRO",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_PRO_PID,           1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair M65 RGB Elite" ,           DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_RGB_ELITE_PID,     1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Scimitar PRO RGB",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_PRO_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 Glaive RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PID,        1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB PRO",          DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PRO_PID,    1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PID,       1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB PRO",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PRO_PID,   1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Ironclaw RGB",            DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_IRONCLAW_RGB_PID,      1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair M65",                     DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_PID,               1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair M65 PRO",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_PRO_PID,           1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair M65 RGB Elite",           DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_RGB_ELITE_PID,     1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Nightsword",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_NIGHTSWORD_PID,        1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Scimitar PRO RGB",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_PRO_RGB_PID,  1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Sabre RGB",               DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SABRE_RGB_PID,         1, 0xFFC2);
 
 /*-----------------------------------------------------------------------------------------------------*\
 | Mousemats                                                                                             |
@@ -180,3 +203,8 @@ REGISTER_HID_DETECTOR_I("Corsair ST100 RGB",                DetectCorsairPeriphe
 | Corsair K100 Keyboard                                                                                 |
 \*-----------------------------------------------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("Corsair K100",                    DetectCorsairK100Controllers,       CORSAIR_VID, CORSAIR_K100_PID,              1, 0xFF42);
+
+/*-----------------------------------------------------------------------------------------------------*\
+| Corsair K55 RGB PRO Keyboard                                                                          |
+\*-----------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO",             DetectCorsairK55RGBPROControllers,  CORSAIR_VID, CORSAIR_K55_RGB_PRO_PID,       1, 0xFF42);

Controllers/CorsairPeripheralController/RGBController_CorsairK55RGBPRO.cpp

@@ -0,0 +1,135 @@
+#include "RGBController_CorsairK55RGBPRO.h"
+/*-----------------------------------------*\
+|  RGBController_CorsairK55RGBPRO.cpp       |
+|                                           |
+|  Driver for Corsair K55 RGB PRO0 Keyboard |
+\*-----------------------------------------*/
+
+#include "LogManager.h"
+
+using namespace std::chrono_literals;
+
+RGBController_CorsairK55RGBPRO::RGBController_CorsairK55RGBPRO(CorsairK55RGBPROController* corsair_ptr)
+{
+    corsair         = corsair_ptr;
+
+    name            = corsair->GetName();
+    vendor          = "Corsair";
+    description     = "Corsair K55 RGB PRO Keyboard Device";
+    type            = DEVICE_TYPE_KEYBOARD;
+    version         = corsair->GetFirmwareString();
+    location        = corsair->GetDeviceLocation();
+    serial          = corsair->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+    /*-----------------------------------------------------*\
+    | The Corsair K55 RGB PRO requires a packet within      |
+    | 1 minutes of sending the lighting change in order     |
+    | to not revert back into rainbow mode.  Start a thread |
+    | to continuously send a keepalive packet every 50 sec  |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = true;
+    keepalive_thread = new std::thread(&RGBController_CorsairK55RGBPRO::KeepaliveThread, this);
+}
+
+RGBController_CorsairK55RGBPRO::~RGBController_CorsairK55RGBPRO()
+{
+    /*-----------------------------------------------------*\
+    | Close keepalive thread                                |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = false;
+    keepalive_thread->join();
+    delete keepalive_thread;
+
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].type == ZONE_TYPE_MATRIX)
+        {
+            delete zones[zone_index].matrix_map;
+        }
+    }
+
+    delete corsair;
+}
+
+void RGBController_CorsairK55RGBPRO::SetupZones()
+{
+    zone new_zone;
+
+    new_zone.name                   = "Keyboard";
+    new_zone.type                   = ZONE_TYPE_LINEAR;
+    new_zone.leds_min               = 5;
+    new_zone.leds_max               = 5;
+    new_zone.leds_count             = 5;
+    new_zone.matrix_map             = NULL;
+
+    for(unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
+    {
+        led new_led;
+        new_led.name = "Zone " + std::to_string( led_idx );
+        leds.push_back(new_led);
+    }
+
+    zones.push_back(new_zone);
+
+    SetupColors();
+}
+
+void RGBController_CorsairK55RGBPRO::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_CorsairK55RGBPRO::DeviceUpdateLEDs()
+{
+    last_update_time = std::chrono::steady_clock::now();
+
+    corsair->SetLEDs(colors);
+}
+
+void RGBController_CorsairK55RGBPRO::UpdateZoneLEDs(int /*zone*/)
+{
+    corsair->SetLEDs(colors);
+}
+
+void RGBController_CorsairK55RGBPRO::UpdateSingleLED(int /*led*/)
+{
+    corsair->SetLEDs(colors);
+}
+
+void RGBController_CorsairK55RGBPRO::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_CorsairK55RGBPRO::DeviceUpdateMode()
+{
+
+}
+
+void RGBController_CorsairK55RGBPRO::KeepaliveThread()
+{
+    while(keepalive_thread_run.load())
+    {
+        if(active_mode == 0)
+        {
+            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50000))
+            {
+                DeviceUpdateLEDs();
+            }
+        }
+        std::this_thread::sleep_for(3000ms);
+    }
+}

Controllers/CorsairPeripheralController/RGBController_CorsairK55RGBPRO.h

@@ -0,0 +1,33 @@
+#ifndef RGBCONTROLLER_CORSAIRK55RGBPRO_H
+#define RGBCONTROLLER_CORSAIRK55RGBPRO_H
+
+#include "RGBController.h"
+#include "CorsairK55RGBPROController.h"
+
+class RGBController_CorsairK55RGBPRO : public RGBController
+{
+public:
+    RGBController_CorsairK55RGBPRO(CorsairK55RGBPROController* corsair_ptr);
+    ~RGBController_CorsairK55RGBPRO();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
+
+    void DeviceUpdateMode();
+    void SetCustomMode();
+    void        KeepaliveThread();
+
+private:
+    CorsairK55RGBPROController*     corsair;
+
+    std::thread*                    keepalive_thread;
+    std::atomic<bool>               keepalive_thread_run;
+    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
+
+};
+
+#endif // RGBCONTROLLER_CORSAIRK55RGBPRO_H

Controllers/CorsairVengeanceProController/CorsairVengeanceProController.h

@@ -16,6 +16,7 @@
 typedef unsigned char	corsair_dev_id;
 
 #define CORSAIR_PRO_LED_COUNT   ( 10 )
+#define CORSAIR_VENGEANCE_RGB_PRO_NAME "Corsair Vengenance RGB PRO"
 
 enum
 {

Controllers/CorsairVengeanceProController/CorsairVengeanceProControllerDetect.cpp

@@ -4,6 +4,7 @@
 #include "RGBController_CorsairVengeancePro.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
+#include "LogManager.h"
 #include <vector>
 #include <stdio.h>
 #include <stdlib.h>
@@ -24,6 +25,8 @@ bool TestForCorsairVengeanceProController(i2c_smbus_interface* bus, unsigned cha
 
     int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
 
+    LOG_DEBUG("[%s] Trying address %02X", CORSAIR_VENGEANCE_RGB_PRO_NAME, address);
+
     if (res >= 0)
     {
         pass = true;
@@ -33,6 +36,7 @@ bool TestForCorsairVengeanceProController(i2c_smbus_interface* bus, unsigned cha
         if (res != 0x1C)
         {
             pass = false;
+            LOG_DEBUG("[%s] Failed: was expecting 0x1C got %02X", CORSAIR_VENGEANCE_RGB_PRO_NAME, res);
         }
 
         res = bus->i2c_smbus_read_byte_data(address, 0x44);
@@ -40,8 +44,13 @@ bool TestForCorsairVengeanceProController(i2c_smbus_interface* bus, unsigned cha
         if (!((res == 0x03) || (res == 0x04)))
         {
             pass = false;
+            LOG_DEBUG("[%s] Failed: was expecting 0x03 or 0x04 got %02X", CORSAIR_VENGEANCE_RGB_PRO_NAME, res);
         }
     }
+    else
+    {
+        LOG_DEBUG("[%s] Failed: res was %04X", CORSAIR_VENGEANCE_RGB_PRO_NAME, res);
+    }
 
     std::this_thread::sleep_for(10ms);
     
@@ -67,6 +76,8 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
 
     for (unsigned int bus = 0; bus < busses.size(); bus++)
     {
+        LOG_DEBUG("[%s] Testing bus %d", CORSAIR_VENGEANCE_RGB_PRO_NAME, bus);
+
         IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
             // Check for Corsair controller at 0x58
@@ -133,6 +144,10 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
                 ResourceManager::get()->RegisterRGBController(new_controller);
             }
         }
+        else
+        {
+            LOG_DEBUG("[%s] Check failed for VID:PID %04X:%04X", CORSAIR_VENGEANCE_RGB_PRO_NAME, busses[bus]->pci_vendor, busses[bus]->pci_device);
+        }
     }
 
 }   /* DetectCorsairVengeanceProControllers() */

Controllers/CrucialController/RGBController_Crucial.cpp

@@ -163,6 +163,11 @@ void RGBController_Crucial::DeviceUpdateLEDs()
     else
     {
         crucial->SetAllColorsEffect(&colors[0]);
+
+        if(modes[active_mode].value == CRUCIAL_MODE_STATIC)
+        {
+            crucial->SetMode(modes[active_mode].value);
+        }
     }
 }
 

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -102,6 +102,7 @@ static const gpu_pci_device device_list[] =
     { NVIDIA_VEN,       NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,       ASUS_TUF_RTX_3080_O10G_V2_GAMING_8822,      0x67,   "ASUS TUF RTX 3080 O10G V2 GAMING"          },
     { NVIDIA_VEN,       NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,       ASUS_TUF_RTX_3080_O10G_V2_GAMING,           0x67,   "ASUS TUF RTX 3080 O10G V2 GAMING"          },
     { NVIDIA_VEN,       NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3080TI_O12G_GAMING,      0x67,   "ASUS ROG STRIX 3080Ti O12G GAMING"         },
+    { NVIDIA_VEN,       NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3090_24G_GAMING,         0x67,   "ASUS ROG STRIX 3090 24G GAMING"            },
     { NVIDIA_VEN,       NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3090_O24G_GAMING,        0x67,   "ASUS ROG STRIX 3090 O24G GAMING"           },
     { NVIDIA_VEN,       NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3090_O24G_GAMING_WHITE,  0x67,   "ASUS ROG STRIX 3090 O24G GAMING White OC"  },
     { NVIDIA_VEN,       NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,       ASUS_TUF_RTX_3090_O24G,                     0x67,   "ASUS TUF RTX 3090 O24G"                    },

Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp

@@ -57,7 +57,9 @@ static const gpu_pci_device device_list[] =
     { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,       EVGA_SUB_VEN,   EVGA_RTX2080_XC_GAMING_SUB_DEV,             EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Gaming"                       },
     { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,       EVGA_SUB_VEN,   EVGA_RTX2080_XC_ULTRA_GAMING_SUB_DEV,       EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Ultra Gaming"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,        EVGA_SUB_VEN,   EVGA_RTX2080S_XC_GAMING_SUB_DEV,            EVGA_RGB_V2,    "EVGA GeForce RTX 2080 SUPER XC Gaming"                 },
+    { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,        EVGA_SUB_VEN,   EVGA_RTX2080S_XC_ULTRA_SUB_DEV,             EVGA_RGB_V2,    "EVGA GeForce RTX 2080 SUPER XC Ultra"                  },
     { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,        EVGA_SUB_VEN,   EVGA_RTX2080S_FTW3_ULTRA_SUB_DEV,           EVGA_RGB_V2,    "EVGA GeForce RTX 2080 SUPER FTW3 Ultra"                },
+    { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,        EVGA_SUB_VEN,   EVGA_RTX2080S_FTW3_HYBRID_OC_SUB_DEV,       EVGA_RGB_V2,    "EVGA GeForce RTX 2080 SUPER FTW3 Hybrid OC"            },
     { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,        EVGA_SUB_VEN,   EVGA_RTX2080S_FTW3_ULTRA_HC_SUB_DEV,        EVGA_RGB_V2,    "EVGA GeForce RTX 2080 SUPER FTW3 Ultra Hydro Copper"   },
     { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX2080TI_BLACK_SUB_DEV,               EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti Black"                         },
     { NVIDIA_VEN,   NVIDIA_RTX2080TI_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_XC_ULTRA_GAMING_SUB_DEV,     EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti XC Ultra"                      },

Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp

@@ -27,11 +27,12 @@ static const gpu_pci_device device_list[] =
     { NVIDIA_VEN,    NVIDIA_RTX2060S_OC_DEV,    GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2060S_V1_SUB_DEV,             0x50,   "Gigabyte AORUS RTX2060 SUPER 8G V1"                },
     { NVIDIA_VEN,    NVIDIA_RTX2070_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2070_XTREME_SUB_DEV,          0x50,   "Gigabyte AORUS RTX2070 XTREME 8G"                  },
     { NVIDIA_VEN,    NVIDIA_RTX2070S_OC_DEV,    GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_SUB_DEV2,           0x50,   "Gigabyte AORUS RTX2070 SUPER 8G"                   },
+    { NVIDIA_VEN,    NVIDIA_RTX2080_A_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080_SUB_DEV,                 0x50,   "Gigabyte AORUS RTX2080 8G"                         },
     { NVIDIA_VEN,    NVIDIA_RTX3060_LHR_DEV,    GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_ELITE_12GB_SUB_DEV,            0x70,   "Gigabyte AORUS RTX3060 ELITE 12G"                  },
     { NVIDIA_VEN,    NVIDIA_RTX3060TI_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_GAMING_OC_PRO_SUB_DEV,       0x62,   "Gigabyte AORUS RTX3060 Ti GAMING OC PRO 8G"        },
     { NVIDIA_VEN,    NVIDIA_RTX3070_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_MASTER_OC_SUB_DEV,             0x66,   "Gigabyte RTX3070 MASTER 8G"                        },
     { NVIDIA_VEN,    NVIDIA_RTX3080_LHR_DEV,    GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080_XTREME_WATERFORCE_SUB_DEV,     0x64,   "Gigabyte AORUS RTX3080 XTREME WATERFORCE WB 10G"   },
-    { NVIDIA_VEN,    NVIDIA_RTX3080TI_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080TI_VISION_OC_SUB_DEV,           0x63,   "Gigabyte RTX3080 Ti Vision OC 12G"             },
+    { NVIDIA_VEN,    NVIDIA_RTX3080TI_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080TI_VISION_OC_SUB_DEV,           0x63,   "Gigabyte RTX3080 Ti Vision OC 12G"                 },
     { NVIDIA_VEN,    NVIDIA_RTX3080TI_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080TI_XTREME_WATERFORCE_SUB_DEV,   0x65,   "Gigabyte AORUS RTX3080 Ti XTREME WATERFORCE 12G"   },
     { NVIDIA_VEN,    NVIDIA_RTX3090_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX3090_XTREME_WATERFORCE_SUB_DEV,     0x64,   "Gigabyte AORUS RTX3090 XTREME WATERFORCE WB 24G"   },
 };

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUController.h

@@ -27,6 +27,7 @@ enum
     RGB_FUSION_GPU_MODE_BREATHING       = 0x02,
     RGB_FUSION_GPU_MODE_FLASHING        = 0x04,
     RGB_FUSION_GPU_MODE_DUAL_FLASHING   = 0x08,
+    RGB_FUSION_GPU_MODE_COLOR_CYCLE     = 0x10,
     RGB_FUSION_GPU_MODE_SPECTRUM_CYCLE  = 0x11
 };
 

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUControllerDetect.cpp

@@ -63,6 +63,7 @@ static const gpu_pci_device device_list[] =
     { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_GAMING_OC_SUB_DEV,             0x62,   "Gigabyte RTX3070 Gaming OC 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX3070_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_GAMING_OC_SUB_DEV,             0x62,   "Gigabyte RTX3070 Gaming OC 8G v3.0 LHR"        },
     { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_VISION_OC_SUB_DEV,             0x63,   "Gigabyte RTX3070 Vision 8G"                    },
+    { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_EAGLE_OC_SUB_DEV,              0x63,   "Gigabyte RTX3070 Eagle OC 8G"                  },    
     { NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070TI_GAMING_OC_SUB_DEV,           0x62,   "Gigabyte RTX3070 Ti Gaming OC 8G"              },
     { NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070TI_EAGLE_SUB_DEV,               0x63,   "Gigabyte RTX3070 Ti EAGLE 8G"                  },
     { NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070TI_VISION_OC_SUB_DEV,           0x63,   "Gigabyte RTX3070 Ti Vision OC 8G"              },

Controllers/GigabyteRGBFusionGPUController/RGBController_GigabyteRGBFusionGPU.cpp

@@ -69,6 +69,16 @@ RGBController_RGBFusionGPU::RGBController_RGBFusionGPU(RGBFusionGPUController* r
     DualFlashing.brightness     = RGB_FUSION_GPU_BRIGHTNESS_MAX;
     modes.push_back(DualFlashing);
 
+    mode ColorCycle;
+    ColorCycle.name       = "Color Cycle";
+    ColorCycle.value      = RGB_FUSION_GPU_MODE_COLOR_CYCLE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    ColorCycle.flags      = MODE_FLAG_HAS_SPEED;
+    ColorCycle.speed_min  = RGB_FUSION_GPU_SPEED_SLOWEST;
+    ColorCycle.speed_max  = RGB_FUSION_GPU_SPEED_FASTEST;
+    ColorCycle.speed      = RGB_FUSION_GPU_SPEED_NORMAL;
+    ColorCycle.color_mode = MODE_COLORS_NONE;
+    modes.push_back(ColorCycle);
+
     mode SpectrumCycle;
     SpectrumCycle.name           = "Spectrum Cycle";
     SpectrumCycle.value          = RGB_FUSION_GPU_MODE_SPECTRUM_CYCLE;

Controllers/LogitechController/LogitechControllerDetect.cpp

@@ -886,4 +886,4 @@ REGISTER_HID_DETECTOR_IPU("Logitech G900 Wireless Gaming Mouse (wired)",
 REGISTER_HID_DETECTOR_IPU("Logitech G903 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G903_LIGHTSPEED_PID,                 1, 0xFF00, 2);
 REGISTER_HID_DETECTOR_IPU("Logitech G903 Hero Wireless Gaming Mouse (wired)",   DetectLogitechWired,        LOGITECH_VID, LOGITECH_G903_LIGHTSPEED_HERO_PID,            1, 0xFF00, 2);
 REGISTER_HID_DETECTOR_IPU("Logitech G Pro Wireless Gaming Mouse (wired)",       DetectLogitechWired,        LOGITECH_VID, LOGITECH_G_PRO_WIRELESS_PID,                  2, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G733 Gaming Headset",                       DetectLogitechWired,        LOGITECH_VID, LOGITECH_G733_PID,                            2, 0xFF43, 514);
+REGISTER_HID_DETECTOR_IPU("Logitech G733 Gaming Headset",                       DetectLogitechWired,        LOGITECH_VID, LOGITECH_G733_PID,                            3, 0xFF43, 514);

Controllers/LogitechController/RGBController_LogitechG815.cpp

@@ -22,7 +22,7 @@ static unsigned int matrix_map[7][27] =
       { 112, NA,  49,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  NA,  41,  42,  38,  NA,  NA,  69,  70,  71,  NA,  79,  80,  81,  82  },
       { 113, NA,  39,  NA,  16,  22,  4,   17,  NA,  19,  24,  20,  8,   14,  15,  43,  44,  45,  NA,  72,  73,  74,  NA,  91,  92,  93,  83  },
       { 114, NA,  53,  NA,  0,   18,  3,   5,   NA,  6,   7,   9,   10,  11,  47,  48,  46,  36,  NA,  NA,  NA,  NA,  NA,  88,  89,  90,  NA  },
-      { 115, NA,  99,  NA,  25,  23,  2,   21,  NA,  1,   NA,  13,  12,  50,  51,  52,  103, NA,  NA,  NA,  78,  NA,  NA,  85,  86,  87,  84  },
+      { 115, NA,  99,  96,  25,  23,  2,   21,  NA,  1,   NA,  13,  12,  50,  51,  52,  103, NA,  NA,  NA,  78,  NA,  NA,  85,  86,  87,  84  },
       { 116, NA,  98,  101, 100, NA,  NA,  NA,  NA,  40,  NA,  NA,  NA,  NA,  104, 105, 97,  102, NA,  76,  77,  75,  NA,  94,  NA,  95,  NA  }  };
 
 static const char* zone_names[] =

Controllers/LogitechController/RGBController_LogitechLightspeed.cpp

@@ -181,7 +181,7 @@ void RGBController_LogitechLightspeed::UpdateZoneLEDs(int zone)
     /*---------------------------------------------------------*\
     | Workaround for G502 mode breathing / spectrum cycle swap  |
     \*---------------------------------------------------------*/
-    bool bright_cycle_swap  = (pid == 0xC08B || pid == 0xC332);
+    bool bright_cycle_swap  = (pid == 0xC08B || pid == 0xC332 || pid == 0x0AB5);
 
     /*---------------------------------------------------------*\
     | Replace direct mode with static when sending to controller|

Controllers/PNYGPUController/PNYGPUControllerDetect.cpp

@@ -44,7 +44,8 @@ static const gpu_pci_device device_list[] =
     { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         PALIT_SUB_VEN,  PALIT_RTX3080_SUB_DEV,                  PNY_RGB,    "Palit 3080"                        },
     { NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     PALIT_SUB_VEN,  PALIT_RTX3080_LHR_SUB_DEV,              PNY_RGB,    "Palit 3080 LHR"                    },
     { NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       PALIT_SUB_VEN,  PALIT_RTX3080TI_SUB_DEV,                PNY_RGB,    "Palit 3080Ti"                      },
-    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         PALIT_SUB_VEN,  PALIT_RTX3090_SUB_DEV,                  PNY_RGB,    "Palit 3090"                        }
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         PALIT_SUB_VEN,  PALIT_RTX3090_SUB_DEV,                  PNY_RGB,    "Palit 3090"                        },
+    { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,        NVIDIA_SUB_VEN, NVIDIA_RTX2080S_DEV,                    PNY_RGB,    "NVIDIA RTX2080S"                   },
 };
 
 /******************************************************************************************\

Controllers/RazerController/RazerController.cpp

@@ -62,6 +62,7 @@ RazerController::RazerController(hid_device* dev_handle, hid_device* dev_argb_ha
         case RAZER_BASE_STATION_V2_CHROMA_PID:
         case RAZER_MOUSE_BUNGEE_V3_CHROMA_PID:
         case RAZER_O11_DYNAMIC_PID:
+        case RAZER_VIPER_8KHZ_PID:
             dev_transaction_id = 0x1F;
             break;
 
@@ -143,6 +144,7 @@ RazerController::RazerController(hid_device* dev_handle, hid_device* dev_argb_ha
         case RAZER_HUNTSMAN_TE_PID:
         case RAZER_HUNTSMAN_V2_ANALOG_PID:
         case RAZER_HUNTSMAN_V2_TKL_PID:
+        case RAZER_HUNTSMAN_V2_PID:
         case RAZER_ORNATA_CHROMA_PID:
         case RAZER_ORNATA_CHROMA_V2_PID:
         case RAZER_CORE_PID:
@@ -239,6 +241,7 @@ RazerController::RazerController(hid_device* dev_handle, hid_device* dev_argb_ha
         case RAZER_HUNTSMAN_TE_PID:
         case RAZER_HUNTSMAN_V2_ANALOG_PID:
         case RAZER_HUNTSMAN_V2_TKL_PID:
+        case RAZER_HUNTSMAN_V2_PID:
         case RAZER_KRAKEN_KITTY_EDITION_PID:
         case RAZER_LANCEHEAD_TE_WIRED_PID:
         case RAZER_LANCEHEAD_2017_WIRED_PID:
@@ -260,6 +263,7 @@ RazerController::RazerController(hid_device* dev_handle, hid_device* dev_argb_ha
         case RAZER_SEIREN_EMOTE_PID:
         case RAZER_TARTARUS_V2_PID:
         case RAZER_TIAMAT_71_V2_PID:
+        case RAZER_VIPER_8KHZ_PID:
         case RAZER_VIPER_MINI_PID:
         case RAZER_VIPER_PID:
         case RAZER_VIPER_ULTIMATE_WIRED_PID:
@@ -500,6 +504,7 @@ bool RazerController::SupportsWave()
         case RAZER_HUNTSMAN_TE_PID:
         case RAZER_HUNTSMAN_V2_ANALOG_PID:
         case RAZER_HUNTSMAN_V2_TKL_PID:
+        case RAZER_HUNTSMAN_V2_PID:
         case RAZER_ORBWEAVER_CHROMA_PID:
         case RAZER_TARTARUS_V2_PID:
 

Controllers/RazerController/RazerControllerDetect.cpp

@@ -251,7 +251,7 @@ REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V3",                             Det
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V3 Pro (Wired)",                 DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V3_PRO_WIRED_PID,              0x02,   0x01,   0x02);
 // REGISTER_HID_DETECTOR_PU ("Razer Blackwidow V3 Pro (Bluetooth)",             DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V3_PRO_BLUETOOTH_PID,          0x01,   0x00);
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V3 Pro (Wireless)",              DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V3_PRO_WIRELESS_PID,           0x03,   0x0C,   0x01);
-REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V3 TKL",                         DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V3_TKL_PID,                    0x00,   0x01,   0x02);
+REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V3 TKL",                         DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V3_TKL_PID,                    0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V3 Mini (Wired)",                DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V3_MINI_WIRED_PID,             0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V3 Mini (Wireless)",             DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V3_MINI_WIRELESS_PID,          0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow X Chroma",                       DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_X_CHROMA_PID,                  0x02,   0x01,   0x02);
@@ -266,6 +266,7 @@ REGISTER_HID_DETECTOR_IPU("Razer Huntsman Mini",                             Det
 REGISTER_HID_DETECTOR_IPU("Razer Huntsman Tournament Edition",               DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_TE_PID,                          0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Huntsman V2 Analog",                        DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_V2_ANALOG_PID,                   0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Huntsman V2 TKL",                           DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_V2_TKL_PID,                      0x03,   0x0C,   0x01);
+REGISTER_HID_DETECTOR_IPU("Razer Huntsman V2",                               DetectRazerControllers,        RAZER_VID,  RAZER_HUNTSMAN_V2_PID,                          0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Ornata Chroma",                             DetectRazerControllers,        RAZER_VID,  RAZER_ORNATA_CHROMA_PID,                        0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Ornata Chroma V2",                          DetectRazerControllers,        RAZER_VID,  RAZER_ORNATA_CHROMA_V2_PID,                     0x02,   0x01,   0x02);
 
@@ -341,6 +342,7 @@ REGISTER_HID_DETECTOR_IPU("Razer Naga Left Handed",                          Det
 REGISTER_HID_DETECTOR_IPU("Razer Naga Hex V2",                               DetectRazerControllers,        RAZER_VID,  RAZER_NAGA_HEX_V2_PID,                          0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Naga Trinity",                              DetectRazerControllers,        RAZER_VID,  RAZER_NAGA_TRINITY_PID,                         0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Viper",                                     DetectRazerControllers,        RAZER_VID,  RAZER_VIPER_PID,                                0x00,   0x01,   0x02);
+REGISTER_HID_DETECTOR_IPU("Razer Viper 8kHz",                                DetectRazerControllers,        RAZER_VID,  RAZER_VIPER_8KHZ_PID,                           0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Viper Mini",                                DetectRazerControllers,        RAZER_VID,  RAZER_VIPER_MINI_PID,                           0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Viper Ultimate (Wired)",                    DetectRazerControllers,        RAZER_VID,  RAZER_VIPER_ULTIMATE_WIRED_PID,                 0x00,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Viper Ultimate (Wireless)",                 DetectRazerControllers,        RAZER_VID,  RAZER_VIPER_ULTIMATE_WIRELESS_PID,              0x00,   0x01,   0x02);
@@ -359,7 +361,8 @@ REGISTER_HID_DETECTOR_IPU("Razer Kraken 7.1",                                Det
 REGISTER_HID_DETECTOR_IPU("Razer Kraken 7.1",                                DetectRazerKrakenControllers,  RAZER_VID,  RAZER_KRAKEN_CLASSIC_ALT_PID,                   0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Kraken 7.1 Chroma",                         DetectRazerKrakenControllers,  RAZER_VID,  RAZER_KRAKEN_PID,                               0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Kraken 7.1 V2",                             DetectRazerKrakenControllers,  RAZER_VID,  RAZER_KRAKEN_V2_PID,                            0x03,   0x0C,   0x01);
-REGISTER_HID_DETECTOR_IPU("Razer Kraken Kitty Edition",                      DetectRazerControllers,        RAZER_VID,  RAZER_KRAKEN_KITTY_EDITION_PID,                 0x00,   0x01,   0x03);
+REGISTER_HID_DETECTOR_IPU("Razer Kraken Kitty Edition",                      DetectRazerControllers,        RAZER_VID,  RAZER_KRAKEN_KITTY_EDITION_PID,                 0x01,   0x01,   0x03);
+REGISTER_HID_DETECTOR_IPU("Razer Kraken Kitty Black Edition",                DetectRazerControllers,        RAZER_VID,  RAZER_KRAKEN_KITTY_BLACK_EDITION_PID,           0x01,   0x01,   0x03);
 REGISTER_HID_DETECTOR_IPU("Razer Kraken Ultimate",                           DetectRazerKrakenControllers,  RAZER_VID,  RAZER_KRAKEN_ULTIMATE_PID,                      0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_I(  "Razer Tiamat 7.1 V2",                             DetectRazerControllers,        RAZER_VID,  RAZER_TIAMAT_71_V2_PID,                         0x00                );
 

Controllers/RazerController/RazerDevices.h

@@ -76,6 +76,7 @@
 #define RAZER_HUNTSMAN_TE_PID                           0x0243
 #define RAZER_HUNTSMAN_V2_ANALOG_PID                    0x0266
 #define RAZER_HUNTSMAN_V2_TKL_PID                       0x026B
+#define RAZER_HUNTSMAN_V2_PID                           0x026C
 #define RAZER_ORBWEAVER_CHROMA_PID                      0x0207
 #define RAZER_ORNATA_CHROMA_PID                         0x021E
 #define RAZER_ORNATA_CHROMA_V2_PID                      0x025D
@@ -142,6 +143,7 @@
 #define RAZER_OROCHI_CHROMA_PID                         0x0048
 #define RAZER_OUROBOROS_PID                             0x0032
 #define RAZER_TAIPAN_PID                                0x0034
+#define RAZER_VIPER_8KHZ_PID                            0x0091
 #define RAZER_VIPER_MINI_PID                            0x008A
 #define RAZER_VIPER_PID                                 0x0078
 #define RAZER_VIPER_ULTIMATE_WIRED_PID                  0x007A
@@ -153,6 +155,7 @@
 #define RAZER_KRAKEN_CLASSIC_ALT_PID                    0x0506
 #define RAZER_KRAKEN_CLASSIC_PID                        0x0501
 #define RAZER_KRAKEN_KITTY_EDITION_PID                  0x0F19
+#define RAZER_KRAKEN_KITTY_BLACK_EDITION_PID            0x0F21
 #define RAZER_KRAKEN_PID                                0x0504
 #define RAZER_KRAKEN_ULTIMATE_PID                       0x0527
 #define RAZER_KRAKEN_V2_PID                             0x0510
@@ -781,6 +784,96 @@ static const razer_key blade_14_2021_keymap[] =
     {   0,      5,      15,             "Key: Down Arrow"                   },
 };
 
+#define BLADE_17_PRO_2021_KEYMAP_SIZE (sizeof(blade_17_pro_2021_keymap) / sizeof(blade_17_pro_2021_keymap[0]))
+
+static const razer_key blade_17_pro_2021_keymap[] =
+{
+    /*---------------------------------------------------------------------*\
+    |   Zone,   Row,    Column,         Key                                 |
+    \*---------------------------------------------------------------------*/
+    {   0,      0,      1,              "Key: Escape"                       },
+    {   0,      0,      2,              "Key: F1"                           },
+    {   0,      0,      3,              "Key: F2"                           },
+    {   0,      0,      4,              "Key: F3"                           },
+    {   0,      0,      5,              "Key: F4"                           },
+    {   0,      0,      6,              "Key: F5"                           },
+    {   0,      0,      7,              "Key: F6"                           },
+    {   0,      0,      8,              "Key: F7"                           },
+    {   0,      0,      9,              "Key: F8"                           },
+    {   0,      0,      10,             "Key: F9"                           },
+    {   0,      0,      11,             "Key: F10"                          },
+    {   0,      0,      12,             "Key: F11"                          },
+    {   0,      0,      13,             "Key: F12"                          },
+    {   0,      0,      14,             "Key: Insert"                       },
+    {   0,      0,      15,             "Key: Delete"                       },
+    {   0,      1,      1,              "Key: `"                            },
+    {   0,      1,      2,              "Key: 1"                            },
+    {   0,      1,      3,              "Key: 2"                            },
+    {   0,      1,      4,              "Key: 3"                            },
+    {   0,      1,      5,              "Key: 4"                            },
+    {   0,      1,      6,              "Key: 5"                            },
+    {   0,      1,      7,              "Key: 6"                            },
+    {   0,      1,      8,              "Key: 7"                            },
+    {   0,      1,      9,              "Key: 8"                            },
+    {   0,      1,      10,             "Key: 9"                            },
+    {   0,      1,      11,             "Key: 0"                            },
+    {   0,      1,      12,             "Key: -"                            },
+    {   0,      1,      13,             "Key: ="                            },
+    {   0,      1,      15,             "Key: Backspace"                    },
+    {   0,      2,      1,              "Key: Tab"                          },
+    {   0,      2,      2,              "Key: Q"                            },
+    {   0,      2,      3,              "Key: W"                            },
+    {   0,      2,      4,              "Key: E"                            },
+    {   0,      2,      5,              "Key: R"                            },
+    {   0,      2,      6,              "Key: T"                            },
+    {   0,      2,      7,              "Key: Y"                            },
+    {   0,      2,      8,              "Key: U"                            },
+    {   0,      2,      9,              "Key: I"                            },
+    {   0,      2,      10,             "Key: O"                            },
+    {   0,      2,      11,             "Key: P"                            },
+    {   0,      2,      12,             "Key: ["                            },
+    {   0,      2,      13,             "Key: ]"                            },
+    {   0,      2,      14,             "Key: Enter"                        },
+    {   0,      2,      15,             "Key: \\ (ANSI)"                    },
+    {   0,      3,      1,              "Key: Caps Lock"                    },
+    {   0,      3,      2,              "Key: A"                            },
+    {   0,      3,      3,              "Key: S"                            },
+    {   0,      3,      4,              "Key: D"                            },
+    {   0,      3,      5,              "Key: F"                            },
+    {   0,      3,      6,              "Key: G"                            },
+    {   0,      3,      7,              "Key: H"                            },
+    {   0,      3,      8,              "Key: J"                            },
+    {   0,      3,      9,              "Key: K"                            },
+    {   0,      3,      10,             "Key: L"                            },
+    {   0,      3,      11,             "Key: ;"                            },
+    {   0,      3,      12,             "Key: '"                            },
+    {   0,      3,      13,             "Key: #"                            },
+    {   0,      4,      1,              "Key: Left Shift"                   },
+    {   0,      4,      2,              "Key: \\ (ISO)"                     },
+    {   0,      4,      3,              "Key: Z"                            },
+    {   0,      4,      4,              "Key: X"                            },
+    {   0,      4,      5,              "Key: C"                            },
+    {   0,      4,      6,              "Key: V"                            },
+    {   0,      4,      7,              "Key: B"                            },
+    {   0,      4,      8,              "Key: N"                            },
+    {   0,      4,      9,              "Key: M"                            },
+    {   0,      4,      10,             "Key: ,"                            },
+    {   0,      4,      11,             "Key: ."                            },
+    {   0,      4,      12,             "Key: /"                            },
+    {   0,      4,      15,             "Key: Right Shift"                  },
+    {   0,      5,      1,              "Key: Left Control"                 },
+    {   0,      5,      2,              "Key: Left Fn"                      },
+    {   0,      5,      3,              "Key: Left Windows"                 },
+    {   0,      5,      5,              "Key: Left Alt"                     },
+    {   0,      5,      9,              "Key: Right Alt"                    },
+    {   0,      5,      10,             "Key: Right Fn"                     },
+    {   0,      5,      11,             "Key: Right Control"                },
+    {   0,      5,      12,             "Key: Left Arrow"                   },
+    {   0,      5,      13,             "Key: Up Arrow"                     },
+    {   0,      5,      14,             "Key: Right Arrow"                  },
+    {   0,      5,      15,             "Key: Down Arrow"                   },
+};
+
 #define BLADE_PRO_2017_KEYMAP_SIZE (sizeof(blade_pro_2017_keymap) / sizeof(blade_pro_2017_keymap[0]))
 
 static const razer_key blade_pro_2017_keymap[] =
@@ -1610,6 +1703,125 @@ static const razer_key huntsman_te_keymap[] =
     {   0,      5,      17,             "Key: Right Arrow"                  },
 };
 
+#define HUNTSMAN_V2_KEYMAP_SIZE (sizeof(huntsman_v2_keymap) / sizeof(huntsman_v2_keymap[0]))
+
+static const razer_key huntsman_v2_keymap[] =
+{
+    /*---------------------------------------------------------------------*\
+    |   Zone,   Row,    Column,         Key                                 |
+    \*---------------------------------------------------------------------*/
+    {   0,      0,      0,              "Key: Escape"                       },
+    {   0,      0,      2,              "Key: F1"                           },
+    {   0,      0,      3,              "Key: F2"                           },
+    {   0,      0,      4,              "Key: F3"                           },
+    {   0,      0,      5,              "Key: F4"                           },
+    {   0,      0,      6,              "Key: F5"                           },
+    {   0,      0,      7,              "Key: F6"                           },
+    {   0,      0,      8,              "Key: F7"                           },
+    {   0,      0,      9,              "Key: F8"                           },
+    {   0,      0,      10,             "Key: F9"                           },
+    {   0,      0,      11,             "Key: F10"                          },
+    {   0,      0,      12,             "Key: F11"                          },
+    {   0,      0,      13,             "Key: F12"                          },
+    {   0,      0,      14,             "Key: Print Screen"                 },
+    {   0,      0,      15,             "Key: Scroll Lock"                  },
+    {   0,      0,      16,             "Key: Pause/Break"                  },
+    {   0,      0,      17,             "Key: Media Previous"               },
+    {   0,      0,      18,             "Key: Media Play/Pause"             },
+    {   0,      0,      19,             "Key: Media Next"                   },
+    {   0,      0,      20,             "Key: Media Mute"                   },
+    {   0,      1,      0,              "Key: `"                            },
+    {   0,      1,      1,              "Key: 1"                            },
+    {   0,      1,      2,              "Key: 2"                            },
+    {   0,      1,      3,              "Key: 3"                            },
+    {   0,      1,      4,              "Key: 4"                            },
+    {   0,      1,      5,              "Key: 5"                            },
+    {   0,      1,      6,              "Key: 6"                            },
+    {   0,      1,      7,              "Key: 7"                            },
+    {   0,      1,      8,              "Key: 8"                            },
+    {   0,      1,      9,              "Key: 9"                            },
+    {   0,      1,      10,             "Key: 0"                            },
+    {   0,      1,      11,             "Key: -"                            },
+    {   0,      1,      12,             "Key: ="                            },
+    {   0,      1,      13,             "Key: Backspace"                    },
+    {   0,      1,      14,             "Key: Insert"                       },
+    {   0,      1,      15,             "Key: Home"                         },
+    {   0,      1,      16,             "Key: Page Up"                      },
+    {   0,      1,      17,             "Key: Num Lock"                     },
+    {   0,      1,      18,             "Key: Number Pad /"                 },
+    {   0,      1,      19,             "Key: Number Pad *"                 },
+    {   0,      1,      20,             "Key: Number Pad -"                 },
+    {   0,      2,      0,              "Key: Tab"                          },
+    {   0,      2,      1,              "Key: Q"                            },
+    {   0,      2,      2,              "Key: W"                            },
+    {   0,      2,      3,              "Key: E"                            },
+    {   0,      2,      4,              "Key: R"                            },
+    {   0,      2,      5,              "Key: T"                            },
+    {   0,      2,      6,              "Key: Y"                            },
+    {   0,      2,      7,              "Key: U"                            },
+    {   0,      2,      8,              "Key: I"                            },
+    {   0,      2,      9,              "Key: O"                            },
+    {   0,      2,      10,             "Key: P"                            },
+    {   0,      2,      11,             "Key: ["                            },
+    {   0,      2,      12,             "Key: ]"                            },
+    {   0,      2,      13,             "Key: \\ (ANSI)"                    },
+    {   0,      2,      14,             "Key: Delete"                       },
+    {   0,      2,      15,             "Key: End"                          },
+    {   0,      2,      16,             "Key: Page Down"                    },
+    {   0,      2,      17,             "Key: Number Pad 7"                 },
+    {   0,      2,      18,             "Key: Number Pad 8"                 },
+    {   0,      2,      19,             "Key: Number Pad 9"                 },
+    {   0,      2,      20,             "Key: Number Pad +"                 },
+    {   0,      3,      0,              "Key: Caps Lock"                    },
+    {   0,      3,      1,              "Key: A"                            },
+    {   0,      3,      2,              "Key: S"                            },
+    {   0,      3,      3,              "Key: D"                            },
+    {   0,      3,      4,              "Key: F"                            },
+    {   0,      3,      5,              "Key: G"                            },
+    {   0,      3,      6,              "Key: H"                            },
+    {   0,      3,      7,              "Key: J"                            },
+    {   0,      3,      8,              "Key: K"                            },
+    {   0,      3,      9,              "Key: L"                            },
+    {   0,      3,      10,             "Key: ;"                            },
+    {   0,      3,      11,             "Key: '"                            },
+    {   0,      3,      12,             "Key: #"                            },
+    {   0,      3,      13,             "Key: Enter"                        },
+    {   0,      3,      17,             "Key: Number Pad 4"                 },
+    {   0,      3,      18,             "Key: Number Pad 5"                 },
+    {   0,      3,      19,             "Key: Number Pad 6"                 },
+    {   0,      4,      0,              "Key: Left Shift"                   },
+    {   0,      4,      1,              "Key: \\ (ISO)"                     },
+    {   0,      4,      2,              "Key: Z"                            },
+    {   0,      4,      3,              "Key: X"                            },
+    {   0,      4,      4,              "Key: C"                            },
+    {   0,      4,      5,              "Key: V"                            },
+    {   0,      4,      6,              "Key: B"                            },
+    {   0,      4,      7,              "Key: N"                            },
+    {   0,      4,      8,              "Key: M"                            },
+    {   0,      4,      9,              "Key: ,"                            },
+    {   0,      4,      10,             "Key: ."                            },
+    {   0,      4,      11,             "Key: /"                            },
+    {   0,      4,      13,             "Key: Right Shift"                  },
+    {   0,      4,      15,             "Key: Up Arrow"                     },
+    {   0,      4,      17,             "Key: Number Pad 1"                 },
+    {   0,      4,      18,             "Key: Number Pad 2"                 },
+    {   0,      4,      19,             "Key: Number Pad 3"                 },
+    {   0,      4,      20,             "Key: Number Pad Enter"             },
+    {   0,      5,      0,              "Key: Left Control"                 },
+    {   0,      5,      1,              "Key: Left Windows"                 },
+    {   0,      5,      2,              "Key: Left Alt"                     },
+    {   0,      5,      6,              "Key: Space"                        },
+    {   0,      5,      10,             "Key: Right Alt"                    },
+    {   0,      5,      11,             "Key: Right Fn"                     },
+    {   0,      5,      12,             "Key: Menu"                         },
+    {   0,      5,      13,             "Key: Right Control"                },
+    {   0,      5,      14,             "Key: Left Arrow"                   },
+    {   0,      5,      15,             "Key: Down Arrow"                   },
+    {   0,      5,      16,             "Key: Right Arrow"                  },
+    {   0,      5,      18,             "Key: Number Pad 0"                 },
+    {   0,      5,      19,             "Key: Number Pad ."                 },
+};
+
 #define HUNTSMAN_V2_TKL_KEYMAP_SIZE (sizeof(huntsman_v2_tkl_keymap) / sizeof(huntsman_v2_tkl_keymap[0]))
 
 static const razer_key huntsman_v2_tkl_keymap[] =
@@ -3253,6 +3465,41 @@ static const razer_device huntsman_v2_tkl_device =
     HUNTSMAN_V2_TKL_KEYMAP_SIZE
 };
 
+/*-------------------------------------------------------------*\
+|  Razer Huntsman V2 1532:026C                                  |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       6 Rows, 22 Columns                                      |
+\*-------------------------------------------------------------*/
+static const razer_zone huntsman_v2_keyboard_zone =
+{
+    "Keyboard",
+    ZONE_TYPE_MATRIX,
+    6,
+    22
+};
+
+static const razer_device huntsman_v2_device =
+{
+    "Razer Huntsman V2",
+    RAZER_HUNTSMAN_V2_PID,
+    DEVICE_TYPE_KEYBOARD,
+    true,
+    9,
+    22,
+    {
+        &huntsman_v2_keyboard_zone,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL
+    },
+    huntsman_v2_keymap,
+    HUNTSMAN_V2_KEYMAP_SIZE
+};
+
 /*-------------------------------------------------------------------------*\
 |  LAPTOPS                                                                  |
 \*-------------------------------------------------------------------------*/
@@ -4058,8 +4305,8 @@ static const razer_device blade_pro_17_2021_device =
         NULL,
         NULL
     },
-    NULL,
-    0
+    blade_17_pro_2021_keymap,
+    BLADE_17_PRO_2021_KEYMAP_SIZE
 };
 
 /*-------------------------------------------------------------*\
@@ -6021,6 +6268,41 @@ static const razer_device naga_trinity_device =
     0
 };
 
+/*-------------------------------------------------------------*\
+|  Razer Viper 8kHz 1532:0091                                   |
+|                                                               |
+|  Zone "Logo"                                                  |
+|       Matrix                                                  |
+|       1 LED                                                   |
+\*-------------------------------------------------------------*/
+static const razer_zone viper_8khz_logo_zone =
+{
+    "Logo",
+    ZONE_TYPE_SINGLE,
+    1,
+    1
+};
+
+static const razer_device viper_8khz_device =
+{
+    "Razer Viper 8kHz",
+    RAZER_VIPER_8KHZ_PID,
+    DEVICE_TYPE_MOUSE,
+    true,
+    1,
+    1,
+    {
+        &viper_8khz_logo_zone,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL
+    },
+    NULL,
+    0
+};
+
 /*-------------------------------------------------------------*\
 |  Razer Viper Mini 1532:008A                                   |
 |                                                               |
@@ -7497,6 +7779,7 @@ static const razer_device* device_list[] =
     &naga_hex_v2_device,
     &naga_left_handed_device,
     &naga_trinity_device,
+    &viper_8khz_device,
     &viper_mini_device,
     &viper_ultimate_wired_device,
     &viper_ultimate_wireless_device,

Controllers/SteelSeriesController/RGBController_SteelSeriesRival.cpp

@@ -45,18 +45,19 @@ RGBController_SteelSeriesRival::RGBController_SteelSeriesRival(SteelSeriesRivalC
     description = "SteelSeries Rival Device";
     location    = rival->GetDeviceLocation();
     serial      = rival->GetSerialString();
+    version     = rival->GetFirmwareVersion();
 
     mode Direct;
     Direct.name       = "Direct";
     Direct.value      = STEELSERIES_RIVAL_DIRECT;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
     Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Pulsate;
     Pulsate.name       = "Pulsate";
     Pulsate.value      = STEELSERIES_RIVAL_PULSATE;
-    Pulsate.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Pulsate.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
     Pulsate.color_mode = MODE_COLORS_PER_LED;
     Pulsate.speed_min  = STEELSERIES_RIVAL_EFFECT_PULSATE_MIN;
     Pulsate.speed_max  = STEELSERIES_RIVAL_EFFECT_PULSATE_MAX;
@@ -243,3 +244,9 @@ void RGBController_SteelSeriesRival::DeviceUpdateMode()
 
     DeviceUpdateLEDs();
 }
+
+void RGBController_SteelSeriesRival::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    rival->SaveMode();
+}

Controllers/SteelSeriesController/RGBController_SteelSeriesRival.h

@@ -28,6 +28,7 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
     SteelSeriesRivalController*     rival;

Controllers/SteelSeriesController/SteelSeriesRivalController.cpp

@@ -70,13 +70,28 @@ std::string SteelSeriesRivalController::GetSerialString()
     return(return_string);
 }
 
+std::string SteelSeriesRivalController::GetFirmwareVersion()
+{
+    if (proto != RIVAL_300 && proto != RIVAL_700) return "";
+
+    char            usb_buf[2] = { 0x10, 0x00 };
+    uint16_t        version;
+    std::string     return_string;
+
+    send_usb_msg(dev, usb_buf, 2);
+    hid_read(dev, (unsigned char *)&version, 2);
+
+    return_string = std::to_string(version);
+    return return_string;
+}
+
 steelseries_type SteelSeriesRivalController::GetMouseType()
 {
     return proto;
 }
 
 /* Saves to the internal configuration */
-void SteelSeriesRivalController::Save()
+void SteelSeriesRivalController::SaveMode()
 {
     char usb_buf[9];
     memset(usb_buf, 0x00, sizeof(usb_buf));
@@ -253,61 +268,32 @@ void SteelSeriesRivalController::SetRival700Color
     unsigned char   blue
     )
 {
-    char usb_buf[0xA5];
+    const uint16_t REPORT_SIZE = 578;
 
+    uint8_t usb_buf[REPORT_SIZE];
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
-    usb_buf[0x00]       = 0x05;
-    usb_buf[0x02]       = zone_id;
+    usb_buf[0x00] = 0x05;
+    usb_buf[0x02] = zone_id;
 
-    usb_buf[0x03]       = 0x1D;
-    usb_buf[0x04]       = 0x01;
-    usb_buf[0x05]       = 0x02;
-    usb_buf[0x06]       = 0x31;
-    usb_buf[0x07]       = 0x51;
-    usb_buf[0x08]       = 0xFF;
-    usb_buf[0x09]       = 0xC8;
+    usb_buf[0x03] = red;
+    usb_buf[0x04] = green;
+    usb_buf[0x05] = blue;
 
-    // 128 bytes of unused color fields
+    usb_buf[0x0b] = zone_id;
+    usb_buf[0x0c] = 0x01;
 
-    // Static color value
-    unsigned short color_value;
-    color_value = ((unsigned short) red) << 4;
-    usb_buf[0x8D]       = (unsigned char)(color_value & 0xFF);
-    usb_buf[0x8E]       = (unsigned char)(color_value >> 8);
-    color_value = ((unsigned short) green) << 4;
-    usb_buf[0x8F]       = (unsigned char)(color_value & 0xFF);
-    usb_buf[0x90]       = (unsigned char)(color_value >> 8);
-    color_value = ((unsigned short) blue) << 4;
-    usb_buf[0x91]       = (unsigned char)(color_value & 0xFF);
-    usb_buf[0x92]       = (unsigned char)(color_value >> 8);
+    char *usb_pkt = new char[REPORT_SIZE + 1];
 
-    usb_buf[0x93]       = 0xFF;
-    usb_buf[0x95]       = 0xDC;  // magic value: 1500
-    usb_buf[0x96]       = 0x05;
-    usb_buf[0x97]       = 0x8A;  // magic value: 650
-    usb_buf[0x98]       = 0x02;
-    usb_buf[0x9D]       = 0x01;
-
-    // 0x9F and 0xA0 = number of colors in sequence - 1 = 0
-
-    usb_buf[0xA1]       = 0xE8;  // Default duration: 1000 ms
-    usb_buf[0xA2]       = 0x03;
-
-    const int pkt_len = 0xA3 + 1;
-    unsigned char* usb_pkt = new unsigned char[pkt_len];
     usb_pkt[0] = 0x00;
-    for(unsigned int i = 1; i < pkt_len; i++)
+    for (unsigned int i = 1; i < REPORT_SIZE + 1; i++)
     {
-        usb_pkt[i] = usb_buf[i-1];
+        usb_pkt[i] = usb_buf[i - 1];
     }
 
-//    hid_write(dev, (unsigned char *)usb_pkt, pkt_len);
-    hid_send_feature_report(dev, (unsigned char *)usb_pkt, pkt_len);
+    hid_send_feature_report(dev, (unsigned char *)usb_pkt, REPORT_SIZE + 1);
 
-    usb_buf[0x00]       = 0x09;
-    usb_buf[0x01]       = 0x00;
-    send_usb_msg(dev, usb_buf, 0x02);
+    delete[] usb_pkt;
 }
 
 void SteelSeriesRivalController::SetColor

Controllers/SteelSeriesController/SteelSeriesRivalController.h

@@ -45,10 +45,11 @@ public:
     std::string GetDeviceLocation();
     char*       GetDeviceName();
     std::string GetSerialString();
+    std::string GetFirmwareVersion();
 
     steelseries_type GetMouseType();
 
-    void Save();
+    void SaveMode();
 
     void SetLightEffect
             (

OpenRGB.pro

@@ -32,7 +32,7 @@ greaterThan(QT_MAJOR_VERSION, 4) {
 #-----------------------------------------------------------------------------------------------#
 # Application Configuration                                                                     #
 #-----------------------------------------------------------------------------------------------#
-VERSION     = 0.7
+VERSION     = 0.71
 TARGET      = OpenRGB
 TEMPLATE    = app
 
@@ -231,6 +231,7 @@ HEADERS +=
     Controllers/AsusAuraUSBController/AsusAuraKeyboardController.h                              \
     Controllers/AsusAuraUSBController/AsusAuraMainboardController.h                             \
     Controllers/AsusAuraUSBController/AsusAuraMouseController.h                                 \
+    Controllers/AsusAuraUSBController/AsusAuraMousematController.h                              \
     Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h                                    \
     Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.h                           \
     Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h                           \
@@ -238,6 +239,7 @@ HEADERS +=
     Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.h                      \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.h                          \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.h                             \
+    Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.h                          \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h                       \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h                       \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.h                               \
@@ -268,9 +270,11 @@ HEADERS +=
     Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h                   \
     Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.h               \
     Controllers/CorsairPeripheralController/CorsairPeripheralController.h                       \
-    Controllers/CorsairPeripheralController/CorsairK100Controller.h                             \
+    Controllers/CorsairPeripheralController/CorsairK100Controller.h                             \    
+    Controllers/CorsairPeripheralController/CorsairK55RGBPROController.h                        \
     Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.h                   \
     Controllers/CorsairPeripheralController/RGBController_CorsairK100.h                         \
+    Controllers/CorsairPeripheralController/RGBController_CorsairK55RGBPRO.h                    \
     Controllers/CorsairVengeanceController/CorsairVengeanceController.h                         \
     Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.h                     \
     Controllers/CorsairVengeanceProController/CorsairVengeanceProController.h                   \
@@ -603,12 +607,14 @@ SOURCES +=
     Controllers/AsusAuraUSBController/AsusAuraKeyboardController.cpp                            \
     Controllers/AsusAuraUSBController/AsusAuraMainboardController.cpp                           \
     Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp                               \
+    Controllers/AsusAuraUSBController/AsusAuraMousematController.cpp                            \
     Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.cpp                         \
     Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp                         \
     Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp                           \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp                    \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp                        \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp                           \
+    Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.cpp                        \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp                     \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp                     \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp                             \
@@ -648,8 +654,10 @@ SOURCES +=
     Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp                     \
     Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp               \
     Controllers/CorsairPeripheralController/CorsairK100Controller.cpp                           \
+    Controllers/CorsairPeripheralController/CorsairK55RGBPROController.cpp                      \
     Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.cpp                 \
     Controllers/CorsairPeripheralController/RGBController_CorsairK100.cpp                       \
+    Controllers/CorsairPeripheralController/RGBController_CorsairK55RGBPRO.cpp                  \
     Controllers/CorsairVengeanceController/CorsairVengeanceController.cpp                       \
     Controllers/CorsairVengeanceController/CorsairVengeanceControllerDetect.cpp                 \
     Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.cpp                   \

README.md

@@ -172,6 +172,7 @@ There have been two instances of hardware damage in OpenRGB's development and we
   * OpenRGB-Client - Java Client (by morg): https://gitlab.com/mguimard/openrgb-client
   * OpenRGB-SDK - NodeJS client (by Mola19): https://www.npmjs.com/package/openrgb-sdk
   * OpenRGB-cppSDK - C++ client (by Youda008): https://github.com/Youda008/OpenRGB-cppSDK
+  * openrgb-rs - Rust client (by nicoulaj): https://github.com/nicoulaj/openrgb-rs
 
 ## Applications Supporting OpenRGB SDK
 
@@ -197,6 +198,7 @@ There have been two instances of hardware damage in OpenRGB's development and we
   * Skin Plugin (by morg): https://gitlab.com/OpenRGBDevelopers/openrgbskinplugin 
   * Hardware Sync Plugin (by morg): https://gitlab.com/OpenRGBDevelopers/OpenRGBHardwareSyncPlugin
   * Http Hook Plugin (by morg): https://gitlab.com/OpenRGBDevelopers/OpenRGBHttpHookPlugin
+  * Razer extras Plugin (by morg): https://gitlab.com/OpenRGBDevelopers/OpenRGBRazerExtrasPlugin
   
 ## Projects Used
 

debian/changelog

@@ -1,4 +1,4 @@
-openrgb (0.7.0) UNRELEASED; urgency=medium
+openrgb (0.71.1) UNRELEASED; urgency=medium
 
   * Builds from git master.  See git history for more information.
 

fedora/OpenRGB.spec

@@ -1,7 +1,7 @@
 %global _name OpenRGB
 
 Name:           openrgb
-Version:        0.7
+Version:        0.7.1
 Release:        0%{?dist}
 Summary:        Open source RGB lighting control that doesn't depend on manufacturer software
 
@@ -47,6 +47,9 @@ fi
 %doc README.md
 
 %changelog
+* Thu Dec 30 2021 Adam Honse <[email protected]> - 0.7.1-0
+- Updated to 0.7.1
+
 * Thu Dec 30 2021 Adam Honse <[email protected]> - 0.7-0
 - Updated to 0.7
 

i2c_smbus/i2c_smbus_linux.cpp

@@ -133,7 +133,7 @@ bool i2c_smbus_linux_detect()
                     strcat(path, ent->d_name);
                     if(ent->d_type == DT_LNK)
                     {
-                        ptr = canonicalize_file_name(path);
+                        ptr = realpath(path, NULL);
                         if(ptr == NULL)
                             continue;
 

pci_ids/pci_ids.h

@@ -19,6 +19,7 @@
 | names here instead of referring to specific products. |
 \*-----------------------------------------------------*/
 #define AMD_POLARIS_DEV                                 0x67DF
+#define AMD_POLARIS11                                   0x67FF
 #define AMD_POLARIS20XL_DEV                             0x6FDF
 #define AMD_VEGA10_DEV                                  0x687F
 #define AMD_NAVI10_DEV                                  0x731F
@@ -100,6 +101,14 @@
 /*-----------------------------------------------------*\
 | ASUS Sub-Device IDs                                   |
 \*-----------------------------------------------------*/
+#define ASUS_VEGA64_STRIX                               0x04C4
+#define ASUS_RX5600XT_STRIX_O6G_GAMING                  0x04EC
+#define ASUS_RX5700XT_STRIX_GAMING_OC                   0x04E2
+#define ASUS_RX480_STRIX_GAMING_OC                      0x04FB
+#define ASUS_RX560_STRIX_4G_GAMING                      0x04BC
+#define ASUS_RX570_STRIX_O4G_GAMING_OC                  0x04C2
+#define ASUS_RX580_STRIX_GAMING_OC                      0x0517
+#define ASUS_RX580_STRIX_GAMING_TOP                     0x0519
 #define ASUS_GTX1050_STRIX_O2G_GAMING                   0x85D8
 #define ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING             0x85CD
 #define ASUS_GTX1060_STRIX_6G_GAMING                    0x85A4
@@ -118,7 +127,10 @@
 #define ASUS_ROG_STRIX_GTX1660S_O6G_GAMING              0x8752
 #define ASUS_ROG_GTX1660TI_OC                           0x86A5
 #define ASUS_ROG_STRIX_RTX2060_EVO_GAMING               0x86D3
+#define ASUS_ROG_STRIX_RTX2060_O6G_GAMING               0x868E
+#define ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING           0x8775
 #define ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING          0x8703
+#define ASUS_ROG_STRIX_RTX2060S_8G_GAMING               0x8730
 #define ASUS_ROG_STRIX_RTX2060S_O8G_GAMING              0x86FB
 #define ASUS_ROG_STRIX_RTX2070_A8G_GAMING               0x8671
 #define ASUS_ROG_STRIX_RTX2070_O8G_GAMING               0x8670
@@ -130,13 +142,6 @@
 #define ASUS_ROG_STRIX_RTX2080S_O8G_GAMING              0x8711
 #define ASUS_ROG_STRIX_RTX2080TI_11G_GAMING             0x8687
 #define ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING            0x866A
-#define ASUS_VEGA64_STRIX                               0x04C4
-#define ASUS_RX5600XT_STRIX_O6G_GAMING                  0x04EC
-#define ASUS_RX5700XT_STRIX_GAMING_OC                   0x04E2
-#define ASUS_RX480_STRIX_GAMING_OC                      0x04FB
-#define ASUS_RX570_STRIX_O4G_GAMING_OC                  0x04C2
-#define ASUS_RX580_STRIX_GAMING_OC                      0x0517
-#define ASUS_RX580_STRIX_GAMING_TOP                     0x0519
 #define ASUS_ROG_STRIX_RTX_3060_O12G_GAMING             0x87F3
 #define ASUS_TUF_RTX_3060_TI_O8G_OC                     0x87C6
 #define ASUS_ROG_STRIX_RTX_3070_OC                      0x87B8
@@ -144,6 +149,7 @@
 #define ASUS_ROG_STRIX_RTX_3070_08G_V2_GAMING           0x882C
 #define ASUS_TUF_RTX_3070_O8G_GAMING                    0x87C1
 #define ASUS_TUF_RTX_3070_O8G_V2_GAMING                 0x8825
+#define ASUS_ROG_STRIX_RTX_3070TI_O8G_GAMING            0x880E
 #define ASUS_ROG_STRIX_RTX_3080_O10G_GAMING             0x87AC
 #define ASUS_ROG_STRIX_RTX_3080_O10G_WHITE              0x87D1
 #define ASUS_ROG_STRIX_RTX_3080_O10G_V2_WHITE           0x8830
@@ -152,12 +158,13 @@
 #define ASUS_TUF_RTX_3080_O10G_V2_GAMING_8822           0x8822
 #define ASUS_TUF_RTX_3080_O10G_V2_GAMING                0x8823
 #define ASUS_ROG_STRIX_RTX_3080TI_O12G_GAMING           0x8807
-#define ASUS_ROG_STRIX_RTX_3070TI_O8G_GAMING            0x880E
+#define ASUS_ROG_STRIX_RTX_3090_24G_GAMING              0x87AD
 #define ASUS_ROG_STRIX_RTX_3090_O24G_GAMING             0x87AF
 #define ASUS_ROG_STRIX_RTX_3090_O24G_GAMING_WHITE       0x87D9
 #define ASUS_TUF_RTX_3090_O24G                          0x87B5
 #define ASUS_TUF_RTX_3090_O24G_OC                       0x87B3
 
+
 /*-----------------------------------------------------*\
 | EVGA Sub-Device IDs                                   |
 \*-----------------------------------------------------*/
@@ -180,7 +187,9 @@
 #define EVGA_RTX2080_XC_GAMING_SUB_DEV                  0x2182
 #define EVGA_RTX2080_XC_ULTRA_GAMING_SUB_DEV            0x2183
 #define EVGA_RTX2080S_XC_GAMING_SUB_DEV                 0x3182
+#define EVGA_RTX2080S_XC_ULTRA_SUB_DEV                  0x3183
 #define EVGA_RTX2080S_FTW3_ULTRA_SUB_DEV                0x3287
+#define EVGA_RTX2080S_FTW3_HYBRID_OC_SUB_DEV            0x3288
 #define EVGA_RTX2080S_FTW3_ULTRA_HC_SUB_DEV             0x3289
 #define EVGA_RTX2080TI_BLACK_SUB_DEV                    0x2281
 #define EVGA_RTX2080TI_XC_ULTRA_GAMING_SUB_DEV          0x2383
@@ -278,6 +287,7 @@
 #define GIGABYTE_RTX2070S_GAMING_OC_3X_WHITE_SUB_DEV    0x400D
 #define GIGABYTE_RTX2080_A_GAMING_OC_SUB_DEV            0x37A7
 #define GIGABYTE_RTX2080_GAMING_OC_SUB_DEV              0x37D6
+#define GIGABYTE_AORUS_RTX2080_SUB_DEV                  0x37B2
 #define GIGABYTE_RTX2080S_GAMING_OC_SUB_DEV             0x3FE9
 #define GIGABYTE_RTX3060_GAMING_OC_12GB_SUB_DEV         0x4074
 #define GIGABYTE_RTX3060_ELITE_12GB_SUB_DEV	            0x407B
@@ -286,6 +296,7 @@
 #define GIGABYTE_RTX3060TI_GAMING_OC_PRO_SUB_DEV        0x405E
 #define GIGABYTE_RTX3070_GAMING_OC_SUB_DEV              0x404C
 #define GIGABYTE_RTX3070_VISION_OC_SUB_DEV              0x404D
+#define GIGABYTE_RTX3070_EAGLE_OC_SUB_DEV               0x404E
 #define GIGABYTE_RTX3070_MASTER_OC_SUB_DEV              0x4069
 #define GIGABYTE_RTX3070TI_GAMING_OC_SUB_DEV            0x408F
 #define GIGABYTE_RTX3070TI_EAGLE_SUB_DEV                0x408C

qt/DeviceView.cpp

@@ -93,6 +93,7 @@ static const std::map<std::string, led_label> led_label_lookup =
     { "Key: \\ (ISO)",          { "\\"    , "\\",              }},
     { "Key: ;",                 { ";"     , ";",               }},
     { "Key: '",                 { "'"     , "'",               }},
+    { "Key: #",                 { "#"     , "#",               }},
     { "Key: ,",                 { ","     , ",",               }},
     { "Key: .",                 { "."     , ".",               }},
     { "Key: /",                 { "/"     , "/",               }},

qt/TabLabel.cpp

@@ -8,14 +8,6 @@ Ui::TabLabel::TabLabel(QString icon, QString name) :
     ui->setupUi(this);
     ui->icon->setText("<img src=':/" + icon + "' height='16' width='16'  />");
     ui->name->setText(name);
-
-    /*---------------------------------------------------------*\
-    | Make sure to properly set the tab label height depending  |
-    | on the font in use.                                       |
-    \*---------------------------------------------------------*/
-    QFontMetrics fontMetrics(font());
-    QRect rect = fontMetrics.boundingRect(0, 0, width(), height(), Qt::TextWordWrap | Qt::TextExpandTabs, name);
-    setFixedHeight(std::max(rect.height(), ui->icon->height()));
 }
 
 Ui::TabLabel::~TabLabel()

qt/TabLabel.ui

@@ -6,12 +6,12 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>200</width>
-    <height>25</height>
+    <width>222</width>
+    <height>16</height>
    </rect>
   </property>
   <property name="sizePolicy">
-   <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+   <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
@@ -20,6 +20,9 @@
    <string>Form</string>
   </property>
   <layout class="QHBoxLayout" name="horizontalLayout">
+   <property name="sizeConstraint">
+    <enum>QLayout::SetMinAndMaxSize</enum>
+   </property>
    <property name="topMargin">
     <number>0</number>
    </property>
@@ -80,11 +83,23 @@
    <item>
     <widget class="QLabel" name="name">
      <property name="sizePolicy">
-      <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
+      <sizepolicy hsizetype="Fixed" vsizetype="Minimum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
+     <property name="minimumSize">
+      <size>
+       <width>150</width>
+       <height>0</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>150</width>
+       <height>16777215</height>
+      </size>
+     </property>
      <property name="text">
       <string>device name</string>
      </property>
@@ -98,3 +113,4 @@
  <resources/>
  <connections/>
 </ui>
+

qt/org.openrgb.OpenRGB.metainfo.xml

@@ -49,6 +49,7 @@
   </description>
 
   <releases>
+    <release version="0.7" date="2021-12-30"></release>
     <release version="0.6" date="2021-06-01"></release>
     <release version="0.5" date="2021-12-07"></release>
     <release version="0.4" date="2020-09-09"></release>