OpenRGB Release Candidate 1.0rc3

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.cpp

@@ -35,6 +35,12 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
             write_cmd   = CORSAIR_V2_WRITE_WIRELESS_ID;
             pid         = GetAddress(0x12);
             break;
+
+        case CORSAIR_K57_RGB_WIRED_PID:
+            write_cmd   = 0x80;
+            light_ctrl  = CORSAIR_V2_LIGHT_CTRL1;
+            skip_reads  = true;
+            break;
     }
 
     /*---------------------------------------------------------*\
@@ -93,14 +99,17 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
     |   If lighting control endpoint 2 is unavailable           |
     |   then use endpoint 1.                                    |
     \*---------------------------------------------------------*/
-    result = StartTransaction(0);
-    if(result > 0)
+    if(light_ctrl == CORSAIR_V2_LIGHT_CTRL2)
     {
-        light_ctrl = CORSAIR_V2_LIGHT_CTRL1;
-        StartTransaction(0);
+        result = StartTransaction(0);
+        if(result > 0)
+        {
+            light_ctrl = CORSAIR_V2_LIGHT_CTRL1;
+            StartTransaction(0);
+        }
+        StopTransaction(0);
+        LOG_DEBUG("[%s] Lighting Endpoint set to %02X", device_name.c_str(), light_ctrl);
     }
-    StopTransaction(0);
-    LOG_DEBUG("[%s] Lighting Endpoint set to %02X", device_name.c_str(), light_ctrl);
 }
 
 CorsairPeripheralV2Controller::~CorsairPeripheralV2Controller()
@@ -171,7 +180,11 @@ void CorsairPeripheralV2Controller::SetRenderMode(corsair_v2_device_mode mode)
     buffer[5]   = mode;
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
-    hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+
+    if(!skip_reads)
+    {
+        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+    }
 }
 
 void CorsairPeripheralV2Controller::LightingControl(uint8_t opt1)
@@ -191,7 +204,11 @@ void CorsairPeripheralV2Controller::LightingControl(uint8_t opt1)
     buffer[5]   = 0x00;
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
-    hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+
+    if(!skip_reads)
+    {
+        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+    }
 }
 
 unsigned int CorsairPeripheralV2Controller::GetKeyboardLayout()
@@ -240,7 +257,11 @@ unsigned char CorsairPeripheralV2Controller::StartTransaction(uint8_t opt1)
     buffer[4]   = light_ctrl;
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
-    hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+
+    if(!skip_reads)
+    {
+        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+    }
 
     return buffer[2];
 }
@@ -257,11 +278,20 @@ void CorsairPeripheralV2Controller::StopTransaction(uint8_t opt1)
     buffer[4]   = opt1;
 
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
-    hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+
+    if(!skip_reads)
+    {
+        hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
+    }
 }
 
 void CorsairPeripheralV2Controller::ClearPacketBuffer()
 {
+    if(skip_reads)
+    {
+        return;
+    }
+
     uint8_t result          = 0;
     uint8_t buffer[CORSAIR_V2_PACKET_SIZE];
 
@@ -304,7 +334,11 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
     memcpy(&buffer[offset1], &data[0], copy_bytes);
 
     hid_write(dev, buffer, pkt_sze);
-    hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT_SHORT);
+
+    if(!skip_reads)
+    {
+        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT_SHORT);
+    }
 
     remaining              -= copy_bytes;
     buffer[2]               = CORSAIR_V2_CMD_BLK_WN;
@@ -325,7 +359,11 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
         memcpy(&buffer[offset2], &data[index], copy_bytes);
 
         hid_write(dev, buffer, pkt_sze);
-        hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT_SHORT);
+
+        if(!skip_reads)
+        {
+            hid_read_timeout(dev, buffer, pkt_sze, CORSAIR_V2_TIMEOUT_SHORT);
+        }
 
         remaining          -= copy_bytes;
     }

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.h

@@ -109,6 +109,7 @@ private:
 
     uint8_t                         write_cmd           = CORSAIR_V2_WRITE_WIRED_ID;
     uint16_t                        pkt_sze             = CORSAIR_V2_WRITE_SIZE;
+    bool                            skip_reads          = false;
     std::string                     firmware_version;
     std::string                     location;
 };

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2ControllerDetect.cpp

@@ -57,6 +57,7 @@ void DetectCorsairV2SoftwareControllers(hid_device_info* info, const std::string
 | Keyboards                                                                                             |
 \*-----------------------------------------------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K55_RGB_PRO_PID,                1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K57 RGB (Wired)",                 DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K57_RGB_WIRED_PID,              1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO Low Profile",         DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_LP_PID,             1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO TKL Black",           DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_TKL_B_PID,          1,  0xFF42);

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.cpp

@@ -48,6 +48,31 @@ std::vector<unsigned int> corsair_full_size_values =
 /*-------------------------------------------------------------------------*\
 |  KEYMAPS                                                                  |
 \*-------------------------------------------------------------------------*/
+keyboard_keymap_overlay_values corsair_K57_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
+    {
+        corsair_full_size_values,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Name,                       Alternate Name,             OpCode                              |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       17,        0,          "Power/Wireless Indicator", KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Profile into new row
+        {   0,      0,       18,        1,          "Lock/Macro Indicator",     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Light key
+        {   0,      1,       0,         131,        "Key: G1",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert G1 key
+        {   0,      2,       0,         132,        "Key: G2",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert G2 key
+        {   0,      3,       0,         133,        "Key: G3",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert G3 key
+        {   0,      4,       0,         134,        "Key: G4",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert G4 key
+        {   0,      5,       0,         135,        "Key: G5",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert G5 key
+        {   0,      6,       0,         136,        "Key: G6",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert G6 key
+    }
+};
+
 keyboard_keymap_overlay_values corsair_K60_layout
 {
     KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
@@ -116,12 +141,14 @@ keyboard_keymap_overlay_values corsair_k70_pro_layout
         {   0,      0,       0,         128,        "Profile",                  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Profile into new row
         {   0,      0,       1,         113,        "Light",                    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Light key
         {   0,      0,       2,         114,        "Lock",                     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lock Key
-        {   0,      0,      10,         191,        "Logo",                     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Logo
+        {   0,      0,      10,         138,        "Logo",                     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Logo
         {   0,      0,      18,         102,        KEY_EN_MEDIA_MUTE,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute Key
         {   0,      1,      17,         123,        KEY_EN_MEDIA_STOP,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Stop Key
         {   0,      1,      18,         126,        KEY_EN_MEDIA_PREVIOUS,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Previous Track Key
         {   0,      1,      19,         124,        KEY_EN_MEDIA_PLAY_PAUSE,    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play Pause Key
         {   0,      1,      20,         125,        KEY_EN_MEDIA_NEXT,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Next Tack Key
+        {   0,      6,       5,         140,        KEY_EN_SPACE,               KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert spacebar L
+        {   0,      6,       7,         141,        KEY_EN_SPACE,               KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert spacebar R
     }
 };
 
@@ -167,10 +194,10 @@ keyboard_keymap_overlay_values corsair_K70_CORE_TKL_layout
         | Edit Keys                                                                                                                             |
         |   Zone,   Row,    Column,     Value,      Name,                       Alternate Name,             OpCode,                             |
         \*-------------------------------------------------------------------------------------------------------------------------------------*/
-        {   0,      0,      14,         70,         KEY_EN_MEDIA_MUTE,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,         },  // Swap PRSC with Mute 
+        {   0,      0,      14,         70,         KEY_EN_MEDIA_MUTE,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,         },  // Swap PRSC with Mute
         {   0,      0,      15,         71,         KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,         },  // Remove SCLK
-        {   0,      0,      16,         72,         KEY_EN_MEDIA_VOLUME_UP,     KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,         },  // Swap PSBK with Volume Potion Up 
-        
+        {   0,      0,      16,         72,         KEY_EN_MEDIA_VOLUME_UP,     KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,         },  // Swap PSBK with Volume Potion Up
+
     }
 };
 
@@ -772,6 +799,38 @@ static const corsair_v2_device k55_rgb_pro_device =
     nullptr
 };
 
+/*-------------------------------------------------------------*\
+|  Corsair K57 RGB (Wired) 1B1C:1B6E                            |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       7 Rows, 22 Columns                                      |
+\*-------------------------------------------------------------*/
+static const corsair_v2_zone k57_rgb_wired_zone =
+{
+    ZONE_EN_KEYBOARD,
+    ZONE_TYPE_MATRIX,
+    7,
+    22
+};
+
+static const corsair_v2_device k57_rgb_wired_device =
+{
+    CORSAIR_K57_RGB_WIRED_PID,
+    DEVICE_TYPE_KEYBOARD,
+    7,
+    22,
+    {
+        &k57_rgb_wired_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    &corsair_K57_layout
+};
+
 /*-------------------------------------------------------------*\
 |  Corsair K60 RGB Pro 1B1C:1BA0                                |
 |                                                               |
@@ -1461,6 +1520,7 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
     &k55_rgb_pro_device,
+    &k57_rgb_wired_device,
     &k60_rgb_pro_device,
     &k60_rgb_pro_lp_device,
     &k60_rgb_pro_tkl_device_b,

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.h

@@ -69,6 +69,8 @@ typedef struct
 | Corsair V2 Protocol Keyboards                         |
 \*-----------------------------------------------------*/
 #define CORSAIR_K55_RGB_PRO_PID                     0x1BA4
+#define CORSAIR_K57_RGB_WIRED_PID                   0x1B6E
+#define CORSAIR_K57_RGB_WIRELESS_PID                0x1B62
 #define CORSAIR_K60_RGB_PRO_PID                     0x1BA0
 #define CORSAIR_K60_RGB_PRO_LP_PID                  0x1BAD
 #define CORSAIR_K60_RGB_PRO_TKL_B_PID               0x1BC7

Controllers/CorsairWirelessController/CorsairWirelessController.cpp

@@ -1,217 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairWirelessController.cpp                             |
-|                                                           |
-|   Driver for Corsair wireless keyboard                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include "CorsairWirelessController.h"
-#include "StringUtils.h"
-
-using namespace std::chrono_literals;
-
-CorsairWirelessController::CorsairWirelessController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-
-    type        = DEVICE_TYPE_KEYBOARD;
-
-    EnterDirectMode();
-}
-
-CorsairWirelessController::~CorsairWirelessController()
-{
-    hid_close(dev);
-}
-
-device_type CorsairWirelessController::GetDeviceType()
-{
-    return type;
-}
-
-std::string CorsairWirelessController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string CorsairWirelessController::GetFirmwareString()
-{
-    return firmware_version;
-}
-
-std::string CorsairWirelessController::GetName()
-{
-    return name;
-}
-
-std::string CorsairWirelessController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    return(StringUtils::wstring_to_string(serial_string));
-}
-
-void CorsairWirelessController::SetLEDs(std::vector<RGBColor>colors)
-{
-    unsigned char buf[3 * 137];
-
-    for(int color = 0; color < 137; color++)
-    {
-        buf[0 + color]   = RGBGetRValue(colors[color]);
-        buf[137 + color] = RGBGetGValue(colors[color]);
-        buf[274+color]   = RGBGetBValue(colors[color]);
-    }
-
-    StartDirectMode();
-
-    SendDirectFrame(true,  &buf[0]);
-    SendDirectFrame(false, &buf[57]);
-    SendDirectFrame(false, &buf[118]);
-    SendDirectFrame(false, &buf[179]);
-    SendDirectFrame(false, &buf[240]);
-    SendDirectFrame(false, &buf[301]);
-    SendDirectFrame(false, &buf[362]);
-}
-
-void CorsairWirelessController::SetName(std::string device_name)
-{
-    name = device_name;
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void CorsairWirelessController::EnterDirectMode()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Submit Mouse Colors packet                     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x80;
-    usb_buf[0x02]   = 0x01;
-    usb_buf[0x03]   = 0x03;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = 0x02;
-
-    /*-----------------------------------------------------*\
-    | Send packet using feature reports, as headset stand   |
-    | seems to not update completely using HID writes       |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-}
-
-void CorsairWirelessController::StartDirectMode()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Submit Mouse Colors packet                     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x80;
-    usb_buf[0x02]   = 0x0D;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet using feature reports, as headset stand   |
-    | seems to not update completely using HID writes       |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-}
-
-void CorsairWirelessController::ExitDirectMode()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Submit Mouse Colors packet                     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x80;
-    usb_buf[0x02]   = 0x01;
-    usb_buf[0x03]   = 0x03;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet using feature reports, as headset stand   |
-    | seems to not update completely using HID writes       |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-}
-
-void CorsairWirelessController::SendDirectFrame(bool first_frame, unsigned char* data)
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Submit Mouse Colors packet                     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x80;
-    usb_buf[0x02]   = first_frame ? 0x06 : 0x07;
-    usb_buf[0x03]   = 0x00;
-
-    if(first_frame)
-    {
-        usb_buf[0x04]   = 0x9B;
-        usb_buf[0x05]   = 0x01;
-    }
-
-    /*-----------------------------------------------------*\
-    | Copy in colors in <RED> <GREEN> <BLUE> order          |
-    \*-----------------------------------------------------*/
-    if(first_frame)
-    {
-        memcpy(&usb_buf[0x08], data, 57);
-    }
-    else
-    {
-        memcpy(&usb_buf[0x04], data, 61);
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet using feature reports, as headset stand   |
-    | seems to not update completely using HID writes       |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}

Controllers/CorsairWirelessController/CorsairWirelessController.h

@@ -1,45 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairWirelessController.h                               |
-|                                                           |
-|   Driver for Corsair wireless keyboard                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
-class CorsairWirelessController
-{
-public:
-    CorsairWirelessController(hid_device* dev_handle, const char* path);
-    ~CorsairWirelessController();
-
-    device_type     GetDeviceType();
-    std::string     GetDeviceLocation();
-    std::string     GetFirmwareString();
-    std::string     GetName();
-    std::string     GetSerialString();
-
-    void            SetLEDs(std::vector<RGBColor> colors);
-    void            SetName(std::string device_name);
-
-private:
-    hid_device*             dev;
-
-    std::string             firmware_version;
-    std::string             location;
-    std::string             name;
-    device_type             type;
-
-    void            EnterDirectMode();
-    void            ExitDirectMode();
-    void            StartDirectMode();
-    void            SendDirectFrame(bool first_frame, unsigned char* data);
-};

Controllers/CorsairWirelessController/CorsairWirelessControllerDetect.cpp

@@ -1,62 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairWirelessControllerDetect.cpp                       |
-|                                                           |
-|   Detector for Corsair wireless keyboard                  |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
-#include "Detector.h"
-#include "CorsairWirelessController.h"
-#include "RGBController.h"
-#include "RGBController_CorsairWireless.h"
-
-/*-----------------------------------------------------*\
-| Corsair vendor ID                                     |
-\*-----------------------------------------------------*/
-#define CORSAIR_VID                     0x1B1C
-
-/*-----------------------------------------------------*\
-| Keyboard product IDs                                  |
-\*-----------------------------------------------------*/
-#define CORSAIR_K57_RGB_WIRED_PID       0x1B6E
-#define CORSAIR_K57_RGB_WIRELESS_PID    0x1B62
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairWirelessControllers                                                       *
-*                                                                                          *
-*       Tests the USB address to see if a Corsair RGB Keyboard controller exists there.    *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairWirelessControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        CorsairWirelessController* controller = new CorsairWirelessController(dev, info->path);
-        controller->SetName(name);
-
-        if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
-        {
-            RGBController_CorsairWireless* rgb_controller = new RGBController_CorsairWireless(controller);
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
-        }
-        else
-        {
-            delete controller;
-        }
-    }
-}   /* DetectCorsairWirelessControllers() */
-
-/*-----------------------------------------------------------------------------------------------------*\
-| Keyboards                                                                                             |
-\*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Corsair K57 RGB (Wired)",         DetectCorsairWirelessControllers,   CORSAIR_VID,    CORSAIR_K57_RGB_WIRED_PID,     1,  0xFF42, 1);
-//REGISTER_HID_DETECTOR_IPU("Corsair K57 RGB (Wireless)",      DetectCorsairWirelessControllers,   CORSAIR_VID,    CORSAIR_K57_RGB_WIRELESS_PID,  1,  0xFF42, 1);

Controllers/CorsairWirelessController/RGBController_CorsairWireless.cpp

@@ -1,342 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_CorsairWireless.cpp                         |
-|                                                           |
-|   RGBController for Corsair wireless keyboard             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include "RGBController_CorsairWireless.h"
-
-using namespace std::chrono_literals;
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-static unsigned int matrix_map[7][24] =
-    { {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,   0,   1,  NA,  NA,  NA },
-      { 131,  41,  NA,  58,  59,  60,  61,  NA,  62,  63,  64,  65,  NA,  66,  67,  68,  69,  70,  71,  72,  NA,  NA,  NA,  NA },
-      { 132,  53,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  NA,  45,  46,  42,  NA,  73,  74,  75,  83,  84,  85,  86 },
-      { 133,  43,  NA,  20,  26,   8,  21,  NA,  23,  28,  24,  12,  18,  19,  47,  48,  49,  76,  77,  78,  95,  96,  97,  87 },
-      { 134,  57,  NA,   4,  22,   7,   9,  NA,  10,  11,  13,  14,  15,  51,  52,  NA,  40,  NA,  NA,  NA,  92,  93,  94,  NA },
-      { 135, 106,  NA,  29,  27,   6,  25,  NA,   5,  NA,  17,  16,  54,  55,  56, 110,  NA,  NA,  82,  NA,  89,  90,  91,  88 },
-      { 136, 105, 108, 107,  NA,  NA,  NA,  NA,  44,  NA,  NA,  NA,  NA, 111, 122, 101, 109,  80,  81,  79,  98,  NA,  99,  NA } };
-
-static const char* zone_names[] =
-{
-    ZONE_EN_KEYBOARD,
-};
-
-static const unsigned int zone_sizes[] =
-{
-    137
-};
-
-static const zone_type zone_types[] =
-{
-    ZONE_TYPE_MATRIX,
-};
-
-static const char* led_names[] =
-{
-    "Power/Wireless Indicator",
-    "Lock/Macro Indicator",
-    "N/A",
-    "N/A",
-    KEY_EN_A,
-    KEY_EN_B,
-    KEY_EN_C,
-    KEY_EN_D,
-    KEY_EN_E,
-    KEY_EN_F,
-    KEY_EN_G,
-    KEY_EN_H,
-    KEY_EN_I,
-    KEY_EN_J,
-    KEY_EN_K,
-    KEY_EN_L,
-    KEY_EN_M,
-    KEY_EN_N,
-    KEY_EN_O,
-    KEY_EN_P,
-    KEY_EN_Q,
-    KEY_EN_R,
-    KEY_EN_S,
-    KEY_EN_T,
-    KEY_EN_U,
-    KEY_EN_V,
-    KEY_EN_W,
-    KEY_EN_X,
-    KEY_EN_Y,
-    KEY_EN_Z,
-    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_ANSI_ENTER,
-    KEY_EN_ESCAPE,
-    KEY_EN_BACKSPACE,
-    KEY_EN_TAB,
-    KEY_EN_SPACE,
-    KEY_EN_MINUS,
-    KEY_EN_EQUALS,
-    KEY_EN_LEFT_BRACKET,
-    KEY_EN_RIGHT_BRACKET,
-    KEY_EN_ANSI_BACK_SLASH,
-    KEY_EN_UNUSED,
-    KEY_EN_SEMICOLON,
-    KEY_EN_QUOTE,
-    KEY_EN_BACK_TICK,
-    KEY_EN_COMMA,
-    KEY_EN_PERIOD,
-    KEY_EN_FORWARD_SLASH,
-    KEY_EN_CAPS_LOCK,
-    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_INSERT,
-    KEY_EN_HOME,
-    KEY_EN_PAGE_UP,
-    KEY_EN_DELETE,
-    KEY_EN_END,
-    KEY_EN_PAGE_DOWN,
-    KEY_EN_RIGHT_ARROW,
-    KEY_EN_LEFT_ARROW,
-    KEY_EN_DOWN_ARROW,
-    KEY_EN_UP_ARROW,
-    KEY_EN_NUMPAD_LOCK,
-    KEY_EN_NUMPAD_DIVIDE,
-    KEY_EN_NUMPAD_TIMES,
-    KEY_EN_NUMPAD_MINUS,
-    KEY_EN_NUMPAD_PLUS,
-    KEY_EN_NUMPAD_ENTER,
-    KEY_EN_NUMPAD_1,
-    KEY_EN_NUMPAD_2,
-    KEY_EN_NUMPAD_3,
-    KEY_EN_NUMPAD_4,
-    KEY_EN_NUMPAD_5,
-    KEY_EN_NUMPAD_6,
-    KEY_EN_NUMPAD_7,
-    KEY_EN_NUMPAD_8,
-    KEY_EN_NUMPAD_9,
-    KEY_EN_NUMPAD_0,
-    KEY_EN_NUMPAD_PERIOD,
-    KEY_EN_UNUSED,
-    KEY_EN_MENU,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_LEFT_CONTROL,
-    KEY_EN_LEFT_SHIFT,
-    KEY_EN_LEFT_ALT,
-    KEY_EN_LEFT_WINDOWS,
-    KEY_EN_RIGHT_CONTROL,
-    KEY_EN_RIGHT_SHIFT,
-    KEY_EN_RIGHT_ALT,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_RIGHT_FUNCTION,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    KEY_EN_UNUSED,
-    "Key: G1",
-    "Key: G2",
-    "Key: G3",
-    "Key: G4",
-    "Key: G5",
-    "Key: G6",
-};
-
-/**------------------------------------------------------------------*\
-    @name Corsair Wireless Peripheral
-    @category Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectCorsairWirelessControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_CorsairWireless::RGBController_CorsairWireless(CorsairWirelessController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = controller->GetName();
-    vendor      = "Corsair";
-    description = "Corsair RGB Peripheral Device";
-    type        = controller->GetDeviceType();
-    version     = controller->GetFirmwareString();
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-
-    /*-----------------------------------------------------*\
-    | The Corsair Lighting Node Pro requires a packet within|
-    | 20 seconds of sending the lighting change in order    |
-    | to not revert back into rainbow mode.  Start a thread |
-    | to continuously send a keepalive packet every 5s      |
-    \*-----------------------------------------------------*/
-    keepalive_thread_run = true;
-    keepalive_thread = new std::thread(&RGBController_CorsairWireless::KeepaliveThread, this);
-}
-
-RGBController_CorsairWireless::~RGBController_CorsairWireless()
-{
-    /*-----------------------------------------------------*\
-    | 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].matrix_map != NULL)
-        {
-            delete zones[zone_index].matrix_map;
-        }
-    }
-
-    delete controller;
-}
-
-void RGBController_CorsairWireless::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Determine number of zones                                 |
-    |   For now, keyboard has 2 zones and mousemat has 1        |
-    \*---------------------------------------------------------*/
-    unsigned int num_zones = 1;
-
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    unsigned int total_led_count = 0;
-    for(unsigned int zone_idx = 0; zone_idx < num_zones; 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 = 7;
-            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 += new_zone.leds_count;
-    }
-
-    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
-    {
-        led new_led;
-
-        new_led.name                    = led_names[led_idx];
-
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_CorsairWireless::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_CorsairWireless::DeviceUpdateLEDs()
-{
-    last_update_time = std::chrono::steady_clock::now();
-
-    controller->SetLEDs(colors);
-}
-
-void RGBController_CorsairWireless::UpdateZoneLEDs(int /*zone*/)
-{
-    controller->SetLEDs(colors);
-}
-
-void RGBController_CorsairWireless::UpdateSingleLED(int /*led*/)
-{
-    controller->SetLEDs(colors);
-}
-
-void RGBController_CorsairWireless::DeviceUpdateMode()
-{
-
-}
-
-void RGBController_CorsairWireless::KeepaliveThread()
-{
-    while(keepalive_thread_run.load())
-    {
-        if(active_mode == 0)
-        {
-            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(5000))
-            {
-                DeviceUpdateLEDs();
-            }
-        }
-        std::this_thread::sleep_for(1000ms);
-    }
-}

Controllers/CorsairWirelessController/RGBController_CorsairWireless.h

@@ -1,43 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_CorsairWireless.h                           |
-|                                                           |
-|   RGBController for Corsair wireless keyboard             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "CorsairWirelessController.h"
-
-class RGBController_CorsairWireless : public RGBController
-{
-public:
-    RGBController_CorsairWireless(CorsairWirelessController* controller_ptr);
-    ~RGBController_CorsairWireless();
-
-    int         physical_layout;
-    int         logical_layout;
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-    void        KeepaliveThread();
-
-private:
-    CorsairWirelessController*                          controller;
-    std::thread*                                        keepalive_thread;
-    std::atomic<bool>                                   keepalive_thread_run;
-    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
-};

Controllers/LogitechController/LogitechControllerDetect.cpp

@@ -366,6 +366,106 @@ void DetectLogitechKeyboardG915(hid_device_info* info, const std::string& name)
     }
 }
 
+static bool ProbeG915ReceiverName(hid_device* dev, std::string& out_name)
+{
+    /*---------------------------------------------------------*\n    | HID++ short message name probe.                           |
+    | Request:  10 01 03 0E 00 00 00  (get name length)         |
+    | Request:  10 01 03 1E 00 00 00  (get name string)         |
+    | Response: 11 01 03 1E <name bytes...>                     |
+    | Verified against G915 TKL (PID 0xC547) which returns      |
+    | "G915 TKL LIGHTSP" (truncated, full: G915 TKL LIGHTSPEED) |
+    \*---------------------------------------------------------*/
+    const unsigned char req_len[7]  = { 0x10, 0x01, 0x03, 0x0E, 0x00, 0x00, 0x00 };
+    const unsigned char req_name[7] = { 0x10, 0x01, 0x03, 0x1E, 0x00, 0x00, 0x00 };
+    unsigned char resp[64] = { 0 };
+
+    hid_write(dev, req_len, sizeof(req_len));
+    hid_read_timeout(dev, resp, sizeof(resp), 100);
+
+    hid_write(dev, req_name, sizeof(req_name));
+    for(int attempt = 0; attempt < 3; attempt++)
+    {
+        int rd = hid_read_timeout(dev, resp, sizeof(resp), 200);
+        if(rd < 8)
+        {
+            continue;
+        }
+        if(resp[0] == 0x11 && resp[1] == 0x01 && resp[2] == 0x03 && resp[3] == 0x1E)
+        {
+            std::string name_str;
+            for(int i = 4; i < rd; i++)
+            {
+                if(resp[i] == 0x00)
+                {
+                    break;
+                }
+                name_str.push_back(static_cast<char>(resp[i]));
+            }
+            out_name = name_str;
+            return true;
+        }
+    }
+    return false;
+}
+
+void DetectLogitechKeyboardG915Receiver2(hid_device_info* info, const std::string& name)
+{
+    /*---------------------------------------------------------*\
+    | PID 0xC547 is shared by multiple Logitech keyboards.      |
+    | Use a HID++ name probe to identify the exact device and   |
+    | route to the correct controller.                          |
+    |                                                           |
+    | Known devices behind this PID:                            |
+    |   "G915 TKL LIGHTSP..." -> G915 TKL (is_tkl = true)      |
+    |   "G915 LIGHTSP..."     -> G915 full-size (is_tkl = false)|
+    |   "G515..."             -> G515 (not handled here)        |
+    \*---------------------------------------------------------*/
+    hid_device* dev = hid_open_path(info->path);
+    if(!dev)
+    {
+        return;
+    }
+
+    std::string probed_name;
+    bool ok = ProbeG915ReceiverName(dev, probed_name);
+
+    if(!ok)
+    {
+        LOG_DEBUG("[LogitechControllerDetect] 0xC547 name probe failed, skipping device");
+        hid_close(dev);
+        return;
+    }
+
+    LOG_DEBUG("[LogitechControllerDetect] 0xC547 probe returned name=\"%s\"", probed_name.c_str());
+
+    /*---------------------------------------------------------*\
+    | Route based on probed name. Check for TKL before full    |
+    | G915 since both contain "G915".                          |
+    \*---------------------------------------------------------*/
+    if(probed_name.find("G915 TKL") != std::string::npos)
+    {
+        LogitechG915Controller*     controller     = new LogitechG915Controller(dev, false, name);
+        RGBController_LogitechG915* rgb_controller = new RGBController_LogitechG915(controller, true);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+    else if(probed_name.find("G915") != std::string::npos)
+    {
+        LogitechG915Controller*     controller     = new LogitechG915Controller(dev, false, name);
+        RGBController_LogitechG915* rgb_controller = new RGBController_LogitechG915(controller, false);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+    else
+    {
+        /*-----------------------------------------------------*\
+        | Unknown device (e.g. G515 or future hardware).        |
+        | Close and leave it for another detector to claim.     |
+        \*-----------------------------------------------------*/
+        LOG_DEBUG("[LogitechControllerDetect] 0xC547 unrecognised device name \"%s\", skipping",
+                  probed_name.c_str());
+        hid_close(dev);
+    }
+}
+
 void DetectLogitechKeyboardG915Wired(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -889,7 +989,7 @@ REGISTER_HID_DETECTOR_IP ("Logitech G910 Orion Spectrum",                   Dete
 REGISTER_HID_DETECTOR_IP ("Logitech G Pro RGB Mechanical Gaming Keyboard",  DetectLogitechKeyboardGPro, LOGITECH_VID, LOGITECH_GPRO_KEYBOARD_1_PID,         1, 0xFF43);
 
 REGISTER_HID_DETECTOR_IPU("Logitech G915 Wireless RGB Mechanical Gaming Keyboard",              DetectLogitechKeyboardG915,      LOGITECH_VID, LOGITECH_G915_RECEIVER_PID,      2, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G915 Wireless RGB Mechanical Gaming Keyboard",              DetectLogitechKeyboardG915,      LOGITECH_VID, LOGITECH_G915_RECEIVER_2_PID,    2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G915 Wireless RGB Mechanical Gaming Keyboard (Receiver 2)", DetectLogitechKeyboardG915Receiver2, LOGITECH_VID, LOGITECH_G915_RECEIVER_2_PID, 2, 0xFF00, 2);
 REGISTER_HID_DETECTOR_IPU("Logitech G915 Wireless RGB Mechanical Gaming Keyboard (Wired)",      DetectLogitechKeyboardG915Wired, LOGITECH_VID, LOGITECH_G915_WIRED_PID,         2, 0xFF00, 2);
 REGISTER_HID_DETECTOR_IPU("Logitech G915TKL Wireless RGB Mechanical Gaming Keyboard",           DetectLogitechKeyboardG915,      LOGITECH_VID, LOGITECH_G915TKL_RECEIVER_PID,   2, 0xFF00, 2);
 REGISTER_HID_DETECTOR_IPU("Logitech G915TKL Wireless RGB Mechanical Gaming Keyboard (Wired)",   DetectLogitechKeyboardG915Wired, LOGITECH_VID, LOGITECH_G915TKL_WIRED_PID,      2, 0xFF00, 2);

Controllers/LogitechController/LogitechG915Controller/LogitechG915Controller.cpp

@@ -146,7 +146,7 @@ void LogitechG915Controller::SendCommit()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev_handle, usb_buf, 4);
+    hid_write(dev_handle, usb_buf, MESSAGE_LEN);
     hid_read_timeout(dev_handle, usb_buf, RESPONSE_LEN, LOGITECH_READ_TIMEOUT);
 }
 
@@ -170,7 +170,7 @@ void LogitechG915Controller::BeginModeSet()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev_handle, usb_buf, 4);
+    hid_write(dev_handle, usb_buf, MESSAGE_LEN);
     hid_read(dev_handle,  usb_buf, RESPONSE_LEN);
 
     /*-----------------------------------------------------*\
@@ -189,7 +189,7 @@ void LogitechG915Controller::BeginModeSet()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev_handle, usb_buf, 4);
+    hid_write(dev_handle, usb_buf, MESSAGE_LEN);
     hid_read(dev_handle,  usb_buf, RESPONSE_LEN);
 }
 
@@ -216,7 +216,7 @@ void LogitechG915Controller::InitializeModeSet()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev_handle, usb_buf, 7);
+    hid_write(dev_handle, usb_buf, MESSAGE_LEN);
     hid_read(dev_handle,  usb_buf, RESPONSE_LEN);
 }
 
@@ -240,7 +240,7 @@ void LogitechG915Controller::InitializeDirect()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev_handle, usb_buf, 4);
+    hid_write(dev_handle, usb_buf, MESSAGE_LEN);
     hid_read(dev_handle,  usb_buf, RESPONSE_LEN);
 
     /*-----------------------------------------------------*\
@@ -259,7 +259,7 @@ void LogitechG915Controller::InitializeDirect()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev_handle, usb_buf, 4);
+    hid_write(dev_handle, usb_buf, MESSAGE_LEN);
     hid_read(dev_handle,  usb_buf, RESPONSE_LEN);
 
     /*-----------------------------------------------------*\
@@ -279,7 +279,7 @@ void LogitechG915Controller::InitializeDirect()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev_handle, usb_buf, 17);
+    hid_write(dev_handle, usb_buf, MESSAGE_LEN);
     hid_read(dev_handle,  usb_buf, MESSAGE_LEN);
 
     /*-----------------------------------------------------*\
@@ -300,7 +300,7 @@ void LogitechG915Controller::InitializeDirect()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev_handle, usb_buf, 17);
+    hid_write(dev_handle, usb_buf, MESSAGE_LEN);
     hid_read(dev_handle,  usb_buf, RESPONSE_LEN);
 }
 
@@ -355,7 +355,7 @@ void LogitechG915Controller::SendDirectFrame
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev_handle, usb_buf, HEADER_SIZE + length);
+    hid_write(dev_handle, usb_buf, MESSAGE_LEN);
     hid_read_timeout(dev_handle, usb_buf, RESPONSE_LEN, LOGITECH_READ_TIMEOUT);
 }
 
@@ -370,7 +370,7 @@ void LogitechG915Controller::SendMode
     unsigned char       blue
     )
 {
-    unsigned char usb_buf[HEADER_SIZE + 13];
+    unsigned char usb_buf[MESSAGE_LEN];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -433,6 +433,6 @@ void LogitechG915Controller::SendMode
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev_handle, usb_buf, HEADER_SIZE + 13);
+    hid_write(dev_handle, usb_buf, MESSAGE_LEN);
     hid_read(dev_handle, usb_buf, RESPONSE_LEN);
 }

Controllers/LogitechController/LogitechHIDPP20Controller/LogitechHIDPP20Controller.h

@@ -795,9 +795,9 @@ private:
     | This is our own host-side animation, independent  |
     | of any firmware dim/sleep timers.                 |
     \*-------------------------------------------------*/
-    static const int DIM_STEPS       = 25;
-    static const int DIM_INTERVAL_MS = 200;
-    static const int DIM_TARGET_PCT  = 50;
+    #define DIM_STEPS                           25
+    #define DIM_INTERVAL_MS                     200
+    #define DIM_TARGET_PCT                      50
     std::atomic<int> dim_brightness_pct;    // 100=full, 50=dimmed
     int              dim_step;
     std::chrono::steady_clock::time_point next_dim_time;

Controllers/MSIMysticLightController/MSIMysticLight185Controller/MSIMysticLight185Controller.cpp

@@ -307,6 +307,7 @@ static const mystic_light_185_config board_configs[] =
     { 0x7D32, 1,  0,  0, 1, &zones_set10, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG Z690 TOMAHAWK WIFI DDR4
     { 0x7D33, 6,  0,  0, 2, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // PRO Z790-VC WIFI
     { 0x7D36, 6,  0,  0, 2, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // PRO Z690-P DDR4
+    { 0x7D37, 6,  0,  0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // PRO B760M-VC WIFI (MS-7D37) - fans on JRAINBOW2
     { 0x7D38, 0,  0,  0, 1, &zones_set1,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MEG Z590 UNIFY-X
     { 0x7D40, 0,  0,  0, 1, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MPG B760i EDGE WIFI DDR4
     { 0x7D41, 6,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG B660M TOMAHAWK WIFI DDR4

Controllers/MSIMysticLightController/MSIMysticLight761Controller/MSIMysticLight761Controller.cpp

@@ -72,35 +72,37 @@ static const std::string board_names[] =
     "MSI MAG B850 TOMAHAWK WIFI (MS-7E53)",
     "MSI MEG Z890 UNIFY-X (MS-7E20)",
     "MSI PRO X870E-S EVO WIFI (MS-7E86)",
+    "MSI PRO Z890-P WIFI (MS-7E34)",
 };
 
 static const mystic_light_761_config board_configs[] =
 {
-    { &(board_names[0]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI X870 TOMAHAWK WIFI
-    { &(board_names[1]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI MAG B850M MORTAR WIFI
-    { &(board_names[2]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI MPG B850I EDGE TI WIFI
-    { &(board_names[3]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI X870 GAMING PLUS WIFI
-    { &(board_names[4]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI B850 GAMING PLUS WIFI6E
-    { &(board_names[5]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI B850M GAMING PLUS WIFI6E
-    { &(board_names[6]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI MPG X870E CARBON WIFI
-    { &(board_names[7]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI Z890 GAMING PLUS WIFI
-    { &(board_names[8]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI X870E GAMING PLUS WIFI
-    { &(board_names[9]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI MAG X870E TOMAHAWK WIFI
-    { &(board_names[10]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI PRO B850-P WIFI (MS-7E56)
-    { &(board_names[11]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI B850M GAMING PLUS WIFI
-    { &(board_names[12]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI PRO X870E-P WIFI
-    { &(board_names[13]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI MPG X870I EDGE TI EVO WIFI (MS-7E50)
-    { &(board_names[14]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI B850 GAMING PLUS WIFI (MS-7E56)
-    { &(board_names[15]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI PRO X870-P WIFI
-    { &(board_names[16]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI MPG X870E EDGE TI WIFI
-    { &(board_names[17]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI MAG B850 TOMAHAWK MAX WIFI
-    { &(board_names[18]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI PRO B850M-P WIFI (MS-7E71)
-    { &(board_names[19]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI MAG Z890 TOMAHAWK WIFI (MS-7E32)
-    { &(board_names[20]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI MPG B850 EDGE TI WIFI (MS-7E62)
-    { &(board_names[21]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },    // MSI PRO B850M-VC WIFI6E (MS-7E71)
-    { &(board_names[22]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI MAG B850 TOMAHAWK WIFI (MS-7E53)
-    { &(board_names[23]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI MEG Z890 UNIFY-X (MS-7E20)
-    { &(board_names[24]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },   // MSI PRO X870E-S EVO WIFI (MS-7E86)
+    { &(board_names[0]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },      // MSI X870 TOMAHAWK WIFI
+    { &(board_names[1]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },      // MSI MAG B850M MORTAR WIFI
+    { &(board_names[2]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },      // MSI MPG B850I EDGE TI WIFI
+    { &(board_names[3]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },      // MSI X870 GAMING PLUS WIFI
+    { &(board_names[4]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },      // MSI B850 GAMING PLUS WIFI6E
+    { &(board_names[5]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },      // MSI B850M GAMING PLUS WIFI6E
+    { &(board_names[6]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },      // MSI MPG X870E CARBON WIFI
+    { &(board_names[7]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },      // MSI Z890 GAMING PLUS WIFI
+    { &(board_names[8]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },      // MSI X870E GAMING PLUS WIFI
+    { &(board_names[9]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },      // MSI MAG X870E TOMAHAWK WIFI
+    { &(board_names[10]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO B850-P WIFI (MS-7E56)
+    { &(board_names[11]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI B850M GAMING PLUS WIFI
+    { &(board_names[12]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO X870E-P WIFI
+    { &(board_names[13]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MPG X870I EDGE TI EVO WIFI (MS-7E50)
+    { &(board_names[14]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI B850 GAMING PLUS WIFI (MS-7E56)
+    { &(board_names[15]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO X870-P WIFI
+    { &(board_names[16]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MPG X870E EDGE TI WIFI
+    { &(board_names[17]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MAG B850 TOMAHAWK MAX WIFI
+    { &(board_names[18]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO B850M-P WIFI (MS-7E71)
+    { &(board_names[19]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MAG Z890 TOMAHAWK WIFI (MS-7E32)
+    { &(board_names[20]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MPG B850 EDGE TI WIFI (MS-7E62)
+    { &(board_names[21]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO B850M-VC WIFI6E (MS-7E71)
+    { &(board_names[22]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MAG B850 TOMAHAWK WIFI (MS-7E53)
+    { &(board_names[23]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI MEG Z890 UNIFY-X (MS-7E20)
+    { &(board_names[24]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO X870E-S EVO WIFI (MS-7E86)
+    { &(board_names[25]), 0,  0,  0, 1, &zone_set1,  MSIMysticLight761Controller::DIRECT_MODE_ZONE_BASED },     // MSI PRO Z890-P WIFI (MS-7E34)
 };
 
 enum MSI_ZONE setup_map [] =

Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp

@@ -209,6 +209,7 @@ REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D31",    DetectMSIMysticLightCont
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D32",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D32,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D33",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D33,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D36",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D36,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D37",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D37,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D38",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D38,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D40",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D40,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D41",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D41,   0x0001, 0x00);

Controllers/QMKController/QMKKeychronController/QMKKeychronController.cpp

@@ -88,6 +88,11 @@ QMKKeychronController::QMKKeychronController(hid_device* dev_handle, const char
     \*-----------------------------------------------------*/
     CmdGetKeychronProtocolVersion(&kc_protocol_version);
 
+    /*-----------------------------------------------------*\
+    | Get Keychron firmware version                         |
+    \*-----------------------------------------------------*/
+    kc_firmware_version = CmdGetKeychronFirmwareVersion();
+
     /*-----------------------------------------------------*\
     | Get supported Keychron features                       |
     \*-----------------------------------------------------*/
@@ -172,7 +177,8 @@ std::string QMKKeychronController::GetVersion()
     \*-----------------------------------------------------*/
     return("VIA: "          + std::to_string(via_protocol_version) + "\r\n" +
            "Keychron: "     + std::to_string(kc_protocol_version) + "\r\n" +
-           "Keychron RGB: " + std::to_string(kc_rgb_protocol_version));
+           "Keychron RGB: " + std::to_string(kc_rgb_protocol_version) + "\r\n" +
+           "Keychron FW: "  + kc_firmware_version);
 }
 
 bool QMKKeychronController::GetSupported()
@@ -256,6 +262,21 @@ unsigned short QMKKeychronController::CmdGetKeycode
     return(keycode);
 }
 
+
+std::string QMKKeychronController::CmdGetKeychronFirmwareVersion()
+{
+    char                response[30];
+
+    ViaSendCommand(KC_GET_FIRMWARE_VERSION, NULL, 0, (unsigned char*)response, sizeof(response));
+
+    /*-----------------------------------------------------*\
+    | Ensure response null termination                      |
+    \*-----------------------------------------------------*/
+    response[29] = 0;
+
+    return(std::string(response));
+}
+
 void QMKKeychronController::CmdGetKeychronProtocolVersion
     (
     unsigned char*      kc_protocol_version

Controllers/QMKController/QMKKeychronController/QMKKeychronController.h

@@ -25,9 +25,249 @@
 /*---------------------------------------------------------*\
 | Product IDs                                               |
 \*---------------------------------------------------------*/
-#define KEYCHRON_K10_V2_PID                         0x0DA0
-#define KEYCHRON_Q1_HE_PID                          0x0B10
-#define KEYCHRON_Q2_PID                             0x0111
+#define KEYCHRON_C1_PRO_ANSI_RGB_PID                0x0510
+#define KEYCHRON_C1_PRO_8K_ANSI_PID                 0x0521
+#define KEYCHRON_C1_PRO_8K_ISO_PID                  0x051D
+#define KEYCHRON_C1_PRO_8K_JIS_PID                  0x051E
+#define KEYCHRON_C1_PRO_V2_ANSI_RGB_PID             0x0516
+#define KEYCHRON_C2_PRO_ANSI_RGB_PID                0x0520
+#define KEYCHRON_C2_PRO_8K_ANSI_PID                 0x0522
+#define KEYCHRON_C2_PRO_8K_ISO_PID                  0x052D
+#define KEYCHRON_C2_PRO_V2_ANSI_RGB_PID             0x0526
+#define KEYCHRON_C3_PRO_ANSI_RGB_PID                0x0433
+#define KEYCHRON_C3_PRO_8K_ANSI_PID                 0x0530
+#define KEYCHRON_C3_PRO_8K_ISO_PID                  0x0531
+#define KEYCHRON_C3_PRO_8K_JIS_PID                  0x0532
+#define KEYCHRON_K0_MAX_PID                         0x0A06
+#define KEYCHRON_K1_MAX_ANSI_RGB_PID                0x0A10
+#define KEYCHRON_K1_MAX_ISO_RGB_PID                 0x0A11
+#define KEYCHRON_K1_MAX_JIS_RGB_PID                 0x0A12
+#define KEYCHRON_K1_V6_ANSI_RGB_PID                 0x0D10
+#define KEYCHRON_K1_V6_ISO_RGB_PID                  0x0D11
+#define KEYCHRON_K1_V6_JIS_RGB_PID                  0x0D12
+#define KEYCHRON_K2_HE_ANSI_PID                     0x0E20
+#define KEYCHRON_K2_HE_ISO_PID                      0x0E21
+#define KEYCHRON_K2_HE_JIS_PID                      0x0E22
+#define KEYCHRON_K2_MAX_ANSI_RGB_PID                0x0A20
+#define KEYCHRON_K2_MAX_ISO_RGB_PID                 0x0A21
+#define KEYCHRON_K2_MAX_JIS_RGB_PID                 0x0A22
+#define KEYCHRON_K2_V3_ANSI_RGB_PID                 0x0D20
+#define KEYCHRON_K2_V3_ISO_RGB_PID                  0x0D21
+#define KEYCHRON_K2_V3_JIS_RGB_PID                  0x0D22
+#define KEYCHRON_K3_MAX_ANSI_RGB_PID                0x0A30
+#define KEYCHRON_K3_MAX_ISO_RGB_PID                 0x0A31
+#define KEYCHRON_K3_MAX_JIS_RGB_PID                 0x0A32
+#define KEYCHRON_K3_V3_ANSI_RGB_PID                 0x0D30
+#define KEYCHRON_K3_V3_ISO_RGB_PID                  0x0D31
+#define KEYCHRON_K3_V3_JIS_RGB_PID                  0x0D32
+#define KEYCHRON_K4_HE_ANSI_PID                     0x0E40
+#define KEYCHRON_K4_HE_ISO_PID                      0x0E41
+#define KEYCHRON_K4_HE_JIS_PID                      0x0E42
+#define KEYCHRON_K4_MAX_ANSI_RGB_PID                0x0A40
+#define KEYCHRON_K4_MAX_ISO_RGB_PID                 0x0A41
+#define KEYCHRON_K4_MAX_JIS_RGB_PID                 0x0A42
+#define KEYCHRON_K4_V3_ANSI_RGB_PID                 0x0D40
+#define KEYCHRON_K4_V3_ISO_RGB_PID                  0x0D41
+#define KEYCHRON_K4_V3_JIS_RGB_PID                  0x0D42
+#define KEYCHRON_K5_MAX_ANSI_RGB_PID                0x0A50
+#define KEYCHRON_K5_MAX_ISO_RGB_PID                 0x0A51
+#define KEYCHRON_K5_MAX_JIS_RGB_PID                 0x0A52
+#define KEYCHRON_K5_MAX_JIS_V2_RGB_PID              0x0A58
+#define KEYCHRON_K5_V2_ANSI_RGB_PID                 0x0D50
+#define KEYCHRON_K5_V2_ISO_RGB_PID                  0x0D51
+#define KEYCHRON_K5_V2_JIS_RGB_PID                  0x0D52
+#define KEYCHRON_K6_HE_ANSI_PID                     0x0E60
+#define KEYCHRON_K7_MAX_ANSI_RGB_PID                0x0A70
+#define KEYCHRON_K7_MAX_ISO_RGB_PID                 0x0A71
+#define KEYCHRON_K7_MAX_JIS_RGB_PID                 0x0A72
+#define KEYCHRON_K7_MAX_JIS_V2_RGB_PID              0x0A76
+#define KEYCHRON_K8_HE_ANSI_PID                     0x0E80
+#define KEYCHRON_K8_HE_ISO_PID                      0x0E81
+#define KEYCHRON_K8_HE_JIS_PID                      0x0E82
+#define KEYCHRON_K8_MAX_ANSI_RGB_PID                0x0A80
+#define KEYCHRON_K8_MAX_ISO_RGB_PID                 0x0A81
+#define KEYCHRON_K8_MAX_JIS_RGB_PID                 0x0A82
+#define KEYCHRON_K8_PRO_ANSI_RGB_PID                0x0280
+#define KEYCHRON_K8_PRO_ISO_RGB_PID                 0x0281
+#define KEYCHRON_K8_PRO_JIS_RGB_PID                 0x0282
+#define KEYCHRON_K8_V2_ANSI_RGB_PID                 0x0D80
+#define KEYCHRON_K8_V2_ISO_RGB_PID                  0x0D81
+#define KEYCHRON_K8_V2_JIS_RGB_PID                  0x0D82
+#define KEYCHRON_K9_MAX_ANSI_RGB_PID                0x0A90
+#define KEYCHRON_K10_HE_ANSI_PID                    0x0EA0
+#define KEYCHRON_K10_HE_ISO_PID                     0x0EA1
+#define KEYCHRON_K10_MAX_ANSI_RGB_PID               0x0AA0
+#define KEYCHRON_K10_MAX_ISO_RGB_PID                0x0AA1
+#define KEYCHRON_K10_MAX_JIS_RGB_PID                0x0AA2
+#define KEYCHRON_K10_V2_ANSI_RGB_PID                0x0DA0
+#define KEYCHRON_K10_V2_ISO_RGB_PID                 0x0DA1
+#define KEYCHRON_K10_V2_JIS_RGB_PID                 0x0DA2
+#define KEYCHRON_K11_MAX_ANSI_ENCODER_RGB_PID       0x0AB3
+#define KEYCHRON_K11_MAX_ISO_ENCODER_RGB_PID        0x0AB4
+#define KEYCHRON_K11_MAX_JIS_ENCODER_RGB_PID        0x0AB5
+#define KEYCHRON_K13_MAX_ANSI_RGB_PID               0x0AD0
+#define KEYCHRON_K13_MAX_ISO_RGB_PID                0x0AD1
+#define KEYCHRON_K13_MAX_JIS_RGB_PID                0x0AD2
+#define KEYCHRON_K15_MAX_ANSI_ENCODER_RGB_PID       0x0AF0
+#define KEYCHRON_K15_MAX_ISO_ENCODER_RGB_PID        0x0AF1
+#define KEYCHRON_K17_MAX_ANSI_ENCODER_RGB_PID       0x0A00
+#define KEYCHRON_K17_MAX_ISO_ENCODER_RGB_PID        0x0A01
+#define KEYCHRON_K17_MAX_JIS_ENCODER_RGB_PID        0x0A02
+#define KEYCHRON_Q0_BASE_PID                        0x0130
+#define KEYCHRON_Q0_PLUS_PID                        0x0131
+#define KEYCHRON_Q0_MAX_ENCODER_PID                 0x0800
+#define KEYCHRON_Q1_HE_ANSI_ENCODER_PID             0x0B10
+#define KEYCHRON_Q1_HE_ISO_ENCODER_PID              0x0B11
+#define KEYCHRON_Q1_HE_JIS_ENCODER_PID              0x0B12
+#define KEYCHRON_Q1_MAX_ANSI_ENCODER_PID            0x0810
+#define KEYCHRON_Q1_MAX_ISO_ENCODER_PID             0x0811
+#define KEYCHRON_Q1_MAX_JIS_ENCODER_PID             0x0812
+#define KEYCHRON_Q1_V1_ANSI_PID                     0x0100
+#define KEYCHRON_Q1_V1_ANSI_ENCODER_PID             0x0101
+#define KEYCHRON_Q1_V1_ISO_PID                      0x0102
+#define KEYCHRON_Q1_V1_ISO_ENCODER_PID              0x0103
+#define KEYCHRON_Q1_V2_ANSI_PID                     0x0106
+#define KEYCHRON_Q1_V2_ANSI_ENCODER_PID             0x0107
+#define KEYCHRON_Q1_V2_ISO_PID                      0x0108
+#define KEYCHRON_Q1_V2_ISO_ENCODER_PID              0x0109
+#define KEYCHRON_Q1_V2_JIS_PID                      0x010A
+#define KEYCHRON_Q1_V2_JIS_ENCODER_PID              0x010B
+#define KEYCHRON_Q2_ANSI_PID                        0x0110
+#define KEYCHRON_Q2_ANSI_ENCODER_PID                0x0111
+#define KEYCHRON_Q2_ISO_PID                         0x0112
+#define KEYCHRON_Q2_ISO_ENCODER_PID                 0x0113
+#define KEYCHRON_Q2_JIS_PID                         0x0114
+#define KEYCHRON_Q2_JIS_ENCODER_PID                 0x0115
+#define KEYCHRON_Q2_HE_ANSI_ENCODER_PID             0x0B20
+#define KEYCHRON_Q2_MAX_ANSI_ENCODER_PID            0x0820
+#define KEYCHRON_Q2_MAX_ISO_ENCODER_PID             0x0821
+#define KEYCHRON_Q3_ANSI_PID                        0x0120
+#define KEYCHRON_Q3_ANSI_ENCODER_PID                0x0121
+#define KEYCHRON_Q3_ISO_PID                         0x0122
+#define KEYCHRON_Q3_ISO_ENCODER_PID                 0x0123
+#define KEYCHRON_Q3_JIS_PID                         0x0124
+#define KEYCHRON_Q3_JIS_ENCODER_PID                 0x0125
+#define KEYCHRON_Q3_HE_ANSI_ENCODER_PID             0x0B30
+#define KEYCHRON_Q3_HE_ISO_ENCODER_PID              0x0B31
+#define KEYCHRON_Q3_HE_JIS_ENCODER_PID              0x0B32
+#define KEYCHRON_Q3_MAX_ANSI_ENCODER_PID            0x0830
+#define KEYCHRON_Q3_MAX_ISO_ENCODER_PID             0x0831
+#define KEYCHRON_Q4_ANSI_PID                        0x0140
+#define KEYCHRON_Q4_ISO_PID                         0x0142
+#define KEYCHRON_Q4_HE_ANSI_PID                     0x0B40
+#define KEYCHRON_Q5_ANSI_PID                        0x0150
+#define KEYCHRON_Q5_ANSI_ENCODER_PID                0x0151
+#define KEYCHRON_Q5_ISO_PID                         0x0152
+#define KEYCHRON_Q5_ISO_ENCODER_PID                 0x0153
+#define KEYCHRON_Q5_HE_ANSI_ENCODER_PID             0x0B50
+#define KEYCHRON_Q5_HE_ISO_ENCODER_PID              0x0B51
+#define KEYCHRON_Q5_HE_JIS_ENCODER_PID              0x0B52
+#define KEYCHRON_Q5_MAX_ANSI_ENCODER_PID            0x0850
+#define KEYCHRON_Q5_MAX_ISO_ENCODER_PID             0x0851
+#define KEYCHRON_Q5_MAX_JIS_ENCODER_PID             0x0852
+#define KEYCHRON_Q6_ANSI_PID                        0x0160
+#define KEYCHRON_Q6_ANSI_ENCODER_PID                0x0161
+#define KEYCHRON_Q6_ISO_PID                         0x0162
+#define KEYCHRON_Q6_ISO_ENCODER_PID                 0x0163
+#define KEYCHRON_Q6_HE_ANSI_ENCODER_PID             0x0B60
+#define KEYCHRON_Q6_HE_ISO_ENCODER_PID              0x0B61
+#define KEYCHRON_Q6_HE_JIS_ENCODER_PID              0x0B62
+#define KEYCHRON_Q6_MAX_ANSI_ENCODER_PID            0x0860
+#define KEYCHRON_Q6_MAX_ISO_ENCODER_PID             0x0861
+#define KEYCHRON_Q7_ANSI_PID                        0x0170
+#define KEYCHRON_Q7_ISO_PID                         0x0172
+#define KEYCHRON_Q8_ANSI_PID                        0x0180
+#define KEYCHRON_Q8_ANSI_ENCODER_PID                0x0181
+#define KEYCHRON_Q8_ISO_PID                         0x0182
+#define KEYCHRON_Q8_ISO_ENCODER_PID                 0x0183
+#define KEYCHRON_Q8_MAX_ANSI_ENCODER_PID            0x0880
+#define KEYCHRON_Q9_ANSI_PID                        0x0190
+#define KEYCHRON_Q9_ANSI_ENCODER_PID                0x0191
+#define KEYCHRON_Q9_ISO_PID                         0x0192
+#define KEYCHRON_Q9_ISO_ENCODER_PID                 0x0193
+#define KEYCHRON_Q9_PLUS_ANSI_ENCODER_PID           0x0194
+#define KEYCHRON_Q10_ANSI_ENCODER_PID               0x01A1
+#define KEYCHRON_Q10_ISO_ENCODER_PID                0x01A3
+#define KEYCHRON_Q10_MAX_ANSI_ENCODER_PID           0x08A0
+#define KEYCHRON_Q10_MAX_ISO_ENCODER_PID            0x08A1
+#define KEYCHRON_Q11_ANSI_ENCODER_PID               0x01E0
+#define KEYCHRON_Q11_ISO_ENCODER_PID                0x01E1
+#define KEYCHRON_Q12_ANSI_ENCODER_PID               0x01D1
+#define KEYCHRON_Q12_ISO_ENCODER_PID                0x01D3
+#define KEYCHRON_Q12_HE_ANSI_ENCODER_PID            0x0BC0
+#define KEYCHRON_Q12_HE_ISO_ENCODER_PID             0x0BC1
+#define KEYCHRON_Q12_MAX_ANSI_ENCODER_PID           0x08C3
+#define KEYCHRON_Q12_MAX_ISO_ENCODER_PID            0x08C4
+#define KEYCHRON_Q13_MAX_ANSI_ENCODER_PID           0x08D0
+#define KEYCHRON_Q13_MAX_JIS_ENCODER_PID            0x08D2
+#define KEYCHRON_Q14_MAX_ANSI_ENCODER_PID           0x08E0
+#define KEYCHRON_Q15_MAX_ANSI_ENCODER_PID           0x08F0
+#define KEYCHRON_Q60_MAX_ANSI_PID                   0x08C0
+#define KEYCHRON_Q65_MAX_ANSI_ENCODER_PID           0x08B0
+#define KEYCHRON_S1_ANSI_RGB_PID                    0x0410
+#define KEYCHRON_V1_ABNT2_ENCODER_PID               0x0317
+#define KEYCHRON_V1_ANSI_PID                        0x0310
+#define KEYCHRON_V1_ANSI_ENCODER_PID                0x0311
+#define KEYCHRON_V1_ISO_PID                         0x0312
+#define KEYCHRON_V1_ISO_ENCODER_PID                 0x0313
+#define KEYCHRON_V1_JIS_PID                         0x0314
+#define KEYCHRON_V1_JIS_ENCODER_PID                 0x0315
+#define KEYCHRON_V1_8K_ANSI_ENCODER_PID             0x0F10
+#define KEYCHRON_V1_MAX_ANSI_ENCODER_PID            0x0913
+#define KEYCHRON_V1_MAX_ISO_ENCODER_PID             0x0914
+#define KEYCHRON_V1_MAX_JIS_ENCODER_PID             0x0915
+#define KEYCHRON_V2_ABNT2_ENCODER_PID               0x0327
+#define KEYCHRON_V2_ANSI_PID                        0x0320
+#define KEYCHRON_V2_ANSI_ENCODER_PID                0x0321
+#define KEYCHRON_V2_ISO_PID                         0x0322
+#define KEYCHRON_V2_ISO_ENCODER_PID                 0x0323
+#define KEYCHRON_V2_JIS_PID                         0x0324
+#define KEYCHRON_V2_JIS_ENCODER_PID                 0x0325
+#define KEYCHRON_V2_MAX_ANSI_ENCODER_PID            0x0920
+#define KEYCHRON_V2_MAX_ISO_ENCODER_PID             0x0921
+#define KEYCHRON_V2_MAX_JIS_ENCODER_PID             0x0922
+#define KEYCHRON_V3_ABNT2_ENCODER_PID               0x0337
+#define KEYCHRON_V3_ANSI_PID                        0x0330
+#define KEYCHRON_V3_ANSI_ENCODER_PID                0x0331
+#define KEYCHRON_V3_ISO_PID                         0x0332
+#define KEYCHRON_V3_ISO_ENCODER_PID                 0x0333
+#define KEYCHRON_V3_JIS_PID                         0x0334
+#define KEYCHRON_V3_JIS_ENCODER_PID                 0x0335
+#define KEYCHRON_V3_MAX_ANSI_ENCODER_PID            0x0933
+#define KEYCHRON_V3_MAX_ISO_ENCODER_PID             0x0934
+#define KEYCHRON_V3_MAX_JIS_ENCODER_PID             0x0935
+#define KEYCHRON_V4_ANSI_PID                        0x0340
+#define KEYCHRON_V4_ISO_PID                         0x0342
+#define KEYCHRON_V4_MAX_ANSI_PID                    0x0940
+#define KEYCHRON_V4_MAX_ISO_PID                     0x0941
+#define KEYCHRON_V5_ANSI_PID                        0x0350
+#define KEYCHRON_V5_ANSI_ENCODER_PID                0x0351
+#define KEYCHRON_V5_ISO_PID                         0x0352
+#define KEYCHRON_V5_ISO_ENCODER_PID                 0x0353
+#define KEYCHRON_V5_MAX_ANSI_ENCODER_PID            0x0950
+#define KEYCHRON_V5_MAX_ISO_ENCODER_PID             0x0951
+#define KEYCHRON_V5_MAX_JIS_ENCODER_PID             0x0952
+#define KEYCHRON_V6_ABNT2_ENCODER_PID               0x0367
+#define KEYCHRON_V6_ANSI_PID                        0x0360
+#define KEYCHRON_V6_ANSI_ENCODER_PID                0x0361
+#define KEYCHRON_V6_ISO_PID                         0x0362
+#define KEYCHRON_V6_ISO_ENCODER_PID                 0x0363
+#define KEYCHRON_V6_MAX_ANSI_ENCODER_PID            0x0960
+#define KEYCHRON_V6_MAX_ISO_ENCODER_PID             0x0961
+#define KEYCHRON_V6_MAX_JIS_ENCODER_PID             0x0962
+#define KEYCHRON_V6_V2_ISO_ENCODER_PID              0x0368
+#define KEYCHRON_V7_ANSI_PID                        0x0370
+#define KEYCHRON_V7_ISO_PID                         0x0372
+#define KEYCHRON_V8_ANSI_PID                        0x0380
+#define KEYCHRON_V8_ANSI_ENCODER_PID                0x0381
+#define KEYCHRON_V8_ISO_PID                         0x0382
+#define KEYCHRON_V8_ISO_ENCODER_PID                 0x0383
+#define KEYCHRON_V8_MAX_ANSI_ENCODER_PID            0x0980
+#define KEYCHRON_V8_MAX_ISO_ENCODER_PID             0x0981
+#define KEYCHRON_V10_ANSI_ENCODER_PID               0x03A1
+#define KEYCHRON_V10_ISO_ENCODER_PID                0x03A3
+#define KEYCHRON_V10_MAX_ANSI_ENCODER_PID           0x09A0
+#define KEYCHRON_V10_MAX_ISO_ENCODER_PID            0x09A1
 
 /*---------------------------------------------------------*\
 | QMK raw HID usage page/usage                              |
@@ -158,6 +398,7 @@ public:
 
 private:
     hid_device*                             dev;
+    std::string                             kc_firmware_version;
     unsigned char                           kc_protocol_version;
     unsigned short                          kc_rgb_protocol_version;
     std::vector<unsigned short>             keycodes;
@@ -171,6 +412,7 @@ private:
     unsigned short                          via_protocol_version;
 
     unsigned short                          CmdGetKeycode(unsigned char layer, unsigned char row, unsigned char col);
+    std::string                             CmdGetKeychronFirmwareVersion();
     void                                    CmdGetKeychronProtocolVersion(unsigned char* kc_protocol_version);
     void                                    CmdGetKeychronRGBProtocolVersion(unsigned short* kc_rgb_protocol_version);
     std::vector<unsigned char>              CmdGetLEDIndexByRow(unsigned char row);

Controllers/QMKController/QMKKeychronController/QMKKeychronControllerDetect.cpp

@@ -14,7 +14,7 @@
 #include "QMKKeychronController.h"
 #include "RGBController_QMKKeychron.h"
 
-void DetectQMKKeychronController(hid_device_info *info, const std::string&)
+void DetectQMKKeychronControllers(hid_device_info *info, const std::string&)
 {
     hid_device *dev = hid_open_path(info->path);
 
@@ -34,6 +34,246 @@ void DetectQMKKeychronController(hid_device_info *info, const std::string&)
     }
 }
 
-REGISTER_HID_DETECTOR_IPU("Keychron K10 V2", DetectQMKKeychronController, KEYCHRON_VID, KEYCHRON_K10_V2_PID, 1, KEYCHRON_QMK_USAGE_PAGE, KEYCHRON_QMK_USAGE);
-REGISTER_HID_DETECTOR_IPU("Keychron Q1 HE",  DetectQMKKeychronController, KEYCHRON_VID, KEYCHRON_Q1_HE_PID,  1, KEYCHRON_QMK_USAGE_PAGE, KEYCHRON_QMK_USAGE);
-REGISTER_HID_DETECTOR_IPU("Keychron Q2",     DetectQMKKeychronController, KEYCHRON_VID, KEYCHRON_Q2_PID,     1, KEYCHRON_QMK_USAGE_PAGE, KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron C1 Pro",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_C1_PRO_ANSI_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron C1 Pro 8K", DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_C1_PRO_8K_ANSI_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron C1 Pro 8K", DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_C1_PRO_8K_ISO_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron C1 Pro 8K", DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_C1_PRO_8K_JIS_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron C1 Pro V2", DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_C1_PRO_V2_ANSI_RGB_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron C2 Pro",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_C2_PRO_ANSI_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron C2 Pro 8K", DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_C2_PRO_8K_ANSI_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron C2 Pro 8K", DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_C2_PRO_8K_ISO_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron C2 Pro V2", DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_C2_PRO_V2_ANSI_RGB_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron C3 Pro",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_C3_PRO_ANSI_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron C3 Pro 8K", DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_C3_PRO_8K_ANSI_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron C3 Pro 8K", DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_C3_PRO_8K_ISO_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron C3 Pro 8K", DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_C3_PRO_8K_JIS_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K0 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K0_MAX_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K1 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K1_MAX_ANSI_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K1 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K1_MAX_ISO_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K1 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K1_MAX_JIS_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K1 V6",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K1_V6_ANSI_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K1 V6",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K1_V6_ISO_RGB_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K1 V6",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K1_V6_JIS_RGB_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K2 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K2_HE_ANSI_PID,                    1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K2 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K2_HE_ISO_PID,                     1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K2 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K2_HE_JIS_PID,                     1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K2 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K2_MAX_ANSI_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K2 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K2_MAX_ISO_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K2 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K2_MAX_JIS_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K2 V3",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K2_V3_ANSI_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K2 V3",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K2_V3_ISO_RGB_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K2 V3",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K2_V3_JIS_RGB_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K3 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K3_MAX_ANSI_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K3 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K3_MAX_ISO_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K3 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K3_MAX_JIS_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K3 V3",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K3_V3_ANSI_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K3 V3",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K3_V3_ISO_RGB_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K3 V3",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K3_V3_JIS_RGB_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K4 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K4_HE_ANSI_PID,                    1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K4 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K4_HE_ISO_PID,                     1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K4 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K4_HE_JIS_PID,                     1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K4 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K4_MAX_ANSI_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K4 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K4_MAX_ISO_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K4 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K4_MAX_JIS_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K4 V3",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K4_V3_ANSI_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K4 V3",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K4_V3_ISO_RGB_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K4 V3",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K4_V3_JIS_RGB_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K5 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K5_MAX_ANSI_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K5 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K5_MAX_ISO_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K5 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K5_MAX_JIS_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K5 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K5_MAX_JIS_V2_RGB_PID,             1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K5 V2",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K5_V2_ANSI_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K5 V2",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K5_V2_ISO_RGB_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K5 V2",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K5_V2_JIS_RGB_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K6 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K6_HE_ANSI_PID,                    1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K7 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K7_MAX_ANSI_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K7 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K7_MAX_ISO_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K7 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K7_MAX_JIS_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K7 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K7_MAX_JIS_V2_RGB_PID,             1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K8 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K8_HE_ANSI_PID,                    1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K8 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K8_HE_ISO_PID,                     1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K8 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K8_HE_JIS_PID,                     1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K8 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K8_MAX_ANSI_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K8 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K8_MAX_ISO_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K8 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K8_MAX_JIS_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K8 Pro",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K8_PRO_ANSI_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K8 Pro",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K8_PRO_ISO_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K8 Pro",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K8_PRO_JIS_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K8 V2",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K8_V2_ANSI_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K8 V2",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K8_V2_ISO_RGB_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K8 V2",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K8_V2_JIS_RGB_PID,                 1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K9 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K9_MAX_ANSI_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K10 HE",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K10_HE_ANSI_PID,                   1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K10 HE",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K10_HE_ISO_PID,                    1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K10 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K10_MAX_ANSI_RGB_PID,              1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K10 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K10_MAX_ISO_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K10 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K10_MAX_JIS_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K10 V2",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K10_V2_ANSI_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K10 V2",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K10_V2_ISO_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K10 V2",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K10_V2_JIS_RGB_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K11 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K11_MAX_ANSI_ENCODER_RGB_PID,      1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K11 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K11_MAX_ISO_ENCODER_RGB_PID,       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K11 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K11_MAX_JIS_ENCODER_RGB_PID,       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K13 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K13_MAX_ANSI_RGB_PID,              1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K13 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K13_MAX_ISO_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K13 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K13_MAX_JIS_RGB_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K15 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K15_MAX_ANSI_ENCODER_RGB_PID,      1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K15 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K15_MAX_ISO_ENCODER_RGB_PID,       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K17 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K17_MAX_ANSI_ENCODER_RGB_PID,      1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K17 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K17_MAX_ISO_ENCODER_RGB_PID,       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron K17 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_K17_MAX_JIS_ENCODER_RGB_PID,       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q0",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q0_BASE_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q0 Plus",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q0_PLUS_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q0 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q0_MAX_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_HE_ANSI_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_HE_ISO_ENCODER_PID,             1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_HE_JIS_ENCODER_PID,             1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_MAX_ANSI_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_MAX_ISO_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_MAX_JIS_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 V1",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_V1_ANSI_PID,                    1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 V1",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_V1_ANSI_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 V1",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_V1_ISO_PID,                     1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 V1",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_V1_ISO_ENCODER_PID,             1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 V2",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_V2_ANSI_PID,                    1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 V2",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_V2_ANSI_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 V2",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_V2_ISO_PID,                     1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 V2",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_V2_ISO_ENCODER_PID,             1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 V2",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_V2_JIS_PID,                     1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q1 V2",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q1_V2_JIS_ENCODER_PID,             1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q2",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q2_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q2",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q2_ANSI_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q2",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q2_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q2",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q2_ISO_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q2",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q2_JIS_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q2",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q2_JIS_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q2 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q2_HE_ANSI_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q2 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q2_MAX_ANSI_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q2 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q2_MAX_ISO_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q3",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q3_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q3",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q3_ANSI_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q3",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q3_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q3",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q3_ISO_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q3",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q3_JIS_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q3",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q3_JIS_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q3 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q3_HE_ANSI_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q3 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q3_HE_ISO_ENCODER_PID,             1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q3 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q3_HE_JIS_ENCODER_PID,             1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q3 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q3_MAX_ANSI_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q3 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q3_MAX_ISO_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q4",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q4_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q4",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q4_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q4 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q4_HE_ANSI_PID,                    1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q5",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q5_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q5",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q5_ANSI_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q5",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q5_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q5",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q5_ISO_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q5 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q5_HE_ANSI_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q5 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q5_HE_ISO_ENCODER_PID,             1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q5 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q5_HE_JIS_ENCODER_PID,             1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q5 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q5_MAX_ANSI_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q5 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q5_MAX_ISO_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q5 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q5_MAX_JIS_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q6",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q6_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q6",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q6_ANSI_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q6",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q6_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q6",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q6_ISO_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q6 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q6_HE_ANSI_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q6 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q6_HE_ISO_ENCODER_PID,             1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q6 HE",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q6_HE_JIS_ENCODER_PID,             1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q6 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q6_MAX_ANSI_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q6 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q6_MAX_ISO_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q7",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q7_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q7",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q7_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q8",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q8_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q8",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q8_ANSI_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q8",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q8_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q8",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q8_ISO_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q8 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q8_MAX_ANSI_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q9",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q9_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q9",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q9_ANSI_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q9",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q9_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q9",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q9_ISO_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q9 Plus",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q9_PLUS_ANSI_ENCODER_PID,          1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q10",       DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q10_ANSI_ENCODER_PID,              1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q10",       DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q10_ISO_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q10 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q10_MAX_ANSI_ENCODER_PID,          1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q10 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q10_MAX_ISO_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q11",       DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q11_ANSI_ENCODER_PID,              1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q11",       DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q11_ISO_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q12",       DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q12_ANSI_ENCODER_PID,              1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q12",       DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q12_ISO_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q12 HE",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q12_HE_ANSI_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q12 HE",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q12_HE_ISO_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q12 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q12_MAX_ANSI_ENCODER_PID,          1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q12 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q12_MAX_ISO_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q13 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q13_MAX_ANSI_ENCODER_PID,          1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q13 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q13_MAX_JIS_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q14 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q14_MAX_ANSI_ENCODER_PID,          1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q15 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q15_MAX_ANSI_ENCODER_PID,          1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q60 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q60_MAX_ANSI_PID,                  1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron Q65 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_Q65_MAX_ANSI_ENCODER_PID,          1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron S1",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_S1_ANSI_RGB_PID,                   1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V1",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V1_ABNT2_ENCODER_PID,              1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V1",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V1_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V1",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V1_ANSI_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V1",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V1_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V1",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V1_ISO_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V1",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V1_JIS_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V1",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V1_JIS_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V1 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V1_8K_ANSI_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V1 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V1_MAX_ANSI_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V1 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V1_MAX_ISO_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V1 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V1_MAX_JIS_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V2",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V2_ABNT2_ENCODER_PID,              1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V2",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V2_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V2",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V2_ANSI_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V2",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V2_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V2",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V2_ISO_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V2",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V2_JIS_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V2",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V2_JIS_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V2 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V2_MAX_ANSI_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V2 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V2_MAX_ISO_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V2 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V2_MAX_JIS_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V3",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V3_ABNT2_ENCODER_PID,              1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V3",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V3_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V3",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V3_ANSI_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V3",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V3_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V3",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V3_ISO_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V3",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V3_JIS_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V3",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V3_JIS_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V3 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V3_MAX_ANSI_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V3 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V3_MAX_ISO_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V3 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V3_MAX_JIS_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V4",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V4_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V4",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V4_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V4 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V4_MAX_ANSI_PID,                   1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V4 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V4_MAX_ISO_PID,                    1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V5",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V5_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V5",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V5_ANSI_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V5",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V5_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V5",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V5_ISO_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V5 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V5_MAX_ANSI_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V5 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V5_MAX_ISO_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V5 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V5_MAX_JIS_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V6",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V6_ABNT2_ENCODER_PID,              1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V6",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V6_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V6",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V6_ANSI_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V6",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V6_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V6",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V6_ISO_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V6 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V6_MAX_ANSI_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V6 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V6_MAX_ISO_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V6 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V6_MAX_JIS_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V6 V2",     DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V6_V2_ISO_ENCODER_PID,             1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V7",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V7_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V7",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V7_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V8",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V8_ANSI_PID,                       1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V8",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V8_ANSI_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V8",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V8_ISO_PID,                        1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V8",        DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V8_ISO_ENCODER_PID,                1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V8 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V8_MAX_ANSI_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V8 Max",    DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V8_MAX_ISO_ENCODER_PID,            1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V10",       DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V10_ANSI_ENCODER_PID,              1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V10",       DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V10_ISO_ENCODER_PID,               1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V10 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V10_MAX_ANSI_ENCODER_PID,          1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);
+REGISTER_HID_DETECTOR_IPU("Keychron V10 Max",   DetectQMKKeychronControllers,   KEYCHRON_VID,   KEYCHRON_V10_MAX_ISO_ENCODER_PID,           1,  KEYCHRON_QMK_USAGE_PAGE,    KEYCHRON_QMK_USAGE);

Controllers/RazerController/RazerControllerDetect.cpp

@@ -237,7 +237,8 @@ REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V3 TKL",                         Det
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V3 Mini (Wired)",                DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V3_MINI_WIRED_PID,             0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V3 Mini (Wireless)",             DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V3_MINI_WIRELESS_PID,          0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V4",                             DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V4_PID,                        0x03,   0x01,   0x00);
-REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V4 Pro",                         DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V4_PRO_PID,                    0x03,   0x01,   0x00);
+REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V4 Pro", /* firmware < 1.5 */    DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V4_PRO_PID,                    0x03,   0x01,   0x00);
+REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V4 Pro", /* firmware >= 1.5 */   DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V4_PRO_PID,                    0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V4 Pro 75% (Wired)",             DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V4_PRO_75_WIRED_PID,           0x03,   0x0C,   0x01);
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V4 Pro 75% (Wireless)",          DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V4_PRO_75_WIRELESS_PID,        0x02,   0x01,   0x02);
 REGISTER_HID_DETECTOR_IPU("Razer Blackwidow V4 75% (Wired)",                 DetectRazerControllers,        RAZER_VID,  RAZER_BLACKWIDOW_V4_75_WIRED_PID,               0x03,   0x01,   0x00);

Controllers/SayoDeviceController/RGBController_SayoDevice.cpp

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------*\
+| RGBController_SayoDevice.cpp                              |
+|                                                           |
+|   Controller for Sayo Devices                             |
+|                                                           |
+|   Richard Harris                              24 Jun 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_SayoDevice.h"
+#include "SayoDeviceController.h"
+#include "LogManager.h"
+
+/**--------------------------------------------------------------------*\
+    @name SayoDevice E1
+    @category Keyboard
+    @type USB
+    @save :white_check_mark:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectSayoDeviceController
+    @comment
+\*---------------------------------------------------------------------*/
+
+RGBController_SayoDevice::RGBController_SayoDevice(SayoDeviceController* controller_ptr)
+{
+    controller                      = controller_ptr;
+
+    name                            = controller->GetDeviceName();
+    vendor                          = "SayoDevice";
+    description                     = "SayoDevice E1 Knob";
+    type                            = DEVICE_TYPE_KEYBOARD;
+    location                        = controller->GetDeviceLocation();
+
+    mode Direct;
+    Direct.name                     = "Direct";
+    Direct.value                    = SAYO_MODE_DIRECT;
+    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Direct.color_mode               = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    /*-----------------------------------------------------*\
+    | Breathing - pulses a single color                     |
+    \*-----------------------------------------------------*/
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = SAYO_MODE_BREATHING;
+    Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_RANDOM_COLOR;
+    Breathing.color_mode            = MODE_COLORS_PER_LED;
+    Breathing.speed_min             = 0;
+    Breathing.speed_max             = 3;
+    Breathing.speed                 = 1;
+    modes.push_back(Breathing);
+
+    /*-----------------------------------------------------*\
+    | Wave - fades through multiple colors                  |
+    \*-----------------------------------------------------*/
+    mode Wave;
+    Wave.name                       = "Wave";
+    Wave.value                      = SAYO_MODE_WAVE;
+    Wave.flags                      = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_RANDOM_COLOR;
+    Wave.color_mode                 = MODE_COLORS_NONE;
+    Wave.speed_min                  = 0;
+    Wave.speed_max                  = 3;
+    Wave.speed                      = 1;
+    modes.push_back(Wave);
+
+    /*-----------------------------------------------------*\
+    | Switch - alternates multiple colors                   |
+    \*-----------------------------------------------------*/
+    mode Switch;
+    Switch.name                     = "Switch";
+    Switch.value                    = SAYO_MODE_SWITCH;
+    Switch.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_RANDOM_COLOR;
+    Switch.color_mode               = MODE_COLORS_NONE;
+    Switch.speed_min                = 0;
+    Switch.speed_max                = 3;
+    Switch.speed                    = 1;
+    modes.push_back(Switch);
+
+    /*-----------------------------------------------------*\
+    | Blink - blinks on and off                             |
+    \*-----------------------------------------------------*/
+    mode Blink;
+    Blink.name                      = "Blink";
+    Blink.value                     = SAYO_MODE_BLINK;
+    Blink.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_RANDOM_COLOR;
+    Blink.color_mode                = MODE_COLORS_PER_LED;
+    Blink.speed_min                 = 0;
+    Blink.speed_max                 = 3;
+    Blink.speed                     = 1;
+    modes.push_back(Blink);
+
+    SetupZones();
+};
+
+RGBController_SayoDevice::~RGBController_SayoDevice()
+{
+    delete controller;
+}
+
+void RGBController_SayoDevice::SetupZones()
+{
+    const int led_count = 1;
+
+    zone zone;
+    zone.name       = "Underglow";
+    zone.type       = ZONE_TYPE_SINGLE;
+    zone.leds_count = led_count;
+    zone.leds_min   = led_count;
+    zone.leds_max   = led_count;
+    zone.matrix_map = NULL;
+
+    zones.clear();
+    zones.push_back(zone);
+
+    leds.clear();
+    leds.resize(led_count);
+    for(int i = 0; i < led_count; i++)
+    {
+        led& new_led = leds[i];
+        new_led.name                = "LED " + std::to_string(i + 1);
+        new_led.value               = i;
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_SayoDevice::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*-----------------------------------------------------*\
+    | This device does not support resizing zones           |
+    \*-----------------------------------------------------*/
+}
+
+void RGBController_SayoDevice::DeviceUpdateLEDs()
+{
+    unsigned int hw_mode = (modes[active_mode].value == SAYO_MODE_DIRECT) ? SAYO_MODE_STATIC : modes[active_mode].value;
+    bool         random  = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+    unsigned int speed   = 3 - modes[active_mode].speed;
+
+    controller->SetMode(hw_mode, speed, colors[0], random);
+}
+
+void RGBController_SayoDevice::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_SayoDevice::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_SayoDevice::DeviceUpdateMode()
+{
+    /*-----------------------------------------------------*\
+    | Mode and color are always set together.               |
+    \*-----------------------------------------------------*/
+    DeviceUpdateLEDs();
+}
+
+void RGBController_SayoDevice::DeviceSaveMode()
+{
+    controller->Save();
+}

Controllers/SayoDeviceController/RGBController_SayoDevice.h

@@ -0,0 +1,36 @@
+/*---------------------------------------------------------*\
+| RGBController_SayoDevice.h                                |
+|                                                           |
+|   Controller for Sayo Devices                             |
+|                                                           |
+|   Richard Harris                              24 Jun 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "SayoDeviceController.h"
+
+class RGBController_SayoDevice : public RGBController
+{
+public:
+    RGBController_SayoDevice(SayoDeviceController* controller_ptr);
+    ~RGBController_SayoDevice();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    SayoDeviceController* controller;
+};

Controllers/SayoDeviceController/SayoDeviceController.cpp

@@ -0,0 +1,128 @@
+/*---------------------------------------------------------*\
+| SayoDeviceController.cpp                                  |
+|                                                           |
+|   Controller for Sayo Devices (USB HID)                   |
+|                                                           |
+|   Richard Harris                              24 Jun 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <vector>
+#include "LogManager.h"
+#include "SayoDeviceController.h"
+#include "RGBController.h"
+#include "Colors.h"
+
+SayoDeviceController::SayoDeviceController(hid_device* dev_handle, const char* path, std::string dev_name)
+{
+    dev         = dev_handle;
+    location    = path;
+    name        = dev_name;
+}
+
+SayoDeviceController::~SayoDeviceController()
+{
+    hid_close(dev);
+}
+
+std::string SayoDeviceController::GetDeviceLocation()
+{
+    return location;
+}
+
+std::string SayoDeviceController::GetDeviceName()
+{
+    return name;
+}
+
+void SayoDeviceController::SetMode(unsigned int mode, unsigned int speed, RGBColor color, bool random)
+{
+    /*-----------------------------------------------------*\
+    | Loop color table creates a rainbow effect which looks |
+    | better than truly random colors, so use that.         |
+    \*-----------------------------------------------------*/
+    unsigned int color_mode = random ? SAYO_COLOR_LOOP_TABLE : SAYO_COLOR_STATIC;
+    unsigned char mode_byte = SAYO_MODE_PACK(speed, color_mode, mode);
+
+    /*-----------------------------------------------------*\
+    | 0x1C (0x00) is potentially length (28) as the payload |
+    | is 27 bytes in size. Could include a zero as many     |
+    | fields seem to be 2-byte.                             |
+    | Other fields have not been mapped out at this time.   |
+    \*-----------------------------------------------------*/
+    std::vector<unsigned char> payload =
+    {
+        0x1C, 0x00, SAYO_CMD_LIGHTING_SET, 0x00, 0x01, 0x00, 0x00, 0x00,
+        0x15, 0x00, 0x28, 0x00, 0x26, 0x00, 0x4C, 0x00,
+        0x26, 0x00, 0x00, 0x00, mode_byte, 0x00, 0x80, 0x80,
+        (unsigned char)RGBGetRValue(color),
+        (unsigned char)RGBGetGValue(color),
+        (unsigned char)RGBGetBValue(color),
+    };
+    SendPacket(payload, true);
+}
+
+/*---------------------------------------------------------*\
+| Persist LED settings to flash memory.                     |
+\*---------------------------------------------------------*/
+void SayoDeviceController::Save()
+{
+    /*-----------------------------------------------------*\
+    | 0x06 0x00 feels like a length too - 6 bytes           |
+    \*-----------------------------------------------------*/
+    std::vector<unsigned char> payload = { 0x06, 0x00, 0x0d, 0x00, 0x96, 0x72 };
+    SendPacket(payload, true);
+}
+
+void SayoDeviceController::SendPacket(const std::vector<unsigned char>& command, bool flush)
+{
+    unsigned char length = (unsigned char)(command.size() + 4);
+
+    if(length > 64)
+    {
+        LOG_ERROR("[SayoDevice] SendPacket: command size (%d) is too large, rejecting", (int)command.size());
+        return;
+    }
+
+    std::vector<unsigned char> packet = {0x21, 0x12};
+
+    /*-----------------------------------------------------*\
+    | Checksum of header + command, as little endian 2-byte |
+    | pairs. Checksum is in same format.                    |
+    \*-----------------------------------------------------*/
+    unsigned short checksum = (unsigned short)(packet[0] | (packet[1] << 8));
+    for(std::size_t i = 0; i < command.size(); i += 2)
+    {
+        unsigned short word = command[i];
+
+        if(i + 1 < command.size())
+        {
+            word |= (unsigned short)(command[i + 1] << 8);
+        }
+
+        checksum = (checksum + word) & 0xFFFF;
+    }
+
+    packet.push_back(checksum & 0xFF);
+    packet.push_back(checksum >> 8);
+    packet.insert(packet.end(), command.begin(), command.end());
+    packet.resize(64, 0u);
+
+    hid_write(dev, packet.data(), packet.size());
+
+    if(flush)
+    {
+        /*-------------------------------------------------*\
+        | Flush away any awaiting IN packets                |
+        \*-------------------------------------------------*/
+        unsigned char buf[64];
+
+        int res = 1;
+        while(res > 0)
+        {
+            res = hid_read_timeout(dev, buf, 64, 0);
+        }
+    }
+}

Controllers/SayoDeviceController/SayoDeviceController.h

@@ -0,0 +1,103 @@
+/*---------------------------------------------------------*\
+| SayoDeviceController.h                                    |
+|                                                           |
+|   Controller for Sayo Devices                             |
+|                                                           |
+|   Richard Harris                              24 Jun 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <hidapi.h>
+#include "RGBController.h"
+
+/*-----------------------------------------*\
+| Lighting modes                            |
+\*-----------------------------------------*/
+enum
+{
+    SAYO_MODE_STATIC                = 0x00,
+    SAYO_MODE_INDICATOR             = 0x01,
+    SAYO_MODE_BREATHING             = 0x02,
+    SAYO_MODE_BREATHING_ONCE        = 0x03,
+    SAYO_MODE_WAVE                  = 0x04,
+    SAYO_MODE_SWITCH                = 0x06,
+    SAYO_MODE_SWITCH_ONCE           = 0x07,
+    SAYO_MODE_BLINK                 = 0x08,
+    SAYO_MODE_BLINK_ONCE            = 0x09,
+    SAYO_MODE_FADE_OUT              = 0x0E,
+    SAYO_MODE_FADE_IN               = 0x0F,
+    /*-------------------------------------*\
+    | Virtual modes                         |
+    \*-------------------------------------*/
+    SAYO_MODE_DIRECT                = 0xFF,
+};
+
+/*-----------------------------------------*\
+| Animation speeds                          |
+\*-----------------------------------------*/
+enum
+{
+    SAYO_SPEED_1X                   = 3,
+    SAYO_SPEED_2X                   = 2,
+    SAYO_SPEED_4X                   = 1,
+    SAYO_SPEED_8X                   = 0,
+};
+
+/*-----------------------------------------*\
+| Animation color mode                      |
+| TABLE modes either loop through or pick   |
+| randomly from a palette of colors.        |
+| RANDOM is truly random.                   |
+\*-----------------------------------------*/
+enum
+{
+    SAYO_COLOR_STATIC               = 0,
+    SAYO_COLOR_LOOP_TABLE           = 1,
+    SAYO_COLOR_RANDOM_TABLE         = 2,
+    SAYO_COLOR_RANDOM               = 3,
+};
+
+#define SAYO_MODE_PACK(speed, color_mode, mode) \
+    ((unsigned char)((((speed) & 0x3) << 6) | \
+                    (((color_mode) & 0x3) << 4) | \
+                    ((mode) & 0xF)))
+
+/*-----------------------------------------*\
+| Commands                                  |
+\*-----------------------------------------*/
+enum
+{
+    SAYO_CMD_API_LIST               = 0x00,
+    SAYO_CMD_KEY_GET                = 0x02, // maybe?
+    SAYO_CMD_SETTINGS               = 0x03,
+    SAYO_CMD_KEY_SET                = 0x10,
+    SAYO_CMD_LIGHTING_SET           = 0x11,
+    SAYO_CMD_REBOOT                 = 0x0E,
+
+};
+
+class SayoDeviceController
+{
+public:
+    SayoDeviceController(hid_device* dev_handle, const char* path, std::string dev_name);
+    ~SayoDeviceController();
+
+    std::string GetDeviceLocation();
+    std::string GetDeviceName();
+
+    void        SetMode(unsigned int mode, unsigned int speed, RGBColor color, bool random);
+    void        Save();
+
+private:
+    hid_device*             dev;
+    std::string             name;
+    std::string             location;
+
+    void        SendPacket(const std::vector<unsigned char>& command, bool flush = true);
+};

Controllers/SayoDeviceController/SayoDeviceControllerDetect.cpp

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------*\
+| SayoDeviceControllerDetect.cpp                            |
+|                                                           |
+|   Detector for Sayo Devices                               |
+|                                                           |
+|   Richard Harris                              24 Jun 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "Detector.h"
+#include "SayoDeviceController.h"
+#include "RGBController_SayoDevice.h"
+
+#define SAYO_USB_VID 0x8089
+#define SAYO_USB_PID_E1 0x0007
+
+/*----------------------------------------------------------*\
+|                                                            |
+|   DetectSayoDevice Controller                              |
+|                                                            |
+|       Detect Sayo Devices                                  |
+|                                                            |
+\*----------------------------------------------------------*/
+
+void DetectSayoDeviceController
+    (
+    hid_device_info*    info,
+    const std::string&  name
+    )
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev != nullptr)
+    {
+        SayoDeviceController*     controller     = new SayoDeviceController(dev, info->path, name);
+        RGBController_SayoDevice *rgb_controller = new RGBController_SayoDevice(controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_PU("SayoDevice E1", DetectSayoDeviceController, SAYO_USB_VID, SAYO_USB_PID_E1, 0xFF11, 0x0002);

OpenRGB.pro

@@ -26,7 +26,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 #-----------------------------------------------------------------------------------------------#
 MAJOR       = 0
 MINOR       = 9
-SUFFIX      = git
+SUFFIX      = 1.0rc3
 
 SHORTHASH   = $$system("git rev-parse --short=7 HEAD")
 LASTTAG     = "release_"$$MAJOR"."$$MINOR

README.md

@@ -39,7 +39,7 @@ This project interacts directly with hardware using reverse engineered protocols
   * Released versions are available to download on [OpenRGB.org](https://openrgb.org/releases.html) or under [Releases](https://gitlab.com/CalcProgrammer1/OpenRGB/-/releases/permalink/latest).
   * Experimental (aka Pipeline) versions are available to download on [OpenRGB.org](https://openrgb.org/index.html#pl).
   * On Windows, you will need the **Microsoft Visual 2019 C++ runtime** installed.  You can get it [here](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170#latest-supported-redistributable-version).
-  * An unofficial Flatpak release is [available on Flathub](https://flathub.org/apps/details/org.openrgb.OpenRGB)
+  * An official Flatpak release is [available on Flathub](https://flathub.org/apps/details/org.openrgb.OpenRGB)
     * Note: If using the AppImage or Flatpak versions, ensure you [install the latest udev rules](Documentation/UdevRules.md).
   * Released versions are officially packaged for various distributions including Alpine, Fedora, and Arch.
   * Arch users can also install from the [Extra repository](https://archlinux.org/packages/extra/x86_64/openrgb/) or from the AUR for the [pipeline](https://aur.archlinux.org/packages/openrgb-git/) version.

scripts/prepare-artifacts.py

@@ -12,12 +12,12 @@ import os
 #############################################
 # OpenRGB version                           #
 #############################################
-version = "1.0rc2"
+version = "1.0rc3"
 
 #############################################
 # Git version (tag, branch, or commit)      #
 #############################################
-git_id = "release_candidate_1.0rc2"
+git_id = "release_candidate_1.0rc3"
 
 command = "git rev-list -n 1 " + git_id
 print(command)
@@ -42,7 +42,7 @@ artifacts = [
     [ "Linux+i386+.deb+%28Debian+Trixie%29",        "openrgb_" + version + "_i386_trixie_"    + commit, ".deb"      ],
     [ "Linux%20amd64%20AppImage",                   "OpenRGB_" + version + "_x86_64_"         + commit, ".AppImage" ],
     [ "Linux%20i386%20AppImage",                    "OpenRGB_" + version + "_i386_"           + commit, ".AppImage" ],
-    [ "Linux+64+F40+rpm",                           "openrgb_" + version + "_x86_64_f40_"     + commit, ".rpm"      ],
+    [ "Linux+64+F43+rpm",                           "openrgb_" + version + "_x86_64_f43_"     + commit, ".rpm"      ],
     [ "Linux+arm64+.deb+%28Debian%20Bookworm%29",   "openrgb_" + version + "_arm64_bookworm_" + commit, ".deb"      ],
     [ "Linux+armhf+.deb+%28Debian%20Bookworm%29",   "openrgb_" + version + "_armhf_bookworm_" + commit, ".deb"      ],
     [ "Linux+arm64+.deb+%28Debian%20Trixie%29",     "openrgb_" + version + "_arm64_trixie_"   + commit, ".deb"      ],