Sanitize filenames from clients in NetworkServer

2026-07-31 19:01:25 -05:00
554 changed files with 21017 additions and 42972 deletions
@@ -61,7 +61,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 32 AppImage":
  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
  stage: build
  script:
  - export $(dpkg-architecture)
@@ -87,7 +87,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 64 AppImage":
  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
  stage: build
  script:
  - export $(dpkg-architecture)
@@ -74,6 +74,7 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/NZXTHue2Controller/
 /Controllers/NZXTHuePlusController/
 /Controllers/NZXTKrakenController/
+/Controllers/OpenRazerController/
 /Controllers/PNYGPUController/
 /Controllers/PatriotViperController/
 /Controllers/PhilipsHueController/
@@ -10,7 +10,6 @@ Please put "Initial commit for" name of the product, including manufacturer abov
 <!-- For admin purposes: Please leave this section as is -->

 # Checklist for Accepting a Merge Request for a New Device
- [ ] The source branch of the merge request is not protected (`master` is protected by default when creating a fork, so it is recommended to not use it as your source).
 - [ ] The `New Device` issue raised for this device is linked to this MR with a keyword `Closes / Resolves / Implements`
 - [ ] There is a device protocol page in the [Developer Wiki](https://gitlab.com/OpenRGBDevelopers/OpenRGB-Wiki) or there is enough information / captures in the `New Device` issue to provide ongoing support.
 - [ ] The code to be merged follows the style guide and change requirements as [documented in the contributing guide](https://gitlab.com/CalcProgrammer1/OpenRGB/-/blob/master/CONTRIBUTING.md).
@@ -4,7 +4,6 @@

 #include <fstream>
 #include <iostream>
-#include <sstream>
 #include <unistd.h>
 #include <linux/limits.h>

@@ -11,7 +11,6 @@ To create a merge request, log into GitLab and fork the OpenRGB project.  Push y
 * Mark your merge request as a draft (start title with "Draft:") until it has been tested and verified working.
 * Follow the Style Guidelines below when making your code changes.
 * Avoid using `git merge` when updating your fork.  The OpenRGB project uses a linear git history, meaning all changes are rebased onto the tip of master.  By using `git rebase` to update your fork, you will make it easier to accept merge requests.
-* Do not submit a merge request using your fork's `master` branch as the source.  The `master` branch is protected by default when creating a fork and I cannot manually rebase a protected branch before merging.  If you submit a merge request with a protected `master` branch as the source, it may not get merged until you unprotect it.

 ### Pipelines, Shared Runners and Quotas

@@ -1,25 +1,15 @@
-/*-------------------------------------------------------------------*\
-|  A4TechDetector.cpp                                                 |
-|                                                                     |
-|  Driver for A4Tech Devices Detector                                 |
-|                                                                     |
-|  Chris M (Dr_No)                              30 Jun 2022           |
-|  Mohammed Julfikar Ali Mahbub (o-julfikar)    01 Apr 2024           |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
 /*-----------------------------------------------------*\
 | OpenRGB includes                                      |
 \*-----------------------------------------------------*/
 #include <hidapi/hidapi.h>
 #include "Detector.h"
+#include "LogManager.h"
 #include "RGBController.h"

 /*-----------------------------------------------------*\
 | A4 Tech specific includes                             |
 \*-----------------------------------------------------*/
 #include "RGBController_BloodyMouse.h"
-#include "RGBController_BloodyB820R.h"

 /*-----------------------------------------------------*\
 | A4 Tech USB vendor ID                                 |
@@ -40,21 +30,5 @@ void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name
    }
 }

-void DetectBloodyB820R(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path);
-        RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
-        rgb_controller->name                      = name;
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
 REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
-REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
 REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
-REGISTER_HID_DETECTOR_IPU("A4Tech Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);
@@ -1,102 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  BloodyB820RController.cpp                                          |
-|                                                                     |
-|  Driver for A4Tech Bloody B820R Keyboard Controller                 |
-|                                                                     |
-|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#include "BloodyB820RController.h"
-
-/*--------------------------------------------------------------------------------------*\
- * The controller for this device should pass a packet of 64 bytes where the subsequent *
- * two packets are for RED, GREEN, and BLUE respectively. The first 6 bytes are control *
- * or information bytes and colors bytes starts from index 6. Moreover, the first pack- *
- * et of each RGB contains color for 58 keys and the rest (104 - 58 == 46) are send on  *
- * the second packet.                                                                   *
-\*--------------------------------------------------------------------------------------*/
-
-BloodyB820RController::BloodyB820RController(hid_device* dev_handle, const char* path)
-{
-    dev                 = dev_handle;
-    location            = path;
-
-    SendControlPacket(BLOODY_B820R_GAIN_CONTROL);
-}
-
-BloodyB820RController::~BloodyB820RController()
-{
-    SendControlPacket(BLOODY_B820R_RELEASE_CONTROL);
-    hid_close(dev);
-}
-
-std::string BloodyB820RController::GetSerial()
-{
-    const int szTemp    = HID_MAX_STR;
-    wchar_t   tmpName[szTemp];
-
-    hid_get_serial_number_string(dev, tmpName, szTemp);
-    std::wstring wName  = std::wstring(tmpName);
-    std::string serial  = std::string(wName.begin(), wName.end());
-
-    return serial;
-}
-
-std::string BloodyB820RController::GetLocation()
-{
-    return("HID: " + location);
-}
-
-void  BloodyB820RController::SendControlPacket(uint8_t data)
-{
-    uint8_t buffer[BLOODY_B820R_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
-
-    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
-
-    buffer[BLOODY_B820R_MODE_BYTE]                   = 0;
-    buffer[BLOODY_B820R_DATA_BYTE]                   = data;
-
-    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
-}
-
-void BloodyB820RController::SetLEDDirect(std::vector<RGBColor> colors)
-{
-
-    uint8_t r1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x07, 0x00, 0x00 };
-    uint8_t r2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x08, 0x00, 0x00 };
-    uint8_t g1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x09, 0x00, 0x00 };
-    uint8_t g2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0A, 0x00, 0x00 };
-    uint8_t b1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0B, 0x00, 0x00 };
-    uint8_t b2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0C, 0x00, 0x00 };
-
-    /*-----------------------------------------------------------------*\
-    | Set up Direct packet                                              |
-    |   packet_map is the index of the Key from full_matrix_map and     |
-    |   the value is the position in the direct packet buffer           |
-    \*-----------------------------------------------------------------*/
-
-
-    for(size_t i = 0; i < colors.size(); i++)
-    {
-        RGBColor    color                     = colors[i];
-        uint8_t     offset                    = BLOODY_B820R_RGB_OFFSET;
-        uint8_t     buffer_idx                = offset + i % BLOODY_B820R_RGB_BUFFER_SIZE;
-        uint8_t*    buffers[2][3]             =
-                {
-                        {r1_buffer, g1_buffer, b1_buffer},
-                        {r2_buffer, g2_buffer, b2_buffer}
-                };
-
-        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][0][buffer_idx] = RGBGetRValue(color);
-        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][1][buffer_idx] = RGBGetGValue(color);
-        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][2][buffer_idx] = RGBGetBValue(color);
-    }
-
-    hid_send_feature_report(dev, r1_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, r2_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, g1_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, g2_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, b1_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, b2_buffer, BLOODY_B820R_PACKET_SIZE);
-}
@@ -1,51 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  BloodyB820RController.h                                            |
-|                                                                     |
-|  Driver for A4Tech Bloody B820R Keyboard Controller                 |
-|                                                                     |
-|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#include <string>
-#include <hidapi/hidapi.h>
-#include "RGBController.h"
-
-#pragma once
-#define NA                                      0xFFFFFFFF
-#define HID_MAX_STR                             255
-
-#define BLOODY_B820R_RGB_BUFFER_SIZE    58
-#define BLOODY_B820R_RGB_OFFSET         6
-#define BLOODY_B820R_PACKET_SIZE        64
-#define BLOODY_B820R_KEYCOUNT           104
-#define BLOODY_B820R_MODE_BYTE          3
-#define BLOODY_B820R_DATA_BYTE          8
-#define BLOODY_B820R_GAIN_CONTROL       0x01
-#define BLOODY_B820R_RELEASE_CONTROL    0x00
-
-/*---------------------------------------------------------*\
-| Bloody B820R product ID                                    |
-\*---------------------------------------------------------*/
-#define BLOODY_B820R_PID                               0xFA10
-
-enum
-{
-    BLOODY_B820R_MODE_DIRECT     = 0x01,    // Direct LED control - Independently set LEDs in zone
-};
-
-class BloodyB820RController
-{
-public:
-    BloodyB820RController(hid_device* dev_handle, const char* path);
-    ~BloodyB820RController();
-
-    std::string     GetSerial();
-    std::string     GetLocation();
-
-    void            SetLEDDirect(std::vector<RGBColor> colors);
-    void            SendControlPacket(uint8_t data);
-private:
-    std::string     location;
-    hid_device*     dev;
-};
@@ -8,7 +8,6 @@
 \*---------------------------------------------------------------------*/

 #include "BloodyMouseController.h"
-#include "LogManager.h"

 BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id)
 {
@@ -9,6 +9,7 @@

 #include <string>
 #include <hidapi/hidapi.h>
+#include "LogManager.h"
 #include "RGBController.h"

 #pragma once
@@ -17,7 +18,6 @@
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
 #define BLOODY_W60_PRO_PID                          0x37EA
-#define BLOODY_W90_MAX_PID                          0x3666

 /*-----------------------------------------------------*\
 | Mousemat product IDs                                  |
@@ -1,247 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_BloodyB820R.cpp                                      |
-|                                                                     |
-|  Driver for A4Tech Bloody B820R Keyboard Controller                 |
-|                                                                     |
-|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include "RGBController_BloodyB820R.h"
-
-static unsigned int matrix_map[6][21] =
-        {
-                {0, NA, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, NA, NA, NA, NA, 13, 14, 15},
-                {16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36},
-                {37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57},
-                {58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, NA, NA, NA, NA, 71, 72, 73, NA},
-                {74, NA, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, NA, NA, 86, NA, 87, 88, 89, 90},
-                {91, 92, 93, 94, NA, NA, NA, NA, NA, NA, 95, 96, 97, 98, 99, 100, 101, 102, NA, 103, NA},
-        };
-
-static const char *led_names[] =
-        {
-                KEY_EN_ESCAPE,              //00
-                KEY_EN_F1,
-                KEY_EN_F2,
-                KEY_EN_F3,
-                KEY_EN_F4,
-                KEY_EN_F5,
-                KEY_EN_F6,
-                KEY_EN_F7,
-                KEY_EN_F8,
-                KEY_EN_F9,
-                KEY_EN_F10,                 
-                KEY_EN_F11,
-                KEY_EN_F12,
-                KEY_EN_PRINT_SCREEN,
-                KEY_EN_SCROLL_LOCK,
-                KEY_EN_PAUSE_BREAK,
-
-                KEY_EN_BACK_TICK,           //10
-                KEY_EN_1,
-                KEY_EN_2,
-                KEY_EN_3,
-                KEY_EN_4,                   
-                KEY_EN_5,
-                KEY_EN_6,
-                KEY_EN_7,
-                KEY_EN_8,
-                KEY_EN_9,
-                KEY_EN_0,
-                KEY_EN_MINUS,
-                KEY_EN_EQUALS,
-                KEY_EN_BACKSPACE,
-                KEY_EN_INSERT,
-                KEY_EN_HOME,
-                KEY_EN_PAGE_UP,
-                KEY_EN_NUMPAD_LOCK,
-                KEY_EN_NUMPAD_DIVIDE,
-                KEY_EN_NUMPAD_TIMES,
-                KEY_EN_NUMPAD_MINUS,
-
-                KEY_EN_TAB,                 //20
-                KEY_EN_Q,
-                KEY_EN_W,
-                KEY_EN_E,
-                KEY_EN_R,
-                KEY_EN_T,
-                KEY_EN_Y,
-                KEY_EN_U,
-                KEY_EN_I,
-                KEY_EN_O,
-                KEY_EN_P,
-                KEY_EN_LEFT_BRACKET,
-                KEY_EN_RIGHT_BRACKET,
-                KEY_EN_ANSI_BACK_SLASH,
-                KEY_EN_DELETE,
-                KEY_EN_END,
-                KEY_EN_PAGE_DOWN,
-                KEY_EN_NUMPAD_7,
-                KEY_EN_NUMPAD_8,
-                KEY_EN_NUMPAD_9,
-                KEY_EN_NUMPAD_PLUS,
-
-                KEY_EN_CAPS_LOCK,           //30
-                KEY_EN_A,
-                KEY_EN_S,
-                KEY_EN_D,
-                KEY_EN_F,
-                KEY_EN_G,
-                KEY_EN_H,
-                KEY_EN_J,
-                KEY_EN_K,
-                KEY_EN_L,
-                KEY_EN_SEMICOLON,
-                KEY_EN_QUOTE,
-                KEY_EN_ANSI_ENTER,
-                KEY_EN_NUMPAD_4,
-                KEY_EN_NUMPAD_5,
-                KEY_EN_NUMPAD_6,
-
-                KEY_EN_LEFT_SHIFT,          //40
-                KEY_EN_Z,
-                KEY_EN_X,
-                KEY_EN_C,
-                KEY_EN_V,
-                KEY_EN_B,
-                KEY_EN_N,
-                KEY_EN_M,
-                KEY_EN_COMMA,
-                KEY_EN_PERIOD,
-                KEY_EN_FORWARD_SLASH,
-                KEY_EN_RIGHT_SHIFT,
-                KEY_EN_UP_ARROW,
-                KEY_EN_NUMPAD_1,
-                KEY_EN_NUMPAD_2,
-                KEY_EN_NUMPAD_3,
-                KEY_EN_NUMPAD_ENTER,
-
-                KEY_EN_LEFT_CONTROL,        //50
-                KEY_EN_LEFT_WINDOWS,
-                KEY_EN_LEFT_ALT,
-                KEY_EN_SPACE,
-                KEY_EN_RIGHT_ALT,
-                KEY_EN_RIGHT_FUNCTION,
-                KEY_EN_MENU,
-                KEY_EN_RIGHT_CONTROL,
-                KEY_EN_LEFT_ARROW,
-                KEY_EN_DOWN_ARROW,
-                KEY_EN_RIGHT_ARROW,
-                KEY_EN_NUMPAD_0,
-                KEY_EN_NUMPAD_PERIOD
-        };
-
-/**------------------------------------------------------------------*\
-    @name A4Tech Bloody B820R
-    @category Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors A4TechDetector
-    @comment The A4Tech Bloody B820R keyboard controller currently
-        supports the full size (ANSI layout).
-\*-------------------------------------------------------------------*/
-
-RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *controller_ptr)
-{
-    controller                  = controller_ptr;
-
-    name                        = "Bloody B820R";
-    vendor                      = "A4Tech";
-    type                        = DEVICE_TYPE_KEYBOARD;
-    description                 = "A4Tech Bloody Keyboard";
-    serial                      = controller->GetSerial();
-    location                    = controller->GetLocation();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = BLOODY_B820R_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-}
-
-RGBController_BloodyB820R::~RGBController_BloodyB820R()
-{
-    delete controller;
-}
-
-void RGBController_BloodyB820R::SetupZones()
-{
-    /*-------------------------------------------------*\
-    | Create the Keyboard zone and add the matrix map   |
-    \*-------------------------------------------------*/
-    zone KB_zone;
-    KB_zone.name                = ZONE_EN_KEYBOARD;
-    KB_zone.type                = ZONE_TYPE_MATRIX;
-    KB_zone.leds_min            = BLOODY_B820R_KEYCOUNT;
-    KB_zone.leds_max            = BLOODY_B820R_KEYCOUNT;
-    KB_zone.leds_count          = BLOODY_B820R_KEYCOUNT;
-
-    KB_zone.matrix_map          = new matrix_map_type;
-    KB_zone.matrix_map->height  = 6;
-    KB_zone.matrix_map->width   = 21;
-    KB_zone.matrix_map->map     = (unsigned int *)&matrix_map;
-    zones.push_back(KB_zone);
-
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
-    leds.clear();
-    colors.clear();
-
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    for(unsigned int led_index = 0; led_index < BLOODY_B820R_KEYCOUNT; led_index++)
-    {
-        led new_led;
-        new_led.name        = led_names[led_index];
-        new_led.value       = led_index;
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_BloodyB820R::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-
-void RGBController_BloodyB820R::DeviceUpdateLEDs()
-{
-    controller->SetLEDDirect(colors);
-}
-
-void RGBController_BloodyB820R::UpdateZoneLEDs(int zone)
-{
-    std::vector<RGBColor> colour;
-    for(size_t i = 0; i < zones[zone].leds_count; i++)
-    {
-        colour.push_back(zones[zone].colors[i]);
-    }
-
-    controller->SetLEDDirect(colour);
-}
-
-void RGBController_BloodyB820R::UpdateSingleLED(int led)
-{
-    std::vector<RGBColor> colour;
-    colour.push_back(colors[led]);
-
-    controller->SetLEDDirect(colour);
-}
-
-void RGBController_BloodyB820R::DeviceUpdateMode()
-{
-    /* This device does not support modes yet */
-}
@@ -1,32 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_BloodyB820R.h                                |
-|                                                                     |
-|  Driver for A4Tech Bloody B820R Keyboard Controller                   |
-|                                                                     |
-|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "BloodyB820RController.h"
-#include <vector>
-
-class RGBController_BloodyB820R : public RGBController
-{
-public:
-    RGBController_BloodyB820R(BloodyB820RController* controller_ptr);
-    ~RGBController_BloodyB820R();
-
-    void    SetupZones();
-    void    ResizeZone(int zone, int new_size);
-
-    void    DeviceUpdateLEDs();
-    void    UpdateZoneLEDs(int zone);
-    void    UpdateSingleLED(int led);
-
-    void    DeviceUpdateMode();
-
-private:
-    BloodyB820RController* controller;
-};
@@ -25,19 +25,6 @@ static const mouse_layout w60_pro
    }
 };

-static const mouse_layout w90_max
-{
-    {
-        "Scroll Wheel", { 14 }
-    },
-    {
-        "Logo",         { 7 }
-    },
-    {
-        "Rear",         { 13, 12, 11, 10, 9, 8, 6, 5, 4, 3, 2, 1, 0 }
-    }
-};
-
 static const mouse_layout mp_50rs
 {
    {
@@ -69,6 +56,7 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont
            type                = DEVICE_TYPE_MOUSE;
    }

+    name                        = "BloodyMouse";
    vendor                      = "Bloody";
    description                 = "Controller compatible with the Bloody W60 Pro and MP 50RS";
    serial                      = controller->GetSerial();
@@ -101,15 +89,11 @@ void RGBController_BloodyMouse::SetupZones()
    | Select layout from PID                            |
    \*-------------------------------------------------*/
    mouse_layout layout;
-
    switch(controller->GetPid())
    {
        case BLOODY_W60_PRO_PID:
            layout = w60_pro;
            break;
-        case BLOODY_W90_MAX_PID:
-            layout = w90_max;
-            break;
        case BLOODY_MP_50RS_PID:
            layout = mp_50rs;
            break;
@@ -9,6 +9,7 @@

 #pragma once
 #include <vector>
+#include "LogManager.h"
 #include "RGBController.h"
 #include "BloodyMouseController.h"

@@ -8,7 +8,6 @@
 \*-----------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GK500_PID                               0x1178
-#define AOC_GK500_PID_2                             0x1229

 /******************************************************************************************\
 *                                                                                          *
@@ -33,4 +32,3 @@ void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name
 }

 REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID,   0xFF19, 0xFF19);
-REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID_2,   0xFF19, 0xFF19);
@@ -12,7 +12,6 @@

 #include "RGBController.h"
 #include "ResourceManager.h"
-#include "SettingsManager.h"
 #include "ASRockPolychromeUSBController.h"
 #include "dependencies/dmiinfo.h"

@@ -15,7 +15,6 @@
 #include <chrono>
 #include <algorithm>
 #include <sstream>
-#include "LogManager.h"

 typedef uint32_t alienware_platform_id;

@@ -25,10 +24,8 @@ typedef uint32_t alienware_platform_id;
 \*---------------------------------------------------------*/
 static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
 {
-    { 0x0C01,   4 },    // Dell G5 SE 5505
-    { 0x0A01,  16 },    // Dell G7 15 7500
-    { 0x0E03,   4 }     // Dell G15   5511
-
+    { 0x0C01,   4 }, // Dell G5 SE 5505
+    { 0x0A01,  16 }  // Dell G7 15 7500
 };

 /*---------------------------------------------------------*\
@@ -42,8 +39,7 @@ static const std::map<alienware_platform_id, std::vector<const char*>> zone_name
                  "Light Bar 1",    "Light Bar 2",  "Light Bar 3",
                  "Light Bar 4",    "Light Bar 5",  "Light Bar 6",
                  "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
-                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } },
-    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } }
+                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } }
 };

 static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
@@ -117,13 +113,10 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic

    if(zone_names_table.count(platform_id))
    {
-        LOG_INFO("[%s] Known platform: %8X, Number of zones: %d", ALIENWARE_CONTROLLER_NAME, platform_id, number_of_zones);
        zone_names = zone_names_table.at(platform_id);
    }
    else
    {
-        LOG_WARNING("[%s] Unknown platform: %8X, Number of zones: %d", ALIENWARE_CONTROLLER_NAME, platform_id, number_of_zones);
-
        /*-------------------------------------------------*\
        | If this is an unknown controller, set the name of |
        | all regions to "Unknown"                          |
@@ -19,7 +19,7 @@

 #define ALIENWARE_REPORT_SIZE               33
 #define HIDAPI_ALIENWARE_REPORT_SIZE        (ALIENWARE_REPORT_SIZE + 1)
-#define ALIENWARE_CONTROLLER_NAME           "AlienWare Controller"
+
 enum
 {
    ALIENWARE_COMMAND_REPORT                = 0x20,     /* Set report type to get               */
@@ -1,448 +0,0 @@
-/*------------------------------------------------------*\
-|  AlienwareAW410KController.cpp                         |
-|                                                        |
-|  Driver for Alienware AW410K                           |
-|  keyboard light controller                             |
-|                                                        |
-|  based on AW510K controller by Mohamad Sallal - msallal|
-|                                                        |
-|  Dominik Mikolajczyk - dmiko 23/10/2023                |
-\*------------------------------------------------------*/
-
-#include "AlienwareAW410KController.h"
-#include <cstring>
-
-AlienwareAW410KController::AlienwareAW410KController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-
-    SendCommit();
-}
-
-AlienwareAW410KController::~AlienwareAW410KController()
-{
-    hid_close(dev);
-}
-
-std::string AlienwareAW410KController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AlienwareAW410KController::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 AlienwareAW410KController::SendCommit()
-{
-    char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Commit packet                                  |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x0A]           = 0x10;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0C]           = 0x01;
-    usb_buf[0x0D]           = 0x02;
-    usb_buf[0x0E]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 20 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(20));
-}
-
-
-void AlienwareAW410KController::SendfeatureReport
-    (
-    unsigned char   first_byte,
-    unsigned char   second_byte,
-    unsigned char   third_byte,
-    unsigned char   forth_byte
-    )
-{
-    char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Feature report packet                          |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = first_byte;
-    usb_buf[0x02]           = second_byte;
-    usb_buf[0x03]           = third_byte;
-    usb_buf[0x04]           = forth_byte;
-
-    /*-----------------------------------------------------*\
-    | Send Feature report packet                            |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, (unsigned char *)usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 10 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-}
-
-void AlienwareAW410KController::SendEdit()
-{
-    char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Edit packet                                    |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x01;
-    usb_buf[0x02]           = 0x00;
-    usb_buf[0x03]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 2 milliseconds                                  |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-}
-
-void AlienwareAW410KController::SendInitialize()
-{
-    char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Commit packet                                  |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x0E;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = 0x00;
-    usb_buf[0x04]           = 0x01;
-    usb_buf[0x05]           = 0xAD;
-    usb_buf[0x06]           = 0x80;
-    usb_buf[0x07]           = 0x10;
-    usb_buf[0x08]           = 0xA5;
-    usb_buf[0x0A]           = 0x0A;
-    usb_buf[0x12]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 2 milliseconds                                  |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-}
-
-void AlienwareAW410KController::SetDirect
-    (
-    unsigned char   /*zone*/,
-    unsigned char   r,
-    unsigned char   g,
-    unsigned char   b
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = 0x01;
-    usb_buf[0x04]           = r;
-    usb_buf[0x05]           = g;
-    usb_buf[0x06]           = b;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0D]           = 0x01;
-    usb_buf[0x0E]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 2 milliseconds                                  |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-}
-
-void AlienwareAW410KController::SendDirectOn
-    (
-    std::vector<SelectedButtons>     &frame_data
-    )
-{
-    SendfeatureReport(0x0E, frame_data.size(), 0x00, 0x01);
-
-    /*-----------------------------------------------*\
-    | To Guarantee the data are always %4 =0 append   |
-    | zeros at end of last packet                     |
-    \*-----------------------------------------------*/
-    for(unsigned int i = 0; i < (frame_data.size() % 4); i++)
-    {
-        SelectedButtons key;
-        key.idx     = 0x00;
-        key.red     = 0x00;
-        key.green   = 0x00;
-        key.blue    = 0x00;
-
-        frame_data.push_back(key);
-    }
-
-    unsigned char usb_buf[65];
-    unsigned int  frame_idx = 0;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, 65);
-
-    for(unsigned int packet_idx = 0; packet_idx < frame_data.size(); packet_idx++)
-    {
-        usb_buf[0x00]           = 0x00;
-        usb_buf[0x01]           = 0x0E;
-        usb_buf[0x02]           = 0x01;
-        usb_buf[0x03]           = 0x00;
-        usb_buf[0x04]           = ++frame_idx;
-        usb_buf[0x05]           = frame_data[packet_idx].idx;
-        usb_buf[0x06]           = 0x81;
-        usb_buf[0x07]           = 0x00;
-        usb_buf[0x08]           = 0xA5;
-        usb_buf[0x0A]           = 0x0A;
-        usb_buf[0x0B]           = frame_data[packet_idx].red;
-        usb_buf[0x0C]           = frame_data[packet_idx].green;
-        usb_buf[0x0D]           = frame_data[packet_idx].blue;
-        usb_buf[0x12]           = 0x01;
-
-        usb_buf[0x14]           = frame_data[++packet_idx].idx;
-        usb_buf[0x15]           = 0x81;
-        usb_buf[0x16]           = 0x00;
-        usb_buf[0x17]           = 0xA5;
-        usb_buf[0x19]           = 0x0A;
-        usb_buf[0x1A]           = frame_data[packet_idx].red;
-        usb_buf[0x1B]           = frame_data[packet_idx].green;
-        usb_buf[0x1C]           = frame_data[packet_idx].blue;
-        usb_buf[0x21]           = 0x01;
-
-        usb_buf[0x23]           = frame_data[++packet_idx].idx;
-        usb_buf[0x24]           = 0x81;
-        usb_buf[0x25]           = 0x00;
-        usb_buf[0x26]           = 0xA5;
-        usb_buf[0x28]           = 0x0A;
-        usb_buf[0x29]           = frame_data[packet_idx].red;
-        usb_buf[0x2A]           = frame_data[packet_idx].green;
-        usb_buf[0x2B]           = frame_data[packet_idx].blue;
-        usb_buf[0x30]           = 0x01;
-
-        usb_buf[0x32]           = frame_data[++packet_idx].idx;
-        usb_buf[0x33]           = 0x81;
-        usb_buf[0x34]           = 0x00;
-        usb_buf[0x35]           = 0xA5;
-        usb_buf[0x37]           = 0x0A;
-        usb_buf[0x38]           = frame_data[packet_idx].red;
-        usb_buf[0x39]           = frame_data[packet_idx].green;
-        usb_buf[0x3A]           = frame_data[packet_idx].blue;
-        usb_buf[0x3F]           = 0x01;
-
-        hid_write(dev, (unsigned char *)usb_buf, 65);
-    }
-}
-
-
-void AlienwareAW410KController::SetMode
-    (
-    unsigned char   mode,
-    unsigned short  speed,
-    unsigned char   direction,
-    unsigned char   colorMode,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    SendMode(ALIENWARE_AW410K_ZONE_MODE_KEYBOARD, mode, speed, direction, colorMode, red, green, blue);
-    SendCommit();
-}
-
-void AlienwareAW410KController::UpdateSingleLED
-    (
-    unsigned char   led,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    SendfeatureReport(0x0E, 0x01, 0x00, 0x01);
-
-    char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Single LED packet                              |
-    \*-----------------------------------------------------*/
-
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x0E;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = 0x00;
-    usb_buf[0x04]           = 0x01;
-    usb_buf[0x05]           = led;
-    usb_buf[0x06]           = 0x81;
-    usb_buf[0x07]           = 0x00;
-    usb_buf[0x08]           = 0xA5;
-    usb_buf[0x09]           = 0x00;
-    usb_buf[0x0A]           = 0x0A;
-    usb_buf[0x0B]           = red;
-    usb_buf[0x0C]           = green;
-    usb_buf[0x0D]           = blue;
-    usb_buf[0x12]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 20 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(20));
-
-}
-void AlienwareAW410KController::SendMode
-    (
-    unsigned char   /*zone*/,
-    unsigned char   mode,
-    unsigned short  speed,
-    unsigned char   direction,
-    unsigned char   colorMode,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Mode Control packet                            |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = mode;
-    usb_buf[0x04]           = red;
-    usb_buf[0x05]           = green;
-    usb_buf[0x06]           = blue;
-    usb_buf[0x0A]           = speed;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0D]           = 0x01;
-    usb_buf[0x0E]           = colorMode;
-    usb_buf[0x0F]           = direction;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-}
-
-void AlienwareAW410KController::SetMorphMode
-    (
-    unsigned char   mode,
-    unsigned short  speed,
-    unsigned char   red1,
-    unsigned char   green1,
-    unsigned char   blue1,
-    unsigned char   red2,
-    unsigned char   green2,
-    unsigned char   blue2
-    )
-{
-    char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Morph Mode packet                              |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = mode;
-    usb_buf[0x04]           = red1;
-    usb_buf[0x05]           = green1;
-    usb_buf[0x06]           = blue1;
-    usb_buf[0x07]           = red2;
-    usb_buf[0x08]           = green2;
-    usb_buf[0x09]           = blue2;
-    usb_buf[0x0E]           = 0x02;
-    usb_buf[0x0A]           = speed;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0D]           = 0x01;
-    usb_buf[0x0E]           = ALIENWARE_AW410K_TWO_USER_DEFINED_COLOR_MODE;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-}
@@ -1,155 +0,0 @@
-/*------------------------------------------------------*\
-|  AlienwareAW410KController.h                           |
-|                                                        |
-|  Definitions and types for alienware                   |
-|  AW410K Keyboard                                       |
-|                                                        |
-|  based on AW510K controller by Mohamad Sallal - msallal|
-|                                                        |
-|  Dominik Mikolajczyk - dmiko 23/10/2023                |
-\*------------------------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    ALIENWARE_AW410K_ZONE_MODE_KEYBOARD         = 0x01,
-};
-
-enum
-{
-    ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD       = 0x01,
-    ALIENWARE_AW410K_ZONE_DIRECT_MEDIA          = 0x02,
-    ALIENWARE_AW410K_ZONE_DIRECT_INDICATORS     = 0x40,
-};
-
-enum
-{
-    ALIENWARE_AW410K_MODE_OFF                   = 0x00,
-    ALIENWARE_AW410K_MODE_DIRECT                = 0x01,
-    ALIENWARE_AW410K_MODE_PULSE                 = 0x02,
-    ALIENWARE_AW410K_MODE_MORPH                 = 0x03,
-    ALIENWARE_AW410K_MODE_BREATHING             = 0x07,
-    ALIENWARE_AW410K_MODE_SPECTRUM              = 0x08,
-    ALIENWARE_AW410K_MODE_SINGLE_WAVE           = 0x0F,
-    ALIENWARE_AW410K_MODE_RAINBOW_WAVE          = 0x10,
-    ALIENWARE_AW410K_MODE_SCANNER               = 0x11,
-    ALIENWARE_AW410K_MODE_STATIC                = 0x13,
-};
-
-enum
-{
-    ALIENWARE_AW410K_SPEED_SLOWEST              = 0x2D,     /* Slowest speed                                */
-    ALIENWARE_AW410K_SPEED_NORMAL               = 0x19,     /* Normal speed                                 */
-    ALIENWARE_AW410K_SPEED_FASTEST              = 0x0A,     /* Fastest speed                                */
-};
-
-enum
-{
-    ALIENWARE_AW410K_DIRECTION_LEFT_TO_RIGHT    = 0x01,
-    ALIENWARE_AW410K_DIRECTION_RIGHT_TO_LEFT    = 0x02,
-    ALIENWARE_AW410K_DIRECTION_TOP_TO_BOTTOM    = 0x03,
-    ALIENWARE_AW410K_DIRECTION_BOTTOM_TO_TOP    = 0x04,
-};
-
-enum
-{
-    ALIENWARE_AW410K_SINGLE_COLOR_MODE          = 0x01,
-    ALIENWARE_AW410K_TWO_USER_DEFINED_COLOR_MODE= 0x02,
-    ALIENWARE_AW410K_RANBOW_COLOR_MODE          = 0x03,
-};
-
-struct SelectedButtons
-{
-    unsigned char idx;
-    unsigned char red;
-    unsigned char green;
-    unsigned char blue;
-};
-
-class AlienwareAW410KController
-{
-public:
-    AlienwareAW410KController(hid_device* dev_handle, const char* path);
-    ~AlienwareAW410KController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void        SendInitialize();
-    void        SendCommit();
-    void        SendfeatureReport
-                    (
-                    unsigned char   first_byte,
-                    unsigned char   second_byte,
-                    unsigned char   third_byte,
-                    unsigned char   forth_byte
-                    );
-
-    void        SendEdit();
-
-    void        SetDirect
-                    (
-                    unsigned char   zone,
-                    unsigned char   r,
-                    unsigned char   g,
-                    unsigned char   b
-                    );
-
-    void    SendDirectOn
-                    (
-                    std::vector<SelectedButtons>     &frame_data
-                    );
-
-    void        SetMode
-                    (
-                    unsigned char   mode,
-                    unsigned short  speed,
-                    unsigned char   direction,
-                    unsigned char   colorMode,
-                    unsigned char   red,
-                    unsigned char   green,
-                    unsigned char   blue
-                    );
-
-    void        SetMorphMode
-                    (
-                    unsigned char   mode,
-                    unsigned short  speed,
-                    unsigned char   red1,
-                    unsigned char   green1,
-                    unsigned char   blue1,
-                    unsigned char   red2,
-                    unsigned char   green2,
-                    unsigned char   blue2
-                    );
-
-    void        UpdateSingleLED
-                    (
-                    unsigned char   led,
-                    unsigned char   red,
-                    unsigned char   green,
-                    unsigned char   blue
-                    );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-
-    void        SendMode
-                    (
-                    unsigned char   zone,
-                    unsigned char   mode,
-                    unsigned short  speed,
-                    unsigned char   direction,
-                    unsigned char   colorMode,
-                    unsigned char   red,
-                    unsigned char   green,
-                    unsigned char   blue
-                    );
-};
@@ -1,9 +1,7 @@
 #include "Detector.h"
 #include "AlienwareAW510KController.h"
-#include "AlienwareAW410KController.h"
 #include "RGBController.h"
 #include "RGBController_AlienwareAW510K.h"
-#include "RGBController_AlienwareAW410K.h"
 #include <hidapi/hidapi.h>

 /*-----------------------------------------------------*\
@@ -15,7 +13,6 @@
 | Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
 #define ALIENWARE_AW510K_PID    0x1830
-#define ALIENWARE_AW410K_PID    0x1968

 /******************************************************************************************\
 *                                                                                          *
@@ -35,20 +32,7 @@ void DetectAlienwareAW510KControllers(hid_device_info* info, const std::string&
        rgb_controller->name = name;
        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
-}
-
-void DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
-    {
-        AlienwareAW410KController*     controller     = new AlienwareAW410KController(dev, info->path);
-        RGBController_AlienwareAW410K* rgb_controller = new RGBController_AlienwareAW410K(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}/* DetectAlienwareKeyboardControllers() */
+}   /* DetectAlienwareKeyboardControllers() */


 REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);
-REGISTER_HID_DETECTOR_IPU("Alienware AW410K",   DetectAlienwareAW410KControllers,   ALIENWARE_VID,  ALIENWARE_AW410K_PID,   0x02,   0xFF00, 0x01);
@@ -1,481 +0,0 @@
-/*------------------------------------------------------*\
-|  RGBController_AlienwareAW410K.cpp                     |
-|                                                        |
-|  Generic RGB Interface for alienware                   |
-|  AW410K Keyboard                                       |
-|                                                        |
-|  based on AW510K controller by Mohamad Sallal - msallal|
-|                                                        |
-|  Dominik Mikolajczyk - dmiko 23/10/2023                |
-\*------------------------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include "RGBController_AlienwareAW410K.h"
-#include <iterator>
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-int GetAW410K_WaveDirection(int input);
-
-static unsigned int matrix_map[6][24] =
-{ {  0,   NA,   1,   2,   3,   4,  NA,   5,   6,   7,   8,   9,  10,  11,  12, NA,  13,  14,  15,  NA,  NA,  16,  17,  18 },
-  {  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  NA, NA,  33,  34,  35,  NA,  36,  37,  38,  39 },
-  {  40,  NA,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  53, NA,  54,  55,  56,  NA,  57,  58,  59,  60 },
-  {  61,  NA,  62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  72,  NA,  73, NA,  NA,  NA,  NA,  NA,  74,  75,  76,  NA },
-  {  77,  NA,  NA,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  NA, NA,  NA,  89,  NA,  NA,  90,  91,  92,  93 },
-  {  94,  NA,  95,  96,  NA,  NA,  NA,  97,  NA,  NA,  NA,  98,  99, 100, 101, NA, 102, 103, 104,  NA, 105,  NA, 106,  NA }};
-
-static const char* zone_names[] =
-{
-    "AW410K",
-};
-
-static zone_type zone_types[] =
-{
-    ZONE_TYPE_MATRIX,
-};
-
-static const unsigned int zone_sizes[] =
-{
-    107,
-};
-
-typedef struct
-{
-    const char *        name;
-    const unsigned char zone;
-    const unsigned char idx;
-} aw410k_led_type;
-
-static const aw410k_led_type led_names[] =
-{
-    /* Key Label                Zone,                                      Index  */
-    { KEY_EN_ESCAPE,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB0    },
-    { KEY_EN_F1,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x98    },
-    { KEY_EN_F2,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x90    },
-    { KEY_EN_F3,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x88    },
-    { KEY_EN_F4,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x80    },
-    { KEY_EN_F5,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x70    },
-    { KEY_EN_F6,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x68    },
-    { KEY_EN_F7,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x60    },
-    { KEY_EN_F8,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x58    },
-    { KEY_EN_F9,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x50    },
-    { KEY_EN_F10,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x48    },
-    { KEY_EN_F11,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x40    },
-    { KEY_EN_F12,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x38    },
-    { KEY_EN_PRINT_SCREEN,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x30    },
-    { KEY_EN_SCROLL_LOCK,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x28    },
-    { KEY_EN_PAUSE_BREAK,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x20    },
-    { KEY_EN_MEDIA_MUTE,        ALIENWARE_AW410K_ZONE_DIRECT_MEDIA,        0x18    },
-    { KEY_EN_MEDIA_VOLUME_DOWN, ALIENWARE_AW410K_ZONE_DIRECT_MEDIA,        0x10    },
-    { KEY_EN_MEDIA_VOLUME_UP,   ALIENWARE_AW410K_ZONE_DIRECT_MEDIA,        0x08    },
-    { KEY_EN_BACK_TICK,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB1    },
-    { KEY_EN_1,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA1    },
-    { KEY_EN_2,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x99    },
-    { KEY_EN_3,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x91    },
-    { KEY_EN_4,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x89    },
-    { KEY_EN_5,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x81    },
-    { KEY_EN_6,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x79    },
-    { KEY_EN_7,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x71    },
-    { KEY_EN_8,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x69    },
-    { KEY_EN_9,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x61    },
-    { KEY_EN_0,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x59    },
-    { KEY_EN_MINUS,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x51    },
-    { KEY_EN_EQUALS,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x49    },
-    { KEY_EN_BACKSPACE,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x39    },
-    { KEY_EN_INSERT,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x31    },
-    { KEY_EN_HOME,              ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x29    },
-    { KEY_EN_PAGE_UP,           ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x21    },
-    { KEY_EN_NUMPAD_LOCK,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x19    },
-    { KEY_EN_NUMPAD_DIVIDE,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x11    },
-    { KEY_EN_NUMPAD_TIMES,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x09    },
-    { KEY_EN_NUMPAD_MINUS,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x01    },
-    { KEY_EN_TAB,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB2    },
-    { KEY_EN_Q,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA2    },
-    { KEY_EN_W,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x9A    },
-    { KEY_EN_E,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x92    },
-    { KEY_EN_R,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x8A    },
-    { KEY_EN_T,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x82    },
-    { KEY_EN_Y,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x7A    },
-    { KEY_EN_U,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x72    },
-    { KEY_EN_I,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x6A    },
-    { KEY_EN_O,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x62    },
-    { KEY_EN_P,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5A    },
-    { KEY_EN_LEFT_BRACKET,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x52    },
-    { KEY_EN_RIGHT_BRACKET,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x4A    },
-    { KEY_EN_ANSI_BACK_SLASH,   ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x42    },
-    { KEY_EN_DELETE,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x32    },
-    { KEY_EN_END,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x2A    },
-    { KEY_EN_PAGE_DOWN,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x22    },
-    { KEY_EN_NUMPAD_7,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1A    },
-    { KEY_EN_NUMPAD_8,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x12    },
-    { KEY_EN_NUMPAD_9,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0A    },
-    { KEY_EN_NUMPAD_PLUS,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x03    },
-    { KEY_EN_CAPS_LOCK,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB3    },
-    { KEY_EN_A,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA3    },
-    { KEY_EN_S,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x9B    },
-    { KEY_EN_D,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x93    },
-    { KEY_EN_F,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x8B    },
-    { KEY_EN_G,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x83    },
-    { KEY_EN_H,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x7B    },
-    { KEY_EN_J,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x73    },
-    { KEY_EN_K,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x6B    },
-    { KEY_EN_L,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x63    },
-    { KEY_EN_SEMICOLON,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5B    },
-    { KEY_EN_QUOTE,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x53    },
-    { KEY_EN_ANSI_ENTER,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x43    },
-    { KEY_EN_NUMPAD_4,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1B    },
-    { KEY_EN_NUMPAD_5,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x13    },
-    { KEY_EN_NUMPAD_6,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0B    },
-    { KEY_EN_LEFT_SHIFT,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB4    },
-    { KEY_EN_Z,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA4    },
-    { KEY_EN_X,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x9C    },
-    { KEY_EN_C,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x94    },
-    { KEY_EN_V,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x8C    },
-    { KEY_EN_B,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x84    },
-    { KEY_EN_N,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x7C    },
-    { KEY_EN_M,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x74    },
-    { KEY_EN_COMMA,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x6C    },
-    { KEY_EN_PERIOD,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x64    },
-    { KEY_EN_FORWARD_SLASH,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5C    },
-    { KEY_EN_RIGHT_SHIFT,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x4C    },
-    { KEY_EN_UP_ARROW,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x2C    },
-    { KEY_EN_NUMPAD_1,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1C    },
-    { KEY_EN_NUMPAD_2,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x14    },
-    { KEY_EN_NUMPAD_3,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0C    },
-    { KEY_EN_NUMPAD_ENTER,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x05    },
-    { KEY_EN_LEFT_CONTROL,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB5    },
-    { KEY_EN_LEFT_WINDOWS,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xAD    },
-    { KEY_EN_LEFT_ALT,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA5    },
-    { KEY_EN_SPACE,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x85    },
-    { KEY_EN_RIGHT_ALT,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x65    },
-    { KEY_EN_RIGHT_FUNCTION,    ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5D    },
-    { KEY_EN_MENU,              ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x55    },
-    { KEY_EN_RIGHT_CONTROL,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x4D    },
-    { KEY_EN_LEFT_ARROW,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x35    },
-    { KEY_EN_DOWN_ARROW,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x2D    },
-    { KEY_EN_RIGHT_ARROW,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x25    },
-    { KEY_EN_NUMPAD_0,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1D    },
-    { KEY_EN_NUMPAD_PERIOD,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0D    }
-};
-
-/**------------------------------------------------------------------*\
-    @name Alienware AW410 Keyboard
-    @category Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAlienwareAW410KControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AlienwareAW410K::RGBController_AlienwareAW410K(AlienwareAW410KController* controller_ptr)
-{
-    controller                      = controller_ptr;
-
-    name                            = "Alienware AW410K Keyboard Device";
-    vendor                          = "Alienware";
-    type                            = DEVICE_TYPE_KEYBOARD;
-    description                     = "Alienware AW410K Keyboard Device";
-    location                        = controller->GetDeviceLocation();
-    serial                          = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name                     = "Direct";
-    Direct.value                    = ALIENWARE_AW410K_MODE_DIRECT;
-    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode               = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name                     = "Static";
-    Static.value                    = ALIENWARE_AW410K_MODE_STATIC;
-    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.colors_min               = 1;
-    Static.colors_max               = 1;
-    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Pulse;
-    Pulse.name                      = "Pulse";
-    Pulse.value                     = ALIENWARE_AW410K_MODE_PULSE;
-    Pulse.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Pulse.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    Pulse.speed_min                 = ALIENWARE_AW410K_SPEED_SLOWEST;
-    Pulse.speed_max                 = ALIENWARE_AW410K_SPEED_NORMAL;
-    Pulse.speed                     = ALIENWARE_AW410K_SPEED_NORMAL;
-    Pulse.colors_min                = 1;
-    Pulse.colors_max                = 1;
-    Pulse.colors.resize(1);
-    modes.push_back(Pulse);
-
-    mode Morph;
-    Morph.name                      = "Morph";
-    Morph.value                     = ALIENWARE_AW410K_MODE_MORPH;
-    Morph.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Morph.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    Morph.speed_min                 = ALIENWARE_AW410K_SPEED_SLOWEST;
-    Morph.speed_max                 = ALIENWARE_AW410K_SPEED_NORMAL;
-    Morph.speed                     = ALIENWARE_AW410K_SPEED_NORMAL;
-    Morph.colors_min                = 2;
-    Morph.colors_max                = 2;
-    Morph.colors.resize(2);
-    modes.push_back(Morph);
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = ALIENWARE_AW410K_MODE_BREATHING;
-    Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathing.colors_min            = 1;
-    Breathing.colors_max            = 1;
-    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors.resize(1);
-    Breathing.speed_min             = ALIENWARE_AW410K_SPEED_SLOWEST;
-    Breathing.speed_max             = ALIENWARE_AW410K_SPEED_FASTEST;
-    Breathing.speed                 = ALIENWARE_AW410K_SPEED_NORMAL;
-    modes.push_back(Breathing);
-
-    mode SingleWave;
-    SingleWave.name                  = "Single Wave";
-    SingleWave.value                 = ALIENWARE_AW410K_MODE_SINGLE_WAVE;
-    SingleWave.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
-    SingleWave.speed_min             = ALIENWARE_AW410K_SPEED_SLOWEST;
-    SingleWave.speed_max             = ALIENWARE_AW410K_SPEED_FASTEST;
-    SingleWave.speed                 = ALIENWARE_AW410K_SPEED_NORMAL;
-    SingleWave.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    SingleWave.colors_min            = 1;
-    SingleWave.colors_max            = 1;
-    SingleWave.colors.resize(1);
-    modes.push_back(SingleWave);
-
-    mode RainbowWave;
-    RainbowWave.name                  = "Rainbow Wave";
-    RainbowWave.value                 = ALIENWARE_AW410K_MODE_RAINBOW_WAVE;
-    RainbowWave.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
-    RainbowWave.speed_min             = ALIENWARE_AW410K_SPEED_SLOWEST;
-    RainbowWave.speed_max             = ALIENWARE_AW410K_SPEED_FASTEST;
-    RainbowWave.speed                 = ALIENWARE_AW410K_SPEED_NORMAL;
-    RainbowWave.colors_min            = 1;
-    RainbowWave.colors_max            = 1;
-    RainbowWave.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    RainbowWave.colors.resize(1);
-    modes.push_back(RainbowWave);
-
-    mode Off;
-    Off.name                          = "Off";
-    Off.value                         = ALIENWARE_AW410K_MODE_OFF;
-    Off.flags                         = 0;
-    Off.color_mode                    = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    SetupZones();
-    std::copy(colors.begin(), colors.end(),std::back_inserter(current_colors));
-}
-
-RGBController_AlienwareAW410K::~RGBController_AlienwareAW410K()
-{
-    /*---------------------------------------------------------*\
-    | Delete the matrix map                                     |
-    \*---------------------------------------------------------*/
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        if(zones[zone_index].matrix_map != NULL)
-        {
-            delete zones[zone_index].matrix_map;
-        }
-    }
-
-    delete controller;
-}
-
-void RGBController_AlienwareAW410K::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    unsigned int total_led_count = 0;
-
-    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
-    {
-        zone new_zone;
-        new_zone.name                   = zone_names[zone_idx];
-        new_zone.type                   = zone_types[zone_idx];
-        new_zone.leds_min               = zone_sizes[zone_idx];
-        new_zone.leds_max               = zone_sizes[zone_idx];
-        new_zone.leds_count             = zone_sizes[zone_idx];
-
-        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
-        {
-            new_zone.matrix_map         = new matrix_map_type;
-            new_zone.matrix_map->height = 6;
-            new_zone.matrix_map->width  = 24;
-            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
-        }
-        else
-        {
-            new_zone.matrix_map         = NULL;
-        }
-
-        zones.push_back(new_zone);
-
-        total_led_count += zone_sizes[zone_idx];
-    }
-
-    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
-    {
-        led new_led;
-        new_led.name  = led_names[led_idx].name;
-        new_led.value = led_names[led_idx].idx;
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AlienwareAW410K::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AlienwareAW410K::DeviceUpdateLEDs()
-{
-    std::vector<SelectedButtons>   frame_buf_keys;
-    std::vector<RGBColor>       new_colors;
-
-    std::copy(colors.begin(), colors.end(),std::back_inserter(new_colors));
-
-    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
-    {
-            SelectedButtons key;
-
-            key.idx     = (unsigned char)leds[led_idx].value;
-            key.red     = RGBGetRValue(colors[led_idx]);
-            key.green   = RGBGetGValue(colors[led_idx]);
-            key.blue    = RGBGetBValue(colors[led_idx]);
-
-            frame_buf_keys.push_back(key);
-    }
-
-    controller->SendInitialize();
-    controller->SendfeatureReport(0x05, 0x01, 0x51, 0x00);
-    controller->SendCommit();
-
-    if(frame_buf_keys.size() > 0)
-    {
-        controller->SendDirectOn(frame_buf_keys);
-    }
-
-    std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
-}
-
-void RGBController_AlienwareAW410K::UpdateZoneLEDs(int zone)
-{
-    controller->SetDirect((unsigned char) zone, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
-}
-
-void RGBController_AlienwareAW410K::UpdateSingleLED(int led)
-{
-    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
-}
-
-void RGBController_AlienwareAW410K::DeviceUpdateMode()
-{
-    if(active_mode == 0xFFFF)
-    {
-        UpdateLEDs();
-        return;
-    }
-
-    controller->SendfeatureReport(0x05, 0x01, 0x51, 0x00);
-    unsigned char red = 0;
-    unsigned char grn = 0;
-    unsigned char blu = 0;
-
-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        red = RGBGetRValue(modes[active_mode].colors[0]);
-        grn = RGBGetGValue(modes[active_mode].colors[0]);
-        blu = RGBGetBValue(modes[active_mode].colors[0]);
-    }
-
-    switch(modes[active_mode].value)
-    {
-        case ALIENWARE_AW410K_MODE_DIRECT:
-            /*-------------------------------------------------------------*\
-            | Load LEDs again in case of profile load etc.                  |
-            \*-------------------------------------------------------------*/
-            DeviceUpdateLEDs();
-            break;  
-        case ALIENWARE_AW410K_MODE_MORPH:
-            /*-------------------------------------------------------------*\
-            | In case of morph it requires two colors (color1 and color2)   |
-            \*-------------------------------------------------------------*/
-            {
-                unsigned char red2 = RGBGetRValue(modes[active_mode].colors[1]);
-                unsigned char grn2 = RGBGetGValue(modes[active_mode].colors[1]);
-                unsigned char blu2 = RGBGetBValue(modes[active_mode].colors[1]);
-
-                controller->SetMorphMode(modes[active_mode].value, modes[active_mode].speed, red, grn, blu, red2, grn2, blu2);
-            }
-            break;
-
-        case ALIENWARE_AW410K_MODE_SPECTRUM:
-            /*-------------------------------------------------------------*\
-            | Spectrum only set mode, speed and colorMode                   |
-            \*-------------------------------------------------------------*/
-            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, 0x00, ALIENWARE_AW410K_RANBOW_COLOR_MODE, 0x00, 0x00, 0x00);
-            break;
-
-        case ALIENWARE_AW410K_MODE_SINGLE_WAVE:
-            /*-------------------------------------------------------------*\
-            | Wave only set mode, speed, direction and colorMode            |
-            \*-------------------------------------------------------------*/
-            {
-                int waveDirection = GetAW410K_WaveDirection(modes[active_mode].direction);
-                controller->SetMode(modes[active_mode].value, modes[active_mode].speed, waveDirection, ALIENWARE_AW410K_SINGLE_COLOR_MODE, red, grn, blu);
-            }
-            break;
-
-        case ALIENWARE_AW410K_MODE_RAINBOW_WAVE:
-            /*-------------------------------------------------------------*\
-            | Wave only set mode, speed, direction and colorMode            |
-            \*-------------------------------------------------------------*/
-            {
-            int waveDirection = GetAW410K_WaveDirection(modes[active_mode].direction);
-            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, waveDirection, ALIENWARE_AW410K_RANBOW_COLOR_MODE, 0x00, 0x00, 0x00);
-            }
-            break;
-
-
-        default:
-            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, 0x00, ALIENWARE_AW410K_SINGLE_COLOR_MODE, red, grn, blu);
-            break;
-    }
-}
-
-int GetAW410K_WaveDirection(int input)
-{
-    switch(input)
-    {
-        case MODE_DIRECTION_LEFT:
-            return(ALIENWARE_AW410K_DIRECTION_RIGHT_TO_LEFT);
-
-        case MODE_DIRECTION_RIGHT:
-            return(ALIENWARE_AW410K_DIRECTION_LEFT_TO_RIGHT);
-
-        case MODE_DIRECTION_UP:
-            return(ALIENWARE_AW410K_DIRECTION_BOTTOM_TO_TOP);
-
-        case MODE_DIRECTION_DOWN:
-            return(ALIENWARE_AW410K_DIRECTION_TOP_TO_BOTTOM);
-
-        default:
-            return(ALIENWARE_AW410K_DIRECTION_RIGHT_TO_LEFT);
-    }
-}
-
@@ -1,36 +0,0 @@
-/*------------------------------------------------------*\
-|  RGBController_AlienwareAW410K.h                       |
-|                                                        |
-|  Generic RGB Interface for Alienware                   |
-|  AW410K keyboard                                       |
-|                                                        |
-|  based on AW510K controller by Mohamad Sallal - msallal|
-|                                                        |
-|  Dominik Mikolajczyk - dmiko 23/10/2023                |
-\*------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AlienwareAW410KController.h"
-
-class RGBController_AlienwareAW410K : public RGBController
-{
-public:
-    RGBController_AlienwareAW410K(AlienwareAW410KController* controller_ptr);
-    ~RGBController_AlienwareAW410K();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AlienwareAW410KController*  controller;
-    std::vector<RGBColor>       current_colors;
-};
@@ -45,9 +45,9 @@ typedef struct
    const char *        name;
    const unsigned char zone;
    const unsigned char idx;
-} aw510k_led_type;
+} led_type;

-static const aw510k_led_type led_names[] =
+static const led_type led_names[] =
 {
    /* Key Label                Zone,                                      Index  */
    { KEY_EN_ESCAPE,            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB0    },
@@ -4,13 +4,11 @@
 #include "RGBController_AnnePro2.h"
 #include <hidapi/hidapi.h>

-#define ANNE_PRO_2_VID_1 0x04D9
-#define ANNE_PRO_2_VID_2 0x3311
+#define ANNE_PRO_2_VID 0x04D9
 #define ANNE_PRO_2_PID_1 0x8008
 #define ANNE_PRO_2_PID_2 0x8009
 #define ANNE_PRO_2_PID_3 0xA292
 #define ANNE_PRO_2_PID_4 0xA293
-#define ANNE_PRO_2_PID_5 0xA297

 /******************************************************************************************\
 *                                                                                          *
@@ -32,8 +30,7 @@ void DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
    }
 }

-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_1, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_2, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_3, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_4, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_2, ANNE_PRO_2_PID_5, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_1, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_2, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_3, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_4, 1);
@@ -40,9 +40,9 @@ typedef struct
 {
    const char *        name;
    const unsigned char idx;
-} annepro2_led_type;
+} led_type;

-static const annepro2_led_type led_names[] =
+static const led_type led_names[] =
 {
    /* Key Label                Index  */
    { KEY_EN_ESCAPE,            0       },
@@ -1,155 +0,0 @@
-/*-----------------------------------------*\
-|  ArcticController.h                       |
-|                                           |
-|  Controller Interface for Arctic devices  |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
-
-#include "ArcticController.h"
-#include <cstring>
-
-using namespace std::chrono_literals;
-
-#define ARCTIC_COMMAND_SET_RGB          0x00
-#define ARCTIC_COMMAND_IDENTIFY         0x5C
-
-#define ARCTIC_RESPONSE_BUFFER_LENGTH   15
-#define ARCTIC_RESPONSE_COMMAND_OFFSET  0
-#define ARCTIC_RESPONSE_DATA_OFFSET     1
-#define ARCTIC_RESPONSE_DATA_LENGTH     12
-#define ARCTIC_RESPONSE_XOR_CSUM_OFFSET 13
-#define ARCTIC_RESPONSE_ADD_CSUM_OFFSET 14
-
-#define ARCTIC_COMMAND_BUFFER_LENGTH(payload_size)  (sizeof(header) + 1 + payload_size)
-#define ARCTIC_COMMAND_COMMAND_OFFSET               (sizeof(header))
-#define ARCTIC_COMMAND_PAYLOAD_OFFSET               (sizeof(header) + 1)
-
-const unsigned char header[] =
-{
-    0x01,
-    0x02,
-    0x03,
-    0xFF,
-    0x05,
-    0xFF,
-    0x02,
-    0x03
-};
-
-const unsigned char identify_payload[] =
-{
-    0x01,
-    0xFE,
-    0x01,
-    0xFE
-};
-
-ArcticController::ArcticController(const std::string &portname)
-: serialport(portname.c_str(), 250000, SERIAL_PORT_PARITY_NONE, SERIAL_PORT_SIZE_8, SERIAL_PORT_STOP_BITS_2, false)
-{
-    port_name = portname;
-    serialport.serial_set_dtr(true);
-}
-
-ArcticController::~ArcticController()
-{
-    serialport.serial_set_dtr(false);
-}
-
-static void FormatCommandBuffer(char *buffer, char command)
-{
-    std::memcpy(buffer, header, sizeof(header));
-    buffer[ARCTIC_COMMAND_COMMAND_OFFSET] = command;
-}
-
-void ArcticController::SetChannels(std::vector<RGBColor> colors)
-{
-    char* buffer = new char[ARCTIC_COMMAND_BUFFER_LENGTH(colors.size() * 3)];
-
-    FormatCommandBuffer(buffer, ARCTIC_COMMAND_SET_RGB);
-
-    for(unsigned int channel = 0; channel < colors.size(); channel++)
-    {
-        const unsigned int offset = ARCTIC_COMMAND_PAYLOAD_OFFSET + channel * 3;
-
-        buffer[offset + 0x00] = std::min<unsigned int>(254, RGBGetRValue(colors[channel]));
-        buffer[offset + 0x01] = std::min<unsigned int>(254, RGBGetGValue(colors[channel]));
-        buffer[offset + 0x02] = std::min<unsigned int>(254, RGBGetBValue(colors[channel]));
-    }
-
-    serialport.serial_write(buffer, sizeof(buffer));
-
-    delete[] buffer;
-}
-
-static char XORChecksum(char *data, int length)
-{
-    char sum = 0;
-
-    for(int i = 0; i < length; i++)
-    {
-        sum ^= data[i];
-    }
-
-    return sum;
-}
-
-static char AddChecksum(char *data, int length)
-{
-    char sum = 0;
-
-    for(int i = 0; i < length; i++)
-    {
-        sum = (char)(sum + data[i]);
-    }
-
-    return sum;
-}
-
-bool ArcticController::IsPresent()
-{
-    char buffer[ARCTIC_COMMAND_BUFFER_LENGTH(sizeof(identify_payload))];
-    char response[ARCTIC_RESPONSE_BUFFER_LENGTH];
-    int ret;
-
-    FormatCommandBuffer(buffer, ARCTIC_COMMAND_IDENTIFY);
-    std::memcpy(buffer + ARCTIC_COMMAND_PAYLOAD_OFFSET, identify_payload, sizeof(identify_payload));
-
-    serialport.serial_flush_rx();
-    ret = serialport.serial_write(buffer, sizeof(buffer));
-    if(ret != sizeof(buffer))
-    {
-        return false;
-    }
-
-    std::this_thread::sleep_for(100ms);
-
-    ret = serialport.serial_read(response, sizeof(response));
-    if(ret != sizeof(response))
-    {
-        return false;
-    }
-
-    if(response[ARCTIC_RESPONSE_COMMAND_OFFSET] != ARCTIC_COMMAND_IDENTIFY)
-    {
-        return false;
-    }
-
-    if(response[ARCTIC_RESPONSE_XOR_CSUM_OFFSET] != XORChecksum(&response[ARCTIC_RESPONSE_DATA_OFFSET], ARCTIC_RESPONSE_DATA_LENGTH))
-    {
-        return false;
-    }
-
-    if(response[ARCTIC_RESPONSE_ADD_CSUM_OFFSET] != AddChecksum(&response[ARCTIC_RESPONSE_DATA_OFFSET], ARCTIC_RESPONSE_DATA_LENGTH))
-    {
-        return false;
-    }
-
-    return true;
-}
-
-std::string ArcticController::GetLocation()
-{
-    return port_name;
-}
@@ -1,29 +0,0 @@
-/*-----------------------------------------*\
-|  ArcticController.h                       |
-|                                           |
-|  Controller Interface for Arctic devices  |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
-
-#pragma once
-#include <algorithm>
-
-#include "RGBController.h"
-#include "serial_port.h"
-
-class ArcticController
-{
-public:
-    ArcticController(const std::string &portname);
-    ~ArcticController();
-
-    void SetChannels(std::vector<RGBColor> colors);
-    bool IsPresent();
-
-    std::string GetLocation();
-
-private:
-    std::string port_name;
-    serial_port serialport;
-};
@@ -1,48 +0,0 @@
-/*-----------------------------------------*\
-|  ArcticControllerDetect.cpp               |
-|                                           |
-|  Detect Arctic RGB controllers            |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
-
-#include "Detector.h"
-#include "ArcticController.h"
-#include "RGBController.h"
-#include "RGBController_Arctic.h"
-#include "find_usb_serial_port.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-#define CH341_VID   0x1A86
-#define CH341_PID   0x7523
-
-void DetectArcticControllers()
-{
-    std::vector<std::string *> ports = find_usb_serial_port(CH341_VID, CH341_PID);
-
-    for(unsigned int device = 0; device < ports.size(); device++)
-    {
-        ArcticController *controller = new ArcticController(*ports[device]);
-
-        if(controller->IsPresent())
-        {
-            RGBController_Arctic *rgb_controller = new RGBController_Arctic(controller);
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
-        }
-        else
-        {
-            delete controller;
-        }
-
-        delete ports[device];
-    }
-}
-
-REGISTER_DETECTOR("Arctic RGB controller", DetectArcticControllers);
-/*---------------------------------------------------------------------------------------------------------*\
-| Entries for dynamic UDEV rules                                                                            |
-|                                                                                                           |
-| DUMMY_DEVICE_DETECTOR("Arctic RGB controller", DetectArcticControllers, 0x1a86, 0x7523 )                  |
-\*---------------------------------------------------------------------------------------------------------*/
@@ -1,131 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_Arctic.h                   |
-|                                           |
-|  Generic RGB Interface for Arctic devices |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
-
-#include "RGBController_Arctic.h"
-#include <math.h>
-
-using namespace std::chrono_literals;
-
-#define ARCTIC_NUM_CHANNELS     4
-#define ARCTIC_SLEEP_THRESHOLD  100ms
-#define ARCTIC_KEEPALIVE_PERIOD 500ms  /* Device requires at least 1s */
-
-/**------------------------------------------------------------------*\
-    @name Arctic RGB Controller Devices
-    @category LEDStrip
-    @type Serial
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectArcticControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_Arctic::RGBController_Arctic(ArcticController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "Arctic RGB Controller";
-    vendor      = "Arctic";
-    description = "Arctic 4-Channel RGB Controller";
-    location    = controller->GetLocation();
-    type        = DEVICE_TYPE_LEDSTRIP;
-
-    mode DirectMode;
-    DirectMode.name         = "Direct";
-    DirectMode.value        = 0;
-    DirectMode.flags        = MODE_FLAG_HAS_PER_LED_COLOR;
-    DirectMode.color_mode   = MODE_COLORS_PER_LED;
-
-    modes.push_back(DirectMode);
-
-    SetupZones();
-
-    keepalive_thread_run = true;
-    keepalive_thread = std::thread(&RGBController_Arctic::KeepaliveThreadFunction, this);
-}
-
-RGBController_Arctic::~RGBController_Arctic()
-{
-    keepalive_thread_run = false;
-    keepalive_thread.join();
-    delete controller;
-}
-
-void RGBController_Arctic::SetupZones()
-{
-    for(int channel = 0; channel < ARCTIC_NUM_CHANNELS; channel++)
-    {
-        zone LedZone;
-        LedZone.name        = "LED Strip " + std::to_string(channel);
-        LedZone.type        = ZONE_TYPE_SINGLE;
-        LedZone.leds_count  = 1;
-        LedZone.leds_min    = 1;
-        LedZone.leds_max    = 1;
-        LedZone.matrix_map  = nullptr;
-
-        led Led;
-        Led.name    = LedZone.name + " LED";
-        Led.value   = channel;
-
-        zones.push_back(LedZone);
-        leds.push_back(Led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_Arctic::ResizeZone(int /* zone */, int /* new_size */)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_Arctic::DeviceUpdateLEDs()
-{
-    last_update_time = std::chrono::steady_clock::now();
-
-    controller->SetChannels(colors);
-}
-
-void RGBController_Arctic::UpdateZoneLEDs(int /* zone */)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_Arctic::UpdateSingleLED(int /* led */)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_Arctic::DeviceUpdateMode()
-{
-    /*---------------------------------------------------------*\
-    | This device does not support mode updates                 |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_Arctic::KeepaliveThreadFunction()
-{
-    std::chrono::nanoseconds sleep_time;
-
-    while(keepalive_thread_run.load())
-    {
-        sleep_time = ARCTIC_KEEPALIVE_PERIOD - (std::chrono::steady_clock::now() - last_update_time);
-        if(sleep_time <= ARCTIC_SLEEP_THRESHOLD)
-        {
-            UpdateLEDs();   // Already protected thru a device update thread
-            std::this_thread::sleep_for(ARCTIC_KEEPALIVE_PERIOD);
-        }
-        else
-        {
-            std::this_thread::sleep_for(sleep_time);
-        }
-    }
-}
@@ -1,40 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_Arctic.h                   |
-|                                           |
-|  Generic RGB Interface for Arctic devices |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 27/08/2023         |
-\*-----------------------------------------*/
-
-#pragma once
-#include "ArcticController.h"
-#include "RGBController.h"
-#include "serial_port.h"
-#include <chrono>
-#include <thread>
-
-class RGBController_Arctic : public RGBController
-{
-public:
-    RGBController_Arctic(ArcticController* controller_ptr);
-    ~RGBController_Arctic();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-    void        KeepaliveThreadFunction();
-
-private:
-    ArcticController*                                   controller;
-    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
-    std::atomic<bool>                                   keepalive_thread_run;
-    std::thread                                         keepalive_thread;
-};
-
@@ -55,4 +55,3 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreContro
 REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1866);
 REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1869);
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 15",      DetectAsusAuraCoreLaptopControllers,    AURA_CORE_VID, AURA_STRIX_SCAR_15_PID,  0xFF31, 0x79);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 17",      DetectAsusAuraCoreLaptopControllers,    AURA_CORE_VID, 0x1866,                  0xFF31, 0x79);
@@ -9,8 +9,6 @@

 #include "AsusAuraCoreLaptopController.h"

-#include "SettingsManager.h"
-
 static uint8_t packet_map[ASUSAURACORELAPTOP_KEYCOUNT       +
                          ASUSAURACORELAPTOP_LIGHTBARCOUNT  +
                          ASUSAURACORELAPTOP_LIDCOUNT       ] =
@@ -13,6 +13,7 @@
 #include "LogManager.h"
 #include "RGBController.h"
 #include "ResourceManager.h"
+#include "SettingsManager.h"
 #include "RGBControllerKeyNames.h"

 #pragma once
@@ -406,8 +406,6 @@ void RGBController_AsusAuraCoreLaptop::Init_Controller()
    lightbar.leds_min           = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
    lightbar.leds_max           = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
    lightbar.leds_count         = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
-    lightbar.matrix_map         = NULL;
-
    zones.push_back(lightbar);

    zone lid;
@@ -416,8 +414,6 @@ void RGBController_AsusAuraCoreLaptop::Init_Controller()
    lid.leds_min                = ASUSAURACORELAPTOP_LIDCOUNT;
    lid.leds_max                = ASUSAURACORELAPTOP_LIDCOUNT;
    lid.leds_count              = ASUSAURACORELAPTOP_LIDCOUNT;
-    lid.matrix_map              = NULL;
-
    zones.push_back(lid);
 }

@@ -7,7 +7,6 @@
 \*-----------------------------------------*/

 #include "AsusAuraGPUController.h"
-#include "pci_ids.h"
 #include <cstring>

 AuraGPUController::AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id dev)
@@ -53,16 +52,25 @@ unsigned char AuraGPUController::GetLEDBlue()
    return(AuraGPURegisterRead(AURA_GPU_REG_BLUE));
 }

-void AuraGPUController::SetLEDColors(unsigned char red, unsigned char green, unsigned char blue)
+void AuraGPUController::SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue)                  // Direct Mode is just Static Mode without applying color changes
 {
    AuraGPURegisterWrite(AURA_GPU_REG_RED, red);
    AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green);
    AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue);
 }

+void AuraGPUController::SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
+{
+    AuraGPURegisterWrite(AURA_GPU_REG_RED, red);
+    AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green);
+    AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue);
+    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
+}
+
 void AuraGPUController::SetMode(unsigned char mode)
 {
    AuraGPURegisterWrite(AURA_GPU_REG_MODE, mode);
+    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
 }

 unsigned char AuraGPUController::AuraGPURegisterRead(unsigned char reg)
@@ -73,21 +81,4 @@ unsigned char AuraGPUController::AuraGPURegisterRead(unsigned char reg)
 void AuraGPUController::AuraGPURegisterWrite(unsigned char reg, unsigned char val)
 {
    bus->i2c_smbus_write_byte_data(dev, reg, val);
-}
-
-bool AuraGPUController::SaveOnlyApplies()
-{
-    switch (bus->pci_subsystem_device)
-    {
-        case ASUS_VEGA64_STRIX:
-            return false;
-    }
-    // Behavior on other GPU models is unknown and needs to be tested.
-    // Assume the safest option to prevent damaage from excessive writes.
-    return false;
-}
-
-void AuraGPUController::Save()
-{
-    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
-}
+}
@@ -23,7 +23,7 @@ enum
    AURA_GPU_REG_BLUE                       = 0x06,    /* AURA GPU BLUE Register           */
    AURA_GPU_REG_MODE                       = 0x07,    /* AURA GPU Mode Selection Register */
    AURA_GPU_REG_SYNC                       = 0x0C,    /* AURA GPU "Sync" Register         */
-    AURA_GPU_REG_APPLY                      = 0x0E,    /* AURA GPU Save or Apply Register  */
+    AURA_GPU_REG_APPLY                      = 0x0E,    /* AURA GPU Apply Chnages Register  */
 };

 enum
@@ -48,18 +48,17 @@ public:
    unsigned char GetLEDRed();
    unsigned char GetLEDGreen();
    unsigned char GetLEDBlue();
-    void          SetLEDColors(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
    void          SetMode(unsigned char mode);
-    void          Save();

    unsigned char AuraGPURegisterRead(unsigned char reg);
    void          AuraGPURegisterWrite(unsigned char reg, unsigned char val);

-    bool          SaveOnlyApplies();
    bool          direct = false;                                                // Temporary solution to check if we are in "Direct" mode

 private:
    char                    device_name[16];
    i2c_smbus_interface *   bus;
    aura_gpu_dev_id         dev;
-};
+};
@@ -69,69 +69,68 @@ void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
 |  NVidia GPUs                              |
 \*-----------------------------------------*/

-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 O2G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti 4G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti O4G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti O4G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1060 Strix 6G Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX_6G_GAMING,               0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1060 Strix"                      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX,                         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1070 Strix Gaming"               , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_GAMING,                  0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1070 Strix OC"                   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_OC,                      0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1070 Ti 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1070 Ti A8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1080 Strix OC"                   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_GTX1080_STRIX,                         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 A8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 O8G 11Gbps"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_11GBPS,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650 SUPER OC 4G"          , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 SUPER O6G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 SUPER 6G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_6G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 Ti OC 6G"             , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_GTX1660TI_OC,                      0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 EVO Gaming 6G"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G EVO Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER 8G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER A8G EVO Gaming" , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER 8G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G V2 Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING,       0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER O8G White"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C,   0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060 Ti 8G Gaming OC"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 O2G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI 4G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1060 Strix 6G Gaming"             , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX_6G_GAMING,               0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1060 Strix"                       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX,                         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1070 Strix Gaming"                , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_GAMING,                  0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1070 Strix OC"                    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_OC,                      0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1070 Ti 8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1070 Ti A8G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1080 Strix OC"                    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_GTX1080_STRIX,                         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 A8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 O8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 O8G 11Gbps"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_11GBPS,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti Gaming"          , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti 11G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti O11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti O11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650S OC 4G"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660S O6G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1660 Ti OC 6G"                , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_GTX1660TI_OC,                      0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G EVO Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S 8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G EVO Gaming"   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S 8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G V2 Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G White"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C,   0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060 Ti 8G Gaming OC"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A);

 /*-----------------------------------------*\
 |  AMD GPUs                                 |
 \*-----------------------------------------*/

-REGISTER_I2C_PCI_DETECTOR("ASUS AREZ Strix RX Vega 56 O8G"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Vega 64 Strix"                       , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5600 XT Strix O6G Gaming"         , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5700 XT Strix Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5700 XT Strix 08G Gaming"         , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING,             0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 470 O4G Gaming"             , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 480 Gaming OC"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 560 Gaming"                 , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 570 Strix O4G Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 570 Strix O8G Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O8G_GAMING_OC,             0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 580 Strix Gaming OC"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_OC,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 580 Strix Gaming TOP"             , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS AREZ Strix RX Vega 56 O8G"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS Vega 64 Strix"                        , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 5600XT Strix O6G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix 08G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING,             0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX470 O4G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX480 Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX560 Gaming"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O4G Gaming OC"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O8G Gaming OC"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O8G_GAMING_OC,             0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming OC"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_OC,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming TOP"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);
@@ -45,15 +45,11 @@ int RGBController_AuraGPU::GetDeviceMode()
    @name Asus Aura GPU
    @category GPU
    @type SMBus
-    @save :tools:
+    @save :x:
    @direct :white_check_mark:
    @effects :white_check_mark:
    @detectors DetectAsusAuraGPUControllers
-    @comment On some models save command might function like apply.
-        Known models with correctly working save: ASUS Vega 64 Strix.
-        This may result in changes not applying until user clicks
-        "save to device". Contact OpenRGB developers if you have one
-        of the affected models.
+    @comment
 \*-------------------------------------------------------------------*/

 RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * controller_ptr)
@@ -73,44 +69,38 @@ RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * controller_ptr)
    Direct.color_mode = MODE_COLORS_PER_LED;
    modes.push_back(Direct);

-    unsigned int save_flags = 0;
-    if(!controller->SaveOnlyApplies())
-    {
-        save_flags |= MODE_FLAG_MANUAL_SAVE;
-    }
-
    mode Off;
    Off.name       = "Off";
    Off.value      = AURA_GPU_MODE_OFF;
-    Off.flags      = save_flags;
+    Off.flags      = 0;
    Off.color_mode = MODE_COLORS_NONE;
    modes.push_back(Off);

    mode Static;
    Static.name       = "Static";
    Static.value      = AURA_GPU_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR | save_flags;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
    Static.color_mode = MODE_COLORS_PER_LED;
    modes.push_back(Static);

    mode Breathing;
    Breathing.name       = "Breathing";
    Breathing.value      = AURA_GPU_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR | save_flags;
+    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
    Breathing.color_mode = MODE_COLORS_PER_LED;
    modes.push_back(Breathing);

    mode Flashing;
    Flashing.name       = "Flashing";
    Flashing.value      = AURA_GPU_MODE_FLASHING;
-    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR | save_flags;
+    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
    Flashing.color_mode = MODE_COLORS_PER_LED;
    modes.push_back(Flashing);

    mode Spectrum_Cycle;
    Spectrum_Cycle.name       = "Spectrum Cycle";
-    Spectrum_Cycle.value      = AURA_GPU_MODE_SPECTRUM_CYCLE ;
-    Spectrum_Cycle.flags      = save_flags;
+    Spectrum_Cycle.value      = AURA_GPU_MODE_SPECTRUM_CYCLE;
+    Spectrum_Cycle.flags      = 0;
    Spectrum_Cycle.color_mode = MODE_COLORS_NONE;
    modes.push_back(Spectrum_Cycle);

@@ -172,11 +162,14 @@ void RGBController_AuraGPU::DeviceUpdateLEDs()
        unsigned char grn = RGBGetGValue(colors[led]);
        unsigned char blu = RGBGetBValue(colors[led]);

-        controller->SetLEDColors(red, grn, blu);
-    }
-    if (controller->SaveOnlyApplies() && GetMode() != 0)
-    {
-        controller->Save();
+        if (GetMode() == 0)
+        {
+            controller->SetLEDColorsDirect(red, grn, blu);
+        }
+        else
+        {
+            controller->SetLEDColorsEffect(red, grn, blu);
+        }
    }
 }

@@ -199,7 +192,7 @@ void RGBController_AuraGPU::DeviceUpdateMode()
    {
        // Set all LEDs to 0 and Mode to static as a workaround for the non existing Off Mode
        case AURA_GPU_MODE_OFF:
-            controller->SetLEDColors(0, 0, 0);
+            controller->SetLEDColorsEffect(0, 0, 0);
            new_mode           = AURA_GPU_MODE_STATIC;
            break;

@@ -211,13 +204,4 @@ void RGBController_AuraGPU::DeviceUpdateMode()
    }

    controller->SetMode(new_mode);
-    if (controller->SaveOnlyApplies())
-    {
-        controller->Save();
-    }
-}
-
-void RGBController_AuraGPU::DeviceSaveMode()
-{
-    controller->Save();
 }
@@ -26,7 +26,6 @@ public:
    void        UpdateSingleLED(int led);

    void        DeviceUpdateMode();
-    void        DeviceSaveMode();

 private:
    AuraGPUController* controller;
@@ -28,12 +28,37 @@ AuraAddressableController::~AuraAddressableController()

 void AuraAddressableController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
 {
-    SendDirect
-    (
-        device_info[channel].direct_channel,
-        num_colors,
-        colors
-    );
+    unsigned char   led_data[60];
+    unsigned int    leds_sent = 0;
+
+    while(leds_sent < num_colors)
+    {
+        unsigned int leds_to_send = 20;
+
+        if((num_colors - leds_sent) < leds_to_send)
+        {
+            leds_to_send = num_colors - leds_sent;
+        }
+
+        for(unsigned int led_idx = 0; led_idx < leds_to_send; led_idx++)
+        {
+            led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx + leds_sent]);
+            led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx + leds_sent]);
+            led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx + leds_sent]);
+        }
+
+        SendDirect
+        (
+            channel,
+            leds_sent,
+            leds_to_send,
+            led_data
+        );
+
+        leds_sent += leds_to_send;
+    }
+
+    SendDirectApply(channel);
 }

 void AuraAddressableController::SetMode
@@ -92,3 +117,28 @@ void AuraAddressableController::SendEffect
    \*-----------------------------------------------------*/
    hid_write(dev, usb_buf, 65);
 }
+
+void AuraAddressableController::SendDirectApply
+    (
+    unsigned char   channel
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
+    usb_buf[0x02]   = 0x80 | channel;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+}
@@ -52,4 +52,9 @@ private:
        unsigned char   grn,
        unsigned char   blu
        );
+
+    void    SendDirectApply
+        (
+        unsigned char   channel
+        );
 };
@@ -15,7 +15,6 @@ AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const c
    unsigned char num_total_mainboard_leds  = config_table[0x1B];
    unsigned char num_rgb_headers           = config_table[0x1D];
    unsigned char num_addressable_headers   = config_table[0x02];
-    unsigned char effect_channel            = 0;

    if(num_total_mainboard_leds < num_rgb_headers)
    {
@@ -25,18 +24,14 @@ AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const c
    /*-----------------------------------------------------*\
    | Add mainboard device                                  |
    \*-----------------------------------------------------*/
-    if(num_total_mainboard_leds > 0)
-    {
-        device_info.push_back({effect_channel, 0x04, num_total_mainboard_leds, num_rgb_headers, AuraDeviceType::FIXED});
-        effect_channel++;
-    }
+    device_info.push_back({0x00, 0x04, num_total_mainboard_leds, num_rgb_headers, AuraDeviceType::FIXED});

    /*-----------------------------------------------------*\
    | Add addressable devices                               |
    \*-----------------------------------------------------*/
    for(int i = 0; i < num_addressable_headers; i++)
    {
-        device_info.push_back({effect_channel, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
+        device_info.push_back({0x01, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
    }
 }

@@ -46,13 +41,36 @@ AuraMainboardController::~AuraMainboardController()

 void AuraMainboardController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
 {
-    SendDirect
-    (
-        device_info[channel].direct_channel,
-        num_colors,
-        colors
-    );
+    unsigned char   led_data[60];
+    unsigned int    leds_sent = 0;

+    while(leds_sent < num_colors)
+    {
+        unsigned int leds_to_send = 20;
+
+        if((num_colors - leds_sent) < leds_to_send)
+        {
+            leds_to_send = num_colors - leds_sent;
+        }
+
+        for(unsigned int led_idx = 0; led_idx < leds_to_send; led_idx++)
+        {
+            led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx + leds_sent]);
+            led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx + leds_sent]);
+            led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx + leds_sent]);
+        }
+
+        SendDirect
+        (
+            device_info[channel].direct_channel,
+            leds_sent,
+            leds_to_send,
+            led_data,
+            leds_sent + leds_to_send >= num_colors
+        );
+
+        leds_sent += leds_to_send;
+    }
 }

 void AuraMainboardController::SetMode
@@ -63,24 +81,11 @@ void AuraMainboardController::SetMode
    unsigned char   grn,
    unsigned char   blu
    )
-{
-    SetMode(channel, mode, red, grn, blu, false);
-}
-
-void AuraMainboardController::SetMode
-    (
-    unsigned char   channel,
-    unsigned char   mode,
-    unsigned char   red,
-    unsigned char   grn,
-    unsigned char   blu,
-    bool            shutdown_effect
-    )
 {
    this->mode = mode;
    RGBColor color = ToRGBColor(red, grn, blu);

-    SendEffect(device_info[channel].effect_channel, mode, shutdown_effect);
+    SendEffect(device_info[channel].effect_channel, mode);
    if(mode == AURA_MODE_DIRECT)
    {
        return;
@@ -106,8 +111,7 @@ void AuraMainboardController::SetMode
        channel,
        start_led,
        device_info[channel].num_leds,
-        led_data,
-        shutdown_effect
+        led_data
    );
 }

@@ -119,8 +123,7 @@ unsigned short AuraMainboardController::GetMask(int start, int size)
 void AuraMainboardController::SendEffect
    (
    unsigned char   channel,
-    unsigned char   mode,
-    bool            shutdown_effect
+    unsigned char   mode
    )
 {
    unsigned char usb_buf[65];
@@ -137,7 +140,7 @@ void AuraMainboardController::SendEffect
    usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT;
    usb_buf[0x02]   = channel;
    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = shutdown_effect ? 0x01 : 0x00;
+    usb_buf[0x04]   = 0x00;
    usb_buf[0x05]   = mode;

    /*-----------------------------------------------------*\
@@ -151,8 +154,7 @@ void AuraMainboardController::SendColor
    unsigned char   /*channel*/,
    unsigned char   start_led,
    unsigned char   led_count,
-    unsigned char*  led_data,
-    bool            shutdown_effect
+    unsigned char*  led_data
    )
 {
    unsigned short  mask = GetMask(start_led, led_count);
@@ -170,7 +172,7 @@ void AuraMainboardController::SendColor
    usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT_COLOR;
    usb_buf[0x02]   = mask >> 8;
    usb_buf[0x03]   = mask & 0xff;
-    usb_buf[0x04]   = shutdown_effect ? 0x01 : 0x00;
+    usb_buf[0x04]   = 0x00;

    /*-----------------------------------------------------*\
    | Copy in color data bytes                              |
@@ -44,28 +44,15 @@ public:
        unsigned char   blu
        );

-    void SetMode
-        (
-        unsigned char   channel,
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu,
-        bool            shutdown_effect
-        );
-
-    void SendCommit();
-
 private:
    unsigned int mode;

    unsigned short GetMask(int start, int size);
-
+    
    void SendEffect
        (
        unsigned char   channel,
-        unsigned char   mode,
-        bool            shutdown_effect
+        unsigned char   mode
        );

    void SendColor
@@ -73,7 +60,8 @@ private:
        unsigned char   channel,
        unsigned char   start_led,
        unsigned char   led_count,
-        unsigned char*  led_data,
-        bool            shutdown_effect
+        unsigned char*  led_data
        );
+
+    void SendCommit();
 };
@@ -49,7 +49,7 @@ void AuraMonitorController::BeginUpdate()
 {
    unsigned char usb_buf[8];

-    if (device_pid == AURA_ROG_PG32UQ_PID || device_pid == AURA_ROG_STRIX_XG32VC_PID)
+    if (device_pid == AURA_ROG_PG32UQ_PID)
    {
        memset(usb_buf, 0x00, sizeof(usb_buf));

@@ -19,7 +19,6 @@ enum
    AURA_ROG_STRIX_XG27AQM_PID  = 0x19BB,
    AURA_ROG_STRIX_XG279Q_PID   = 0x1919,
    AURA_ROG_STRIX_XG27W_PID    = 0x1933,
-    AURA_ROG_STRIX_XG32VC_PID   = 0x1968,
    AURA_ROG_PG32UQ_PID         = 0x19B9,
 };

@@ -28,32 +28,6 @@ std::string AuraMouseController::GetDeviceLocation()
    return("HID: " + location);
 }

-std::string AuraMouseController::CleanSerial(const std::wstring& wstr)
-{
-    /*---------------------------------------------------------------*\
-    | Cleanes garbage at the end of serial numbers                    |
-    | (apparently 2 characters too much, but maybe variable)          |
-    | Limited to new devices, old ones don't even have serial numbers |
-    \*---------------------------------------------------------------*/
-    std::string result;
-    for(wchar_t c : wstr)
-    {
-        /*-----------------------------------------------------*\
-        | Forbid anything besides digits and upper case letters |
-        \*-----------------------------------------------------*/
-        bool isUpperCaseLetter = (c >= 64 && c <= 90);
-        bool isDigit           = (c >= 48 && c <= 57);
-        if(!isUpperCaseLetter && !isDigit)
-        {
-            break;
-        }
-
-        result += c;
-    }
-
-    return(result);
-}
-
 std::string AuraMouseController::GetSerialString()
 {
    wchar_t serial_string[HID_MAX_STR];
@@ -64,8 +38,8 @@ std::string AuraMouseController::GetSerialString()
        return("");
    }

-    std::wstring serial_wstring = serial_string;
-    std::string return_string = CleanSerial(serial_wstring);
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());

    return(return_string);
 }
@@ -210,48 +184,3 @@ void AuraMouseController::SendUpdate
    unsigned char usb_buf_out[ASUS_AURA_MOUSE_PACKET_SIZE];
    hid_read_timeout(dev, usb_buf_out, ASUS_AURA_MOUSE_PACKET_SIZE, 10);
 }
-
-void AuraMouseController::SendDirect
-    (
-    std::vector<RGBColor>   zone_colors
-    )
-{
-    std::vector<RGBColor> colors = {};
-    colors.resize(aura_mouse_led_maps[device_pid].led_amount);
-
-    for(unsigned char zone = 0; zone < zone_colors.size(); zone++)
-    {
-        std::vector<uint8_t> zone_map = aura_mouse_led_maps[device_pid].map[zone];
-        for(unsigned char led = 0; led < zone_map.size(); led++)
-        {
-            colors[zone_map[led]] = zone_colors[zone];
-        }
-    }
-
-    /*-----------------------------------------------------*\
-    | Only 5 colors can be sent in each packet              |
-    \*-----------------------------------------------------*/
-    for(unsigned char led = 0; led < aura_mouse_led_maps[device_pid].led_amount; led += 5)
-    {
-        unsigned char usb_buf[ASUS_AURA_MOUSE_PACKET_SIZE];
-        memset(usb_buf, 0x00, ASUS_AURA_MOUSE_PACKET_SIZE);
-
-        unsigned char colors_in_packet = (aura_mouse_led_maps[device_pid].led_amount >= led + 5) ? 5 : aura_mouse_led_maps[device_pid].led_amount - led;
-
-        usb_buf[0x00]   = 0x00;
-        usb_buf[0x01]   = 0x51;
-        usb_buf[0x02]   = 0x29;
-        usb_buf[0x03]   = colors_in_packet; // colors in this packet
-        usb_buf[0x04]   = 0x00;
-        usb_buf[0x05]   = led; // offset
-
-        for(unsigned char color = 0; color < colors_in_packet; color++)
-        {
-            usb_buf[0x06 + color * 3] = RGBGetRValue(colors[led + color]);
-            usb_buf[0x07 + color * 3] = RGBGetGValue(colors[led + color]);
-            usb_buf[0x08 + color * 3] = RGBGetBValue(colors[led + color]);
-        }
-
-        hid_write(dev, usb_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
-    }
-};
@@ -25,7 +25,6 @@ public:
    virtual ~AuraMouseController();

    std::string GetDeviceLocation();
-    std::string CleanSerial(const std::wstring& wstr);
    std::string GetSerialString();
    std::string GetVersion(bool wireless, int protocol);

@@ -42,10 +41,6 @@ public:
        unsigned char   speed,
        unsigned char   brightness
        );
-    void SendDirect
-        (
-        std::vector<RGBColor>   zone_colors
-        );

    uint16_t                    device_pid;

@@ -11,50 +11,42 @@

 #pragma once

-#define AURA_ROG_GLADIUS_II_CORE_PID                    0x18DD
-#define AURA_ROG_GLADIUS_II_PID                         0x1845
-#define AURA_ROG_GLADIUS_II_ORIGIN_PID                  0x1877
-#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID          0x18CD
-#define AURA_ROG_GLADIUS_II_ORIGIN_COD_PID              0x18B1
-#define AURA_ROG_GLADIUS_II_WIRELESS_1_PID              0x189E
-#define AURA_ROG_GLADIUS_II_WIRELESS_2_PID              0x18A0
-#define AURA_ROG_GLADIUS_III_PID                        0x197B
-#define AURA_ROG_GLADIUS_III_WIRELESS_USB_PID           0x197D
-#define AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID           0x197F
-#define AURA_ROG_GLADIUS_III_WIRELESS_BT_PID            0x1981
-#define AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID  0x1A70
-#define AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID  0x1A72
-#define AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_BT_PID   0x1A74
-#define AURA_ROG_CHAKRAM_WIRELESS_PID                   0x18E5
-#define AURA_ROG_CHAKRAM_WIRED_1_PID                    0x18E3
-#define AURA_ROG_CHAKRAM_CORE_PID                       0x1958
-#define AURA_ROG_CHAKRAM_X_USB_PID                      0x1A18
-#define AURA_ROG_CHAKRAM_X_2_4_PID                      0x1A1A
-#define AURA_ROG_SPATHA_X_USB_PID                       0x1977
-#define AURA_ROG_SPATHA_X_2_4_PID                       0x1979
-#define AURA_ROG_SPATHA_X_DOCK_PID                      0x1979
-#define AURA_ROG_PUGIO_PID                              0x1846
-#define AURA_ROG_PUGIO_II_WIRED_PID                     0x1906
-#define AURA_ROG_PUGIO_II_WIRELESS_PID                  0x1908
-#define AURA_ROG_STRIX_IMPACT_PID                       0x1847
-#define AURA_ROG_STRIX_IMPACT_II_PID                    0x18E1
-#define AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID             0x189E
-#define AURA_ROG_STRIX_IMPACT_II_PUNK_PID               0x1956
-#define AURA_ROG_STRIX_IMPACT_II_WHITE_PID              0x19D2
-#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID       0x1947
-#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID       0x1949
-#define AURA_ROG_STRIX_IMPACT_III_PID                   0x1A88
-#define AURA_ROG_KERIS                                  0x195C
-#define AURA_ROG_KERIS_WIRELESS_USB_PID                 0x195E
-#define AURA_ROG_KERIS_WIRELESS_2_4_PID                 0x1960
-#define AURA_ROG_KERIS_WIRELESS_BT_PID                  0x1962
-#define AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID        0x1A66
-#define AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID        0x1A68
-#define AURA_ROG_KERIS_WIRELESS_AIMPOINT_BT_PID         0x1A6A
-#define AURA_TUF_M3_PID                                 0x1910
-#define AURA_TUF_M5_PID                                 0x1898
+#define AURA_ROG_GLADIUS_II_CORE_PID                0x18DD
+#define AURA_ROG_GLADIUS_II_PID                     0x1845
+#define AURA_ROG_GLADIUS_II_ORIGIN_PID              0x1877
+#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID      0x18CD
+#define AURA_ROG_GLADIUS_II_ORIGIN_COD_PID          0x18B1
+#define AURA_ROG_GLADIUS_II_WIRELESS_1_PID          0x189E
+#define AURA_ROG_GLADIUS_II_WIRELESS_2_PID          0x18A0
+#define AURA_ROG_GLADIUS_III_PID                    0x197B
+#define AURA_ROG_GLADIUS_III_WIRELESS_USB_PID       0x197D
+#define AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID       0x197F
+#define AURA_ROG_GLADIUS_III_WIRELESS_BT_PID        0x1981
+#define AURA_ROG_CHAKRAM_WIRELESS_PID               0x18E5
+#define AURA_ROG_CHAKRAM_WIRED_1_PID                0x18E3
+#define AURA_ROG_CHAKRAM_CORE_PID                   0x1958
+#define AURA_ROG_CHAKRAM_X_USB_PID                  0x1A18
+#define AURA_ROG_CHAKRAM_X_2_4_PID                  0x1A1A
+#define AURA_ROG_SPATHA_X_USB_PID                   0x1977
+#define AURA_ROG_SPATHA_X_2_4_PID                   0x1979
+#define AURA_ROG_PUGIO_PID                          0x1846
+#define AURA_ROG_PUGIO_II_WIRED_PID                 0x1906
+#define AURA_ROG_PUGIO_II_WIRELESS_PID              0x1908
+#define AURA_ROG_STRIX_IMPACT_PID                   0x1847
+#define AURA_ROG_STRIX_IMPACT_II_PID                0x18E1
+#define AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID         0x189E
+#define AURA_ROG_STRIX_IMPACT_II_PUNK_PID           0x1956
+#define AURA_ROG_STRIX_IMPACT_II_WHITE_PID          0x19D2
+#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID   0x1947
+#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID   0x1949
+#define AURA_ROG_KERIS                              0x195C
+#define AURA_ROG_KERIS_WIRELESS_USB_PID             0x195E
+#define AURA_ROG_KERIS_WIRELESS_2_4_PID             0x1960
+#define AURA_ROG_KERIS_WIRELESS_BT_PID              0x1962
+#define AURA_TUF_M3_PID                             0x1910
+#define AURA_TUF_M5_PID                             0x1898

-#define AURA_ROG_SPATHA_X_DOCK_FAKE_PID                 0xFFFF
+#define AURA_ROG_SPATHA_X_DOCK_FAKE_PID             0xFFFF

 enum
 {
@@ -74,7 +66,6 @@ enum
    AURA_MOUSE_MODE_REACTIVE    = 4,
    AURA_MOUSE_MODE_COMET       = 5,
    AURA_MOUSE_MODE_BATTERY     = 6,
-    AURA_MOUSE_MODE_DIRECT      = 254,
    AURA_MOUSE_MODE_NONE        = 255,
 };

@@ -86,7 +77,6 @@ typedef struct
    uint8_t                 brightness_max;
    bool                    wireless;
    int                     version_protocol;
-    bool                    direct;
    std::vector<uint8_t>    mouse_zones;
    std::vector<uint8_t>    mouse_modes;
 } mouse_type;
@@ -110,7 +100,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,      // Brightness Max
            false,  // is wireless? (important for fetching the version)
            1,      // version protocol
-            false,  // direct - defines whether the mouse has a native direct mode or just uses static as direct (only present on newer devices)
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
        }
@@ -124,7 +113,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            0,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
        }
@@ -138,7 +126,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            0,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
        }
@@ -152,7 +139,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            0,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
        }
@@ -166,7 +152,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            0,
-            false,
            { AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
        }
@@ -180,7 +165,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            true,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
        }
@@ -194,7 +178,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            true,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
        }
@@ -205,10 +188,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
            255,
            1,
            0,
-            100,
+            64,
            false,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
        }
@@ -219,10 +201,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
            255,
            1,
            0,
-            100,
+            64,
            false,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
        }
@@ -233,10 +214,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
            255,
            1,
            0,
-            100,
+            64,
            true,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
        }
@@ -247,42 +227,13 @@ static std::map<int,mouse_type> aura_mouse_devices =
            255,
            1,
            0,
-            100,
+            64,
            true,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
        }
    },
-    {
-        AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID, // ROG Gladius III Wireless AimPoint USB
-        {
-            255,
-            1,
-            0,
-            100,
-            false,
-            2,
-            true,
-            { AURA_MOUSE_ZONE_LOGO },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID, // ROG Gladius III Wireless AimPoint 2.4 GHz Dongle
-        {
-            255,
-            1,
-            0,
-            100,
-            true,
-            2,
-            true,
-            { AURA_MOUSE_ZONE_LOGO },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
    {
        AURA_ROG_CHAKRAM_WIRELESS_PID, // ROG Chakram Wireless
        {
@@ -292,7 +243,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            true,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
        }
@@ -306,7 +256,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
        }
@@ -320,7 +269,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
        }
@@ -331,10 +279,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
            15, // technically until 255, but unusably slow after 15
            1,
            0,
-            100,
+            64,
            false,
            2,
-            true,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
        }
@@ -345,10 +292,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
            15, // technically until 255, but unusably slow after 15
            1,
            0,
-            100,
+            64,
            true,
            2,
-            true,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
        }
@@ -359,10 +305,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
            15, // technically until 255, but unusably slow after 15
            1,
            0,
-            100,
+            64,
            false,
            1,
-            true,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
        }
@@ -373,10 +318,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
            15, // technically until 255, but unusably slow after 15
            1,
            0,
-            100,
+            64,
            true,
            1,
-            true,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
        }
@@ -390,7 +334,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            0,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
        }
@@ -404,7 +347,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
        }
@@ -418,7 +360,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            true,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
        }
@@ -432,7 +373,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            4,
-            false,
            { AURA_MOUSE_ZONE_LOGO },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
        }
@@ -446,7 +386,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
        }
@@ -460,7 +399,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
        }
@@ -474,7 +412,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
        }
@@ -488,7 +425,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
        }
@@ -502,7 +438,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            1, // not tested, but likely same as ROG Strix Impact II non wireless
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
        }
@@ -516,25 +451,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            true,
            1, // not tested, but likely same as ROG Strix Impact II non wireless
-            false,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
        }
    },
-    {
-        AURA_ROG_STRIX_IMPACT_III_PID, // ROG Strix Impact III
-        {
-            0,
-            0,
-            0,
-            100,
-            false,
-            1,
-            true,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
-        }
-    },
    {
        AURA_ROG_KERIS, // ROG Keris
        {
@@ -543,8 +463,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
            0,
            4,
            false,
-            1,
-            false,
+            1, // might be the wrong protocol for version
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
        }
@@ -556,9 +475,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
            0,
            0,
            4,
-            false,
-            1,
-            false,
+            true,
+            1, // might be the wrong protocol for version
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
        }
@@ -571,8 +489,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
            0,
            4,
            true,
-            1,
-            false,
+            1, // might be the wrong protocol for version
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
        }
@@ -585,40 +502,11 @@ static std::map<int,mouse_type> aura_mouse_devices =
            0,
            4,
            true,
-            1,
-            false,
+            1, // might be the wrong protocol for version
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
        }
    },
-    {
-        AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID, // ROG Keris Wireless AimPoint
-        {
-            0,
-            0,
-            0,
-            100,
-            false,
-            1,
-            true,
-            { AURA_MOUSE_ZONE_LOGO },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID, // ROG Keris Wireless AimPoint
-        {
-            0,
-            0,
-            0,
-            100,
-            true,
-            2,
-            true,
-            { AURA_MOUSE_ZONE_LOGO },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
    {
        AURA_TUF_M3_PID, // TUF M3
        {
@@ -628,7 +516,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            1,
-            false,
            { AURA_MOUSE_ZONE_LOGO },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
        }
@@ -642,7 +529,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            4,
            false,
            3,
-            false,
            { AURA_MOUSE_ZONE_LOGO },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
        }
@@ -656,118 +542,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
            100,
            false,
            1,
-            false,
            { AURA_MOUSE_ZONE_DOCK },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
        }
    },
 };
-
-typedef struct
-{
-    unsigned char                                           led_amount;
-    std::map< unsigned char, std::vector<unsigned char>>    map;
-} led_map;
-
-/*-----------------------------------------------------------------*\
-|  LED MAP                                                          |
-|                                                                   |
-|    This maps the LEDs to the correct zone.                        |
-|    This is necessary, because openrgb doesn't support per-zone    |
-|    lighting. To allow for per-zone color of modes like breathing, |
-|    the leds defined need to be the zones, which means the actual  |
-|    LEDs can't be implemented.                                     |
-\*-----------------------------------------------------------------*/
-static std::map<unsigned short, led_map > aura_mouse_led_maps =
-{
-    {
-        AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID,
-        {
-            1,
-            {
-                { AURA_MOUSE_ZONE_LOGO, { 0 } },
-            }
-        }
-    },
-    {
-        AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID,
-        {
-            1,
-            {
-                { AURA_MOUSE_ZONE_LOGO, { 0 } },
-            }
-        }
-    },
-    {
-        AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID,
-        {
-            1,
-            {
-                { AURA_MOUSE_ZONE_LOGO, { 0 } },
-            }
-        }
-    },
-    {
-        AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID,
-        {
-            1,
-            {
-                { AURA_MOUSE_ZONE_LOGO, { 0 } },
-            }
-        }
-    },
-    {
-        AURA_ROG_SPATHA_X_2_4_PID,
-        {
-            5,
-            {
-                { AURA_MOUSE_ZONE_LOGO, { 0 } },
-                { AURA_MOUSE_ZONE_SCROLL, { 1 } },
-                { AURA_MOUSE_ZONE_UNDERGLOW, { 2, 3, 4 } },
-            }
-        }
-    },
-    {
-        AURA_ROG_SPATHA_X_USB_PID,
-        {
-            5,
-            {
-                { AURA_MOUSE_ZONE_LOGO, { 0 } },
-                { AURA_MOUSE_ZONE_SCROLL, { 1 } },
-                { AURA_MOUSE_ZONE_UNDERGLOW, { 2, 3, 4 } },
-            }
-        }
-    },
-    {
-        AURA_ROG_CHAKRAM_X_USB_PID,
-        {
-            9,
-            {
-                { AURA_MOUSE_ZONE_LOGO, { 7 } },
-                { AURA_MOUSE_ZONE_SCROLL, { 8 } },
-                { AURA_MOUSE_ZONE_UNDERGLOW, { 0, 1, 2, 3, 4, 5, 6 } },
-            }
-        }
-    },
-    {
-        AURA_ROG_CHAKRAM_X_2_4_PID,
-        {
-            9,
-            {
-                { AURA_MOUSE_ZONE_LOGO, { 7 } },
-                { AURA_MOUSE_ZONE_SCROLL, { 8 } },
-                { AURA_MOUSE_ZONE_UNDERGLOW, { 0, 1, 2, 3, 4, 5, 6 } },
-            }
-        }
-    },
-    {
-        AURA_ROG_STRIX_IMPACT_III_PID,
-        {
-            2,
-            {
-                { AURA_MOUSE_ZONE_LOGO, { 0 } },
-                { AURA_MOUSE_ZONE_SCROLL, { 1 } },
-            }
-        }
-    }
-};
@@ -1,176 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraMouseGen1Controller.cpp          |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Mola19 11/30/2021                        |
-\*-----------------------------------------*/
-
-#include "AsusAuraMouseGen1Controller.h"
-
-#include <cstring>
-#include <chrono>
-#include <thread>
-
-AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid)
-{
-    dev         = dev_handle;
-    location    = path;
-    device_pid  = pid;
-}
-
-AsusAuraMouseGen1Controller::~AsusAuraMouseGen1Controller()
-{
-    hid_close(dev);
-}
-
-std::string AsusAuraMouseGen1Controller::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AsusAuraMouseGen1Controller::GetSerialString()
-{
-    wchar_t serial_string[HID_MAX_STR];
-    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
-
-    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 AsusAuraMouseGen1Controller::GetVersion()
-{
-    unsigned char usb_buf[9] = { 0x0C, 0xC4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-    usb_buf[3] = (device_pid == 0x1824) ? 0x02 : 0x00;
-    hid_send_feature_report(dev, usb_buf, 9);
-
-    unsigned char usb_buf_out[9] = { 0x0C };
-    hid_get_feature_report(dev, usb_buf_out, 9);
-
-    return std::string("1." +  std::to_string(usb_buf_out[3]));
-}
-
-int AsusAuraMouseGen1Controller::GetActiveProfile()
-{
-    unsigned char profile;
-
-    unsigned char profile_amount = 0;
-    unsigned char profile_key    = 0;
-
-    switch(device_pid)
-    {
-        case 0x185B:
-            profile_amount = 3;
-            profile_key    = 0xF0;
-            break;
-        case 0x181C:
-        case 0x1824:
-        default:
-            profile_amount = 6;
-            profile_key    = 0x60;
-            break;
-    }
-
-    do
-    {
-        unsigned char usb_buf[9] = { 0x0C, 0xDF, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-        hid_send_feature_report(dev, usb_buf, 9);
-
-        unsigned char usb_buf_out[9] = { 0x0C };
-        hid_get_feature_report(dev, usb_buf_out, 9);
-
-        profile = usb_buf_out[4];
-    } while(profile < profile_key || profile > profile_key + profile_amount - 1);
-
-    return (profile % 16) + 1;
-}
-
-void AsusAuraMouseGen1Controller::SendUpdate
-    (
-    unsigned char   key,
-    unsigned char   value
-    )
-{
-    unsigned char usb_buf[9];
-
-    memset(usb_buf, 0x00, 9);
-
-    usb_buf[0x00]   = 0x0C;
-    usb_buf[0x01]   = 0xC4;
-    usb_buf[0x02]   = 0x0F;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = key;
-    usb_buf[0x05]   = value;
-    hid_send_feature_report(dev, usb_buf, 9);
-
-    unsigned char buf_in[9];
-    buf_in[0] = 0x0C;
-    hid_get_feature_report(dev, buf_in, 9);
-    
-    std::this_thread::sleep_for(std::chrono::milliseconds(15));
-}
-
-
-void AsusAuraMouseGen1Controller::UpdateProfile
-    (
-    unsigned char   key,
-    unsigned char   profile,
-    unsigned char   value
-    )
-{
-    unsigned char usb_buf[9];
-
-    memset(usb_buf, 0x00, 9);
-
-    usb_buf[0x00]   = 0x0C;
-    usb_buf[0x01]   = 0xDE;
-    usb_buf[0x02]   = key;
-    usb_buf[0x03]   = profile;
-    usb_buf[0x04]   = value;
-    hid_send_feature_report(dev, usb_buf, 9);
-
-    unsigned char buf_in[9];
-    buf_in[0] = 0x0C;
-    hid_get_feature_report(dev, buf_in, 9);
-}
-
-void AsusAuraMouseGen1Controller::SendDirectSpatha(std::vector<RGBColor> colors)
-{
-    unsigned char usb_buf[33];
-
-    memset(usb_buf, 0x00, 33);
-
-    usb_buf[0x00]   = 0x10;
-    usb_buf[0x01]   = 0x00;
-    usb_buf[0x02]   = 0xF0;
-    usb_buf[0x03]   = 0x00;
-    
-    for(unsigned char i = 0; i < 3; i++)
-    {
-        usb_buf[4 + i * 3] = RGBGetRValue(colors[i]);
-        usb_buf[5 + i * 3] = RGBGetGValue(colors[i]);
-        usb_buf[6 + i * 3] = RGBGetBValue(colors[i]);
-    }
-
-    hid_send_feature_report(dev, usb_buf, 33);
-}
-
-void AsusAuraMouseGen1Controller::ResetToSavedLighting()
-{
-    unsigned char usb_buf[9];
-
-    memset(usb_buf, 0x00, 9);
-
-    usb_buf[0x00]   = 0x0C;
-    usb_buf[0x01]   = 0xC4;
-
-    hid_send_feature_report(dev, usb_buf, 9);
-}
@@ -0,0 +1,146 @@
+/*-----------------------------------------*\
+|  AsusAuraStrixEvolveController.cpp        |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Mola19 11/30/2021                        |
+\*-----------------------------------------*/
+
+#include "AsusAuraStrixEvolveController.h"
+
+#include <cstring>
+#include <chrono>
+#include <thread>
+
+AuraStrixEvolveController::AuraStrixEvolveController(hid_device* dev_handle, const char* path, uint16_t pid)
+{
+    dev         = dev_handle;
+    location    = path;
+    device_pid  = pid;
+}
+
+AuraStrixEvolveController::~AuraStrixEvolveController()
+{
+    hid_close(dev);
+}
+
+std::string AuraStrixEvolveController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AuraStrixEvolveController::GetSerialString()
+{
+    wchar_t serial_string[HID_MAX_STR];
+    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
+
+    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 AuraStrixEvolveController::GetVersion()
+{
+    unsigned char usb_buf[9] = { 0x0c, 0xc4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+    hid_send_feature_report(dev, usb_buf, 9);
+
+    unsigned char usb_buf_out[9] = { 0x0c };
+    hid_get_feature_report(dev, usb_buf_out, 9);
+
+    return std::string("1." +  std::to_string(usb_buf_out[3]));
+}
+
+int AuraStrixEvolveController::GetActiveProfile()
+{
+    int profile;
+
+    do
+    {
+        unsigned char usb_buf[9] = { 0x0c, 0xdf, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+        hid_send_feature_report(dev, usb_buf, 9);
+
+        unsigned char usb_buf_out[9] = { 0x0c };
+        hid_get_feature_report(dev, usb_buf_out, 9);
+
+        profile = usb_buf_out[4] % 16;
+    } while (profile > 2);
+
+    return profile + 1;
+}
+
+void AuraStrixEvolveController::SendUpdate
+    (
+    unsigned char   key,
+    unsigned char   value
+    )
+{
+    unsigned char usb_buf[9];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, 9);
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x0c;
+    usb_buf[0x01]   = 0xc4;
+    usb_buf[0x02]   = 0x0f;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = key;
+    usb_buf[0x05]   = value;
+    hid_send_feature_report(dev, usb_buf, 9);
+}
+
+
+void AuraStrixEvolveController::UpdateProfile
+    (
+    unsigned char   key,
+    unsigned char   profile,
+    unsigned char   value
+    )
+{
+    unsigned char usb_buf[9];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, 9);
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x0c;
+    usb_buf[0x01]   = 0xde;
+    usb_buf[0x02]   = key;
+    usb_buf[0x03]   = profile;
+    usb_buf[0x04]   = value;
+    hid_send_feature_report(dev, usb_buf, 9);
+    std::this_thread::sleep_for(std::chrono::milliseconds(5));
+}
+
+void AuraStrixEvolveController::SendSavePacket()
+{
+    unsigned char usb_buf[9];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, 9);
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x0c;
+    usb_buf[0x01]   = 0xc4;
+
+    hid_send_feature_report(dev, usb_buf, 9);
+}
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraMouseGen1Controller.h            |
+|  AsusAuraStrixEvolveController.h          |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  USB RGB lighting controller              |
@@ -10,18 +10,17 @@
 #include "RGBController.h"

 #include <string>
-#include <vector>
 #include <hidapi/hidapi.h>

 #pragma once

 #define HID_MAX_STR 255

-class AsusAuraMouseGen1Controller
+class AuraStrixEvolveController
 {
 public:
-    AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid);
-    virtual ~AsusAuraMouseGen1Controller();
+    AuraStrixEvolveController(hid_device* dev_handle, const char* path, uint16_t pid);
+    virtual ~AuraStrixEvolveController();

    std::string GetDeviceLocation();
    std::string GetSerialString();
@@ -40,9 +39,8 @@ public:
        unsigned char   profile,
        unsigned char   value
        );
-    void SendDirectSpatha(std::vector<RGBColor> colors);

-    void ResetToSavedLighting();
+    void SendSavePacket();

    uint16_t                    device_pid;

@@ -37,26 +37,6 @@ std::string AuraTUFKeyboardController::GetDeviceLocation()
    return("HID: " + location);
 }

-std::string clean_serial(const std::wstring& wstr)
-{
-    // Skip non-ASCII, trailing garbage in serial numbers. Required by the
-    // Scope II 96, whose original firmware outputs garbage, which even differs
-    // after computer reboots and therefore breaks OpenRGB profile matching.
-    std::string result;
-    for(auto c : wstr)
-    {
-        // Forbid control chars and anything above final printable low-ASCII.
-        if(c < 32 || c > 126)
-        {
-            break;
-        }
-
-        result += c;
-    }
-
-    return(result);
-}
-
 std::string AuraTUFKeyboardController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -67,8 +47,8 @@ std::string AuraTUFKeyboardController::GetSerialString()
        return("");
    }

-    std::wstring serial_wstring = serial_string;
-    std::string return_string = clean_serial(serial_wstring);
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());

    return(return_string);
 }
@@ -92,24 +72,13 @@ std::string AuraTUFKeyboardController::GetVersion()
        hid_read(dev, usb_buf_out, 65);

        char version[9];
-        
-        switch(device_pid)
+        if(device_pid == AURA_TUF_K3_GAMING_PID)
        {
-            case AURA_ROG_AZOTH_USB_PID:
-            case AURA_ROG_AZOTH_2_4_PID:
-            case AURA_TUF_K3_GAMING_PID:
-            case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
-            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
-            case AURA_ROG_STRIX_SCOPE_II_PID:
-            case AURA_ROG_STRIX_SCOPE_II_RX_PID:
-            case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
-                snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
-                break;
-            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
-                snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[13], usb_buf_out[12], usb_buf_out[11]);
-                break;
-            default:
-                snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
+            snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
+        }
+        else
+        {
+            snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
        }

        return std::string(version);
@@ -351,131 +320,6 @@ void AuraTUFKeyboardController::UpdateK1Wave
    AwaitResponse(20);
 }

-void AuraTUFKeyboardController::UpdateScopeIIRainbowRipple
-    (
-    unsigned char           mode,
-    std::vector<RGBColor>   colors,
-    unsigned char           direction,
-    unsigned char           color_mode,
-    unsigned char           speed,
-    unsigned char           brightness
-    )
-{
-    unsigned char usb_buf[65];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x51;
-    usb_buf[0x02]   = 0x2C;
-    usb_buf[0x03]   = mode;
-    usb_buf[0x04]   = 0x02;
-    usb_buf[0x05]   = speed;
-    usb_buf[0x06]   = brightness;
-    usb_buf[0x07]   = color_mode;
-    usb_buf[0x08]   = direction;
-    usb_buf[0x09]   = 0x02;
-    usb_buf[0x0A]   = colors.size();
-
-    for(unsigned int i = 0; i < 2; i ++)
-    {
-        if (i >= colors.size()) continue;
-        usb_buf[11 + i * 4] = 100/(double)colors.size()*(i+1);
-        usb_buf[12 + i * 4] = RGBGetRValue(colors[i]);
-        usb_buf[13 + i * 4] = RGBGetGValue(colors[i]);
-        usb_buf[14 + i * 4] = RGBGetBValue(colors[i]);
-    }
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-
-    memset(usb_buf + 4, 0x00, sizeof(usb_buf) - 4);
-
-    usb_buf[0x04] = 0x01;
-
-    for(unsigned int i = 0; i < 4; i ++)
-    {
-        if (i + 2 >= colors.size()) continue;
-        usb_buf[5 + i * 4] = 100/(double)colors.size()*(i+1+2);
-        usb_buf[6 + i * 4] = RGBGetRValue(colors[i+2]);
-        usb_buf[7 + i * 4] = RGBGetGValue(colors[i+2]);
-        usb_buf[8 + i * 4] = RGBGetBValue(colors[i+2]);
-    }
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-
-    memset(usb_buf + 4, 0x00, sizeof(usb_buf) - 4);
-
-    usb_buf[0x04] = 0x00;
-
-    for(unsigned int i = 0; i < 1; i ++)
-    {
-        if (i + 6 >= colors.size()) continue;
-        usb_buf[5 + i * 4] = 100/(double)colors.size()*(i+1+6);
-        usb_buf[6 + i * 4] = RGBGetRValue(colors[i+6]);
-        usb_buf[7 + i * 4] = RGBGetGValue(colors[i+6]);
-        usb_buf[8 + i * 4] = RGBGetBValue(colors[i+6]);
-    }
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-}
-
-void AuraTUFKeyboardController::UpdateScopeIIQuicksand
-    (
-    std::vector<RGBColor>   colors,
-    unsigned char           direction,
-    unsigned char           color_mode,
-    unsigned char           speed,
-    unsigned char           brightness
-    )
-{
-    unsigned char usb_buf[65];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x51;
-    usb_buf[0x02]   = 0x2C;
-    usb_buf[0x03]   = 0x07;
-    usb_buf[0x04]   = 0x01;
-    usb_buf[0x05]   = speed;
-    usb_buf[0x06]   = brightness;
-    usb_buf[0x07]   = color_mode;
-    usb_buf[0x08]   = direction;
-    usb_buf[0x09]   = 0x02;
-
-    for(unsigned int i = 0; i < 3; i ++)
-    {
-        usb_buf[10 + i * 3] = RGBGetRValue(colors[i]);
-        usb_buf[11 + i * 3] = RGBGetGValue(colors[i]);
-        usb_buf[12 + i * 3] = RGBGetBValue(colors[i]);
-    }
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-
-    memset(usb_buf + 4, 0x00, sizeof(usb_buf) - 4);
-
-    usb_buf[0x04] = 0x00;
-
-    for(unsigned int i = 0; i < 3; i ++)
-    {
-        usb_buf[5 + i * 3] = RGBGetRValue(colors[i+3]);
-        usb_buf[6 + i * 3] = RGBGetGValue(colors[i+3]);
-        usb_buf[7 + i * 3] = RGBGetBValue(colors[i+3]);
-    }
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-}
-
 void AuraTUFKeyboardController::UpdateDevice
    (
    unsigned char           mode,
@@ -491,24 +335,6 @@ void AuraTUFKeyboardController::UpdateDevice
        return UpdateK1Wave(colors, direction, speed, brightness);
    }

-    if(device_pid == AURA_ROG_AZOTH_USB_PID
-    || device_pid == AURA_ROG_AZOTH_2_4_PID
-    || device_pid == AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID
-    || device_pid == AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID
-    || device_pid == AURA_ROG_STRIX_SCOPE_II_PID
-    || device_pid == AURA_ROG_STRIX_SCOPE_II_RX_PID
-    || device_pid == AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID)
-    {
-        if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
-        {
-            return UpdateScopeIIRainbowRipple(mode, colors, direction, color_mode, speed, brightness);
-        }
-        else if (mode == AURA_KEYBOARD_MODE_QUICKSAND)
-        {
-            return UpdateScopeIIQuicksand(colors, direction, color_mode, speed, brightness);
-        }
-    }
-
    unsigned char usb_buf[65];
    memset(usb_buf, 0x00, sizeof(usb_buf));

@@ -33,27 +33,13 @@ enum

 enum
 {
-    AURA_ROG_AZOTH_USB_PID                              = 0x1A83,
-    AURA_ROG_AZOTH_2_4_PID                              = 0x1A85,
-    AURA_ROG_CLAYMORE_PID                               = 0x184D,
-    AURA_ROG_FALCHION_WIRED_PID                         = 0x193C,
-    AURA_ROG_FALCHION_WIRELESS_PID                      = 0x193E,
-    AURA_ROG_STRIX_FLARE_PID                            = 0x1875,
-    AURA_ROG_STRIX_FLARE_PNK_LTD_PID                    = 0x18CF,
-    AURA_ROG_STRIX_FLARE_COD_BO4_PID                    = 0x18AF,
-    AURA_ROG_STRIX_FLARE_II_PID                         = 0x19FE,
-    AURA_ROG_STRIX_FLARE_II_ANIMATE_PID                 = 0x19FC,
-    AURA_ROG_STRIX_SCOPE_PID                            = 0x18F8,
-    AURA_ROG_STRIX_SCOPE_RX_PID                         = 0x1951,
-    AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID     = 0x19F6,
-    AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID     = 0x19F8,
-    AURA_ROG_STRIX_SCOPE_II_PID                         = 0x1AB3,
-    AURA_ROG_STRIX_SCOPE_II_RX_PID                      = 0x1AB5,
-    AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID         = 0x1AAE,
-    AURA_TUF_K1_GAMING_PID                              = 0x1945,
-    AURA_TUF_K3_GAMING_PID                              = 0x194B,
-    AURA_TUF_K5_GAMING_PID                              = 0x1899,
-    AURA_TUF_K7_GAMING_PID                              = 0x18AA,
+    AURA_ROG_FALCHION_WIRED_PID     = 0x193C,
+    AURA_ROG_FALCHION_WIRELESS_PID  = 0x193E,
+    AURA_TUF_K1_GAMING_PID          = 0x1945,
+    AURA_TUF_K3_GAMING_PID          = 0x194B,
+    AURA_TUF_K5_GAMING_PID          = 0x1899,
+    AURA_TUF_K7_GAMING_PID          = 0x18AA,
+    AURA_ROG_CLAYMORE_PID           = 0x184D,
 };

 struct led_color
@@ -97,25 +83,6 @@ public:
        unsigned char           brightness
        );

-    void UpdateScopeIIRainbowRipple
-        (
-        unsigned char           mode,
-        std::vector<RGBColor>   colors,
-        unsigned char           direction,
-        unsigned char           color_mode,
-        unsigned char           speed,
-        unsigned char           brightness
-        );
-
-    void UpdateScopeIIQuicksand
-        (
-        std::vector<RGBColor>   colors,
-        unsigned char           direction,
-        unsigned char           color_mode,
-        unsigned char           speed,
-        unsigned char           brightness
-        );
-
    void UpdateDevice
        (
        unsigned char           mode,
@@ -11,6 +11,7 @@
 #include "LogManager.h"

 #include <cstring>
+#include <stdexcept>

 AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path)
 {
@@ -143,56 +144,36 @@ void AuraUSBController::GetFirmwareVersion()
 void AuraUSBController::SendDirect
    (
    unsigned char   device,
+    unsigned char   start_led,
    unsigned char   led_count,
-    RGBColor*  colors
+    unsigned char*  led_data,
+    bool apply /* = false */
    )
 {
    unsigned char usb_buf[65];
-    unsigned char offset         =      0x00;
-    unsigned char sent_led_count =      LEDS_PER_PACKET;
-    bool apply                   =      false;
-    while(!apply)
-    {
-        if(offset + sent_led_count > led_count)
-        {
-            sent_led_count = led_count - offset;
-        }

+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));

-        if(offset + sent_led_count == led_count)
-        {
-            apply = true;
-        }
-        /*-----------------------------------------------------*\
-        | Zero out buffer                                       |
-        \*-----------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
+    usb_buf[0x02]   = apply ? 0x80 : 0x00;
+    usb_buf[0x02]  |= device;
+    usb_buf[0x03]   = start_led;
+    usb_buf[0x04]   = led_count;

-        /*-----------------------------------------------------*\
-        | Set up message packet                                 |
-        \*-----------------------------------------------------*/
-        usb_buf[0x00]   = 0xEC;
-        usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
-        usb_buf[0x02]   = (apply ? 0x80 : 0x00) | device;
-        usb_buf[0x03]   = offset;
-        usb_buf[0x04]   = sent_led_count;
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x05], led_data, led_count * 3);

-        /*-----------------------------------------------------*\
-        | Copy in color data bytes                              |
-        \*-----------------------------------------------------*/
-        for(unsigned char led_idx = 0; led_idx < sent_led_count; led_idx++)
-        {
-
-            usb_buf[0x05 + (led_idx * 3)] = RGBGetRValue(colors[offset + led_idx]);
-            usb_buf[0x06 + (led_idx * 3)] = RGBGetGValue(colors[offset + led_idx]);
-            usb_buf[0x07 + (led_idx * 3)] = RGBGetBValue(colors[offset + led_idx]);
-        }
-
-        /*-----------------------------------------------------*\
-        | Send packet                                           |
-        \*-----------------------------------------------------*/
-        hid_write(dev, usb_buf, 65);
-
-        offset += sent_led_count;
-    }
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
 }
@@ -49,8 +49,6 @@ enum class AuraDeviceType
    ADDRESSABLE,
 };

-#define LEDS_PER_PACKET  0x14;
-
 struct AuraDeviceInfo
 {
    unsigned char effect_channel;
@@ -99,8 +97,10 @@ protected:
    void SendDirect
        (
        unsigned char   device,
+        unsigned char   start_led,
        unsigned char   led_count,
-        RGBColor *      colors
+        unsigned char*  led_data,
+        bool apply = false
        );
 private:
    char                        device_name[16];
@@ -5,9 +5,9 @@
 #include "AsusAuraTUFKeyboardController.h"
 #include "AsusAuraMainboardController.h"
 #include "AsusAuraMouseController.h"
-#include "AsusROGAllyController.h"
-#include "AsusAuraMouseGen1Controller.h"
 #include "AsusAuraMousematController.h"
+#include "AsusROGAllyController.h"
+#include "AsusAuraStrixEvolveController.h"
 #include "AsusAuraMonitorController.h"
 #include "AsusAuraRyuoAIOController.h"
 #include "RGBController.h"
@@ -15,105 +15,96 @@
 #include "RGBController_AsusAuraHeadsetStand.h"
 #include "RGBController_AsusAuraKeyboard.h"
 #include "RGBController_AsusAuraTUFKeyboard.h"
-#include "RGBController_AsusAuraMainboard.h"
 #include "RGBController_AsusAuraMouse.h"
 #include "RGBController_AsusAuraMousemat.h"
 #include "RGBController_AsusROGAlly.h"
 #include "RGBController_ROGStrixLC_Controller.h"
-#include "RGBController_AsusROGSpatha.h"
-#include "RGBController_AsusROGStrixEvolve.h"
+#include "RGBController_AsusAuraStrixEvolve.h"
 #include "RGBController_AsusAuraMonitor.h"
 #include "RGBController_AsusAuraRyuoAIO.h"
 #include <stdexcept>
 #include <hidapi/hidapi.h>
 #include "dependencies/dmiinfo.h"

-#define AURA_USB_VID                                  0x0B05
+#define AURA_USB_VID                            0x0B05

 /*-----------------------------------------------------------------*\
 |  MOTHERBOARDS                                                     |
 \*-----------------------------------------------------------------*/
-#define AURA_ADDRESSABLE_1_PID                        0x1867
-#define AURA_ADDRESSABLE_2_PID                        0x1872
-#define AURA_ADDRESSABLE_3_PID                        0x18A3
-#define AURA_ADDRESSABLE_4_PID                        0x18A5
-#define AURA_MOTHERBOARD_1_PID                        0x18F3
-#define AURA_MOTHERBOARD_2_PID                        0x1939
-#define AURA_MOTHERBOARD_3_PID                        0x19AF
+#define AURA_ADDRESSABLE_1_PID                  0x1867
+#define AURA_ADDRESSABLE_2_PID                  0x1872
+#define AURA_ADDRESSABLE_3_PID                  0x18A3
+#define AURA_ADDRESSABLE_4_PID                  0x18A5
+#define AURA_MOTHERBOARD_1_PID                  0x18F3
+#define AURA_MOTHERBOARD_2_PID                  0x1939
+#define AURA_MOTHERBOARD_3_PID                  0x19AF

 /*-----------------------------------------------------------------*\
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
-#define AURA_ROG_AZOTH_USB_PID                              0x1A83
-#define AURA_ROG_AZOTH_2_4_PID                              0x1A85
-#define AURA_ROG_CLAYMORE_PID                               0x184D
-#define AURA_ROG_FALCHION_WIRED_PID                         0x193C
-#define AURA_ROG_FALCHION_WIRELESS_PID                      0x193E
-#define AURA_ROG_STRIX_FLARE_PID                            0x1875
-#define AURA_ROG_STRIX_FLARE_PNK_LTD_PID                    0x18CF
-#define AURA_ROG_STRIX_FLARE_COD_BO4_PID                    0x18AF
-#define AURA_ROG_STRIX_FLARE_II_ANIMATE_PID                 0x19FC
-#define AURA_ROG_STRIX_FLARE_II_PID                         0x19FE
-#define AURA_ROG_STRIX_SCOPE_PID                            0x18F8
-#define AURA_ROG_STRIX_SCOPE_TKL_PID                        0x190C
-#define AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID                0x1954
-#define AURA_ROG_STRIX_SCOPE_RX_PID                         0x1951
-#define AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID              0x1A05
-#define AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID     0x19F6
-#define AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID     0x19F8
-#define AURA_ROG_STRIX_SCOPE_II_PID                         0x1AB3
-#define AURA_ROG_STRIX_SCOPE_II_RX_PID                      0x1AB5
-#define AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID         0x1AAE
-#define AURA_TUF_K1_GAMING_PID                              0x1945
-#define AURA_TUF_K3_GAMING_PID                              0x194B
-#define AURA_TUF_K5_GAMING_PID                              0x1899
-#define AURA_TUF_K7_GAMING_PID                              0x18AA
+#define AURA_ROG_FALCHION_WIRED_PID             0x193C
+#define AURA_ROG_FALCHION_WIRELESS_PID          0x193E
+#define AURA_ROG_STRIX_FLARE_PID                0x1875
+#define AURA_ROG_STRIX_FLARE_PNK_LTD_PID        0x18CF
+#define AURA_ROG_STRIX_FLARE_COD_BO4_PID        0x18AF
+#define AURA_ROG_STRIX_SCOPE_PID                0x18F8
+#define AURA_ROG_STRIX_SCOPE_RX_PID             0x1951
+#define AURA_ROG_STRIX_SCOPE_TKL_PID            0x190C
+#define AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID  0x1A05
+#define AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID    0x1954
+#define AURA_ROG_CLAYMORE_PID                   0x184D
+#define AURA_TUF_K1_GAMING_PID                  0x1945
+#define AURA_TUF_K3_GAMING_PID                  0x194B
+#define AURA_TUF_K5_GAMING_PID                  0x1899
+#define AURA_TUF_K7_GAMING_PID                  0x18AA

 /*-----------------------------------------------------------------*\
 |  MICE - defined in AsusAuraMouseDevices.h                         |
 \*-----------------------------------------------------------------*/

-#define AURA_ROG_STRIX_EVOLVE_PID                     0x185B
-#define AURA_ROG_SPATHA_WIRED_PID                     0x181C
-#define AURA_ROG_SPATHA_WIRELESS_PID                  0x1824
+#define AURA_ROG_STRIX_EVOLVE_PID               0x185B

 /*-----------------------------------------------------------------*\
 | MOUSEMATS                                                         |
 \*-----------------------------------------------------------------*/
-#define AURA_ROG_BALTEUS_PID                          0x1891
-#define AURA_ROG_BALTEUS_QI_PID                       0x1890
+#define AURA_ROG_BALTEUS_PID                    0x1891
+#define AURA_ROG_BALTEUS_QI_PID                 0x1890

 /*-----------------------------------------------------------------*\
 | MONITORS                                                          |
 \*-----------------------------------------------------------------*/

-#define AURA_ROG_STRIX_XG27AQ_PID                     0x198C
-#define AURA_ROG_STRIX_XG27AQM_PID                    0x19BB
-#define AURA_ROG_STRIX_XG279Q_PID                     0x1919
-#define AURA_ROG_STRIX_XG27W_PID                      0x1933
-#define AURA_ROG_STRIX_XG32VC_PID                     0x1968
-#define AURA_ROG_PG32UQ_PID                           0x19B9
+#define AURA_ROG_STRIX_XG27AQ_PID               0x198C
+#define AURA_ROG_STRIX_XG27AQM_PID              0x19BB
+#define AURA_ROG_STRIX_XG279Q_PID               0x1919
+#define AURA_ROG_STRIX_XG27W_PID                0x1933
+#define AURA_ROG_PG32UQ_PID                     0x19B9

 /*-----------------------------------------------------------------*\
 | HEADSETSTANDS                                                     |
 \*-----------------------------------------------------------------*/

-#define AURA_ROG_THRONE_PID                           0x18D9
-#define AURA_ROG_THRONE_QI_PID                        0x18C5
-#define AURA_ROG_THRONE_QI_GUNDAM_PID                 0x1994
+#define AURA_ROG_THRONE_PID                     0x18D9
+#define AURA_ROG_THRONE_QI_PID                  0x18C5
+#define AURA_ROG_THRONE_QI_GUNDAM_PID           0x1994

 /*-----------------------------------------------------------------*\
 |  OTHER                                                            |
 \*-----------------------------------------------------------------*/
-#define AURA_TERMINAL_PID                             0x1889
-#define ROG_STRIX_LC120_PID                           0x879E
-#define AURA_RYUO_AIO_PID                             0x1887
-#define ASUS_ROG_ALLY_PID                             0x1ABE
+#define AURA_TERMINAL_PID                       0x1889
+#define ROG_STRIX_LC120_PID                     0x879E
+#define AURA_RYUO_AIO_PID                       0x1887
+#define ASUS_ROG_ALLY_PID                       0x1ABE

 AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
 {
    switch(pid)
    {
+        case AURA_ROG_STRIX_FLARE_PID:
+        case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
+        case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
+            return FLARE_LAYOUT;
+
        case AURA_ROG_STRIX_SCOPE_PID:
            return SCOPE_LAYOUT;

@@ -167,7 +158,7 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*n
        {
            DMIInfo dmi;
            AuraMainboardController* controller             = new AuraMainboardController(dev, info->path);
-            RGBController_AuraMainboard*   rgb_controller   = new RGBController_AuraMainboard(controller);
+            RGBController_AuraUSB*   rgb_controller         = new RGBController_AuraUSB(controller);
            rgb_controller->name                            = "ASUS " + dmi.getMainboard();
            ResourceManager::get()->RegisterRGBController(rgb_controller);
        }
@@ -199,11 +190,19 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)

    if(dev)
    {
-        uint16_t pid = (name == "Asus ROG Spatha X Dock") ? AURA_ROG_SPATHA_X_DOCK_FAKE_PID : info->product_id;
-        AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, pid);
+        AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, info->product_id);
        RGBController_AuraMouse* rgb_controller             = new RGBController_AuraMouse(controller);
        rgb_controller->name                                = name;
        ResourceManager::get()->RegisterRGBController(rgb_controller);
+
+        // adding the mouse dock for the ASUS ROG Spatha X
+        if(info->product_id == AURA_ROG_SPATHA_X_2_4_PID)
+        {
+            AuraMouseController*     dock_controller            = new AuraMouseController(dev, info->path, AURA_ROG_SPATHA_X_DOCK_FAKE_PID);
+            RGBController_AuraMouse* rgb_controller_dock        = new RGBController_AuraMouse(dock_controller);
+            rgb_controller_dock->name                           = "Asus ROG Spatha X Dock";
+            ResourceManager::get()->RegisterRGBController(rgb_controller_dock);
+        }
    }
 }

@@ -252,21 +251,8 @@ void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name

    if(dev)
    {
-        AsusAuraMouseGen1Controller*     controller         = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id);
-        RGBController_AsusROGStrixEvolve* rgb_controller    = new RGBController_AsusROGStrixEvolve(controller);
-        rgb_controller->name                                = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAsusAuraUSBSpatha(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AsusAuraMouseGen1Controller*     controller         = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id);
-        RGBController_AsusROGSpatha* rgb_controller         = new RGBController_AsusROGSpatha(controller);
+        AuraStrixEvolveController*     controller           = new AuraStrixEvolveController(dev, info->path, info->product_id);
+        RGBController_AuraStrixEvolve* rgb_controller       = new RGBController_AuraStrixEvolve(controller);
        rgb_controller->name                                = name;
        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
@@ -338,78 +324,61 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAs
 /*-----------------------------------------------------------------*\
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID,                     1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX TKL Wireless Deluxe",     DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID,           1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL PNK LTD",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID,             1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Azoth USB",                              DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_AZOTH_USB_PID,                           1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Azoth 2.4GHz",                           DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_AZOTH_2_4_PID,                           1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Claymore",                               DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_CLAYMORE_PID,                            1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",                       DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,                      1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",                    DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,                   1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                            DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                         1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",                    DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,                 1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare CoD Black Ops 4 Edition",    DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_COD_BO4_PID,                 1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare II Animate",                 DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_II_ANIMATE_PID,              1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare II",                         DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_II_PID,                      1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                            DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                         1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",                         DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,                      1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope NX Wireless Deluxe USB",     DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID,  1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope NX Wireless Deluxe 2.4GHz",  DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID,  1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II",                         DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_PID,                      1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II RX",                      DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_RX_PID,                   1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II 96 Wireless USB",         DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID,      1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K1",                              DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K1_GAMING_PID,                           2,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                              DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                           1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K5",                              DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K5_GAMING_PID,                           2,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7",                              DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                           1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                     1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,             1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare CoD Black Ops 4 Edition",DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_COD_BO4_PID,             1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                     1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",                     DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,                  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL",                    DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID,                 1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX TKL Wireless Deluxe", DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID,       1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL PNK LTD",            DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID,         1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Claymore",                           DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_CLAYMORE_PID,                        1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",                   DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,                  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",                DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,               1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K1",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K1_GAMING_PID,                       2,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                       1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K5",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K5_GAMING_PID,                       2,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                       1,  0xFF00);

 /*-----------------------------------------------------------------*\
 |  MICE                                                             |
 \*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",                            DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,                     0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",                                 DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,                          2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin",                          DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID,                   2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",                  DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID,           2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",                      DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID,               2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                        DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,               1,  0xFF13);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                        DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,               2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III",                                DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_PID,                         0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless USB",                   DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_USB_PID,            0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless 2.4Ghz",                DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID,            0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth",             DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_BT_PID,             0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless AimPoint USB",          DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_USB_PID,   0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless AimPoint 2.4Ghz",       DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_AIMPOINT_2_4_PID,   0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",                         DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,                    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",                            DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,                     0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram Core",                               DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID,                        0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X USB",                              DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_CHAKRAM_X_USB_PID,                       0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X 2.4GHz",                           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_CHAKRAM_X_2_4_PID,                       0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X USB",                               DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_SPATHA_X_USB_PID,                        0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X 2.4GHz",                            DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_SPATHA_X_2_4_PID,                        0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X Dock",                              DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_SPATHA_X_DOCK_PID,                       0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio",                                      DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_PUGIO_PID,                               2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",                           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,                      0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",                        DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,                   0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact",                               DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID,                        2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II",                            DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PID,                     0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Gundam",                     DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID,              0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Electro Punk",               DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PUNK_PID,                0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Moonlight White",            DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WHITE_PID,               0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless USB",               DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID,        0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless 2.4 Ghz",           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID,        0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact III",                           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_STRIX_IMPACT_III_PID,                    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris",                                      DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS,                                   0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless USB",                         DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_USB_PID,                  0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless 2.4Ghz",                      DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_2_4_PID,                  0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless Bluetooth",                   DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_BT_PID,                   0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless AimPoint USB",                DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID,         0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless AimPoint 2.4Ghz",             DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID,         0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3",                                  DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_TUF_M3_PID,                                  1,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                                  DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_TUF_M5_PID,                                  2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,                 0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",                         DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,                      2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin",                  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID,               2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID,       2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID,           2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,           1,  0xFF13);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,           2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III",                        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_PID,                     0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless USB",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_USB_PID,        0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless 2.4Ghz",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID,        0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth",     DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_BT_PID,         0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,                0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,                 0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram Core",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID,                    0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X USB",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_X_USB_PID,                   0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X 2.4GHz",                   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_X_2_4_PID,                   0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X USB",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_SPATHA_X_USB_PID,                    0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X 2.4GHz",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_SPATHA_X_2_4_PID,                    0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio",                              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_PID,                           2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",                   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,                  0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,               0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID,                    2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PID,                 0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Gundam",             DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID,          0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Electro Punk",       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PUNK_PID,            0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Moonlight White",    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WHITE_PID,           0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless USB",       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID,    0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless 2.4 Ghz",   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID,    0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris",                              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS,                               0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless USB",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_USB_PID,              0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless 2.4Ghz",              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_2_4_PID,              0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless Bluetooth",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_BT_PID,               0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3",                          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M3_PID,                              1,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M5_PID,                              2,  0xFF01);

 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Evolve",                       DetectAsusAuraUSBStrixEvolve,   AURA_USB_VID, AURA_ROG_STRIX_EVOLVE_PID,                    1,  0x0008);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Spatha Wired",                       DetectAsusAuraUSBSpatha,        AURA_USB_VID, AURA_ROG_SPATHA_WIRED_PID,                    1,  0x0008);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Spatha Wireless",                    DetectAsusAuraUSBSpatha,        AURA_USB_VID, AURA_ROG_SPATHA_WIRELESS_PID,                 1,  0x0008);

 /*-----------------------------------------------------------------*\
 | MOUSEMATS                                                         |
@@ -424,7 +393,6 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQ",                       DetectAs
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQM",                      DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27AQM_PID,                   0xFFA0, 1);
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG279Q",                       DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG279Q_PID,                    0xFFA0, 1);
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27W",                        DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27W_PID,                     0xFFA0, 1);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG32VC",                       DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG32VC_PID,                    0xFFA0, 1);
 REGISTER_HID_DETECTOR_PU("ASUS ROG PG32UQ",                             DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_PG32UQ_PID,                          0xFFA0, 1);

 /*-----------------------------------------------------------------*\
@@ -14,8 +14,6 @@ ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path)
 {
    dev         = dev_handle;
    location    = path;
-
-    SendInitialization();
 }

 ROGAllyController::~ROGAllyController()
@@ -49,56 +47,6 @@ std::string ROGAllyController::GetVersion()
    return("");
 }

-void ROGAllyController::SendInitialization()
-{
-    unsigned char usb_buf[64];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x5D;
-    usb_buf[0x01]   = 0xB9;
-    
-    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x5D;
-    usb_buf[0x01]   = 0x41;
-    usb_buf[0x02]   = 0x53;
-    usb_buf[0x03]   = 0x55;
-    usb_buf[0x04]   = 0x53;
-    usb_buf[0x05]   = 0x20;
-    usb_buf[0x06]   = 0x54;
-    usb_buf[0x07]   = 0x65;
-    usb_buf[0x08]   = 0x63;
-    usb_buf[0x09]   = 0x68;
-    usb_buf[0x0A]   = 0x2E;
-    usb_buf[0x0B]   = 0x49;
-    usb_buf[0x0C]   = 0x6E;
-    usb_buf[0x0D]   = 0x63;
-    usb_buf[0x0E]   = 0x2E;
-    
-    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
-}
-
-void ROGAllyController::UpdateBrightness
-    (
-    unsigned char           brightness
-    )
-{
-    unsigned char usb_buf[64];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x5A;
-    usb_buf[0x01]   = 0xBA;
-    usb_buf[0x02]   = 0xC5;
-    usb_buf[0x03]   = 0xC4;
-    usb_buf[0x04]   = brightness;
-
-    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
-}
-
 void ROGAllyController::UpdateLeds
    (
    std::vector<RGBColor>    colors
@@ -128,6 +76,7 @@ void ROGAllyController::UpdateDevice
    unsigned char           mode,
    std::vector<RGBColor>   colors,
    unsigned char           speed,
+    unsigned char           /*brightness*/,
    unsigned char           direction
    )
 {
@@ -45,13 +45,6 @@ public:
    std::string GetSerialString();
    std::string GetVersion();

-    void SendInitialization();
-    
-    void UpdateBrightness
-        (
-            unsigned char           brightness
-        );
-
    void UpdateLeds
        (
            std::vector<RGBColor>    colors
@@ -62,6 +55,7 @@ public:
            unsigned char           mode,
            std::vector<RGBColor>   colors,
            unsigned char           speed,
+            unsigned char           brightness,
            unsigned char           direction
            );

@@ -44,7 +44,7 @@ static unsigned int falchion_matrix_map[5][16] =
      {   3,  NA,  12,  17,  21,  25,  29,  34,  38,  42,  47,  52,  56,  NA,  61,  66 },
      {   4,   8,  13,  NA,  NA,  NA,  30,  NA,  NA,  NA,  43,  48,  53,  57,  62,  67 } };

-static const std::vector<aura_keyboard_led> default_led_names =
+static const std::vector<led_type> default_led_names =
 {
    /* Key Label                Index  */
    { KEY_EN_ESCAPE,            0x00    },
@@ -153,7 +153,7 @@ static const std::vector<aura_keyboard_led> default_led_names =
    { KEY_EN_NUMPAD_ENTER,      0xB4    },
 };

-static const std::vector<aura_keyboard_led> default_tkl_led_names =
+static const std::vector<led_type> default_tkl_led_names =
 {
    /* Key Label                Index  */
    { KEY_EN_ESCAPE,            0x00    },
@@ -270,7 +270,7 @@ static const std::vector<aura_keyboard_led> default_tkl_led_names =
    { "Underglow 26",           0xCE    },
 };

-static const std::vector<aura_keyboard_led> default_65pct_led_names =
+static const std::vector<led_type> default_65pct_led_names =
 {
    /* Key Label                Index  */
    { KEY_EN_ESCAPE,            0x00    },
@@ -395,7 +395,7 @@ void RGBController_AuraKeyboard::SetupZones()
    | Set up zones                                              |
    \*---------------------------------------------------------*/
    std::vector<led_zone> led_zones;
-    std::vector<aura_keyboard_led> led_names;
+    std::vector<led_type> led_names;

    switch(layout)
    {
@@ -24,7 +24,7 @@ typedef struct
 {
    const char*         name;
    unsigned char       idx;
-} aura_keyboard_led;
+} led_type;

 typedef struct
 {
@@ -1,78 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMainboard.cpp      |
-|                                           |
-|  RGB controller for Asus Aura USB         |
-|  mainboards                               |
-|                                           |
-|  rytypete 8/30/2023                       |
-|  based on RGBController_AsusAuraUSB.cpp   |
-|  code                                     |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraMainboard.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus Aura USB Mainboard
-    @category Motherboard
-    @type USB
-    @save :white_check_mark:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBMotherboards
-    @comment The Asus Aura USB Mainboard controller applies to most
-        AMD and Intel mainboards from the x570 chipset onwards.
-\*-------------------------------------------------------------------*/
-
-RGBController_AuraMainboard::RGBController_AuraMainboard(AuraMainboardController* controller_ptr) :
-    RGBController_AuraUSB(controller_ptr)
-{
-    name        = "ASUS Aura USB Mainboard";
-    description = "ASUS Aura USB Mainboard Device";
-
-    /*-------------------------------------------------------*\
-    | Add manual save flag to all modes except direct mode    |
-    \*-------------------------------------------------------*/
-    for(unsigned int mode_idx = 0; mode_idx < modes.size(); mode_idx++)
-    {
-        mode Mode = modes[mode_idx];
-        if(Mode.value != AURA_MODE_DIRECT)
-        {
-            Mode.flags |= MODE_FLAG_MANUAL_SAVE;
-            modes[mode_idx] = Mode;
-        }
-    }
-}
-
-void RGBController_AuraMainboard::DeviceUpdateShutdownEffect()
-{
-    unsigned char red = 0;
-    unsigned char grn = 0;
-    unsigned char blu = 0;
-
-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        red = RGBGetRValue(modes[active_mode].colors[0]);
-        grn = RGBGetGValue(modes[active_mode].colors[0]);
-        blu = RGBGetBValue(modes[active_mode].colors[0]);
-    }
-
-    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        AuraDeviceInfo device_info = controller->GetAuraDevices()[zone_idx];
-
-        /*---------------------------------------------------*\
-        | Shutdown effect only works with onboard lighting    |
-        \*---------------------------------------------------*/
-        if(device_info.device_type == AuraDeviceType::FIXED && zones[zone_idx].leds_count > 0)
-        {
-            ((AuraMainboardController*) controller)->SetMode(zone_idx, modes[active_mode].value, red, grn, blu, true);
-        }
-    }
-}
-
-void RGBController_AuraMainboard::DeviceSaveMode()
-{
-    DeviceUpdateMode();
-    DeviceUpdateShutdownEffect();
-    ((AuraMainboardController*) controller)->SendCommit();
-}
@@ -1,25 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMainboard.h        |
-|                                           |
-|  RGB controller for Asus Aura USB         |
-|  mainboards                               |
-|                                           |
-|  rytypete 8/30/2023                       |
-|  based on RGBController_AsusAuraUSB.h     |
-|  code                                     |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController_AsusAuraUSB.h"
-#include "AsusAuraMainboardController.h"
-
-class RGBController_AuraMainboard : public RGBController_AuraUSB
-{
-public:
-    RGBController_AuraMainboard(AuraMainboardController* controller_ptr);
-
-    void        DeviceSaveMode();
-
-private:
-    void        DeviceUpdateShutdownEffect();
-};
@@ -9,12 +9,11 @@

 #include "RGBController_AsusAuraMouse.h"

-static std::string aura_mouse_zone_names[5]
+static std::string aura_mouse_zone_names[4]
 {
    "Logo",
    "Scroll Wheel",
    "Underglow",
-    "All",
    "Dock"
 };

@@ -45,16 +44,6 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller

    std::vector<uint8_t> mm = aura_mouse_devices[pid].mouse_modes;

-    if(aura_mouse_devices[pid].direct)
-    {
-        mode Direct;
-        Direct.name                 = "Direct";
-        Direct.value                = 254;
-        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-        Direct.color_mode           = MODE_COLORS_PER_LED;
-        modes.push_back(Direct);
-    }
-
    int mode_value          = 0;

    for(std::vector<uint8_t>::iterator it = mm.begin(); it != mm.end(); it++)
@@ -62,24 +51,16 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
        switch(*it)
        {
            case AURA_MOUSE_MODE_STATIC:
-                /*-----------------------------------------------------------------*\
-                | If there is no direct mode, this mode can be used as direct       |
-                | (Asus does it the same way).                                      |
-                | The acutal direct mode is only found on new devices and on        |
-                | these devices static can't be used as direct anymore as it is     |
-                | too slow. The Spatha X's dock can't be controlled, because        |
-                | static is too slow and it can't be adressed in direct             |
-                \*-----------------------------------------------------------------*/
                {
-                    mode Static;
-                    Static.name                 = (aura_mouse_devices[pid].direct || pid == AURA_ROG_SPATHA_X_DOCK_FAKE_PID)? "Static" : "Direct";
-                    Static.value                = mode_value;
-                    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-                    Static.brightness_min       = aura_mouse_devices[pid].brightness_min;
-                    Static.brightness_max       = aura_mouse_devices[pid].brightness_max;
-                    Static.brightness           = aura_mouse_devices[pid].brightness_max;
-                    Static.color_mode           = MODE_COLORS_PER_LED;
-                    modes.push_back(Static);
+                    mode Direct;
+                    Direct.name                 = "Direct";
+                    Direct.value                = mode_value;
+                    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    Direct.brightness_min       = aura_mouse_devices[pid].brightness_min;
+                    Direct.brightness_max       = aura_mouse_devices[pid].brightness_max;
+                    Direct.brightness           = aura_mouse_devices[pid].brightness_max;
+                    Direct.color_mode           = MODE_COLORS_PER_LED;
+                    modes.push_back(Direct);
                }
                break;

@@ -219,16 +200,9 @@ void RGBController_AuraMouse::ResizeZone(int /*zone*/, int /*new_size*/)

 void RGBController_AuraMouse::DeviceUpdateLEDs()
 {
-    if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
    {
-        controller->SendDirect(colors);
-    }
-    else
-    {
-        for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-        {
-            UpdateSingleLED(zone_index);
-        }
+        UpdateSingleLED(zone_index);
    }
 }

@@ -239,12 +213,6 @@ void RGBController_AuraMouse::UpdateZoneLEDs(int /*zone*/)

 void RGBController_AuraMouse::UpdateSingleLED(int led)
 {
-    if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
-    {
-        DeviceUpdateLEDs();
-        return;
-    }
-
    uint8_t red = RGBGetRValue(colors[led]);
    uint8_t grn = RGBGetGValue(colors[led]);
    uint8_t blu = RGBGetBValue(colors[led]);
@@ -254,11 +222,6 @@ void RGBController_AuraMouse::UpdateSingleLED(int led)

 void RGBController_AuraMouse::DeviceUpdateMode()
 {
-    if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
-    {
-        return;
-    }
-
    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
    {
        DeviceUpdateLEDs();
@@ -17,7 +17,7 @@
    @save :white_check_mark:
    @direct :white_check_mark:
    @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBRyuoAIO
+    @detectors DetectAsusAuraUSBMousemats
    @category Cooler
    @comment
 \*-------------------------------------------------------------------*/
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AsusROGStrixEvolve.cpp     |
+|  RGBController_AsusAuraStrixEvolve.cpp    |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
 |  USB controller driver                    |
@@ -7,7 +7,7 @@
 |  Mola19 11/30/2021                        |
 \*-----------------------------------------*/

-#include "RGBController_AsusROGStrixEvolve.h"
+#include "RGBController_AsusAuraStrixEvolve.h"

 /**------------------------------------------------------------------*\
    @name Asus Aura Strix Evolve
@@ -20,7 +20,7 @@
    @comment
 \*-------------------------------------------------------------------*/

-RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouseGen1Controller* controller_ptr)
+RGBController_AuraStrixEvolve::RGBController_AuraStrixEvolve(AuraStrixEvolveController* controller_ptr)
 {
    controller                  = controller_ptr;

@@ -34,53 +34,53 @@ RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouse

    mode Direct;
    Direct.name                 = "Direct";
-    Direct.value                = ASUS_ROG_STRIX_EVOLVE_MODE_DIRECT;
+    Direct.value                = 1;
    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.brightness_min       = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    Direct.brightness_max       = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    Direct.brightness           = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Direct.brightness_min       = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Direct.brightness_max       = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Direct.brightness           = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
    Direct.color_mode           = MODE_COLORS_PER_LED;
    modes.push_back(Direct);

    mode Breathing;
    Breathing.name              = "Breathing";
-    Breathing.value             = ASUS_ROG_STRIX_EVOLVE_MODE_BREATHING;
+    Breathing.value             = 2;
    Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.brightness_min    = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    Breathing.brightness_max    = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    Breathing.brightness        = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Breathing.brightness_min    = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Breathing.brightness        = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
    Breathing.color_mode        = MODE_COLORS_PER_LED;
    modes.push_back(Breathing);

    mode ColorCycle;
    ColorCycle.name             = "Spectrum Cycle";
-    ColorCycle.value            = ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE;
+    ColorCycle.value            = 3;
    ColorCycle.flags            = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    ColorCycle.brightness_min   = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    ColorCycle.brightness_max   = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    ColorCycle.brightness       = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    ColorCycle.brightness_min   = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    ColorCycle.brightness_max   = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    ColorCycle.brightness       = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
    ColorCycle.color_mode       = MODE_COLORS_NONE;
    modes.push_back(ColorCycle);

    mode Reactive;
    Reactive.name               = "Reactive";
-    Reactive.value              = ASUS_ROG_STRIX_EVOLVE_MODE_REACTIVE;
+    Reactive.value              = 4;
    Reactive.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Reactive.brightness_min     = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    Reactive.brightness_max     = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    Reactive.brightness         = ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Reactive.brightness_min     = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Reactive.brightness_max     = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Reactive.brightness         = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
    Reactive.color_mode         = MODE_COLORS_PER_LED;
    modes.push_back(Reactive);

    SetupZones();
 }

-RGBController_AsusROGStrixEvolve::~RGBController_AsusROGStrixEvolve()
+RGBController_AuraStrixEvolve::~RGBController_AuraStrixEvolve()
 {
    delete controller;
 }

-void RGBController_AsusROGStrixEvolve::SetupZones()
+void RGBController_AuraStrixEvolve::SetupZones()
 {
    zone mouse_zone;

@@ -103,48 +103,58 @@ void RGBController_AsusROGStrixEvolve::SetupZones()
    SetupColors();
 }

-void RGBController_AsusROGStrixEvolve::ResizeZone(int /*zone*/, int /*new_size*/)
+void RGBController_AuraStrixEvolve::ResizeZone(int /*zone*/, int /*new_size*/)
 {

 }

-void RGBController_AsusROGStrixEvolve::DeviceUpdateLEDs()
+void RGBController_AuraStrixEvolve::DeviceUpdateLEDs()
 {
-    UpdateSingleLED(0);
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+
+    controller->SendUpdate(0x1C, red);
+    controller->SendUpdate(0x1D, grn);
+    controller->SendUpdate(0x1E, blu);
 }

-void RGBController_AsusROGStrixEvolve::UpdateZoneLEDs(int zone)
+void RGBController_AuraStrixEvolve::UpdateZoneLEDs(int /*zone*/)
 {
-    UpdateSingleLED(zone);
+    DeviceUpdateLEDs();
 }

-void RGBController_AsusROGStrixEvolve::UpdateSingleLED(int led)
+void RGBController_AuraStrixEvolve::UpdateSingleLED(int /*led*/)
 {
-    controller->SendUpdate(0x1C, RGBGetRValue(colors[0]));
-    controller->SendUpdate(0x1D, RGBGetGValue(colors[0]));
-    controller->SendUpdate(0x1E, RGBGetBValue(colors[0]));
+    DeviceUpdateLEDs();
 }

-void RGBController_AsusROGStrixEvolve::DeviceUpdateMode()
+void RGBController_AuraStrixEvolve::DeviceUpdateMode()
 {
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+
    controller->SendUpdate(0x19, modes[active_mode].value);
    controller->SendUpdate(0x1A, modes[active_mode].brightness);
+    controller->SendUpdate(0x1C, red);
+    controller->SendUpdate(0x1D, grn);
+    controller->SendUpdate(0x1E, blu);
 }

-void RGBController_AsusROGStrixEvolve::DeviceSaveMode()
+void RGBController_AuraStrixEvolve::DeviceSaveMode()
 {
-    unsigned int profile = controller->GetActiveProfile();
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);

+    unsigned int profile = controller->GetActiveProfile();

    controller->UpdateProfile(0x19, profile, modes[active_mode].value);
    controller->UpdateProfile(0x1A, profile, modes[active_mode].brightness);
+    controller->UpdateProfile(0x1C, profile, red);
+    controller->UpdateProfile(0x1D, profile, grn);
+    controller->UpdateProfile(0x1E, profile, blu);

-    if(modes[active_mode].value != ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE)
-    {
-        controller->UpdateProfile(0x1C, profile, RGBGetRValue(colors[0]));
-        controller->UpdateProfile(0x1D, profile, RGBGetGValue(colors[0]));
-        controller->UpdateProfile(0x1E, profile, RGBGetBValue(colors[0]));
-    }
-
-    controller->ResetToSavedLighting();
+    controller->SendSavePacket();
 }
@@ -0,0 +1,40 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraStrixEvolve.h      |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 11/30/2021                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraStrixEvolveController.h"
+
+enum
+{
+    AURA_STRIX_EVOLVE_BRIGHTNESS_MIN     = 0,
+    AURA_STRIX_EVOLVE_BRIGHTNESS_MAX     = 255,
+    AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT = 255
+};
+
+class RGBController_AuraStrixEvolve : public RGBController
+{
+public:
+    RGBController_AuraStrixEvolve(AuraStrixEvolveController* controller_ptr);
+    ~RGBController_AuraStrixEvolve();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    AuraStrixEvolveController*  controller;
+};
@@ -49,32 +49,22 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
                AURA_KEYBOARD_SPEED_MAX          = 2;
                AURA_KEYBOARD_SPEED_DEFAULT      = 1;
                break;
-            case AURA_ROG_STRIX_FLARE_PID:
-            case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
-            case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
            case AURA_TUF_K3_GAMING_PID:
            case AURA_TUF_K7_GAMING_PID:
                AURA_KEYBOARD_SPEED_MIN          = 15;
                AURA_KEYBOARD_SPEED_MAX          = 0;
                AURA_KEYBOARD_SPEED_DEFAULT      = 8;
                break;
-            case AURA_ROG_AZOTH_USB_PID:
-            case AURA_ROG_AZOTH_2_4_PID:
+            case AURA_TUF_K5_GAMING_PID:
+                AURA_KEYBOARD_SPEED_MIN          = 63;
+                AURA_KEYBOARD_SPEED_MAX          = 0;
+                AURA_KEYBOARD_SPEED_DEFAULT      = 31;
+                break;
            case AURA_ROG_FALCHION_WIRED_PID:
            case AURA_ROG_FALCHION_WIRELESS_PID:
-            case AURA_ROG_STRIX_FLARE_II_PID:
-            case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
-            case AURA_ROG_STRIX_SCOPE_RX_PID:
-            case AURA_ROG_STRIX_SCOPE_PID:
-            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
-            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
-            case AURA_ROG_STRIX_SCOPE_II_PID:
-            case AURA_ROG_STRIX_SCOPE_II_RX_PID:
-            case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
-            case AURA_TUF_K5_GAMING_PID:
                AURA_KEYBOARD_SPEED_MIN          = 255;
                AURA_KEYBOARD_SPEED_MAX          = 0;
-                AURA_KEYBOARD_SPEED_DEFAULT      = 30;
+                AURA_KEYBOARD_SPEED_DEFAULT      = 8;
                break;
            default:
                AURA_KEYBOARD_SPEED_MIN          = 15;
@@ -406,38 +396,10 @@ void RGBController_AuraTUFKeyboard::SetupZones()

    switch(pid)
    {
-        case AURA_ROG_STRIX_FLARE_PID:
-        case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
-        case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
-            keyboard_ptr = &AsusROGStrixFlareLayouts;
-            break;
        case AURA_TUF_K3_GAMING_PID:
        case AURA_TUF_K7_GAMING_PID:
            keyboard_ptr = &AsusTUFK7Layouts;
            break;
-        case AURA_ROG_STRIX_SCOPE_PID:
-        case AURA_ROG_STRIX_SCOPE_RX_PID:
-        case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
-        case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
-            keyboard_ptr = &AsusROGStrixScopeLayouts;
-            break;
-        case AURA_ROG_STRIX_SCOPE_II_PID:
-        case AURA_ROG_STRIX_SCOPE_II_RX_PID:
-            keyboard_ptr = &AsusROGStrixScopeIILayouts;
-            break;
-        case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
-            keyboard_ptr = &AsusROGStrixScopeII96WirelessLayouts;
-            break;
-        case AURA_ROG_STRIX_FLARE_II_PID:
-            keyboard_ptr = &AsusROGStrixFlareIILayouts;
-			break;
-        case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
-            keyboard_ptr = &AsusROGStrixFlareIIAnimateLayouts;
-            break;
-        case AURA_ROG_AZOTH_USB_PID:
-        case AURA_ROG_AZOTH_2_4_PID:
-            keyboard_ptr = &AsusROGAzothLayouts;
-            break;
        case AURA_ROG_FALCHION_WIRED_PID:
        case AURA_ROG_FALCHION_WIRELESS_PID:
            keyboard_ptr = &AsusFalchionLayouts;
@@ -602,7 +564,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
            color_mode = 1;
        }

-        if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE || modes[active_mode].value == AURA_KEYBOARD_MODE_QUICKSAND)
+        if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE)
        {
            /*----------------------------------------------------------*\
            | converting openrgb direction value to keyboard directions  |
@@ -16,9 +16,9 @@
    @save :x:
    @direct :white_check_mark:
    @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable
+    @detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable,DetectAsusAuraUSBMotherboards
    @comment The Asus Aura USB controller applies to most AMD and
-        Intel mainboards from the x470 and z390 chipset generations.
+        Intel mainboards from the x470 and z390 chipsets onwards.
 \*-------------------------------------------------------------------*/

 RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr) :
@@ -29,10 +29,8 @@ public:

    void        DeviceUpdateMode();

-protected:
-    AuraUSBController*          controller;
-
 private:
+    AuraUSBController*          controller;
    std::vector<unsigned int>   leds_channel;
    std::vector<unsigned int>   zones_channel;
    bool                        initializedMode;
@@ -13,9 +13,9 @@
    @name Asus ROG Ally
    @category Gamepad
    @type USB
-    @save :white_check_mark:
+    @save :x:
    @direct :white_check_mark:
-    @effects :white_check_mark:
+    @effects :x:
    @detectors DetectAsusROGAlly
    @comment
 \*-------------------------------------------------------------------*/
@@ -35,30 +35,24 @@ RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controll
    mode Direct;
    Direct.name                 = "Direct";
    Direct.value                = ROG_ALLY_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
    Direct.color_mode           = MODE_COLORS_PER_LED;
-    Direct.brightness_min       = 0;
-    Direct.brightness_max       = 3;
-    Direct.brightness           = 3;
    modes.push_back(Direct);

    mode Static;
    Static.name                 = "Static";
    Static.value                = ROG_ALLY_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
    Static.colors_min           = 1;
    Static.colors_max           = 1;
    Static.colors.resize(1);
-    Static.brightness_min       = 0;
-    Static.brightness_max       = 3;
-    Static.brightness           = 3;
    modes.push_back(Static);

    mode Breathing;
    Breathing.name              = "Breathing";
    Breathing.value             = ROG_ALLY_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED;
    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
    Breathing.speed_min         = ROG_ALLY_SPEED_MIN;
    Breathing.speed_max         = ROG_ALLY_SPEED_MAX;
@@ -66,47 +60,35 @@ RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controll
    Breathing.colors_min        = 2;
    Breathing.colors_max        = 2;
    Breathing.colors.resize(2);
-    Breathing.brightness_min    = 0;
-    Breathing.brightness_max    = 3;
-    Breathing.brightness        = 3;
    modes.push_back(Breathing);

    mode ColorCycle;
    ColorCycle.name             = "Spectrum Cycle";
    ColorCycle.value            = ROG_ALLY_MODE_COLOR_CYCLE;
-    ColorCycle.flags            = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    ColorCycle.flags            = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED;
    ColorCycle.color_mode       = MODE_COLORS_RANDOM;
    ColorCycle.speed_min        = ROG_ALLY_SPEED_MIN;
    ColorCycle.speed_max        = ROG_ALLY_SPEED_MAX;
    ColorCycle.speed            = ROG_ALLY_SPEED_MED;
-    ColorCycle.brightness_min   = 0;
-    ColorCycle.brightness_max   = 3;
-    ColorCycle.brightness       = 3;
    modes.push_back(ColorCycle);

    mode Rainbow;
    Rainbow.name                = "Rainbow Wave";
    Rainbow.value               = ROG_ALLY_MODE_RAINBOW;
-    Rainbow.flags               = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS;
+    Rainbow.flags               = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
    Rainbow.color_mode          = MODE_COLORS_RANDOM;
    Rainbow.speed_min           = ROG_ALLY_SPEED_MIN;
    Rainbow.speed_max           = ROG_ALLY_SPEED_MAX;
    Rainbow.speed               = ROG_ALLY_SPEED_MED;
-    Rainbow.brightness_min      = 0;
-    Rainbow.brightness_max      = 3;
-    Rainbow.brightness          = 3;
    modes.push_back(Rainbow);

    mode Strobing;
    Strobing.name               = "Strobing";
    Strobing.value              = ROG_ALLY_MODE_STROBING;
-    Strobing.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Strobing.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
    Strobing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
    Strobing.colors_min         = 1;
    Strobing.colors_max         = 1;
-    Strobing.brightness_min     = 0;
-    Strobing.brightness_max     = 3;
-    Strobing.brightness         = 3;
    Strobing.colors.resize(1);
    modes.push_back(Strobing);

@@ -190,8 +172,6 @@ void RGBController_AsusROGAlly::UpdateSingleLED(int /*led*/)

 void RGBController_AsusROGAlly::DeviceUpdateMode()
 {
-    controller->UpdateBrightness(modes[active_mode].brightness);
-
    if(modes[active_mode].value == ROG_ALLY_MODE_DIRECT)
    {
        DeviceUpdateLEDs();
@@ -205,7 +185,7 @@ void RGBController_AsusROGAlly::DeviceUpdateMode()
            rog_ally_direction = ROG_ALLY_DIRECTION_LEFT;
        }

-        controller->UpdateDevice(modes[active_mode].value, modes[active_mode].colors, modes[active_mode].speed, rog_ally_direction);
+        controller->UpdateDevice(modes[active_mode].value, modes[active_mode].colors, modes[active_mode].speed, modes[active_mode].brightness, rog_ally_direction);
    }
 }

@@ -1,272 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusROGSpatha.cpp          |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 11/05/2023                        |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusROGSpatha.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus Aura Spatha
-    @category Mouse
-    @type USB
-    @save :white_check_mark:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBSpatha
-    @comment This device allows indiviual modes for each zone,
-        which currently can't be implemented in OpenRGB.
-        Also there seem to be a firmware bug which causes static
-        to use a random colorand random to use a static color
-        that was previously set. This can be worked around by saving
-\*-------------------------------------------------------------------*/
-
-RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Controller* controller_ptr)
-{
-    controller                  = controller_ptr;
-
-    name                        = "ASUS ROG Spatha";
-    vendor                      = "ASUS";
-    type                        = DEVICE_TYPE_MOUSE;
-    description                 = "ASUS Aura Mouse Device";
-    version                     = controller->GetVersion();
-    location                    = controller->GetDeviceLocation();
-    serial                      = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = ASUS_ROG_SPATHA_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = ASUS_ROG_SPATHA_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.brightness_min       = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
-    Static.brightness_max       = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
-    Static.brightness           = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
-    Static.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = ASUS_ROG_SPATHA_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.brightness_min    = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
-    Breathing.brightness_max    = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
-    Breathing.brightness        = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
-    Breathing.colors_min        = 2;
-    Breathing.colors_max        = 2;
-    Breathing.colors.resize(2);
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    modes.push_back(Breathing);
-
-    mode ColorCycle;
-    ColorCycle.name             = "Spectrum Cycle";
-    ColorCycle.value            = ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE;
-    ColorCycle.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    ColorCycle.brightness_min   = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
-    ColorCycle.brightness_max   = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
-    ColorCycle.brightness       = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
-    ColorCycle.colors_min       = 12;
-    ColorCycle.colors_max       = 12;
-    ColorCycle.colors.resize(12);
-    ColorCycle.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-    modes.push_back(ColorCycle);
-
-    mode Random;
-    Random.name                 = "Random";
-    Random.value                = ASUS_ROG_SPATHA_MODE_RANDOM;
-    Random.flags                = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Random.brightness_min       = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
-    Random.brightness_max       = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
-    Random.brightness           = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
-    Random.color_mode           = MODE_COLORS_NONE;
-    modes.push_back(Random);
-
-    mode Reactive;
-    Reactive.name               = "Reactive";
-    Reactive.value              = ASUS_ROG_SPATHA_MODE_REACTIVE;
-    Reactive.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Reactive.brightness_min     = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
-    Reactive.brightness_max     = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
-    Reactive.brightness         = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
-    Reactive.color_mode         = MODE_COLORS_PER_LED;
-    modes.push_back(Reactive);
-
-    mode Battery;
-    Battery.name               = "Battery";
-    Battery.value              = ASUS_ROG_SPATHA_MODE_BATTERY;
-    Battery.flags              = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Battery.brightness_min     = ASUS_ROG_SPATHA_BRIGHTNESS_MIN;
-    Battery.brightness_max     = ASUS_ROG_SPATHA_BRIGHTNESS_MAX;
-    Battery.brightness         = ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT;
-    Battery.color_mode         = MODE_COLORS_NONE;
-    modes.push_back(Battery);
-
-    SetupZones();
-}
-
-RGBController_AsusROGSpatha::~RGBController_AsusROGSpatha()
-{
-    delete controller;
-}
-
-void RGBController_AsusROGSpatha::SetupZones()
-{
-
-    std::string zones_names[3] = {"Side", "Scroll Wheel", "Logo"};
-
-    for(unsigned char i = 0; i < 3; i++)
-    {
-        zone spatha_zone;
-
-        spatha_zone.name         = zones_names[i];
-        spatha_zone.type         = ZONE_TYPE_SINGLE;
-        spatha_zone.leds_min     = 1;
-        spatha_zone.leds_max     = 1;
-        spatha_zone.leds_count   = 1;
-        spatha_zone.matrix_map   = NULL;
-
-        zones.push_back(spatha_zone);
-
-        led spatha_led;
-
-        spatha_led.name          = zones_names[i];
-        spatha_led.value         = 1;
-
-        leds.push_back(spatha_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AsusROGSpatha::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
-void RGBController_AsusROGSpatha::DeviceUpdateLEDs()
-{
-    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
-    {
-        controller->SendDirectSpatha(colors);
-    }
-    else
-    {
-        UpdateSingleLED(0);
-        UpdateSingleLED(1);
-        UpdateSingleLED(2);
-    }
-}
-
-void RGBController_AsusROGSpatha::UpdateZoneLEDs(int zone)
-{
-    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
-    {
-        controller->SendDirectSpatha(colors);
-    }
-    else
-    {
-        UpdateSingleLED(zone);
-    }
-}
-
-void RGBController_AsusROGSpatha::UpdateSingleLED(int led)
-{
-    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
-    {
-        controller->SendDirectSpatha(colors);
-    }
-    else
-    {
-        controller->SendUpdate(0x13 + led * 38, RGBGetRValue(colors[led]));
-        controller->SendUpdate(0x14 + led * 38, RGBGetGValue(colors[led]));
-        controller->SendUpdate(0x15 + led * 38, RGBGetBValue(colors[led]));
-    }
-}
-
-void RGBController_AsusROGSpatha::DeviceUpdateMode()
-{
-    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
-    {
-        return;
-    }
-    
-    /*-----------------------------------------------------*\
-    | Needed to overwrite direct                            |
-    \*-----------------------------------------------------*/
-    controller->ResetToSavedLighting();
-
-    /*-----------------------------------------------------*\
-    | Send data to all 3 zones                              |
-    \*-----------------------------------------------------*/
-    for(int i = 0; i < 3; i++)
-    {
-        controller->SendUpdate(0x11 + i * 38, modes[active_mode].value);
-
-        /*------------------------------------------------------------------*\
-        | This mouse has independent brightness for wired and wireless.      |
-        | Each is 4-bit in the same byte (wireless is the first/bigger one). |
-        | OpenRGB misses that feature, hence both are the same               |
-        \*------------------------------------------------------------------*/
-        controller->SendUpdate(0x12 + i * 38, (modes[active_mode].brightness << 4) + modes[active_mode].brightness);
-        
-        if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_BREATHING)
-        {
-            for(int j = 0; j < modes[active_mode].colors.size(); j++)
-            {
-                controller->SendUpdate(0x13 + j * 3 + i * 38, RGBGetRValue(modes[active_mode].colors[j]));
-                controller->SendUpdate(0x14 + j * 3 + i * 38, RGBGetGValue(modes[active_mode].colors[j]));
-                controller->SendUpdate(0x15 + j * 3 + i * 38, RGBGetBValue(modes[active_mode].colors[j]));
-            }
-        }
-    }
-}
-
-void RGBController_AsusROGSpatha::DeviceSaveMode()
-{
-    if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
-    {
-        return;
-    }
-
-    unsigned int profile = controller->GetActiveProfile();
-    
-    /*-----------------------------------------------------*\
-    | Send data to all 3 zones                              |
-    \*-----------------------------------------------------*/
-    for(int i = 0; i < 3; i++)
-    {
-        controller->UpdateProfile(0x11 + i * 38, profile, modes[active_mode].value);
-        /*------------------------------------------------------------------*\
-        | This mouse has independent brightness for wired and wireless.      |
-        | Each is 4-bit in the same byte (wireless is the first/bigger one). |
-        | OpenRGB misses that feature, hence both are the same               |
-        \*------------------------------------------------------------------*/
-        controller->UpdateProfile(0x12 + i * 38, profile, (modes[active_mode].brightness << 4) + modes[active_mode].brightness);
-        
-        if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_BREATHING)
-        {
-            for(int j = 0; j < modes[active_mode].colors.size(); j++)
-            {
-                controller->UpdateProfile(0x13 + j * 3 + i * 38, profile, RGBGetRValue(modes[active_mode].colors[j]));
-                controller->UpdateProfile(0x14 + j * 3 + i * 38, profile, RGBGetGValue(modes[active_mode].colors[j]));
-                controller->UpdateProfile(0x15 + j * 3 + i * 38, profile, RGBGetBValue(modes[active_mode].colors[j]));
-            }
-        }
-        else if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_STATIC || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_REACTIVE)
-        {
-            controller->UpdateProfile(0x13 + i * 38, profile, RGBGetRValue(colors[i]));
-            controller->UpdateProfile(0x14 + i * 38, profile, RGBGetGValue(colors[i]));
-            controller->UpdateProfile(0x15 + i * 38, profile, RGBGetBValue(colors[i]));
-        }
-    }
-
-    controller->ResetToSavedLighting();
-}
@@ -1,51 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusROGSpatha.h           |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 11/05/2023                        |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusAuraMouseGen1Controller.h"
-
-enum
-{
-    ASUS_ROG_SPATHA_BRIGHTNESS_MIN          = 0,
-    ASUS_ROG_SPATHA_BRIGHTNESS_MAX          = 15,
-    ASUS_ROG_SPATHA_BRIGHTNESS_DEFAULT      = 15
-};
-
-enum
-{
-    ASUS_ROG_SPATHA_MODE_DIRECT             = 0xFF,
-    ASUS_ROG_SPATHA_MODE_STATIC             = 0x01,
-    ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE     = 0x05,
-    ASUS_ROG_SPATHA_MODE_RANDOM             = 0x06,
-    ASUS_ROG_SPATHA_MODE_BREATHING          = 0x0A,
-    ASUS_ROG_SPATHA_MODE_BATTERY            = 0x0B,
-    ASUS_ROG_SPATHA_MODE_REACTIVE           = 0x0C,
-};
-
-class RGBController_AsusROGSpatha : public RGBController
-{
-public:
-    RGBController_AsusROGSpatha(AsusAuraMouseGen1Controller* controller_ptr);
-    ~RGBController_AsusROGSpatha();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-    void        DeviceSaveMode();
-
-private:
-    AsusAuraMouseGen1Controller*  controller;
-};
@@ -1,48 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusROGStrixEvolve.h       |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 11/30/2021                        |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusAuraMouseGen1Controller.h"
-
-enum
-{
-    ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MIN        = 0,
-    ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_MAX        = 255,
-    ASUS_ROG_STRIX_EVOLVE_BRIGHTNESS_DEFAULT    = 255,
-};
-
-enum
-{
-    ASUS_ROG_STRIX_EVOLVE_MODE_DIRECT           = 0x01,
-    ASUS_ROG_STRIX_EVOLVE_MODE_BREATHING        = 0x02,
-    ASUS_ROG_STRIX_EVOLVE_MODE_SPECTRUM_CYCLE   = 0x03,
-    ASUS_ROG_STRIX_EVOLVE_MODE_REACTIVE         = 0x04,
-};
-
-class RGBController_AsusROGStrixEvolve : public RGBController
-{
-public:
-    RGBController_AsusROGStrixEvolve(AsusAuraMouseGen1Controller* controller_ptr);
-    ~RGBController_AsusROGStrixEvolve();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-    void        DeviceSaveMode();
-
-private:
-    AsusAuraMouseGen1Controller*  controller;
-};
@@ -1,20 +1,16 @@
 #include "Detector.h"
 #include "AsusCerberusKeyboardController.h"
-#include "AsusSagarisKeyboardController.h"
 #include "AsusStrixClawController.h"
 #include "RGBController.h"
 #include "RGBController_AsusCerberusKeyboard.h"
-#include "RGBController_AsusSagarisKeyboard.h"
 #include "RGBController_AsusStrixClaw.h"
 #include <stdexcept>
 #include <hidapi/hidapi.h>
 #include "dependencies/dmiinfo.h"

 #define ASUS_LEGACY_USB_VID         0x195D
-#define ASUS_USB_VID                0x0B05

 #define ASUS_CERBERUS_MECH_PID      0x2047
-#define ASUS_SAGARIS_GK1100_PID     0x1835
 #define ASUS_ROG_STRIX_CLAW_PID     0x1016

 void DetectAsusCerberusMech(hid_device_info* info, const std::string& name)
@@ -30,19 +26,6 @@ void DetectAsusCerberusMech(hid_device_info* info, const std::string& name)
    }
 }

-void DetectAsusSagarisKeyboard(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AsusSagarisKeyboardController*     controller          = new AsusSagarisKeyboardController(dev, info->path, info->release_number);
-        RGBController_AsusSagarisKeyboard* rgb_controller      = new RGBController_AsusSagarisKeyboard(controller);
-        rgb_controller->name                                = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
 void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
 {
    hid_device* dev = hid_open_path(info->path);
@@ -57,6 +40,5 @@ void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
 }

 REGISTER_HID_DETECTOR_IPU("ASUS Cerberus Mech",  DetectAsusCerberusMech,  ASUS_LEGACY_USB_VID, ASUS_CERBERUS_MECH_PID,  1, 0xFF01, 1);
-REGISTER_HID_DETECTOR_IPU("ASUS Sagaris GK1100", DetectAsusSagarisKeyboard,       ASUS_USB_VID,        ASUS_SAGARIS_GK1100_PID, 1, 0xFF02, 2);

 REGISTER_HID_DETECTOR_IPU("ASUS ROG Strix Claw", DetectAsusStrixClaw,     ASUS_LEGACY_USB_VID, ASUS_ROG_STRIX_CLAW_PID, 0, 0xFF01, 1);
@@ -1,197 +0,0 @@
-/*-----------------------------------------*\
-|  AsusSagarisKeyboardController.cpp       |
-|                                           |
-|  Driver for ASUS Sagaris USB lighting    |
-|  controller                               |
-|                                           |
-|  Mola19 08/20/2023                        |
-\*-----------------------------------------*/
-
-#include "AsusSagarisKeyboardController.h"
-
-#include <cstring>
-#include <string>
-#include <math.h>
-#include <vector>
-#include <string.h>
-
-#include "LogManager.h"
-
-#define ASUS_SAGARIS_KB_PACKET_SIZE 65
-
-AsusSagarisKeyboardController::AsusSagarisKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version)
-{
-    dev         = dev_handle;
-    location    = path;
-    version     = rev_version;
-}
-
-AsusSagarisKeyboardController::~AsusSagarisKeyboardController()
-{
-    hid_close(dev);
-}
-
-std::string AsusSagarisKeyboardController::GetVersion()
-{
-    return std::to_string((int) floor(version / 0x100)) + "." + std::to_string(version % 0x100);
-}
-
-std::string AsusSagarisKeyboardController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AsusSagarisKeyboardController::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);
-}
-
-sagaris_mode AsusSagarisKeyboardController::GetMode()
-{
-    ClearResponses();
-
-    uint8_t usb_buf_out[ASUS_SAGARIS_KB_PACKET_SIZE];
-    memset(usb_buf_out, 0x00, sizeof(usb_buf_out));
-
-    usb_buf_out[0x00] = 0x06;
-    usb_buf_out[0x01] = 0x0B;
-    usb_buf_out[0x02] = 0x03;
-
-    hid_write(dev, usb_buf_out, ASUS_SAGARIS_KB_PACKET_SIZE);
-
-    unsigned char usb_buf_in[ASUS_SAGARIS_KB_PACKET_SIZE];
-    memset(usb_buf_in, 0x00, sizeof(usb_buf_in));
-    int return_length = hid_read_timeout(dev, usb_buf_in, ASUS_SAGARIS_KB_PACKET_SIZE, 100);
-
-    if(return_length == -1)
-    {
-        LOG_DEBUG("[Asus Sagaris GK1100]: Could not fetch mode");
-        sagaris_mode default_mode;
-        default_mode.mode       = SAGARIS_KEYBOARD_MODE_STATIC;
-        default_mode.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-        default_mode.speed      = 0;
-        default_mode.colorIndex = 0;
-
-        return default_mode;
-    }
-
-    sagaris_mode current_mode;
-    current_mode.mode       = usb_buf_in[3];
-    current_mode.brightness = usb_buf_in[4];
-    current_mode.speed      = usb_buf_in[5];
-    current_mode.colorIndex = usb_buf_in[6];
-
-    return current_mode;
-}
-
-std::vector<RGBColor> AsusSagarisKeyboardController::GetColors()
-{
-    ClearResponses();
-
-    uint8_t usb_buf_out[ASUS_SAGARIS_KB_PACKET_SIZE];
-    memset(usb_buf_out, 0x00, sizeof(usb_buf_out));
-
-    usb_buf_out[0x00] = 0x06;
-    usb_buf_out[0x01] = 0x0B;
-    usb_buf_out[0x02] = 0x05;
-
-    hid_write(dev, usb_buf_out, ASUS_SAGARIS_KB_PACKET_SIZE);
-
-    std::vector<RGBColor> colors;
-    colors.resize(7);
-
-    for(int i = 0; i < 7; i++)
-    {
-        unsigned char usb_buf_in[ASUS_SAGARIS_KB_PACKET_SIZE];
-        memset(usb_buf_in, 0x00, sizeof(usb_buf_in));
-        int return_length = hid_read_timeout(dev, usb_buf_in, ASUS_SAGARIS_KB_PACKET_SIZE, 100);
-
-        if(return_length == -1)
-        {
-           LOG_DEBUG("[Asus Sagaris GK1100]: Could not fetch color %i", i);
-           colors[i] = ToRGBColor(0, 0, 0);
-           continue;
-        }
-
-        colors[i] = ToRGBColor(usb_buf_in[4] * 16, usb_buf_in[5] * 16, usb_buf_in[6] * 16);
-    }
-
-    return colors;
-}
-
-void AsusSagarisKeyboardController::SetColor
-    (
-    uint8_t           index,
-    uint8_t           red,
-    uint8_t           green,
-    uint8_t           blue
-    )
-{
-    uint8_t usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00] = 0x06;
-    usb_buf[0x01] = 0x0B;
-    usb_buf[0x02] = 0x04;
-    usb_buf[0x03] = 0x00;
-    usb_buf[0x04] = index;
-    usb_buf[0x05] = red;
-    usb_buf[0x06] = green;
-    usb_buf[0x07] = blue;
-
-    hid_write(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE);
-}
-
-void AsusSagarisKeyboardController::SetMode
-    (
-    uint8_t           mode,
-    uint8_t           brightness,
-    uint8_t           speed,
-    uint8_t           colorIndex
-    )
-{
-    ClearResponses();
-
-    uint8_t usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00] = 0x06;
-    usb_buf[0x01] = 0x0B;
-    usb_buf[0x02] = 0x01;
-    usb_buf[0x03] = mode;
-    usb_buf[0x04] = brightness;
-    usb_buf[0x05] = speed;
-    usb_buf[0x06] = colorIndex;
-
-    hid_write(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE);
-
-    AwaitResponse(20);
-}
-
-void AsusSagarisKeyboardController::AwaitResponse(int ms)
-{
-    unsigned char usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
-    hid_read_timeout(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE, ms);
-}
-
-void AsusSagarisKeyboardController::ClearResponses()
-{
-    int result = 1;
-    unsigned char usb_buf_flush[65];
-    while(result > 0)
-    {
-        result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
-    }
-}
@@ -1,76 +0,0 @@
-/*-----------------------------------------*\
-|  AsusSagarisKeyboardController.h         |
-|                                           |
-|  Definitions and types for ASUS Sagaris  |
-|  USB RGB lighting controller              |
-|                                           |
-|  Mola19 08/20/2023                        |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    SAGARIS_KEYBOARD_MODE_OFF           = 0,
-    SAGARIS_KEYBOARD_MODE_STATIC        = 1,
-    SAGARIS_KEYBOARD_MODE_SPRIAL        = 2,
-    SAGARIS_KEYBOARD_MODE_CUSTOM        = 3,
-    SAGARIS_KEYBOARD_MODE_BREATHING     = 4,
-    SAGARIS_KEYBOARD_MODE_REACTIVE      = 5,
-    SAGARIS_KEYBOARD_MODE_STARRY_NIGHT  = 6,
-    SAGARIS_KEYBOARD_MODE_LASER         = 7,
-};
-
-enum
-{
-    SAGARIS_KEYBOARD_BRIGHTNESS_MIN     = 0,
-    SAGARIS_KEYBOARD_BRIGHTNESS_MAX     = 3,
-    SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT = 3
-};
-
-enum
-{
-    SAGARIS_KEYBOARD_SPEED_MIN     = 0,
-    SAGARIS_KEYBOARD_SPEED_MAX     = 3,
-    SAGARIS_KEYBOARD_SPEED_DEFAULT = 2
-};
-
-typedef struct
-{
-    uint8_t                 mode;
-    uint8_t                 brightness;
-    uint8_t                 speed;
-    uint8_t                 colorIndex;
-} sagaris_mode;
-
-
-class AsusSagarisKeyboardController
-{
-public:
-    AsusSagarisKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version);
-    ~AsusSagarisKeyboardController();
-
-    std::string GetVersion();
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    sagaris_mode          GetMode();
-    std::vector<RGBColor> GetColors();
-
-    void SetMode(uint8_t mode, uint8_t brightness, uint8_t speed, uint8_t colorIndex);
-    void SetColor(uint8_t index, uint8_t red, uint8_t green, uint8_t blue);
-
-    void AwaitResponse(int ms);
-    void ClearResponses();
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-    unsigned short              version;
-};
@@ -1,246 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusSagarisKeyboard.cpp    |
-|                                           |
-|  Generic RGB Interface for Asus Sagaris   |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 08/20/2023                        |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusSagarisKeyboard.h"
-#include <vector>
-
-/**------------------------------------------------------------------*\
-    @name Asus Sagaris Keyboard
-    @category Keyboard
-    @type USB
-    @save :robot:
-    @direct :x:
-    @effects :white_check_mark:
-    @detectors DetectAsusSagarisKeyboard
-    @comment Missing controls for modifier keys, as they have independent lighting
-\*-------------------------------------------------------------------*/
-
-#include <iostream>
-
-RGBController_AsusSagarisKeyboard::RGBController_AsusSagarisKeyboard(AsusSagarisKeyboardController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "ASUS Sagaris Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "ASUS Sagaris Keyboard Device";
-    version    = controller->GetVersion();
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Off;
-    Off.name                     = "Off";
-    Off.value                    = SAGARIS_KEYBOARD_MODE_OFF;
-    Off.flags                    = MODE_FLAG_AUTOMATIC_SAVE;
-    Off.color_mode               = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    mode Static;
-    Static.name                  = "Static";
-    Static.value                 = SAGARIS_KEYBOARD_MODE_STATIC;
-    Static.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.brightness_min        = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Static.brightness_max        = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Static.brightness            = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Static.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min            = 1;
-    Static.colors_max            = 1;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Spiral;
-    Spiral.name                  = "Spiral";
-    Spiral.value                 = SAGARIS_KEYBOARD_MODE_SPRIAL;
-    Spiral.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Spiral.brightness_min        = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Spiral.brightness_max        = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Spiral.brightness            = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Spiral.speed_min             = SAGARIS_KEYBOARD_SPEED_MIN;
-    Spiral.speed_max             = SAGARIS_KEYBOARD_SPEED_MAX;
-    Spiral.speed                 = SAGARIS_KEYBOARD_SPEED_DEFAULT;
-    Spiral.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Spiral.colors_min            = 7;
-    Spiral.colors_max            = 7;
-    Spiral.colors.resize(7);
-    modes.push_back(Spiral);
-
-    mode Custom;
-    Custom.name                  = "Custom";
-    Custom.value                 = SAGARIS_KEYBOARD_MODE_CUSTOM;
-    Custom.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Custom.brightness_min        = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Custom.brightness_max        = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Custom.brightness            = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Custom.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Custom.colors_min            = 7;
-    Custom.colors_max            = 7;
-    Custom.colors.resize(7);
-    modes.push_back(Custom);
-
-    mode Breathing;
-    Breathing.name               = "Breathing";
-    Breathing.value              = SAGARIS_KEYBOARD_MODE_BREATHING;
-    Breathing.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED;
-    Breathing.speed_min          = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Breathing.speed_max          = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Breathing.speed              = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Breathing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors_min         = 7;
-    Breathing.colors_max         = 7;
-    Breathing.colors.resize(7);
-    modes.push_back(Breathing);
-
-    mode Reactive;
-    Reactive.name                = "Reactive";
-    Reactive.value               = SAGARIS_KEYBOARD_MODE_REACTIVE;
-    Reactive.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Reactive.brightness_min      = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Reactive.brightness_max      = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Reactive.brightness          = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Reactive.speed_min           = SAGARIS_KEYBOARD_SPEED_MIN;
-    Reactive.speed_max           = SAGARIS_KEYBOARD_SPEED_MAX;
-    Reactive.speed               = SAGARIS_KEYBOARD_SPEED_DEFAULT;
-    Reactive.color_mode          = MODE_COLORS_MODE_SPECIFIC;
-    Reactive.colors_min          = 1;
-    Reactive.colors_max          = 1;
-    Reactive.colors.resize(1);
-    modes.push_back(Reactive);
-
-    mode Starry_Night;
-    Starry_Night.name            = "Starry Night";
-    Starry_Night.value           = SAGARIS_KEYBOARD_MODE_STARRY_NIGHT;
-    Starry_Night.flags           = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Starry_Night.brightness_min  = SAGARIS_KEYBOARD_SPEED_MIN;
-    Starry_Night.brightness_max  = SAGARIS_KEYBOARD_SPEED_MAX;
-    Starry_Night.brightness      = SAGARIS_KEYBOARD_SPEED_DEFAULT;
-    Starry_Night.speed_min       = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Starry_Night.speed_max       = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Starry_Night.speed           = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Starry_Night.color_mode      = MODE_COLORS_MODE_SPECIFIC;
-    Starry_Night.colors_min      = 7;
-    Starry_Night.colors_max      = 7;
-    Starry_Night.colors.resize(7);
-    modes.push_back(Starry_Night);
-
-    mode Laser;
-    Laser.name                   = "Laser";
-    Laser.value                  = SAGARIS_KEYBOARD_MODE_LASER;
-    Laser.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Laser.brightness_min         = SAGARIS_KEYBOARD_SPEED_MIN;
-    Laser.brightness_max         = SAGARIS_KEYBOARD_SPEED_MAX;
-    Laser.brightness             = SAGARIS_KEYBOARD_SPEED_DEFAULT;
-    Laser.speed_min              = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Laser.speed_max              = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Laser.speed                  = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Laser.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-    Laser.colors_min             = 7;
-    Laser.colors_max             = 7;
-    Laser.colors.resize(7);
-    modes.push_back(Laser);
-
-    SetupZones();
-
-    sagaris_mode current_mode = controller->GetMode();
-
-    active_mode = current_mode.mode;
-    last_mode   = current_mode.mode;
-    modes[active_mode].brightness = current_mode.brightness;
-    modes[active_mode].speed      = current_mode.speed;
-
-    current_colors = controller->GetColors();
-
-    for(int i = 0; i < modes[active_mode].colors.size(); i++)
-    {
-        modes[active_mode].colors[i] = current_colors[i];
-    }
-}
-
-RGBController_AsusSagarisKeyboard::~RGBController_AsusSagarisKeyboard()
-{
-    delete controller;
-}
-
-void RGBController_AsusSagarisKeyboard::SetupZones()
-{
-    zone keyboard;
-    keyboard.name               = "Keyboard";
-    keyboard.type               = ZONE_TYPE_SINGLE;
-    keyboard.leds_min           = 1;
-    keyboard.leds_max           = 1;
-    keyboard.leds_count         = 1;
-    keyboard.matrix_map         = nullptr;
-
-    SetupColors();
-}
-
-void RGBController_AsusSagarisKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
-void RGBController_AsusSagarisKeyboard::DeviceUpdateLEDs()
-{
-
-}
-
-void RGBController_AsusSagarisKeyboard::UpdateZoneLEDs(int /*zone*/)
-{
-
-}
-
-void RGBController_AsusSagarisKeyboard::UpdateSingleLED(int led)
-{
-    
-}
-
-void RGBController_AsusSagarisKeyboard::DeviceUpdateMode()
-{
-    if(last_mode != active_mode)
-    {
-        last_mode = active_mode;
-        for(int i = 0; i < modes[active_mode].colors.size(); i++)
-        {
-            modes[active_mode].colors[i] = current_colors[i];
-        }
-    }
-    else
-    {
-        for(int i = 0; i < modes[active_mode].colors.size(); i++)
-        {
-            current_colors[i] = modes[active_mode].colors[i];
-        }
-
-        for(int i = 0; i < modes[active_mode].colors.size(); i++)
-        {
-            /*-----------------------------------------*\
-            | This device uses 4bit colorValues (0-16)  |
-            \*-----------------------------------------*/
-            uint8_t red     = RGBGetRValue(modes[active_mode].colors[i]) / 16;
-            uint8_t green   = RGBGetGValue(modes[active_mode].colors[i]) / 16;
-            uint8_t blue    = RGBGetBValue(modes[active_mode].colors[i]) / 16;
-
-            controller->SetColor(i, red, green, blue);
-        }
-    }
-
-    /*------------------------------------------------------------------------------------------------------*\
-    | This device uses a global color storage for 7 colors,                                                  |
-    | each time a mode is selected, it is specified which color is chosen (some use all).                    |
-    | As OpenRGB doesn't support selecting the color index, color 1 is used for single color modes.          |
-    \*------------------------------------------------------------------------------------------------------*/
-
-    uint8_t colorIndex = 0;
-
-    uint8_t mode = modes[active_mode].value;
-
-    if(mode == SAGARIS_KEYBOARD_MODE_STARRY_NIGHT) colorIndex = 7;
-
-    controller->SetMode(mode, modes[active_mode].brightness, modes[active_mode].speed, colorIndex);
-}
@@ -1,34 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusSagarisKeyboard.h     |
-|                                           |
-|  Generic RGB Interface for Asus Sagaris  |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 08/20/2023                        |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusSagarisKeyboardController.h"
-
-class RGBController_AsusSagarisKeyboard : public RGBController
-{
-public:
-    RGBController_AsusSagarisKeyboard(AsusSagarisKeyboardController* controller_ptr);
-    ~RGBController_AsusSagarisKeyboard();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AsusSagarisKeyboardController*  controller;
-    std::vector<RGBColor>           current_colors;
-    uint8_t                         last_mode;
-};
@@ -1,6 +1,6 @@
 #ifdef _WIN32

-#include "AsusTUFLaptopController_Windows.h"
+#include "AsusTUFLaptopController.h"

 #include <Objbase.h>
 #include <setupapi.h>
@@ -1,4 +1,4 @@
-#include "AsusTUFLaptopController_Linux.h"
+#include "AsusTUFLaptopLinuxController.h"

 #include <string>

@@ -1,4 +1,5 @@
-#include "RGBController_AsusTUFLaptop_Linux.h"
+#include "RGBController_AsusTUFLaptopLinux.h"
+#include "AsusTUFLaptopLinuxController.h"

 #include <string>
 #include "Detector.h"
@@ -1,6 +1,7 @@
 #ifdef _WIN32

-#include "RGBController_AsusTUFLaptop_Windows.h"
+#include "AsusTUFLaptopController.h"
+#include "RGBController_AsusTUFLaptopWMI.h"

 #include "Detector.h"
 #include "wmi.h"
@@ -1,4 +1,4 @@
-#include "RGBController_AsusTUFLaptop_Linux.h"
+#include "RGBController_AsusTUFLaptopLinux.h"

 /**------------------------------------------------------------------*\
    @name Asus TUF Laptop Linux WMI
@@ -2,7 +2,7 @@
 #define RGBCONTROLLER_ASUSTUFLAPTOPLINUX_H

 #include "RGBController.h"
-#include "AsusTUFLaptopController_Linux.h"
+#include "AsusTUFLaptopLinuxController.h"


 class RGBController_AsusTUFLaptopLinux : public RGBController
@@ -1,6 +1,6 @@
 #ifdef _WIN32

-#include "RGBController_AsusTUFLaptop_Windows.h"
+#include "RGBController_AsusTUFLaptopWMI.h"

 using namespace std::chrono_literals;

@@ -3,7 +3,7 @@
 #ifndef RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
 #define RGBCONTROLLER_ASUSTUFLAPTOPWMI_H

-#include "AsusTUFLaptopController_Windows.h"
+#include "AsusTUFLaptopController.h"
 #include "RGBController.h"

 class RGBController_AsusTUFLaptopWMI : public RGBController
@@ -2,6 +2,7 @@
 #include "BlinkyTapeController.h"
 #include "RGBController.h"
 #include "RGBController_BlinkyTape.h"
+#include "SettingsManager.h"
 #include "find_usb_serial_port.h"
 #include <vector>
 #include <stdio.h>
@@ -95,19 +95,18 @@ void CherryKeyboardController::SendKeyboardModeEx
    unsigned char       blue
    )
 {
-    unsigned char parameter_data[9];
+    unsigned char parameter_data[8];

-    parameter_data[0]   = 0x0;
-    parameter_data[1]   = mode;
-    parameter_data[2]   = brightness;
-    parameter_data[3]   = speed;
-    parameter_data[4]   = direction;
-    parameter_data[5]   = random_flag;
-    parameter_data[6]   = red;
-    parameter_data[7]   = green;
-    parameter_data[8]   = blue;
+    parameter_data[0]   = mode;
+    parameter_data[1]   = brightness;
+    parameter_data[2]   = speed;
+    parameter_data[3]   = direction;
+    parameter_data[4]   = random_flag;
+    parameter_data[5]   = red;
+    parameter_data[6]   = green;
+    parameter_data[7]   = blue;

-    SendKeyboardParameter(0, 9, parameter_data);
+    SendKeyboardParameter(0, 8, parameter_data);
 }

 /*-------------------------------------------------------------------------------------------------*\
@@ -238,18 +237,17 @@ void CherryKeyboardController::SendKeyboardParameter
    memset(usb_buf, 0x00, sizeof(usb_buf));

    /*-----------------------------------------------------*\
-    | Set up Keyboard Parameter (0x08) packet               |
+    | Set up Keyboard Parameter (0x06) packet               |
    \*-----------------------------------------------------*/
    usb_buf[0x00]           = 0x04;
    usb_buf[0x03]           = CHERRY_KB_COMMAND_SET_PARAMETER;
    usb_buf[0x04]           = parameter_size;
    usb_buf[0x05]           = parameter;
-    usb_buf[0x07]           = 0x55;

    /*-----------------------------------------------------*\
    | Copy in data bytes                                    |
    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x08], parameter_data, parameter_size);
+    memcpy(&usb_buf[0x09], parameter_data, parameter_size);

    /*-----------------------------------------------------*\
    | Compute Checksum                                      |
@@ -17,34 +17,6 @@
 #define CHERRY_KB_PACKET_SIZE                        64
 #define CHERRY_KB_MAX_PACKET_SIZE                  ( 0x36 )/* max packet size for color*/
                                                            /* update packets           */
-
-/*-----------------------------------------------------*\
-| Cherry keyboard product IDs                           |
-\*-----------------------------------------------------*/
-#define MX_BOARD_3_0S_FL_NBL_PID        0x0077
-#define MX_BOARD_3_0S_FL_RGB_PID        0x0079
-#define MX_BOARD_3_0S_FL_RGB_KOR_PID    0x0083
-#define MX_1_0_FL_BL_PID                0x00AB
-#define MX_BOARD_1_0_TKL_RGB_PID        0x00AC
-#define MX_BOARD_8_0_TKL_RGB_PID        0x00B7
-#define MX_BOARD_10_0_FL_RGB_PID        0x00BB
-#define G80_3000_TKL_NBL_PID            0x00C3
-#define MX_BOARD_2_0S_FL_RGB_PID        0x00C4
-#define G80_3000_TKL_RGB_PID            0x00C5
-#define MV_BOARD_3_0FL_RGB_PID          0x00C7
-#define CCF_MX_8_0_TKL_BL_PID           0x00C9
-#define CCF_MX_1_0_TKL_BL_PID           0x00CA
-#define CCF_MX_1_0_TKL_NBL_PID          0x00CB
-#define G80_3000_TKL_NBL_KOR_PID        0x00CD
-#define MX_BOARD_2_0S_FL_NBL_PID        0x00CE
-#define MX_1_0_FL_NBL_PID               0x00D2
-#define MX_1_0_FL_RGB_PID               0x00D3
-#define G80_3000N_TKL_RGB_PID           0x00DD
-#define G80_3000N_FL_RGB_PID            0x00DE
-#define MX_BOARD_10_0N_FL_RGB_PID       0x00DF
-#define MX_BOARD_2_0S_FL_RGB_DE_PID     0x01A6
-
-
 enum
 {
    CHERRY_KB_COMMAND_BEGIN                        = 0x01, /* Begin packet command     */
@@ -6,10 +6,32 @@
 #include <hidapi/hidapi.h>

 /*-----------------------------------------------------*\
-| Cherry keyboard VID and usage page                    |
+| Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
 #define CHERRY_KEYBOARD_VID             0x046A
 #define CHERRY_KEYBOARD_USAGE_PAGE      0xFF1C
+#define MX_BOARD_3_0S_FL_NBL_PID        0x0077
+#define MX_BOARD_3_0S_FL_RGB_PID        0x0079
+#define MX_BOARD_3_0S_FL_RGB_KOR_PID    0x0083
+#define MX_1_0_FL_BL_PID                0x00AB
+#define MX_BOARD_1_0_TKL_RGB_PID        0x00AC
+#define MX_BOARD_8_0_TKL_RGB_PID        0x00B7
+#define MX_BOARD_10_0_FL_RGB_PID        0x00BB
+#define G80_3000_TKL_NBL_PID            0x00C3
+#define MX_BOARD_2_0S_FL_RGB_PID        0x00C4
+#define G80_3000_TKL_RGB_PID            0x00C5
+#define MV_BOARD_3_0FL_RGB_PID          0x00C7
+#define CCF_MX_8_0_TKL_BL_PID           0x00C9
+#define CCF_MX_1_0_TKL_BL_PID           0x00CA
+#define CCF_MX_1_0_TKL_NBL_PID          0x00CB
+#define G30_3000_TKL_NBL_KOR_PID        0x00CD
+#define MX_BOARD_2_0S_FL_NBL_PID        0x00CE
+#define MX_1_0_FL_NBL_PID               0x00D2
+#define MX_1_0_FL_RGB_PID               0x00D3
+#define G80_3000N_TKL_RGB_PID           0x00DD
+#define G30_3000N_FL_RGB_PID            0x00DE
+#define MX_BOARD_10_0N_FL_RGB_PID       0x00DF
+#define MX_BOARD_2_0S_FL_RGB_DE_PID     0x01A6

 /******************************************************************************************\
 *                                                                                          *
@@ -25,7 +47,7 @@ void DetectCherryKeyboards(hid_device_info* info, const std::string& name)
    if( dev )
    {
        CherryKeyboardController* controller = new CherryKeyboardController(dev, info->path);
-        RGBController_CherryKeyboard* rgb_controller = new RGBController_CherryKeyboard(controller, info->product_id);
+        RGBController_CherryKeyboard* rgb_controller = new RGBController_CherryKeyboard(controller);
        rgb_controller->name = name;
        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
@@ -48,11 +70,11 @@ REGISTER_HID_DETECTOR_IP("Cherry Keyboard MV BOARD 3.0 FL RGB",         DetectCh
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard CCF MX 8.0 TKL BL",           DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   CCF_MX_8_0_TKL_BL_PID       , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard CCF MX 1.0 TKL BL",           DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   CCF_MX_1_0_TKL_BL_PID       , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard CCF MX 1.0 TKL NBL",          DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   CCF_MX_1_0_TKL_NBL_PID      , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000 TKL NBL KOREAN",     DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G80_3000_TKL_NBL_KOR_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000 TKL NBL KOREAN",     DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G30_3000_TKL_NBL_KOR_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 2.0S FL NBL",        DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_2_0S_FL_NBL_PID    , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX 1.0 FL NBL",               DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_1_0_FL_NBL_PID           , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX 1.0 FL RGB",               DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_1_0_FL_RGB_PID           , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000N TKL RGB",           DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G80_3000N_TKL_RGB_PID       , 1, CHERRY_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000N FL RGB",            DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G80_3000N_FL_RGB_PID        , 1, CHERRY_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000N FL RGB",            DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   G30_3000N_FL_RGB_PID        , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 10.0N FL RGB",       DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_10_0N_FL_RGB_PID   , 1, CHERRY_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 2.0S FL RGB DE",     DetectCherryKeyboards, CHERRY_KEYBOARD_VID,   MX_BOARD_2_0S_FL_RGB_DE_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
@@ -11,20 +11,14 @@

 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF
-#define CHERRY_MATRIX_MAP_HEIGHT 6
-#define CHERRY_MATRIX_MAP_WIDTH 21
-#define CHERRY_MATRIX_CELL_COUNT ( CHERRY_MATRIX_MAP_HEIGHT * CHERRY_MATRIX_MAP_WIDTH )

-/* The total byte count for all colors is 'number of matrix cells' times '3 color components' */
-#define CUSTOM_COLOR_ARRAY_BYTE_COUNT ( CHERRY_MATRIX_CELL_COUNT * 3 )
-
-static unsigned int matrix_map[CHERRY_MATRIX_MAP_HEIGHT][CHERRY_MATRIX_MAP_WIDTH] =
-    { {  0,  NA,  12,  18,  24,  30,  36,  42,  48,  54,  60,  66,  72,  78,  84,  90,  96,  102, 108, 114, 120 },
-      {  1,   7,  13,  19,  25,  31,  37,  43,  49,  55,  61,  67,  73,  79,  85,  91,  97,  103, 109, 115, 121 },
-      {  2,   8,  14,  20,  26,  32,  38,  44,  50,  56,  62,  68,  74,  NA,  86,  92,  98,  104, 110, 116,  NA },
-      {  3,   9,  15,  21,  27,  33,  39,  45,  51,  57,  63,  69,  75,  81,  NA,  NA,  NA,  105, 111, 117, 122 },
-      {  4,  10,  16,  22,  28,  34,  40,  46,  52,  58,  64,  70,  NA,  82,  NA,  94,  NA,  106, 112, 118,  NA },
-      {  5,  11,  17,  NA,  NA,  NA,  41,  NA,  NA,  NA,  65,  71,  77,  83,  89,  95, 101,  113,  NA, 119, 124 } };
+static unsigned int matrix_map[6][23] =
+    { {  0,  NA,  12,  18,  24,  30,  36,  42,  48,  54,  60,  66,  72,  78,  84,  90,  96,  NA,  NA,  NA,  NA,  NA,  NA },
+      {  1,   7,  13,  19,  25,  31,  37,  43,  49,  55,  61,  67,  73,  79,  85,  91,  97,  NA,  NA,  NA,  NA,  NA,  NA },
+      {  2,   8,  14,  20,  26,  32,  38,  44,  50,  56,  62,  68,  74,  NA,  86,  92,  98,  NA,  NA,  NA,  NA,  NA,  NA },
+      {  3,   9,  15,  21,  27,  33,  39,  45,  51,  57,  63,  69,  75,  81,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
+      {  4,  10,  16,  22,  28,  34,  40,  46,  52,  58,  64,  70,  NA,  82,  NA,  94,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
+      {  5,  11,  17,  NA,  NA,  NA,  41,  NA,  NA,  NA,  65,  71,  77,  83,  89,  95, 101,  NA,  NA,  NA,  NA,  NA,  NA } };

 /**------------------------------------------------------------------*\
    @name Cherry Keyboard
@@ -37,7 +31,7 @@ static unsigned int matrix_map[CHERRY_MATRIX_MAP_HEIGHT][CHERRY_MATRIX_MAP_WIDTH
    @comment
 \*-------------------------------------------------------------------*/

-RGBController_CherryKeyboard::RGBController_CherryKeyboard(CherryKeyboardController* controller_ptr, uint16_t product_id)
+RGBController_CherryKeyboard::RGBController_CherryKeyboard(CherryKeyboardController* controller_ptr)
 {
    controller  = controller_ptr;

@@ -49,259 +43,202 @@ RGBController_CherryKeyboard::RGBController_CherryKeyboard(CherryKeyboardControl
    serial      = controller->GetSerialString();

    mode Custom;
-    Custom.name           = "Custom";
-    Custom.value          = CHERRY_KB_MODE_CUSTOM;
-    Custom.flags          = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Custom.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Custom.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Custom.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Custom.color_mode     = MODE_COLORS_PER_LED;
+    Custom.name       = "Custom";
+    Custom.value      = CHERRY_KB_MODE_CUSTOM;
+    Custom.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Custom.color_mode = MODE_COLORS_PER_LED;
    modes.push_back(Custom);

    mode Wave;
-    Wave.name           = "Wave";
-    Wave.value          = CHERRY_KB_MODE_WAVE;
-    Wave.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Wave.speed_min      = CHERRY_KB_SPEED_SLOWEST;
-    Wave.speed_max      = CHERRY_KB_SPEED_FASTEST;
-    Wave.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Wave.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Wave.colors_min     = 1;
-    Wave.colors_max     = 1;
-    Wave.speed          = CHERRY_KB_SPEED_NORMAL;
-    Wave.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Wave.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Wave.name       = "Wave";
+    Wave.value      = CHERRY_KB_MODE_WAVE;
+    Wave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Wave.speed_min  = CHERRY_KB_SPEED_SLOWEST;
+    Wave.speed_max  = CHERRY_KB_SPEED_FASTEST;
+    Wave.speed      = CHERRY_KB_SPEED_NORMAL;
+    Wave.colors_min = 1;
+    Wave.colors_max = 1;
+    Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
    Wave.colors.resize(1);
    modes.push_back(Wave);

    mode Spectrum;
-    Spectrum.name           = "Spectrum";
-    Spectrum.value          = CHERRY_KB_MODE_SPECTRUM;
-    Spectrum.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
-    Spectrum.speed_min      = CHERRY_KB_SPEED_SLOWEST;
-    Spectrum.speed_max      = CHERRY_KB_SPEED_FASTEST;
-    Spectrum.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Spectrum.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Spectrum.speed          = CHERRY_KB_SPEED_NORMAL;
-    Spectrum.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Spectrum.color_mode     = MODE_COLORS_NONE;
+    Spectrum.name       = "Spectrum";
+    Spectrum.value      = CHERRY_KB_MODE_SPECTRUM;
+    Spectrum.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Spectrum.speed_min  = CHERRY_KB_SPEED_SLOWEST;
+    Spectrum.speed_max  = CHERRY_KB_SPEED_FASTEST;
+    Spectrum.speed      = CHERRY_KB_SPEED_NORMAL;
+    Spectrum.color_mode = MODE_COLORS_NONE;
    Spectrum.colors.resize(1);
    modes.push_back(Spectrum);

    mode Breathing;
-    Breathing.name           = "Breathing";
-    Breathing.value          = CHERRY_KB_MODE_BREATHING;
-    Breathing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Breathing.speed_min      = CHERRY_KB_SPEED_SLOWEST;
-    Breathing.speed_max      = CHERRY_KB_SPEED_FASTEST;
-    Breathing.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Breathing.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Breathing.colors_min     = 1;
-    Breathing.colors_max     = 1;
-    Breathing.speed          = CHERRY_KB_SPEED_NORMAL;
-    Breathing.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Breathing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.name       = "Breathing";
+    Breathing.value      = CHERRY_KB_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Breathing.speed_min  = CHERRY_KB_SPEED_SLOWEST;
+    Breathing.speed_max  = CHERRY_KB_SPEED_FASTEST;
+    Breathing.speed      = CHERRY_KB_SPEED_NORMAL;
+    Breathing.colors_min = 1;
+    Breathing.colors_max = 1;
+    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
    Breathing.colors.resize(1);
    modes.push_back(Breathing);

    mode Static;
-    Static.name           = "Static";
-    Static.value          = CHERRY_KB_MODE_STATIC;
-    Static.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
-    Static.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Static.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Static.colors_min     = 1;
-    Static.colors_max     = 1;
-    Static.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Static.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Static.name       = "Static";
+    Static.value      = CHERRY_KB_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Static.colors_min = 1;
+    Static.colors_max = 1;
+    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
    Static.colors.resize(1);
    modes.push_back(Static);

    mode Radar;
-    Radar.name           = "Radar";
-    Radar.value          = CHERRY_KB_MODE_RADAR;
-    Radar.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Radar.speed_min      = CHERRY_KB_SPEED_SLOWEST;
-    Radar.speed_max      = CHERRY_KB_SPEED_FASTEST;
-    Radar.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Radar.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Radar.colors_min     = 1;
-    Radar.colors_max     = 1;
-    Radar.speed          = CHERRY_KB_SPEED_NORMAL;
-    Radar.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Radar.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Radar.name       = "Radar";
+    Radar.value      = CHERRY_KB_MODE_RADAR;
+    Radar.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Radar.speed_min  = CHERRY_KB_SPEED_SLOWEST;
+    Radar.speed_max  = CHERRY_KB_SPEED_FASTEST;
+    Radar.speed      = CHERRY_KB_SPEED_NORMAL;
+    Radar.colors_min = 1;
+    Radar.colors_max = 1;
+    Radar.color_mode = MODE_COLORS_MODE_SPECIFIC;
    Radar.colors.resize(1);
-    if(hasUnofficialModeSupport(product_id))
-        modes.push_back(Radar);
+    modes.push_back(Radar);

    mode Vortex;
-    Vortex.name           = "Vortex";
-    Vortex.value          = CHERRY_KB_MODE_VORTEX;
-    Vortex.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Vortex.speed_min      = CHERRY_KB_SPEED_SLOWEST;
-    Vortex.speed_max      = CHERRY_KB_SPEED_FASTEST;
-    Vortex.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Vortex.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Vortex.colors_min     = 1;
-    Vortex.colors_max     = 1;
-    Vortex.speed          = CHERRY_KB_SPEED_NORMAL;
-    Vortex.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Vortex.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Vortex.name       = "Vortex";
+    Vortex.value      = CHERRY_KB_MODE_VORTEX;
+    Vortex.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Vortex.speed_min  = CHERRY_KB_SPEED_SLOWEST;
+    Vortex.speed_max  = CHERRY_KB_SPEED_FASTEST;
+    Vortex.speed      = CHERRY_KB_SPEED_NORMAL;
+    Vortex.colors_min = 1;
+    Vortex.colors_max = 1;
+    Vortex.color_mode = MODE_COLORS_MODE_SPECIFIC;
    Vortex.colors.resize(1);
-    if(hasUnofficialModeSupport(product_id))
-        modes.push_back(Vortex);
+    modes.push_back(Vortex);

    mode Fire;
-    Fire.name           = "Fire";
-    Fire.value          = CHERRY_KB_MODE_FIRE;
-    Fire.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Fire.speed_min      = CHERRY_KB_SPEED_SLOWEST;
-    Fire.speed_max      = CHERRY_KB_SPEED_FASTEST;
-    Fire.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Fire.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Fire.colors_min     = 1;
-    Fire.colors_max     = 1;
-    Fire.speed          = CHERRY_KB_SPEED_NORMAL;
-    Fire.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Fire.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Fire.name       = "Fire";
+    Fire.value      = CHERRY_KB_MODE_FIRE;
+    Fire.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Fire.speed_min  = CHERRY_KB_SPEED_SLOWEST;
+    Fire.speed_max  = CHERRY_KB_SPEED_FASTEST;
+    Fire.speed      = CHERRY_KB_SPEED_NORMAL;
+    Fire.colors_min = 1;
+    Fire.colors_max = 1;
+    Fire.color_mode = MODE_COLORS_MODE_SPECIFIC;
    Fire.colors.resize(1);
-    if(hasUnofficialModeSupport(product_id))
-        modes.push_back(Fire);
+    modes.push_back(Fire);

    mode Stars;
-    Stars.name           = "Stars";
-    Stars.value          = CHERRY_KB_MODE_STARS;
-    Stars.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Stars.speed_min      = CHERRY_KB_SPEED_SLOWEST;
-    Stars.speed_max      = CHERRY_KB_SPEED_FASTEST;
-    Stars.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Stars.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Stars.speed          = CHERRY_KB_SPEED_NORMAL;
-    Stars.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Stars.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Stars.name       = "Stars";
+    Stars.value      = CHERRY_KB_MODE_STARS;
+    Stars.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Stars.speed_min  = CHERRY_KB_SPEED_SLOWEST;
+    Stars.speed_max  = CHERRY_KB_SPEED_FASTEST;
+    Stars.speed      = CHERRY_KB_SPEED_NORMAL;
+    Stars.color_mode = MODE_COLORS_MODE_SPECIFIC;
    Stars.colors.resize(1);
-    if(hasUnofficialModeSupport(product_id))
-        modes.push_back(Stars);
+    modes.push_back(Stars);

    mode Rain;
-    Rain.name           = "Rain";
-    Rain.value          = CHERRY_KB_MODE_RAIN;
-    Rain.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Rain.speed_min      = CHERRY_KB_SPEED_SLOWEST;
-    Rain.speed_max      = CHERRY_KB_SPEED_FASTEST;
-    Rain.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Rain.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Rain.colors_min     = 1;
-    Rain.colors_max     = 1;
-    Rain.speed          = CHERRY_KB_SPEED_NORMAL;
-    Rain.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Rain.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Rain.name       = "Rain";
+    Rain.value      = CHERRY_KB_MODE_RAIN;
+    Rain.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Rain.speed_min  = CHERRY_KB_SPEED_SLOWEST;
+    Rain.speed_max  = CHERRY_KB_SPEED_FASTEST;
+    Rain.speed      = CHERRY_KB_SPEED_NORMAL;
+    Rain.colors_min = 1;
+    Rain.colors_max = 1;
+    Rain.color_mode = MODE_COLORS_MODE_SPECIFIC;
    Rain.colors.resize(1);
-    if(hasUnofficialModeSupport(product_id))
-        modes.push_back(Rain);
+    modes.push_back(Rain);

    mode Rolling;
-    Rolling.name           = "Rolling";
-    Rolling.value          = CHERRY_KB_MODE_ROLLING;
-    Rolling.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
-    Rolling.speed_min      = CHERRY_KB_SPEED_SLOWEST;
-    Rolling.speed_max      = CHERRY_KB_SPEED_FASTEST;
-    Rolling.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Rolling.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Rolling.speed          = CHERRY_KB_SPEED_NORMAL;
-    Rolling.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Rolling.color_mode     = MODE_COLORS_NONE;
+    Rolling.name       = "Rolling";
+    Rolling.value      = CHERRY_KB_MODE_ROLLING;
+    Rolling.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Rolling.speed_min  = CHERRY_KB_SPEED_SLOWEST;
+    Rolling.speed_max  = CHERRY_KB_SPEED_FASTEST;
+    Rolling.speed      = CHERRY_KB_SPEED_NORMAL;
+    Rolling.color_mode = MODE_COLORS_NONE;
    modes.push_back(Rolling);
    
    mode Curve;
-    Curve.name           = "Curve";
-    Curve.value          = CHERRY_KB_MODE_CURVE;
-    Curve.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Curve.speed_min      = CHERRY_KB_SPEED_SLOWEST;
-    Curve.speed_max      = CHERRY_KB_SPEED_FASTEST;
-    Curve.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Curve.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Curve.colors_min     = 1;
-    Curve.colors_max     = 1;
-    Curve.speed          = CHERRY_KB_SPEED_NORMAL;
-    Curve.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Curve.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Curve.name       = "Curve";
+    Curve.value      = CHERRY_KB_MODE_CURVE;
+    Curve.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Curve.speed_min  = CHERRY_KB_SPEED_SLOWEST;
+    Curve.speed_max  = CHERRY_KB_SPEED_FASTEST;
+    Curve.speed      = CHERRY_KB_SPEED_NORMAL;
+    Curve.colors_min = 1;
+    Curve.colors_max = 1;
+    Curve.color_mode = MODE_COLORS_MODE_SPECIFIC;
    Curve.colors.resize(1);
    modes.push_back(Curve);

    mode WaveMid;
-    WaveMid.name           = "Wave Mid";
-    WaveMid.value          = CHERRY_KB_MODE_WAVE_MID;
-    WaveMid.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    WaveMid.speed_min      = CHERRY_KB_SPEED_SLOWEST;
-    WaveMid.speed_max      = CHERRY_KB_SPEED_FASTEST;
-    WaveMid.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    WaveMid.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    WaveMid.speed          = CHERRY_KB_SPEED_NORMAL;
-    WaveMid.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    WaveMid.color_mode     = MODE_COLORS_NONE;
+    WaveMid.name       = "Wave Mid";
+    WaveMid.value      = CHERRY_KB_MODE_WAVE_MID;
+    WaveMid.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    WaveMid.speed_min  = CHERRY_KB_SPEED_SLOWEST;
+    WaveMid.speed_max  = CHERRY_KB_SPEED_FASTEST;
+    WaveMid.speed      = CHERRY_KB_SPEED_NORMAL;
+    WaveMid.color_mode = MODE_COLORS_NONE;
    WaveMid.colors.resize(1);
-    if(hasUnofficialModeSupport(product_id))
-        modes.push_back(WaveMid);
+    modes.push_back(WaveMid);

    mode Scan;
-    Scan.name           = "Scan";
-    Scan.value          = CHERRY_KB_MODE_SCAN;
-    Scan.flags          = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Scan.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Scan.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Scan.colors_min     = 1;
-    Scan.colors_max     = 1;
-    Scan.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Scan.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Scan.name       = "Scan";
+    Scan.value      = CHERRY_KB_MODE_SCAN;
+    Scan.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Scan.colors_min = 1;
+    Scan.colors_max = 1;
+    Scan.color_mode = MODE_COLORS_MODE_SPECIFIC;
    Scan.colors.resize(1);
    modes.push_back(Scan);

    mode Radiation;
-    Radiation.name           = "Radiation";
-    Radiation.value          = CHERRY_KB_MODE_RADIATION;
-    Radiation.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Radiation.speed_min      = CHERRY_KB_SPEED_SLOWEST;
-    Radiation.speed_max      = CHERRY_KB_SPEED_FASTEST;
-    Radiation.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Radiation.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Radiation.colors_min     = 1;
-    Radiation.colors_max     = 1;
-    Radiation.speed          = CHERRY_KB_SPEED_NORMAL;
-    Radiation.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Radiation.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Radiation.name       = "Radiation";
+    Radiation.value      = CHERRY_KB_MODE_RADIATION;
+    Radiation.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Radiation.speed_min  = CHERRY_KB_SPEED_SLOWEST;
+    Radiation.speed_max  = CHERRY_KB_SPEED_FASTEST;
+    Radiation.speed      = CHERRY_KB_SPEED_NORMAL;
+    Radiation.colors_min = 1;
+    Radiation.colors_max = 1;
+    Radiation.color_mode = MODE_COLORS_MODE_SPECIFIC;
    Radiation.colors.resize(1);
    modes.push_back(Radiation);

    mode Ripples;
-    Ripples.name           = "Ripples";
-    Ripples.value          = CHERRY_KB_MODE_RIPPLES;
-    Ripples.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Ripples.speed_min      = CHERRY_KB_SPEED_SLOWEST;
-    Ripples.speed_max      = CHERRY_KB_SPEED_FASTEST;
-    Ripples.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    Ripples.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Ripples.colors_min     = 1;
-    Ripples.colors_max     = 1;
-    Ripples.speed          = CHERRY_KB_SPEED_NORMAL;
-    Ripples.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    Ripples.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Ripples.name       = "Ripples";
+    Ripples.value      = CHERRY_KB_MODE_RIPPLES;
+    Ripples.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Ripples.speed_min  = CHERRY_KB_SPEED_SLOWEST;
+    Ripples.speed_max  = CHERRY_KB_SPEED_FASTEST;
+    Ripples.speed      = CHERRY_KB_SPEED_NORMAL;
+    Ripples.colors_min = 1;
+    Ripples.colors_max = 1;
+    Ripples.color_mode = MODE_COLORS_MODE_SPECIFIC;
    Ripples.colors.resize(1);
    modes.push_back(Ripples);

    mode SingleKey;
-    SingleKey.name           = "Single Key";
-    SingleKey.value          = CHERRY_KB_MODE_SINGLE_KEY;
-    SingleKey.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    SingleKey.speed_min      = CHERRY_KB_SPEED_SLOWEST;
-    SingleKey.speed_max      = CHERRY_KB_SPEED_FASTEST;
-    SingleKey.brightness_min = CHERRY_KB_BRIGHTNESS_LOWEST;
-    SingleKey.brightness_max = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    SingleKey.colors_min     = 1;
-    SingleKey.colors_max     = 1;
-    SingleKey.speed          = CHERRY_KB_SPEED_NORMAL;
-    SingleKey.brightness     = CHERRY_KB_BRIGHTNESS_HIGHEST;
-    SingleKey.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    SingleKey.name       = "Single Key";
+    SingleKey.value      = CHERRY_KB_MODE_SINGLE_KEY;
+    SingleKey.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    SingleKey.speed_min  = CHERRY_KB_SPEED_SLOWEST;
+    SingleKey.speed_max  = CHERRY_KB_SPEED_FASTEST;
+    SingleKey.speed      = CHERRY_KB_SPEED_NORMAL;
+    SingleKey.colors_min = 1;
+    SingleKey.colors_max = 1;
+    SingleKey.color_mode = MODE_COLORS_MODE_SPECIFIC;
    SingleKey.colors.resize(1);
    modes.push_back(SingleKey);

@@ -330,17 +267,17 @@ void RGBController_CherryKeyboard::SetupZones()

    new_zone.name               = "Keyboard";
    new_zone.type               = ZONE_TYPE_MATRIX;
-    new_zone.leds_min           = CHERRY_MATRIX_CELL_COUNT;
-    new_zone.leds_max           = CHERRY_MATRIX_CELL_COUNT;
-    new_zone.leds_count         = CHERRY_MATRIX_CELL_COUNT;
+    new_zone.leds_min           = 126;
+    new_zone.leds_max           = 126;
+    new_zone.leds_count         = 126;
    new_zone.matrix_map         = new matrix_map_type;
-    new_zone.matrix_map->height = CHERRY_MATRIX_MAP_HEIGHT;
-    new_zone.matrix_map->width  = CHERRY_MATRIX_MAP_WIDTH;
+    new_zone.matrix_map->height = 6;
+    new_zone.matrix_map->width  = 23;
    new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
    
    zones.push_back(new_zone);

-    for(int led_idx = 0; led_idx < CHERRY_MATRIX_CELL_COUNT; led_idx++)
+    for(int led_idx = 0; led_idx < 126; led_idx++)
    {
        led new_led;

@@ -362,9 +299,9 @@ void RGBController_CherryKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)

 void RGBController_CherryKeyboard::DeviceUpdateLEDs()
 {
-    unsigned char color_data[CUSTOM_COLOR_ARRAY_BYTE_COUNT];
+    unsigned char color_data[7*CHERRY_KB_MAX_PACKET_SIZE];

-    for(int led_idx = 0; led_idx < CHERRY_MATRIX_CELL_COUNT; led_idx++)
+    for(int led_idx = 0; led_idx < 126; led_idx++)
    {
        color_data[(3 * led_idx) + 0] = RGBGetRValue(colors[led_idx]);
        color_data[(3 * led_idx) + 1] = RGBGetGValue(colors[led_idx]);
@@ -374,7 +311,7 @@ void RGBController_CherryKeyboard::DeviceUpdateLEDs()
    controller->SetKeyboardColors
                    (
                    color_data,
-                    CUSTOM_COLOR_ARRAY_BYTE_COUNT
+                    CHERRY_KB_MAX_PACKET_SIZE * 7
                    );
 }

@@ -410,7 +347,7 @@ void RGBController_CherryKeyboard::DeviceUpdateMode()
    controller->SendKeyboardModeEx
                    (
                    modes[active_mode].value,
-                    modes[active_mode].brightness,
+                    CHERRY_KB_BRIGHTNESS_HIGHEST,
                    modes[active_mode].speed,
                    0,
                    random,
@@ -419,40 +356,3 @@ void RGBController_CherryKeyboard::DeviceUpdateMode()
                    blu
                    );
 }
-
-bool RGBController_CherryKeyboard::hasUnofficialModeSupport(const uint16_t product_id)
-{
-    switch(product_id)
-    {
-    // no backlight: Why are they even listed here? (no lights, no macros)
-    case MX_BOARD_3_0S_FL_NBL_PID:
-    case G80_3000_TKL_NBL_PID:
-    case MX_1_0_FL_NBL_PID:
-    case G80_3000_TKL_NBL_KOR_PID:
-    case CCF_MX_1_0_TKL_NBL_PID:
-    // white backlight keyboards: very doubtful if any of those RGB modes match
-    case CCF_MX_8_0_TKL_BL_PID:
-    case CCF_MX_1_0_TKL_BL_PID:
-    case MX_1_0_FL_BL_PID:
-        return false;
-    // RGB keyboards known for not supporting unofficial modes
-    case MX_BOARD_3_0S_FL_RGB_PID:
-    case MX_BOARD_3_0S_FL_RGB_KOR_PID:
-    case MX_BOARD_2_0S_FL_RGB_PID:
-    case MX_BOARD_2_0S_FL_NBL_PID:
-    case MX_BOARD_2_0S_FL_RGB_DE_PID:
-    case MV_BOARD_3_0FL_RGB_PID:
-        return false;
-    // RGB keyboards which (probably) support unofficial modes
-    case MX_BOARD_1_0_TKL_RGB_PID: // unknown
-    case MX_BOARD_8_0_TKL_RGB_PID: // unknown
-    case MX_BOARD_10_0_FL_RGB_PID: // unknown (probably yes, related to 10.0N)
-    case G80_3000_TKL_RGB_PID: // unknown
-    case MX_1_0_FL_RGB_PID: // unkown
-    case G80_3000N_TKL_RGB_PID: // yes
-    case G80_3000N_FL_RGB_PID: // firmware v0102: YES, firmware v0103: NO
-    case MX_BOARD_10_0N_FL_RGB_PID: // yes
-    default:
-        return true;
-    }
-}
@@ -14,7 +14,7 @@
 class RGBController_CherryKeyboard : public RGBController
 {
 public:
-    RGBController_CherryKeyboard(CherryKeyboardController* controller_ptr, uint16_t product_id);
+    RGBController_CherryKeyboard(CherryKeyboardController* controller_ptr);
    ~RGBController_CherryKeyboard();

    void        SetupZones();
@@ -30,6 +30,4 @@ public:

 private:
    CherryKeyboardController*  controller;
-
-    static bool hasUnofficialModeSupport(uint16_t product_id);
 };
@@ -1,7 +1,5 @@
 #include "ColorfulGPUController.h"
 #include <cstring>
-#include "pci_ids.h"
-#include "LogManager.h"

 ColorfulGPUController::ColorfulGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev)
 {
@@ -30,40 +28,17 @@ void ColorfulGPUController::SetDirect(RGBColor color)
    uint8_t g = RGBGetGValue(color);
    uint8_t b = RGBGetBValue(color);

-    if(this->bus->pci_subsystem_device == COLORFUL_IGAME_RTX_4070_VULCAN_OCV)
+    uint8_t data_pkt[COLORFUL_PACKET_LENGTH] = { 0xAA, 0xEF, 0x12, 0x03, 0x01, 0xFF, r, g, b};
+
+    int crc = 0;
+
+    for (int i = 0; i < COLORFUL_PACKET_LENGTH - 2; ++i)
    {
-        uint8_t data_pkt[COLORFUL_PACKET_LENGTH_V2] = { 0xAA, 0xEF, 0x01, 0x04, 0x88, 0x26 };
-        for(int i=6; i < COLORFUL_PACKET_LENGTH_V2 -2; i = i + 3)
-        {
-            data_pkt[i] = r;
-            data_pkt[i+1] = g;
-            data_pkt[i+2] = b;
-        }
-
-        int crc = 0;
-        for(int i = 0; i < COLORFUL_PACKET_LENGTH_V2 - 2; ++i)
-        {
-            crc += data_pkt[i];
-        }
-
-        data_pkt[COLORFUL_PACKET_LENGTH_V2 - 2] = crc & 0xFF;
-        data_pkt[COLORFUL_PACKET_LENGTH_V2 - 1] = crc >> 8;
-
-        bus->i2c_write_block(dev, COLORFUL_PACKET_LENGTH_V2, data_pkt);
+        crc += data_pkt[i];
    }
-    else
-    {
-        uint8_t data_pkt[COLORFUL_PACKET_LENGTH_V1] = { 0xAA, 0xEF, 0x12, 0x03, 0x01, 0xFF, r, g, b};

-        int crc = 0;
-        for(int i = 0; i < COLORFUL_PACKET_LENGTH_V1 - 2; ++i)
-        {
-            crc += data_pkt[i];
-        }
+    data_pkt[COLORFUL_PACKET_LENGTH - 2] = crc & 0xFF;
+    data_pkt[COLORFUL_PACKET_LENGTH - 1] = crc >> 8;

-        data_pkt[COLORFUL_PACKET_LENGTH_V1 - 2] = crc & 0xFF;
-        data_pkt[COLORFUL_PACKET_LENGTH_V1 - 1] = crc >> 8;
-
-        bus->i2c_write_block(dev, COLORFUL_PACKET_LENGTH_V1, data_pkt);
-    }
+    bus->i2c_write_block(dev, COLORFUL_PACKET_LENGTH, data_pkt);
 }
@@ -6,8 +6,7 @@

 typedef unsigned char colorful_gpu_dev_id;

-#define COLORFUL_PACKET_LENGTH_V1 11
-#define COLORFUL_PACKET_LENGTH_V2 122
+#define COLORFUL_PACKET_LENGTH 11

 class ColorfulGPUController
 {
@@ -1,5 +1,4 @@
 #include "Detector.h"
-#include "LogManager.h"
 #include "ColorfulGPUController.h"
 #include "RGBController.h"
 #include "RGBController_ColorfulGPU.h"
@@ -23,9 +22,7 @@ bool TestForColorfulGPU(i2c_smbus_interface* bus, uint8_t i2c_addr)

    int res = bus->i2c_read_block(i2c_addr, &pktsz, read_pkt);

-    LOG_DEBUG("[ColorfulGPUController] Handshake: res: %d. Expected 0xAA, 0xEF, 0x81. Received: 0x%02X, 0x%02X, 0x%02X.", res, read_pkt[0], read_pkt[1], read_pkt[2]);
-
-    return res >= 0 && (read_pkt[0] == 0xAA && read_pkt[1] == 0xEF && read_pkt[2] == 0x81);
+    return res == 0 && (read_pkt[0] == 0xAA && read_pkt[1] == 0xEF && read_pkt[2] == 0x81);
 }

 void DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
@@ -40,26 +37,16 @@ void DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
    }
 }

-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Advanced OC 12G L-V",  DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ADVANCED_OC_12G_LV, 0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",   DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,      0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",   DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_GA106_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,      0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",   DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,    0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",  DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,    0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,       0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_TI_ADVANCED_OC,     0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,       0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV2,      0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC-V",         DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ULTRAW_OC,          0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC LHR",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ULTRAW_OC,          0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Ultra W OC LHR",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_TI_ULTRAW_OC,       0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_TI_ADVANCED_OCV2,   0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Advanced OC 10G-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_ADVANCED_OC_10G,    0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_TI_ADVANCED_OCV2,   0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ultra W OC 10G LHR-V", DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_ULTRAW_OC_10G,      0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ultra W OC 10G LHR-V", DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_ULTRAW_OC_10G_2,    0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_TI_ADVANCED_OCV,    0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Vulcan OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_VULCAN_OCV,         0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",         DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV,         0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",         DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2,        0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV,       0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV2,      0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Advanced OC 12G L-V", DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ADVANCED_OC_12G_LV, 0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",  DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,      0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",  DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,    0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V", DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,    0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,       0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,       0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV2,      0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC LHR",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ULTRAW_OC,          0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Ultra W OC LHR",   DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_TI_ULTRAW_OC,       0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Advanced OC-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_TI_ADVANCED_OCV2,   0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ti Advanced OC-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_TI_ADVANCED_OCV2,   0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Ti Advanced OC-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_TI_ADVANCED_OCV,    0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2,        0x61);
@@ -65,19 +65,12 @@ void ColorfulTuringGPUController::SetStateDisplay(RGBColor color)
    bus->i2c_write_block(dev, COLORFUL_COLOR_PACKET_LENGTH, data_pkt);
 }

-void ColorfulTuringGPUController::SetDirect(RGBColor color, bool save)
+void ColorfulTuringGPUController::SetDirect(RGBColor color)
 {
    uint8_t r = RGBGetRValue(color);
    uint8_t g = RGBGetGValue(color);
    uint8_t b = RGBGetBValue(color);
-    uint8_t data_pkt[COLORFUL_COLOR_PACKET_LENGTH] = { 0x08, 0x0, 0x20, 0x10, r, g, b};
-    if(save)
-    {
-        data_pkt[0] = 0x88;
-        data_pkt[1] = 0x02;
-        data_pkt[2] = 0x32;
-        data_pkt[3] = 0x02;
-    }
+    uint8_t data_pkt[COLORFUL_COLOR_PACKET_LENGTH] = { 0x88, 0x02, 0x32, 0x02, r, g, b};

    int crc = 1;

--- a/Show More
+++ b/Show More