Remove unused string

.gitlab-ci.yml

@@ -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)

.gitlab/merge_request_templates/New Device.md

@@ -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).

AutoStart/AutoStart-Linux.cpp

@@ -4,7 +4,6 @@
 
 #include <fstream>
 #include <iostream>
-#include <sstream>
 #include <unistd.h>
 #include <linux/limits.h>
 

CONTRIBUTING.md

@@ -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
 

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -1,13 +1,3 @@
-/*-------------------------------------------------------------------*\
-|  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                                      |
 \*-----------------------------------------------------*/
@@ -19,7 +9,6 @@
 | A4 Tech specific includes                             |
 \*-----------------------------------------------------*/
 #include "RGBController_BloodyMouse.h"
-#include "RGBController_BloodyB820R.h"
 
 /*-----------------------------------------------------*\
 | A4 Tech USB vendor ID                                 |
@@ -40,21 +29,6 @@ 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);

Controllers/A4TechController/BloodyB820RController.cpp

@@ -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);
-}

Controllers/A4TechController/BloodyB820RController.h

@@ -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;
-};

Controllers/A4TechController/RGBController_BloodyB820R.cpp

@@ -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 */
-}

Controllers/A4TechController/RGBController_BloodyB820R.h

@@ -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;
-};

Controllers/AOCKeyboardController/AOCKeyboardControllerDetect.cpp

@@ -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);

Controllers/AlienwareKeyboardController/AlienwareAW410KController.cpp

@@ -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);
-}

Controllers/AlienwareKeyboardController/AlienwareAW410KController.h

@@ -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
-                    );
-};

Controllers/AlienwareKeyboardController/AlienwareKeyboardControllerDetect.cpp

@@ -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);

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW410K.cpp

@@ -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);
-    }
-}
-

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW410K.h

@@ -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;
-};

Controllers/AnnePro2Controller/AnnePro2ControllerDetect.cpp

@@ -4,8 +4,7 @@
 #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
@@ -32,8 +31,8 @@ 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);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_5, 1);

Controllers/AsusAuraGPUController/AsusAuraGPUController.cpp

@@ -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);
-}
+}

Controllers/AsusAuraGPUController/AsusAuraGPUController.h

@@ -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;
-};
+};

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -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);

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp

@@ -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();
 }

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.h

@@ -26,7 +26,6 @@ public:
     void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
-    void        DeviceSaveMode();
 
 private:
     AuraGPUController* controller;

Controllers/AsusAuraUSBController/AsusAuraAddressableController.cpp

@@ -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);
+}

Controllers/AsusAuraUSBController/AsusAuraAddressableController.h

@@ -52,4 +52,9 @@ private:
         unsigned char   grn,
         unsigned char   blu
         );
+
+    void    SendDirectApply
+        (
+        unsigned char   channel
+        );
 };

Controllers/AsusAuraUSBController/AsusAuraMainboardController.cpp

@@ -46,13 +46,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

Controllers/AsusAuraUSBController/AsusAuraMonitorController.cpp

@@ -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));
 

Controllers/AsusAuraUSBController/AsusAuraMonitorController.h

@@ -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,
 };
 

Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp

@@ -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);
-    }
-};

Controllers/AsusAuraUSBController/AsusAuraMouseController.h

@@ -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;
 

Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h

@@ -11,50 +11,43 @@
 
 #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_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_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 +67,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 +78,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 +101,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 +114,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 +127,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 +140,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 +153,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 +166,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 +179,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 }
         }
@@ -208,7 +192,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             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 }
         }
@@ -222,7 +205,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             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 }
         }
@@ -236,7 +218,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             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 }
         }
@@ -250,39 +231,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             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 +244,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 +257,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 +270,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 }
         }
@@ -334,7 +283,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             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 }
         }
@@ -348,7 +296,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             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 }
         }
@@ -362,7 +309,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             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 }
         }
@@ -376,7 +322,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
             100,
             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 +335,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 +348,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 +361,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 +374,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 +387,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 +400,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 +413,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 +426,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 +439,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 +452,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 +464,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 +476,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 +490,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 +503,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 +517,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 +530,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 +543,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 } },
-            }
-        }
-    }
-};

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller.cpp

@@ -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);
-}

Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.cpp

@@ -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);
+}

Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.h

@@ -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;
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp

@@ -95,19 +95,11 @@ std::string AuraTUFKeyboardController::GetVersion()
         
         switch(device_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]);
         }
@@ -351,131 +343,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 +358,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));
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h

@@ -33,27 +33,20 @@ 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_STRIX_FLARE_PID                     = 0x1875,
+    AURA_ROG_STRIX_FLARE_PNK_LTD_PID             = 0x18CF,
+    AURA_ROG_STRIX_FLARE_COD_BO4_PID             = 0x18AF,
+    AURA_ROG_FALCHION_WIRED_PID                  = 0x193C,
+    AURA_ROG_FALCHION_WIRELESS_PID               = 0x193E,
+    AURA_ROG_STRIX_SCOPE_PID                     = 0x18F8,
+    AURA_ROG_STRIX_SCOPE_RX_PID                  = 0x1951,
+    AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID  = 0x1AAE,
+    AURA_ROG_STRIX_FLARE_II_ANIMATE_PID          = 0x19FC,
+    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 +90,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,

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardLayouts.h

@@ -80,24 +80,6 @@ static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_ISO[6][24] =
     {   5,   8,  14,  NA,  NA,  NA,  34,  NA,  NA,  NA,  55,  61,  66,  NA,  74,  NA,  78,  83,  87,  NA,  92,  NA, 101,  NA }
 };
 
-static unsigned int ASUS_ROG_AZOTH_LAYOUT_KEYS_US[6][16] = {
-    {   0,   6,   9,  15,  20,  25,  30,  36,  41,  46,  51,  57,  63,  NA,  NA,  NA },
-    {   1,   7,  10,  16,  21,  26,  31,  37,  42,  47,  52,  58,  64,  69,  NA,  76 },
-    {   2,  NA,  11,  17,  22,  27,  32,  38,  43,  48,  53,  59,  65,  70,  72,  77 },
-    {   3,  NA,  12,  18,  23,  28,  33,  39,  44,  49,  54,  60,  66,  NA,  73,  78 },
-    {   4,  NA,  13,  19,  24,  29,  34,  40,  45,  50,  55,  61,  67,  NA,  74,  79 },
-    {   5,   8,  14,  NA,  NA,  NA,  35,  NA,  NA,  NA,  56,  62,  68,  71,  75,  80 }
-};
-
-static unsigned int ASUS_ROG_AZOTH_LAYOUT_KEYS_UK[6][16] = {
-    {   0,   6,  10,  16,  21,  26,  31,  37,  42,  47,  52,  58,  64,  NA,  NA,  NA },
-    {   1,   7,  11,  17,  22,  27,  32,  38,  43,  48,  53,  59,  65,  70,  NA,  77 },
-    {   2,  NA,  12,  18,  23,  28,  33,  39,  44,  49,  54,  60,  66,  71,  NA,  78 },
-    {   3,  NA,  13,  19,  24,  29,  34,  40,  45,  50,  55,  61,  67,  72,  74,  79 },
-    {   4,   8,  14,  20,  25,  30,  35,  41,  46,  51,  56,  62,  68,  NA,  75,  80 },
-    {   5,   9,  15,  NA,  NA,  NA,  36,  NA,  NA,  NA,  57,  63,  69,  73,  76,  81 }
-};
-
 static unsigned int ASUS_ROG_STRIX_SCOPE_LAYOUT_KEYS_ANSI[6][24] =
 {
     {   0,  NA,   8,  14,  19,  24,  NA,  34,  39,  44,  49,  55,  61,  66,  70,  NA,  74,  78,  83,  NA,  NA,  NA, 104, 105 },
@@ -119,27 +101,6 @@ static unsigned int ASUS_ROG_STRIX_SCOPE_LAYOUT_KEYS_ISO[6][24] =
     {   5,   8,  14,  NA,  NA,  NA,  34,  NA,  NA,  NA,  55,  61,  66,  NA,  74,  NA,  78,  83,  87,  NA,  92,  NA, 101,  NA }
 };
 
-static unsigned int ASUS_ROG_STRIX_SCOPE_II_LAYOUT_KEYS_ANSI[6][24] =
-{
-    {   0,  NA,   8,  14,  19,  24,  NA,  35,  41,  46,  51,  57,  63,  68,  72,  NA,  76,  80,  85,  NA,  NA,  94,  NA,  NA },
-    {   1,   6,   9,  15,  20,  25,  30,  36,  42,  47,  52,  58,  64,  69,  NA,  NA,  77,  81,  86,  NA,  89,  95,  99, 104 },
-    {   2,  NA,  10,  16,  21,  26,  31,  37,  43,  48,  53,  59,  65,  70,  73,  NA,  78,  82,  87,  NA,  90,  96, 100, 105 },
-    {   3,  NA,  11,  17,  22,  27,  32,  38,  44,  49,  54,  60,  66,  NA,  74,  NA,  NA,  NA,  NA,  NA,  91,  97, 101,  NA },
-    {   4,  NA,  12,  18,  23,  28,  33,  39,  45,  50,  55,  61,  NA,  71,  NA,  NA,  NA,  83,  NA,  NA,  92,  98, 102, 106 },
-    {   5,   7,  13,  NA,  NA,  29,  34,  40,  NA,  NA,  56,  62,  67,  NA,  75,  NA,  79,  84,  88,  NA,  93,  NA, 103,  NA }
-};
-
-
-static unsigned int ASUS_ROG_STRIX_SCOPE_II_LAYOUT_KEYS_ISO[6][24] =
-{
-    {   0,  NA,   9,  15,  20,  25,  NA,  36,  42,  47,  52,  58,  64,  69,  74,  NA,  77,  81,  86,  NA,  NA,  95,  NA,  NA },
-    {   1,   6,  10,  16,  21,  26,  31,  37,  43,  48,  53,  59,  65,  70,  NA,  NA,  78,  82,  87,  NA,  90,  96, 100, 105 },
-    {   2,  NA,  11,  17,  22,  27,  32,  38,  44,  49,  54,  60,  66,  71,  NA,  NA,  79,  83,  88,  NA,  91,  97, 101, 106 },
-    {   3,  NA,  12,  18,  23,  28,  33,  39,  45,  50,  55,  61,  67,  72,  75,  NA,  NA,  NA,  NA,  NA,  92,  98, 102,  NA },
-    {   4,   7,  13,  19,  24,  29,  34,  40,  46,  51,  56,  62,  NA,  73,  NA,  NA,  NA,  84,  NA,  NA,  93,  99, 103, 107 },
-    {   5,   8,  14,  NA,  NA,  30,  35,  41,  NA,  NA,  57,  63,  68,  NA,  76,  NA,  80,  85,  89,  NA,  94,  NA, 104,  NA }
-};
-
 static unsigned int ASUS_ROG_STRIX_SCOPE_II_96_WIRELESS_LAYOUT_KEYS_ANSI[6][19] =
 {
     {   0,   6,  11,  17,  22,  27,  33,  39,  45,  50,  55,  61,  67,  72,  77,  80,  86,  NA,  97 },
@@ -181,28 +142,6 @@ static unsigned int ASUS_ROG_STRIX_FLARE_LAYOUT_KEYS_ISO[6][26] =
 };
 
 static unsigned int ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_ANSI[7][30] =
-{
-    {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 104, 105,  NA,  NA },
-    {   0,  NA,   8,  14,  19,  24,  NA,  34,  39,  44,  49,  55,  61,  66,  70,  NA,  NA,  NA,  NA,  74,  78,  83,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
-    {   1,   6,   9,  15,  20,  25,  29,  35,  40,  45,  50,  56,  62,  67,  NA,  NA,  NA,  NA,  NA,  75,  79,  84,  NA,  NA,  NA,  NA,  87,  92,  96, 101 },
-    {   2,  NA,  10,  16,  21,  26,  30,  36,  41,  46,  51,  57,  63,  68,  71,  NA,  NA,  NA,  NA,  76,  80,  85,  NA,  NA,  NA,  NA,  88,  93,  97, 102 },
-    {   3,  NA,  11,  17,  22,  27,  31,  37,  42,  47,  52,  58,  64,  NA,  72,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  89,  94,  98,  NA },
-    {   4,  NA,  12,  18,  23,  28,  32,  38,  43,  48,  53,  59,  NA,  69,  NA,  NA,  NA,  NA,  NA,  NA,  81,  NA,  NA,  NA,  NA,  NA,  90,  95,  99, 103 },
-    {   5,   7,  13,  NA,  NA,  NA,  33,  NA,  NA,  NA,  54,  60,  65,  NA,  73,  NA,  NA,  NA,  NA,  77,  82,  86,  NA,  NA,  NA,  NA,  91,  NA, 100,  NA },
-};
-
-static unsigned int ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_ISO[7][30] =
-{
-    {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA, 105, 106,  NA,  NA },
-    {   0,  NA,   9,  15,  20,  25,  NA,  35,  40,  45,  50,  56,  62,  67,  72,  NA,  NA,  NA,  NA,  75,  79,  84,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
-    {   1,   6,  10,  16,  21,  26,  30,  36,  41,  46,  51,  57,  63,  68,  NA,  NA,  NA,  NA,  NA,  76,  80,  85,  NA,  NA,  NA,  NA,  88,  93,  97, 102 },
-    {   2,  NA,  11,  17,  22,  27,  31,  37,  42,  47,  52,  58,  64,  69,  NA,  NA,  NA,  NA,  NA,  77,  81,  86,  NA,  NA,  NA,  NA,  89,  94,  98, 103 },
-    {   3,  NA,  12,  18,  23,  28,  32,  38,  43,  48,  53,  59,  65,  70,  73,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  90,  95,  99,  NA },
-    {   4,   7,  13,  19,  24,  29,  33,  39,  44,  49,  54,  60,  NA,  71,  NA,  NA,  NA,  NA,  NA,  NA,  82,  NA,  NA,  NA,  NA,  NA,  91,  96, 100, 104 },
-    {   5,   8,  14,  NA,  NA,  NA,  34,  NA,  NA,  NA,  55,  61,  66,  NA,  74,  NA,  NA,  NA,  NA,  78,  83,  87,  NA,  NA,  NA,  NA,  92,  NA, 101,  NA },
-};
-
-static unsigned int ASUS_ROG_STRIX_FLARE_II_ANIMATE_LAYOUT_KEYS_ANSI[7][30] =
 {
     {   0,  NA,   8,  14,  19,  24,  NA,  34,  39,  44,  49,  55,  61,  66,  70,  NA,  NA,  NA,  NA,  74,  78,  83,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
     {   1,   6,   9,  15,  20,  25,  29,  35,  40,  45,  50,  56,  62,  67,  NA,  NA,  NA,  NA,  NA,  75,  79,  84,  NA,  NA,  NA,  NA,  87,  92,  96, 101 },
@@ -213,7 +152,7 @@ static unsigned int ASUS_ROG_STRIX_FLARE_II_ANIMATE_LAYOUT_KEYS_ANSI[7][30] =
     { 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133 }
 };
 
-static unsigned int ASUS_ROG_STRIX_FLARE_II_ANIMATE_LAYOUT_KEYS_ISO[7][30] =
+static unsigned int ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_ISO[7][30] =
 {
     {   0,  NA,   9,  15,  20,  25,  NA,  35,  40,  45,  50,  56,  62,  67,  72,  NA,  NA,  NA,  NA,  75,  79,  84,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
     {   1,   6,  10,  16,  21,  26,  30,  36,  41,  46,  51,  57,  63,  68,  NA,  NA,  NA,  NA,  NA,  76,  80,  85,  NA,  NA,  NA,  NA,  88,  93,  97, 102 },
@@ -236,8 +175,8 @@ static unsigned int ASUS_FALCHION_LAYOUT_KEYS_ANSI[5][16] =
 static unsigned int ASUS_FALCHION_LAYOUT_KEYS_ISO[5][16] =
 {
     {   0,   5,   8,  13,  17,  21,  25,  30,  34,  38,  42,  47,  52,  57,  NA,  64 },
-    {   1,  NA,   9,  14,  18,  22,  26,  31,  35,  39,  43,  48,  53,  58,  NA,  65 },
-    {   2,  NA,  10,  15,  19,  23,  27,  32,  36,  40,  44,  49,  54,  59,  61,  66 },
+    {   1,  NA,   9,  14,  18,  22,  26,  31,  35,  39,  43,  48,  53,  58,  61,  65 },
+    {   2,  NA,  10,  15,  19,  23,  27,  32,  36,  40,  44,  49,  54,  59,  NA,  66 },
     {   3,   6,  11,  16,  20,  24,  28,  33,  37,  41,  45,  50,  55,  NA,  62,  67 },
     {   4,   7,  12,  NA,  NA,  NA,  29,  NA,  NA,  NA,  46,  51,  56,  60,  63,  68 }
 };
@@ -590,225 +529,6 @@ static std::map<int,layout_info> AsusTUFK7Layouts =
     },
 };
 
-static std::map<int,layout_info> AsusROGAzothLayouts =
-{
-    {
-        ASUS_TUF_K7_LAYOUT_UK,
-        {
-            *ASUS_ROG_AZOTH_LAYOUT_KEYS_UK,
-            82,
-            6,
-            16,
-            {
-                { KEY_EN_ESCAPE,              0x00 },
-                { KEY_EN_BACK_TICK,           0x01 },
-                { KEY_EN_TAB,                 0x02 },
-                { KEY_EN_CAPS_LOCK,           0x03 },
-                { KEY_EN_LEFT_SHIFT,          0x04 },
-                { KEY_EN_LEFT_CONTROL,        0x05 },
-
-                { KEY_EN_F1,                  0x08 },
-                { KEY_EN_1,                   0x09 },
-                { KEY_EN_ISO_BACK_SLASH,      0x0C },
-                { KEY_EN_LEFT_WINDOWS,        0x0D },
-
-                { KEY_EN_F2,                  0x10 },
-                { KEY_EN_2,                   0x11 },
-                { KEY_EN_Q,                   0x0A },
-                { KEY_EN_A,                   0x0B },
-                { KEY_EN_Z,                   0x14 },
-                { KEY_EN_LEFT_ALT,            0x15 },
-
-                { KEY_EN_F3,                  0x18 },
-                { KEY_EN_3,                   0x19 },
-                { KEY_EN_W,                   0x12 },
-                { KEY_EN_S,                   0x13 },
-                { KEY_EN_X,                   0x1C },
-
-                { KEY_EN_F4,                  0x20 },
-                { KEY_EN_4,                   0x21 },
-                { KEY_EN_E,                   0x1A },
-                { KEY_EN_D,                   0x1B },
-                { KEY_EN_C,                   0x24 },
-
-                { KEY_EN_F5,                  0x28 },
-                { KEY_EN_5,                   0x29 },
-                { KEY_EN_R,                   0x22 },
-                { KEY_EN_F,                   0x23 },
-                { KEY_EN_V,                   0x2C },
-
-                { KEY_EN_F6,                  0x30 },
-                { KEY_EN_6,                   0x31 },
-                { KEY_EN_T,                   0x2A },
-                { KEY_EN_G,                   0x2B },
-                { KEY_EN_B,                   0x34 },
-                { KEY_EN_SPACE,               0x35 },
-
-                { KEY_EN_F7,                  0x38 },
-                { KEY_EN_7,                   0x39 },
-                { KEY_EN_Y,                   0x32 },
-                { KEY_EN_H,                   0x33 },
-                { KEY_EN_N,                   0x3C },
-
-                { KEY_EN_F8,                  0x40 },
-                { KEY_EN_8,                   0x41 },
-                { KEY_EN_U,                   0x3A },
-                { KEY_EN_J,                   0x3B },
-                { KEY_EN_M,                   0x44 },
-
-                { KEY_EN_F9,                  0x48 },
-                { KEY_EN_9,                   0x49 },
-                { KEY_EN_I,                   0x42 },
-                { KEY_EN_K,                   0x43 },
-                { KEY_EN_COMMA,               0x4C },
-
-                { KEY_EN_F10,                 0x50 },
-                { KEY_EN_0,                   0x51 },
-                { KEY_EN_O,                   0x4A },
-                { KEY_EN_L,                   0x4B },
-                { KEY_EN_PERIOD,              0x54 },
-                { KEY_EN_RIGHT_ALT,           0x55 },
-
-                { KEY_EN_F11,                 0x58 },
-                { KEY_EN_MINUS,               0x59 },
-                { KEY_EN_P,                   0x52 },
-                { KEY_EN_SEMICOLON,           0x53 },
-                { KEY_EN_FORWARD_SLASH,       0x5C },
-                { KEY_EN_RIGHT_FUNCTION,      0x5D },
-
-                { KEY_EN_F12,                 0x60 },
-                { KEY_EN_EQUALS,              0x61 },
-                { KEY_EN_LEFT_BRACKET,        0x5A },
-                { KEY_EN_QUOTE,               0x5B },
-                { KEY_EN_RIGHT_SHIFT,         0x64 },
-                { KEY_EN_RIGHT_CONTROL,       0x65 },
-
-                { KEY_EN_BACKSPACE,           0x69 },
-                { KEY_EN_RIGHT_BRACKET,       0x62 },
-                { KEY_EN_POUND,               0x6B },
-                { KEY_EN_LEFT_ARROW,          0x6D },
-
-                { KEY_EN_ISO_ENTER,           0x6A },
-                { KEY_EN_UP_ARROW,            0x74 },
-                { KEY_EN_DOWN_ARROW,          0x75 },
-
-                { KEY_EN_INSERT,              0x79 },
-                { KEY_EN_DELETE,              0x7A },
-                { KEY_EN_PAGE_UP,             0x7B },
-                { KEY_EN_PAGE_DOWN,           0x7C },
-                { KEY_EN_RIGHT_ARROW,         0x7D },
-            }
-        }
-    },
-    {
-        ASUS_TUF_K7_LAYOUT_US,
-        {
-            *ASUS_ROG_AZOTH_LAYOUT_KEYS_US,
-            81,
-            6,
-            16,
-            {
-                { KEY_EN_ESCAPE,              0x00 },
-                { KEY_EN_BACK_TICK,           0x01 },
-                { KEY_EN_TAB,                 0x02 },
-                { KEY_EN_CAPS_LOCK,           0x03 },
-                { KEY_EN_LEFT_SHIFT,          0x04 },
-                { KEY_EN_LEFT_CONTROL,        0x05 },
-
-                { KEY_EN_F1,                  0x08 },
-                { KEY_EN_1,                   0x09 },
-                { KEY_EN_LEFT_WINDOWS,        0x0D },
-
-                { KEY_EN_F2,                  0x10 },
-                { KEY_EN_2,                   0x11 },
-                { KEY_EN_Q,                   0x0A },
-                { KEY_EN_A,                   0x0B },
-                { KEY_EN_Z,                   0x14 },
-                { KEY_EN_LEFT_ALT,            0x15 },
-
-                { KEY_EN_F3,                  0x18 },
-                { KEY_EN_3,                   0x19 },
-                { KEY_EN_W,                   0x12 },
-                { KEY_EN_S,                   0x13 },
-                { KEY_EN_X,                   0x1C },
-
-                { KEY_EN_F4,                  0x20 },
-                { KEY_EN_4,                   0x21 },
-                { KEY_EN_E,                   0x1A },
-                { KEY_EN_D,                   0x1B },
-                { KEY_EN_C,                   0x24 },
-
-                { KEY_EN_F5,                  0x28 },
-                { KEY_EN_5,                   0x29 },
-                { KEY_EN_R,                   0x22 },
-                { KEY_EN_F,                   0x23 },
-                { KEY_EN_V,                   0x2C },
-
-                { KEY_EN_F6,                  0x30 },
-                { KEY_EN_6,                   0x31 },
-                { KEY_EN_T,                   0x2A },
-                { KEY_EN_G,                   0x2B },
-                { KEY_EN_B,                   0x34 },
-                { KEY_EN_SPACE,               0x35 },
-
-                { KEY_EN_F7,                  0x38 },
-                { KEY_EN_7,                   0x39 },
-                { KEY_EN_Y,                   0x32 },
-                { KEY_EN_H,                   0x33 },
-                { KEY_EN_N,                   0x3C },
-
-                { KEY_EN_F8,                  0x40 },
-                { KEY_EN_8,                   0x41 },
-                { KEY_EN_U,                   0x3A },
-                { KEY_EN_J,                   0x3B },
-                { KEY_EN_M,                   0x44 },
-
-                { KEY_EN_F9,                  0x48 },
-                { KEY_EN_9,                   0x49 },
-                { KEY_EN_I,                   0x42 },
-                { KEY_EN_K,                   0x43 },
-                { KEY_EN_COMMA,               0x4C },
-
-                { KEY_EN_F10,                 0x50 },
-                { KEY_EN_0,                   0x51 },
-                { KEY_EN_O,                   0x4A },
-                { KEY_EN_L,                   0x4B },
-                { KEY_EN_PERIOD,              0x54 },
-                { KEY_EN_RIGHT_ALT,           0x55 },
-
-                { KEY_EN_F11,                 0x58 },
-                { KEY_EN_MINUS,               0x59 },
-                { KEY_EN_P,                   0x52 },
-                { KEY_EN_SEMICOLON,           0x53 },
-                { KEY_EN_FORWARD_SLASH,       0x5C },
-                { KEY_EN_RIGHT_FUNCTION,      0x5D },
-
-                { KEY_EN_F12,                 0x60 },
-                { KEY_EN_EQUALS,              0x61 },
-                { KEY_EN_LEFT_BRACKET,        0x5A },
-                { KEY_EN_QUOTE,               0x5B },
-                { KEY_EN_RIGHT_SHIFT,         0x64 },
-                { KEY_EN_RIGHT_CONTROL,       0x65 },
-
-                { KEY_EN_BACKSPACE,           0x69 },
-                { KEY_EN_RIGHT_BRACKET,       0x62 },
-                { KEY_EN_LEFT_ARROW,          0x6D },
-
-                { KEY_EN_ANSI_BACK_SLASH,     0x6A },
-                { KEY_EN_ANSI_ENTER,          0x6B },
-                { KEY_EN_UP_ARROW,            0x74 },
-                { KEY_EN_DOWN_ARROW,          0x75 },
-
-                { KEY_EN_INSERT,              0x79 },
-                { KEY_EN_DELETE,              0x7A },
-                { KEY_EN_PAGE_UP,             0x7B },
-                { KEY_EN_PAGE_DOWN,           0x7C },
-                { KEY_EN_RIGHT_ARROW,         0x7D },
-            }
-        }
-    },
-};
-
 static std::map<int,layout_info> AsusROGStrixScopeLayouts =
 {
     {
@@ -1092,290 +812,6 @@ static std::map<int,layout_info> AsusROGStrixScopeLayouts =
     },
 };
 
-static std::map<int,layout_info> AsusROGStrixScopeIILayouts =
-{
-    {
-        ASUS_TUF_K7_LAYOUT_UK,
-        {
-            *ASUS_ROG_STRIX_SCOPE_II_LAYOUT_KEYS_ISO,
-            108,
-            6,
-            24,
-            {
-                { KEY_EN_ESCAPE,              0x00 },
-                { KEY_EN_BACK_TICK,           0x01 },
-                { KEY_EN_TAB,                 0x02 },
-                { KEY_EN_CAPS_LOCK,           0x03 },
-                { KEY_EN_LEFT_SHIFT,          0x04 },
-                { KEY_EN_LEFT_CONTROL,        0x05 },
-
-                { KEY_EN_1,                   0x11 },
-                { KEY_EN_ISO_BACK_SLASH,      0x0C },
-                { KEY_EN_LEFT_WINDOWS,        0x0D },
-
-                { KEY_EN_F1,                  0x18 },
-                { KEY_EN_2,                   0x19 },
-                { KEY_EN_Q,                   0x12 },
-                { KEY_EN_A,                   0x13 },
-                { KEY_EN_Z,                   0x14 },
-                { KEY_EN_LEFT_ALT,            0x15 },
-
-                { KEY_EN_F2,                  0x20 },
-                { KEY_EN_3,                   0x21 },
-                { KEY_EN_W,                   0x1A },
-                { KEY_EN_S,                   0x1B },
-                { KEY_EN_X,                   0x1C },
-
-                { KEY_EN_F3,                  0x28 },
-                { KEY_EN_4,                   0x29 },
-                { KEY_EN_E,                   0x22 },
-                { KEY_EN_D,                   0x23 },
-                { KEY_EN_C,                   0x24 },
-
-                { KEY_EN_F4,                  0x30 },
-                { KEY_EN_5,                   0x31 },
-                { KEY_EN_R,                   0x2A },
-                { KEY_EN_F,                   0x2B },
-                { KEY_EN_V,                   0x2C },
-                { KEY_EN_SPACE,               0x2D },
-
-                { KEY_EN_6,                   0x39 },
-                { KEY_EN_T,                   0x32 },
-                { KEY_EN_G,                   0x33 },
-                { KEY_EN_B,                   0x34 },
-                { KEY_EN_SPACE,               0x35 },
-
-                { KEY_EN_F5,                  0x40 },
-                { KEY_EN_7,                   0x41 },
-                { KEY_EN_Y,                   0x3A },
-                { KEY_EN_H,                   0x3B },
-                { KEY_EN_N,                   0x3C },
-                { KEY_EN_SPACE,               0x3D },
-
-                { KEY_EN_F6,                  0x48 },
-                { KEY_EN_8,                   0x49 },
-                { KEY_EN_U,                   0x42 },
-                { KEY_EN_J,                   0x43 },
-                { KEY_EN_M,                   0x44 },
-
-                { KEY_EN_F7,                  0x50 },
-                { KEY_EN_9,                   0x51 },
-                { KEY_EN_I,                   0x4A },
-                { KEY_EN_K,                   0x4B },
-                { KEY_EN_COMMA,               0x4C },
-
-                { KEY_EN_F8,                  0x58 },
-                { KEY_EN_0,                   0x59 },
-                { KEY_EN_O,                   0x52 },
-                { KEY_EN_L,                   0x53 },
-                { KEY_EN_PERIOD,              0x54 },
-                { KEY_EN_RIGHT_ALT,           0x4D },
-
-                { KEY_EN_F9,                  0x60 },
-                { KEY_EN_MINUS,               0x61 },
-                { KEY_EN_P,                   0x5A },
-                { KEY_EN_SEMICOLON,           0x5B },
-                { KEY_EN_FORWARD_SLASH,       0x5C },
-                { KEY_EN_RIGHT_FUNCTION,      0x5D },
-
-                { KEY_EN_F10,                 0x68 },
-                { KEY_EN_EQUALS,              0x69 },
-                { KEY_EN_LEFT_BRACKET,        0x62 },
-                { KEY_EN_QUOTE,               0x63 },
-                { KEY_EN_MENU,                0x65 },
-
-                { KEY_EN_F11,                 0x70 },
-                { KEY_EN_BACKSPACE,           0x79 },
-                { KEY_EN_RIGHT_BRACKET,       0x6A },
-                { KEY_EN_POUND,               0x6B },
-                { KEY_EN_RIGHT_SHIFT,         0x7C },
-
-                { KEY_EN_F12,                 0x78 },
-                { KEY_EN_ISO_ENTER,           0x7B },
-                { KEY_EN_RIGHT_CONTROL,       0x7D },
-
-                { KEY_EN_PRINT_SCREEN,        0x80 },
-                { KEY_EN_INSERT,              0x81 },
-                { KEY_EN_DELETE,              0x82 },
-                { KEY_EN_LEFT_ARROW,          0x85 },
-
-                { KEY_EN_SCROLL_LOCK,         0x88 },
-                { KEY_EN_HOME,                0x89 },
-                { KEY_EN_END,                 0x8A },
-                { KEY_EN_UP_ARROW,            0x8C },
-                { KEY_EN_DOWN_ARROW,          0x8D },
-
-                { KEY_EN_PAUSE_BREAK,         0x90 },
-                { KEY_EN_PAGE_UP,             0x91 },
-                { KEY_EN_PAGE_DOWN,           0x92 },
-                { KEY_EN_RIGHT_ARROW,         0x95 },
-
-                { KEY_EN_NUMPAD_LOCK,         0x99 },
-                { KEY_EN_NUMPAD_7,            0x9A },
-                { KEY_EN_NUMPAD_4,            0x9B },
-                { KEY_EN_NUMPAD_1,            0x9C },
-                { KEY_EN_NUMPAD_0,            0x9D },
-
-                { "Logo",                     0xA0 },
-                { KEY_EN_NUMPAD_DIVIDE,       0xA1 },
-                { KEY_EN_NUMPAD_8,            0xA2 },
-                { KEY_EN_NUMPAD_5,            0xA3 },
-                { KEY_EN_NUMPAD_2,            0xA4 },
-
-                { KEY_EN_NUMPAD_TIMES,        0xA9 },
-                { KEY_EN_NUMPAD_9,            0xAA },
-                { KEY_EN_NUMPAD_6,            0xAB },
-                { KEY_EN_NUMPAD_3,            0xAC },
-                { KEY_EN_NUMPAD_PERIOD,       0xAD },
-
-                { KEY_EN_NUMPAD_MINUS,        0xB1 },
-                { KEY_EN_NUMPAD_PLUS,         0xB2 },
-                { KEY_EN_NUMPAD_ENTER,        0xB4 },
-
-            }
-        }
-    },
-    {
-        ASUS_TUF_K7_LAYOUT_US,
-        {
-            *ASUS_ROG_STRIX_SCOPE_II_LAYOUT_KEYS_ANSI,
-            107,
-            6,
-            24,
-            {
-                { KEY_EN_ESCAPE,              0x00 },
-                { KEY_EN_BACK_TICK,           0x01 },
-                { KEY_EN_TAB,                 0x02 },
-                { KEY_EN_CAPS_LOCK,           0x03 },
-                { KEY_EN_LEFT_SHIFT,          0x04 },
-                { KEY_EN_LEFT_CONTROL,        0x05 },
-
-                { KEY_EN_1,                   0x11 },
-                { KEY_EN_LEFT_WINDOWS,        0x0D },
-
-                { KEY_EN_F1,                  0x18 },
-                { KEY_EN_2,                   0x19 },
-                { KEY_EN_Q,                   0x12 },
-                { KEY_EN_A,                   0x13 },
-                { KEY_EN_Z,                   0x14 },
-                { KEY_EN_LEFT_ALT,            0x15 },
-
-                { KEY_EN_F2,                  0x20 },
-                { KEY_EN_3,                   0x21 },
-                { KEY_EN_W,                   0x1A },
-                { KEY_EN_S,                   0x1B },
-                { KEY_EN_X,                   0x1C },
-
-                { KEY_EN_F3,                  0x28 },
-                { KEY_EN_4,                   0x29 },
-                { KEY_EN_E,                   0x22 },
-                { KEY_EN_D,                   0x23 },
-                { KEY_EN_C,                   0x24 },
-
-                { KEY_EN_F4,                  0x30 },
-                { KEY_EN_5,                   0x31 },
-                { KEY_EN_R,                   0x2A },
-                { KEY_EN_F,                   0x2B },
-                { KEY_EN_V,                   0x2C },
-                { KEY_EN_SPACE,               0x2D },
-
-                { KEY_EN_6,                   0x39 },
-                { KEY_EN_T,                   0x32 },
-                { KEY_EN_G,                   0x33 },
-                { KEY_EN_B,                   0x34 },
-                { KEY_EN_SPACE,               0x35 },
-
-                { KEY_EN_F5,                  0x40 },
-                { KEY_EN_7,                   0x41 },
-                { KEY_EN_Y,                   0x3A },
-                { KEY_EN_H,                   0x3B },
-                { KEY_EN_N,                   0x3C },
-                { KEY_EN_SPACE,               0x3D },
-
-                { KEY_EN_F6,                  0x48 },
-                { KEY_EN_8,                   0x49 },
-                { KEY_EN_U,                   0x42 },
-                { KEY_EN_J,                   0x43 },
-                { KEY_EN_M,                   0x44 },
-
-                { KEY_EN_F7,                  0x50 },
-                { KEY_EN_9,                   0x51 },
-                { KEY_EN_I,                   0x4A },
-                { KEY_EN_K,                   0x4B },
-                { KEY_EN_COMMA,               0x4C },
-
-                { KEY_EN_F8,                  0x58 },
-                { KEY_EN_0,                   0x59 },
-                { KEY_EN_O,                   0x52 },
-                { KEY_EN_L,                   0x53 },
-                { KEY_EN_PERIOD,              0x54 },
-                { KEY_EN_RIGHT_ALT,           0x4D },
-
-                { KEY_EN_F9,                  0x60 },
-                { KEY_EN_MINUS,               0x61 },
-                { KEY_EN_P,                   0x5A },
-                { KEY_EN_SEMICOLON,           0x5B },
-                { KEY_EN_FORWARD_SLASH,       0x5C },
-                { KEY_EN_RIGHT_FUNCTION,      0x5D },
-
-                { KEY_EN_F10,                 0x68 },
-                { KEY_EN_EQUALS,              0x69 },
-                { KEY_EN_LEFT_BRACKET,        0x62 },
-                { KEY_EN_QUOTE,               0x63 },
-                { KEY_EN_MENU,                0x65 },
-
-                { KEY_EN_F11,                 0x70 },
-                { KEY_EN_BACKSPACE,           0x79 },
-                { KEY_EN_RIGHT_BRACKET,       0x6A },
-                { KEY_EN_RIGHT_SHIFT,         0x7C },
-
-                { KEY_EN_F12,                 0x78 },
-                { KEY_EN_ANSI_BACK_SLASH,     0x7A },
-                { KEY_EN_ANSI_ENTER,          0x7B },
-                { KEY_EN_RIGHT_CONTROL,       0x7D },
-
-                { KEY_EN_PRINT_SCREEN,        0x80 },
-                { KEY_EN_INSERT,              0x81 },
-                { KEY_EN_DELETE,              0x82 },
-                { KEY_EN_LEFT_ARROW,          0x85 },
-
-                { KEY_EN_SCROLL_LOCK,         0x88 },
-                { KEY_EN_HOME,                0x89 },
-                { KEY_EN_END,                 0x8A },
-                { KEY_EN_UP_ARROW,            0x8C },
-                { KEY_EN_DOWN_ARROW,          0x8D },
-
-                { KEY_EN_PAUSE_BREAK,         0x90 },
-                { KEY_EN_PAGE_UP,             0x91 },
-                { KEY_EN_PAGE_DOWN,           0x92 },
-                { KEY_EN_RIGHT_ARROW,         0x95 },
-
-                { KEY_EN_NUMPAD_LOCK,         0x99 },
-                { KEY_EN_NUMPAD_7,            0x9A },
-                { KEY_EN_NUMPAD_4,            0x9B },
-                { KEY_EN_NUMPAD_1,            0x9C },
-                { KEY_EN_NUMPAD_0,            0x9D },
-
-                { "Logo",                     0xA0 },
-                { KEY_EN_NUMPAD_DIVIDE,       0xA1 },
-                { KEY_EN_NUMPAD_8,            0xA2 },
-                { KEY_EN_NUMPAD_5,            0xA3 },
-                { KEY_EN_NUMPAD_2,            0xA4 },
-
-                { KEY_EN_NUMPAD_TIMES,        0xA9 },
-                { KEY_EN_NUMPAD_9,            0xAA },
-                { KEY_EN_NUMPAD_6,            0xAB },
-                { KEY_EN_NUMPAD_3,            0xAC },
-                { KEY_EN_NUMPAD_PERIOD,       0xAD },
-
-                { KEY_EN_NUMPAD_MINUS,        0xB1 },
-                { KEY_EN_NUMPAD_PLUS,         0xB2 },
-                { KEY_EN_NUMPAD_ENTER,        0xB4 },
-            }
-        }
-    },
-};
-
 static std::map<int,layout_info> AsusROGStrixScopeII96WirelessLayouts =
 {
     {
@@ -2063,289 +1499,6 @@ static std::map<int,layout_info> AsusROGStrixFlareIILayouts =
         ASUS_TUF_K7_LAYOUT_UK,
         {
             *ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_ISO,
-            107,
-            7,
-            30,
-            {
-                { KEY_EN_ESCAPE,              0x00 },
-                { KEY_EN_BACK_TICK,           0x01 },
-                { KEY_EN_TAB,                 0x02 },
-                { KEY_EN_CAPS_LOCK,           0x03 },
-                { KEY_EN_LEFT_SHIFT,          0x04 },
-                { KEY_EN_LEFT_CONTROL,        0x05 },
-
-                { KEY_EN_1,                   0x11 },
-                { KEY_EN_ISO_BACK_SLASH,      0x0C },
-                { KEY_EN_LEFT_WINDOWS,        0x15 },
-
-                { KEY_EN_F1,                  0x18 },
-                { KEY_EN_2,                   0x19 },
-                { KEY_EN_Q,                   0x12 },
-                { KEY_EN_A,                   0x13 },
-                { KEY_EN_Z,                   0x14 },
-                { KEY_EN_LEFT_ALT,            0x1D },
-
-                { KEY_EN_F2,                  0x20 },
-                { KEY_EN_3,                   0x21 },
-                { KEY_EN_W,                   0x1A },
-                { KEY_EN_S,                   0x1B },
-                { KEY_EN_X,                   0x1C },
-
-                { KEY_EN_F3,                  0x28 },
-                { KEY_EN_4,                   0x29 },
-                { KEY_EN_E,                   0x22 },
-                { KEY_EN_D,                   0x23 },
-                { KEY_EN_C,                   0x24 },
-
-                { KEY_EN_F4,                  0x30 },
-                { KEY_EN_5,                   0x31 },
-                { KEY_EN_R,                   0x2A },
-                { KEY_EN_F,                   0x2B },
-                { KEY_EN_V,                   0x2C },
-
-                { KEY_EN_6,                   0x39 },
-                { KEY_EN_T,                   0x32 },
-                { KEY_EN_G,                   0x33 },
-                { KEY_EN_B,                   0x34 },
-                { KEY_EN_SPACE,               0x35 },
-
-                { KEY_EN_F5,                  0x40 },
-                { KEY_EN_7,                   0x41 },
-                { KEY_EN_Y,                   0x3A },
-                { KEY_EN_H,                   0x3B },
-                { KEY_EN_N,                   0x3C },
-
-                { KEY_EN_F6,                  0x48 },
-                { KEY_EN_8,                   0x49 },
-                { KEY_EN_U,                   0x42 },
-                { KEY_EN_J,                   0x43 },
-                { KEY_EN_M,                   0x44 },
-
-                { KEY_EN_F7,                  0x50 },
-                { KEY_EN_9,                   0x51 },
-                { KEY_EN_I,                   0x4A },
-                { KEY_EN_K,                   0x4B },
-                { KEY_EN_COMMA,               0x4C },
-
-                { KEY_EN_F8,                  0x58 },
-                { KEY_EN_0,                   0x59 },
-                { KEY_EN_O,                   0x52 },
-                { KEY_EN_L,                   0x53 },
-                { KEY_EN_PERIOD,              0x54 },
-                { KEY_EN_RIGHT_ALT,           0x4D },
-
-                { KEY_EN_F9,                  0x60 },
-                { KEY_EN_MINUS,               0x61 },
-                { KEY_EN_P,                   0x5A },
-                { KEY_EN_SEMICOLON,           0x5B },
-                { KEY_EN_FORWARD_SLASH,       0x5C },
-                { KEY_EN_RIGHT_FUNCTION,      0x5D },
-
-                { KEY_EN_F10,                 0x68 },
-                { KEY_EN_EQUALS,              0x69 },
-                { KEY_EN_LEFT_BRACKET,        0x62 },
-                { KEY_EN_QUOTE,               0x63 },
-                { KEY_EN_MENU,                0x65 },
-
-                { KEY_EN_F11,                 0x70 },
-                { KEY_EN_BACKSPACE,           0x79 },
-                { KEY_EN_RIGHT_BRACKET,       0x6A },
-                { KEY_EN_POUND,               0x6B },
-                { KEY_EN_RIGHT_SHIFT,         0x7C },
-
-                { KEY_EN_F12,                 0x78 },
-                { KEY_EN_ISO_ENTER,           0x7B },
-                { KEY_EN_RIGHT_CONTROL,       0x7D },
-
-                { KEY_EN_PRINT_SCREEN,        0x80 },
-                { KEY_EN_INSERT,              0x81 },
-                { KEY_EN_DELETE,              0x82 },
-                { KEY_EN_LEFT_ARROW,          0x85 },
-
-                { KEY_EN_SCROLL_LOCK,         0x88 },
-                { KEY_EN_HOME,                0x89 },
-                { KEY_EN_END,                 0x8A },
-                { KEY_EN_UP_ARROW,            0x8C },
-                { KEY_EN_DOWN_ARROW,          0x8D },
-
-                { KEY_EN_PAUSE_BREAK,         0x90 },
-                { KEY_EN_PAGE_UP,             0x91 },
-                { KEY_EN_PAGE_DOWN,           0x92 },
-                { KEY_EN_RIGHT_ARROW,         0x95 },
-
-                { KEY_EN_NUMPAD_LOCK,         0x99 },
-                { KEY_EN_NUMPAD_7,            0x9A },
-                { KEY_EN_NUMPAD_4,            0x9B },
-                { KEY_EN_NUMPAD_1,            0x9C },
-                { KEY_EN_NUMPAD_0,            0x9D },
-
-                { KEY_EN_NUMPAD_DIVIDE,       0xA1 },
-                { KEY_EN_NUMPAD_8,            0xA2 },
-                { KEY_EN_NUMPAD_5,            0xA3 },
-                { KEY_EN_NUMPAD_2,            0xA4 },
-
-                { KEY_EN_NUMPAD_TIMES,        0xA9 },
-                { KEY_EN_NUMPAD_9,            0xAA },
-                { KEY_EN_NUMPAD_6,            0xAB },
-                { KEY_EN_NUMPAD_3,            0xAC },
-                { KEY_EN_NUMPAD_PERIOD,       0xAD },
-
-                { KEY_EN_NUMPAD_MINUS,        0xB1 },
-                { KEY_EN_NUMPAD_PLUS,         0xB2 },
-                { KEY_EN_NUMPAD_ENTER,        0xB4 },
-
-                { "Logo 1",                    0xB0 },
-                { "Logo 2",                    0xA8 },
-            }
-        }
-    },
-    {
-        ASUS_TUF_K7_LAYOUT_US,
-        {
-            *ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_ANSI,
-            106,
-            7,
-            30,
-            {
-                { KEY_EN_ESCAPE,              0x00 },
-                { KEY_EN_BACK_TICK,           0x01 },
-                { KEY_EN_TAB,                 0x02 },
-                { KEY_EN_CAPS_LOCK,           0x03 },
-                { KEY_EN_LEFT_SHIFT,          0x04 },
-                { KEY_EN_LEFT_CONTROL,        0x05 },
-
-                { KEY_EN_1,                   0x11 },
-                { KEY_EN_LEFT_WINDOWS,        0x15 },
-
-                { KEY_EN_F1,                  0x18 },
-                { KEY_EN_2,                   0x19 },
-                { KEY_EN_Q,                   0x12 },
-                { KEY_EN_A,                   0x13 },
-                { KEY_EN_Z,                   0x14 },
-                { KEY_EN_LEFT_ALT,            0x1D },
-
-                { KEY_EN_F2,                  0x20 },
-                { KEY_EN_3,                   0x21 },
-                { KEY_EN_W,                   0x1A },
-                { KEY_EN_S,                   0x1B },
-                { KEY_EN_X,                   0x1C },
-
-                { KEY_EN_F3,                  0x28 },
-                { KEY_EN_4,                   0x29 },
-                { KEY_EN_E,                   0x22 },
-                { KEY_EN_D,                   0x23 },
-                { KEY_EN_C,                   0x24 },
-
-                { KEY_EN_F4,                  0x30 },
-                { KEY_EN_5,                   0x31 },
-                { KEY_EN_R,                   0x2A },
-                { KEY_EN_F,                   0x2B },
-                { KEY_EN_V,                   0x2C },
-
-                { KEY_EN_6,                   0x39 },
-                { KEY_EN_T,                   0x32 },
-                { KEY_EN_G,                   0x33 },
-                { KEY_EN_B,                   0x34 },
-                { KEY_EN_SPACE,               0x35 },
-
-                { KEY_EN_F5,                  0x40 },
-                { KEY_EN_7,                   0x41 },
-                { KEY_EN_Y,                   0x3A },
-                { KEY_EN_H,                   0x3B },
-                { KEY_EN_N,                   0x3C },
-
-                { KEY_EN_F6,                  0x48 },
-                { KEY_EN_8,                   0x49 },
-                { KEY_EN_U,                   0x42 },
-                { KEY_EN_J,                   0x43 },
-                { KEY_EN_M,                   0x44 },
-
-                { KEY_EN_F7,                  0x50 },
-                { KEY_EN_9,                   0x51 },
-                { KEY_EN_I,                   0x4A },
-                { KEY_EN_K,                   0x4B },
-                { KEY_EN_COMMA,               0x4C },
-
-                { KEY_EN_F8,                  0x58 },
-                { KEY_EN_0,                   0x59 },
-                { KEY_EN_O,                   0x52 },
-                { KEY_EN_L,                   0x53 },
-                { KEY_EN_PERIOD,              0x54 },
-                { KEY_EN_RIGHT_ALT,           0x4D },
-
-                { KEY_EN_F9,                  0x60 },
-                { KEY_EN_MINUS,               0x61 },
-                { KEY_EN_P,                   0x5A },
-                { KEY_EN_SEMICOLON,           0x5B },
-                { KEY_EN_FORWARD_SLASH,       0x5C },
-                { KEY_EN_RIGHT_FUNCTION,      0x5D },
-
-                { KEY_EN_F10,                 0x68 },
-                { KEY_EN_EQUALS,              0x69 },
-                { KEY_EN_LEFT_BRACKET,        0x62 },
-                { KEY_EN_QUOTE,               0x63 },
-                { KEY_EN_MENU,                0x65 },
-
-                { KEY_EN_F11,                 0x70 },
-                { KEY_EN_BACKSPACE,           0x79 },
-                { KEY_EN_RIGHT_BRACKET,       0x6A },
-                { KEY_EN_RIGHT_SHIFT,         0x7C },
-
-                { KEY_EN_F12,                 0x78 },
-                { KEY_EN_ANSI_BACK_SLASH,     0x7A },
-                { KEY_EN_ANSI_ENTER,          0x7B },
-                { KEY_EN_RIGHT_CONTROL,       0x7D },
-
-                { KEY_EN_PRINT_SCREEN,        0x80 },
-                { KEY_EN_INSERT,              0x81 },
-                { KEY_EN_DELETE,              0x82 },
-                { KEY_EN_LEFT_ARROW,          0x85 },
-
-                { KEY_EN_SCROLL_LOCK,         0x88 },
-                { KEY_EN_HOME,                0x89 },
-                { KEY_EN_END,                 0x8A },
-                { KEY_EN_UP_ARROW,            0x8C },
-                { KEY_EN_DOWN_ARROW,          0x8D },
-
-                { KEY_EN_PAUSE_BREAK,         0x90 },
-                { KEY_EN_PAGE_UP,             0x91 },
-                { KEY_EN_PAGE_DOWN,           0x92 },
-                { KEY_EN_RIGHT_ARROW,         0x95 },
-
-                { KEY_EN_NUMPAD_LOCK,         0x99 },
-                { KEY_EN_NUMPAD_7,            0x9A },
-                { KEY_EN_NUMPAD_4,            0x9B },
-                { KEY_EN_NUMPAD_1,            0x9C },
-                { KEY_EN_NUMPAD_0,            0x9D },
-
-                { KEY_EN_NUMPAD_DIVIDE,       0xA1 },
-                { KEY_EN_NUMPAD_8,            0xA2 },
-                { KEY_EN_NUMPAD_5,            0xA3 },
-                { KEY_EN_NUMPAD_2,            0xA4 },
-
-                { KEY_EN_NUMPAD_TIMES,        0xA9 },
-                { KEY_EN_NUMPAD_9,            0xAA },
-                { KEY_EN_NUMPAD_6,            0xAB },
-                { KEY_EN_NUMPAD_3,            0xAC },
-                { KEY_EN_NUMPAD_PERIOD,       0xAD },
-
-                { KEY_EN_NUMPAD_MINUS,        0xB1 },
-                { KEY_EN_NUMPAD_PLUS,         0xB2 },
-                { KEY_EN_NUMPAD_ENTER,        0xB4 },
-
-                { "Logo 1",                    0xB0 },
-                { "Logo 2",                    0xA8 },
-            }
-        }
-    },
-};
-
-static std::map<int,layout_info> AsusROGStrixFlareIIAnimateLayouts =
-{
-    {
-        ASUS_TUF_K7_LAYOUT_UK,
-        {
-            *ASUS_ROG_STRIX_FLARE_II_ANIMATE_LAYOUT_KEYS_ISO,
             135,
             7,
             30,
@@ -2513,7 +1666,7 @@ static std::map<int,layout_info> AsusROGStrixFlareIIAnimateLayouts =
     {
         ASUS_TUF_K7_LAYOUT_US,
         {
-            *ASUS_ROG_STRIX_FLARE_II_ANIMATE_LAYOUT_KEYS_ANSI,
+            *ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_ANSI,
             134,
             7,
             30,

Controllers/AsusAuraUSBController/AsusAuraUSBController.cpp

@@ -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);
 }

Controllers/AsusAuraUSBController/AsusAuraUSBController.h

@@ -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];

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -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"
@@ -20,8 +20,7 @@
 #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>
@@ -44,38 +43,29 @@
 /*-----------------------------------------------------------------*\
 |  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_FLARE_II_ANIMATE_PID           0x19FC
+#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_STRIX_SCOPE_II_96_WIRELESS_USB_PID   0x1AAE
+#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
 
 /*-----------------------------------------------------------------*\
 | MOUSEMATS                                                         |
@@ -91,7 +81,6 @@
 #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
 
 /*-----------------------------------------------------------------*\
@@ -252,21 +241,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 +314,64 @@ 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 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 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 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 II Animate",             DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_II_ANIMATE_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 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 TUF Gaming K7",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_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);
 
 /*-----------------------------------------------------------------*\
 |  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 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 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 +386,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);
 
 /*-----------------------------------------------------------------*\

Controllers/AsusAuraUSBController/AsusROGAllyController.cpp

@@ -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
     )
 {

Controllers/AsusAuraUSBController/AsusROGAllyController.h

@@ -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
             );
 

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp

@@ -45,16 +45,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 +52,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 +201,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 +214,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 +223,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();

Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.cpp

@@ -17,7 +17,7 @@
     @save :white_check_mark:
     @direct :white_check_mark:
     @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBRyuoAIO
+    @detectors DetectAsusAuraUSBMousemats
     @category Cooler
     @comment
 \*-------------------------------------------------------------------*/

Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp

@@ -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();
 }

Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h

@@ -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;
+};

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -58,18 +58,11 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
                 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_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;
@@ -417,26 +410,13 @@ void RGBController_AuraTUFKeyboard::SetupZones()
             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;
+            keyboard_ptr = &AsusROGStrixFlareIILayouts;
             break;
         case AURA_ROG_FALCHION_WIRED_PID:
         case AURA_ROG_FALCHION_WIRELESS_PID:

Controllers/AsusAuraUSBController/RGBController_AsusROGAlly.cpp

@@ -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);
     }
 }
 

Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.cpp

@@ -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();
-}

Controllers/AsusAuraUSBController/RGBController_AsusROGSpatha.h

@@ -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;
-};

Controllers/AsusAuraUSBController/RGBController_AsusROGStrixEvolve.h

@@ -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;
-};

Controllers/AsusTUFLaptopController/AsusTUFLaptopController.cpp

@@ -1,6 +1,6 @@
 #ifdef _WIN32
 
-#include "AsusTUFLaptopController_Windows.h"
+#include "AsusTUFLaptopController.h"
 
 #include <Objbase.h>
 #include <setupapi.h>

Controllers/AsusTUFLaptopController/AsusTUFLaptopLinuxController.cpp

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

Controllers/AsusTUFLaptopController/AsusTUFLaptopLinuxDetect.cpp

@@ -1,4 +1,5 @@
-#include "RGBController_AsusTUFLaptop_Linux.h"
+#include "RGBController_AsusTUFLaptopLinux.h"
+#include "AsusTUFLaptopLinuxController.h"
 
 #include <string>
 #include "Detector.h"

Controllers/AsusTUFLaptopController/AsusTUFLaptopWMIDetect.cpp

@@ -1,6 +1,7 @@
 #ifdef _WIN32
 
-#include "RGBController_AsusTUFLaptop_Windows.h"
+#include "AsusTUFLaptopController.h"
+#include "RGBController_AsusTUFLaptopWMI.h"
 
 #include "Detector.h"
 #include "wmi.h"

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopLinux.cpp

@@ -1,4 +1,4 @@
-#include "RGBController_AsusTUFLaptop_Linux.h"
+#include "RGBController_AsusTUFLaptopLinux.h"
 
 /**------------------------------------------------------------------*\
     @name Asus TUF Laptop Linux WMI

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopLinux.h

@@ -2,7 +2,7 @@
 #define RGBCONTROLLER_ASUSTUFLAPTOPLINUX_H
 
 #include "RGBController.h"
-#include "AsusTUFLaptopController_Linux.h"
+#include "AsusTUFLaptopLinuxController.h"
 
 
 class RGBController_AsusTUFLaptopLinux : public RGBController

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.cpp

@@ -1,6 +1,6 @@
 #ifdef _WIN32
 
-#include "RGBController_AsusTUFLaptop_Windows.h"
+#include "RGBController_AsusTUFLaptopWMI.h"
 
 using namespace std::chrono_literals;
 

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.h

@@ -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

Controllers/CherryKeyboardController/CherryKeyboardController.cpp

@@ -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                                      |

Controllers/CherryKeyboardController/CherryKeyboardController.h

@@ -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     */

Controllers/CherryKeyboardController/CherryKeyboardControllerDetect.cpp

@@ -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);

Controllers/CherryKeyboardController/RGBController_CherryKeyboard.cpp

@@ -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;
-    }
-}

Controllers/CherryKeyboardController/RGBController_CherryKeyboard.h

@@ -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);
 };

Controllers/ColorfulGPUController/ColorfulGPUController.cpp

@@ -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);
 }

Controllers/ColorfulGPUController/ColorfulGPUController.h

@@ -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
 {

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -40,26 +40,20 @@ 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 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 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);
+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);

Controllers/CoolerMasterController/CMKeyboardAbstractController.cpp

@@ -1,203 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  CMKeyboardAbstractController.h                                     |
-|                                                                     |
-|  Abstract driver for Coolermaster keyboards                         |
-|                                                                     |
-|  Tam D (too.manyhobbies)      30th Nov 2023                         |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-#include "CMKeyboardAbstractController.h"
-
-CMKeyboardAbstractController::CMKeyboardAbstractController(hid_device* dev_handle, hid_device_info* dev_info)
-{
-    wchar_t tmp[HID_MAX_STR];
-
-    m_pDev                   = dev_handle;
-    m_productId              = dev_info->product_id;
-    m_sLocation              = dev_info->path;
-
-    hid_get_manufacturer_string(m_pDev, tmp, HID_MAX_STR);
-    std::wstring wVendorName = std::wstring(tmp);
-    m_vendorName             = std::string(wVendorName.begin(), wVendorName.end());
-
-    hid_get_product_string(m_pDev, tmp, HID_MAX_STR);
-    std::wstring wDeviceName = std::wstring(tmp);
-    m_deviceName             = std::string(wDeviceName.begin(), wDeviceName.end());
-    m_serialNumber           = m_deviceName;
-
-    bool bNotFound           = true;
-
-    for(uint16_t i = 0; i < COOLERMASTER_KEYBOARD_DEVICE_COUNT; i++)
-    {
-        if(cm_kb_device_list[i]->product_id == m_productId)
-        {
-            bNotFound = false;
-            m_deviceIndex = i;
-            break;
-        }
-    }
-
-    if(bNotFound)
-    {
-        LOG_ERROR("[%s] device capabilities not found. Please creata a new device request.",
-                m_deviceName.c_str());
-    }
-};
-
-CMKeyboardAbstractController::~CMKeyboardAbstractController()
-{
-    if(m_pDev)
-    {
-        hid_close(m_pDev);
-    }
-};
-
-std::string CMKeyboardAbstractController::GetDeviceName()
-{
-    return m_deviceName;
-}
-
-void CMKeyboardAbstractController::SetDeviceName(std::string name)
-{
-    m_deviceName = name;
-}
-
-std::string CMKeyboardAbstractController::GetDeviceVendor()
-{
-    return m_vendorName;
-}
-
-std::string CMKeyboardAbstractController::GetDeviceSerial()
-{
-    return m_serialNumber;
-}
-
-const cm_kb_device* CMKeyboardAbstractController::GetDeviceData()
-{
-    return cm_kb_device_list[m_deviceIndex];
-}
-
-std::string CMKeyboardAbstractController::GetLocation()
-{
-    return m_sLocation;
-}
-
-std::string CMKeyboardAbstractController::GetFirmwareVersion()
-{
-    return m_sFirmwareVersion;
-}
-
-int CMKeyboardAbstractController::GetProductID()
-{
-    return m_productId;
-}
-
-std::vector<uint8_t> CMKeyboardAbstractController::SendCommand(std::vector<uint8_t> buf, uint8_t fill)
-{
-    int status;
-    std::vector<uint8_t> read;
-
-    uint8_t data[CM_KEYBOARD_WRITE_SIZE];
-    memset(data, fill, CM_KEYBOARD_WRITE_SIZE);
-
-    size_t i = 1;
-    for(uint8_t b : buf)
-    {
-        data[i++] = b;
-    }
-
-    std::lock_guard<std::mutex> guard(m_mutexSendCommand);
-    status = hid_write(m_pDev, data, CM_KEYBOARD_WRITE_SIZE);
-
-    if(status < 0)
-    {
-        LOG_ERROR("[%s] SendCommand() failed code %d.", m_deviceName.c_str(), status);
-        return read;
-    }
-
-    memset(data, 0, CM_KEYBOARD_WRITE_SIZE);
-    status = hid_read(m_pDev, data, CM_KEYBOARD_WRITE_SIZE);
-
-    if(status < 0)
-    {
-        LOG_ERROR("[%s] SendCommand() failed code %d.", m_deviceName.c_str(), status);
-        return read;
-    }
-
-    for(i = 0; i < (size_t)status; i++)
-    {
-        read.push_back(data[i]);
-    }
-
-    return read;
-}
-
-/*---------------------------------------------------------*\
-| Enter/leave direct control mode                           |
-\*---------------------------------------------------------*/
-void CMKeyboardAbstractController::SetControlMode(uint8_t modeId)
-{
-    SendCommand({0x41, (uint8_t)modeId});
-};
-
-/*---------------------------------------------------------*\
-| Sets the currently active profile.                        |
-| byte[0] = 0x51 0x00 0x00 0x00                             |
-| byte[4] = profileId                                       |
-| - corresponds to saved keyboard profile i.e. [1-4]        |
-| - 0x05 - Used on MK and CK style keyboards?               |
-\*---------------------------------------------------------*/
-void CMKeyboardAbstractController::SetActiveProfile(uint8_t profileId)
-{
-    SendCommand({0x51, 0x00, 0x00, 0x00, profileId});
-};
-
-uint8_t CMKeyboardAbstractController::GetActiveProfile()
-{
-    std::vector<uint8_t> data = SendCommand({0x52, 0x00});
-
-    if(data.size() > 4)
-    {
-        return (int)data[4];
-    }
-
-    return 0xFF; // error
-}
-
-/*---------------------------------------------------------*\
-| Saves changes in currently used profile.                  |
-| byte[1] = 0x52                                            |
-\*---------------------------------------------------------*/
-void CMKeyboardAbstractController::SaveActiveProfile()
-{
-    SendCommand({0x50, 0x55});
-}
-
-void CMKeyboardAbstractController::SetActiveEffect(uint8_t effectId)
-{
-    SendCommand({0x51, 0x28, 0x00, 0x00, effectId});
-};
-
-void CMKeyboardAbstractController::SaveProfile()
-{
-    SendCommand({0x50, 0x55});
-}
-
-
-uint8_t CMKeyboardAbstractController::GetModeStatus()
-{
-    std::vector<uint8_t> data = SendCommand({0x52, 0x28});
-    return data[4];
-};
-
-std::string CMKeyboardAbstractController::GetHexString(std::vector<uint8_t> buf)
-{
-    std::stringstream hexss;
-
-    for(uint8_t b : buf)
-    {
-        hexss << std::hex << b << " ";
-    }
-
-    return hexss.str();
-}

Controllers/CoolerMasterController/CMKeyboardAbstractController.h

@@ -1,122 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  CMKeyboardAbstractController.h                                     |
-|                                                                     |
-|  Abstract driver for Coolermaster keyboards                         |
-|                                                                     |
-|  Tam D (too.manyhobbies)      30th Nov 2023                         |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#pragma once
-
-#include <cstring>
-#include <stdint.h>
-#include <string>
-#include <sstream>
-#include <map>
-#include <vector>
-
-#include <hidapi/hidapi.h>
-
-#include "CMKeyboardDevices.h"
-#include "KeyboardLayoutManager.h"
-#include "RGBController.h"
-#include "LogManager.h"
-
-
-#define HID_MAX_STR                         255
-#define CM_KEYBOARD_WRITE_SIZE              65
-#define CM_MAX_LEDS                         255
-#define CM_KEYBOARD_TIMEOUT                 50
-#define CM_KEYBOARD_TIMEOUT_SHORT           3
-
-struct cm_keyboard_effect
-{
-    uint8_t  effectId;
-    uint8_t  p1;
-    uint8_t  p2;
-    uint8_t  p3;
-    RGBColor color1;
-    RGBColor color2;
-};
-
-/*---------------------------------------------------------*\
-| byte[0] = 0x41                                            |
-| byte[1] = modeId                                          |
-\*---------------------------------------------------------*/
-enum cm_keyboard_control_mode
-{
-    MODE_FIRMWARE           = 0x00,
-    MODE_EFFECT             = 0x01,
-    MODE_MANUAL_V2          = 0x02,
-    MODE_CUSTOM_PROFILE     = 0x03,
-    MODE_CUSTOM_PROFILE_V2  = 0x05,
-    MODE_DIRECT             = 0x80
-};
-
-class CMKeyboardAbstractController
-{
-public:
-    CMKeyboardAbstractController(hid_device* dev_handle, hid_device_info* dev_info);
-    ~CMKeyboardAbstractController();
-
-    /*---------------------------------------------------------*\
-    | Common USB controller fuctions                            |
-    \*---------------------------------------------------------*/
-    int                 GetProductID();
-    std::string         GetDeviceName();
-    void                SetDeviceName(std::string name);
-    std::string         GetDeviceVendor();
-    std::string         GetDeviceSerial();
-    std::string         GetLocation();
-    std::string         GetFirmwareVersion();
-    const cm_kb_device* GetDeviceData();
-
-    /*---------------------------------------------------------*\
-    | Keyboard Layout Manager support funtions                  |
-    \*---------------------------------------------------------*/
-
-    /*---------------------------------------------------------*\
-    | Common keyboard driver functions                          |
-    \*---------------------------------------------------------*/
-    virtual void        SetControlMode(uint8_t modeId);
-    virtual void        SetActiveProfile(uint8_t profileId);
-    virtual uint8_t     GetActiveProfile();
-    virtual void        SaveActiveProfile();
-    virtual void        SaveProfile();
-    virtual void        SetActiveEffect(uint8_t effectId);
-    virtual uint8_t     GetModeStatus();
-    virtual void        InitializeModes(std::vector<mode> &modes) = 0;
-    virtual KEYBOARD_LAYOUT GetKeyboardLayout() = 0;
-
-    /*---------------------------------------------------------*\
-    | Protocol specific funtions to be implmented               |
-    \*---------------------------------------------------------*/
-    virtual void        SetLeds(std::vector<led> leds, std::vector<RGBColor> colors) = 0;
-    virtual void        SetSingleLED(uint8_t in_led, RGBColor in_color) = 0;
-    virtual void        Initialize() = 0;
-    virtual void        Shutdown() = 0;
-    virtual void        SetLEDControl(bool bManual) = 0; // FW or SW control
-    virtual void        SetCustomMode() = 0;
-    virtual void        SetMode(mode selectedMode) = 0;
-
-protected:
-    /*---------------------------------------------------------*\
-    | Utility functions.                                        |
-    \*---------------------------------------------------------*/
-    std::vector<std::uint8_t> SendCommand(std::vector<uint8_t> buf, uint8_t fill=0x00);
-    std::string         GetHexString(std::vector<uint8_t> buf);
-    std::string         m_sFirmwareVersion;
-    std::string         m_deviceName;
-    hid_device*         m_pDev;
-    uint16_t            m_productId;
-    uint16_t            m_deviceIndex;
-    std::string         m_vendorName;
-    std::string         m_sLocation;
-    std::string         m_serialNumber;
-    KEYBOARD_LAYOUT     m_keyboardLayout;
-    std::map<int, int>  mapModeValueEffect;
-    std::mutex          m_mutex;
-    std::mutex          m_mutexSendCommand;
-};
-

Controllers/CoolerMasterController/CMKeyboardDevices.cpp

@@ -1,768 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  CMKeyboardDevices.cpp                                              |
-|                                                                     |
-|  Keymap definitions for Cooler Master Keyboards                     |
-|                                                                     |
-|  Tam D (too.manyhobbies)      30th Nov 2023                         |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-#include "CMKeyboardDevices.h"
-
-/*-------------------------------------------------------------------------*\
-|  Coolermaster Key Values                                                  |
-\*-------------------------------------------------------------------------*/
-
-const std::vector<unsigned int> mk_pro_s_keymap =
-{
-/*  ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK        */
-	96,   97,   98,   99,   104,  105,  106,  112,  113,  114,  67,   68,   69,   102,  103,  107,
-/*  BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  */
-	0,    1,    8,    9,    16,   17,   24,   25,   32,   33,   40,   41,   48,   49,   56,   57,   64,
-/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  */
-	2,    3,    10,   11,   18,   19,   26,   27,   34,   35,   42,   43,   50,   51,   58,   59,   66,
-/*  CPLK  A     S     D     F     G     H     J     K     L     ;     "     #     ENTR                    */
-	4,    5,    12,   13,   20,   21,   28,   29,   36,   37,   44,   45,   89,   52,
-/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /     RSFT              ARWU        */
-	6,    100,  7,    14,   15,   22,   23,   30,   31,   38,   39,   46,   47,               61,
-/*  LCTL  LWIN  LALT              SPC               RALT  RFNC  RMNU  RCTL              ARWL  ARWD  ARWR  */
-	91,   90,   92,               93,               94,   60,   95,   54,               63,   62,   70,
-};
-
-const std::vector<unsigned int> mk_pro_l_keymap =
-{
-/*  ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK        P1    P2    P3    P4   */
-	11,   22,   30,   25,   27,   7,    51,   57,   62,   86,   87,   83,   85,   79,   72,   0,
-/*	BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
-	14,   15,   23,   31,   39,   38,   46,   47,   55,   63,   71,   70,   54,   81,   3,    1,    2,    100,  108,  116,  118,
-/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL */
-	9,    8,    16,   24,   32,   33,   41,   40,   48,   56,   64,   65,   49,   82,   94,   92,   88,   96,   104,  112,  110,
-/*  CPLK    A   S     D     F     G     H     J     K     L     ;     '     \     ENTR                    NM4   NM5   NM6        */
-	17,   10,   18,   26,   34,   35,   43,   42,   50,   58,   66,   67,   68,   84,                     97,   105,  113,
-/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /     RSFT              ARWU        NM1   NM2   NM3   NMER */
-	73,   19,   12,   20,   28,   36,   37,   45,   44,   52,   60,   69,   74,               80,         98,   106,  114,  111,
-/*  LCTL  LWIN  LALT              SPACE             RALT  RWFNC RMNU  RCTRL             ARWL  ARDN  ARWR  NM0         NMPD       */
-	6,    90,   75,               91,               77,   78,   61,   4,                95,   93,   5,    107,        115,
-};
-
-const std::vector<unsigned int> mk850_keymap =
-{
-/*        ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK        AIM   AIMU   AIMD */
-	      6,    27,   34,   41,   48,   62,   69,   76,   83,   90,   97,   104,  111,  118,  125,  132,
-/*	M1    BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
-	      7,    21,   28,   35,   42,   49,   56,   63,   70,   77,   84,   91,   98,   112,  119,  126,  133,  254,  147,  154,  161,
-/*  M2    TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL */
-	      8,    22,   29,   36,   43,   50,   57,   64,   71,   78,   85,   92,   99,   113,  120,  127,  134,  141,  148,  155,  162,
-/*  M3    CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    NM4   NM5   NM6        */
-	      9,    23,   30,   37,   44,   51,   58,   65,   72,   79,   86,   93,   0,    114,                    142,  149,  156,
-/*  M4    LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /     RSFT              ARWU        NM1   NM2   NM3   NMER */
-	      10,   0,    24,   31,   38,   45,   52,   59,   66,   73,   80,   87,   115,              129,        143,  150,  157,  164,
-/*  M5    LCTL  LWIN  LALT              SPACE             RALT  RWFNC RMNU  RCTRL             ARWL  ARDN  ARWR  NM0         NMPD       */
-	      11,   18,   25,               53,               81,   88,   95,   116,              123,  130,  137,  144,        158,
-};
-
-/*-------------------------------------------------------------*\
-| CoolerMaster SK (60%)                                         |
-\*-------------------------------------------------------------*/
-const std::vector<unsigned int> sk622_keymap =
-{
-/*	T1    T2    T3    T4    T5    T6    T7    T8    T9    T10   T11   T12   T13   T14   T15        */
-/*	L1    ESC   1     2     3     4     5     6     7     8     9     0     -     =     BPSC        R1  */
-	   	  8,    15,   22,   29,   36,   43,   50,   57,   64,   71,   78,   85,   92,   106,
-/*  L2    TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]                 R2  */
-	  	  9,    23,   30,   37,   44,   51,   58,   65,   72,   79,   86,   93,   100,
-/*  L3    CPLK  A     S     D     F     G     H     J     K     L     ;     "     \     ENTR        R3  */
-	  	  10,   24,   31,   38,   45,   52,   59,   66,   73,   80,   87,   94,   101,  108,
-/*  L4    LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     #     RSFT  ARWU   DEL  R$  */
-	      11,   18,   25,   32,   39,   46,   53,   60,   67,   74,   81,   88,   95,   102,   109,
-/*  L5    LCTL  LWIN  LALT              SPACE                         RALT  RWFNC ARWL  ARDN  ARWR  R5  */
-	  	  12,   19,   26,               54,                           82,   89,   96,   103,   110,
-/*  B1    B2    B3    B4    B5    B6    B7    B8    B9    B10   B11   B12   B13   B14   B15    B15      */
-};
-
-const std::vector<unsigned int> sk630_keymap =
-{
-/*  ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK        */
-	9,    33,   41,   49,   57,    73,   81,   89,   97,  105,  113,  121,  129,  137,  145,  153,
-/*  BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  */
-	10,   26,   34,   42,   50,   58,   66,   74,   82,   90,   98,  106,   114,  130,  138,  146,  154,
-/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  */
-	11,   27,   35,   43,   51,   59,   67,   75,   83,   91,   99,  107,   115,  131,  139,  147,  155,
-/*  CPLK  A     S     D     F     G     H     J     K     L     ;     "     #     ENTR                    */
-	12,   28,   36,   44,   52,   60,   68,   76,   84,   92,  100,  108,   116,  132,
-/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /     RSFT              ARWU        */
-	13,   21,   29,   37,   45,   53,   61,   69,   77,   85,   93,  101,   133,              149,
-/*  LCTL  LWIN  LALT              SPC               RALT  RFNC  RMNU  RCTL              ARWL  ARWD  ARWR  */
-	14,   22,   30,               62,               94,  102,  110,   134,              142,  150,  158,
-};
-
-const std::vector<unsigned int> sk650_keymap =
-{
-/*  ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK                               */
-	0,    24,   32,   40,   48,   64,   72,   80,   88,   96,   104,  112,  120,  128,  136,  144,
-/*	BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
-	1,    17,   25,   33,   41,   49,   57,   65,   73,   81,   89,   97,   105,  121,  129,  137,  145,  153,  161,  169,  177,
-/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL */
-	2,    18,   26,   34,   42,   50,   58,   66,   74,   82,   90,   98,   106,  122,  130,  138,  146,  154,  162,  170,  178,
-/*  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    NM4   NM5   NM6        */
-	3,    19,   27,   35,   43,   51,   59,   67,   75,   83,   91,   99,   107,  123,                    155,  163,  171,
-/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        NM1   NM2   NM3   NMER */
-	4,    20,   28,   36,   44,   52,   60,   68,   76,   84,   92,   100,        124,        140,        156,  164,  172,  180,
-/*  LCTL  LWIN  LALT              SPACE             RALT  RWFNC RMNU  RCTRL             ARWL  ARDN  ARWR        NM0   NMPD       */
-	5,    13,   21,               53,                     85,   93,   101,        125,  133,  141,  149,        165,  173,
-};
-
-const std::vector<unsigned int> sk652_keymap =
-{
-
-/*  ESC         F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK                         */
-    9,          33,   41,   49,   57,   73,   81,   89,   97,   105,  113,  121,  129,  137,  145,  153,
-/*  BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
-    10,   26,   34,   42,   50,   58,   66,   74,   82,   90,   98,   106,  114,  130,  138,  146,  154,  162,  170,  178,  186,
-/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL */
-    11,   27,   35,   43,   51,   59,   67,   75,   83,   91,   99,   107,  115,  131,  139,  147,  155,  163,  171,  179,  187,
-/*  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    NM4   NM5   NM6        */
-    12,   28,   36,   44,   52,   60,   68,   76,   84,   92,   100,  108,  116,  132,                    164,  172,  180,
-/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        NM1   NM2   NM3   NMER */
-    13,   21,   29,   37,   45,   53,   61,   69,   77,   85,   93,   101,        133,        149,        165,  173,  181,  189,
-/*  LCTL  LWIN  LALT              SPACE                         RALT  RWFNC RMNU  RCTRL ARWL  ARDN  ARWR        NM0   NMPD       */
-    14,   22,   30,               62,                           94,   102,  110,  134,  142,  150,  158,        174,  182,
-};
-
-const std::vector<unsigned int> sk653_keymap =
-{
-/*  ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK                               */
-	0,    24,   32,   40,   48,   64,   72,   80,   88,   96,   104,  112,  120,  128,  136,  144,
-/*	BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
-	1,    17,   25,   33,   41,   49,   57,   65,   73,   81,   89,   97,   105,  121,  129,  137,  145,  153,  161,  169,  177,
-/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL */
-	2,    18,   26,   34,   42,   50,   58,   66,   74,   82,   90,   98,   106,  122,  130,  138,  146,  154,  162,  170,  178,
-/*  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    NM4   NM5   NM6        */
-	3,    19,   27,   35,   43,   51,   59,   67,   75,   83,   91,   99,   107,  123,                    155,  163,  171,
-/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        NM1   NM2   NM3   NMER */
-	4,    20,   28,   36,   44,   52,   60,   68,   76,   84,   92,   100,        124,        140,        156,  164,  172,  180,
-/*  LCTL  LWIN  LALT              SPACE             RALT  RWFNC RMNU  RCTRL             ARWL  ARDN  ARWR        NM0   NMPD       */
-	5,    13,   21,               53,                     85,   93,   101,        125,  133,  141,  149,        165,  173,
-};
-
-const std::vector<unsigned int> mk730_keymap =
-{
-/*      ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK            */
-        7,    28,   35,   42,   49,   63,   70,   77,   84,   91,   98,   105,  112,   119,  126,  133,
-/*	L1  BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  R1  */
-	    8,    22,   29,   36,   43,   50,   57,   64,   71,   78,   85,   92,   99,    113,  120,  127,  134,
-/*  L2  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  R2  */
-	    9,    23,   30,   37,   44,   51,   58,   65,   72,   79,   86,   93,   100,   114,  121,  128,  135,
-/*  L3  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    R3  */
-	    10,   24,   31,   38,   45,   52,   59,   66,   73,   80,   87,   94,   108,   115,
-/*  L4  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        R4  */
-	    11,   18,   25,   32,   39,   46,   53,   60,   67,   74,   81,   88,          116,       130,
-/*      LCTL  LWIN  LALT              SPACE             RALT  RWFNC RMNU  RCTRL             ARWL  ARDN  ARWR      */
-	    12,   19,   26,               54,               82,   89,   96,   117,               124, 131,  138,
-/*      B1    B2    B3    B4    B5    B6    B7    B8    B9    B10   B11   B12   B12                          */
-};
-
-const std::vector<unsigned int> mk750_keymap =
-{
-/*      ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK  MUT   PLA   REW   FFWD            */
-        7,    28,   35,   42,   49,   63,   70,   77,   84,   91,   98,   105,  112,  119,  136,  133,
-/*	L1  BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI  R1  */
-	    8,    22,   29,   36,   43,   50,   57,   64,   71,   78,   85,   92,   99,   113,  120,  127,  134,    0,  148,  155,  162,
-/*  L2  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL  R2  */
-	    9,    23,   30,   37,   44,   51,   58,   65,   72,   79,   86,   93,   100,  114,  121,  128,  135,  142,  149,  156,  163,
-/*  L3  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    NM4   NM5   NM6         R3  */
-	    10,   24,   31,   38,   45,   52,   59,   66,   73,   80,   87,   94,   108,  115,                    143,  150,  157,
-/*  L4  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        NM1   NM2   NM3   NMER  R4  */
-	    11,   18,   25,   32,   39,   46,   53,   60,   67,   74,   81,   88,         116,        130,        144,  151,  158,  165,
-/*      LCTL  LWIN  LALT              SPACE             RALT  RWFNC RMNU  RCTRL             ARWL  ARDN  ARWR        NM0   NMPD            */
-	    12,   19,   26,               54,               82,   89,   96,   117,              124,  131,  138,        152,  159,
-/*      B1    B2    B3    B4    B5    B6    B7    B8    B9    B10   B11   B12   B12   B13   B14   B15   B16  B17  B18                     */
-};
-
-
-const std::vector<unsigned int> ck530_keymap =
-{
-/*  ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK        */
-    6,    21,   27,   34,   41,   55,   62,   69,   76,   83,   90,   97,   104,  111,  118,  125,
-/*  BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  */
-    7,    15,   22,   28,   35,   42,   49,   56,   63,   70,   77,   84,   91,   105,  112,  119,  126,
-/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  */
-    8,    16,   23,   29,   36,   43,   50,   57,   64,   71,   78,   85,   92,   106,  113,  120,  127,
-/*  CPLK  A     S     D     F     G     H     J     K     L     ;     "     #     ENTR                    */
-    9,    17,   24,   30,   37,   44,   51,   58,   65,   72,   79,   86,   93,   107,
-/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        */
-    10,   18,   25,   31,   38,   45,   52,   59,   66,   73,   80,   87,         108,        122,
-/*  LCTL  LWIN  LALT              SPC                     RALT  RFNC  RMNU  RCTL        ARWL  ARWD  ARWR  */
-    11,   12,   19,               46,                    74,   81,    88,  109,         116,  123,  130,
-};
-
-const std::vector<unsigned int> ck550_v2_keymap =
-{
-/*  ESC         F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK                         */
-	0,          18,   24,   30,   36,   48,   54,   60,   66,   72,   78,   84,   90,   96,   102,  108,
-/*	BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
-	1,    13,   19,   25,   31,   37,   43,   49,   55,   61,   67,   73,   79,   91,   97,   103,  109,  115,  121,  127,  133,
-/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL */
-    2,    14,   20,   26,   32,   38,   44,   50,   56,   62,   68,   74,   80,   92,   98,   104,  110,  116,  122,  128,  134,
-/*  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    NM4   NM5   NM6        */
-    3,    15,   21,   27,   33,   39,   45,   51,   57,   63,   69,   75,   87,   93,                     117,  123,  129,
-/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        NM1   NM2   NM3   NMER */
-    4,    10,   16,   22,   28,   34,   40,   46,   52,   58,   64,   70,/*76,*/  94,         106,        118,  124,  130,  136,
-/*  LCTL  LWIN  LALT              SPACE                   RALT  RWFNC RMNU        RCTRL  ARWL ARDN  ARWR        NM0   NMPD       */
-    5,    11,   17,               41,                     65,   71,   77,         95,    101, 107,  113,        125,  131,
-};
-
-const std::vector<unsigned int> ck552_keymap =
-{
-/*  ESC         F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK                         */
-	0,          18,   24,   30,   36,   48,   54,   60,   66,   72,   78,   84,   90,   96,   102,  108,
-/*	BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BPSC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
-	1,    13,   19,   25,   31,   37,   43,   49,   55,   61,   67,   73,   79,   91,   97,   103,  109,  115,  121,  127,  133,
-/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     \     DEL   END   PGDN  NM7   NM8   NM9   NMPL */
-    2,    14,   20,   26,   32,   38,   44,   50,   56,   62,   68,   74,   80,   92,   98,   104,  110,  116,  122,  128,  134,
-/*  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR                    NM4   NM5   NM6        */
-    3,    15,   21,   27,   33,   39,   45,   51,   57,   63,   69,   75,   81,   93,                     117,  123,  129,
-/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        NM1   NM2   NM3   NMER */
-    4,    10,   16,   22,   28,   34,   40,   46,   52,   58,   64,   70,/*76,*/  94,         106,        118,  124,  130,  136,
-/*  LCTL  LWIN  LALT              SPACE                   RALT  RWFNC RMNU        RCTRL  ARWL ARDN  ARWR        NM0   NMPD       */
-    5,    11,   17,               41,                     65,   71,   77,         95,    101, 107,  113,        125,  131,
-};
-
-/*-------------------------------------------------------------------------*\
-|  KEYMAPS                                                                  |
-\*-------------------------------------------------------------------------*/
-keyboard_keymap_overlay_values mk_pro_s_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
-    {
-        mk_pro_s_keymap,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-        \*---------------------------------------------------------------------------------------------------------*/
-    },
-};
-
-keyboard_keymap_overlay_values mk_pro_l_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
-    {
-        mk_pro_l_keymap,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Name,       Translated Name,    OpCode,                         |
-        \*---------------------------------------------------------------------------------------------------------*/
-        {   0,      0,      17,         101,        "Key: P1",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      18,         109,        "Key: P2",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      19,         117,        "Key: P3",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      20,         119,        "Key: P4",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-    },
-};
-
-/*-------------------------------------------------------------*\
-| CoolerMaster MK85O Keyboard                                   |
-| Unknown Keys: ISO\, ISO# set to 0                             |
-\*-------------------------------------------------------------*/
-keyboard_keymap_overlay_values mk850_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
-    {
-        mk850_keymap,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Name,           Translated Name,    OpCode,                     |
-        \*---------------------------------------------------------------------------------------------------------*/
-        {   0,      0,      17,       146,          "Key: Aim <|>", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // aimpad <|>
-        {   0,      0,      18,       153,          "Key: Aim -",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // aimpad +
-        {   0,      0,      19,       160,          "Key: Aim +",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // aimpad -
-        {   0,      1,       0,         0,          "Key: M5",      KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      2,       0,         1,          "Key: M4",      KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      3,       0,         2,          "Key: M3",      KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      4,       0,         3,          "Key: M2",      KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      5,       0,         4,          "Key: M1",      KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-    },
-};
-
-keyboard_keymap_overlay_values sk622_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_SIXTY,
-    {
-        sk622_keymap,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Name,               Translated Name,    OpCode,                 |
-        \*---------------------------------------------------------------------------------------------------------*/
-        {   0,      0,      0,          7,          "Light: Top 1",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_ROW, },
-        {   0,      0,      1,         14,          "Light: Top 2",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      2,         21,          "Light: Top 3",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      3,         28,          "Light: Top 4",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      4,         35,          "Light: Top 5",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      5,         42,          "Light: Top 6",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      6,         49,          "Light: Top 7",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      7,         56,          "Light: Top 8",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      8,         63,          "Light: Top 9",     KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      9,         70,          "Light: Top 10",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      10,        77,          "Light: Top 11",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      11,        84,          "Light: Top 12",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      12,        91,          "Light: Top 13",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      13,        98,          "Light: Top 14",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      14,       105,          "Light: Top 14",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      1,      0,          0,          "Light: Left 1",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      2,      0,          1,          "Light: Left 2",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      3,      0,          2,          "Light: Left 3",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      4,      0,          3,          "Light: Left 4",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      5,      0,          4,          "Light: Left 5",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      1,      16,       112,          "Light: Right 1",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      2,      16,       113,          "Light: Right 2",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      3,      16,       114,          "Light: Right 3",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      4,      16,       115,          "Light: Right 4",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      5,      16,       116,          "Light: Right 5",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       0,         6,          "Light: Bottom 1",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_ROW, },
-        {   0,      6,       1,        20,          "Light: Bottom 2",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       2,        27,          "Light: Bottom 3",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       3,        34,          "Light: Bottom 4",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       4,        41,          "Light: Bottom 5",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       5,        48,          "Light: Bottom 6",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       6,        55,          "Light: Bottom 7",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       7,        62,          "Light: Bottom 8",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       8,        69,          "Light: Bottom 9",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       9,        76,          "Light: Bottom 10", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       10,       83,          "Light: Bottom 11", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       11,       90,          "Light: Bottom 12", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       12,       97,          "Light: Bottom 13", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       13,      104,          "Light: Bottom 14", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       14,      111,          "Light: Bottom 15", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       14,      118,          "Light: Bottom 16", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-    },
-};
-
-keyboard_keymap_overlay_values sk630_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
-    {
-        sk630_keymap,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-        \*---------------------------------------------------------------------------------------------------------*/
-    }
-};
-
-keyboard_keymap_overlay_values sk650_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
-    {
-        sk650_keymap,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-        \*---------------------------------------------------------------------------------------------------------*/
-    }
-};
-
-keyboard_keymap_overlay_values sk652_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
-    {
-        sk652_keymap,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-        \*---------------------------------------------------------------------------------------------------------*/
-    }
-};
-
-keyboard_keymap_overlay_values sk653_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
-    {
-        sk653_keymap,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-        \*---------------------------------------------------------------------------------------------------------*/
-    }
-};
-
-/*-------------------------------------------------------------*\
-| CoolerMaster MK730 Keyboard                                   |
-\*-------------------------------------------------------------*/
-keyboard_keymap_overlay_values mk730_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
-    {
-        mk730_keymap,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Name,               Translated Name,    OpCode,                 |
-        \*---------------------------------------------------------------------------------------------------------*/
-        {   0,      1,      0,          1,          "Light: Left 1",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      2,      0,          2,          "Light: Left 2",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      3,      0,          3,          "Light: Left 3",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      4,      0,          4,          "Light: Left 4",    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      1,      18,       141,          "Light: Right 1",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      2,      18,       142,          "Light: Right 2",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      3,      18,       143,          "Light: Right 3",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      4,      18,       144,          "Light: Right 4",   KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       1,        13,          "Light: Bottom 1",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_ROW, },
-        {   0,      6,       2,        20,          "Light: Bottom 2",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       3,        27,          "Light: Bottom 3",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       4,        34,          "Light: Bottom 4",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       5,        41,          "Light: Bottom 5",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       6,        55,          "Light: Bottom 6",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       7,        62,          "Light: Bottom 7",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       8,        69,          "Light: Logo",      KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      10,        76,          "Light: Bottom 8",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      11,        90,          "Light: Bottom 9",  KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      12,       104,          "Light: Bottom 10", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      13,       111,          "Light: Bottom 11", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      14,       118,          "Light: Bottom 12", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      15,       125,          "Light: Bottom 13", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-    }
-};
-
-/*-------------------------------------------------------------*\
-| CoolerMaster MK750 Keyboard                                   |
-| based on keymap defined in Signal.                            |
-| The keymap needs the following adjustments                    |
-| NMLK - Unknown set to 0                                       |
-| SCLK - Unknown set to 0                                       |
-| CAPS - Unknown set to 0                                       |
-| Guesses on ISO\ and #                                         |
-\*-------------------------------------------------------------*/
-keyboard_keymap_overlay_values mk750_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
-    {
-        mk750_keymap,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Name,                       Translated Name,    OpCode,         |
-        \*---------------------------------------------------------------------------------------------------------*/
-        {   0,      0,      17,       140,          KEY_EN_MEDIA_MUTE,          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      18,       147,          KEY_EN_MEDIA_PLAY_PAUSE,    KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      19,       154,          KEY_EN_MEDIA_PREVIOUS,      KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      20,       161,          KEY_EN_MEDIA_NEXT,          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      1,      0,          1,          "Light: Left 1",            KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      2,      0,          2,          "Light: Left 2",            KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      3,      0,          3,          "Light: Left 3",            KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      4,      0,          4,          "Light: Left 4",            KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      1,      22,       170,          "Light: Right 1",           KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      2,      22,       171,          "Light: Right 2",           KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      3,      22,       172,          "Light: Right 3",           KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      4,      22,       173,          "Light: Right 4",           KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       1,        20,          "Light: Bottom 1",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_ROW, },
-        {   0,      6,       2,        27,          "Light: Bottom 2",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       3,        34,          "Light: Bottom 3",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       4,        41,          "Light: Bottom 4",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       5,        55,          "Light: Bottom 5",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       6,        62,          "Light: Bottom 6",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       7,        69,          "Light: Bottom 7",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       8,        76,          "Light: Bottom 8",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,       9,        83,          "Light: Bottom 9",          KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      10,        90,          "Light: Bottom 10",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      11,       104,          "Light: Bottom 11",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      12,       111,          "Light: Bottom 12",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      13,       118,          "Light: Bottom 13",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      14,       125,          "Light: Bottom 14",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      15,       132,          "Light: Bottom 15",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      16,       146,          "Light: Bottom 16",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      17,       153,          "Light: Bottom 17",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      18,       160,          "Light: Bottom 18",         KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-    }
-};
-
-keyboard_keymap_overlay_values ck530_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
-    {
-        ck530_keymap,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-        \*---------------------------------------------------------------------------------------------------------*/
-    }
-};
-
-keyboard_keymap_overlay_values ck550v2_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
-    {
-        ck550_v2_keymap,
-        {
-            {
-                /* Add more regional layout fixes here */
-                /*---------------------------------------------------------------------------------------------------------*\
-                | Edit Keys                                                                                                 |
-                |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-                \*---------------------------------------------------------------------------------------------------------*/
-            },
-        },
-    },
-    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Name,           Translated Name,    OpCode,                             |
-        \*---------------------------------------------------------------------------------------------------------*/
-        {   0,      0,      17,        120,         "Indicator: N", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      18,        126,         "Indicator: C", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      19,        132,         "Indicator: S", KEY_EN_UNUSED,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-    },
-};
-
-keyboard_keymap_overlay_values ck552_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
-    {
-        ck552_keymap,
-        {
-            {
-                /* Add more regional layout fixes here */
-                /*---------------------------------------------------------------------------------------------------------*\
-                | Edit Keys                                                                                                 |
-                |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-                \*---------------------------------------------------------------------------------------------------------*/
-            },
-        },
-    },
-    {
-        /*---------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                 |
-        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
-        \*---------------------------------------------------------------------------------------------------------*/
-    },
-};
-
-static const cm_kb_zone cm_generic_zone =
-{
-    ZONE_EN_KEYBOARD,
-    ZONE_TYPE_MATRIX,
-};
-
-cm_kb_device mk_pro_s_device
-{
-    COOLERMASTER_KEYBOARD_PRO_S_PID,
-    {
-        &cm_generic_zone,
-    },
-    &mk_pro_s_layout,
-};
-
-cm_kb_device mk_pro_l_device
-{
-    COOLERMASTER_KEYBOARD_PRO_L_PID,
-    {
-        &cm_generic_zone,
-    },
-    &mk_pro_l_layout,
-};
-
-cm_kb_device mk850_device
-{
-    COOLERMASTER_KEYBOARD_MK850_PID,
-    {
-        &cm_generic_zone,
-    },
-    &mk850_layout,
-};
-
-cm_kb_device sk622w_device
-{
-    COOLERMASTER_KEYBOARD_SK622W_PID,
-    {
-        &cm_generic_zone,
-    },
-    &sk622_layout,
-};
-
-cm_kb_device sk622b_device
-{
-    COOLERMASTER_KEYBOARD_SK622B_PID,
-    {
-        &cm_generic_zone,
-    },
-    &sk622_layout,
-};
-
-cm_kb_device sk630_device
-{
-    COOLERMASTER_KEYBOARD_SK630_PID,
-    {
-        &cm_generic_zone,
-    },
-    &sk630_layout,
-};
-
-cm_kb_device sk650_device
-{
-    COOLERMASTER_KEYBOARD_SK650_PID,
-    {
-        &cm_generic_zone,
-    },
-    &sk650_layout,
-};
-
-cm_kb_device sk652_device
-{
-    COOLERMASTER_KEYBOARD_SK652_PID,
-    {
-        &cm_generic_zone,
-    },
-    &sk652_layout,
-};
-
-cm_kb_device sk653_device
-{
-    COOLERMASTER_KEYBOARD_SK653_PID,
-    {
-        &cm_generic_zone,
-    },
-    &sk652_layout,
-};
-
-/*---------------------------------------------------------*\
-| TODO: Keymap is incomplete. Extra keys mode enabled to    |
-| aid in key discovery.                                     |
-\*---------------------------------------------------------*/
-cm_kb_device mk730_device
-{
-    COOLERMASTER_KEYBOARD_MK730_PID,
-    {
-        &cm_generic_zone,
-    },
-    &mk730_layout,
-};
-
-cm_kb_device mk750_device
-{
-    COOLERMASTER_KEYBOARD_MK750_PID,
-    {
-        &cm_generic_zone,
-    },
-    &mk750_layout,
-};
-
-cm_kb_device ck530_device
-{
-    COOLERMASTER_KEYBOARD_CK530_PID,
-    {
-        &cm_generic_zone,
-    },
-    &ck530_layout,
-};
-
-cm_kb_device ck530_v2_device
-{
-    COOLERMASTER_KEYBOARD_CK530_V2_PID,
-    {
-        &cm_generic_zone,
-    },
-    &ck530_layout,
-};
-
-cm_kb_device ck550_v2_device
-{
-    COOLERMASTER_KEYBOARD_CK550_V2_PID,
-    {
-        &cm_generic_zone,
-    },
-    &ck550v2_layout,
-};
-
-cm_kb_device ck552_v2_device
-{
-    COOLERMASTER_KEYBOARD_CK552_V2_PID,
-    {
-        &cm_generic_zone,
-    },
-    &ck552_layout,
-};
-
-cm_kb_device mk_pro_l_white_device
-{
-    COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID,
-    {
-        &cm_generic_zone,
-    },
-    &mk_pro_s_layout,
-};
-
-/*-----------------------------------------------------------------*\
-|  KEYBOARDS                                                        |
-\*-----------------------------------------------------------------*/
-const cm_kb_device* cm_kb_devices[] =
-{
-    &mk_pro_s_device,
-    &mk_pro_l_device,
-    &mk850_device,
-    &sk622w_device,
-    &sk622b_device,
-    &sk630_device,
-    &sk650_device,
-    &sk652_device,
-    &sk653_device,
-    &mk730_device,
-    &mk750_device,
-    &ck530_device,
-    &ck530_v2_device,
-    &ck550_v2_device,
-    &ck552_v2_device,
-    &mk_pro_l_white_device,
-};
-
-const unsigned int COOLERMASTER_KEYBOARD_DEVICE_COUNT = (sizeof(cm_kb_devices) / sizeof(cm_kb_devices[ 0 ]));
-const cm_kb_device** cm_kb_device_list = cm_kb_devices;

Controllers/CoolerMasterController/CMKeyboardDevices.h

@@ -1,120 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  CMKeyboardDevices.h                                                |
-|                                                                     |
-|  Keymap definitions for Cooler Master Keyboards                     |
-|                                                                     |
-|  Tam D (too.manyhobbies)      30th Nov 2023                         |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-#pragma once
-
-#include "RGBController.h"
-#include "KeyboardLayoutManager.h"
-
-/*-----------------------------------------------------*\
-| List of all supported effects by this controller.     |
-| All of these effects are firmware controlled, and     |
-| they types of effects supported will depend on the    |
-| Keyboard.                                             |
-|                                                       |
-| To enable a command, the SetEffect(effectId) needs    |
-| to be called. The specific effectId->Effect mapping   |
-| depends on the keyboard.                              |
-\*-----------------------------------------------------*/
-enum cm_keyboard_effect_type
-{
-    NONE = 0,
-    DIRECT,
-    SINGLE,
-    FULLY_LIT,
-    STATIC,
-    BREATHE,
-    CYCLE,
-    WAVE,
-    RIPPLE,
-    CROSS,
-    RAINDROPS,
-    STARS,
-    SNAKE,
-    CUSTOMIZED,
-    INDICATOR,
-    MULTILAYER,
-    REACTIVE_FADE,
-    REACTIVE_PUNCH,
-    REACTIVE_TORNADO,
-    HEARTBEAT,
-    FIREBALL,
-    SNOW,
-    CIRCLE_SPECTRUM,
-    WATER_RIPPLE,
-    OFF
-};
-
-#define CM_KB_ZONES_MAX 1
-
-typedef struct
-{
-    std::string                     name;
-    zone_type                       type;
-} cm_kb_zone;
-
-typedef struct
-{
-    uint16_t                        product_id;
-    const cm_kb_zone *              zones[CM_KB_ZONES_MAX];
-    keyboard_keymap_overlay_values* layout_new;
-} cm_kb_device;
-
-#define COOLERMASTER_VID    0x2516
-
-#define CMKB_MAXKEYS        256
-
-/*-----------------------------------------------------------------*\
-| keyboard support status is indicated to the right of              |
-| the PID definition. Attribution to products is also               |
-| indicated.                                                        |
-|                                                                   |
-| libcmmk                                                           |
-| signal    https://gitlab.com/signalrgb/signal-plugins             |
-| openrgb                                                           |
-| ck550-macos https://github.com/vookimedlo/ck550-macos/tree/master |
-| reversed                                                          |
-|                                                                   |
-| issue tickets, open merge requests etc are provided               |
-| for developer references.                                         |
-| # denotes issue ticket                                            |
-| ! denotes merge/pull request                                      |
-\*-----------------------------------------------------------------*/
-#define COOLERMASTER_KEYBOARD_CK351_PID           0x014F // unsupported
-#define COOLERMASTER_KEYBOARD_CK530_PID           0x009F // [ck550-macos]
-#define COOLERMASTER_KEYBOARD_CK530_V2_PID        0x0147 // [signal]
-#define COOLERMASTER_KEYBOARD_CK550_V2_PID        0x0145 // [openrgb #800, #2863, signal]
-#define COOLERMASTER_KEYBOARD_CK552_V2_PID        0x007F // [ck550-macos, signal]
-#define COOLERMASTER_KEYBOARD_CK570_V2_PID        0x01E8 // unsupported
-#define COOLERMASTER_KEYBOARD_CK720_PID           0x016B // unsupported
-#define COOLERMASTER_KEYBOARD_CK721_PID           0x016D // unsupported
-#define COOLERMASTER_KEYBOARD_CK721LINE_PID       0x01EE // unsupported
-#define COOLERMASTER_KEYBOARD_PRO_L_PID           0x003B // [libcmmk !16]
-#define COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID     0x0047 // [libcmmk]
-#define COOLERMASTER_KEYBOARD_PRO_S_PID           0x003C // [libcmmk #30 !31 !36, !37, !7, #5(closed), #3(closed)]
-// MASTERKEYS PRO M [libcmmk #17]
-#define COOLERMASTER_KEYBOARD_MK721_PID           0x016F // unsupported
-#define COOLERMASTER_KEYBOARD_MK730_PID           0x008F // [openrgb #1630, libcmmk]
-#define COOLERMASTER_KEYBOARD_MK750_PID           0x0067 // fw1.2 [libcmmk #25 !9, !14, signal]
-#define COOLERMASTER_KEYBOARD_MK770_PID           0x01D5 // unsupported
-#define COOLERMASTER_KEYBOARD_MK850_PID           0x0069 // [signal]
-#define COOLERMASTER_KEYBOARD_SK620B_PID          0x0157 // unsupported
-#define COOLERMASTER_KEYBOARD_SK620W_PID          0x0159 // [signal]
-#define COOLERMASTER_KEYBOARD_SK622B_PID          0x0149 // [openrgb #3110, signal #217(closed)]
-#define COOLERMASTER_KEYBOARD_SK622W_PID          0x014B // [signal]
-#define COOLERMASTER_KEYBOARD_SK630_PID           0x0089 // [openrgb #967, libcmmk !21]
-#define COOLERMASTER_KEYBOARD_SK631B_PID          0x008B // unsupported
-#define COOLERMASTER_KEYBOARD_SK631W_PID          0x0125 // [libcmmk]
-#define COOLERMASTER_KEYBOARD_SK650_PID           0x008D // [openrgb #613, libcmmk #23 !37 !27 !28, signal]
-#define COOLERMASTER_KEYBOARD_SK651B_PID          0x0091 // unsupported
-#define COOLERMASTER_KEYBOARD_SK651W_PID          0x0127 // [signal]
-#define COOLERMASTER_KEYBOARD_SK652_PID           0x015D // [signal]
-#define COOLERMASTER_KEYBOARD_SK653_PID           0x01AB // [openrgb #3571, signal]
-
-extern const unsigned int COOLERMASTER_KEYBOARD_DEVICE_COUNT;
-extern const cm_kb_device** cm_kb_device_list;

Controllers/CoolerMasterController/CMKeyboardV1Controller.cpp

@@ -1,497 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  CMKeyboardV1Controller.cpp                                         |
-|                                                                     |
-|  Driver for Coolermaster MasterKeys keyboards (V1)                  |
-|                                                                     |
-|  Tam D (too.manyhobbies)      30th Nov 2023                         |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-#include "CMKeyboardV1Controller.h"
-#include "LogManager.h"
-#include <cmath>
-
-CMKeyboardV1Controller::CMKeyboardV1Controller(hid_device* dev_handle, hid_device_info* dev_info) : CMKeyboardAbstractController(dev_handle, dev_info)
-{
-    m_sFirmwareVersion = _GetFirmwareVersion();
-}
-
-CMKeyboardV1Controller::~CMKeyboardV1Controller()
-{
-}
-
-void CMKeyboardV1Controller::Initialize()
-{
-    SetLEDControl(true);
-}
-
-void CMKeyboardV1Controller::SetActiveEffect(uint8_t effectId)
-{
-    SendCommand({0x51, 0x28, 0x00, 0x00, effectId});
-}
-
-uint8_t CMKeyboardV1Controller::GetActiveEffect()
-{
-    std::vector<uint8_t> data = SendCommand({0x52, 0x28});
-
-    return data[4];
-}
-
-void CMKeyboardV1Controller::SetEffect(uint8_t effectId, uint8_t p1, uint8_t p2, uint8_t p3, RGBColor color1, RGBColor color2)
-{
-    std::vector<uint8_t> data;
-
-    data.push_back(0x51);
-    data.push_back(0x2C);
-    data.push_back(0x00); // multilayer_mode - NOT SUPPORTED
-    data.push_back(0x00);
-    data.push_back(effectId);
-    data.push_back(p1);
-    data.push_back(p2);
-    data.push_back(p3);
-    data.push_back(0xFF);
-    data.push_back(0xFF);
-    data.push_back(RGBGetRValue(color1));
-    data.push_back(RGBGetGValue(color1));
-    data.push_back(RGBGetBValue(color1));
-    data.push_back(RGBGetRValue(color2));
-    data.push_back(RGBGetGValue(color2));
-    data.push_back(RGBGetBValue(color2));
-
-    /*-------------------------------------------*\
-    | Likely a bit mask for each LEDs.            |
-    | 3 bits per LED x 127 possible LEDs ~48 bytes|
-    \*-------------------------------------------*/
-    for(size_t i = 0; i < 48; i++)
-    {
-        data.push_back(0xFF);
-    }
-
-    SetCustomMode();
-    SetActiveEffect(effectId);
-    SendCommand(data);
-}
-
-void CMKeyboardV1Controller::SetCustomMode()
-{
-    SetControlMode(0x01);
-}
-
-void CMKeyboardV1Controller::SetMode(mode selectedMode)
-{
-    RGBColor color1     = 0;
-    RGBColor color2     = 0;
-    uint8_t cSpeed      = 0;
-    uint8_t cDirection  = 0;
-    uint8_t effectId    = selectedMode.value;
-    bool bModeRandom    = false;
-
-    if(selectedMode.colors.size() >= 1)
-    {
-        color1 = selectedMode.colors[0];
-    }
-
-    if(selectedMode.colors.size() >= 2)
-    {
-        color2 = selectedMode.colors[1];
-    }
-
-    if(selectedMode.color_mode == MODE_COLORS_RANDOM)
-    {
-        bModeRandom = true;
-    }
-
-    int selectedEffect = mapModeValueEffect[effectId];
-    cSpeed = selectedMode.speed;
-
-    switch(selectedMode.direction)
-    {
-        case MODE_DIRECTION_LEFT:
-        case MODE_DIRECTION_HORIZONTAL:
-        cDirection = 0x00;
-        break;
-
-        case MODE_DIRECTION_RIGHT:
-        cDirection = 0x04;
-        break;
-
-        case MODE_DIRECTION_UP:
-        case MODE_DIRECTION_VERTICAL:
-        cDirection = 0x06;
-        break;
-
-        case MODE_DIRECTION_DOWN:
-        cDirection = 0x02;
-        break;
-
-        default:
-        break;
-    }
-
-    switch(selectedEffect)
-    {
-        case DIRECT:
-        case STATIC:
-        {
-            SetEffect(effectId, 0, 0, 0, color1, color2);
-        }
-        break;
-
-        case CROSS:
-        case BREATHE:
-        case REACTIVE_PUNCH:
-        case CIRCLE_SPECTRUM:
-        case SNAKE:
-        {
-            SetEffect(effectId, cSpeed, 0, 0xFF, color1, color2);
-        }
-        break;
-
-        case WAVE:
-        {
-            SetEffect(effectId, cSpeed, cDirection, 0xFF, color1, color2);
-        }
-        break;
-
-        case RIPPLE:
-        {
-            SetEffect(effectId, cSpeed, bModeRandom ? 0x80 : 0x00, 0xFF, color1, color2);
-        }
-        break;
-
-        case RAINDROPS:
-        {
-            SetEffect(effectId, 0x6a, 0x00, cSpeed, color1, color2);
-        }
-        break;
-
-        case STARS:
-        {
-            SetEffect(effectId, cSpeed, 0x00, 0x10, color1, color2);
-        }
-        break;
-
-        default:
-        break;
-    }
-}
-
-void CMKeyboardV1Controller::InitializeModes(std::vector<mode> &modes)
-{
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = 0x02;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-
-    modes.push_back(Direct);
-
-    mapModeValueEffect[0x02]    = DIRECT;
-
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = 0x00;
-    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min           = 1;
-    Static.colors_max           = 1;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-    mapModeValueEffect[0x00]    = STATIC;
-
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = 0x01;
-    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.speed_min         = 0x46;
-    Breathing.speed_max         = 0x27;
-    Breathing.speed             = 0x36;
-    Breathing.colors_min        = 1;
-    Breathing.colors_max        = 1;
-    Breathing.colors.resize(1);
-    modes.push_back(Breathing);
-    mapModeValueEffect[0x01]    = BREATHE;
-
-    mode Cycle;
-    Cycle.name                  = "Spectrum Cycle";
-    Cycle.value                 = 0x02;
-    Cycle.flags                 = MODE_FLAG_HAS_SPEED;
-    Cycle.color_mode            = MODE_COLORS_NONE;
-    Cycle.speed_min             = 0x96;
-    Cycle.speed_max             = 0x68;
-    Cycle.speed                 = 0x7F;
-    modes.push_back(Cycle);
-    mapModeValueEffect[0x02]    = CIRCLE_SPECTRUM;
-
-    mode Reactive;
-    Reactive.name               = "Reactive";
-    Reactive.value              = 0x03;
-    Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-    Reactive.speed_min          = 0x3C;
-    Reactive.speed_max          = 0x2F;
-    Reactive.speed              = 0x35;
-    Reactive.colors_min         = 2;
-    Reactive.colors_max         = 2;
-    Reactive.colors.resize(2);
-    modes.push_back(Reactive);
-    mapModeValueEffect[0x03]    = REACTIVE_PUNCH;
-
-    mode Wave;
-    Wave.name                   = "Rainbow Wave";
-    Wave.value                  = 0x04;
-    Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
-    Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-    Wave.speed_min              = 0x48;
-    Wave.speed_max              = 0x2A;
-    Wave.speed                  = 0x29;
-    Wave.direction              = MODE_DIRECTION_LEFT;
-    Wave.colors_min             = 1;
-    Wave.colors_max             = 1;
-    Wave.colors.resize(1);
-    modes.push_back(Wave);
-    mapModeValueEffect[0x04]    = WAVE;
-
-    mode Ripple;
-    Ripple.name                 = "Ripple Effect";
-    Ripple.value                = 0x05;
-    Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
-    Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Ripple.speed_min            = 0x96;
-    Ripple.speed_max            = 0x62;
-    Ripple.speed                = 0x7C;
-    Ripple.colors_min           = 2;
-    Ripple.colors_max           = 2;
-    Ripple.colors.resize(2);
-    modes.push_back(Ripple);
-    mapModeValueEffect[0x05]    = RIPPLE;
-
-    mode Cross;
-    Cross.name                  = "Cross";
-    Cross.value                 = 0x06;
-    Cross.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Cross.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Cross.speed_min             = 0x2A;
-    Cross.speed_max             = 0x48;
-    Cross.speed                 = 0x39;
-    Cross.colors_min            = 2;
-    Cross.colors_max            = 2;
-    Cross.colors.resize(2);
-    modes.push_back(Cross);
-    mapModeValueEffect[0x06]    = CROSS;
-
-    mode Raindrops;
-    Raindrops.name              = "Raindrops";
-    Raindrops.value             = 0x07;
-    Raindrops.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Raindrops.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Raindrops.speed_min         = 0x40;
-    Raindrops.speed_max         = 0x08;
-    Raindrops.speed             = 0x24;
-    Raindrops.colors_min        = 2;
-    Raindrops.colors_max        = 2;
-    Raindrops.colors.resize(2);
-    modes.push_back(Raindrops);
-    mapModeValueEffect[0x07]    = RAINDROPS;
-
-    mode Stars;
-    Stars.name                  = "Starfield";
-    Stars.value                 = 0x08;
-    Stars.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Stars.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Stars.speed_min             = 0x46;
-    Stars.speed_max             = 0x32;
-    Stars.speed                 = 0x3C;
-    Stars.colors_min            = 2;
-    Stars.colors_max = 2;
-    Stars.colors.resize(2);
-    modes.push_back(Stars);
-    mapModeValueEffect[0x08]    = STARS;
-
-    mode Snake;
-    Snake.name                  = "Snake";
-    Snake.value                 = 0x09;
-    Snake.flags                 = MODE_FLAG_HAS_SPEED;
-    Snake.color_mode            = MODE_COLORS_NONE;
-    Snake.speed_min             = 0x48;
-    Snake.speed_max             = 0x2A;
-    Snake.speed                 = 0x39;
-    modes.push_back(Snake);
-    mapModeValueEffect[0x09]    = SNAKE;
-}
-
-struct cm_keyboard_effect CMKeyboardV1Controller::GetEffect(uint8_t effectId)
-{
-    std::vector<uint8_t> data;
-    data.push_back(0x52);
-    data.push_back(0x2C);
-    data.push_back(0x00);
-    data.push_back(0x00);
-    data.push_back(effectId);
-
-    data = SendCommand(data);
-    struct cm_keyboard_effect response;
-
-    response.effectId   = effectId;
-    response.p1         = data[5];
-    response.p2         = data[6];
-    response.p3         = data[7];
-    response.color1     = ToRGBColor(data[10], data[11], data[12]);
-    response.color2     = ToRGBColor(data[13], data[14], data[15]);
-
-    return response;
-}
-
-std::vector<uint8_t> CMKeyboardV1Controller::GetEnabledEffects()
-{
-    std::vector<uint8_t> data;
-
-    data = SendCommand({0x52, 0x29});
-
-    std::vector<uint8_t> effects;
-
-    for(size_t i = 4; data[i] != 0xFF; i++)
-    {
-        effects.push_back(data[i]);
-    }
-
-    return effects;
-}
-
-
-void CMKeyboardV1Controller::SetLEDControl(bool bManual)
-{
-    uint8_t modeId = 0; // firmware
-
-    if(bManual)
-    {
-        modeId = 0x02;  // manual
-    }
-
-    SetControlMode(modeId);
-};
-
-void CMKeyboardV1Controller::SetLeds(std::vector<led> leds, std::vector<RGBColor> colors)
-{
-    SetLEDControl(true);
-
-    RGBColor rgbColorMap[CM_MAX_LEDS];
-    memset(rgbColorMap, 0, sizeof(RGBColor)*CM_MAX_LEDS);
-
-    for(size_t i = 0; i < leds.size(); i++)
-    {
-        rgbColorMap[leds[i].value] = colors[i];
-    }
-
-    RGBColor * pRGBColor = rgbColorMap;
-
-    std::lock_guard<std::mutex> guard(m_mutex);
-
-    for(size_t i = 0; i < 8; i++)
-    {
-        std::vector<uint8_t> data;
-        data.push_back(0xC0);
-        data.push_back(0x02);
-        data.push_back(i*2);
-        data.push_back(0x00);
-
-        for(size_t j = 0; j < 16; j++)
-        {
-            data.push_back(RGBGetRValue(*pRGBColor));
-            data.push_back(RGBGetGValue(*pRGBColor));
-            data.push_back(RGBGetBValue(*pRGBColor));
-
-            ++pRGBColor;
-        }
-
-        SendCommand(data);
-    }
-}
-
-void CMKeyboardV1Controller::SetSingleLED(uint8_t in_led, RGBColor in_color)
-{
-    std::vector<uint8_t> data;
-    data.push_back(0xC0);
-    data.push_back(0x01);
-    data.push_back(0x01);
-    data.push_back(0x00);
-    data.push_back(in_led);
-    data.push_back(RGBGetRValue(in_color));
-    data.push_back(RGBGetGValue(in_color));
-    data.push_back(RGBGetBValue(in_color));
-
-    SendCommand(data);
-}
-
-/*-------------------------------------------------------------------*\
-| Detect the Firmware Version                                         |
-|                                                                     |
-|  Firmware version string is in the format:                          |
-|    <layout>.<minor>.<major>                                         |
-|  Where <layout> is:                                                 |
-|   UNK = 0, ANSI/US = 1, ISO/EU = 2, JP = 3                          |
-|  Examples:                                                          |
-|  1.2.1 = ANSI/US Keyboard (PRO S)                                   |
-|  2.2.1 = ISO/EU Keyboard (PRO L)                                    |
-\*-------------------------------------------------------------------*/
-std::string CMKeyboardV1Controller::_GetFirmwareVersion()
-{
-    std::vector<uint8_t> read;
-
-    SetControlMode(MODE_FIRMWARE);
-    read = SendCommand({0x01, 0x02});
-
-    char cVersionStr[CM_KEYBOARD_WRITE_SIZE];
-
-    for(size_t i = 0; i < read.size(); i++)
-    {
-        cVersionStr[i] = read[i];
-    }
-
-    cVersionStr[CM_KEYBOARD_WRITE_SIZE - 1] = 0;
-
-    std::string sFirmwareVersion;
-
-    sFirmwareVersion = std::string(cVersionStr+4);
-
-    LOG_VERBOSE("[%s] GetFirmwareVersion(): [%s]", m_deviceName.c_str(), sFirmwareVersion.c_str());
-
-    return sFirmwareVersion;
-}
-
-void CMKeyboardV1Controller::Shutdown()
-{
-
-}
-
-KEYBOARD_LAYOUT CMKeyboardV1Controller::GetKeyboardLayout()
-{
-    KEYBOARD_LAYOUT layout = KEYBOARD_LAYOUT_DEFAULT;
-
-    if(m_sFirmwareVersion.empty())
-    {
-        LOG_WARNING("[%s] GetKeyboardLayout() empty firmware string detected. Unable to detect firmware layout. Assuming defaults.", m_deviceName.c_str());
-
-        layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
-        return layout;
-    }
-
-    switch(m_sFirmwareVersion.c_str()[0])
-    {
-        case '0':
-        default:
-        case '1':
-        layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
-        break;
-
-        case '2':
-        layout = KEYBOARD_LAYOUT_ISO_QWERTY;
-        break;
-
-        case '3':
-        layout = KEYBOARD_LAYOUT_JIS;
-        break;
-    }
-
-    return layout;
-}

Controllers/CoolerMasterController/CMKeyboardV1Controller.h

@@ -1,39 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  CMKeyboardV1Controller.h                                           |
-|                                                                     |
-|  Driver for Coolermaster MasterKeys keyboards (V1)                  |
-|                                                                     |
-|  Tam D (too.manyhobbies)      30th Nov 2023                         |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-#include "CMKeyboardAbstractController.h"
-
-class CMKeyboardV1Controller : public CMKeyboardAbstractController
-{
-public:
-    CMKeyboardV1Controller(hid_device* dev_handle, hid_device_info* dev_info);
-    ~CMKeyboardV1Controller();
-
-    /*---------------------------------------------------------*\
-    | Protocol specific funtions to be implmented               |
-    \*---------------------------------------------------------*/
-    void                        SetLeds(std::vector<led> leds, std::vector<RGBColor> colors);
-    void                        SetSingleLED(uint8_t in_led, RGBColor in_color);
-    void                        Initialize();
-    void                        Shutdown();
-    void                        SetLEDControl(bool bManual);
-
-    void                        SetActiveEffect(uint8_t effectId);
-    uint8_t                     GetActiveEffect();
-    void                        SetEffect(uint8_t effectId, uint8_t p1, uint8_t p2, uint8_t p3, RGBColor color1, RGBColor color2);
-    struct cm_keyboard_effect   GetEffect(uint8_t effectId);
-    void                        SetCustomMode();
-    void                        SetMode(mode selectedMode);
-    std::vector<uint8_t>        GetEnabledEffects();
-    void                        InitializeModes(std::vector<mode> &modes);
-    KEYBOARD_LAYOUT             GetKeyboardLayout();
-
-private:
-    std::string                 _GetFirmwareVersion();
-
-};

Controllers/CoolerMasterController/CMKeyboardV2Controller.h

@@ -1,54 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  CMKeyboardV2Controller.h                                           |
-|                                                                     |
-|  Driver for Coolermaster V2                                         |
-|                                                                     |
-|  Tam D (too.manyhobbies)      30th Nov 2023                         |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-#include "CMKeyboardAbstractController.h"
-
-struct stCMKeyboardV2_mode
-{
-    const char      *name;
-    unsigned int    value;
-    unsigned int    speed_min;
-    unsigned int    speed_max;
-    unsigned int    speed;
-    unsigned int    brightness;
-    unsigned int    direction;
-    unsigned int    nColors;
-    unsigned int    color_mode;
-    unsigned int    flags;
-};
-
-class CMKeyboardV2Controller : public CMKeyboardAbstractController
-{
-public:
-    CMKeyboardV2Controller(hid_device* dev_handle, hid_device_info* dev_info);
-    ~CMKeyboardV2Controller();
-
-    /*---------------------------------------------------------*\
-    | Protocol specific funtions to be implmented               |
-    \*---------------------------------------------------------*/
-    void            SetLeds(std::vector<led> leds, std::vector<RGBColor> colors);
-    void            SetSingleLED(uint8_t in_led, RGBColor in_color);
-    void            Initialize();
-    void            Shutdown();
-    void            SetLEDControl(bool bManual);
-    void            SendApplyPacket(uint8_t mode);
-    void            MagicStartupPacket();
-    void            MagicCommand(uint8_t profileId);
-    void            SetCustomMode();
-    void            SetMode(mode selectedMode);
-    void            SetEffect(uint8_t effectId, uint8_t p1, uint8_t p2, uint8_t p3, RGBColor color1, RGBColor color2);
-    void            InitializeModes(std::vector<mode> &modes);
-    KEYBOARD_LAYOUT GetKeyboardLayout();
-
-private:
-    void            _SetEffectMode(uint8_t effectId);
-    void            _UpdateSpeed(mode selectedMode, uint8_t &cSpeed1, uint8_t &cSpeed2);
-    std::string     _GetFirmwareVersion();
-
-    bool            m_bMoreFFs;
-};

Controllers/CoolerMasterController/CMMKController.cpp

@@ -0,0 +1,320 @@
+/*-------------------------------------------------------------------*\
+|  CMMKController.cpp                                                 |
+|                                                                     |
+|  Lukas N (chmod222)          28th Jun 2020                          |
+|  Tam D (too.manyhobbies)     25th Apr 2021                          |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "CMMKController.h"
+
+CMMKController::CMMKController(hid_device* dev, hid_device_info* dev_info)
+{
+    location            =  dev_info->path;
+
+    const int szTemp    = 256;
+    wchar_t tmpName[szTemp];
+
+    hid_get_manufacturer_string(dev, tmpName, szTemp);
+    std::wstring wName  = std::wstring(tmpName);
+    vendor_name         = std::string(wName.begin(), wName.end());
+
+    hid_get_product_string(dev, tmpName, szTemp);
+    wName  = std::wstring(tmpName);
+    device_name         = std::string(wName.begin(), wName.end());
+
+    cmmk_attach_path(&cmmk_handle, dev_info->path, dev_info->product_id, -1);
+
+    char buf[32] = {0};
+    cmmk_get_firmware_version(&cmmk_handle, buf, 32);
+    firmware_version = std::string(buf);
+
+    enum cmmk_product_type kb_type = cmmk_get_device_model(&cmmk_handle);
+
+    switch(kb_type)
+    {
+        case CMMK_PRODUCT_MASTERKEYS_PRO_S:
+        case CMMK_PRODUCT_MASTERKEYS_SK630:
+            kb_size = KEYBOARD_SIZE_TKL;
+            row_count = CMMK_ROWS_MAX - 1;
+            column_count = CMMK_COLS_MAX - 4;
+            break;
+
+        case CMMK_PRODUCT_MASTERKEYS_PRO_L:
+        case CMMK_PRODUCT_MASTERKEYS_SK650:
+            kb_size = KEYBOARD_SIZE_FULL;
+            row_count = CMMK_ROWS_MAX - 1;
+            column_count = CMMK_COLS_MAX;
+            break;
+
+        case CMMK_PRODUCT_MASTERKEYS_MK750:
+        default:
+            kb_size = KEYBOARD_SIZE_FULL;
+            row_count = CMMK_ROWS_MAX;
+            column_count = CMMK_COLS_MAX;
+    }
+
+    /*--------------------------------------------------------------*\
+    | Detect the keyboard version and set the appropriate layout.    |
+    \*--------------------------------------------------------------*/
+
+    switch(firmware_version[0])
+    {
+        case '1':
+            kb_layout_type = KEYBOARD_LAYOUT_ANSI_QWERTY;
+            break;
+
+        /*--------------------------------------------------------------*\
+        | In case we need to handle different versions in the future.    |
+        \*--------------------------------------------------------------*/
+        default:
+            kb_layout_type = KEYBOARD_LAYOUT_ISO_QWERTY;
+            break;
+    }
+
+    /*--------------------------------------------------------------*\
+    | Populate key offsets.                                          |
+    \*--------------------------------------------------------------*/
+    keyboard_layout*    kb_layout;
+    if(KEYBOARD_LAYOUT_ANSI_QWERTY == kb_layout_type)
+    {
+        switch (kb_type)
+        {
+            case CMMK_PRODUCT_MASTERKEYS_PRO_L:
+                kb_layout = &layout_ansi_pro_l;
+                break;
+            case CMMK_PRODUCT_MASTERKEYS_PRO_S:
+                kb_layout = &layout_ansi_pro_s;
+                break;
+            case CMMK_PRODUCT_MASTERKEYS_MK750:
+                kb_layout = &layout_ansi_mk750;
+                break;
+            case CMMK_PRODUCT_MASTERKEYS_SK630:
+                kb_layout = &layout_ansi_sk630;
+                break;
+            case CMMK_PRODUCT_MASTERKEYS_SK650:
+                kb_layout = &layout_ansi_sk650;
+                break;
+
+            default:
+                kb_layout = 0;
+                break;
+        }
+    }
+    else
+    {
+        switch (kb_type)
+        {
+            case CMMK_PRODUCT_MASTERKEYS_PRO_L:
+                kb_layout = &layout_iso_pro_l;
+                break;
+            case CMMK_PRODUCT_MASTERKEYS_PRO_S:
+                kb_layout = &layout_iso_pro_s;
+                break;
+            case CMMK_PRODUCT_MASTERKEYS_MK750:
+                kb_layout = &layout_iso_mk750;
+                break;
+            case CMMK_PRODUCT_MASTERKEYS_SK630:
+                kb_layout = &layout_iso_sk630;
+                break;
+            case CMMK_PRODUCT_MASTERKEYS_SK650:
+                kb_layout = &layout_iso_sk650;
+                break;
+
+            default:
+                kb_layout = 0;
+                break;
+        }
+    }
+
+    std::vector<int> keys_fn, keys_main, keys_num, keys_extra;
+
+    memset(&kb_transform, -1, row_count*column_count);
+
+    int key_idx = 0;
+    if(kb_layout)
+    {
+        for(int row = 0; row < row_count; row++)
+        {
+            for(int col = 0; col < column_count; col++)
+            {
+                int val = (*kb_layout)[row][col];
+
+                if (-1 != val)
+                {
+                    kb_offsets.ansi.push_back(val);
+                    kb_transform[row][col] = key_idx;
+                    key_idx++;
+                }
+            }
+        }
+    }
+}
+
+CMMKController::~CMMKController()
+{
+    cmmk_detach(&cmmk_handle);
+}
+
+std::string CMMKController::GetDeviceName()
+{
+    return device_name;
+}
+
+std::string CMMKController::GetDeviceVendor()
+{
+    return vendor_name;
+}
+
+std::string CMMKController::GetLocation()
+{
+    return location;
+}
+
+std::string CMMKController::GetFirmwareVersion()
+{
+    return firmware_version;
+}
+
+uint8_t CMMKController::GetRowCount()
+{
+    return row_count;
+}
+
+uint8_t CMMKController::GetColumnCount()
+{
+    return column_count;
+}
+
+KEYBOARD_LAYOUT CMMKController::GetLayout()
+{
+    return kb_layout_type;
+}
+
+keyboard_layout * CMMKController::GetTransform()
+{
+    return &kb_transform;
+}
+
+KEYBOARD_SIZE CMMKController::GetSize()
+{
+    return kb_size;
+}
+
+layout_values CMMKController::GetLayoutValues()
+{
+    return kb_offsets;
+}
+
+void CMMKController::SetFirmwareControl()
+{
+    ActivateMode(CMMK_FIRMWARE);
+}
+
+void CMMKController::SetManualControl()
+{
+    ActivateMode(CMMK_MANUAL);
+}
+
+void CMMKController::SetSingle(int row, int col, struct rgb color)
+{
+    cmmk_set_single_key(&cmmk_handle, row, col, &color);
+}
+
+void CMMKController::SetAll(struct cmmk_color_matrix const& colors)
+{
+    cmmk_set_leds(&cmmk_handle, &colors);
+}
+
+void CMMKController::SetAllSingle(struct rgb color)
+{
+    cmmk_set_all_single(&cmmk_handle, &color);
+}
+
+void CMMKController::SetMode(cmmk_effect_fully_lit eff)
+{
+    ActivateEffect(CMMK_EFFECT_FULLY_LIT);
+    cmmk_set_effect_fully_lit(&cmmk_handle, &eff);
+}
+
+void CMMKController::SetMode(cmmk_effect_breathe eff)
+{
+    ActivateEffect(CMMK_EFFECT_BREATHE);
+    cmmk_set_effect_breathe(&cmmk_handle, &eff);
+}
+
+void CMMKController::SetMode(cmmk_effect_cycle eff)
+{
+    ActivateEffect(CMMK_EFFECT_CYCLE);
+    cmmk_set_effect_cycle(&cmmk_handle, &eff);
+}
+
+void CMMKController::SetMode(cmmk_effect_single eff)
+{
+    ActivateEffect(CMMK_EFFECT_SINGLE);
+    cmmk_set_effect_single(&cmmk_handle, &eff);
+}
+
+void CMMKController::SetMode(cmmk_effect_wave eff)
+{
+    ActivateEffect(CMMK_EFFECT_WAVE);
+    cmmk_set_effect_wave(&cmmk_handle, &eff);
+}
+
+void CMMKController::SetMode(cmmk_effect_ripple eff)
+{
+    ActivateEffect(CMMK_EFFECT_RIPPLE);
+    cmmk_set_effect_ripple(&cmmk_handle, &eff);
+}
+
+void CMMKController::SetMode(cmmk_effect_cross eff)
+{
+    ActivateEffect(CMMK_EFFECT_CROSS);
+    cmmk_set_effect_cross(&cmmk_handle, &eff);
+}
+
+void CMMKController::SetMode(cmmk_effect_raindrops eff)
+{
+    ActivateEffect(CMMK_EFFECT_RAINDROPS);
+    cmmk_set_effect_raindrops(&cmmk_handle, &eff);
+}
+
+void CMMKController::SetMode(cmmk_effect_stars eff)
+{
+    ActivateEffect(CMMK_EFFECT_STARS);
+    cmmk_set_effect_stars(&cmmk_handle, &eff);
+}
+
+void CMMKController::SetMode(cmmk_effect_snake eff)
+{
+    ActivateEffect(CMMK_EFFECT_SNAKE);
+    cmmk_set_effect_snake(&cmmk_handle, &eff);
+}
+
+bool CMMKController::PositionValid(int y, int x)
+{
+    return(cmmk_lookup_key_id(&cmmk_handle, y, x) >= 0);
+}
+
+void CMMKController::ActivateMode(int mode)
+{
+    if (current_mode != mode)
+    {
+        cmmk_set_control_mode(&cmmk_handle, mode);
+
+        current_mode = mode;
+        current_effect = -1;
+    }
+}
+
+void CMMKController::ActivateEffect(int effect)
+{
+    ActivateMode(CMMK_EFFECT);
+
+    if (current_effect != effect)
+    {
+        cmmk_set_active_effect(&cmmk_handle, (enum cmmk_effect_id)effect);
+
+        current_effect = effect;
+    }
+}

Controllers/CoolerMasterController/CMMKController.h

@@ -0,0 +1,97 @@
+/*-------------------------------------------------------------------*\
+|  CMMKController.h                                                   |
+|                                                                     |
+|  Driver for Coolermaster MasterKeys keyboards                       |
+|                                                                     |
+|  Lukas N (chmod222)       28th Jun 2020                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include <cstring>
+#include <KeyboardLayoutManager.h>
+#include <hidapi/hidapi.h>
+#include <libcmmk/libcmmk.h>
+
+typedef int16_t keyboard_layout[CMMK_ROWS_MAX][CMMK_COLS_MAX];
+
+/*---------------------------------------------------------*\
+| i'm not thrilled with the include path, but this will     |
+| work for now. fixing this would need to happen in libcmmk |
+\*---------------------------------------------------------*/
+#pragma GCC push
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#include <ansi/pro_s.h>
+#include <ansi/pro_l.h>
+#include <ansi/mk750.h>
+#include <ansi/sk630.h>
+#include <ansi/sk650.h>
+#include <iso/pro_s.h>
+#include <iso/pro_l.h>
+#include <iso/mk750.h>
+#include <iso/sk630.h>
+#include <iso/sk650.h>
+#pragma GCC pop
+
+#pragma once
+
+class CMMKController
+{
+public:
+    CMMKController(hid_device* dev_handle, hid_device_info* dev_info);
+    ~CMMKController();
+
+    std::string         GetDeviceName();
+    std::string         GetDeviceVendor();
+    std::string         GetLocation();
+    std::string         GetFirmwareVersion();
+    uint8_t             GetRowCount();
+    uint8_t             GetColumnCount();
+
+    KEYBOARD_LAYOUT     GetLayout();
+    KEYBOARD_SIZE       GetSize();
+    layout_values       GetLayoutValues();
+    keyboard_layout*    GetTransform();
+
+    void SetFirmwareControl();
+    void SetManualControl();
+
+    void SetSingle(int row, int col, struct rgb color);
+    void SetAll(struct cmmk_color_matrix const& colors);
+    void SetAllSingle(struct rgb color);
+
+    void SetMode(cmmk_effect_fully_lit eff);
+    void SetMode(cmmk_effect_breathe eff);
+    void SetMode(cmmk_effect_cycle eff);
+    void SetMode(cmmk_effect_single eff);
+    void SetMode(cmmk_effect_wave eff);
+    void SetMode(cmmk_effect_ripple eff);
+    void SetMode(cmmk_effect_cross eff);
+    void SetMode(cmmk_effect_raindrops eff);
+    void SetMode(cmmk_effect_stars eff);
+    void SetMode(cmmk_effect_snake eff);
+
+    bool PositionValid(int y, int x);
+
+private:
+    void ActivateMode(int mode);
+    void ActivateEffect(int effect);
+
+    int         current_mode    = -1;
+    int         current_effect  = -1;
+
+    std::string device_name;
+    std::string vendor_name;
+    std::string location;
+    std::string firmware_version;
+
+    KEYBOARD_SIZE       kb_size;
+    KEYBOARD_LAYOUT     kb_layout_type;
+    layout_values       kb_offsets;
+    keyboard_layout     kb_transform;
+    keyboard_layout*    kb_layout;
+
+    uint8_t     row_count;
+    uint8_t     column_count;
+
+    mutable struct cmmk cmmk_handle;
+};

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -17,9 +17,8 @@
 #include "RGBController_CMARGBGen2A1Controller.h"
 #include "RGBController_CMRGBController.h"
 #include "RGBController_CMR6000Controller.h"
+#include "RGBController_CMMKController.h"
 #include "RGBController_CMMonitorController.h"
-#include "RGBController_CMKeyboardController.h"
-
 /*-----------------------------------------------------*\
 | Coolermaster USB vendor ID                            |
 \*-----------------------------------------------------*/
@@ -27,8 +26,13 @@
 
 /*-----------------------------------------------------*\
 | Coolermaster Keyboards                                |
-|   PIDs defined in `CMMKControllerV2.h`                |
 \*-----------------------------------------------------*/
+#define COOLERMASTER_MASTERKEYS_PRO_L_PID           0x003B
+#define COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID     0x0047
+#define COOLERMASTER_MASTERKEYS_PRO_S_PID           0x003C
+#define COOLERMASTER_MASTERKEYS_MK750_PID           0x0067
+#define COOLERMASTER_MASTERKEYS_SK630_PID           0x0089
+#define COOLERMASTER_MASTERKEYS_SK650_PID           0x008D
 
 /*-----------------------------------------------------*\
 | Coolermaster GPUs                                     |
@@ -121,75 +125,16 @@ void DetectCoolerMasterGPU(hid_device_info* info, const std::string&)
     }
 }
 
-void DetectCoolerMasterV1Keyboards(hid_device_info* info, const std::string& name)
+void DetectCoolerMasterKeyboards(hid_device_info* info, const std::string&)
 {
     hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
-        switch(info->product_id)
-        {
-            case COOLERMASTER_KEYBOARD_PRO_L_PID:
-            case COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID:
-            case COOLERMASTER_KEYBOARD_PRO_S_PID:
-            {
-                CMKeyboardV1Controller* controller                 = new CMKeyboardV1Controller(dev, info);
-                controller->SetDeviceName(name);
-                RGBController_CMKeyboardController* rgb_controller = new RGBController_CMKeyboardController(controller);
-                ResourceManager::get()->RegisterRGBController(rgb_controller);
-            }
-            break;
-
-            default:
-
-                LOG_DEBUG("[%s] Controller not created as the product ID %04X is missing from detector switch", name.c_str(), info->product_id);
-            break;
-        }
-    }
-}
-
-void DetectCoolerMasterV2Keyboards(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        switch(info->product_id)
-        {
-            case COOLERMASTER_KEYBOARD_PRO_L_PID:
-            case COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID:
-            case COOLERMASTER_KEYBOARD_PRO_S_PID:
-            {
-                CMKeyboardV1Controller* controller                 = new CMKeyboardV1Controller(dev, info);
-                controller->SetDeviceName(name);
-                RGBController_CMKeyboardController* rgb_controller = new RGBController_CMKeyboardController(controller);
-                ResourceManager::get()->RegisterRGBController(rgb_controller);
-            }
-            break;
-
-            case COOLERMASTER_KEYBOARD_SK622B_PID:
-            case COOLERMASTER_KEYBOARD_SK622W_PID:
-            case COOLERMASTER_KEYBOARD_SK630_PID:
-            case COOLERMASTER_KEYBOARD_SK650_PID:
-            case COOLERMASTER_KEYBOARD_SK652_PID:
-            case COOLERMASTER_KEYBOARD_SK653_PID:
-            case COOLERMASTER_KEYBOARD_CK530_PID:
-            case COOLERMASTER_KEYBOARD_CK530_V2_PID:
-            case COOLERMASTER_KEYBOARD_CK550_V2_PID:
-            case COOLERMASTER_KEYBOARD_CK552_V2_PID:
-            case COOLERMASTER_KEYBOARD_MK730_PID:
-            case COOLERMASTER_KEYBOARD_MK750_PID:
-            {
-                CMKeyboardV2Controller* controller                 = new CMKeyboardV2Controller(dev, info);
-                controller->SetDeviceName(name);
-                RGBController_CMKeyboardController* rgb_controller = new RGBController_CMKeyboardController(controller);
-                ResourceManager::get()->RegisterRGBController(rgb_controller);
-            }
-
-            default:
-                LOG_DEBUG("[%s] Controller not created as the product ID %04X is missing from detector switch", name.c_str(), info->product_id);
-            break;
-        }
+        CMMKController*               controller     = new CMMKController(dev, info);
+        RGBController_CMMKController* rgb_controller = new RGBController_CMMKController(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
 
@@ -282,24 +227,13 @@ void DetectCoolerMasterMonitor(hid_device_info* info, const std::string& name)
 
 /*-----------------------------------------------------*\
 | Coolermaster Keyboards                                |
-|   PIDs defined in `CMKeyboardDevices.h`               |
 \*-----------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro S",         DetectCoolerMasterV1Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_PRO_S_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L",         DetectCoolerMasterV1Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_PRO_L_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L White",   DetectCoolerMasterV1Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID,    1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MK850",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_MK850_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master SK622 White",              DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK622W_PID,         1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master SK622 Black",              DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK622B_PID,         1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master SK630",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK630_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master SK650",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK650_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master SK652",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK652_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master SK653",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK653_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MK730",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_MK730_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MK750",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_MK750_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master CK530",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_CK530_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master CK530 V2",                 DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_CK530_V2_PID,       1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master CK550 V2",                 DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_CK550_V2_PID,       1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master CK550 V1 / CK552",         DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_CK552_V2_PID,       1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L White",   DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID,    1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro S",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_S_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MK750",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_MK750_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master SK630",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_SK630_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master SK650",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_SK650_PID,          1,      0xFF00, 1);
 
 /*-----------------------------------------------------*\
 | Coolermaster LEDstrip controllers                     |

Controllers/CoolerMasterController/RGBController_CMKeyboardController.cpp

@@ -1,182 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_CMKeyboardController.cpp                             |
-|                                                                     |
-|  Controller for Coolermaster keyboards                              |
-|                                                                     |
-|  Tam D (too.manyhobbies)     30th Nov 2023                          |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-#include "RGBController_CMKeyboardController.h"
-#include "CMKeyboardDevices.h"
-
-/**------------------------------------------------------------------*\
-    @name Coolermaster Masterkeys Keyboards
-    @category Keyboard
-    @type USB
-    @save :robot:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectCoolerMasterKeyboards
-    @comment
-    In CMKeyboardV1Controller brightness control not supported.
-    Supported effects differ between CMKeyboardV1Controller and
-    CMKeyboardV2Controller.
-\*-------------------------------------------------------------------*/
-RGBController_CMKeyboardController::RGBController_CMKeyboardController(CMKeyboardAbstractController* pController)
-{
-    m_pController       = pController;
-    vendor              = m_pController->GetDeviceVendor();
-    type                = DEVICE_TYPE_KEYBOARD;
-    description         = "Cooler Master Keyboard Device";
-    version             = m_pController->GetFirmwareVersion();
-
-    /*----------------------------------------------------------------*\
-    | Coolermaster uses the name field to store the serial number in   |
-    | many of their keyboards.                                         |
-    \*----------------------------------------------------------------*/
-    serial              = m_pController->GetDeviceSerial();
-    location            = m_pController->GetLocation();
-    m_keyboardLayout    = m_pController->GetKeyboardLayout();
-    name                = m_pController->GetDeviceName();
-
-    m_pController->InitializeModes(modes);
-
-    SetupZones();
-}
-
-RGBController_CMKeyboardController::~RGBController_CMKeyboardController()
-{
-    for(size_t i = 0; i < m_pUnknownKeyNames.size(); i++)
-    {
-        if(m_pUnknownKeyNames[i])
-        {
-            delete(m_pUnknownKeyNames[i]);
-        }
-    }
-}
-
-#define COOLERMASTER_ZONES_MAX 1
-void RGBController_CMKeyboardController::SetupZones()
-{
-    std::string physical_size;
-    unsigned int max_led_value              = 0;
-    const cm_kb_device* coolermaster        = m_pController->GetDeviceData();
-
-    /*---------------------------------------------------------*\
-    | Fill in zones from the device data                        |
-    \*---------------------------------------------------------*/
-    for(size_t i = 0; i < COOLERMASTER_ZONES_MAX; i++)
-    {
-        if(coolermaster->zones[i] == NULL)
-        {
-            break;
-        }
-        else
-        {
-            zone new_zone;
-
-            new_zone.name                   = coolermaster->zones[i]->name;
-            new_zone.type                   = coolermaster->zones[i]->type;
-
-            if(new_zone.type == ZONE_TYPE_MATRIX)
-            {
-                KeyboardLayoutManager new_kb(m_keyboardLayout, coolermaster->layout_new->base_size, coolermaster->layout_new->key_values);
-
-                matrix_map_type * new_map   = new matrix_map_type;
-                new_zone.matrix_map         = new_map;
-
-                new_map->map                = new unsigned int[new_map->height * new_map->width];
-
-                if(coolermaster->layout_new->base_size != KEYBOARD_SIZE_EMPTY)
-                {
-                    /*---------------------------------------------------------*\
-                    | Minor adjustments to keyboard layout                      |
-                    \*---------------------------------------------------------*/
-                    keyboard_keymap_overlay_values* temp    = coolermaster->layout_new;
-                    new_kb.ChangeKeys(*temp);
-
-                    new_map->height             = new_kb.GetRowCount();
-                    new_map->width              = new_kb.GetColumnCount();
-
-                    /*---------------------------------------------------------*\
-                    | Matrix map still uses declared zone rows and columns      |
-                    |   as the packet structure depends on the matrix map       |
-                    \*---------------------------------------------------------*/
-                    new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT, new_map->height, new_map->width);
-
-                    /*---------------------------------------------------------*\
-                    | Create LEDs for the Matrix zone                           |
-                    |   Place keys in the layout to populate the matrix         |
-                    \*---------------------------------------------------------*/
-                    new_zone.leds_count                     = new_kb.GetKeyCount();
-                    LOG_DEBUG("[%s] Created KB matrix with %d rows and %d columns containing %d keys",
-                              m_pController->GetDeviceName().c_str(), new_kb.GetRowCount(), new_kb.GetColumnCount(), new_zone.leds_count);
-
-                    for(unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
-                    {
-                        led new_led;
-
-                        new_led.name                = new_kb.GetKeyNameAt(led_idx);
-                        new_led.value               = new_kb.GetKeyValueAt(led_idx);
-                        max_led_value               = std::max(max_led_value, new_led.value);
-                        leds.push_back(new_led);
-                    }
-                }
-
-                /*---------------------------------------------------------*\
-                | Add 1 the max_led_value to account for the 0th index      |
-                \*---------------------------------------------------------*/
-                max_led_value++;
-            }
-
-            /*---------------------------------------------------------*\
-            | name is not set yet so description is used instead        |
-            \*---------------------------------------------------------*/
-            LOG_DEBUG("[%s] Creating a %s zone: %s with %d LEDs", description.c_str(),
-                      ((new_zone.type == ZONE_TYPE_MATRIX) ? "matrix": "linear"),
-                      new_zone.name.c_str(), new_zone.leds_count);
-            new_zone.leds_min                   = new_zone.leds_count;
-            new_zone.leds_max                   = new_zone.leds_count;
-            zones.push_back(new_zone);
-
-        }
-    }
-
-
-    SetupColors();
-}
-
-void RGBController_CMKeyboardController::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-}
-
-void RGBController_CMKeyboardController::DeviceUpdateLEDs()
-{
-    m_pController->SetLeds(leds, colors);
-}
-
-void RGBController_CMKeyboardController::UpdateSingleLED(int led, RGBColor color)
-{
-    uint8_t key_value = m_pLayoutManager->GetKeyValueAt(led);
-    m_pController->SetSingleLED(key_value, color);
-}
-
-void RGBController_CMKeyboardController::UpdateSingleLED(int led)
-{
-    m_pController->SetSingleLED(led, colors[led]);
-}
-
-void RGBController_CMKeyboardController::UpdateZoneLEDs(int /*zone_idx*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_CMKeyboardController::DeviceUpdateMode()
-{
-    m_pController->SetMode(modes[active_mode]);
-}
-
-void RGBController_CMKeyboardController::SetCustomMode()
-{
-
-}

Controllers/CoolerMasterController/RGBController_CMKeyboardController.h

@@ -1,41 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_CMKeyboardController.h                               |
-|                                                                     |
-|  Controller for Coolermaster keyboards                              |
-|                                                                     |
-|  Tam D (too.manyhobbies)     30th Nov 2023                          |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-#pragma once
-
-#include "RGBController.h"
-#include "CMKeyboardAbstractController.h"
-#include "CMKeyboardV1Controller.h"
-#include "CMKeyboardV2Controller.h"
-#include "CMKeyboardDevices.h"
-
-class RGBController_CMKeyboardController : public RGBController
-{
-public:
-    RGBController_CMKeyboardController(CMKeyboardAbstractController* pController);
-    ~RGBController_CMKeyboardController();
-
-    void SetupZones();
-    void ResizeZone(int zone, int new_size);
-
-    void DeviceUpdateLEDs();
-    void UpdateSingleLED(int led, RGBColor color);
-    void UpdateSingleLED(int led);
-    void UpdateZoneLEDs(int zone_idx);
-
-    void SetCustomMode();
-    void DeviceUpdateMode();
-
-private:
-    CMKeyboardAbstractController*   m_pController;;
-    KeyboardLayoutManager*          m_pLayoutManager;
-    KEYBOARD_LAYOUT                 m_keyboardLayout;
-    KEYBOARD_SIZE                   m_keyboardSize;
-    layout_values                   m_layoutValues;
-    std::vector<char *>             m_pUnknownKeyNames;
-};

Controllers/CoolerMasterController/RGBController_CMMKController.cpp

@@ -0,0 +1,503 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMMKController.cpp                                   |
+|                                                                     |
+|  Driver for Coolermaster MasterKeys keyboards                       |
+|                                                                     |
+|  Lukas N (chmod222)          28th Jun 2020                          |
+|  Tam D (too.manyhobbies)     25th Apr 2021                          |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBController_CMMKController.h"
+
+#include <sstream>
+
+using namespace std::chrono_literals;
+
+#define CMMK_SPEED_MIN          CMMK_SPEED0
+#define CMMK_SPEED_MID          CMMK_SPEED2
+#define CMMK_SPEED_MAX          CMMK_SPEED4
+#define CMMK_MODE_FIRMWARE      0xFF
+#define CMMK_MODE_MANUAL        0x7F
+
+/**------------------------------------------------------------------*\
+    @name Coolermaster Masterkeys Keyboards
+    @category Keyboard
+    @type USB
+    @save :robot:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectCoolerMasterKeyboards
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_CMMKController::RGBController_CMMKController(CMMKController* controller_ptr)
+{
+    controller                  = controller_ptr;
+    name                        = controller->GetDeviceName();
+    vendor                      = controller->GetDeviceVendor();
+    type                        = DEVICE_TYPE_KEYBOARD;
+    description                 = "Cooler Master MasterKeys Device";
+    version                     = controller->GetFirmwareVersion();
+    serial                      = "";
+    location                    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = CMMK_MODE_MANUAL;
+    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                = CMMK_EFFECT_FULLY_LIT;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = CMMK_EFFECT_BREATHE;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed_min         = CMMK_SPEED_MIN;
+    Breathing.speed_max         = CMMK_SPEED_MAX;
+    Breathing.speed             = CMMK_SPEED_MID;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
+    Breathing.colors.resize(1);
+    modes.push_back(Breathing);
+
+    mode Cycle;
+    Cycle.name                  = "Spectrum Cycle";
+    Cycle.value                 = CMMK_EFFECT_CYCLE;
+    Cycle.flags                 = MODE_FLAG_HAS_SPEED;
+    Cycle.color_mode            = MODE_COLORS_NONE;
+    Cycle.speed_min             = 2 * CMMK_SPEED_MIN; //Spectrum Cycle uses a unique speed range
+    Cycle.speed_max             = 2 * CMMK_SPEED_MAX;
+    Cycle.speed                 = 2 * CMMK_SPEED_MID;
+    modes.push_back(Cycle);
+
+    mode Reactive;
+    Reactive.name               = "Reactive";
+    Reactive.value              = CMMK_EFFECT_SINGLE;
+    Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Reactive.speed_min          = CMMK_SPEED_MIN;
+    Reactive.speed_max          = CMMK_SPEED_MAX;
+    Reactive.speed              = CMMK_SPEED_MID;
+    Reactive.colors_min         = 2;
+    Reactive.colors_max         = 2;
+    Reactive.colors.resize(2);
+    modes.push_back(Reactive);
+
+    mode Wave;
+    Wave.name                   = "Rainbow Wave";
+    Wave.value                  = CMMK_EFFECT_WAVE;
+    Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Wave.speed_min              = CMMK_SPEED_MIN;
+    Wave.speed_max              = CMMK_SPEED_MAX;
+    Wave.speed                  = CMMK_SPEED_MID;
+    Wave.direction              = MODE_DIRECTION_LEFT;
+    Wave.colors_min             = 1;
+    Wave.colors_max             = 1;
+    Wave.colors.resize(1);
+    modes.push_back(Wave);
+
+    mode Ripple;
+    Ripple.name                 = "Ripple Effect";
+    Ripple.value                = CMMK_EFFECT_RIPPLE;
+    Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
+    Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Ripple.speed_min            = CMMK_SPEED_MIN;
+    Ripple.speed_max            = CMMK_SPEED_MAX;
+    Ripple.speed                = CMMK_SPEED_MID;
+    Ripple.colors_min           = 2;
+    Ripple.colors_max           = 2;
+    Ripple.colors.resize(2);
+    modes.push_back(Ripple);
+
+    mode Cross;
+    Cross.name                  = "Cross";
+    Cross.value                 = CMMK_EFFECT_CROSS;
+    Cross.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Cross.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Cross.speed_min             = CMMK_SPEED_MIN;
+    Cross.speed_max             = CMMK_SPEED_MAX;
+    Cross.speed                 = CMMK_SPEED_MID;
+    Cross.colors_min            = 2;
+    Cross.colors_max            = 2;
+    Cross.colors.resize(2);
+    modes.push_back(Cross);
+
+    mode Raindrops;
+    Raindrops.name              = "Raindrops";
+    Raindrops.value             = CMMK_EFFECT_RAINDROPS;
+    Raindrops.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Raindrops.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Raindrops.speed_min         = CMMK_SPEED_MIN;
+    Raindrops.speed_max         = CMMK_SPEED_MAX;
+    Raindrops.speed             = CMMK_SPEED_MID;
+    Raindrops.colors_min        = 2;
+    Raindrops.colors_max        = 2;
+    Raindrops.colors.resize(2);
+    modes.push_back(Raindrops);
+
+    mode Stars;
+    Stars.name                  = "Starfield";
+    Stars.value                 = CMMK_EFFECT_STARS;
+    Stars.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Stars.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Stars.speed_min             = CMMK_SPEED_MIN;
+    Stars.speed_max             = CMMK_SPEED_MAX;
+    Stars.speed                 = CMMK_SPEED_MID;
+    Stars.colors_min            = 2;
+    Stars.colors_max = 2;
+    Stars.colors.resize(2);
+    modes.push_back(Stars);
+
+    mode Snake;
+    Snake.name                  = "Snake";
+    Snake.value                 = CMMK_EFFECT_SNAKE;
+    Snake.flags                 = MODE_FLAG_HAS_SPEED;
+    Snake.color_mode            = MODE_COLORS_NONE;
+    Snake.speed_min             = CMMK_SPEED_MIN;
+    Snake.speed_max             = CMMK_SPEED_MAX;
+    Snake.speed                 = CMMK_SPEED_MID;
+    modes.push_back(Snake);
+
+    mode FirmwareControl;
+    FirmwareControl.name        = "Firmware Controlled";
+    FirmwareControl.value       = 0xFF;
+    FirmwareControl.flags       = 0;
+    FirmwareControl.color_mode  = MODE_COLORS_NONE;
+    modes.push_back(FirmwareControl);
+
+    SetupZones();
+}
+
+RGBController_CMMKController::~RGBController_CMMKController()
+{
+    delete controller;
+}
+
+void RGBController_CMMKController::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Create the keyboard zone usiung Keyboard Layout Manager   |
+    \*---------------------------------------------------------*/
+    zone new_zone;
+    new_zone.name           = ZONE_EN_KEYBOARD;
+    new_zone.type           = ZONE_TYPE_MATRIX;
+
+    layoutManager = new KeyboardLayoutManager(controller->GetLayout(), controller->GetSize(), controller->GetLayoutValues());
+
+    matrix_map_type * new_map   = new matrix_map_type;
+    new_zone.matrix_map         = new_map;
+    new_zone.matrix_map->height = layoutManager->GetRowCount();
+    new_zone.matrix_map->width  = layoutManager->GetColumnCount();
+
+    new_zone.matrix_map->map    = new unsigned int[new_map->height * new_map->width];
+    new_zone.leds_count         = layoutManager->GetKeyCount();
+    new_zone.leds_min           = new_zone.leds_count;
+    new_zone.leds_max           = new_zone.leds_count;
+
+    /*---------------------------------------------------------*\
+    | Matrix map still uses declared zone rows and columns      |
+    |   as the packet structure depends on the matrix map       |
+    \*---------------------------------------------------------*/
+    layoutManager->GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT, new_map->height, new_map->width);
+
+    /*---------------------------------------------------------*\
+    | Create LEDs for the Matrix zone                           |
+    |   Place keys in the layout to populate the matrix         |
+    \*---------------------------------------------------------*/
+    for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
+    {
+        led new_led;
+
+        new_led.name                = layoutManager->GetKeyNameAt(led_idx);
+        new_led.value               = layoutManager->GetKeyValueAt(led_idx);
+        leds.push_back(new_led);
+    }
+
+    zones.push_back(new_zone);
+
+    SetupColors();
+}
+
+void RGBController_CMMKController::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+struct rgb map_to_cmmk_rgb(RGBColor input)
+{
+    return rgb
+    {
+        (uint8_t)RGBGetRValue(input),
+        (uint8_t)RGBGetGValue(input),
+        (uint8_t)RGBGetBValue(input)
+    };
+}
+
+enum cmmk_wave_direction map_to_cmmk_dir(int input)
+{
+    switch(input)
+    {
+        case MODE_DIRECTION_LEFT:
+            return CMMK_RIGHT_TO_LEFT;
+
+        case MODE_DIRECTION_RIGHT:
+            return CMMK_LEFT_TO_RIGHT;
+
+        case MODE_DIRECTION_UP:
+            return CMMK_FRONT_TO_BACK;
+
+        case MODE_DIRECTION_DOWN:
+            return CMMK_BACK_TO_FRONT;
+
+        default:
+            return CMMK_RIGHT_TO_LEFT;
+    }
+}
+
+
+void RGBController_CMMKController::copy_buffers(std::vector<RGBColor> &in_colors, struct cmmk_color_matrix& mat, std::atomic<bool>& dirty)
+{
+    dirty.store(false);
+
+    keyboard_layout * transform = controller->GetTransform();
+
+    if(0 == transform)
+    {
+        return;
+    }
+
+    for(int row = 0; row < controller->GetRowCount(); row++)
+    {
+        for(int col = 0; col < controller->GetColumnCount(); col++)
+        {
+            int key_idx = (*transform)[row][col];
+
+            if(-1 == key_idx)
+            {
+                continue;
+            }
+
+            struct rgb color = map_to_cmmk_rgb(in_colors[key_idx]);
+
+            dirty.store(true);
+            mat.data[row][col] = color;
+        }
+    }
+}
+
+void RGBController_CMMKController::DeviceUpdateLEDs()
+{
+    copy_buffers(colors, current_matrix, dirty);
+
+    if(force_update.load() || dirty.load())
+    {
+        controller->SetAll(current_matrix);
+
+        force_update.store(false);
+    }
+}
+
+void RGBController_CMMKController::UpdateZoneLEDs(int zone_idx)
+{
+    /*---------------------------------------------------------*\
+    | This device only supports a single zone, as a result we  |
+    | update all LEDs.                                         |
+    \*---------------------------------------------------------*/
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CMMKController::UpdateSingleLED(int led_idx, RGBColor color)
+{
+    keyboard_layout * transform = controller->GetTransform();
+    led selected_led = leds[led_idx];
+
+    if(0 == transform)
+    {
+        return;
+    }
+
+    // this is really expensive
+    for(int row = 0; row < controller->GetRowCount(); row++)
+    {
+        for(int col = 0; col < controller->GetColumnCount(); col++)
+        {
+            int val = (*transform)[row][col];
+
+            if(val != (int)selected_led.value)
+            {
+                continue;
+            }
+
+            controller->SetSingle(row, col, map_to_cmmk_rgb(color));
+            dirty.store(false);
+
+            return;
+        }
+    }
+
+}
+
+void RGBController_CMMKController::UpdateSingleLED(int led_idx)
+{
+    UpdateSingleLED(led_idx, colors[led_idx]);
+}
+
+void RGBController_CMMKController::SetCustomMode()
+{
+    active_mode = 1;
+}
+
+void RGBController_CMMKController::DeviceUpdateMode()
+{
+    force_update.store(true);
+
+    switch(modes[active_mode].value)
+    {
+        case CMMK_MODE_FIRMWARE:
+            controller->SetFirmwareControl();
+            break;
+
+        case CMMK_MODE_MANUAL:
+            controller->SetManualControl();
+            break;
+
+        case CMMK_EFFECT_FULLY_LIT:
+            {
+                cmmk_effect_fully_lit fully_lit_effect;
+
+                fully_lit_effect.color  = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+
+                controller->SetMode(fully_lit_effect);
+            }
+            break;
+
+        case CMMK_EFFECT_BREATHE:
+            {
+                cmmk_effect_breathe breathe_effect;
+
+                breathe_effect.speed    = (uint8_t)modes[active_mode].speed;
+                breathe_effect.color    = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+
+                controller->SetMode(breathe_effect);
+            }
+            break;
+
+        case CMMK_EFFECT_CYCLE:
+            {
+                cmmk_effect_cycle cycle_effect;
+
+                cycle_effect.speed  = (uint8_t)modes[active_mode].speed;
+
+                controller->SetMode(cycle_effect);
+            }
+            break;
+
+        case CMMK_EFFECT_SINGLE:
+            {
+                cmmk_effect_single single_effect;
+
+                single_effect.speed     = (uint8_t)modes[active_mode].speed;
+                single_effect.active    = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+                single_effect.rest      = map_to_cmmk_rgb(modes[active_mode].colors[1]);
+
+                controller->SetMode(single_effect);
+            }
+            break;
+
+        case CMMK_EFFECT_WAVE:
+            {
+                cmmk_effect_wave wave_effect;
+
+                wave_effect.speed       = (uint8_t)modes[active_mode].speed;
+                wave_effect.direction   = map_to_cmmk_dir(modes[active_mode].direction);
+                wave_effect.start       = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+
+                controller->SetMode(wave_effect);
+            }
+            break;
+
+        case CMMK_EFFECT_RIPPLE:
+            {
+                cmmk_effect_ripple ripple_effect;
+
+                ripple_effect.speed             = (uint8_t)modes[active_mode].speed;
+                ripple_effect.active            = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+                ripple_effect.rest              = map_to_cmmk_rgb(modes[active_mode].colors[1]);
+
+                if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
+                {
+                    ripple_effect.ripple_type   = CMMK_RIPPLE_RANDOM_COLOR;
+                }
+                else
+                {
+                    ripple_effect.ripple_type   = CMMK_RIPPLE_GIVEN_COLOR;
+                }
+
+                controller->SetMode(ripple_effect);
+            }
+            break;
+
+        case CMMK_EFFECT_CROSS:
+            {
+                cmmk_effect_cross cross_effect;
+
+                cross_effect.speed  = (uint8_t)modes[active_mode].speed;
+                cross_effect.active = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+                cross_effect.rest   = map_to_cmmk_rgb(modes[active_mode].colors[1]);
+
+                controller->SetMode(cross_effect);
+            }
+            break;
+
+        case CMMK_EFFECT_RAINDROPS:
+            {
+                cmmk_effect_raindrops raindrops_effect;
+
+                raindrops_effect.speed      = (uint8_t)modes[active_mode].speed;
+                raindrops_effect.interval   = CMMK_SPEED_MID;
+                raindrops_effect.active     = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+                raindrops_effect.rest       = map_to_cmmk_rgb(modes[active_mode].colors[1]);
+
+                controller->SetMode(raindrops_effect);
+            }
+            break;
+
+        case CMMK_EFFECT_STARS:
+            {
+                cmmk_effect_stars stars_effect;
+
+                stars_effect.speed      = (uint8_t)modes[active_mode].speed;
+                stars_effect.interval   = CMMK_SPEED_MID;
+                stars_effect.active     = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+                stars_effect.rest       = map_to_cmmk_rgb(modes[active_mode].colors[1]);
+
+                controller->SetMode(stars_effect);
+            }
+            break;
+
+        case CMMK_EFFECT_SNAKE:
+            {
+                cmmk_effect_snake snake_effect;
+
+                snake_effect.speed = (uint8_t)modes[active_mode].speed;
+
+                controller->SetMode(snake_effect);
+            }
+            break;
+    }
+}

Controllers/CoolerMasterController/RGBController_CMMKController.h

@@ -0,0 +1,46 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMMKController.h                                     |
+|                                                                     |
+|  Driver for Coolermaster MasterKeys keyboards                       |
+|                                                                     |
+|  Lukas N (chmod222)          28th Jun 2020                          |
+|  Tam D (too.manyhobbies)     25th Apr 2021                          |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+
+#include <cstring>
+#include "RGBController.h"
+#include "CMMKController.h"
+#include "RGBControllerKeyNames.h"
+#include "KeyboardLayoutManager.h"
+
+class RGBController_CMMKController : public RGBController
+{
+public:
+    RGBController_CMMKController(CMMKController* controller_ptr);
+    ~RGBController_CMMKController();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+    void UpdateSingleLED(int led, RGBColor color);
+    void UpdateSingleLED(int led);
+    void UpdateZoneLEDs(int zone_idx);
+
+    void SetCustomMode();
+    void DeviceUpdateMode();
+
+private:
+    void copy_buffers(std::vector<RGBColor> &in_colors, struct cmmk_color_matrix& mat, std::atomic<bool>& dirty);
+
+    CMMKController*             controller;
+    KeyboardLayoutManager*      layoutManager;
+
+    struct cmmk_color_matrix current_matrix;
+
+    std::atomic<bool>           dirty;
+    std::atomic<bool>           force_update;
+};

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.cpp

@@ -7,7 +7,6 @@
 \*---------------------------------------------------------*/
 
 #include "CorsairCommanderCoreController.h"
-#include "CorsairDeviceGuard.h"
 
 #include <cstring>
 #include <iomanip>
@@ -24,7 +23,9 @@ CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_h
     packet_size             = CORSAIR_COMMANDER_CORE_PACKET_SIZE_V2;
     command_res_size        = packet_size - 4;
     this->pid               = pid;
-    guard_manager_ptr           = new DeviceGuardManager(new CorsairDeviceGuard());
+#ifdef _WIN32
+    global_corsair_access_handle = CreateMutexA(NULL, FALSE, GLOBAL_CORSAIR_MUTEX_NAME);
+#endif
 
     /*-----------------------------------------------------*\
     | Initialize controller                                 |
@@ -42,6 +43,12 @@ CorsairCommanderCoreController::~CorsairCommanderCoreController()
     /*-----------------------------------------------------*\
     | Close keepalive thread                                |
     \*-----------------------------------------------------*/
+#ifdef _WIN32
+    if(global_corsair_access_handle != NULL)
+    {
+        CloseHandle(global_corsair_access_handle);
+    }
+#endif
     keepalive_thread_run = 0;
     keepalive_thread->join();
     delete keepalive_thread;
@@ -50,7 +57,6 @@ CorsairCommanderCoreController::~CorsairCommanderCoreController()
     | Close HID device                                      |
     \*-----------------------------------------------------*/
     hid_close(dev);
-    delete guard_manager_ptr;
 }
 
 void CorsairCommanderCoreController::InitController()
@@ -98,24 +104,6 @@ std::string CorsairCommanderCoreController::GetLocationString()
     return("HID: " + location);
 }
 
-std::vector<unsigned short int> CorsairCommanderCoreController::GetLedCounts()
-{
-    /*-----------------------------------------------------*\
-    | Get the LED count per device                          |
-    \*-----------------------------------------------------*/
-    std::vector<unsigned short int> led_counts;
-    unsigned char endpoint[2] = {0x20, 0x00};
-    unsigned char* res = new unsigned char[command_res_size];
-    ReadData(endpoint, res);
-    for(int i = 0; i < res[2]; i++)
-    {
-        led_counts.push_back(res[i*4+6] << 8 | res[i*4+5]);
-    }
-    delete[] res;
-
-    return  led_counts;
-}
-
 void CorsairCommanderCoreController::KeepaliveThread()
 {
     while(keepalive_thread_run.load())
@@ -165,6 +153,13 @@ void CorsairCommanderCoreController::SendCommand(unsigned char command[2], unsig
     \*---------------------------------------------------------*/
     unsigned char* buf = new unsigned char[packet_size];
 
+#ifdef _WIN32
+    if(global_corsair_access_handle != NULL)
+    {
+        WaitForSingleObject(global_corsair_access_handle, INFINITE);
+    }
+#endif
+
     memset(buf, 0, packet_size);
     buf[0] = 0x00;
     buf[1] = 0x08;
@@ -175,28 +170,25 @@ void CorsairCommanderCoreController::SendCommand(unsigned char command[2], unsig
         memcpy(&buf[4], data, data_len);
     }
 
-    /*---------------------------------------------------------*\
-    | HID I/O start                                             |
-    \*---------------------------------------------------------*/
+    hid_write(dev, buf, packet_size);
+    do
     {
-        DeviceGuardLock _ = guard_manager_ptr->AwaitExclusiveAccess();
-
-        hid_write(dev, buf, packet_size);
-        do
-        {
-            hid_read(dev, buf, packet_size);
-        }
-        while (buf[0] != 0x00);
+        hid_read(dev, buf, packet_size);
     }
-    /*---------------------------------------------------------*\
-    | HID I/O end (lock released)                               |
-    \*---------------------------------------------------------*/
+    while (buf[0] != 0x00);
 
     if(res != NULL)
     {
         memcpy(res, &buf[3], command_res_size);
     }
 
+#ifdef _WIN32
+    if(global_corsair_access_handle != NULL)
+    {
+        ReleaseMutex(global_corsair_access_handle);
+    }
+#endif
+
     delete[] buf;
 }
 
@@ -209,9 +201,17 @@ void CorsairCommanderCoreController::WriteData(unsigned char endpoint[2], unsign
     /*---------------------------------------------------------*\
     | Open endpoint                                             |
     \*---------------------------------------------------------*/
-    unsigned char command[2] = {0x0D, 0x00};
+#ifdef _WIN32
+    if(global_corsair_access_handle != NULL)
+    {
+        WaitForSingleObject(global_corsair_access_handle, INFINITE);
+    }
+#endif
+
+    unsigned char command[2] = {0x0d, 0x00};
     SendCommand(command, endpoint, 2, NULL);
 
+
     /*---------------------------------------------------------*\
     | Write data                                                |
     \*---------------------------------------------------------*/
@@ -271,35 +271,13 @@ void CorsairCommanderCoreController::WriteData(unsigned char endpoint[2], unsign
     command[0] = 0x05;
     command[1] = 0x01;
     SendCommand(command, NULL, 0, NULL);
-}
 
-void CorsairCommanderCoreController::ReadData(unsigned char endpoint[2], unsigned char data[])
-{
-    /*---------------------------------------------------------*\
-    | Private function to read data from an endpoint            |
-    | Note: Right now we only know how to read the first packet.|
-    |       It is not currently know how to read more.          |
-    \*---------------------------------------------------------*/
-
-    /*---------------------------------------------------------*\
-    | Open endpoint                                             |
-    \*---------------------------------------------------------*/
-    unsigned char command[2] = {0x0D, 0x00};
-    SendCommand(command, endpoint, 2, NULL);
-
-    /*---------------------------------------------------------*\
-    | Read data                                                 |
-    \*---------------------------------------------------------*/
-    command[0] = 0x08;
-    command[1] = 0x00;
-    SendCommand(command, NULL, 0, data);
-
-    /*---------------------------------------------------------*\
-    | Close endpoint                                            |
-    \*---------------------------------------------------------*/
-    command[0] = 0x05;
-    command[1] = 0x01;
-    SendCommand(command, NULL, 0, NULL);
+#ifdef _WIN32
+    if(global_corsair_access_handle != NULL)
+    {
+        ReleaseMutex(global_corsair_access_handle);
+    }
+#endif
 }
 
 void CorsairCommanderCoreController::SetDirectColor
@@ -329,17 +307,24 @@ void CorsairCommanderCoreController::SetDirectColor
                 usb_buf[packet_offset]   = RGBGetRValue(colors[i]);
                 usb_buf[packet_offset+1] = RGBGetGValue(colors[i]);
                 usb_buf[packet_offset+2] = RGBGetBValue(colors[i]);
+
                 packet_offset += 3;
             }
 
             led_idx = led_idx + zones[zone_idx].leds_count;
 
-
+            /*-------------------------------------------------*\
+            | Move offset for pump zone with less than 29 LEDs  |
+            \*-------------------------------------------------*/
+            if(zone_idx == 0)
+            {
+                packet_offset += 3 * (29 - zones[zone_idx].leds_count);
+            }
+            else
+            {
             /*-------------------------------------------------*\
             | Move offset for fans with less than 34 LEDs       |
             \*-------------------------------------------------*/
-            if(zone_idx != 0)
-            {
                 packet_offset += 3 * (34 - zones[zone_idx].leds_count);
             }
 
@@ -386,6 +371,6 @@ void CorsairCommanderCoreController::SetFanMode()
     }
 
     WriteData(endpoint, data_type, buf, 15);
-
+    
     controller_ready    = 1;
 }

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.h

@@ -9,12 +9,15 @@
 \*---------------------------------------------------------*/
 
 #include "RGBController.h"
-#include "DeviceGuardManager.h"
 
 #include <vector>
 #include <chrono>
 #include <hidapi/hidapi.h>
 
+#ifdef _WIN32
+#include <Windows.h>
+#endif
+
 #pragma once
 
 #define CORSAIR_COMMANDER_CORE_PACKET_SIZE_V1   1025 // First bit is the report bit
@@ -25,6 +28,10 @@
 #define CORSAIR_QL_FAN_ZONE_OFFSET              102
 #define CORSAIR_COMMANDER_CORE_NUM_CHANNELS     6
 
+#ifdef _WIN32
+#define GLOBAL_CORSAIR_MUTEX_NAME "Global\\CorsairLinkReadWriteGuardMutex"
+#endif
+
 enum
 {
     CORSAIR_COMMANDER_CORE_MODE_DIRECT          = 0x00,
@@ -37,7 +44,6 @@ public:
     ~CorsairCommanderCoreController();
 
     std::string GetFirmwareString();
-    std::vector<unsigned short int> GetLedCounts();
     std::string GetLocationString();
 
     void        SetDirectColor
@@ -50,23 +56,25 @@ public:
     void        SetFanMode();
 
 private:
-    hid_device*                                         dev;
-    std::thread*                                        keepalive_thread;
-    std::atomic<bool>                                   keepalive_thread_run;
-    std::atomic<bool>                                   controller_ready;
-    std::string                                         location;
-    std::vector<RGBColor>                               lastcolors;
-    std::vector<zone>                                   lastzones;
-    unsigned short int                                  version[3] = {0, 0, 0};
-    int                                                 packet_size;
-    int                                                 command_res_size;
-    int                                                 pid;
-    std::chrono::time_point<std::chrono::steady_clock>  last_commit_time;
-    DeviceGuardManager*                                 guard_manager_ptr;
+    hid_device*             dev;
+    std::thread*            keepalive_thread;
+    std::atomic<bool>       keepalive_thread_run;
+    std::atomic<bool>       controller_ready;
+    std::string             location;
+    std::vector<RGBColor>   lastcolors;
+    std::vector<zone>       lastzones;
+    unsigned short int      version[3] = {0, 0, 0};
+    int                     packet_size;
+    int                     command_res_size;
+    int                     pid;
+    std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
 
+#ifdef _WIN32
+    HANDLE                  global_corsair_access_handle = NULL;
+#endif
+    
     void        SendCommand(unsigned char command[2], unsigned char data[], unsigned short int data_len, unsigned char res[]);
     void        WriteData(unsigned char endpoint[2], unsigned char data_type[2], unsigned char data[], unsigned short int data_len);
-    void        ReadData(unsigned char endpoint[2], unsigned char data[]);
 
     void        SendCommit();
     void        InitController();

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.cpp

@@ -21,7 +21,7 @@
 \*-------------------------------------------------------------------*/
 
 #define NA 0xFFFFFFFF
-static unsigned int matrix_map29[7][7] =
+static unsigned int matrix_map[7][7] =
 {
     { 28,  NA,  27,  NA,  26,  NA,  25 },
     { NA,  16,  NA,  15,  NA,  14,  NA },
@@ -32,21 +32,6 @@ static unsigned int matrix_map29[7][7] =
     { 19,  NA,  20,  NA,  21,  NA,  22 },
 };
 
-static unsigned int matrix_map24[11][11] =
-{
-    { NA,  NA,  NA,  NA,  NA,   6,  NA,  NA,  NA,  NA,  NA },
-    { NA,  NA,  NA,   4,   5,  NA,   7,   8,  NA,  NA,  NA },
-    { NA,  NA,   3,  NA,  NA,  NA,  NA,  NA,   9,  NA,  NA },
-    { NA,   2,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  10,  NA },
-    { NA,   1,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  11,  NA },
-    {  0,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  12 },
-    { NA,  23,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  13,  NA },
-    { NA,  22,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  14,  NA },
-    { NA,  NA,  21,  NA,  NA,  NA,  NA,  NA,  15,  NA,  NA },
-    { NA,  NA,  NA,  20,  19,  NA,  17,  16,  NA,  NA,  NA },
-    { NA,  NA,  NA,  NA,  NA,  18,  NA,  NA,  NA,  NA,  NA }
-};
-
 RGBController_CorsairCommanderCore::RGBController_CorsairCommanderCore(CorsairCommanderCoreController* controller_ptr)
 {
     controller  = controller_ptr;
@@ -82,26 +67,16 @@ void RGBController_CorsairCommanderCore::SetupZones()
         first_run = 1;
     }
 
-    std::vector<unsigned short int> led_count = controller->GetLedCounts();
     zones.resize(7);
     zones[0].name                   = "Pump";
     zones[0].type                   = ZONE_TYPE_MATRIX;
-    zones[0].leds_min               = led_count.at(0);
-    zones[0].leds_max               = led_count.at(0);
-    zones[0].leds_count             = led_count.at(0);
+    zones[0].leds_min               = 29;
+    zones[0].leds_max               = 29;
+    zones[0].leds_count             = 29;
     zones[0].matrix_map             = new matrix_map_type;
-    if(led_count.at(0) == 24)
-    {
-        zones[0].matrix_map->height     = 11;
-        zones[0].matrix_map->width      = 11;
-        zones[0].matrix_map->map        = (unsigned int *)&matrix_map24;
-    }
-    else
-    {
-        zones[0].matrix_map->height     = 7;
-        zones[0].matrix_map->width      = 7;
-        zones[0].matrix_map->map        = (unsigned int *)&matrix_map29;
-    }
+    zones[0].matrix_map->height     = 7;
+    zones[0].matrix_map->width      = 7;
+    zones[0].matrix_map->map        = (unsigned int *)&matrix_map;
 
     for(unsigned int i = 1; i < (CORSAIR_COMMANDER_CORE_NUM_CHANNELS + 1); i++)
     {
@@ -112,7 +87,7 @@ void RGBController_CorsairCommanderCore::SetupZones()
 
         if(first_run)
         {
-            zones[i].leds_count     = (led_count.size() > i) ? led_count.at(i) : 0;
+            zones[i].leds_count     = 0;
         }
     }
 

Controllers/CorsairController/CorsairDeviceGuard.cpp

@@ -1,64 +0,0 @@
-/*---------------------------------------------------------*\
-|  CorsairDeviceGuard.h                                     |
-|                                                           |
-|  A DeviceGuard implementation for Corsair devices.        |
-|                                                           |
-|  On Windows platforms, a global mutex is used.            |
-|                                                           |
-|  Evan Mulawski, 2023-09-04                                |
-|                                                           |
-\*---------------------------------------------------------*/
-
-#include "CorsairDeviceGuard.h"
-
-CorsairDeviceGuard::CorsairDeviceGuard() : DeviceGuard()
-{
-#ifdef _WIN32
-    mutex_handle = CreateWindowsMutex();
-#endif
-}
-
-void CorsairDeviceGuard::Acquire()
-{
-#ifdef _WIN32
-    while(true)
-    {
-        DWORD result = WaitForSingleObject(mutex_handle, INFINITE);
-
-        if(result == WAIT_OBJECT_0)
-        {
-            break;
-        }
-
-        if(result == WAIT_ABANDONED)
-        {
-            ReleaseMutex(mutex_handle);
-        }
-    }
-#endif
-}
-
-void CorsairDeviceGuard::Release()
-{
-#ifdef _WIN32
-    ReleaseMutex(mutex_handle);
-#endif
-}
-
-#ifdef _WIN32
-
-HANDLE CorsairDeviceGuard::CreateWindowsMutex()
-{
-    SECURITY_DESCRIPTOR sd;
-    InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
-    SetSecurityDescriptorDacl(&sd, TRUE, NULL, FALSE);
-
-    SECURITY_ATTRIBUTES sa;
-    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
-    sa.lpSecurityDescriptor = &sd;
-    sa.bInheritHandle = FALSE;
-
-    return CreateMutex(&sa, FALSE, "Global\\CorsairLinkReadWriteGuardMutex");
-}
-
-#endif

Controllers/CorsairController/CorsairDeviceGuard.h

@@ -1,34 +0,0 @@
-/*---------------------------------------------------------*\
-|  CorsairDeviceGuard.h                                     |
-|                                                           |
-|  A DeviceGuard implementation for Corsair devices.        |
-|                                                           |
-|  On Windows platforms, a global mutex is used.            |
-|                                                           |
-|  Evan Mulawski, 2023-09-04                                |
-|                                                           |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "DeviceGuard.h"
-
-#ifdef _WIN32
-#include <Windows.h>
-#endif
-
-class CorsairDeviceGuard : public DeviceGuard
-{
-public:
-    CorsairDeviceGuard();
-
-    void Acquire() override;
-    void Release() override;
-
-private:
-#ifdef _WIN32
-    HANDLE mutex_handle;
-
-    HANDLE CreateWindowsMutex();
-#endif
-};

Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.cpp

@@ -17,16 +17,6 @@
     @effects :x:
     @detectors DetectCorsairDominatorPlatinumControllers
     @comment
-        The Corsair Dominator controller chip can be found on several
-        Corsair memory sticks which have different LED counts. This can be controlled
-        by editing the Part Number in OpenRGB.json with values in the below table.
-
-        | Part Number | LED Count |
-        | :---------: | --------: |
-        | CMG         |  6        |
-        | CMH         | 10        |
-        | CMN         | 10        |
-        | CMT         | 12        |
 \*-------------------------------------------------------------------*/
 
 RGBController_CorsairDominatorPlatinum::RGBController_CorsairDominatorPlatinum(CorsairDominatorPlatinumController* controller_ptr)

Controllers/CorsairHydroPlatinumController/CorsairHydroPlatinumController.cpp

@@ -8,7 +8,6 @@
 \*-------------------------------------------------------------------*/
 
 #include "CorsairHydroPlatinumController.h"
-#include "CorsairDeviceGuard.h"
 #include <cstring>
 
 static const uint8_t CRC_TABLE[256] =
@@ -87,7 +86,6 @@ CorsairHydroPlatinumController::CorsairHydroPlatinumController(hid_device* dev_h
 {
     dev         = dev_handle;
     location    = path;
-    guard_manager_ptr = new DeviceGuardManager(new CorsairDeviceGuard());
 
     SendMagic(MAGIC_1, CORSAIR_HYDRO_PLATINUM_MAGIC_1);
     SendMagic(MAGIC_2, CORSAIR_HYDRO_PLATINUM_MAGIC_2);
@@ -97,7 +95,6 @@ CorsairHydroPlatinumController::CorsairHydroPlatinumController(hid_device* dev_h
 CorsairHydroPlatinumController::~CorsairHydroPlatinumController()
 {
     hid_close(dev);
-    delete guard_manager_ptr;
 }
 
 std::string CorsairHydroPlatinumController::GetLocation()
@@ -155,18 +152,8 @@ void CorsairHydroPlatinumController::SendMagic(const uint8_t* magic, unsigned in
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    /*---------------------------------------------------------*\
-    | HID I/O start                                             |
-    \*---------------------------------------------------------*/
-    {
-        DeviceGuardLock _ = guard_manager_ptr->AwaitExclusiveAccess();
-
-        hid_write(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
-        hid_read(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
-    }
-    /*---------------------------------------------------------*\
-    | HID I/O end (lock released)                               |
-    \*---------------------------------------------------------*/
+    hid_write(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
+    hid_read(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
 
     if(firmware_version.empty())
     {
@@ -217,17 +204,8 @@ void CorsairHydroPlatinumController::SendColors(std::vector<RGBColor> colors, un
     checksum_array.insert(checksum_array.begin(), std::begin(usb_buf) + 2, std::end(usb_buf) - 1);
     usb_buf[64] = ComputePEC(static_cast<void*>(checksum_array.data()), 62);
 
-    /*---------------------------------------------------------*\
-    | HID I/O start                                             |
-    \*---------------------------------------------------------*/
-    {
-        DeviceGuardLock _ = guard_manager_ptr->AwaitExclusiveAccess();
-
-        hid_write(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
-    }
-    /*---------------------------------------------------------*\
-    | HID I/O end (lock released)                               |
-    \*---------------------------------------------------------*/
+    hid_write(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
+    hid_read(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
 
     /*-----------------------------------------------------*\
     | This delay prevents the AIO from soft-locking when    |
@@ -264,4 +242,4 @@ uint8_t CorsairHydroPlatinumController::ComputePEC(const void * data, size_t siz
 	}
 
 	return val;
-}
+}

Controllers/CorsairHydroPlatinumController/CorsairHydroPlatinumController.h

@@ -10,8 +10,6 @@
 #pragma once
 
 #include "RGBController.h"
-#include "DeviceGuardManager.h"
-
 #include <vector>
 #include <string>
 #include <hidapi/hidapi.h>
@@ -41,11 +39,11 @@ public:
     void SetupColors(std::vector<RGBColor> colors);
 
 private:
-    hid_device*                 dev;
-    std::string                 location;
-    std::string                 firmware_version;
-    std::atomic<unsigned int>   sequence_number;
-    DeviceGuardManager*         guard_manager_ptr;
+    hid_device* dev;
+    std::string location;
+    std::string firmware_version;
+
+    std::atomic<unsigned int> sequence_number;
 
     void SendMagic(const uint8_t* magic, unsigned int command);
     void SendColors(std::vector<RGBColor> colors, unsigned int start, unsigned int end, unsigned int command);

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -5,7 +5,6 @@
 \*---------------------------------------------------------*/
 
 #include "CorsairLightingNodeController.h"
-#include "CorsairDeviceGuard.h"
 
 #include <fstream>
 #include <iostream>
@@ -18,7 +17,6 @@ CorsairLightingNodeController::CorsairLightingNodeController(hid_device* dev_han
 {
     dev         = dev_handle;
     location    = path;
-    guard_manager_ptr = new DeviceGuardManager(new CorsairDeviceGuard());
 
     SendFirmwareRequest();
 
@@ -39,7 +37,6 @@ CorsairLightingNodeController::~CorsairLightingNodeController()
     delete keepalive_thread;
 
     hid_close(dev);
-    delete guard_manager_ptr;
 }
 
 void CorsairLightingNodeController::KeepaliveThread()
@@ -179,7 +176,7 @@ void CorsairLightingNodeController::SetChannelLEDs(unsigned char channel, RGBCol
         {
             pkt_size = 50;
         }
-
+        
         for(int color_idx = 0; color_idx < pkt_size; color_idx++)
         {
             red_color_data[color_idx] = RGBGetRValue(colors[pkt_offset + color_idx]);
@@ -208,7 +205,7 @@ void CorsairLightingNodeController::SetChannelLEDs(unsigned char channel, RGBCol
 void CorsairLightingNodeController::SendFirmwareRequest()
 {
     int             actual;
-    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -224,7 +221,8 @@ void CorsairLightingNodeController::SendFirmwareRequest()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    actual = WriteAndRead(usb_buf);
+    hid_write(dev, usb_buf, 65);
+    actual = hid_read(dev, usb_buf, 17);
 
     if(actual > 0)
     {
@@ -241,7 +239,7 @@ void CorsairLightingNodeController::SendDirect
     unsigned char*  color_data
     )
 {
-    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -266,12 +264,13 @@ void CorsairLightingNodeController::SendDirect
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    WriteAndRead(usb_buf, 5);
+    hid_write(dev, usb_buf, 65);
+    hid_read_timeout(dev, usb_buf, 17, 5);
 }
 
 void CorsairLightingNodeController::SendCommit()
 {
-    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -293,7 +292,8 @@ void CorsairLightingNodeController::SendCommit()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    WriteAndRead(usb_buf, 5);
+    hid_write(dev, usb_buf, 65);
+    hid_read_timeout(dev, usb_buf, 17, 5);
 }
 
 void CorsairLightingNodeController::SendBegin
@@ -301,7 +301,7 @@ void CorsairLightingNodeController::SendBegin
     unsigned char   channel
     )
 {
-    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -318,7 +318,8 @@ void CorsairLightingNodeController::SendBegin
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    WriteAndRead(usb_buf);
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
 }
 
 void CorsairLightingNodeController::SendEffectConfig
@@ -344,7 +345,7 @@ void CorsairLightingNodeController::SendEffectConfig
     unsigned short  temperature_2
     )
 {
-    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -395,7 +396,8 @@ void CorsairLightingNodeController::SendEffectConfig
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    WriteAndRead(usb_buf);
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
 }
 
 void CorsairLightingNodeController::SendTemperature()
@@ -408,7 +410,7 @@ void CorsairLightingNodeController::SendReset
     unsigned char   channel
     )
 {
-    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -425,7 +427,8 @@ void CorsairLightingNodeController::SendReset
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    WriteAndRead(usb_buf);
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
 }
 
 void CorsairLightingNodeController::SendPortState
@@ -434,7 +437,7 @@ void CorsairLightingNodeController::SendPortState
     unsigned char   state
     )
 {
-    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -452,7 +455,8 @@ void CorsairLightingNodeController::SendPortState
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    WriteAndRead(usb_buf, 5);
+    hid_write(dev, usb_buf, 65);
+    hid_read_timeout(dev, usb_buf, 17, 5);
 }
 
 void CorsairLightingNodeController::SendBrightness
@@ -461,7 +465,7 @@ void CorsairLightingNodeController::SendBrightness
     unsigned char   brightness
     )
 {
-    unsigned char   usb_buf[CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE];
+    unsigned char   usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Brightness goes from 0-100                            |
@@ -487,7 +491,8 @@ void CorsairLightingNodeController::SendBrightness
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    WriteAndRead(usb_buf);
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
 }
 
 void CorsairLightingNodeController::SendLEDCount()
@@ -499,34 +504,3 @@ void CorsairLightingNodeController::SendProtocol()
 {
 
 }
-
-int CorsairLightingNodeController::WriteAndRead
-    (
-    unsigned char *buf,
-    int read_timeout_ms
-    )
-{
-    int hid_read_ret;
-
-    /*---------------------------------------------------------*\
-    | HID I/O start                                             |
-    \*---------------------------------------------------------*/
-    {
-        DeviceGuardLock _ = guard_manager_ptr->AwaitExclusiveAccess();
-
-        hid_write(dev, buf, CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE);
-        if(read_timeout_ms > 0)
-        {
-            hid_read_ret = hid_read_timeout(dev, buf, CORSAIR_LIGHTING_NODE_READ_PACKET_SIZE, read_timeout_ms);
-        }
-        else
-        {
-            hid_read_ret = hid_read(dev, buf, CORSAIR_LIGHTING_NODE_READ_PACKET_SIZE);
-        }
-    }
-    /*---------------------------------------------------------*\
-    | HID I/O end (lock released)                               |
-    \*---------------------------------------------------------*/
-
-    return hid_read_ret;
-}

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h

@@ -4,18 +4,13 @@
 |  Adam Honse ([email protected]), 1/12/2020        |
 \*---------------------------------------------------------*/
 
-#include "DeviceGuardManager.h"
 #include "RGBController.h"
-
 #include <chrono>
 #include <vector>
 #include <hidapi/hidapi.h>
 
 #pragma once
 
-#define CORSAIR_LIGHTING_NODE_WRITE_PACKET_SIZE      65          /* First byte is the report number      */
-#define CORSAIR_LIGHTING_NODE_READ_PACKET_SIZE       17          /* First byte is the report number      */
-
 enum
 {
     CORSAIR_LIGHTING_NODE_PACKET_ID_FIRMWARE         = 0x02,     /* Get firmware version                 */
@@ -94,7 +89,7 @@ public:
     unsigned int    GetStripsOnChannel(unsigned int channel);
 
     void            SetBrightness(unsigned char brightness);
-
+    
     void            SetChannelEffect(unsigned char channel,
                                      unsigned char num_leds,
                                      unsigned char mode,
@@ -117,13 +112,12 @@ public:
     void            KeepaliveThread();
 
 private:
-    hid_device*                                         dev;
-    std::string                                         firmware_version;
-    std::string                                         location;
-    std::thread*                                        keepalive_thread;
-    std::atomic<bool>                                   keepalive_thread_run;
-    std::chrono::time_point<std::chrono::steady_clock>  last_commit_time;
-    DeviceGuardManager*                                 guard_manager_ptr;
+    hid_device*             dev;
+    std::string             firmware_version;
+    std::string             location;
+    std::thread*            keepalive_thread;
+    std::atomic<bool>       keepalive_thread_run;
+    std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
 
     void            SendFirmwareRequest();
 
@@ -188,10 +182,4 @@ private:
     void            SendLEDCount();
 
     void            SendProtocol();
-
-    int             WriteAndRead
-                        (
-                        unsigned char *buf,
-                        int read_timeout_ms = -1
-                        );
 };

Controllers/CorsairPeripheralController/CorsairK100Controller.cpp

@@ -0,0 +1,172 @@
+/*-----------------------------------------*\
+|  CorsairK100Controller.cpp                |
+|                                           |
+|  Driver for Corsair K100 Keyboard         |
+\*-----------------------------------------*/
+
+#include "CorsairK100Controller.h"
+#include "LogManager.h"
+
+static unsigned int keys_k100[] = {0x25, 0x31, 0x27, 0x35, 0x66, 0x65, 0x41, 0x2A, 0x6E, 0x5B, 0x36, 0x1A, 0x10, 0x00, 0x68, 0x42,
+                                   0x62, 0x5C, 0x37, 0x1B, 0x16, 0x12, 0x19, 0x67, 0x43, 0x26, 0x77, 0x5D, 0x38, 0x1C, 0x04, 0x03,
+                                   0x17, 0x44, 0x48, 0x7A, 0x39, 0x1D, 0x11, 0x05, 0x02, 0x28, 0x45, 0x49, 0x78, 0x58, 0x3A, 0x1E,
+                                   0x13, 0x06, 0x15, 0x46, 0x4A, 0x79, 0x59, 0x3B, 0x1F, 0x18, 0x07, 0x01, 0x47, 0x6A, 0x4F, 0x5A,
+                                   0x3C, 0x20, 0x14, 0x09, 0x0D, 0x6B, 0x2C, 0x69, 0x50, 0x55, 0x3D, 0x21, 0x08, 0x0A, 0x0C, 0x76,
+                                   0x2D, 0x4E, 0x51, 0x56, 0x3E, 0x22, 0x0E, 0x0B, 0x32, 0x61, 0x4C, 0x52, 0x57, 0x3F, 0x23, 0x0F,
+                                   0x2F, 0x33, 0x24, 0x4D, 0x53, 0x5E, 0x40, 0x29, 0x2B, 0x30, 0x34, /*Brightness,*/
+                                   0x4B, 0x54, 0x5F, 0x60, 0x2E, 0x7C,
+                                   0x7F, 0x80, 0x81, 0x82, 0x83, 0x84,//Macro
+                                   0xA6, 0xA5, 0xA4, 0xA3, 0xA2, 0xA1, 0xA0, 0x9F, 0x9E, 0x9D, 0x9C, 0x86, 0x87, 0x88, 0x89, 0x8A,
+                                   0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A,
+                                   0x9B, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,0xB0, 0xB1, //Light Bar
+                                   0x85, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9,//Nameplate
+                                   0xBA, 0xBB, 0xBC/*Logo*/};
+
+CorsairK100Controller::CorsairK100Controller(hid_device* dev_handle, const char* path)
+{
+    dev             = dev_handle;
+    location        = path;
+    keyboard_type   = CORSAIR_TYPE_K100;
+
+    LightingControl();
+}
+CorsairK100Controller::~CorsairK100Controller()
+{
+    hid_close(dev);
+}
+
+std::string CorsairK100Controller::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string CorsairK100Controller::GetFirmwareString()
+{
+    return "";
+}
+
+std::string CorsairK100Controller::GetName()
+{
+    return name;
+}
+
+void CorsairK100Controller::SetName(std::string device_name)
+{
+    name = device_name;
+}
+
+CorsairKeyboardType CorsairK100Controller::GetKeyboardType()
+{
+    return keyboard_type;
+}
+
+std::string CorsairK100Controller::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 CorsairK100Controller::LightingControl()
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    //This is requered
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x01;
+    usb_buf[0x03] = 0x03;
+    usb_buf[0x05] = 0x02;
+
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x01;
+    usb_buf[0x03] = 0x4A;
+    usb_buf[0x05] = 0x01;
+
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x01;
+    usb_buf[0x03] = 0x45;
+    usb_buf[0x05] = 0x00;
+
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    //This is requered
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x0D;
+    usb_buf[0x03] = 0x01;
+    usb_buf[0x04] = 0x22;
+
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x05;
+    usb_buf[0x03] = 0x01;
+
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    int res = hid_read_timeout(dev, usb_buf, 50, 1000);
+
+    if (res == 0 || usb_buf[1] != 0x01)
+    {
+        LOG_INFO("[Corsair-K100] This device did not allow to take control over it. recieved response: %02X", usb_buf[1]);
+        keyboard_type = CORSAIR_TYPE_UNKNOWN;
+    }*/
+
+}
+
+void CorsairK100Controller::SetLEDs(std::vector<RGBColor>colors)
+{
+    switch(keyboard_type)
+    {
+        case CORSAIR_TYPE_K100:
+            SetLEDsKeyboardFull(colors);
+            break;
+
+        case CORSAIR_TYPE_UNKNOWN:
+            break;
+    }
+}
+
+void CorsairK100Controller::SetLEDsKeyboardFull(std::vector<RGBColor> colors)
+{
+    unsigned char usb_buf[600];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x06;
+    usb_buf[0x03] = 0x01;
+    usb_buf[0x04] = 0x45;
+    usb_buf[0x05] = 0x02;
+    usb_buf[0x08] = 0x12;
+
+    for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        RGBColor color = colors[color_idx];
+        usb_buf[0x16 + keys_k100[color_idx]*3] = RGBGetRValue(color);
+        usb_buf[0x17 + keys_k100[color_idx]*3] = RGBGetGValue(color);
+        usb_buf[0x18 + keys_k100[color_idx]*3] = RGBGetBValue(color);
+    }
+
+    hid_write(dev, (unsigned char *)usb_buf, 600);
+}

Controllers/CorsairPeripheralController/CorsairK100Controller.h

@@ -0,0 +1,49 @@
+/*-----------------------------------------*\
+|  CorsairK100Controller.h                  |
+|                                           |
+|  Driver for Corsair K100 Keyboard         |
+\*-----------------------------------------*/
+
+#ifndef CORSAIRK100CONTROLLER_H
+#define CORSAIRK100CONTROLLER_H
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+typedef enum
+{
+    CORSAIR_TYPE_UNKNOWN            = 0,
+    CORSAIR_TYPE_K100               = 1
+} CorsairKeyboardType;
+
+class CorsairK100Controller
+{
+public:
+    CorsairK100Controller(hid_device* dev_handle, const char* path);
+    ~CorsairK100Controller();
+    CorsairKeyboardType             GetKeyboardType();
+    std::string                     GetDeviceLocation();
+    std::string                     GetFirmwareString();
+    std::string                     GetName();
+    std::string                     GetSerialString();
+
+    void                            SetLEDs(std::vector<RGBColor> colors);
+    void                            SetLEDsKeyboardLimited(std::vector<RGBColor> colors);
+    void                            SetName(std::string device_name);
+
+private:
+    hid_device*             dev;
+
+    std::string             firmware_version;
+    std::string             location;
+    std::string             name;
+    device_type             type;
+    CorsairKeyboardType     keyboard_type;
+
+    void                    LightingControl();
+    void                    SetLEDsKeyboardFull(std::vector<RGBColor> colors);
+};
+
+#endif // CORSAIRK100CONTROLLER_H

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -3,6 +3,7 @@
 \*-----------------------------------------------------*/
 #include <hidapi/hidapi.h>
 #include "Detector.h"
+#include "CorsairK55RGBPROXTController.h"
 #include "LogManager.h"
 #include "RGBController.h"
 
@@ -10,6 +11,7 @@
 | Corsair Peripheral specific includes                  |
 \*-----------------------------------------------------*/
 #include "RGBController_CorsairPeripheral.h"
+#include "RGBController_CorsairK100.h"
 #include "RGBController_CorsairK55RGBPROXT.h"
 #include "RGBController_CorsairK65Mini.h"
 #include "RGBController_CorsairK95PlatinumXT.h"
@@ -32,7 +34,7 @@
 #define CORSAIR_K65_LUX_RGB_PID         0x1B37
 #define CORSAIR_K65_RGB_RAPIDFIRE_PID   0x1B39
 
-#define CORSAIR_K68_RGB_PID             0x1B4F
+#define CORSAIR_K68_RGB                 0x1B4F
 
 #define CORSAIR_K70_RGB_PID             0x1B13
 #define CORSAIR_K70_LUX_RGB_PID         0x1B33
@@ -52,7 +54,6 @@
 | Non-RGB Keyboard product IDs                          |
 \*-----------------------------------------------------*/
 #define CORSAIR_K70_LUX_PID             0x1B36
-#define CORSAIR_K68_RED_PID             0x1B3F
 
 /*-----------------------------------------------------*\
 | Mouse product IDs                                     |
@@ -84,6 +85,13 @@
 \*-----------------------------------------------------*/
 #define CORSAIR_ST100_PID               0x0A34
 
+/*-----------------------------------------------------*\
+| Corsair K100 Keyboard product ID                      |
+| This keyboard uses a separate driver                  |
+\*-----------------------------------------------------*/
+#define CORSAIR_K100_OPTICAL_PID                0x1B7C
+#define CORSAIR_K100_MXRED_PID                  0x1B7D
+
 /*-----------------------------------------------------*\
 | Corsair K55 RGB PRO XT Keyboard product ID            |
 | This keyboard uses a separate driver                  |
@@ -102,6 +110,27 @@
 \*-----------------------------------------------------*/
 #define CORSAIR_K95_PLATINUM_XT_PID     0x1B89
 
+void DetectCorsairK100Controllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        CorsairK100Controller* controller = new CorsairK100Controller(dev, info->path);
+        controller->SetName(name);
+
+        if(controller->GetKeyboardType() != CORSAIR_TYPE_UNKNOWN)
+        {
+            RGBController_CorsairK100* rgb_controller = new RGBController_CorsairK100(controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+        else
+        {
+            delete controller;
+        }
+    }
+}   /* DetectCorsairPeripheralControllers() */
+
 void DetectCorsairK55RGBPROXTControllers(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -183,8 +212,7 @@ REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                 DetectCorsairPeriphe
 REGISTER_HID_DETECTOR_IP("Corsair K65 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_PID,            1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K65 LUX RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_LUX_RGB_PID,        1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K65 RGB RAPIDFIRE",       DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_RAPIDFIRE_PID,  1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K68 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K68_RGB_PID,            1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K68 RED",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K68_RED_PID,            1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair K68 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K68_RGB,                1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K70 RGB",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_PID,            1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K70 LUX",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_LUX_PID,            1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K70 LUX RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_LUX_RGB_PID,        1, 0xFFC2);
@@ -231,6 +259,12 @@ REGISTER_HID_DETECTOR_P("Corsair ST100 RGB",                DetectCorsairPeriphe
 REGISTER_HID_DETECTOR_I("Corsair ST100 RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID,              0);
 #endif
 
+/*-----------------------------------------------------------------------------------------------------*\
+| Corsair K100 Keyboard                                                                                 |
+\*-----------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("Corsair K100",                    DetectCorsairK100Controllers,       CORSAIR_VID, CORSAIR_K100_OPTICAL_PID,       1, 0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K100",                    DetectCorsairK100Controllers,       CORSAIR_VID, CORSAIR_K100_MXRED_PID,         1, 0xFF42);
+
 /*-----------------------------------------------------------------------------------------------------*\
 | Corsair K65 Mini Keyboard                                                                             |
 \*-----------------------------------------------------------------------------------------------------*/

Controllers/CorsairPeripheralController/RGBController_CorsairK100.cpp

@@ -0,0 +1,383 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairK100.cpp            |
+|                                           |
+|  Driver for Corsair K100 Keyboard         |
+\*-----------------------------------------*/
+
+#include "RGBControllerKeyNames.h"
+#include "RGBController_CorsairK100.h"
+#include "LogManager.h"
+
+using namespace std::chrono_literals;
+
+#define NA  0xFFFFFFFF
+
+static unsigned int matrix_map_k100[7][24] =
+    { {  NA, 112,  NA,   8,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  16,  NA,  NA,  NA,},
+      { 113,   0,  NA,  10,  18,  28,  36,  NA,  46,  55,  64,  74,  NA,  84,  93, 102,   6,  15,  24,  33,  26,  35,  44,  53 },
+      { 114,   1,  11,  19,  29,  37,  47,  56,  65,  75,  85,  94,  NA, 103,   7,  25,  NA,  42,  51,  60,  62,  72,  82,  91 },
+      { 115,   2,  NA,  12,  20,  30,  38,  NA,  48,  57,  66,  76,  86,  95, 104,  70,  80,  34,  43,  52,  9,   17,  27, 100 },
+      { 116,   3,  NA,  13,  21,  31,  39,  NA,  49,  58,  67,  77,  87,  96, 105,  98, 111,  NA,  NA,  NA,  45,  54,  63,  NA },
+      { 117,   4, 110,  22,  32,  40,  50,  NA,  59,  NA,  68,  78,  88,  97, 106,  61,  NA,  NA,  81,  NA,  73,  83,  92, 108 },
+      { 118,   5,  14,  23,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  69,  79,  89,  71,  90,  99, 107, 101,  NA, 109,  NA } };
+
+static const char* led_names_k100[] =
+{
+    KEY_EN_ESCAPE,              //0
+    KEY_EN_BACK_TICK,           //1
+    KEY_EN_TAB,                 //2
+    KEY_EN_CAPS_LOCK,           //3
+    KEY_EN_LEFT_SHIFT,          //4
+    KEY_EN_LEFT_CONTROL,        //5
+    KEY_EN_F12,                 //6
+    KEY_EN_EQUALS,              //7
+    "Key: Lock",                //8
+    KEY_EN_NUMPAD_7,            //9
+    KEY_EN_F1,                  //12
+    KEY_EN_1,                   //13
+    KEY_EN_Q,                   //14
+    KEY_EN_A,                   //15
+    KEY_EN_LEFT_WINDOWS,        //17
+    KEY_EN_PRINT_SCREEN,        //18
+    KEY_EN_MEDIA_MUTE,          //20
+    KEY_EN_NUMPAD_8,            //21
+    KEY_EN_F2,                  //24
+    KEY_EN_2,                   //25
+    KEY_EN_W,                   //26
+    KEY_EN_S,                   //27
+    KEY_EN_Z,                   //28
+    KEY_EN_LEFT_ALT,            //29
+    KEY_EN_SCROLL_LOCK,         //30
+    KEY_EN_BACKSPACE,           //31
+    KEY_EN_MEDIA_STOP,          //32
+    KEY_EN_NUMPAD_9,            //33
+    KEY_EN_F3,                  //36
+    KEY_EN_3,                   //37
+    KEY_EN_E,                   //38
+    KEY_EN_D,                   //39
+    KEY_EN_X,                   //40
+    KEY_EN_PAUSE_BREAK,         //42
+    KEY_EN_DELETE,              //43
+    KEY_EN_MEDIA_PREVIOUS,      //44
+    KEY_EN_F4,                  //48
+    KEY_EN_4,                   //49
+    KEY_EN_R,                   //50
+    KEY_EN_F,                   //51
+    KEY_EN_C,                   //52
+    KEY_EN_SPACE,               //53
+    KEY_EN_INSERT,              //54
+    KEY_EN_END,                 //55
+    KEY_EN_MEDIA_PLAY_PAUSE,    //56
+    KEY_EN_NUMPAD_4,            //57
+    KEY_EN_F5,                  //60
+    KEY_EN_5,                   //61
+    KEY_EN_T,                   //62
+    KEY_EN_G,                   //63
+    KEY_EN_V,                   //64
+    KEY_EN_HOME,                //66
+    KEY_EN_PAGE_DOWN,           //67
+    KEY_EN_MEDIA_NEXT,          //68
+    KEY_EN_NUMPAD_5,            //69
+    KEY_EN_F6,                  //72
+    KEY_EN_6,                   //73
+    KEY_EN_Y,                   //74
+    KEY_EN_H,                   //75
+    KEY_EN_B,                   //76
+    KEY_EN_PAGE_UP,             //78
+    KEY_EN_RIGHT_SHIFT,         //79
+    KEY_EN_NUMPAD_LOCK,         //80
+    KEY_EN_NUMPAD_6,            //81
+    KEY_EN_F7,                  //84
+    KEY_EN_7,                   //85
+    KEY_EN_U,                   //86
+    KEY_EN_J,                   //87
+    KEY_EN_N,                   //88
+    KEY_EN_RIGHT_ALT,           //89
+    KEY_EN_RIGHT_BRACKET,       //90
+    KEY_EN_RIGHT_CONTROL,       //91
+    KEY_EN_NUMPAD_DIVIDE,       //92
+    KEY_EN_NUMPAD_1,            //93
+    KEY_EN_F8,                  //96
+    KEY_EN_8,                   //97
+    KEY_EN_I,                   //98
+    KEY_EN_K,                   //99
+    KEY_EN_M,                   //100
+    KEY_EN_RIGHT_WINDOWS,       //101
+    KEY_EN_ANSI_BACK_SLASH,     //102
+    KEY_EN_UP_ARROW,            //103
+    KEY_EN_NUMPAD_TIMES,        //104
+    KEY_EN_NUMPAD_2,            //105
+    KEY_EN_F9,                  //108
+    KEY_EN_9,                   //109
+    KEY_EN_O,                   //110
+    KEY_EN_L,                   //111
+    KEY_EN_COMMA,               //112
+    KEY_EN_MENU,                //113
+    KEY_EN_LEFT_ARROW,          //115
+    KEY_EN_NUMPAD_MINUS,        //116
+    KEY_EN_NUMPAD_3,            //117
+    KEY_EN_F10,                 //120
+    KEY_EN_0,                   //121
+    KEY_EN_P,                   //122
+    KEY_EN_SEMICOLON,           //123
+    KEY_EN_PERIOD,              //124
+    KEY_EN_ANSI_ENTER,          //126
+    KEY_EN_DOWN_ARROW,          //127
+    KEY_EN_NUMPAD_PLUS,         //128
+    KEY_EN_NUMPAD_0,            //129
+    KEY_EN_F11,                 //132
+    KEY_EN_MINUS,               //133
+    KEY_EN_LEFT_BRACKET,        //134
+    KEY_EN_QUOTE,               //135
+    KEY_EN_FORWARD_SLASH,       //136
+    //    "Key: Brightness",    //137
+    KEY_EN_RIGHT_ARROW,         //139
+    KEY_EN_NUMPAD_ENTER,        //140
+    KEY_EN_NUMPAD_PERIOD,       //141
+    "Key: / (ISO)",
+    KEY_EN_ISO_BACK_SLASH,
+    "Key: Preset",
+    "Key: G1",
+    "Key: G2",
+    "Key: G3",
+    "Key: G4",
+    "Key: G5",
+    "Key: G6",
+};
+static const char* led_names_lightbar[] =
+{
+    "Underglow 1",
+    "Underglow 2",
+    "Underglow 3",
+    "Underglow 4",
+    "Underglow 5",
+    "Underglow 6",
+    "Underglow 7",
+    "Underglow 8",
+    "Underglow 9",
+    "Underglow 10",
+    "Underglow 11",
+    "Underglow 12",
+    "Underglow 13",
+    "Underglow 14",
+    "Underglow 15",
+    "Underglow 16",
+    "Underglow 17",
+    "Underglow 18",
+    "Underglow 19",
+    "Underglow 20",
+    "Underglow 21",
+    "Underglow 22",
+    "Underglow 23",
+    "Underglow 24",
+    "Underglow 25",
+    "Underglow 26",
+    "Underglow 27",
+    "Underglow 28",
+    "Underglow 29",
+    "Underglow 30",
+    "Underglow 31",
+    "Underglow 32",
+    "Underglow 33",
+    "Underglow 34",
+    "Underglow 35",
+    "Underglow 36",
+    "Underglow 37",
+    "Underglow 38",
+    "Underglow 39",
+    "Underglow 40",
+    "Underglow 41",
+    "Underglow 42",
+    "Underglow 43",
+    "Underglow 44",
+};
+static const char* led_names_nameplate[] =
+{
+    "Nameplate 1",
+    "Nameplate 2",
+    "Nameplate 3",
+    "Nameplate 4",
+    "Nameplate 5",
+    "Nameplate 6",
+    "Nameplate 7",
+    "Nameplate 8",
+    "Nameplate 9",
+};
+static const char* led_names_logo[] =
+{
+    "Logo",
+    "Logo",
+    "Logo",
+};
+
+typedef struct
+{
+    const char* name;
+    const unsigned int size;
+    const zone_type type;
+    const char** led_names;
+    matrix_map_type* matrix;
+} led_zone_layout;
+
+/**------------------------------------------------------------------*\
+    @name Corsair K100 Keyboard
+    @category Keyboard
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectCorsairK100Controllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_CorsairK100::RGBController_CorsairK100(CorsairK100Controller* controller_ptr)
+{
+    controller      = controller_ptr;
+
+    name            = controller->GetName();
+    vendor          = "Corsair";
+    description     = "Corsair K100 Keyboard Device";
+    type            = DEVICE_TYPE_KEYBOARD;
+    version         = controller->GetFirmwareString();
+    location        = controller->GetDeviceLocation();
+    serial          = controller->GetSerialString();
+
+    logical_layout  = controller->GetKeyboardType();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+
+    /*-----------------------------------------------------*\
+    | The Corsair K100 requires a packet within             |
+    | 1 minutes of sending the lighting change in order     |
+    | to not revert back into rainbow mode.  Start a thread |
+    | to continuously send a keepalive packet every 50 sec  |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = true;
+    keepalive_thread = new std::thread(&RGBController_CorsairK100::KeepaliveThread, this);
+}
+
+RGBController_CorsairK100::~RGBController_CorsairK100()
+{
+    /*-----------------------------------------------------*\
+    | Close keepalive thread                                |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = false;
+    keepalive_thread->join();
+    delete keepalive_thread;
+
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].type == ZONE_TYPE_MATRIX)
+        {
+            delete zones[zone_index].matrix_map;
+        }
+    }
+
+    delete controller;
+}
+
+void RGBController_CorsairK100::SetupZones()
+{
+    std::vector<led_zone_layout> selected_zone;
+
+    switch(logical_layout)
+    {
+        case CORSAIR_TYPE_K100:
+            selected_zone.push_back({ZONE_EN_KEYBOARD,  119,    ZONE_TYPE_MATRIX, led_names_k100, new matrix_map_type{7, 24, (unsigned int *)&matrix_map_k100}});
+            selected_zone.push_back({"Underglow",       44,     ZONE_TYPE_LINEAR, led_names_lightbar, NULL});
+            selected_zone.push_back({"Nameplate",       9,      ZONE_TYPE_LINEAR, led_names_nameplate, NULL});
+            selected_zone.push_back({"Logo",            3,      ZONE_TYPE_LINEAR, led_names_logo, NULL});
+            break;
+
+        case CORSAIR_TYPE_UNKNOWN:
+            break;
+    }
+
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_idx = 0; zone_idx < selected_zone.size(); zone_idx++)
+    {
+        zone new_zone;
+
+        new_zone.name                   = selected_zone[zone_idx].name;
+        new_zone.type                   = selected_zone[zone_idx].type;
+        new_zone.leds_min               = selected_zone[zone_idx].size;
+        new_zone.leds_max               = selected_zone[zone_idx].size;
+        new_zone.leds_count             = selected_zone[zone_idx].size;
+
+        if (new_zone.type == ZONE_TYPE_MATRIX)
+        {
+            new_zone.matrix_map         = selected_zone[zone_idx].matrix;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
+        }
+
+        zones.push_back(new_zone);
+
+        for(unsigned int led_idx = 0; led_idx < selected_zone[zone_idx].size; led_idx++)
+        {
+            led new_led;
+            new_led.name = selected_zone[zone_idx].led_names[led_idx];
+            leds.push_back(new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_CorsairK100::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_CorsairK100::DeviceUpdateLEDs()
+{
+    last_update_time = std::chrono::steady_clock::now();
+
+    controller->SetLEDs(colors);
+}
+
+void RGBController_CorsairK100::UpdateZoneLEDs(int /*zone*/)
+{
+    controller->SetLEDs(colors);
+}
+
+void RGBController_CorsairK100::UpdateSingleLED(int /*led*/)
+{
+    controller->SetLEDs(colors);
+}
+
+void RGBController_CorsairK100::DeviceUpdateMode()
+{
+
+}
+
+void RGBController_CorsairK100::KeepaliveThread()
+{
+    while(keepalive_thread_run.load())
+    {
+        if(active_mode == 0)
+        {
+            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50000))
+            {
+                DeviceUpdateLEDs();
+            }
+        }
+        std::this_thread::sleep_for(3000ms);
+    }
+}

Controllers/CorsairPeripheralController/RGBController_CorsairK100.h

@@ -0,0 +1,40 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairK100.cpp            |
+|                                           |
+|  Driver for Corsair K100 Keyboard         |
+\*-----------------------------------------*/
+
+#ifndef RGBCONTROLLER_CORSAIRK100_H
+#define RGBCONTROLLER_CORSAIRK100_H
+
+#include "RGBController.h"
+#include "CorsairK100Controller.h"
+
+class RGBController_CorsairK100 : public RGBController
+{
+public:
+    RGBController_CorsairK100(CorsairK100Controller* controller_ptr);
+    ~RGBController_CorsairK100();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
+
+    void DeviceUpdateMode();
+
+    void KeepaliveThread();
+
+private:
+    CorsairK100Controller*                              controller;
+    CorsairKeyboardType                                 logical_layout;
+
+    std::thread*                                        keepalive_thread;
+    std::atomic<bool>                                   keepalive_thread_run;
+    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
+
+};
+
+#endif // RGBCONTROLLER_CORSAIRK100_H

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.cpp

@@ -36,8 +36,7 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
 
     switch(pid)
     {
-        case CORSAIR_SLIPSTREAM_WIRELESS_PID1:
-        case CORSAIR_SLIPSTREAM_WIRELESS_PID2:
+        case CORSAIR_SLIPSTREAM_WIRELESS_PID:
             write_cmd   = CORSAIR_V2_WRITE_WIRELESS_ID;
             pid         = GetAddress(0x12);
             break;

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2ControllerDetect.cpp

@@ -28,8 +28,7 @@ void DetectCorsairV2HardwareControllers(hid_device_info* info, const std::string
     {
         CorsairPeripheralV2HWController*    controller      = new CorsairPeripheralV2HWController(dev, info->path, name);
         RGBController_CorsairV2HW*          rgb_controller  = new RGBController_CorsairV2HW(controller);
-        if(info->product_id == CORSAIR_SLIPSTREAM_WIRELESS_PID1
-        || info->product_id == CORSAIR_SLIPSTREAM_WIRELESS_PID2)
+        if(info->product_id == CORSAIR_SLIPSTREAM_WIRELESS_PID)
         {
             rgb_controller->name                            = controller->GetName();
         }
@@ -61,28 +60,19 @@ void DetectCorsairV2SoftwareControllers(hid_device_info* info, const std::string
 REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K55_RGB_PRO_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO Low Profile",         DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_LP_PID,             1,  0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO TKL",                 DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_TKL_PID,            1,  0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB PRO",                     DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K70_RGB_PRO_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K70 RGB TKL",                     DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K70_RGB_TKL_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K70 RGB TKL Champion Series",     DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K70_RGB_TKL_CS_PID,             1,  0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair K100 RGB Optical",                DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K100_OPTICAL_V1_PID,            1,  0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair K100 RGB Optical",                DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K100_OPTICAL_V2_PID,            1,  0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair K100 MX Red",                     DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K100_MXRED_PID,                 1,  0xFF42);
 
 /*-----------------------------------------------------------------------------------------------------*\
 | Mice                                                                                                  |
 \*-----------------------------------------------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("Corsair Dark Core RGB SE (Wired)",        DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_DARK_CORE_RGB_PID,              1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Dark Core RGB Pro SE (Wired)",    DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_DARK_CORE_RGB_PRO_PID,          1,  0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair Harpoon Wireless (Wired)",        DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_HARPOON_WIRELESS_PID,           1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair Ironclaw Wireless (Wired)",       DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_IRONCLAW_WIRELESS_PID,          1,  0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair Katar Pro",                       DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_KATAR_PRO_PID,                  1,  0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair Katar Pro V2",                    DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_KATAR_PRO_V2_PID,               1,  0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair Katar Pro XT",                    DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_KATAR_PRO_XT_PID,               1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair M55 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_M55_RGB_PRO_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair M65 Ultra RGB (Wired)",           DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_M65_ULTRA_RGB_PID,              1,  0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair Slipstream Wireless Receiver HW", DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_SLIPSTREAM_WIRELESS_PID1,       1,  0xFF42);
-REGISTER_HID_DETECTOR_IP("Corsair Slipstream Wireless Receiver SW", DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_SLIPSTREAM_WIRELESS_PID2,       1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair Slipstream Wireless Receiver",    DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_SLIPSTREAM_WIRELESS_PID,        1,  0xFF42);
+
 /*-----------------------------------------------------------------------------------------------------*\
 | Mousemat                                                                                              |
 \*-----------------------------------------------------------------------------------------------------*/

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.cpp

@@ -49,44 +49,10 @@ keyboard_keymap_overlay_values corsair_K60_layout
         }
     },
     {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Name,                       Translated Name,            OpCode                              |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
-    }
-};
-
-keyboard_keymap_overlay_values corsair_K60_tkl_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
-    {
-        corsair_tkl_values,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Name,                       Translated Name,            OpCode                              |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
-    }
-};
-
-keyboard_keymap_overlay_values corsair_k70_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
-    {
-        corsair_full_size_values,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Name,                       Translated Name,            OpCode                              |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
     }
 };
 
@@ -100,114 +66,20 @@ keyboard_keymap_overlay_values corsair_K70_TKL_cs_layout
         }
     },
     {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Name,                       Translated Name,            OpCode,                             |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
-        {   0,      0,       1,         123,        KEY_EN_MEDIA_STOP,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Stop Key into new media keys row
-        {   0,      0,       2,         126,        KEY_EN_MEDIA_PREVIOUS,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Previous Track Key
-        {   0,      0,       3,         124,        KEY_EN_MEDIA_PLAY_PAUSE,    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play Pause Key
-        {   0,      0,       4,         125,        KEY_EN_MEDIA_NEXT,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Next Tack Key
-        {   0,      0,       7,           1,        "Logo L",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert 'Logo Left'
-        {   0,      0,       8,           3,        "Logo R",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert 'Logo Right'
-        {   0,      0,      11,         128,        "Profile",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Profile
-        {   0,      0,      12,         113,        "Light",                    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Light key
-        {   0,      0,      13,         114,        "Lock",                     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lock Key
-        {   0,      0,      14,         102,        KEY_EN_MEDIA_MUTE,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute Key
-    }
-};
-
-keyboard_keymap_overlay_values corsair_k100_layout
-{
-    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
-    {
-        corsair_full_size_values,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Name,                       Translated Name,            OpCode,                             |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
-        //media keys
-        {   0,      0,      17,         123,        KEY_EN_MEDIA_STOP,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      18,         126,        KEY_EN_MEDIA_PREVIOUS,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      19,         124,        KEY_EN_MEDIA_PLAY_PAUSE,    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      20,         125,        KEY_EN_MEDIA_NEXT,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        //upper row
-        {   0,      0,      1,          128,        "Profile",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },
-        {   0,      0,      2,          137,        "iCue",                     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      3,          114,        "Lock",                     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      10,         190,        "Logo L",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      11,         191,        "Logo M",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      12,         192,        "Logo R",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      18,         102,        KEY_EN_MEDIA_MUTE,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        //macro keys
-        {   0,      1,      0,          131,        "G1",                       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      2,      0,          132,        "G2",                       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      3,      0,          133,        "G3",                       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      4,      0,          134,        "G4",                       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      5,      0,          135,        "G5",                       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      0,          136,        "G6",                       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        //underglow 44 entries
-        //underglow upper
-        {   0,      0,      0,          138,        "Underglow 1",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },
-        {   0,      0,      1,          139,        "Underglow 2",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      2,          140,        "Underglow 3",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      3,          141,        "Underglow 4",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      4,          142,        "Underglow 5",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      5,          143,        "Underglow 6",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      6,          144,        "Underglow 7",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      7,          145,        "Underglow 8",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      8,          146,        "Underglow 9",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      9,          147,        "Underglow 10",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      10,         148,        "Underglow 11",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      11,         149,        "Underglow 12",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      12,         150,        "Underglow 13",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      13,         151,        "Underglow 14",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      14,         152,        "Underglow 15",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      15,         153,        "Underglow 16",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      16,         154,        "Underglow 17",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      17,         155,        "Underglow 18",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      18,         156,        "Underglow 19",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      19,         157,        "Underglow 20",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      20,         158,        "Underglow 21",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      21,         159,        "Underglow 22",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        //underglow left
-        {   0,      0,      0,          160,        "Underglow 23",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      1,      0,          161,        "Underglow 24",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      2,      0,          162,        "Underglow 25",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      3,      0,          163,        "Underglow 26",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      4,      0,          164,        "Underglow 27",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      5,      0,          165,        "Underglow 28",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      0,          166,        "Underglow 29",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      7,      0,          167,        "Underglow 30",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      8,      0,          168,        "Underglow 31",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      9,      0,          169,        "Underglow 32",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      10,     0,          170,        "Underglow 33",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        //underglow right
-        {   0,      0,      23,         171,        "Underglow 34",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      1,      23,         172,        "Underglow 35",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      2,      23,         173,        "Underglow 36",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      3,      23,         174,        "Underglow 37",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      4,      23,         175,        "Underglow 38",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      5,      23,         176,        "Underglow 39",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      6,      23,         177,        "Underglow 40",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      7,      23,         178,        "Underglow 41",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      8,      23,         179,        "Underglow 42",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      9,      23,         180,        "Underglow 43",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      10,     23,         181,        "Underglow 44",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        //wheel
-        {   0,      0,      0,          182,        "Wheel 1",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },
-        {   0,      0,      1,          183,        "Wheel 2",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      2,          184,        "Wheel 3",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      3,          185,        "Wheel 4",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      4,          186,        "Wheel 5",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      5,          187,        "Wheel 6",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      6,          188,        "Wheel 7",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      7,          189,        "Wheel 8",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       1,         123,        KEY_EN_MEDIA_STOP,          KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Stop Key into new media keys row
+        {   0,      0,       2,         126,        KEY_EN_MEDIA_PREVIOUS,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Previous Track Key
+        {   0,      0,       3,         124,        KEY_EN_MEDIA_PLAY_PAUSE,    KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play Pause Key
+        {   0,      0,       4,         125,        KEY_EN_MEDIA_NEXT,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Next Tack Key
+        {   0,      0,       7,           1,        "Logo L",                   KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert 'Logo Left'
+        {   0,      0,       8,           3,        "Logo R",                   KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert 'Logo Right'
+        {   0,      0,      11,         128,        "Profile",                  KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Profile
+        {   0,      0,      12,         113,        "Light",                    KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Light key
+        {   0,      0,      13,         114,        "Lock",                     KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lock Key
+        {   0,      0,      14,         102,        KEY_EN_MEDIA_MUTE,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute Key
     }
 };
 
@@ -391,48 +263,6 @@ static const corsair_v2_device dark_core_pro_se_device =
     nullptr
 };
 
-/*-------------------------------------------------------------*\
-|  Corsair Harpoon Wireless 1B1C:1B5E                          |
-|                                                               |
-|  Zone "Logo"                                                  |
-|       Single                                                  |
-|                                                               |
-|  Zone "Scroll Wheel"                                          |
-|       Single                                                  |
-\*-------------------------------------------------------------*/
-static const corsair_v2_zone harpoon_indicator_zone =
-{
-    "Indicator",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const corsair_v2_zone harpoon_logo_zone =
-{
-    "Logo",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const corsair_v2_device harpoon_wireless_device =
-{
-    CORSAIR_HARPOON_WIRELESS_PID,
-    DEVICE_TYPE_MOUSE,
-    1,
-    2,
-    {
-        &harpoon_indicator_zone,
-        &harpoon_logo_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    },
-    nullptr
-};
-
 /*-------------------------------------------------------------*\
 |  Corsair Ironclaw Wireless 1B1C:1B4C                          |
 |                                                               |
@@ -498,135 +328,6 @@ static const corsair_v2_device ironclaw_wireless_device =
     nullptr
 };
 
-/*-------------------------------------------------------------*\
-|  Corsair Katar Pro 1B1C:1B93                                  |
-|                                                               |
-|  Zone "Scroll Wheel"                                          |
-|       Single                                                  |
-|                                                               |
-|  Zone "DPI"                                                   |
-|       Single                                                  |
-|                                                               |
-\*-------------------------------------------------------------*/
-static const corsair_v2_zone katar_pro_scroll_zone =
-{
-    "Scroll Wheel",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const corsair_v2_zone katar_pro_dpi_zone =
-{
-    "DPI",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const corsair_v2_device katar_pro_device =
-{
-    CORSAIR_KATAR_PRO_PID,
-    DEVICE_TYPE_MOUSE,
-    1,
-    2,
-    {
-        &katar_pro_scroll_zone,
-        &katar_pro_dpi_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    },
-    nullptr
-};
-
-/*-------------------------------------------------------------*\
-|  Corsair Katar Pro V2 1B1C:1BBA                               |
-|                                                               |
-|  Zone "Scroll Wheel"                                          |
-|       Single                                                  |
-|                                                               |
-|  Zone "DPI"                                                   |
-|       Single                                                  |
-|                                                               |
-\*-------------------------------------------------------------*/
-static const corsair_v2_zone katar_pro_v2_scroll_zone =
-{
-    "Scroll Wheel",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const corsair_v2_zone katar_pro_v2_dpi_zone =
-{
-    "DPI",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const corsair_v2_device katar_pro_v2_device =
-{
-    CORSAIR_KATAR_PRO_V2_PID,
-    DEVICE_TYPE_MOUSE,
-    1,
-    2,
-    {
-        &katar_pro_v2_scroll_zone,
-        &katar_pro_v2_dpi_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    },
-    nullptr
-};
-
-/*-------------------------------------------------------------*\
-|  Corsair Katar Pro XT 1B1C:1BAC                               |
-|                                                               |
-|  Zone "Scroll Wheel"                                          |
-|       Single                                                  |
-|                                                               |
-|  Zone "DPI"                                                   |
-|       Single                                                  |
-|                                                               |
-\*-------------------------------------------------------------*/
-static const corsair_v2_zone katar_pro_xt_scroll_zone =
-{
-    "Scroll Wheel",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const corsair_v2_zone katar_pro_xt_dpi_zone =
-{
-    "DPI",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const corsair_v2_device katar_pro_xt_device =
-{
-    CORSAIR_KATAR_PRO_XT_PID,
-    DEVICE_TYPE_MOUSE,
-    1,
-    2,
-    {
-        &katar_pro_xt_scroll_zone,
-        &katar_pro_xt_dpi_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    },
-    nullptr
-};
-
 /*-------------------------------------------------------------*\
 |  Corsair K55 RGB Pro 1B1C:1BA4                                |
 |                                                               |
@@ -723,38 +424,6 @@ static const corsair_v2_device k60_rgb_pro_lp_device =
     &corsair_K60_layout
 };
 
-/*-------------------------------------------------------------*\
-|  Corsair K60 RGB Pro TKL 1B1C:1BC7                            |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       6 Rows, 21 Columns                                      |
-\*-------------------------------------------------------------*/
-static const corsair_v2_zone k60_rgb_pro_tkl_zone =
-{
-    ZONE_EN_KEYBOARD,
-    ZONE_TYPE_MATRIX,
-    6,
-    21
-};
-
-static const corsair_v2_device k60_rgb_pro_tkl_device =
-{
-    CORSAIR_K60_RGB_PRO_TKL_PID,
-    DEVICE_TYPE_KEYBOARD,
-    6,
-    21,
-    {
-        &k60_rgb_pro_lp_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    },
-    &corsair_K60_tkl_layout
-};
-
 /*-------------------------------------------------------------*\
 |  Corsair K70 RGB TKL 1B1C:1B73                                |
 |                                                               |
@@ -819,129 +488,6 @@ static const corsair_v2_device k70_rgb_tkl_cs_device =
     &corsair_K70_TKL_cs_layout
 };
 
-/*-------------------------------------------------------------*\
-|  Corsair K70 RGB Pro 1B1C:1BC4                                |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       6 Rows, 21 Columns                                      |
-\*-------------------------------------------------------------*/
-static const corsair_v2_zone k70_rgb_pro_zone =
-{
-    ZONE_EN_KEYBOARD,
-    ZONE_TYPE_MATRIX,
-    6,
-    21
-};
-
-static const corsair_v2_device k70_rgb_pro_device =
-{
-    CORSAIR_K70_RGB_PRO_PID,
-    DEVICE_TYPE_KEYBOARD,
-    6,
-    21,
-    {
-        &k70_rgb_pro_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    },
-    &corsair_k70_layout
-};
-
-/*-------------------------------------------------------------*\
-|   Corsair K100 MX Red 1B1C:1B7D                               |
-|                                                               |
-|   Zone "Keyboard"                                             |
-|       Matrix                                                  |
-|       12 Rows, 24 Columns                                     |
-\*-------------------------------------------------------------*/
-
-static const corsair_v2_zone k100_mx_red_zone =
-{
-    ZONE_EN_KEYBOARD,
-    ZONE_TYPE_MATRIX,
-    12,
-    24
-};
-
-static const corsair_v2_device k100_mx_red_device =
-{
-    CORSAIR_K100_MXRED_PID,
-    DEVICE_TYPE_KEYBOARD,
-    12,
-    24,
-    {
-        &k100_mx_red_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    },
-    &corsair_k100_layout
-};
-
-/*-------------------------------------------------------------*\
-|   Corsair K100 RGB Optical V1 1B1C:1B7C                       |
-|                                                               |
-|   Zone "Keyboard"                                             |
-|       Matrix                                                  |
-|       12 Rows, 24 Columns                                     |
-\*-------------------------------------------------------------*/
-
-static const corsair_v2_zone k100_rgb_opt_zone =
-{
-    ZONE_EN_KEYBOARD,
-    ZONE_TYPE_MATRIX,
-    12,
-    24
-};
-
-static const corsair_v2_device k100_rgb_opt_v1_device =
-{
-    CORSAIR_K100_OPTICAL_V1_PID,
-    DEVICE_TYPE_KEYBOARD,
-    12,
-    24,
-    {
-        &k100_rgb_opt_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    },
-    &corsair_k100_layout
-};
-
-/*-------------------------------------------------------------*\
-|   Corsair K100 RGB Optical V2 1B1C:1BC5                       |
-|                                                               |
-|   Zone "Keyboard"                                             |
-|       Matrix                                                  |
-|       12 Rows, 24 Columns                                     |
-\*-------------------------------------------------------------*/
-
-static const corsair_v2_device k100_rgb_opt_v2_device =
-{
-    CORSAIR_K100_OPTICAL_V2_PID,
-    DEVICE_TYPE_KEYBOARD,
-    12,
-    24,
-    {
-        &k100_rgb_opt_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    },
-    &corsair_k100_layout
-};
-
 /*-------------------------------------------------------------*\
 |  Corsair M55 1B1C:1B70                                        |
 |                                                               |
@@ -1089,24 +635,15 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
     &k55_rgb_pro_device,
     &k60_rgb_pro_device,
     &k60_rgb_pro_lp_device,
-    &k60_rgb_pro_tkl_device,
-    &k70_rgb_pro_device,
     &k70_rgb_tkl_device,
     &k70_rgb_tkl_cs_device,
-    &k100_mx_red_device,
-    &k100_rgb_opt_v1_device,
-    &k100_rgb_opt_v2_device,
 
 /*-----------------------------------------------------------------*\
 |  MICE                                                             |
 \*-----------------------------------------------------------------*/
     &dark_core_se_device,
     &dark_core_pro_se_device,
-    &harpoon_wireless_device,
     &ironclaw_wireless_device,
-    &katar_pro_device,
-    &katar_pro_v2_device,
-    &katar_pro_xt_device,
     &m55_device,
     &m65_ultra_rgb_device,