Initialize NZXT Hue 2 fan reporting

Commits squashed and amended for code style by Adam Honse <[email protected]>

.gitlab-ci.yml

@@ -177,7 +177,7 @@ before_script:
   script:
   - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
-  - dpkg-buildpackage --target-arch i386 -us -B
+  - dpkg-buildpackage -us -B
   - rm -v ../openrgb-dbgsym*.deb
   - mv -v ../openrgb*.deb ./
 

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -57,6 +57,7 @@ void DetectBloodyB820R(hid_device_info* info, const std::string& name)
 }
 
 REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
+REGISTER_HID_DETECTOR_IPU("Bloody W70 Max",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W70_MAX_PID,     2,      0xFF33,     0x0518);
 REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
 REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
 REGISTER_HID_DETECTOR_IPU("A4Tech Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.h

@@ -19,6 +19,7 @@
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
 #define BLOODY_W60_PRO_PID                          0x37EA
+#define BLOODY_W70_MAX_PID                          0x79EF
 #define BLOODY_W90_MAX_PID                          0x3666
 
 /*-----------------------------------------------------*\

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.cpp

@@ -109,6 +109,7 @@ void RGBController_BloodyMouse::SetupZones()
         case BLOODY_W60_PRO_PID:
             layout = w60_pro;
             break;
+        case BLOODY_W70_MAX_PID:
         case BLOODY_W90_MAX_PID:
             layout = w90_max;
             break;

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp

@@ -35,10 +35,10 @@ layout_values aoc_keyboard_offset_values =
             75,   76,   91,   62,   48,   64,   50,   65,   66,   67,   97,   68,   84,   70,   59,   74,   89,    58,   73,   88,  103,
         /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \   DEL   END   PGDN   NP7   NP8   NP9   NP+ */
             60,   61,   47,   78,   33,   49,   35,   80,   51,   52,   53,   69,   99,   25,   44,   29,   14,    43,   28,   13,  102,
-        /* CPLK    A     S     D     F     G     H     J     K     L     ;     "   ENTR                           NP4   NP5   NP6       */
-            45,   46,   32,   93,   18,   34,   20,   95,   36,   37,   38,   54,   10,                            57,   72,   87,
-        /* LSFT    Z     X     C     V     B     N     M     ,     .     /   RSFT                   ARWU          NP1   NP2   NP3  NPEN */
-            30,   31,   17,    2,    3,   19,    5,    6,   21,   22,   23,   39,                     11,          42,   27,   12,  101,
+        /* CPLK    A     S     D     F     G     H     J     K     L     ;     "     #   ENTR                     NP4   NP5   NP6       */
+            45,   46,   32,   93,   18,   34,   20,   95,   36,   37,   38,   54,    0,   10,                      57,   72,   87,
+        /* LSFT    \     Z     X     C     V     B     N     M     ,     .     /   RSFT             ARWU          NP1   NP2   NP3  NPEN */
+            30,    0,   31,   17,    2,    3,   19,    5,    6,   21,   22,   23,   39,               11,          42,   27,   12,  101,
         /* LCTL  LWIN  LALT               SPC              RALT  RFNC  RMNU  RCTL              ARWL ARWD   ARWR   NP0         NP.       */
             15,    0,    1,                4,                7,    8,   24,    9,               26,   41,   56,    71,         86
     },

Controllers/AlienwareController/AlienwareController.cpp

@@ -31,7 +31,8 @@ static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
 {
     { 0x0C01,   4 },    // Dell G5 SE 5505
     { 0x0A01,  16 },    // Dell G7 15 7500
-    { 0x0E03,   4 }     // Dell G15   5511
+    { 0x0E03,   4 },    // Dell G15   5511
+    { 0x0E0A,   4 }     // Dell G15   5530
 
 };
 
@@ -47,7 +48,8 @@ static const std::map<alienware_platform_id, std::vector<const char*>> zone_name
                   "Light Bar 4",    "Light Bar 5",  "Light Bar 6",
                   "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
                   "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } },
-    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } }
+    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } },
+    { 0x0E0A,   { "Left",           "Middle",       "Right",        "Numpad"    } }
 };
 
 static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)

Controllers/AlienwareController/AlienwareControllerDetect.cpp

@@ -20,7 +20,8 @@
 /*---------------------------------------------------------*\
 | Alienware product ID                                      |
 \*---------------------------------------------------------*/
-#define ALIENWARE_G_SERIES_PID                      0x0550
+#define ALIENWARE_G_SERIES_PID1                      0x0550
+#define ALIENWARE_G_SERIES_PID2                      0x0551
 
 void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
 {
@@ -35,4 +36,5 @@ void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
     }
 }
 
-REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID);
+REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID1);
+REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID2);

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

@@ -19,8 +19,6 @@
 
 #define AURA_CORE_VID                   0x0B05
 
-#define AURA_STRIX_SCAR_15_PID          0x19B6
-
 /******************************************************************************************\
 *                                                                                          *
 *   DetectAuraCoreControllers                                                              *

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.cpp

@@ -10,45 +10,10 @@
 \*---------------------------------------------------------*/
 
 #include "AsusAuraCoreLaptopController.h"
+#include "dmiinfo.h"
 #include "SettingsManager.h"
 #include "StringUtils.h"
 
-static uint8_t packet_map[ASUSAURACORELAPTOP_KEYCOUNT       +
-                          ASUSAURACORELAPTOP_LIGHTBARCOUNT  +
-                          ASUSAURACORELAPTOP_LIDCOUNT       ] =
-{
-/*00        ESC  F1   F2   F3   F4   F5   F6   F7   F8   F9  */
-            21,  23,  24,  25,  26,  28,  29,  30,  31,  33,
-
-/*10        F10  F11  F12  DEL   `    1    2    3    4    5  */
-            34,  35,  36,  37,  42,  43,  44,  45,  46,  47,
-
-/*20         6    7    8    9    0    -    =   BSP  BSP  BSP */
-            48,  49,  50,  51,  52,  53,  54,  55,  56,  57,
-
-/*30        PLY  TAB   Q    W    E    R    T    Y    U    I  */
-            58,  63,  64,  65,  66,  67,  68,  69,  70,  71,
-
-/*40         O    P    [    ]    \   STP  CAP   A    S    D  */
-            72,  73,  74,  75,  76,  79,  84,  85,  86,  87,
-
-/*50         F    G    H    J    K    L    ;    '   ENT  PRV */
-            88,  89,  90,  91,  92,  93,  94,  95,  98, 100,
-
-/*60        LSH   Z    X    C    V    B    N    M    ,    .  */
-           105, 107, 108, 109, 110, 111, 112, 113, 114, 115,
-
-/*70         /   RSH  UP   NXT LCTL  LFN LWIN LALT  SPC RALT */
-           116, 119, 139, 121, 126, 127, 128, 129, 131, 135,
-
-/*80       RCTL  LFT  DWN  RGT  PRT KSTN  VDN  VUP MICM HPFN */
-           137, 159, 160, 161, 142, 175,   2,   3,   4,   5,
-
-/*90       ARMC  LB1  LB2  LB3  LB4  LB5  LB6 LOGO LIDL LIDR */
-             6, 174, 173, 172, 171, 170, 169, 167, 176, 177,
-
-};
-
 static std::string power_zones[ASUSAURACORELAPTOP_POWER_ZONES] =
 {
     "Logo",
@@ -67,20 +32,40 @@ static std::string power_states[ASUSAURACORELAPTOP_POWER_STATES] =
 
 AsusAuraCoreLaptopController::AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path)
 {
-    dev                 = dev_handle;
-    location            = path;
+    dev                     = dev_handle;
+    location                = path;
 
     /*---------------------------------------------------------*\
-    | Get device name from HID manufacturer and product strings |
+    | The motherboard name will uniquely ID the laptop to       |
+    |   determine the metadata of the device.                   |
     \*---------------------------------------------------------*/
-    wchar_t name_string[HID_MAX_STR];
+    DMIInfo dmi_info;
+    std::string dmi_name    = dmi_info.getMainboard();
+    bool not_found          = true;
 
-    hid_get_manufacturer_string(dev, name_string, HID_MAX_STR);
-    device_name = StringUtils::wstring_to_string(name_string);
+    for(uint16_t i = 0; i < AURA_CORE_LAPTOP_DEVICE_COUNT; i++)
+    {
+        if(aura_core_laptop_device_list[i]->dmi_name == dmi_name)
+        {
+            /*---------------------------------------------------------*\
+            | Set device ID                                             |
+            \*---------------------------------------------------------*/
+            not_found       = false;
+            device_index    = i;
+            break;
+        }
+    }
 
-    hid_get_product_string(dev, name_string, HID_MAX_STR);
-    device_name.append(" ").append(StringUtils::wstring_to_string(name_string));
+    if(not_found)
+    {
+        LOG_ERROR("[%s] device capabilities not found. Please creata a new device request.",
+                  dmi_name.c_str());
+        return;
+    }
 
+    /*---------------------------------------------------------*\
+    | Only set power config for known devices                   |
+    \*---------------------------------------------------------*/
     SetPowerConfigFromJSON();
 }
 
@@ -89,9 +74,66 @@ AsusAuraCoreLaptopController::~AsusAuraCoreLaptopController()
     hid_close(dev);
 }
 
-std::string AsusAuraCoreLaptopController::GetDeviceName()
+const aura_core_laptop_device* AsusAuraCoreLaptopController::GetDeviceData()
 {
-    return device_name;
+    return aura_core_laptop_device_list[device_index];
+}
+
+std::string AsusAuraCoreLaptopController::GetDeviceDescription()
+{
+    /*---------------------------------------------------------*\
+    | Get device name from HID manufacturer and product strings |
+    \*---------------------------------------------------------*/
+    wchar_t name_string[HID_MAX_STR];
+
+    hid_get_manufacturer_string(dev, name_string, HID_MAX_STR);
+    std::string name = StringUtils::wstring_to_string(name_string);
+
+    hid_get_product_string(dev, name_string, HID_MAX_STR);
+    name.append(" ").append(StringUtils::wstring_to_string(name_string));
+    return name;
+}
+
+unsigned int AsusAuraCoreLaptopController::GetKeyboardLayout()
+{
+    const uint8_t index                                     = 6;
+    uint8_t result                                          = 0;
+    uint8_t rd_buf[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID };
+    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID,
+                                                                ASUSAURACORELAPTOP_CMD_LAYOUT,
+                                                                0x20,
+                                                                0x31,
+                                                                0x00,
+                                                                0x10  };
+
+    /*---------------------------------------------------------*\
+    | Clear the read buffer to ensure we read the right packet  |
+    \*---------------------------------------------------------*/
+    do
+    {
+        result = hid_read_timeout(dev, rd_buf, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE, 10);
+    }
+    while(result > 0);
+
+    memset(&rd_buf[1],     0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - 1);
+    memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
+
+    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+    result = hid_get_feature_report(dev, rd_buf, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+
+    LOG_DEBUG("[%s] GetKeyboardLayout %02X %02X %02X %02X   %02X %02X %02X {%02X}   %02X %02X %02X %02X",
+              aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
+              rd_buf[5],  rd_buf[6],  rd_buf[7],  rd_buf[8],  rd_buf[9],  rd_buf[10],
+              rd_buf[11], rd_buf[12], rd_buf[13], rd_buf[14], rd_buf[15], rd_buf[16]);
+
+    if(result > 0)
+    {
+        return rd_buf[12];
+    }
+
+    LOG_DEBUG("[%s] GetKeyboardLayout: An error occurred! Setting layout to ANSI",
+              aura_core_laptop_device_list[device_index]->dmi_name.c_str());
+    return ASUSAURACORELAPTOP_LAYOUT_ANSI;
 }
 
 std::string AsusAuraCoreLaptopController::GetSerial()
@@ -101,6 +143,8 @@ std::string AsusAuraCoreLaptopController::GetSerial()
 
     if(ret != 0)
     {
+        LOG_DEBUG("[%s] Get HID Serial string failed",
+                  aura_core_laptop_device_list[device_index]->dmi_name.c_str());
         return("");
     }
 
@@ -132,35 +176,50 @@ void AsusAuraCoreLaptopController::SetMode(uint8_t mode, uint8_t speed, uint8_t
         current_random      = random;
         current_direction   = direction;
 
+        if(current_mode == ASUSAURACORELAPTOP_MODE_DIRECT)
+        {
+            SendInitDirectMode();
+            return;
+        }
+
         SendUpdate();
         SendBrightness();
     }
 }
 
-void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor> colors)
+void AsusAuraCoreLaptopController::SendInitDirectMode()
+{
+    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_DIRECT };
+    memset(&buffer[2], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - 2);
+
+    LOG_DEBUG("[%s] Resetting device for direct control", aura_core_laptop_device_list[device_index]->dmi_name.c_str());
+    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+}
+
+void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor *> colors)
 {
     /*---------------------------------------------------------*\
     | The keyboard zone is a set of 168 keys (indexed from 0)   |
     |   sent in 11 packets of 16 triplets. The Lid and Lightbar |
     |   zones are sent in one final packet afterwards.          |
     \*---------------------------------------------------------*/
-    const uint8_t  key_set                                  = 167;
-    const uint8_t  led_count                                = 178;
-    const uint16_t map_size                                 = 3 * led_count;
-    const uint8_t leds_per_packet                           = 16;
+    const uint8_t   key_set                                 = 167;
+    const uint8_t   led_count                               = colors.size();
+    const uint16_t  map_size                                = 3 * led_count;
+    const uint8_t   leds_per_packet                         = 16;
     uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_DIRECT,
                                                                 0x00, 0x01, 0x01, 0x01, 0x00, leds_per_packet, 0x00 };
-    uint8_t key_buf[map_size];
+    uint8_t*        key_buf                                 = new uint8_t[map_size];
 
     memset(key_buf, 0, map_size);
 
-    for(size_t led_index = 0; led_index < colors.size(); led_index++)
+    for(size_t led_index = 0; led_index < led_count; led_index++)
     {
-        uint16_t offset         = 3 * packet_map[led_index];
+        std::size_t buf_idx     = (led_index * 3);
 
-        key_buf[offset]         = RGBGetRValue(colors[led_index]);
-        key_buf[offset + 1]     = RGBGetGValue(colors[led_index]);
-        key_buf[offset + 2]     = RGBGetBValue(colors[led_index]);
+        key_buf[buf_idx]        = RGBGetRValue(*colors[led_index]);
+        key_buf[buf_idx + 1]    = RGBGetGValue(*colors[led_index]);
+        key_buf[buf_idx + 2]    = RGBGetBValue(*colors[led_index]);
     }
 
     for(size_t i = 0; i < key_set; i+=leds_per_packet)
@@ -170,11 +229,20 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor> colors)
         if(leds_remaining < leds_per_packet)
         {
             buffer[07]          = leds_remaining;
+
+            memset(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
+                   0,
+                   ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - ASUSAURACORELAPTOP_DATA_BYTE);
         }
 
         buffer[06]              = (uint8_t)i;
         memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * i], (3 * buffer[07]));
 
+        LOG_DEBUG("[%s] Sending buffer @ index %d thru index %d",
+                  aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
+                  i,
+                  i + buffer[07]);
+
         hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
     }
 
@@ -182,15 +250,31 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor> colors)
     buffer[5] = 0x00;
     buffer[6] = 0x00;
     buffer[7] = 0x00;
-    memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * key_set], (3 * (led_count - key_set)));
+
+    memset(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
+           0,
+           ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - ASUSAURACORELAPTOP_DATA_BYTE);
+
+    if(led_count > key_set)
+    {
+        memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
+               &key_buf[3 * key_set],
+               (3 * (led_count - key_set)));
+    }
+
+    LOG_DEBUG("[%s] Sending buffer @ index %d thru index %d",
+              aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
+              key_set,
+              led_count);
 
     hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
+    delete[] key_buf;
 }
 
 void AsusAuraCoreLaptopController::SendBrightness()
 {
-    const uint8_t index                                     = 2;
-    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_BRIGHTNESS };
+    const uint8_t index                                     = 5;
+    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_BRIGHTNESS, 0xC5, 0xC4};
 
     memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
     buffer[4] = current_brightness;
@@ -283,6 +367,8 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
         device_settings[section_power]  = pcfg;
         settings_manager->SetSettings(detector_name, device_settings);
         settings_manager->SaveSettings();
+        LOG_DEBUG("[%s] default power config saved to openrgb.json",
+                  aura_core_laptop_device_list[device_index]->dmi_name.c_str());
     }
     else
     {
@@ -293,7 +379,9 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
             if(device_settings[section_power].contains(key_name))
             {
                 power_config[i].state   = device_settings[section_power][key_name];
-                LOG_DEBUG("[%s] Reading power config for %s: %s", device_name.c_str(), key_name.c_str(), ((power_config[i].state) ? "On" : "Off"));
+                LOG_DEBUG("[%s] Reading power config for %s: %s",
+                          aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
+                          key_name.c_str(), ((power_config[i].state) ? "On" : "Off"));
             }
         }
     }
@@ -303,7 +391,7 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
     |   With thanks to AsusCtl for helping to decipher the packet captures          |
     |   https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-aura/src/usb.rs#L150  |
     \*-----------------------------------------------------------------------------*/
-    bool flag_array[] =
+    bool flag_array[32] =
     {
         power_config[0].state,      power_config[4].state,
         power_config[1].state,      power_config[5].state,
@@ -320,7 +408,9 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
     };
 
     uint32_t flags      = PackPowerFlags(flag_array);
-    LOG_DEBUG("[%s] Sending power config Logo+KB: %02X Lightbar: %02X Lid Edges: %02X Raw: %08X", device_name.c_str(), (flags & 0xFF), ((flags >> 8)  & 0xFF), ((flags >> 16)  & 0xFF), flags);
+    LOG_DEBUG("[%s] Sending power config Logo+KB: %02X Lightbar: %02X Lid Edges: %02X Raw: %08X",
+              aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
+              (flags & 0xFF), ((flags >> 8)  & 0xFF), ((flags >> 16)  & 0xFF), flags);
     SendPowerConfig(flags);
 }
 

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.h

@@ -18,6 +18,7 @@
 #include "RGBController.h"
 #include "ResourceManager.h"
 #include "RGBControllerKeyNames.h"
+#include "AsusAuraCoreLaptopDevices.h"
 
 #define NA                                      0xFFFFFFFF
 #define HID_MAX_STR                             255
@@ -33,7 +34,7 @@
 #define ASUSAURACORELAPTOP_POWER_ZONES          4
 #define ASUSAURACORELAPTOP_POWER_STATES         4
 #define ASUSAURACORELAPTOP_BRIGHTNESS_MIN       0
-#define ASUSAURACORELAPTOP_BRIGHTNESS_MAX       255
+#define ASUSAURACORELAPTOP_BRIGHTNESS_MAX       3 // No device has proven to have 256 keyboard brightness levels, only 0..3
 
 enum
 {
@@ -83,6 +84,7 @@ enum
     ASUSAURACORELAPTOP_CMD_UPDATE               = 0xB3,
     ASUSAURACORELAPTOP_CMD_APPLY                = 0xB4,
     ASUSAURACORELAPTOP_CMD_SET                  = 0xB5,
+    ASUSAURACORELAPTOP_CMD_LAYOUT               = 0x05,
 };
 
 enum
@@ -92,6 +94,12 @@ enum
     ASUSAURACORELAPTOP_SPEED_FASTEST            = 0xF5, // Fastest speed
 };
 
+enum aura_core_laptop_layout
+{
+    ASUSAURACORELAPTOP_LAYOUT_ANSI              = 0x01,     /* US ANSI Layout                   */
+    ASUSAURACORELAPTOP_LAYOUT_ISO               = 0x02,     /* EURO ISO Layout                  */
+};
+
 struct p_state
 {
     std::string zone;
@@ -104,33 +112,36 @@ public:
     AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path);
     ~AsusAuraCoreLaptopController();
 
-    std::string             GetDeviceName();
-    std::string             GetSerial();
-    std::string             GetLocation();
+    const aura_core_laptop_device*  GetDeviceData();
+    std::string                     GetDeviceDescription();
+    std::string                     GetSerial();
+    unsigned int                    GetKeyboardLayout();
+    std::string                     GetLocation();
 
-    void                    SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction);
-    void                    SetLedsDirect(std::vector<RGBColor> colors);
+    void                            SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction);
+    void                            SetLedsDirect(std::vector<RGBColor *>colors);
+    void                            SendInitDirectMode();
 private:
-    std::string             device_name;
-    std::string             location;
-    hid_device*             dev;
+    hid_device*                     dev;
+    uint16_t                        device_index;
+    std::string                     location;
 
-    uint8_t                 current_mode;
-    uint8_t                 current_speed;
-    uint8_t                 current_direction;
+    uint8_t                         current_mode;
+    uint8_t                         current_speed;
+    uint8_t                         current_direction;
 
-    RGBColor                current_c1;
-    RGBColor                current_c2;
-    uint8_t                 current_brightness;
-    uint8_t                 current_random;
+    RGBColor                        current_c1;
+    RGBColor                        current_c2;
+    uint8_t                         current_brightness;
+    uint8_t                         current_random;
 
-    void                    SendApply();
-    void                    SendBrightness();
-    void                    SendSet();
-    void                    SendUpdate();
+    void                            SendApply();
+    void                            SendBrightness();
+    void                            SendSet();
+    void                            SendUpdate();
 
-    void                    SetPowerConfigFromJSON();
-    void                    SendPowerConfig(uint32_t flags);
-    uint32_t                PackPowerFlags(bool flags[]);
-    std::vector<p_state>    PowerConfigArray();
+    void                            SetPowerConfigFromJSON();
+    void                            SendPowerConfig(uint32_t flags);
+    uint32_t                        PackPowerFlags(bool flags[]);
+    std::vector<p_state>            PowerConfigArray();
 };

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopDevices.cpp

@@ -0,0 +1,347 @@
+#include "AsusAuraCoreLaptopDevices.h"
+
+/*-------------------------------------------------------------------------*\
+|  Aura Core Key Values                                                     |
+|    NULL values are keys that are handed to the KLM but are removed as     |
+|    a part of customisation. They are included to maintain expected key    |
+|    count is aligned to the value count.                                   |
+\*-------------------------------------------------------------------------*/
+
+std::vector<unsigned int> aura_core_laptop_15_values =
+{
+    /* ESC          F1    F2    F3    F4    F5    F6    F7    F8    F9   F10   F11   F12         DEL  */
+        21,         23,   24,   25,   26,   28,   29,   30,   31,   33,   34,   35,   36,
+    /* BKTK    1     2     3     4     5     6     7     8     9     0     -     =   BSPC        PLAY  */
+        42,   43,   44,   45,   46,   47,   48,   49,   50,   51,   52,   53,   54,   55,
+    /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \         STOP  */
+        63,   64,   65,   66,   67,   68,   69,   70,   71,   72,   73,   74,   75,   76,
+    /* CPLK    A     S     D     F     G     H     J     K     L     ;     "     #   ENTR        PREV  */
+        84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,   95,   96,   98,
+    /* LSFT  ISO\    Z     X     C     V     B     N     M     ,     .     /   RSFT        ARWU  NEXT  */
+       105,  106,  107,  108,  109,  110,  111,  112,  113,  114,  115,  116,  119,
+    /* LCTL  LWIN  LALT              SPC               RALT  RFNC  RMNU  RCTL        ARWL  ARWD  ARWR  */
+       126,  128,  129,              131,              135,  136,  136,  137,
+};
+
+std::vector<unsigned int> aura_core_laptop_17_values =
+{
+    /* ESC          F1    F2    F3    F4    F5    F6    F7    F8    F9   F10   F11   F12   NULL  NULL  PAUS                          */
+        21,         23,   24,   25,   26,   28,   29,   30,   31,   33,   34,   35,   36,    0,    0,   39,
+    /* BKTK    1     2     3     4     5     6     7     8     9     0     -     =   BSPC  NULL  NULL  NULL  NMLK  NMDV  NMTM  NMMI  */
+        42,   43,   44,   45,   46,   47,   48,   49,   50,   51,   52,   53,   54,   56,    0,    0,    0,   59,   60,   61,   62,
+    /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \   NULL  NULL  NULL  NM7   NM8   NM9   NMPL  */
+        63,   64,   65,   66,   67,   68,   69,   70,   71,   72,   73,   74,   75,   76,    0,    0,    0,   80,   81,   82,   83,
+    /* CPLK    A     S     D     F     G     H     J     K     L     ;     "     #   ENTR                    NM4   NM5   NM6         */
+        84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,   95,   96,   98,                    101,  102,  103,
+    /* LSFT  ISO\    Z     X     C     V     B     N     M     ,     .     /   RSFT              ARWU        NM1   NM2   NM3   NMER  */
+       105,  106,  107,  108,  109,  110,  111,  112,  113,  114,  115,  116,  119,              139,        122,  123,  124,  125,
+    /* LCTL  LWIN  LALT              SPC               RALT  RFNC  RMNU  RCTL              ARWL  ARWD  ARWR        NM0   NMPD        */
+       126,  128,  129,              131,              135,  136,  136,  137,              159,  160,  161,        144,  145,
+};
+
+std::vector<unsigned int> aura_core_laptop_18_values =
+{
+    /* ESC          F1    F2    F3    F4    F5    F6    F7    F8    F9   F10   F11   F12   NULL  NULL  PAUS                          */
+        21,         23,   24,   25,   26,   28,   29,   30,   31,   33,   34,   35,   36,    0,    0,   39,
+    /* BKTK    1     2     3     4     5     6     7     8     9     0     -     =   BSPC  NULL  NULL  NULL  NMLK  NMDV  NMTM  NMMI  */
+        42,   43,   44,   45,   46,   47,   48,   49,   50,   51,   52,   53,   54,   56,    0,    0,    0,   59,   60,   61,   62,
+    /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \   NULL  NULL  NULL  NM7   NM8   NM9   NMPL  */
+        63,   64,   65,   66,   67,   68,   69,   70,   71,   72,   73,   74,   75,   76,    0,    0,    0,   80,   81,   82,   83,
+    /* CPLK    A     S     D     F     G     H     J     K     L     ;     "     #   ENTR                    NM4   NM5   NM6         */
+        84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,   95,   96,   98,                    101,  102,  103,
+    /* LSFT  ISO\    Z     X     C     V     B     N     M     ,     .     /   RSFT              ARWU        NM1   NM2   NM3   NMER  */
+        105,  106,  107,  108,  109,  110,  111,  112,  113,  114,  115,  116,  119,              121,        122,  123,  124,  125,
+    /* LCTL  LWIN  LALT              SPC               RALT  RFNC  RMNU  RCTL              ARWL  ARWD  ARWR        NM0   NMPD        */
+        126,  128,  129,              131,              135,  136,  136,  137,              141,  142,  143,        144,  145,
+};
+
+/*-------------------------------------------------------------------------*\
+|  KEYMAPS                                                                  |
+\*-------------------------------------------------------------------------*/
+keyboard_keymap_overlay_values g533zm_layout
+{
+    KEYBOARD_SIZE_SEVENTY_FIVE,
+    {
+        aura_core_laptop_15_values,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,      15,          37,        KEY_EN_DELETE,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Delete
+        {   0,      1,      15,          58,        KEY_EN_MEDIA_PLAY_PAUSE,    KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
+        {   0,      2,      15,          79,        KEY_EN_MEDIA_STOP,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
+        {   0,      3,      15,         100,        KEY_EN_MEDIA_PREVIOUS,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
+        {   0,      4,      13,         139,        KEY_EN_UP_ARROW,            KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Up Arrow
+        {   0,      4,      15,         121,        KEY_EN_MEDIA_NEXT,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
+        {   0,      5,      12,         159,        KEY_EN_LEFT_ARROW,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Arrow
+        {   0,      5,      13,         160,        KEY_EN_DOWN_ARROW,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Down Arrow
+        {   0,      5,      14,         161,        KEY_EN_RIGHT_ARROW,         KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Right Arrow
+    }
+};
+
+keyboard_keymap_overlay_values g713rw_keyboard_layout
+{
+    KEYBOARD_SIZE_FULL,
+    {
+        aura_core_laptop_17_values,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       2,           2,        KEY_EN_MEDIA_VOLUME_DOWN,   KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Row and add Volume Down
+        {   0,      0,       3,           3,        KEY_EN_MEDIA_VOLUME_UP,     KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Volume Up
+        {   0,      0,       4,           4,        KEY_EN_MEDIA_MUTE,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute
+        {   0,      0,       5,           5,        "Key: Fan",                 KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "Fan" key
+        {   0,      0,       6,           6,        "Key: ROG",                 KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "ROG" key
+        {   0,      6,       1,         127,        KEY_EN_LEFT_FUNCTION,       KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Fuction
+        {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
+        {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
+        {   0,      6,      10,         136,        KEY_EN_RIGHT_FUNCTION,      KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Fuction
+        {   0,      6,      10,         136,        KEY_EN_RIGHT_WINDOWS,       KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Win Key
+
+        {   0,      1,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },
+        {   0,      1,      15,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad
+        {   0,      1,      15,          38,        KEY_EN_DELETE,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Delete key
+        {   0,      1,      17,          40,        KEY_EN_PRINT_SCREEN,        KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Print Screen key
+        {   0,      1,      18,          41,        KEY_EN_HOME,                KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Home key
+        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      3,      13,          76,        KEY_EN_ANSI_BACK_SLASH,     KEYBOARD_OPCODE_SWAP_ONLY,          }, // Force ANSI | even on ISO layouts
+        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      5,      12,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // gap before arrow up key
+        {   0,      5,      13,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad
+
+        {   0,      6,      11,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // 1 empty key before arrow keys
+        {   0,      6,      15,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad
+        {   0,      6,      16,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // 1 empty key between numpad 0 and .
+
+        // Close numpad gap completely
+        {   0,      1,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      5,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+        {   0,      6,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+
+        // Move Arrow keys
+        {   0,      5,      13,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Remove Arrow Up
+        {   0,      6,      13,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Remove Arrow Down
+        {   0,      6,      12,         139,        KEY_EN_UP_ARROW,            KEYBOARD_OPCODE_SWAP_ONLY,          },  // Shift Arrow Up
+        {   0,      7,      11,         159,        KEY_EN_LEFT_ARROW,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      7,      12,         160,        KEY_EN_DOWN_ARROW,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      7,      13,         161,        KEY_EN_RIGHT_ARROW,         KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+    }
+};
+
+keyboard_keymap_overlay_values g713rw_lightbar_layout
+{
+    KEYBOARD_SIZE_EMPTY,
+    {
+        {   /* Values not set in empty keyboard */   },
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       0,         174,        "Lightbar L1",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L1
+        {   0,      0,       1,         173,        "Lightbar L2",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L2
+        {   0,      0,       2,         172,        "Lightbar L3",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L3
+        {   0,      0,       3,         171,        "Lightbar R3",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R3
+        {   0,      0,       4,         170,        "Lightbar R2",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
+        {   0,      0,       5,         169,        "Lightbar R1",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R1
+    }
+};
+
+keyboard_keymap_overlay_values g814jv_keyboard_layout
+{
+    KEYBOARD_SIZE_FULL,
+    {
+        aura_core_laptop_18_values,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+     /*---------------------------------------------------------------------------------------------------------*\
+    | Edit Keys                                                                                                 |
+    |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+    \*---------------------------------------------------------------------------------------------------------*/
+     {   0,      0,       2,           2,        KEY_EN_MEDIA_VOLUME_DOWN,   KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Row and add Volume Down
+     {   0,      0,       3,           3,        KEY_EN_MEDIA_VOLUME_UP,     KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Volume Up
+     {   0,      0,       4,           4,        KEY_EN_MEDIA_MUTE,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute
+     {   0,      0,       5,           5,        "Key: Fan",                 KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "Fan" key
+     {   0,      0,       6,           6,        "Key: ROG",                 KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "ROG" key
+     {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
+     {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
+     {   0,      6,       1,         127,        KEY_EN_LEFT_FUNCTION,       KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Fuction
+     {   0,      6,      11,         136,        KEY_EN_PRINT_SCREEN,        KEYBOARD_OPCODE_SWAP_ONLY,          },  // Replace Right Fuction with PrtSc
+     {   0,      6,      12,         136,        KEY_EN_RIGHT_WINDOWS,       KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Win Key
+     {   0,      1,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      1,      14,          38,        KEY_EN_DELETE,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Insert a Delete key
+     {   0,      1,      16,          40,        KEY_EN_PRINT_SCREEN,        KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Print Screen key
+     {   0,      1,      17,          41,        KEY_EN_HOME,                KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Home key
+     {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      3,      13,          76,        KEY_EN_ANSI_BACK_SLASH,     KEYBOARD_OPCODE_SWAP_ONLY,          }, // Force ANSI | even on ISO layouts
+     {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  }, // Numpad gap
+     {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      5,      12,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      5,      13,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      5,      14,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     {   0,      6,      15,           0,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
+     }
+};
+
+keyboard_keymap_overlay_values g814jv_lightbar_layout
+{
+    KEYBOARD_SIZE_EMPTY,
+    {
+        {   /* Values not set in empty keyboard */   },
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       0,         173,        "Lightbar L1",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L1
+        {   0,      0,       1,         172,        "Lightbar L2",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L2
+        {   0,      0,       2,         170,        "Lightbar R2",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
+        {   0,      0,       3,         169,        "Lightbar R1",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
+    }
+};
+
+
+/*-------------------------------------------------------------------------*\
+|  AURA CORE LAPTOP DEVICES                                                 |
+\*-------------------------------------------------------------------------*/
+
+/*-------------------------------------------------------------*\
+|  ASUS ROG Strix SCAR 15                                       |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       7 Rows, 16 Columns                                      |
+\*-------------------------------------------------------------*/
+static const aura_core_laptop_zone g533zm_zone =
+{
+    ZONE_EN_KEYBOARD,
+    &g533zm_layout
+};
+
+static const aura_core_laptop_device g533zm_device =
+{
+    "G533ZM",
+    {
+        &g533zm_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    }
+};
+
+/*-------------------------------------------------------------*\
+|  ASUS ROG Strix SCAR G713RW                                   |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       7 Rows, 20 Columns                                      |
+\*-------------------------------------------------------------*/
+static const aura_core_laptop_zone g713rw_keyboard_zone =
+{
+    ZONE_EN_KEYBOARD,
+    &g713rw_keyboard_layout
+};
+
+static const aura_core_laptop_zone g713rw_lightbar_zone =
+{
+    "Lightbar",
+    &g713rw_lightbar_layout
+};
+
+static const aura_core_laptop_device g713rw_device =
+{
+    "G713RW",
+    {
+        &g713rw_keyboard_zone,
+        &g713rw_lightbar_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    }
+};
+/*-------------------------------------------------------------*\
+|  ASUS ROG Strix G18 (G814JV)                                  |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       7 Rows, 16 Columns                                      |
+\*-------------------------------------------------------------*/
+
+static const aura_core_laptop_zone g814rw_keyboard_zone =
+{
+    ZONE_EN_KEYBOARD,
+    &g814jv_keyboard_layout
+};
+
+static const aura_core_laptop_zone g814jv_lightbar_zone =
+{
+    "Lightbar",
+    &g814jv_lightbar_layout
+};
+
+static const aura_core_laptop_device g814jv_device =
+{
+    "G814JV",
+    {
+        &g814rw_keyboard_zone,
+        &g814jv_lightbar_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    }
+};
+
+/*-------------------------------------------------------------------------*\
+|  DEVICE MASTER LIST                                                       |
+\*-------------------------------------------------------------------------*/
+const aura_core_laptop_device* aura_core_laptop_device_list_data[] =
+{
+/*-----------------------------------------------------------------*\
+|  KEYBOARDS                                                        |
+\*-----------------------------------------------------------------*/
+    &g533zm_device,
+    &g713rw_device,
+    &g814jv_device,
+};
+
+const unsigned int AURA_CORE_LAPTOP_DEVICE_COUNT = (sizeof(aura_core_laptop_device_list_data) / sizeof(aura_core_laptop_device_list_data[ 0 ]));
+const aura_core_laptop_device** aura_core_laptop_device_list = aura_core_laptop_device_list_data;

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopDevices.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include "RGBController.h"
+#include "RGBControllerKeyNames.h"
+#include "KeyboardLayoutManager.h"
+
+#define AURA_CORE_LAPTOP_ZONES_MAX      6
+
+enum aura_core_kb_layout
+{
+    AURA_CORE_LAPTOP_KB_LAYOUT_ANSI     = 0x01,     /* US ANSI Layout                   */
+    AURA_CORE_LAPTOP_KB_LAYOUT_ISO      = 0x02,     /* EURO ISO Layout                  */
+    AURA_CORE_LAPTOP_KB_LAYOUT_ABNT     = 0x03,     /* Brazilian Layout                 */
+    AURA_CORE_LAPTOP_KB_LAYOUT_JIS      = 0x04,     /* Japanese Layout                  */
+};
+
+typedef struct
+{
+    std::string                         name;
+    keyboard_keymap_overlay_values*     layout_new;
+}   aura_core_laptop_zone;
+
+typedef struct
+{
+    uint8_t                             zone;
+    uint8_t                             row;
+    uint8_t                             col;
+    uint8_t                             index;
+    const char*                         name;
+}   aura_core_laptop_led;
+
+typedef struct
+{
+    std::string                         dmi_name;
+    const aura_core_laptop_zone*        zones[AURA_CORE_LAPTOP_ZONES_MAX];
+}   aura_core_laptop_device;
+
+/*-----------------------------------------------------*\
+| Aura Core Laptop Protocol Keyboards                   |
+\*-----------------------------------------------------*/
+#define AURA_STRIX_SCAR_15_PID                      0x19B6
+
+/*-----------------------------------------------------*\
+| These constant values are defined in                  |
+| AsusAuraCoreLaptopDevices.cpp                         |
+\*-----------------------------------------------------*/
+extern const unsigned int AURA_CORE_LAPTOP_DEVICE_COUNT;
+extern const aura_core_laptop_device** aura_core_laptop_device_list;

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.cpp

@@ -11,129 +11,6 @@
 
 #include "RGBController_AsusAuraCoreLaptop.h"
 
-static unsigned int matrix_map[ASUSAURACORELAPTOP_KEY_HEIGHT][ASUSAURACORELAPTOP_KEY_WIDTH] =
-{
-    {  NA,  NA,  86,  87,  88,  89,  90,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
-    {   0,  NA,   1,   2,   3,   4,  NA,   5,   6,   7,   8,  NA,   9,  10,  11,  12,  13,  NA },
-    {  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  NA },
-    {  31,  NA,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  NA,  45,  NA },
-    {  46,  NA,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  NA,  58,  NA,  59,  NA },
-    {  60,  NA,  61,  62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  NA,  72,  NA,  73,  NA },
-    {  74,  75,  76,  77,  NA,  NA,  NA,  78,  NA,  NA,  NA,  79,  80,  81,  82,  83,  84,  85 }
-};
-
-static const char *led_names[] =
-{
-    KEY_EN_ESCAPE,              //00
-    KEY_EN_F1,
-    KEY_EN_F2,
-    KEY_EN_F3,
-    KEY_EN_F4,
-    KEY_EN_F5,
-    KEY_EN_F6,
-    KEY_EN_F7,
-    KEY_EN_F8,
-    KEY_EN_F9,
-    KEY_EN_F10,                 //10
-    KEY_EN_F11,
-    KEY_EN_F12,
-    KEY_EN_DELETE,
-
-    KEY_EN_BACK_TICK,
-    KEY_EN_1,
-    KEY_EN_2,
-    KEY_EN_3,
-    KEY_EN_4,
-    KEY_EN_5,
-    KEY_EN_6,                   //20
-    KEY_EN_7,
-    KEY_EN_8,
-    KEY_EN_9,
-    KEY_EN_0,
-    KEY_EN_MINUS,
-    KEY_EN_EQUALS,
-    KEY_EN_BACKSPACE,
-    KEY_EN_BACKSPACE,
-    KEY_EN_BACKSPACE,
-    KEY_EN_MEDIA_PLAY_PAUSE,    //30
-
-    KEY_EN_TAB,
-    KEY_EN_Q,
-    KEY_EN_W,
-    KEY_EN_E,
-    KEY_EN_R,
-    KEY_EN_T,
-    KEY_EN_Y,
-    KEY_EN_U,
-    KEY_EN_I,
-    KEY_EN_O,                   //40
-    KEY_EN_P,
-    KEY_EN_LEFT_BRACKET,
-    KEY_EN_RIGHT_BRACKET,
-    KEY_EN_ANSI_BACK_SLASH,
-    KEY_EN_MEDIA_STOP,
-
-    KEY_EN_CAPS_LOCK,
-    KEY_EN_A,
-    KEY_EN_S,
-    KEY_EN_D,
-    KEY_EN_F,                   //50
-    KEY_EN_G,
-    KEY_EN_H,
-    KEY_EN_J,
-    KEY_EN_K,
-    KEY_EN_L,
-    KEY_EN_SEMICOLON,
-    KEY_EN_QUOTE,
-    KEY_EN_ANSI_ENTER,
-    KEY_EN_MEDIA_PREVIOUS,
-
-    KEY_EN_LEFT_SHIFT,          //60
-    KEY_EN_Z,
-    KEY_EN_X,
-    KEY_EN_C,
-    KEY_EN_V,
-    KEY_EN_B,
-    KEY_EN_N,
-    KEY_EN_M,
-    KEY_EN_COMMA,
-    KEY_EN_PERIOD,
-    KEY_EN_FORWARD_SLASH,       //70
-    KEY_EN_RIGHT_SHIFT,
-    KEY_EN_UP_ARROW,
-    KEY_EN_MEDIA_NEXT,
-
-    KEY_EN_LEFT_CONTROL,
-    KEY_EN_LEFT_FUNCTION,
-    KEY_EN_LEFT_WINDOWS,
-    KEY_EN_LEFT_ALT,
-    KEY_EN_SPACE,
-    KEY_EN_RIGHT_ALT,
-    KEY_EN_RIGHT_CONTROL,       //80
-    KEY_EN_LEFT_ARROW,
-    KEY_EN_DOWN_ARROW,
-    KEY_EN_RIGHT_ARROW,
-    KEY_EN_PRINT_SCREEN,
-    "Asus Keystone",
-
-    KEY_EN_MEDIA_VOLUME_DOWN,
-    KEY_EN_MEDIA_VOLUME_UP,
-    "Key: Mic On/Off",
-    "Key: HyperFan",
-    "Key: Armoury Crate",       //90
-
-    "Lightbar LED 1",
-    "Lightbar LED 2",
-    "Lightbar LED 3",
-    "Lightbar LED 4",
-    "Lightbar LED 5",
-    "Lightbar LED 6",
-
-    "Logo",
-    "Lid Left",
-    "Lid Right",                //99
-};
-
 /**------------------------------------------------------------------*\
     @name AsusAuraCoreLaptop
     @category DEVICE_TYPE_KEYBOARD
@@ -150,18 +27,24 @@ static const char *led_names[] =
         * Awake (Normal Usage)
         * Sleeping
         * Shutdown / Power Off
+
+        MatrixMaps can be found in ArmouryCrate (it needs a chance to download device data)
+        Default path is:
+            C:\ProgramData\ASUS\ROG Live Service\DeviceContent\<Model name>\<Model name>.csv
+        (Model name is the code like G814JV - can be found in the error in logs)
 \*-------------------------------------------------------------------*/
 
 RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController *controller_ptr)
 {
-    controller                  = controller_ptr;
+    controller                              = controller_ptr;
+    const aura_core_laptop_device* aura_dev = controller->GetDeviceData();
 
-    name                        = "Asus Aura Core Laptop";
-    vendor                      = "Asus";
-    type                        = DEVICE_TYPE_KEYBOARD;
-    description                 = controller->GetDeviceName();
-    serial                      = controller->GetSerial();
-    location                    = controller->GetLocation();
+    name                                    = aura_dev->dmi_name;
+    vendor                                  = "Asus";
+    type                                    = DEVICE_TYPE_KEYBOARD;
+    description                             = controller->GetDeviceDescription();
+    serial                                  = controller->GetSerial();
+    location                                = controller->GetLocation();
 
     mode Direct;
     Direct.name                 = "Direct";
@@ -375,8 +258,9 @@ RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreL
     Off.color_mode              = MODE_COLORS_NONE;
     modes.push_back(Off);
 
-    Init_Controller();
     SetupZones();
+
+    SetMode(active_mode);
 }
 
 RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
@@ -384,70 +268,131 @@ RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
     delete controller;
 }
 
-void RGBController_AsusAuraCoreLaptop::Init_Controller()
-{
-    /*-------------------------------------------------*\
-    | Create the keyboard zone and add the matix map    |
-    \*-------------------------------------------------*/
-    zone KB_zone;
-    KB_zone.name                = "Keyboard Zone";
-    KB_zone.type                = ZONE_TYPE_MATRIX;
-    KB_zone.leds_min            = ASUSAURACORELAPTOP_KEYCOUNT;
-    KB_zone.leds_max            = ASUSAURACORELAPTOP_KEYCOUNT;
-    KB_zone.leds_count          = ASUSAURACORELAPTOP_KEYCOUNT;
-
-    KB_zone.matrix_map          = new matrix_map_type;
-    KB_zone.matrix_map->height  = ASUSAURACORELAPTOP_KEY_HEIGHT;
-    KB_zone.matrix_map->width   = ASUSAURACORELAPTOP_KEY_WIDTH;
-    KB_zone.matrix_map->map     = (unsigned int *)&matrix_map;
-    zones.push_back(KB_zone);
-
-    zone lightbar;
-    lightbar.name               = "Lightbar Zone";
-    lightbar.type               = ZONE_TYPE_LINEAR;
-    lightbar.leds_min           = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
-    lightbar.leds_max           = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
-    lightbar.leds_count         = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
-    lightbar.matrix_map         = NULL;
-
-    zones.push_back(lightbar);
-
-    zone lid;
-    lid.name                    = "Lid Zone";
-    lid.type                    = ZONE_TYPE_LINEAR;
-    lid.leds_min                = ASUSAURACORELAPTOP_LIDCOUNT;
-    lid.leds_max                = ASUSAURACORELAPTOP_LIDCOUNT;
-    lid.leds_count              = ASUSAURACORELAPTOP_LIDCOUNT;
-    lid.matrix_map              = NULL;
-
-    zones.push_back(lid);
-}
-
 void RGBController_AsusAuraCoreLaptop::SetupZones()
 {
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
-    leds.clear();
-    colors.clear();
+    std::string physical_size;
+    KEYBOARD_LAYOUT new_layout;
+    unsigned int max_led_value              = 0;
+
+    const aura_core_laptop_device* aura_dev = controller->GetDeviceData();
+    unsigned int layout                     = controller->GetKeyboardLayout();
+
+    switch(layout)
+    {
+        case ASUSAURACORELAPTOP_LAYOUT_ISO:
+            new_layout = KEYBOARD_LAYOUT_ISO_QWERTY;
+            break;
+
+        case ASUSAURACORELAPTOP_LAYOUT_ANSI:
+        default:
+            new_layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
+            break;
+    }
+    LOG_DEBUG("[%s] layout set as %d", description.c_str(), new_layout);
 
     /*---------------------------------------------------------*\
-    | Set up zones                                              |
+    | Fill in zones from the device data                        |
     \*---------------------------------------------------------*/
-    for(std::size_t zone_index = 0; zone_index < zones.size(); zone_index++)
+    for(size_t i = 0; i < AURA_CORE_LAPTOP_ZONES_MAX; i++)
     {
-        int zone_offset = (int)leds.size();
+        LOG_DEBUG("[%s] setting up zone %d", description.c_str(), i);
 
-        for(unsigned int led_index = 0; led_index < zones[zone_index].leds_count; led_index++)
+        if(aura_dev->zones[i] == NULL)
         {
-            led new_led;
-            new_led.value   = led_index + zone_offset;
-            new_led.name    = led_names[new_led.value];
-            leds.push_back(new_led);
+            break;
+        }
+        else
+        {
+            zone new_zone;
+
+            new_zone.name                   = aura_dev->zones[i]->name;
+
+            if(aura_dev->zones[i]->layout_new != NULL)
+            {
+                KeyboardLayoutManager new_kb(new_layout,
+                                             aura_dev->zones[i]->layout_new->base_size,
+                                             aura_dev->zones[i]->layout_new->key_values);
+
+                if(aura_dev->zones[i]->layout_new->base_size != KEYBOARD_SIZE_EMPTY ||
+                   aura_dev->zones[i]->layout_new->edit_keys.size() > 0)
+                {
+                    /*---------------------------------------------------------*\
+                    | Minor adjustments to keyboard layout                      |
+                    \*---------------------------------------------------------*/
+                    keyboard_keymap_overlay_values* temp    = aura_dev->zones[i]->layout_new;
+                    new_kb.ChangeKeys(*temp);
+
+                    if(new_kb.GetRowCount() == 1 || new_kb.GetColumnCount() == 1)
+                    {
+                        if(new_kb.GetKeyCount() == 1)
+                        {
+                            new_zone.type               = ZONE_TYPE_SINGLE;
+                        }
+                        else
+                        {
+                            new_zone.type               = ZONE_TYPE_LINEAR;
+                        }
+                    }
+                    else
+                    {
+                        new_zone.type               = ZONE_TYPE_MATRIX;
+                        matrix_map_type * new_map   = new matrix_map_type;
+                        new_zone.matrix_map         = new_map;
+
+                        /*---------------------------------------------------------*\
+                        | Trusting the layout handed to the KLM is correct use the  |
+                        |   row & column counts to set the matrix height & width    |
+                        \*---------------------------------------------------------*/
+                        new_map->height             = new_kb.GetRowCount();
+                        new_map->width              = new_kb.GetColumnCount();
+                        new_map->map                = new unsigned int[new_map->height * new_map->width];
+
+                        new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT);
+                    }
+
+                    /*---------------------------------------------------------*\
+                    | Create LEDs for the Matrix zone                           |
+                    |   Place keys in the layout to populate the matrix         |
+                    \*---------------------------------------------------------*/
+                    new_zone.leds_count             = new_kb.GetKeyCount();
+                    for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
+                    {
+                        led new_led;
+
+                        new_led.name                = new_kb.GetKeyNameAt(led_idx);
+                        new_led.value               = new_kb.GetKeyValueAt(led_idx);
+                        max_led_value               = std::max(max_led_value, new_led.value);
+                        leds.push_back(new_led);
+                    }
+                }
+
+                /*---------------------------------------------------------*\
+                | Add 1 the max_led_value to account for the 0th index      |
+                \*---------------------------------------------------------*/
+                max_led_value++;
+            }
+
+            LOG_DEBUG("[%s] Creating a %s zone: %s with %d LEDs", name.c_str(),
+                      ((new_zone.type == ZONE_TYPE_MATRIX) ? "matrix": "linear"),
+                      new_zone.name.c_str(), new_zone.leds_count);
+            new_zone.leds_min                   = new_zone.leds_count;
+            new_zone.leds_max                   = new_zone.leds_count;
+            zones.push_back(new_zone);
         }
     }
 
     SetupColors();
+
+    /*---------------------------------------------------------*\
+    | Create a buffer map of pointers which contains the        |
+    |   layout order of colors the device expects.              |
+    \*---------------------------------------------------------*/
+    buffer_map.resize(max_led_value, &null_color);
+
+    for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        buffer_map[leds[led_idx].value] = &colors[led_idx];
+    }
 }
 
 void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/)
@@ -459,36 +404,35 @@ void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/
 
 void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs()
 {
-    controller->SetLedsDirect(colors);
-}
-
-void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int zone)
-{
-    std::vector<RGBColor> colour;
-    for(size_t i = 0; i < zones[zone].leds_count; i++)
+    for(size_t i = 85; i < leds.size(); i++)
     {
-        colour.push_back(zones[zone].colors[i]);
+        LOG_DEBUG("[%s] Setting %s @ LED index %d and buffer index %d to R: %02X G: %02X B: %02X",
+                  name.c_str(),
+                  leds[i].name.c_str(),
+                  i,
+                  leds[i].value,
+                  RGBGetRValue(colors[i]),
+                  RGBGetGValue(colors[i]),
+                  RGBGetBValue(colors[i]));
     }
 
-    controller->SetLedsDirect(colour);
+    controller->SetLedsDirect(buffer_map);
 }
 
-void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int led)
+void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int /*zone*/)
 {
-    std::vector<RGBColor> colour;
-    colour.push_back(colors[led]);
+    controller->SetLedsDirect(buffer_map);
+}
 
-    controller->SetLedsDirect(colour);
+void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int /*led*/)
+{
+    controller->SetLedsDirect(buffer_map);
 }
 
 void RGBController_AsusAuraCoreLaptop::DeviceUpdateMode()
 {
     mode set_mode       = modes[active_mode];
 
-    if(set_mode.value == ASUSAURACORELAPTOP_MODE_DIRECT)
-    {
-        return;
-    }
     uint8_t random      = (set_mode.color_mode == MODE_COLORS_RANDOM) ? 0xFF : 0;
     RGBColor color1     = (set_mode.colors.size() > 0) ? set_mode.colors[0] : 0;
     RGBColor color2     = (set_mode.colors.size() > 1) ? set_mode.colors[1] : 0;

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.h

@@ -11,6 +11,7 @@
 
 #pragma once
 
+#include <algorithm>
 #include <vector>
 #include "RGBController.h"
 #include "AsusAuraCoreLaptopController.h"
@@ -31,7 +32,8 @@ public:
     void                DeviceUpdateMode();
 
 private:
-    void                Init_Controller();
+    RGBColor                            null_color              = 0;
+    std::vector<RGBColor *>             buffer_map;
 
-    AsusAuraCoreLaptopController*      controller;
+    AsusAuraCoreLaptopController*       controller;
 };

Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseDevices.h

@@ -55,6 +55,7 @@
 #define AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID        0x1A68
 #define AURA_ROG_KERIS_WIRELESS_AIMPOINT_BT_PID         0x1A6A
 #define AURA_TUF_M3_PID                                 0x1910
+#define AURA_TUF_M3_GEN_II_PID                          0x1A9B
 #define AURA_TUF_M5_PID                                 0x1898
 
 #define AURA_ROG_SPATHA_X_DOCK_FAKE_PID                 0xFFFF
@@ -636,6 +637,20 @@ static std::map<int,mouse_type> aura_mouse_devices =
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
     },
+    {
+        AURA_TUF_M3_GEN_II_PID, // TUF M3 Gen II
+        {
+            0,
+            0,
+            0,
+            100,
+            false,
+            1,
+            false,
+            { AURA_MOUSE_ZONE_LOGO },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
+        }
+    },
     {
         AURA_TUF_M5_PID, // TUF M5
         {

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.cpp

@@ -14,17 +14,19 @@
 
 AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
 {
-	/*-----------------------------------------------------*\
-	| Add addressable devices                               |
-	|    Manually adding device info for now                |
-	|    TODO: Implement config table accurately            |
-	\*-----------------------------------------------------*/
-	device_info.push_back({0x00, 0x00, 12, 0, AuraDeviceType::FIXED});
+    /*-----------------------------------------------------*\
+    | Add addressable devices                               |
+    |    Manually adding device info for now                |
+    |    TODO: Implement config table accurately            |
+    \*-----------------------------------------------------*/
+    device_info.push_back({0x00, 0x00, 12, 0, AuraDeviceType::FIXED});
 }
 
 AsusAuraRyuoAIOController::~AsusAuraRyuoAIOController()
 {
-	hid_close(dev);
+    /*---------------------------------------------------------*\
+    | HID device is closed in the base class                    |
+    \*---------------------------------------------------------*/
 }
 
 std::string AsusAuraRyuoAIOController::GetLocation()
@@ -34,10 +36,10 @@ std::string AsusAuraRyuoAIOController::GetLocation()
 
 void AsusAuraRyuoAIOController::SetMode(unsigned char /*channel*/, unsigned char /*mode*/, unsigned char /*red*/, unsigned char /*grn*/, unsigned char /*blu*/)
 {
-	/*---------------------------------------------------------*\
-	| This interface is not used in this controller however is  |
-	|   required by the abstract class                          |
-	\*---------------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | This interface is not used in this controller however is  |
+    |   required by the abstract class                          |
+    \*---------------------------------------------------------*/
 }
 
 void AsusAuraRyuoAIOController::SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour)

Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraMainboardController.cpp

@@ -39,6 +39,7 @@ AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const c
     for(int i = 0; i < num_addressable_headers; i++)
     {
         device_info.push_back({effect_channel, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
+        effect_channel++;
     }
 }
 

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -415,6 +415,7 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless Bluetooth",
 REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless AimPoint USB",                DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_AIMPOINT_USB_PID,         0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless AimPoint 2.4Ghz",             DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID,         0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3",                                  DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_TUF_M3_PID,                                  1,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3 Gen II",                           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_TUF_M3_GEN_II_PID,                           2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                                  DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_TUF_M5_PID,                                  2,  0xFF01);
 
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Evolve",                       DetectAsusAuraUSBStrixEvolve,   AURA_USB_VID, AURA_ROG_STRIX_EVOLVE_PID,                    1,  0x0008);

Controllers/AsusTUFLaptopController/AsusTUFLaptopDetect_Windows.cpp

@@ -9,6 +9,7 @@
 
 #include <string>
 #include "Detector.h"
+#include "FanController_AsusTUFLaptop_Windows.h"
 #include "RGBController_AsusTUFLaptop_Windows.h"
 #include "wmi.h"
 
@@ -44,8 +45,10 @@ static void DetectAsusTUFLaptopWMIControllers()
     if(controller)
     {
         RGBController* new_controller = new RGBController_AsusTUFLaptopWMI(controller);
+        FanController* fan_controller = new FanController_AsusTUFLaptopWMI(controller);
 
         ResourceManager::get()->RegisterRGBController(new_controller);
+        ResourceManager::get()->RegisterFanController(fan_controller);
     }
 }   /* DetectAsusTUFLaptopWMIControllers() */
 

Controllers/AsusTUFLaptopController/FanController_AsusTUFLaptop_Windows.cpp

@@ -0,0 +1,44 @@
+#include "FanController_AsusTUFLaptop_Windows.h"
+
+
+FanController_AsusTUFLaptopWMI::FanController_AsusTUFLaptopWMI(AsusTUFLaptopController* dev)
+{
+    controller = dev;
+    name = "ASUS TUF Laptop";
+    description = "WMI Device";
+    location    = "\\\\.\\ATKACPI";
+
+    // Coolers RPM reading & current mode retrieval is still WIP
+    fans.resize(2);
+    fans[0].name = "CPU Cooler";
+    fans[0].speed_min = 0;
+    fans[0].speed_max = 2;
+    fans[0].speed_cmd = 1;
+    fans[0].prev_speed_cmd = 1;
+    fans[0].rpm_rdg = 0; // We don't have it, but we don't want an unitialized value either
+}
+
+void FanController_AsusTUFLaptopWMI::UpdateControl()
+{
+    int mode = fans[0].speed_cmd;
+    switch(mode)
+    {
+    case 0:
+        mode = ASUS_WMI_FAN_SPEED_SILENT;
+        break;
+    case 1:
+        mode = ASUS_WMI_FAN_SPEED_NORMAL;
+        break;
+    case 2:
+        mode = ASUS_WMI_FAN_SPEED_TURBO;
+        break;
+    }
+
+    controller->setFanMode(mode);
+}
+
+void FanController_AsusTUFLaptopWMI::UpdateReading()
+{
+    ;
+}
+

Controllers/AsusTUFLaptopController/FanController_AsusTUFLaptop_Windows.h

@@ -0,0 +1,18 @@
+#ifndef FANCONTROLLER_ASUSTUFLAPTOPWMI_H
+#define FANCONTROLLER_ASUSTUFLAPTOPWMI_H
+
+#include "FanController.h"
+#include "AsusTUFLaptopController_Windows.h"
+
+class FanController_AsusTUFLaptopWMI : public FanController
+{
+private:
+    AsusTUFLaptopController* controller;
+
+public:
+    FanController_AsusTUFLaptopWMI(AsusTUFLaptopController* dev);
+    void UpdateControl() override;
+    void UpdateReading() override;
+};
+
+#endif // FANCONTROLLER_ASUSTUFLAPTOPWMI_H

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -49,26 +49,27 @@ void DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
     }
 }
 
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Advanced OC 12G L-V",  DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ADVANCED_OC_12G_LV, 0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",   DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,      0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",   DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_GA106_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,      0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",   DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,    0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",  DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,    0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,       0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_TI_ADVANCED_OC,     0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,       0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV2,      0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC-V",         DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ULTRAW_OC,          0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC LHR",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ULTRAW_OC,          0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Ultra W OC LHR",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_TI_ULTRAW_OC,       0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_TI_ADVANCED_OCV2,   0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Advanced OC 10G-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_ADVANCED_OC_10G,    0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_TI_ADVANCED_OCV2,   0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ultra W OC 10G LHR-V", DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_ULTRAW_OC_10G,      0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ultra W OC 10G LHR-V", DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,   COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_ULTRAW_OC_10G_2,    0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Ti Advanced OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,     COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_TI_ADVANCED_OCV,    0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Vulcan OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_VULCAN_OCV,         0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",         DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV,         0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",         DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2,        0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV,       0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",        DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV2,      0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Advanced OC 12G L-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ADVANCED_OC_12G_LV,     0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_GA106_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,        0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,        0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,           0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_TI_ADVANCED_OC,         0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,           0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV2,          0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ULTRAW_OC,              0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC LHR",         DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ULTRAW_OC,              0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Ultra W OC LHR",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_TI_ULTRAW_OC,           0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_TI_ADVANCED_OCV2,       0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Advanced OC 10G-V",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_ADVANCED_OC_10G,        0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ti Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_TI_ADVANCED_OCV2,       0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ultra W OC 10G LHR-V",   DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_ULTRAW_OC_10G,          0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ultra W OC 10G LHR-V",   DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3080_ULTRAW_OC_10G_2,        0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Ti Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_TI_ADVANCED_OCV,        0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Ti SUPER Advanced OC-V", DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070TIS_AD102_DEV, COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_TI_SUPER_ADVANCED_OCV2, 0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Vulcan OC-V",            DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_VULCAN_OCV,             0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV,             0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2,            0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV,           0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV2,          0x61);

Controllers/CoolerMasterController/CMKeyboardController/CMKeyboardDevices.cpp

@@ -63,6 +63,25 @@ const std::vector<unsigned int> mk850_keymap =
 	      11,   18,   25,               53,               81,   88,   95,   116,              123,  130,  137,  144,        158,
 };
 
+/*-------------------------------------------------------------*\
+| CoolerMaster SK (60%)                                         |
+\*-------------------------------------------------------------*/
+const std::vector<unsigned int> sk620_keymap =
+{
+/*	T1    T2    T3    T4    T5    T6    T7    T8    T9    T10   T11   T12   T13   T14   T15        */
+/*	L1    ESC   1     2     3     4     5     6     7     8     9     0     -     =     BPSC        R1  */
+	   	  8,    15,   22,   29,   36,   43,   50,   57,   64,   71,   78,   85,   92,   106,
+/*  L2    TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]                 R2  */
+	  	  9,    23,   30,   37,   44,   51,   58,   65,   72,   79,   86,   93,   100,
+/*  L3    CPLK  A     S     D     F     G     H     J     K     L     ;     "     \     ENTR        R3  */
+	  	  10,   24,   31,   38,   45,   52,   59,   66,   73,   80,   87,   94,   101,  108,
+/*  L4    LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     #     RSFT  ARWU   DEL  R$  */
+	      11,   18,   25,   32,   39,   46,   53,   60,   67,   74,   81,   88,   95,   102,   109,
+/*  L5    LCTL  LWIN  LALT              SPACE                         RALT  RWFNC ARWL  ARDN  ARWR  R5  */
+	  	  12,   19,   26,               54,                           82,   89,   96,   103,   110,
+/*  B1    B2    B3    B4    B5    B6    B7    B8    B9    B10   B11   B12   B13   B14   B15    B15      */
+};
+
 /*-------------------------------------------------------------*\
 | CoolerMaster SK (60%)                                         |
 \*-------------------------------------------------------------*/
@@ -209,7 +228,7 @@ const std::vector<unsigned int> ck530_v2_keymap =
 /*  CPLK  A     S     D     F     G     H     J     K     L     ;     "     #     ENTR                    */
     10,   24,   31,   38,   45,   52,   59,   66,   73,   80,   87,   94,  108,   115,
 /*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /           RSFT        ARWU        */
-    11,   18,   25,   32,   39,   46,   53,   60,   67,   74,   88,   81,         116,        130, 
+    11,   18,   25,   32,   39,   46,   53,   60,   67,   74,   88,   81,         116,        130,
 /*  LCTL  LWIN  LALT              SPC                     RALT  RFNC  RMNU  RCTL        ARWL  ARWD  ARWR  */
     12,   19,   26,               54,                     82,   89,   96,   117,        124,  131,  138,
 };
@@ -316,6 +335,64 @@ keyboard_keymap_overlay_values mk850_layout
     },
 };
 
+keyboard_keymap_overlay_values sk620_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_SIXTY,
+    {
+        sk620_keymap,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,      0,          7,         "Light: Top 1",              KEYBOARD_OPCODE_INSERT_ROW, },
+        {   0,      0,      1,         14,         "Light: Top 2",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      2,         21,         "Light: Top 3",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      3,         28,         "Light: Top 4",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      4,         35,         "Light: Top 5",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      5,         42,         "Light: Top 6",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      6,         49,         "Light: Top 7",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      7,         56,         "Light: Top 8",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      8,         63,         "Light: Top 9",              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      9,         70,         "Light: Top 10",             KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      10,        77,         "Light: Top 11",             KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      11,        84,         "Light: Top 12",             KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      12,        91,         "Light: Top 13",             KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      13,        98,         "Light: Top 14",             KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      0,      14,       105,         "Light: Top 14",             KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      1,      0,          0,         "Light: Left 1",             KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      2,      0,          1,         "Light: Left 2",             KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      3,      0,          2,         "Light: Left 3",             KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      4,      0,          3,         "Light: Left 4",             KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      5,      0,          4,         "Light: Left 5",             KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      1,      16,       112,         "Light: Right 1",            KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      2,      16,       113,         "Light: Right 2",            KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      3,      16,       114,         "Light: Right 3",            KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      4,      16,       115,         "Light: Right 4",            KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      5,      16,       116,         "Light: Right 5",            KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       0,         6,         "Light: Bottom 1",           KEYBOARD_OPCODE_INSERT_ROW, },
+        {   0,      6,       1,        20,         "Light: Bottom 2",           KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       2,        27,         "Light: Bottom 3",           KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       3,        34,         "Light: Bottom 4",           KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       4,        41,         "Light: Bottom 5",           KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       5,        48,         "Light: Bottom 6",           KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       6,        55,         "Light: Bottom 7",           KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       7,        62,         "Light: Bottom 8",           KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       8,        69,         "Light: Bottom 9",           KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       9,        76,         "Light: Bottom 10",          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       10,       83,         "Light: Bottom 11",          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       11,       90,         "Light: Bottom 12",          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       12,       97,         "Light: Bottom 13",          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       13,      104,         "Light: Bottom 14",          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       14,      111,         "Light: Bottom 15",          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+        {   0,      6,       14,      118,         "Light: Bottom 16",          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
+    },
+};
+
 keyboard_keymap_overlay_values sk622_layout
 {
     KEYBOARD_SIZE::KEYBOARD_SIZE_SIXTY,
@@ -657,6 +734,24 @@ cm_kb_device mk850_device
     &mk850_layout,
 };
 
+cm_kb_device sk620w_device
+{
+    COOLERMASTER_KEYBOARD_SK620W_PID,
+    {
+        &cm_generic_zone,
+    },
+    &sk620_layout,
+};
+
+cm_kb_device sk620b_device
+{
+    COOLERMASTER_KEYBOARD_SK620B_PID,
+    {
+        &cm_generic_zone,
+    },
+    &sk620_layout,
+};
+
 cm_kb_device sk622w_device
 {
     COOLERMASTER_KEYBOARD_SK622W_PID,
@@ -786,6 +881,8 @@ const cm_kb_device* cm_kb_devices[] =
     &mk_pro_s_device,
     &mk_pro_l_device,
     &mk850_device,
+    &sk620w_device,
+    &sk620b_device,
     &sk622w_device,
     &sk622b_device,
     &sk630_device,

Controllers/CoolerMasterController/CMKeyboardController/CMKeyboardDevices.h

@@ -106,8 +106,8 @@ typedef struct
 #define COOLERMASTER_KEYBOARD_MK750_PID           0x0067 // fw1.2 [libcmmk #25 !9, !14, signal]
 #define COOLERMASTER_KEYBOARD_MK770_PID           0x01D5 // unsupported
 #define COOLERMASTER_KEYBOARD_MK850_PID           0x0069 // [signal]
-#define COOLERMASTER_KEYBOARD_SK620B_PID          0x0157 // unsupported
-#define COOLERMASTER_KEYBOARD_SK620W_PID          0x0159 // [signal]
+#define COOLERMASTER_KEYBOARD_SK620B_PID          0x0157 // [openrgb #4292]
+#define COOLERMASTER_KEYBOARD_SK620W_PID          0x0159 // [openrgb #4292, signal]
 #define COOLERMASTER_KEYBOARD_SK622B_PID          0x0149 // [openrgb #3110, signal #217(closed)]
 #define COOLERMASTER_KEYBOARD_SK622W_PID          0x014B // [signal]
 #define COOLERMASTER_KEYBOARD_SK630_PID           0x0089 // [openrgb #967, libcmmk !21]

Controllers/CoolerMasterController/CMKeyboardController/CMKeyboardV2Controller.cpp

@@ -14,6 +14,7 @@
 #include <string>
 #include "CMKeyboardV2Controller.h"
 #include "LogManager.h"
+#include "StringUtils.h"
 
 CMKeyboardV2Controller::CMKeyboardV2Controller(hid_device* dev_handle, hid_device_info* dev_info) : CMKeyboardAbstractController(dev_handle, dev_info)
 {
@@ -98,7 +99,7 @@ std::string CMKeyboardV2Controller::_GetFirmwareVersion()
     }
 
     std::u16string usFirmwareVersion(reinterpret_cast<const char16_t*>(cVersionStr+8));
-    std::string sFirmwareVersion(usFirmwareVersion.begin(), usFirmwareVersion.end());
+    std::string sFirmwareVersion(StringUtils::u16string_to_string(usFirmwareVersion));
 
     LOG_VERBOSE("[%s] GetFirmwareVersion(): [%s]", m_deviceName.c_str(), sFirmwareVersion.c_str());
 

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -297,6 +297,8 @@ REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro S",         DetectCooler
 REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L",         DetectCoolerMasterV1Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_PRO_L_PID,          1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L White",   DetectCoolerMasterV1Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID,    1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MK850",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_MK850_PID,          1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master SK620 White",              DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK620W_PID,         1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master SK620 Black",              DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK620B_PID,         1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master SK622 White",              DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK622W_PID,         1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master SK622 Black",              DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK622B_PID,         1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master SK630",                    DetectCoolerMasterV2Keyboards,  COOLERMASTER_VID,   COOLERMASTER_KEYBOARD_SK630_PID,          1,      0xFF00, 1);

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -59,6 +59,72 @@ void CorsairLightingNodeController::KeepaliveThread()
     }
 }
 
+unsigned char CorsairLightingNodeController::GetFanPercent(unsigned char fan_channel)
+{
+    int             actual;
+    unsigned char   usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Get Fan RPM packet                             |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_GET_FAN_PERCENT;
+    usb_buf[0x02]   = fan_channel;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    actual = hid_read(dev, usb_buf, 17);
+
+    if(actual > 0)
+    {
+        return(usb_buf[0x01]);
+    }
+    else
+    {
+        return(0);
+    }    
+}
+
+unsigned short CorsairLightingNodeController::GetFanRPM(unsigned char fan_channel)
+{
+    int             actual;
+    unsigned char   usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Get Fan RPM packet                             |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_GET_FAN_RPM;
+    usb_buf[0x02]   = fan_channel;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    actual = hid_read(dev, usb_buf, 17);
+
+    if(actual > 0)
+    {
+        return((usb_buf[0x01] << 8) + (usb_buf[0x02] & 0xFF));
+    }
+    else
+    {
+        return(0);
+    }
+}
+
 std::string CorsairLightingNodeController::GetFirmwareString()
 {
     return(firmware_version);
@@ -203,6 +269,92 @@ void CorsairLightingNodeController::SetChannelLEDs(unsigned char channel, RGBCol
     SendCommit();
 }
 
+void CorsairLightingNodeController::SetFanConfiguration
+    (
+        unsigned char   fan_channel,
+        unsigned char   fan_configuration
+    )
+{
+    unsigned char   usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Fan Configuration packet                       |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_FAN_CONFIG;
+    usb_buf[0x02]   = 0x02;
+    usb_buf[0x03]   = fan_channel;
+    usb_buf[0x04]   = fan_configuration;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
+}
+
+void CorsairLightingNodeController::SetFanPercent
+    (
+        unsigned char   fan_channel,
+        unsigned char   fan_cmd
+    )
+{
+    unsigned char   usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Fan Fixed Percent Command packet               |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_FAN_CMD_PERCENT;
+    usb_buf[0x02]   = fan_channel;
+    usb_buf[0x03]   = fan_cmd;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
+}
+
+void CorsairLightingNodeController::SetFanRPM
+    (
+        unsigned char   fan_channel,
+        unsigned short  fan_cmd
+    )
+{
+    unsigned char   usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Fan Fixed RPM Command packet                   |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_FAN_CMD_RPM;
+    usb_buf[0x02]   = fan_channel;
+    usb_buf[0x03]   = fan_cmd & 0xFF;
+    usb_buf[0x04]   = fan_cmd >> 8;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
+}
+
 /*-------------------------------------------------------------------------------------------------*\
 | Private packet sending functions.                                                                 |
 \*-------------------------------------------------------------------------------------------------*/

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h

@@ -23,6 +23,12 @@
 enum
 {
     CORSAIR_LIGHTING_NODE_PACKET_ID_FIRMWARE         = 0x02,     /* Get firmware version                 */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_GET_FAN_CONFIG   = 0x20,     /* Get fan configuration                */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_GET_FAN_RPM      = 0x21,     /* Get fan RPM                          */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_GET_FAN_PERCENT  = 0x22,     /* Get fan fixed percent command        */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_FAN_CMD_PERCENT  = 0x23,     /* Set fan fixed percent command        */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_FAN_CMD_RPM      = 0x24,     /* Set fan fixed RPM command            */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_FAN_CONFIG       = 0x28,     /* Set fan configuration                */
     CORSAIR_LIGHTING_NODE_PACKET_ID_DIRECT           = 0x32,     /* Direct mode LED update packet        */
     CORSAIR_LIGHTING_NODE_PACKET_ID_COMMIT           = 0x33,     /* Commit changes packet                */
     CORSAIR_LIGHTING_NODE_PACKET_ID_BEGIN            = 0x34,     /* Begin effect packet                  */
@@ -63,6 +69,17 @@ enum
     CORSAIR_LIGHTING_NODE_NUM_CHANNELS               = 0x02,     /* Number of channels                   */
 };
 
+enum
+{
+    CORSAIR_LIGHTING_NODE_FAN_CHANNEL_1              = 0x00,     /* Fan channel 1                        */
+    CORSAIR_LIGHTING_NODE_FAN_CHANNEL_2              = 0x01,     /* Fan channel 2                        */
+    CORSAIR_LIGHTING_NODE_FAN_CHANNEL_3              = 0x02,     /* Fan channel 3                        */
+    CORSAIR_LIGHTING_NODE_FAN_CHANNEL_4              = 0x03,     /* Fan channel 4                        */
+    CORSAIR_LIGHTING_NODE_FAN_CHANNEL_5              = 0x04,     /* Fan channel 5                        */
+    CORSAIR_LIGHTING_NODE_FAN_CHANNEL_6              = 0x05,     /* Fan channel 6                        */
+    CORSAIR_LIGHTING_NODE_NUM_FAN_CHANNELS           = 0x06,     /* Number of fan channels               */
+};
+
 enum
 {
     CORSAIR_LIGHTING_NODE_SPEED_FAST                 = 0x00,     /* Fast speed                           */
@@ -85,12 +102,23 @@ enum
     CORSAIR_LIGHTING_NODE_MODE_RAINBOW               = 0x0A,     /* Rainbow mode                         */
 };
 
+enum
+{
+    CORSAIR_LIGHTING_NODE_FAN_CONFIG_AUTO            = 0x00,     /* Auto/Disconnected                    */
+    CORSAIR_LIGHTING_NODE_FAN_CONFIG_3_PIN           = 0x01,     /* 3-Pin Fan                            */
+    CORSAIR_LIGHTING_NODE_FAN_CONFIG_4_PIN           = 0x02,     /* 4-Pin Fan                            */
+};
+
 class CorsairLightingNodeController
 {
 public:
     CorsairLightingNodeController(hid_device* dev_handle, const char* path);
     ~CorsairLightingNodeController();
 
+    unsigned char   GetFanPercent(unsigned char fan_channel);
+
+    unsigned short  GetFanRPM(unsigned char fan_channel);
+
     std::string     GetFirmwareString();
     std::string     GetLocationString();
     std::string     GetSerialString();
@@ -118,6 +146,24 @@ public:
 
     void            SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors);
 
+    void            SetFanConfiguration
+                        (
+                            unsigned char   fan_channel,
+                            unsigned char   fan_configuration
+                        );
+
+    void            SetFanPercent
+                        (
+                            unsigned char   fan_channel,
+                            unsigned char   fan_cmd
+                        );
+
+    void            SetFanRPM
+                        (
+                            unsigned char   fan_channel,
+                            unsigned short  fan_cmd
+                        );
+
     void            KeepaliveThread();
 
 private:

Controllers/CorsairLightingNodeController/CorsairLightingNodeControllerDetect.cpp

@@ -1,55 +1,64 @@
-/*---------------------------------------------------------*\
-| CorsairLightingNodeControllerDetect.cpp                   |
-|                                                           |
-|   Detector for Corsair Lighting Node devices              |
-|                                                           |
-|   Adam Honse (calcprogrammer1@gmail.com)      12 Jan 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <vector>
-#include <hidapi.h>
-#include "Detector.h"
-#include "CorsairLightingNodeController.h"
-#include "RGBController.h"
-#include "RGBController_CorsairLightingNode.h"
-
-#define CORSAIR_VID                     0x1B1C
-#define CORSAIR_LIGHTING_NODE_CORE_PID  0x0C1A
-#define CORSAIR_LIGHTING_NODE_PRO_PID   0x0C0B
-#define CORSAIR_COMMANDER_PRO_PID       0x0C10
-#define CORSAIR_LS100_PID               0x0C1E
-#define CORSAIR_1000D_OBSIDIAN_PID      0x1D00
-#define CORSAIR_SPEC_OMEGA_RGB_PID      0x1D04
-#define CORSAIR_LT100_PID               0x0C23
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairLightingNodeControllers                                                   *
-*                                                                                          *
-*       Detect devices supported by the Corsair Lighting Node Pro driver                   *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairLightingNodeControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        CorsairLightingNodeController*     controller     = new CorsairLightingNodeController(dev, info->path);
-        RGBController_CorsairLightingNode* rgb_controller = new RGBController_CorsairLightingNode(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}   /* DetectCorsairLightingNodeControllers() */
-
-REGISTER_HID_DETECTOR("Corsair Lighting Node Core", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_CORE_PID); // 1 channel
-REGISTER_HID_DETECTOR("Corsair Lighting Node Pro",  DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_PRO_PID);  // 2 channels
-REGISTER_HID_DETECTOR("Corsair Commander Pro",      DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_COMMANDER_PRO_PID);      // 2 channels
-REGISTER_HID_DETECTOR("Corsair LS100 Lighting Kit", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LS100_PID);              // 1 channel
-REGISTER_HID_DETECTOR("Corsair 1000D Obsidian",     DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_1000D_OBSIDIAN_PID);     // 2 channels
-REGISTER_HID_DETECTOR("Corsair SPEC OMEGA RGB",     DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_SPEC_OMEGA_RGB_PID);     // 2 channels
-REGISTER_HID_DETECTOR("Corsair LT100",              DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LT100_PID);              // 2 channels
+/*---------------------------------------------------------*\
+| CorsairLightingNodeControllerDetect.cpp                   |
+|                                                           |
+|   Detector for Corsair Lighting Node devices              |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      12 Jan 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <vector>
+#include <hidapi.h>
+#include "Detector.h"
+#include "CorsairLightingNodeController.h"
+#include "FanController.h"
+#include "FanController_CorsairCommander.h"
+#include "RGBController.h"
+#include "RGBController_CorsairLightingNode.h"
+
+#define CORSAIR_VID                     0x1B1C
+#define CORSAIR_LIGHTING_NODE_CORE_PID  0x0C1A
+#define CORSAIR_LIGHTING_NODE_PRO_PID   0x0C0B
+#define CORSAIR_COMMANDER_PRO_PID       0x0C10
+#define CORSAIR_LS100_PID               0x0C1E
+#define CORSAIR_1000D_OBSIDIAN_PID      0x1D00
+#define CORSAIR_SPEC_OMEGA_RGB_PID      0x1D04
+#define CORSAIR_LT100_PID               0x0C23
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCorsairLightingNodeControllers                                                   *
+*                                                                                          *
+*       Detect devices supported by the Corsair Lighting Node Pro driver                   *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectCorsairLightingNodeControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        CorsairLightingNodeController*     controller     = new CorsairLightingNodeController(dev, info->path);
+        RGBController_CorsairLightingNode* rgb_controller = new RGBController_CorsairLightingNode(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+
+        if(info->product_id == CORSAIR_COMMANDER_PRO_PID)
+        {
+            FanController_CorsairCommander* fan_controller = new FanController_CorsairCommander(controller);
+            fan_controller->name = name;
+            ResourceManager::get()->RegisterFanController(fan_controller);
+        }
+    }
+}   /* DetectCorsairLightingNodeControllers() */
+
+REGISTER_HID_DETECTOR("Corsair Lighting Node Core", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_CORE_PID); // 1 channel
+REGISTER_HID_DETECTOR("Corsair Lighting Node Pro",  DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_PRO_PID);  // 2 channels
+REGISTER_HID_DETECTOR("Corsair Commander Pro",      DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_COMMANDER_PRO_PID);      // 2 channels
+REGISTER_HID_DETECTOR("Corsair LS100 Lighting Kit", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LS100_PID);              // 1 channel
+REGISTER_HID_DETECTOR("Corsair 1000D Obsidian",     DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_1000D_OBSIDIAN_PID);     // 2 channels
+REGISTER_HID_DETECTOR("Corsair SPEC OMEGA RGB",     DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_SPEC_OMEGA_RGB_PID);     // 2 channels
+REGISTER_HID_DETECTOR("Corsair LT100",              DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LT100_PID);              // 2 channels

Controllers/CorsairLightingNodeController/FanController_CorsairCommander.cpp

@@ -0,0 +1,57 @@
+/*-----------------------------------------*\
+|  FanController_CorsairCommander.cpp       |
+|                                           |
+|  Generic Fan Interface for Corsair        |
+|  Commander controller                     |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/7/2020    |
+\*-----------------------------------------*/
+
+#include "FanController_CorsairCommander.h"
+
+FanController_CorsairCommander::FanController_CorsairCommander(CorsairLightingNodeController* corsair_ptr)
+{
+    corsair = corsair_ptr;
+
+    name        = "Corsair Commander";
+    description = "Corsair Commander Device";
+    version     = corsair->GetFirmwareString();
+
+    for(std::size_t fan_index = 0; fan_index < CORSAIR_LIGHTING_NODE_NUM_FAN_CHANNELS; fan_index++)
+    {
+        fan new_fan;
+
+        new_fan.name        = "Corsair Commander Fan ";
+        new_fan.name.append(std::to_string(fan_index + 1));
+        new_fan.speed_min   = 0;
+        new_fan.speed_max   = 100;
+        new_fan.speed_cmd   = corsair->GetFanPercent(fan_index);
+        new_fan.rpm_rdg     = corsair->GetFanRPM(fan_index);
+
+        fans.push_back(new_fan);
+
+        corsair->SetFanConfiguration(fan_index, CORSAIR_LIGHTING_NODE_FAN_CONFIG_4_PIN);
+    }
+
+    UpdateControl();
+}
+
+void FanController_CorsairCommander::UpdateControl()
+{
+    for(std::size_t fan_index = 0; fan_index < fans.size(); fan_index++)
+    {
+        corsair->SetFanPercent(fan_index, fans[fan_index].speed_cmd);
+    }
+}
+
+void FanController_CorsairCommander::UpdateReading()
+{
+    for(std::size_t fan_index = 0; fan_index < fans.size(); fan_index++)
+    {
+        unsigned short rpm;
+
+        rpm = corsair->GetFanRPM(fan_index);
+
+        fans[fan_index].rpm_rdg = rpm;
+    }
+}

Controllers/CorsairLightingNodeController/FanController_CorsairCommander.h

@@ -0,0 +1,24 @@
+/*-----------------------------------------*\
+|  FanController_CorsairCommander.h         |
+|                                           |
+|  Generic Fan Interface for Corsair        |
+|  Commander controller                     |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/7/2020    |
+\*-----------------------------------------*/
+
+#pragma once
+#include "FanController.h"
+#include "CorsairLightingNodeController.h"
+
+class FanController_CorsairCommander : public FanController
+{
+public:
+    FanController_CorsairCommander(CorsairLightingNodeController* corsair_ptr);
+
+    void        UpdateControl();
+    void        UpdateReading();
+
+private:
+    CorsairLightingNodeController* corsair;
+};

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Controller.cpp

@@ -67,7 +67,7 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
     hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
     uint16_t result = hid_read_timeout(dev, buffer, CORSAIR_V2_PACKET_SIZE, CORSAIR_V2_TIMEOUT);
     result++;
-    pkt_sze = result;
+    pkt_sze = std::max(result, (uint16_t)CORSAIR_V2_WRITE_SIZE);
     LOG_DEBUG("[%s] Packet length set to %d", device_name.c_str(), pkt_sze);
 
     /*---------------------------------------------------------*\
@@ -78,6 +78,8 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
 
     for(uint16_t i = 0; i < CORSAIR_V2_DEVICE_COUNT; i++)
     {
+        LOG_DEBUG("[%s] Checking PID %04X against index %d with %04X - %smatch", device_name.c_str(),
+                  pid, i, corsair_v2_device_list[i]->pid, corsair_v2_device_list[i]->pid == pid ? "" : "no ");
         if(corsair_v2_device_list[i]->pid == pid)
         {
             /*---------------------------------------------------------*\

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2ControllerDetect.cpp

@@ -71,7 +71,9 @@ REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO",                     DetectCorsai
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO",                     DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO Low Profile",         DetectCorsairV2SoftwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_LP_PID,             1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO TKL",                 DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K60_RGB_PRO_TKL_PID,            1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K70 Core RGB",                    DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K70_CORE_RGB_PID,               1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K70 RGB PRO",                     DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K70_RGB_PRO_PID,                1,  0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K70 RGB PRO V2",                  DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K70_RGB_PRO_V2_PID,             1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K70 RGB TKL",                     DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K70_RGB_TKL_PID,                1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K70 RGB TKL Champion Series",     DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K70_RGB_TKL_CS_PID,             1,  0xFF42);
 REGISTER_HID_DETECTOR_IP("Corsair K100 RGB Optical",                DetectCorsairV2HardwareControllers, CORSAIR_VID,    CORSAIR_K100_OPTICAL_V1_PID,            1,  0xFF42);

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.cpp

@@ -99,6 +99,32 @@ keyboard_keymap_overlay_values corsair_k70_layout
     }
 };
 
+keyboard_keymap_overlay_values corsair_k70_pro_layout
+{
+    KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
+    {
+        corsair_full_size_values,
+        {
+            /* Add more regional layout fixes here */
+        }
+    },
+    {
+        /*---------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                 |
+        |   Zone,   Row,    Column,     Value,      Key,                        OpCode,                             |
+        \*---------------------------------------------------------------------------------------------------------*/
+        {   0,      0,       0,         128,        "Profile",                  KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Profile into new row
+        {   0,      0,       1,         113,        "Light",                    KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Light key
+        {   0,      0,       2,         114,        "Lock",                     KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lock Key
+        {   0,      0,      10,         191,        "Logo",                     KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Logo
+        {   0,      0,      18,         102,        KEY_EN_MEDIA_MUTE,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute Key
+        {   0,      1,      17,         123,        KEY_EN_MEDIA_STOP,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Stop Key
+        {   0,      1,      18,         126,        KEY_EN_MEDIA_PREVIOUS,      KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Previous Track Key
+        {   0,      1,      19,         124,        KEY_EN_MEDIA_PLAY_PAUSE,    KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play Pause Key
+        {   0,      1,      20,         125,        KEY_EN_MEDIA_NEXT,          KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Next Tack Key
+    }
+};
+
 keyboard_keymap_overlay_values corsair_K70_TKL_cs_layout
 {
     KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
@@ -764,6 +790,38 @@ static const corsair_v2_device k60_rgb_pro_tkl_device =
     &corsair_K60_tkl_layout
 };
 
+/*-------------------------------------------------------------*\
+|  Corsair K70 Core RGB 1B1C:1BFD                               |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       6 Rows, 21 Columns                                      |
+\*-------------------------------------------------------------*/
+static const corsair_v2_zone k70_core_rgb_zone =
+{
+    ZONE_EN_KEYBOARD,
+    ZONE_TYPE_MATRIX,
+    6,
+    21
+};
+
+static const corsair_v2_device k70_core_rgb_device =
+{
+    CORSAIR_K70_CORE_RGB_PID,
+    DEVICE_TYPE_KEYBOARD,
+    6,
+    21,
+    {
+        &k70_core_rgb_zone,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr,
+        nullptr
+    },
+    &corsair_k70_layout
+};
+
 /*-------------------------------------------------------------*\
 |  Corsair K70 RGB TKL 1B1C:1B73                                |
 |                                                               |
@@ -839,7 +897,7 @@ static const corsair_v2_zone k70_rgb_pro_zone =
 {
     ZONE_EN_KEYBOARD,
     ZONE_TYPE_MATRIX,
-    6,
+    7,
     21
 };
 
@@ -847,7 +905,7 @@ static const corsair_v2_device k70_rgb_pro_device =
 {
     CORSAIR_K70_RGB_PRO_PID,
     DEVICE_TYPE_KEYBOARD,
-    6,
+    7,
     21,
     {
         &k70_rgb_pro_zone,
@@ -857,7 +915,31 @@ static const corsair_v2_device k70_rgb_pro_device =
         nullptr,
         nullptr
     },
-    &corsair_k70_layout
+    &corsair_k70_pro_layout
+};
+
+/*-------------------------------------------------------------*\
+|  Corsair K70 RGB Pro V2 1B1C:1BB3                             |
+|                                                               |
+|  Zone "Keyboard"                                              |
+|       Matrix                                                  |
+|       6 Rows, 21 Columns                                      |
+\*-------------------------------------------------------------*/
+static const corsair_v2_device k70_rgb_pro_v2_device =
+    {
+        CORSAIR_K70_RGB_PRO_V2_PID,
+        DEVICE_TYPE_KEYBOARD,
+        7,
+        21,
+        {
+            &k70_rgb_pro_zone,
+            nullptr,
+            nullptr,
+            nullptr,
+            nullptr,
+            nullptr
+        },
+        &corsair_k70_pro_layout
 };
 
 /*-------------------------------------------------------------*\
@@ -1153,7 +1235,9 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
     &k60_rgb_pro_device,
     &k60_rgb_pro_lp_device,
     &k60_rgb_pro_tkl_device,
+    &k70_core_rgb_device,
     &k70_rgb_pro_device,
+    &k70_rgb_pro_v2_device,
     &k70_rgb_tkl_device,
     &k70_rgb_tkl_cs_device,
     &k100_mx_red_device,

Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.h

@@ -72,7 +72,9 @@ typedef struct
 #define CORSAIR_K60_RGB_PRO_PID                     0x1BA0
 #define CORSAIR_K60_RGB_PRO_LP_PID                  0x1BAD
 #define CORSAIR_K60_RGB_PRO_TKL_PID                 0x1BC7
+#define CORSAIR_K70_CORE_RGB_PID                    0x1BFD
 #define CORSAIR_K70_RGB_PRO_PID                     0x1BC4
+#define CORSAIR_K70_RGB_PRO_V2_PID                  0x1BB3
 #define CORSAIR_K70_RGB_TKL_PID                     0x1B73
 #define CORSAIR_K70_RGB_TKL_CS_PID                  0x1BB9
 #define CORSAIR_K100_OPTICAL_V1_PID                 0x1B7C

Controllers/DreamCheekyController/DreamCheekyController.cpp

@@ -0,0 +1,83 @@
+/*---------------------------------------------------------*\
+| DreamCheekyController.cpp                                 |
+|                                                           |
+|   Driver for Dream Cheeky devices                         |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      06 Sep 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <cstring>
+#include "DreamCheekyController.h"
+#include "StringUtils.h"
+
+DreamCheekyController::DreamCheekyController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+
+    /*-----------------------------------------------------*\
+    | The Dream Cheeky Webmail Notifier requires four       |
+    | initialization packets before sending colors.         |
+    \*-----------------------------------------------------*/
+    const unsigned char init_0[9] = { 0x00, 0x1F, 0x02, 0x00, 0x5F, 0x00, 0x00, 0x1F, 0x03 };
+    const unsigned char init_1[9] = { 0x00, 0x00, 0x02, 0x00, 0x5F, 0x00, 0x00, 0x1F, 0x04 };
+    const unsigned char init_2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x05 };
+    const unsigned char init_3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 };
+
+    hid_write(dev, init_0, sizeof(init_0));
+    hid_write(dev, init_1, sizeof(init_1));
+    hid_write(dev, init_2, sizeof(init_2));
+    hid_write(dev, init_3, sizeof(init_3));
+}
+
+DreamCheekyController::~DreamCheekyController()
+{
+    hid_close(dev);
+}
+
+std::string DreamCheekyController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string DreamCheekyController::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 DreamCheekyController::SetColor(unsigned char red, unsigned char grn, unsigned char blu)
+{
+    unsigned char usb_buf[9];
+
+    memset(usb_buf, 0, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | The Dream Cheeky Webmail Notifier color values range  |
+    | from 0-64, so we scale the 0-255 input range down by  |
+    | right shifting by 2 to get the range 0-63. Add 1 if   |
+    | the value is exactly 255 because otherwise the maximum|
+    | value of 64 would never be reached.                   |
+    \*-----------------------------------------------------*/
+    usb_buf[0] = 0x00;
+    usb_buf[1] = (red >> 2) + (red == 255);
+    usb_buf[2] = (grn >> 2) + (grn == 255);
+    usb_buf[3] = (blu >> 2) + (blu == 255);
+    usb_buf[4] = 0x00;
+    usb_buf[5] = 0x00;
+    usb_buf[6] = 0x00;
+    usb_buf[7] = 0x1F;
+    usb_buf[8] = 0x05;
+
+    hid_write(dev, usb_buf, sizeof(usb_buf));
+}

Controllers/DreamCheekyController/DreamCheekyController.h

@@ -1,9 +1,9 @@
 /*---------------------------------------------------------*\
-| RaspberryPiController_Linux.h                             |
+| DreamCheekyController.h                                   |
 |                                                           |
-|   Driver for Raspberry Pi GPIO ARGB                       |
+|   Driver for Dream Cheeky devices                         |
 |                                                           |
-|   Adam Honse (CalcProgrammer1)                21 Jul 2024 |
+|   Adam Honse (calcprogrammer1@gmail.com)      06 Sep 2024 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-only                   |
@@ -12,24 +12,20 @@
 #pragma once
 
 #include <string>
-#include "RGBController.h"
-#include "ws2811.h"
+#include <hidapi.h>
 
-#define RPI_WS2811_DMA  10
-#define RPI_WS2811_GPIO 18
-
-class RaspberryPiController
+class DreamCheekyController
 {
 public:
-    RaspberryPiController();
-    ~RaspberryPiController();
+    DreamCheekyController(hid_device* dev_handle, const char* path);
+    ~DreamCheekyController();
 
     std::string GetDeviceLocation();
+    std::string GetSerialString();
 
-    bool Initialize();
-    void SetColors(RGBColor * colors);
-    void SetSize(unsigned int new_size);
+    void SetColor(unsigned char red, unsigned char grn, unsigned char blu);
 
 private:
-    ws2811_t        rpi_ws2811;
+    hid_device* dev;
+    std::string location;
 };

Controllers/DreamCheekyController/DreamCheekyControllerDetect.cpp

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------*\
+| DreamCheekyControllerDetect.cpp                           |
+|                                                           |
+|   Detector for Dream Cheeky devices                       |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      06 Sep 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include "Detector.h"
+#include "DreamCheekyController.h"
+#include "RGBController_DreamCheeky.h"
+
+/*---------------------------------------------------------*\
+| Dream Cheeky USB Vendor ID                                |
+\*---------------------------------------------------------*/
+#define DREAM_CHEEKY_VID                            0x1D34
+
+/*---------------------------------------------------------*\
+| Dream Cheeky USB Product ID                               |
+\*---------------------------------------------------------*/
+#define DREAM_CHEEKY_WEBMAIL_NOTIFIER_PID           0x0004
+
+void DetectDreamCheekyControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        DreamCheekyController*     controller     = new DreamCheekyController(dev, info->path);
+        RGBController_DreamCheeky* rgb_controller = new RGBController_DreamCheeky(controller);
+        rgb_controller->name                      = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR( "Dream Cheeky Webmail Notifier", DetectDreamCheekyControllers, DREAM_CHEEKY_VID, DREAM_CHEEKY_WEBMAIL_NOTIFIER_PID );

Controllers/DreamCheekyController/RGBController_DreamCheeky.cpp

@@ -0,0 +1,94 @@
+/*---------------------------------------------------------*\
+| RGBController_DreamCheeky.cpp                             |
+|                                                           |
+|   RGBController for Dream Cheeky devices                  |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      06 Sep 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include "RGBController_DreamCheeky.h"
+
+RGBController_DreamCheeky::RGBController_DreamCheeky(DreamCheekyController* controller_ptr)
+{
+    controller          = controller_ptr;
+
+    name                = "Dream Cheeky Device";
+    type                = DEVICE_TYPE_ACCESSORY;
+    vendor              = "Dream Cheeky";
+    description         = "Dream Cheeky Device";
+    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();
+}
+
+RGBController_DreamCheeky::~RGBController_DreamCheeky()
+{
+
+}
+
+void RGBController_DreamCheeky::SetupZones()
+{
+    zone mail_zone;
+    mail_zone.name          = "LED";
+    mail_zone.type          = ZONE_TYPE_SINGLE;
+    mail_zone.leds_min      = 1;
+    mail_zone.leds_max      = 1;
+    mail_zone.leds_count    = 1;
+    mail_zone.matrix_map    = NULL;
+    zones.push_back(mail_zone);
+
+    led mail_led;
+    mail_led.name           = "LED";
+    leds.push_back(mail_led);
+
+    SetupColors();
+}
+
+void RGBController_DreamCheeky::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*-----------------------------------------------------*\
+    | This device does not support resizing zones           |
+    \*-----------------------------------------------------*/
+}
+
+void RGBController_DreamCheeky::DeviceUpdateLEDs()
+{
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+
+    controller->SetColor(red, grn, blu);
+}
+
+void RGBController_DreamCheeky::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_DreamCheeky::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_DreamCheeky::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_DreamCheeky::DeviceSaveMode()
+{
+    /*-----------------------------------------------------*\
+    | This device does not support saving                   |
+    \*-----------------------------------------------------*/
+}

Controllers/DreamCheekyController/RGBController_DreamCheeky.h

@@ -1,9 +1,9 @@
 /*---------------------------------------------------------*\
-| RGBController_RaspberryPi_Linux.h                         |
+| RGBController_DreamCheeky.h                               |
 |                                                           |
-|   RGBController for Raspberry Pi GPIO ARGB                |
+|   RGBController for Dream Cheeky devices                  |
 |                                                           |
-|   Adam Honse (CalcProgrammer1)                21 Jul 2024 |
+|   Adam Honse (calcprogrammer1@gmail.com)      06 Sep 2024 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-only                   |
@@ -11,15 +11,17 @@
 
 #pragma once
 
-#include "RaspberryPiController_Linux.h"
+#include "DreamCheekyController.h"
 #include "RGBController.h"
 
-class RGBController_RaspberryPi : public RGBController
+class RGBController_DreamCheeky : public RGBController
 {
 public:
-    RGBController_RaspberryPi(RaspberryPiController* controller_ptr);
+    RGBController_DreamCheeky(DreamCheekyController* controller_ptr);
+    ~RGBController_DreamCheeky();
 
     void        SetupZones();
+
     void        ResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
@@ -27,7 +29,8 @@ public:
     void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
-    RaspberryPiController*      controller;
+    DreamCheekyController* controller;
 };

Controllers/EKController/EKController.cpp

@@ -10,7 +10,7 @@
 \*---------------------------------------------------------*/
 
 #include "EKController.h"
-#include "StringUtils.cpp"
+#include "StringUtils.h"
 
 static unsigned char ek_colour_mode_data[][16] =
 {

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -426,6 +426,7 @@ REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4070 Ti O12G Gaming White",
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4070 Ti SUPER 16G Gaming",              DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4070TIS_DEV,      ASUS_SUB_VEN,   ASUS_TUF_RTX_4070TI_SUPER_16G_GAMING,           0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4070 Ti SUPER O16G Gaming",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4070TIS_DEV,      ASUS_SUB_VEN,   ASUS_TUF_RTX_4070TI_SUPER_O16G_GAMING,          0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 4070 Ti SUPER O16G Gaming White",       DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4070TIS_DEV,      ASUS_SUB_VEN,   ASUS_TUF_RTX_4070TI_SUPER_O16G_GAMING_WHITE,    0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 4070 Ti 12G Gaming",              DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4070TI_12G_GAMING,           0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 4070 Ti O12G Gaming",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4070TI_O12G_GAMING,          0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 4070 Ti O12G Gaming",             DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4070TI_O12G_GAMING_2,        0x67);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 4070 Ti SUPER 16G Gaming",        DetectENESMBusGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX4070TIS_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_4070TI_SUPER_16G_GAMING,     0x67);

Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp

@@ -25,9 +25,11 @@
 #define EVISION_KEYBOARD3_VID       0x3299
 #define EVISION_KEYBOARD_USAGE_PAGE 0xFF1C
 #define ENDORFY_OMNIS_PID           0x0012
+#define DEXP_BLAZE_PID              0x5084
 #define GLORIOUS_GMMK_TKL_PID       0x5064
 #define REDRAGON_K550_PID           0x5204
 #define MARS_GAMING_MKMINI_PID      0x5078
+#define SKILLKORP_K5_PID            0x505B
 #define REDRAGON_K552_PID           0x5104
 #define REDRAGON_K552_V2_PID        0x5000
 #define REDRAGON_K556_PID           0x5004
@@ -122,5 +124,7 @@ REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:8520", DetectEVisionKeyboards,
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:502A", DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, WOMIER_K87_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:7698", DetectEVisionKeyboards,   EVISION_KEYBOARD_VID,  WOMIER_K66_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5064", DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, GLORIOUS_GMMK_TKL_PID,     1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5084", DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, DEXP_BLAZE_PID,            1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:505B", DetectEVisionKeyboards,   EVISION_KEYBOARD2_VID, SKILLKORP_K5_PID,          1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("Endorfy Omnis",              DetectEndorfyKeyboards,   EVISION_KEYBOARD3_VID, ENDORFY_OMNIS_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("CSB/ICL01 Keyboard",         DetectEVisionV2Keyboards, EVISION_KEYBOARD2_VID, BYGG_CSB_ICL01_PID,        1, EVISION_KEYBOARD_USAGE_PAGE);

Controllers/FanBusController/FanBusController.cpp

@@ -34,6 +34,31 @@ std::string FanBusController::GetLocation()
     return(location_string);
 }
 
+unsigned char FanBusController::GetFanPWM()
+{
+    unsigned char fan_pwm;
+
+    fan_pwm = bus->read(dev, 0x01);
+
+    return(fan_pwm);
+}
+
+unsigned short FanBusController::GetFanRPM()
+{
+    unsigned char fan_rpm_low;
+    unsigned char fan_rpm_high;
+
+    fan_rpm_low = bus->read(dev, 0x02);
+    fan_rpm_high = bus->read(dev, 0x03);
+
+    return((fan_rpm_high << 8) | fan_rpm_low);
+}
+
+void FanBusController::SetFanPWM(unsigned char fan_pwm)
+{
+    bus->write(dev, 0x01, fan_pwm);
+}
+
 void FanBusController::SetLEDs(std::vector<RGBColor> colors)
 {
     for(unsigned int led_idx = 0; led_idx < 4; led_idx++)

Controllers/FanBusController/FanBusController.h

@@ -21,9 +21,12 @@ public:
     FanBusController(FanBusInterface* bus_ptr, unsigned char dev_addr);
     ~FanBusController();
 
-    std::string GetLocation();
+    std::string     GetLocation();
 
-    void        SetLEDs(std::vector<RGBColor> colors);
+    unsigned char   GetFanPWM();
+    unsigned short  GetFanRPM();
+    void            SetFanPWM(unsigned char fan_pwm);
+    void            SetLEDs(std::vector<RGBColor> colors);
 
 private:
     std::string         port_name;

Controllers/FanBusController/FanBusControllerDetect.cpp

@@ -11,6 +11,7 @@
 
 #include "Detector.h"
 #include "FanBusController.h"
+#include "FanController_FanBus.h"
 #include "RGBController_FanBus.h"
 #include "SettingsManager.h"
 
@@ -45,6 +46,10 @@ void DetectFanBusControllers()
                     RGBController_FanBus* rgb_controller = new RGBController_FanBus(controller);
 
                     ResourceManager::get()->RegisterRGBController(rgb_controller);
+
+                    FanController_FanBus* fan_controller = new FanController_FanBus(controller);
+
+                    ResourceManager::get()->RegisterFanController(fan_controller);
                 }
             }
         }

Controllers/FanBusController/FanController_FanBus.cpp

@@ -0,0 +1,43 @@
+/*-----------------------------------------*\
+|  FanController_FanBus.cpp                 |
+|                                           |
+|  Generic Fan Interface for FanBus         |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 3/1/2020    |
+\*-----------------------------------------*/
+
+#include "FanController_FanBus.h"
+
+FanController_FanBus::FanController_FanBus(FanBusController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "FanBus Device";
+    description = "FanBus Device";
+    location    = controller->GetLocation();
+
+    fan new_fan;
+
+    new_fan.name        = "FanBus Fan";
+    new_fan.speed_min   = 0;
+    new_fan.speed_max   = 255;
+    new_fan.speed_cmd   = controller->GetFanPWM();
+    new_fan.rpm_rdg     = controller->GetFanRPM();
+
+    fans.push_back(new_fan);
+}
+
+void FanController_FanBus::UpdateControl()
+{
+    controller->SetFanPWM(fans[0].speed_cmd);
+}
+
+void FanController_FanBus::UpdateReading()
+{
+    unsigned short rpm;
+
+    rpm = controller->GetFanRPM();
+
+    fans[0].rpm_rdg = rpm;
+}

Controllers/FanBusController/FanController_FanBus.h

@@ -0,0 +1,24 @@
+/*-----------------------------------------*\
+|  FanController_FanBus.h                   |
+|                                           |
+|  Generic Fan Interface for FanBus         |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 3/1/2020    |
+\*-----------------------------------------*/
+
+#pragma once
+#include "FanController.h"
+#include "FanBusController.h"
+
+class FanController_FanBus : public FanController
+{
+public:
+    FanController_FanBus(FanBusController* controller_ptr);
+
+    void        UpdateControl();
+    void        UpdateReading();
+
+private:
+    FanBusController* controller;
+};

Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp

@@ -102,18 +102,24 @@ void DetectGigabyteRGBFusion2GPUControllers(i2c_smbus_interface* bus, uint8_t i2
     }
 }   /* DetectGigabyteRGBFusion2GPUControllers() */
 
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2060 SUPER 8G V1",                     DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2060S_V1_SUB_DEV,             0x50);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2070 XTREME 8G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2070_XTREME_SUB_DEV,          0x50);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2070 XTREME 8G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2070_XTREME_SUB_DEV2,         0x50);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2070 SUPER 8G",                        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_SUB_DEV2,           0x50);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2070 SUPER 8G",                        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2070S_8G_SUB_DEV,             0x50);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 8G",                              DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_A_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080_SUB_DEV,                 0x50);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 XTREME 8G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_A_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080_XTREME_SUB_DEV,          0x50);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 SUPER 8G",                        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_SUB_DEV,                0x50);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 SUPER 8G Rev 1.0",                DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_SUB_DEV_V1,             0x50);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 SUPER Waterforce WB 8G",          DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_WATERFORCE_WB_SUB_DEV,  0x51);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 SUPER Waterforce WB 8G",          DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_WATERFORCE_WB_SUB_DEV2, 0x08);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 Ti XTREME 11G",                   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080TI_EXTREME_SUB_DEV,       0x50);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2060 SUPER 8G V1",                     DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2060S_V1_SUB_DEV_H,           0x50);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2060 SUPER 8G V1",                     DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2060S_V1_SUB_DEV_P,           0x50);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2070 XTREME 8G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2070_XTREME_SUB_DEV_H,        0x50);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2070 XTREME 8G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2070_XTREME_SUB_DEV_P,        0x50);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2070 SUPER 8G",                        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2070S_8G_SUB_DEV_H,           0x50);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2070 SUPER 8G",                        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2070S_8G_SUB_DEV_P,           0x50);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 8G",                              DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_A_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080_SUB_DEV_H,               0x50);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 8G",                              DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_A_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080_SUB_DEV_P,               0x50);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 XTREME 8G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_A_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080_XTREME_SUB_DEV_H,        0x50);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 XTREME 8G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_A_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080_XTREME_SUB_DEV_P,        0x50);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 SUPER 8G",                        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_SUB_DEV_H,              0x50);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 SUPER 8G",                        DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_SUB_DEV_P,              0x50);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 SUPER Waterforce WB 8G",          DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_WATERFORCE_WB_SUB_DEV_H,0x51);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 SUPER Waterforce WB 8G",          DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_WATERFORCE_WB_SUB_DEV_P,0x51);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 SUPER Waterforce 8G",             DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_WATERFORCE_SUB_DEV_H,   0x08);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 SUPER Waterforce 8G",             DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080S_WATERFORCE_SUB_DEV_P,   0x08);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 Ti XTREME 11G",                   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080TI_EXTREME_SUB_DEV_H,     0x50);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 2080 Ti XTREME 11G",                   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX2080TI_EXTREME_SUB_DEV_P,     0x50);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 3060 ELITE 12G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3060_GA104_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_ELITE_12GB_SUB_DEV,            0x70);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 3060 ELITE 12G Rev a1",                DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3060_GA106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_ELITE_12GB_SUB_DEV,            0x70);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 3060 ELITE 12G LHR",                   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_ELITE_12GB_SUB_DEV,            0x70);
@@ -140,13 +146,16 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4070 Gaming OC 12G",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4070 Gaming OC 12G",                         DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070_GAMING_OC_12G_V2,              0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4070 SUPER Gaming OC 12G",                   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_GAMING_OC_12G,                0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4070 SUPER Aero OC 12G",                     DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_AERO_OC_12G,                  0x71);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4070 Super Eagle OC Ice 12G",                DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070S_EAGLE_OC_ICE_12G,             0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4070 Ti Gaming 12G",                         DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070TI_GAMING_12G,                  0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4070 Ti Gaming OC 12G",                      DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070TI_GAMING_OC_12G,               0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4070 Ti Gaming OC 12G",                      DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070TI_GAMING_OC_12G_SUB_DEV2,      0x71);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4070 Ti Eagle OC 12G",                       DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070TI_EAGLE_OC_SUB_DEV,            0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4070 Ti Super Gaming OC 16G",                DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TIS_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_RTX4070TIS_GAMING_OC_16G_SUB_DEV,      0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4080 AERO OC 16G",                           DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4080_AERO_OC_SUB_DEV,               0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4080 Eagle OC 16G",                          DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4080_EAGLE_OC_SUB_DEV,              0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4080 SUPER Gaming OC 16G",                   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4080S_GAMING_OC_16GB_SUB_DEV,       0x72);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4080 SUPER AERO OC 16G",                     DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4080S_AERO_OC_16GB_SUB_DEV,         0x72);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4080 Gaming OC 16G",                         DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4080_GAMING_OC_SUB_DEV,             0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 4080 MASTER 16G",                      DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX4080_MASTER_16G_SUB_DEV,      0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4090 AERO OC 24G",                           DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4090_AERO_OC_24G_SUB_DEV,           0x71);

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUControllerDetect.cpp

@@ -114,24 +114,30 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1050 Ti G1 Gaming (rev A1)",         Det
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1050 Ti G1 Gaming",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1050TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1050TI_G1_GAMING_SUB_DEV,           0x48);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1060 G1 Gaming 6G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_G1_GAMING_SUB_DEV,             0x48);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1060 G1 Gaming 6G OC",               DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_G1_GAMING_OC_SUB_DEV,          0x47);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1060 Xtreme Gaming V1",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_XTREME_V1_SUB_DEV,             0x47);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1060 Xtreme Gaming v2",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_XTREME_V2_SUB_DEV,             0x47);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1070 Xtreme Gaming",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1070_XTREME_SUB_DEV,                0x47);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1060 Xtreme Gaming V1",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_XTREME_V1_SUB_DEV_D,           0x47);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1060 Xtreme Gaming V1",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_XTREME_V1_SUB_DEV_H,           0x47);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1060 Xtreme Gaming V2",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_XTREME_V2_SUB_DEV_D,           0x47);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1060 Xtreme Gaming V2",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_XTREME_V2_SUB_DEV_H,           0x47);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1070 Xtreme Gaming",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1070_XTREME_SUB_DEV_D,              0x47);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1070 Xtreme Gaming",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1070_XTREME_SUB_DEV_H,              0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1070 G1 Gaming 8G V1",               DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1070_G1_GAMING_8G_SUB_DEV,          0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1070 Ti 8G Gaming",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1070TI_GAMING_SUB_DEV,              0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1080 G1 Gaming",                     DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080_G1_GAMING_SUB_DEV,             0x48);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1080 Ti 11G",                        DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080TI_SUB_DEV,                     0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1080 Ti Gaming OC 11G",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080TI_GAMING_OC_SUB_DEV,           0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1080 Ti Gaming OC BLACK 11G",        DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080TI_GAMING_OC_BLACK_SUB_DEV,     0x47);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1080 Ti Xtreme Edition",             DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080TI_XTREME_SUB_DEV,              0x47);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1080 Ti Xtreme Waterforce Edition",  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080TI_XTREME_WATERFORCE_SUB_DEV,   0x47);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1080 Ti Xtreme Edition",             DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080TI_XTREME_SUB_DEV_D,            0x47);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1080 Ti Xtreme Edition",             DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080TI_XTREME_SUB_DEV_H,            0x47);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1080 Ti Xtreme Waterforce Edition",  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080TI_XTREME_WATERFORCE_SUB_DEV_D, 0x47);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1080 Ti Xtreme Waterforce Edition",  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080TI_XTREME_WATERFORCE_SUB_DEV_H, 0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1650 Gaming OC",                     DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1650_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1650_GAMING_OC_SUB_DEV,             0x55);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1660 Gaming OC 6G",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1660_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1660_GAMING_OC_6G_SUB_DEV,          0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1660 SUPER Gaming OC",               DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1660S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_GTX1660S_GAMING_OC_SUB_DEV,            0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte GTX 1660 Ti Gaming OC",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_GTX1660TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1660TI_GAMING_OC_SUB_DEV,           0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 2060 Gaming OC",                     DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_SUB_DEV,             0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 2060 Gaming OC PRO",                 DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_PRO_SUB_DEV,         0x47);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 2060 Gaming OC PRO V2",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_PRO_SUB_DEV2,        0x47);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 2060 Gaming OC PRO V2",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2060_TU104_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_PRO_SUB_DEV2,        0x47);
+REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 2060 Gaming OC PRO V3",              DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_PRO_SUB_DEV2,        0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 2060 Gaming OC PRO White",           DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_PRO_WHITE_SUB_DEV,   0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 2060 SUPER Gaming",                  DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_SUB_DEV,               0x47);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 2060 SUPER Gaming OC",               DetectGigabyteRGBFusionGPUControllers,  NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_OC_SUB_DEV,            0x47);

Controllers/HyperXMicrophoneController/RGBController_HyperXMicrophone.cpp

@@ -99,7 +99,7 @@ void RGBController_HyperXMicrophone::SetupZones()
 
     zone Mic;
     Mic.name       = "Microphone";
-    Mic.type       = ZONE_TYPE_LINEAR;
+    Mic.type       = ZONE_TYPE_SINGLE;
     Mic.leds_min   = 2;
     Mic.leds_max   = 2;
     Mic.leds_count = 2;

Controllers/InstantMouseController/InstantMouseController.cpp

@@ -17,6 +17,7 @@ InstantMouseController::InstantMouseController(hid_device* dev_handle, const hid
 {
     dev                 = dev_handle;
     location            = info.path;
+    pid                 = info.product_id;
     version             = "";
 }
 
@@ -43,6 +44,11 @@ std::string InstantMouseController::GetSerialString()
     return(StringUtils::wstring_to_string(serial_string));
 }
 
+uint16_t InstantMouseController::GetPID()
+{
+    return pid;
+}
+
 std::string InstantMouseController::GetFirmwareVersion()
 {
     return(version);
@@ -78,7 +84,7 @@ void InstantMouseController::SetMode(uint8_t mode_value, uint8_t speed, uint8_t
 {
     /*---------------------------------------------------------*\
     | Packet details:                                           |
-    | 07 13 FF MS DN -B -- --                                   |
+    | 07 13 FF MS DN -B M- --                                   |
     |                                                           |
     | 07 = report id                                            |
     | 13 = set mode function                                    |
@@ -103,7 +109,7 @@ void InstantMouseController::SetMode(uint8_t mode_value, uint8_t speed, uint8_t
     pkt[4] = (direction << 4) | led_mask;
     pkt[5] = 0xF - (brightness & 0xF);
 
-    pkt[6] = 0x00;
+    pkt[6] = mode_value & 0xF0;
     pkt[7] = 0x00;
 
     hid_send_feature_report(dev, pkt, INSTANT_MOUSE_REPORT_SIZE);

Controllers/InstantMouseController/InstantMouseController.h

@@ -29,7 +29,13 @@ enum
     INSTANT_MOUSE_LOOP_MODE                     = 0x04,
     INSTANT_MOUSE_SPECTRUM_CYCLE_MODE           = 0x06,
     INSTANT_MOUSE_RAINBOW_WAVE_MODE             = 0x07,
-    INSTANT_MOUSE_BREATHING_MODE                = 0x08
+    INSTANT_MOUSE_BREATHING_MODE                = 0x08,
+    ANT_MOUSE_BREATHING_MODE                    = 0x09,
+    INSTANT_MOUSE_ENRAPTURED_MODE               = 0xBB,
+    INSTANT_MOUSE_FLICKER_MODE                  = 0xB8,
+    INSTANT_MOUSE_RIPPLE_MODE                   = 0xBA,
+    INSTANT_MOUSE_STARTRECK_MODE                = 0xB9,
+
 };
 
 enum
@@ -48,6 +54,7 @@ public:
 
     std::string GetSerialString();
     std::string GetDeviceLocation();
+    uint16_t GetPID();
     std::string GetFirmwareVersion();
 
     void SetMode(uint8_t mode_value, uint8_t speed, uint8_t brightness, uint8_t direction);
@@ -57,4 +64,5 @@ private:
     hid_device* dev;
     std::string location;
     std::string version;
+    uint16_t pid;
 };

Controllers/InstantMouseController/InstantMouseControllerDetect.cpp

@@ -13,11 +13,8 @@
 #include "InstantMouseController.h"
 #include "RGBController.h"
 #include "RGBController_InstantMouse.h"
+#include "InstantMouseDevices.h"
 
-#define INSTANT_MICROELECTRONICS_VID            0x30FA
-#define ADVANCED_GTA_250_PID                    0x1030
-#define ANKO_KM43243952_VID                     0x1440
-#define ANKO_KM43277483_VID                     0x1540
 
 void DetectInstantMouseControllers(hid_device_info* info, const std::string& name)
 {
@@ -35,3 +32,5 @@ void DetectInstantMouseControllers(hid_device_info* info, const std::string& nam
 REGISTER_HID_DETECTOR_IPU("Advanced GTA 250 USB Gaming Mouse",  DetectInstantMouseControllers,  INSTANT_MICROELECTRONICS_VID, ADVANCED_GTA_250_PID, 1, 0xFF01, 0x01);
 REGISTER_HID_DETECTOR_IPU("Anko KM43243952 USB Gaming Mouse",   DetectInstantMouseControllers,  INSTANT_MICROELECTRONICS_VID, ANKO_KM43243952_VID,  1, 0xFF01, 0x01);
 REGISTER_HID_DETECTOR_IPU("Anko KM43277483 USB Gaming Mouse",   DetectInstantMouseControllers,  INSTANT_MICROELECTRONICS_VID, ANKO_KM43277483_VID,  1, 0xFF01, 0x01);
+REGISTER_HID_DETECTOR_IPU("AntEsports GM600 USB Gaming Mouse",  DetectInstantMouseControllers,  INSTANT_MICROELECTRONICS_VID, ANTESPORTS_GM600_PID, 1, 0xFF01, 0001);
+

Controllers/InstantMouseController/InstantMouseDevices.h

@@ -0,0 +1,19 @@
+/*---------------------------------------------------------*\
+| InstantMouseController.h                                  |
+|                                                           |
+|   Driver for Instant mouse                                |
+|                                                           |
+|   shafiahaz2478                               29 Aug 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+#pragma once
+
+#define INSTANTMOUSEDEVICES_H
+
+#define INSTANT_MICROELECTRONICS_VID            0x30FA
+#define ADVANCED_GTA_250_PID                    0x1030
+#define ANKO_KM43243952_VID                     0x1440
+#define ANKO_KM43277483_VID                     0x1540
+#define ANTESPORTS_GM600_PID                    0x1040

Controllers/InstantMouseController/RGBController_InstantMouse.cpp

@@ -10,6 +10,7 @@
 \*---------------------------------------------------------*/
 
 #include "RGBController_InstantMouse.h"
+#include "InstantMouseDevices.h"
 
 /**------------------------------------------------------------------*\
     @name Instant mouse
@@ -21,7 +22,8 @@
     @detectors DetectInstantMouseControllers
     @comment This controller should work with all mouse with this chip.
     Identified devices that work with this controller: Advance Gaming
-    GTA 250 (GX72-A725), Anko KM43243952 (GM8-A825), Anko KM43277483
+    GTA 250 (GX72-A725), Anko KM43243952 (GM8-A825), Anko KM43277483,
+    Ant Esports GM600
 \*-------------------------------------------------------------------*/
 
 RGBController_InstantMouse::RGBController_InstantMouse(InstantMouseController* controller_ptr)
@@ -66,7 +68,10 @@ RGBController_InstantMouse::RGBController_InstantMouse(InstantMouseController* c
 
     mode breathing;
     breathing.name                      = "Breathing";
-    breathing.value                     = INSTANT_MOUSE_BREATHING_MODE;
+    /*------------------------------------------------------------------*\
+    |    ANT ESPORTS GM600 has different mode id for breathing mode.     |
+    \*------------------------------------------------------------------*/
+    breathing.value                     = (controller->GetPID() == ANTESPORTS_GM600_PID ) ? ANT_MOUSE_BREATHING_MODE : INSTANT_MOUSE_BREATHING_MODE;
     breathing.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
     breathing.color_mode                = MODE_COLORS_MODE_SPECIFIC;
     breathing.colors.resize(1);
@@ -102,6 +107,47 @@ RGBController_InstantMouse::RGBController_InstantMouse(InstantMouseController* c
     loop.brightness_min                 = INSTANT_MOUSE_BRIGHTNESS_MIN;
     loop.brightness_max                 = INSTANT_MOUSE_BRIGHTNESS_MAX;
     modes.push_back(loop);
+    /*------------------------------------------------------------------*\
+    |    Extra modes for Ant Esports GM600.                              |
+    \*------------------------------------------------------------------*/
+    if(controller->GetPID() == ANTESPORTS_GM600_PID )
+    {
+        mode enraptured;
+        enraptured.name                 = "Enrpatured";
+        enraptured.value                = INSTANT_MOUSE_ENRAPTURED_MODE;
+        enraptured.flags                = MODE_FLAG_HAS_SPEED;
+        enraptured.color_mode           = MODE_COLORS_NONE;
+        enraptured.speed_min            = INSTANT_MOUSE_SPEED_MIN;
+        enraptured.speed_max            = INSTANT_MOUSE_SPEED_MAX;
+        enraptured.speed                = INSTANT_MOUSE_SPEED_MAX/2;
+        modes.push_back(enraptured);
+
+        mode flicker;
+        flicker.name                    = "Flicker";
+        flicker.value                   = INSTANT_MOUSE_FLICKER_MODE;
+        flicker.flags                   = MODE_FLAG_HAS_SPEED;
+        flicker.color_mode              = MODE_COLORS_NONE;
+        flicker.speed_min               = INSTANT_MOUSE_SPEED_MIN;
+        flicker.speed_max               = INSTANT_MOUSE_SPEED_MAX;
+        flicker.speed                   = INSTANT_MOUSE_SPEED_MAX/2;
+        modes.push_back(flicker);
+
+        mode ripple;
+        ripple.name                     = "Ripple";
+        ripple.value                    = INSTANT_MOUSE_RIPPLE_MODE;
+        ripple.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+        ripple.color_mode               = MODE_COLORS_NONE;
+        ripple.speed_min                = INSTANT_MOUSE_SPEED_MIN;
+        ripple.speed_max                = INSTANT_MOUSE_SPEED_MAX;
+        ripple.speed                    = INSTANT_MOUSE_SPEED_MAX/2;
+        modes.push_back(ripple);
+
+        mode startreck;
+        startreck.name                  = "Star treck";
+        startreck.value                 = INSTANT_MOUSE_STARTRECK_MODE;
+
+        modes.push_back(startreck);
+    }
 
     mode off;
     off.name                            = "Off";

Controllers/KingstonFuryDRAMController/RGBController_KingstonFuryDRAM.cpp

@@ -558,6 +558,7 @@ void RGBController_KingstonFuryDRAM::DeviceUpdateLEDs()
     case FURY_MODE_TELEPORT:
         // between 1 and 12
         controller->SetRegister(FURY_REG_LENGTH, 3);
+        break;
 
     case FURY_MODE_WIND:
         // between 0 and 32

Controllers/LenovoControllers/LenovoUSBController/RGBController_LenovoUSB.cpp

@@ -398,15 +398,13 @@ void RGBController_LenovoUSB::DeviceUpdateLEDs()
 
         prev_zone_id = zone_id;
 
-        curr_color_map.push_back({leds[i].value & 0xFF, colors[i]});
-
+        curr_color_map.push_back({(uint8_t)(leds[i].value & 0xFF), colors[i]});
     }
 
     if(curr_color_map.size() > 0)
     {
         controller->setZoneLeds(prev_zone_id, curr_color_map);
     }
-
 }
 
 void RGBController_LenovoUSB::DeviceUpdateMode()

Controllers/LogitechController/LogitechG815Controller/RGBController_LogitechG815.cpp

@@ -333,7 +333,7 @@ void RGBController_LogitechG815::DeviceUpdateLEDs()
         zone = ( leds[led_idx].value >> 8 );
         idx  = ( leds[led_idx].value );
 
-        if (current_colors[led_idx]==new_colors[led_idx])
+        if(current_colors[led_idx]==new_colors[led_idx])
         {
             /*-------------------------------------------------*\
             | Don't send if key color is not changed            |
@@ -366,7 +366,7 @@ void RGBController_LogitechG815::DeviceUpdateLEDs()
 
         colorkey = new_colors[led_idx];
 
-        if (ledsByColors.count(colorkey) == 0)
+        if(ledsByColors.count(colorkey) == 0)
         {
             ledsByColors.insert(std::pair<RGBColor, std::vector<char>>(colorkey, {}));
         }
@@ -400,16 +400,16 @@ void RGBController_LogitechG815::DeviceUpdateLEDs()
                 frame_buffer_big_mode[2] = RGBGetBValue(x.first);
                 frame_pos                = 3;
 
-                for(uint8_t i = 0; i < max_key_per_color; i++)
+                for(uint8_t i = 0; i < (uint8_t)max_key_per_color; i++)
                 {
-                    if(bi + i < x.second.size())
+                    if((bi + i) < (uint8_t)x.second.size())
                     {
                         frame_buffer_big_mode[frame_pos] = x.second[bi+i];
                         frame_pos++;
                     }
                 }
 
-                if (frame_pos < data_size)
+                if(frame_pos < data_size)
                 {
                     /*-----------------------------------------*\
                     | Zeroing just what is needed and if needed |
@@ -446,7 +446,7 @@ void RGBController_LogitechG815::DeviceUpdateLEDs()
                 li++;
                 led_in_little_frame++;
 
-                if (led_in_little_frame == 4)
+                if(led_in_little_frame == 4)
                 {
                     /*-----------------------------------------*\
                     | No End of Data byte if the packet is full |

Controllers/LogitechController/LogitechG915Controller/LogitechG915Controller.h

@@ -113,12 +113,12 @@ public:
                     );
 
 private:
-    hid_device* dev_handle;
-    char feature_4522_idx;
-    char device_index;
-    char feature_8040_idx;
-    char feature_8071_idx;
-    char feature_8081_idx;
+    hid_device*   dev_handle;
+    unsigned char feature_4522_idx;
+    unsigned char device_index;
+    unsigned char feature_8040_idx;
+    unsigned char feature_8071_idx;
+    unsigned char feature_8081_idx;
 
     void        SendDirectFrame
                     (

Controllers/LogitechController/LogitechG915Controller/RGBController_LogitechG915.cpp

@@ -393,7 +393,7 @@ void RGBController_LogitechG915::DeviceUpdateLEDs()
         zone = ( leds[led_idx].value >> 8 );
         idx  = ( leds[led_idx].value );
 
-        if (current_colors[led_idx]==new_colors[led_idx])
+        if(current_colors[led_idx]==new_colors[led_idx])
         {
             /*-------------------------------------------------*\
             | Don't send if key color is not changed            |
@@ -401,7 +401,7 @@ void RGBController_LogitechG915::DeviceUpdateLEDs()
             continue;
         }
 
-        switch (zone)
+        switch(zone)
         {
             case LOGITECH_G915_ZONE_MODE_GKEYS:
                 idx = ((idx & 0x00ff) + 0xb3);
@@ -426,7 +426,7 @@ void RGBController_LogitechG915::DeviceUpdateLEDs()
 
         colorkey = new_colors[led_idx];
 
-        if (ledsByColors.count(colorkey) == 0)
+        if(ledsByColors.count(colorkey) == 0)
         {
             ledsByColors.insert(std::pair<RGBColor, std::vector<char>>(colorkey, {}));
         }
@@ -462,14 +462,14 @@ void RGBController_LogitechG915::DeviceUpdateLEDs()
 
                 for(uint8_t i = 0; i < max_key_per_color; i++)
                 {
-                    if(bi + i < x.second.size())
+                    if((bi + i) < (uint8_t)x.second.size())
                     {
                         frame_buffer_big_mode[frame_pos] = x.second[bi+i];
                         frame_pos++;
                     }
                 }
 
-                if (frame_pos < data_size)
+                if(frame_pos < data_size)
                 {
                     /*-----------------------------------------*\
                     | Zeroing just what is needed and if needed |
@@ -506,7 +506,7 @@ void RGBController_LogitechG915::DeviceUpdateLEDs()
                 li++;
                 led_in_little_frame++;
 
-                if (led_in_little_frame == 4)
+                if(led_in_little_frame == 4)
                 {
                     /*-----------------------------------------*\
                     | No End of Data byte if the packet is full |

Controllers/LogitechController/LogitechLightspeedController/LogitechLightspeedController.cpp

@@ -11,6 +11,7 @@
 
 #include <cstring>
 #include "LogitechLightspeedController.h"
+#include "StringUtils.h"
 
 LogitechLightspeedController::LogitechLightspeedController(hid_device* dev_handle, const char* path)
 {
@@ -46,8 +47,7 @@ std::string LogitechLightspeedController::GetSerialString()
             return("");
         }
 
-        std::wstring return_wstring = serial_string;
-        std::string return_string(return_wstring.begin(), return_wstring.end());
+        std::string return_string(StringUtils::wstring_to_string(serial_string));
 
         return(return_string);
     }

Controllers/LogitechController/LogitechLightspeedController/RGBController_LogitechLightspeed.cpp

@@ -174,7 +174,7 @@ void RGBController_LogitechLightspeed::SetupZones()
         {
             zone Lightspeed_logo_zone;
             led Lightspeed_logo_led;
-            logitech_led new_led                    = controller->lightspeed->getLED_info(i);
+            logitech_led new_led                    = controller->lightspeed->getLED_info((uint8_t)i);
 
             if(new_led.location < NUM_LOGITECH_LED_LOCATIONS )
             {
@@ -198,7 +198,7 @@ void RGBController_LogitechLightspeed::SetupZones()
             Lightspeed_logo_zone.matrix_map         = NULL;
             zones.push_back(Lightspeed_logo_zone);
 
-            Lightspeed_logo_led.value               = i;
+            Lightspeed_logo_led.value               = (unsigned int)i;
             leds.push_back(Lightspeed_logo_led);
         }
     }

Controllers/LuxaforController/LuxaforController.cpp

@@ -0,0 +1,129 @@
+/*---------------------------------------------------------*\
+| LuxaforController.cpp                                     |
+|                                                           |
+|   Driver for Luxafor devices                              |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      05 Sep 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <cstring>
+#include "LuxaforController.h"
+#include "StringUtils.h"
+
+LuxaforController::LuxaforController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+LuxaforController::~LuxaforController()
+{
+    hid_close(dev);
+}
+
+std::string LuxaforController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string LuxaforController::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 LuxaforController::SendPacket(unsigned char mode, unsigned char led, unsigned char red, unsigned char grn, unsigned char blu, unsigned char type)
+{
+    unsigned char usb_buf[9];
+
+    memset(usb_buf, 0, sizeof(usb_buf));
+
+    switch(mode)
+    {
+        /*-------------------------------------------------*\
+        | For Direct, Fade, and Strobe, the packet format:  |
+        |   0: Report ID (Always 0)                         |
+        |   1: Mode (1: Direct, 2: Fade, 3: Strobe)         |
+        |   2: LED Index                                    |
+        |   3: Red                                          |
+        |   4: Green                                        |
+        |   5: Blue                                         |
+        |   6: Changing Time (Fade) / Speed (Strobe)        |
+        |   7: Unused                                       |
+        |   8: Repeat (Strobe)                              |
+        \*-------------------------------------------------*/
+        case LUXAFOR_MODE_DIRECT:
+        case LUXAFOR_MODE_FADE:
+        case LUXAFOR_MODE_STROBE:
+            usb_buf[0] = 0x00;
+            usb_buf[1] = mode;
+            usb_buf[2] = led;
+            usb_buf[3] = red;
+            usb_buf[4] = grn;
+            usb_buf[5] = blu;
+            usb_buf[6] = 100;
+            usb_buf[7] = 0;
+            usb_buf[8] = (mode == LUXAFOR_MODE_STROBE) ? 255 : 0;
+            break;
+
+        /*-------------------------------------------------*\
+        | For Wave, the packet format:                      |
+        |   0: Report ID (Always 0)                         |
+        |   1: Mode (4: Wave)                               |
+        |   2: Wave Type (1-5)                              |
+        |   3: Red                                          |
+        |   4: Green                                        |
+        |   5: Blue                                         |
+        |   6: Unused                                       |
+        |   7: Repeat                                       |
+        |   8: Speed                                        |
+        \*-------------------------------------------------*/
+        case LUXAFOR_MODE_WAVE:
+            usb_buf[0] = 0x00;
+            usb_buf[1] = mode;
+            usb_buf[2] = type;
+            usb_buf[3] = red;
+            usb_buf[4] = grn;
+            usb_buf[5] = blu;
+            usb_buf[6] = 0;
+            usb_buf[7] = 255;
+            usb_buf[8] = 100;
+            break;
+
+        /*-------------------------------------------------*\
+        | For Pattern, the packet format:                   |
+        |   0: Report ID (Always 0)                         |
+        |   1: Mode (6: Pattern)                            |
+        |   2: Pattern Number (1-8)                         |
+        |   3: Repeat                                       |
+        |   4: Unused                                       |
+        |   5: Unused                                       |
+        |   6: Unused                                       |
+        |   7: Unused                                       |
+        |   8: Unused                                       |
+        \*-------------------------------------------------*/
+        case LUXAFOR_MODE_PATTERN:
+            usb_buf[0] = 0x00;
+            usb_buf[1] = mode;
+            usb_buf[2] = type;
+            usb_buf[3] = 255;
+            usb_buf[4] = 0;
+            usb_buf[5] = 0;
+            usb_buf[6] = 0;
+            usb_buf[7] = 0;
+            usb_buf[8] = 0;
+            break;
+    }
+
+    hid_write(dev, usb_buf, sizeof(usb_buf));
+}

Controllers/LuxaforController/LuxaforController.h

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------*\
+| LuxaforController.h                                       |
+|                                                           |
+|   Driver for Luxafor devices                              |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      05 Sep 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include <hidapi.h>
+
+enum
+{
+    LUXAFOR_LED_FIRST       = 1,
+    LUXAFOR_LED_ALL         = 255,
+};
+
+enum
+{
+    LUXAFOR_MODE_DIRECT     = 1,
+    LUXAFOR_MODE_FADE       = 2,
+    LUXAFOR_MODE_STROBE     = 3,
+    LUXAFOR_MODE_WAVE       = 4,
+    LUXAFOR_MODE_PATTERN    = 6,
+};
+
+enum
+{
+    LUXAFOR_PATTERN_TRAFFIC_LIGHTS  = 1,
+    LUXAFOR_PATTERN_2               = 2,
+    LUXAFOR_PATTERN_3               = 3,
+    LUXAFOR_PATTERN_4               = 4,
+    LUXAFOR_PATTERN_POLICE          = 5,
+    LUXAFOR_PATTERN_6               = 6,
+    LUXAFOR_PATTERN_7               = 7,
+    LUXAFOR_PATTERN_8               = 8,
+};
+
+class LuxaforController
+{
+public:
+    LuxaforController(hid_device* dev_handle, const char* path);
+    ~LuxaforController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void SendPacket(unsigned char mode, unsigned char led, unsigned char red, unsigned char grn, unsigned char blu, unsigned char type);
+
+private:
+    hid_device* dev;
+    std::string location;
+};

Controllers/LuxaforController/LuxaforControllerDetect.cpp

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------*\
+| LuxaforControllerDetect.cpp                               |
+|                                                           |
+|   Detector for Luxafor devices                            |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      05 Sep 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include "Detector.h"
+#include "LuxaforController.h"
+#include "RGBController_Luxafor.h"
+
+/*---------------------------------------------------------*\
+| Luxafor USB Vendor ID                                     |
+\*---------------------------------------------------------*/
+#define LUXAFOR_VID                                 0x04D8
+
+/*---------------------------------------------------------*\
+| Luxafor USB Product ID                                    |
+\*---------------------------------------------------------*/
+#define LUXAFOR_FLAG_PID                            0xF372
+
+void DetectLuxaforControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        LuxaforController*     controller     = new LuxaforController(dev, info->path);
+        RGBController_Luxafor* rgb_controller = new RGBController_Luxafor(controller);
+        rgb_controller->name                  = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR( "Luxafor Flag", DetectLuxaforControllers, LUXAFOR_VID, LUXAFOR_FLAG_PID );

Controllers/LuxaforController/RGBController_Luxafor.cpp

@@ -0,0 +1,239 @@
+/*---------------------------------------------------------*\
+| RGBController_Luxafor.cpp                                 |
+|                                                           |
+|   RGBController for Luxafor devices                       |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      05 Sep 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include "RGBController_Luxafor.h"
+
+RGBController_Luxafor::RGBController_Luxafor(LuxaforController* controller_ptr)
+{
+    controller          = controller_ptr;
+
+    name                = "Luxafor Device";
+    type                = DEVICE_TYPE_ACCESSORY;
+    vendor              = "Luxafor";
+    description         = "Luxafor Device";
+    location            = controller->GetDeviceLocation();
+    serial              = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name         = "Direct";
+    Direct.value        = LUXAFOR_MODE_DIRECT;
+    Direct.flags        = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode   = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    // mode Fade;
+    // Fade.name           = "Fade";
+    // Fade.value          = LUXAFOR_MODE_FADE;
+    // Fade.flags          = MODE_FLAG_HAS_PER_LED_COLOR;
+    // Fade.color_mode     = MODE_COLORS_PER_LED;
+    // modes.push_back(Fade);
+
+    // mode Strobe;
+    // Strobe.name         = "Strobe";
+    // Strobe.value        = LUXAFOR_MODE_STROBE;
+    // Strobe.flags        = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    // Strobe.color_mode   = MODE_COLORS_MODE_SPECIFIC;
+    // Strobe.colors_min   = 1;
+    // Strobe.colors_max   = 1;
+    // Strobe.colors.resize(1);
+    // modes.push_back(Strobe);
+
+    // mode Wave;
+    // Wave.name           = "Wave";
+    // Wave.value          = LUXAFOR_MODE_WAVE;
+    // Wave.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    // Wave.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    // Wave.colors_min     = 1;
+    // Wave.colors_max     = 1;
+    // Wave.colors.resize(1);
+    // modes.push_back(Wave);
+
+    mode TrafficLights;
+    TrafficLights.name          = "Traffic Lights";
+    TrafficLights.value         = LUXAFOR_MODE_PATTERN_TRAFFIC_LIGHTS;
+    TrafficLights.flags         = 0;
+    TrafficLights.color_mode    = MODE_COLORS_NONE;
+    modes.push_back(TrafficLights);
+
+    mode Pattern2;
+    Pattern2.name               = "Pattern 2";
+    Pattern2.value              = LUXAFOR_MODE_PATTERN_2;
+    Pattern2.flags              = 0;
+    Pattern2.color_mode         = MODE_COLORS_NONE;
+    modes.push_back(Pattern2);
+
+    mode Pattern3;
+    Pattern3.name               = "Pattern 3";
+    Pattern3.value              = LUXAFOR_MODE_PATTERN_3;
+    Pattern3.flags              = 0;
+    Pattern3.color_mode         = MODE_COLORS_NONE;
+    modes.push_back(Pattern3);
+
+    mode Pattern4;
+    Pattern4.name               = "Pattern 4";
+    Pattern4.value              = LUXAFOR_MODE_PATTERN_4;
+    Pattern4.flags              = 0;
+    Pattern4.color_mode         = MODE_COLORS_NONE;
+    modes.push_back(Pattern4);
+
+    mode Police;
+    Police.name                 = "Police";
+    Police.value                = LUXAFOR_MODE_PATTERN_POLICE;
+    Police.flags                = 0;
+    Police.color_mode           = MODE_COLORS_NONE;
+    modes.push_back(Police);
+
+    mode Pattern6;
+    Pattern6.name               = "Pattern 6";
+    Pattern6.value              = LUXAFOR_MODE_PATTERN_6;
+    Pattern6.flags              = 0;
+    Pattern6.color_mode         = MODE_COLORS_NONE;
+    modes.push_back(Pattern6);
+
+    mode Pattern7;
+    Pattern7.name               = "Pattern 7";
+    Pattern7.value              = LUXAFOR_MODE_PATTERN_7;
+    Pattern7.flags              = 0;
+    Pattern7.color_mode         = MODE_COLORS_NONE;
+    modes.push_back(Pattern7);
+
+    mode Pattern8;
+    Pattern8.name               = "Pattern 8";
+    Pattern8.value              = LUXAFOR_MODE_PATTERN_8;
+    Pattern8.flags              = 0;
+    Pattern8.color_mode         = MODE_COLORS_NONE;
+    modes.push_back(Pattern8);
+
+    SetupZones();
+}
+
+RGBController_Luxafor::~RGBController_Luxafor()
+{
+
+}
+
+void RGBController_Luxafor::SetupZones()
+{
+    /*-----------------------------------------------------*\
+    | The Luxafor Flag has 2 zones                          |
+    |   * Flag (3 LEDs)                                     |
+    |   * Rear (3 LEDs)                                     |
+    | The LED index starts at 1. Sending 255 for the LED ID |
+    | sets all LEDs at once.                                |
+    \*-----------------------------------------------------*/
+    unsigned int led_value  = LUXAFOR_LED_FIRST;
+
+    zone flag_zone;
+    flag_zone.name          = "Flag";
+    flag_zone.type          = ZONE_TYPE_SINGLE;
+    flag_zone.leds_min      = 3;
+    flag_zone.leds_max      = 3;
+    flag_zone.leds_count    = 3;
+    flag_zone.matrix_map    = NULL;
+    zones.push_back(flag_zone);
+
+    for(std::size_t led_idx = 0; led_idx < flag_zone.leds_count; led_idx++)
+    {
+        led luxafor_led;
+        luxafor_led.name        = "Flag LED";
+        luxafor_led.value       = led_value;
+        leds.push_back(luxafor_led);
+
+        led_value++;
+    }
+
+    zone rear_zone;
+    rear_zone.name          = "Rear";
+    rear_zone.type          = ZONE_TYPE_SINGLE;
+    rear_zone.leds_min      = 3;
+    rear_zone.leds_max      = 3;
+    rear_zone.leds_count    = 3;
+    rear_zone.matrix_map    = NULL;
+    zones.push_back(rear_zone);
+
+    for(std::size_t led_idx = 0; led_idx < rear_zone.leds_count; led_idx++)
+    {
+        led luxafor_led;
+        luxafor_led.name        = "Rear LED";
+        luxafor_led.value       = led_value;
+        leds.push_back(luxafor_led);
+
+        led_value++;
+    }
+
+    SetupColors();
+}
+
+void RGBController_Luxafor::ResizeZone(int zone, int new_size)
+{
+    /*-----------------------------------------------------*\
+    | This device does not support resizing zones           |
+    \*-----------------------------------------------------*/
+}
+
+void RGBController_Luxafor::DeviceUpdateLEDs()
+{
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        UpdateZoneLEDs(zone_idx);
+    }
+}
+
+void RGBController_Luxafor::UpdateZoneLEDs(int zone)
+{
+    for(std::size_t led_idx = 0; led_idx < zones[zone].leds_count; led_idx++)
+    {
+        UpdateSingleLED(zones[zone].start_idx + led_idx);
+    }
+}
+
+void RGBController_Luxafor::UpdateSingleLED(int led)
+{
+    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
+    {
+        unsigned char red = RGBGetRValue(colors[led]);
+        unsigned char grn = RGBGetGValue(colors[led]);
+        unsigned char blu = RGBGetBValue(colors[led]);
+
+        controller->SendPacket((modes[active_mode].value & 0xFF), leds[led].value, red, grn, blu, 0);
+    }
+}
+
+void RGBController_Luxafor::DeviceUpdateMode()
+{
+    switch(modes[active_mode].color_mode)
+    {
+        case MODE_COLORS_PER_LED:
+            DeviceUpdateLEDs();
+            break;
+
+        case MODE_COLORS_MODE_SPECIFIC:
+            {
+            unsigned char red = RGBGetRValue(colors[modes[active_mode].colors[0]]);
+            unsigned char grn = RGBGetGValue(colors[modes[active_mode].colors[0]]);
+            unsigned char blu = RGBGetBValue(colors[modes[active_mode].colors[0]]);
+
+            controller->SendPacket((modes[active_mode].value & 0xFF), LUXAFOR_LED_ALL, red, grn, blu, 0);
+            }
+            break;
+
+        case MODE_COLORS_NONE:
+            controller->SendPacket((modes[active_mode].value & 0xFF), LUXAFOR_LED_ALL, 0, 0, 0, (modes[active_mode].value >> 8));
+            break;
+    }
+}
+
+void RGBController_Luxafor::DeviceSaveMode()
+{
+    /*-----------------------------------------------------*\
+    | This device does not support saving                   |
+    \*-----------------------------------------------------*/
+}

Controllers/LuxaforController/RGBController_Luxafor.h

@@ -0,0 +1,52 @@
+/*---------------------------------------------------------*\
+| RGBController_Luxafor.h                                   |
+|                                                           |
+|   RGBController for Luxafor devices                       |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      05 Sep 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "LuxaforController.h"
+#include "RGBController.h"
+
+/*---------------------------------------------------------*\
+| Additional "pseudo-modes" which combine pattern mode with |
+| the pattern to use.                                       |
+\*---------------------------------------------------------*/
+enum
+{
+    LUXAFOR_MODE_PATTERN_TRAFFIC_LIGHTS = LUXAFOR_MODE_PATTERN + (LUXAFOR_PATTERN_TRAFFIC_LIGHTS << 8),
+    LUXAFOR_MODE_PATTERN_2              = LUXAFOR_MODE_PATTERN + (LUXAFOR_PATTERN_2 << 8),
+    LUXAFOR_MODE_PATTERN_3              = LUXAFOR_MODE_PATTERN + (LUXAFOR_PATTERN_3 << 8),
+    LUXAFOR_MODE_PATTERN_4              = LUXAFOR_MODE_PATTERN + (LUXAFOR_PATTERN_4 << 8),
+    LUXAFOR_MODE_PATTERN_POLICE         = LUXAFOR_MODE_PATTERN + (LUXAFOR_PATTERN_POLICE << 8),
+    LUXAFOR_MODE_PATTERN_6              = LUXAFOR_MODE_PATTERN + (LUXAFOR_PATTERN_6 << 8),
+    LUXAFOR_MODE_PATTERN_7              = LUXAFOR_MODE_PATTERN + (LUXAFOR_PATTERN_7 << 8),
+    LUXAFOR_MODE_PATTERN_8              = LUXAFOR_MODE_PATTERN + (LUXAFOR_PATTERN_8 << 8),
+};
+
+class RGBController_Luxafor : public RGBController
+{
+public:
+    RGBController_Luxafor(LuxaforController* controller_ptr);
+    ~RGBController_Luxafor();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    LuxaforController* controller;
+};

Controllers/MSIGPUController/MSIGPUController/RGBController_MSIGPU.cpp

@@ -18,9 +18,9 @@ int RGBController_MSIGPU::GetDeviceMode()
 
     for(std::size_t mode = 0; mode < modes.size(); mode++)
     {
-        if (modes[mode].value == dev_mode)
+        if(modes[mode].value == dev_mode)
         {
-            active_mode = mode;
+            active_mode = (int)mode;
             break;
         }
     }
@@ -36,11 +36,11 @@ int RGBController_MSIGPU::GetModeSpeed()
     {
         if(speed_values[speed] == mode_speed)
         {
-            return speed;
+            return((int)speed);
         }
     }
 
-    return 0;
+    return(0);
 }
 
 /**------------------------------------------------------------------*\

Controllers/MSIGPUController/MSIGPUv2Controller/MSIGPUv2ControllerDetect.cpp

@@ -54,6 +54,7 @@ REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4070 Ti 12GB Suprim X Trio",
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4070 Ti SUPER 16GB Gaming X Trio White", DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4070TIS_DEV,      MSI_SUB_VEN,    MSI_RTX4070TI_GAMING_X_TRIO_WHITE_SUB_DEV,     0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4070 Ti SUPER 16GB Gaming Slim",         DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4070TIS_DEV,      MSI_SUB_VEN,    MSI_RTX4070TIS_GAMING_SLIM_SUB_DEV,            0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4070 Ti SUPER 16GB Gaming X Slim",       DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4070TIS_DEV,      MSI_SUB_VEN,    MSI_RTX4070TIS_GAMING_X_SLIM_SUB_DEV,          0x68);
+REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4070 Ti SUPER 16GB Gaming White X Slim", DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4070TIS_DEV,      MSI_SUB_VEN,    MSI_RTX4070TIS_GAMING_X_SLIM_WHITE_SUB_DEV,    0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4080 16GB Gaming X Slim White",          DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4080_DEV,         MSI_SUB_VEN,    MSI_RTX4080S_GAMING_X_SLIM_WHITE_SUB_DEV,      0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4080 16GB Gaming X Trio",                DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4080_DEV,         MSI_SUB_VEN,    MSI_RTX4080_GAMING_X_TRIO_SUB_DEV,             0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4080 16GB Gaming X Trio White",          DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4080_DEV,         MSI_SUB_VEN,    MSI_RTX4080_GAMING_X_TRIO_WHITE_SUB_DEV,       0x68);
@@ -61,6 +62,7 @@ REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4080 16GB Suprim X",
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4080 SUPER 16GB Gaming X Slim",          DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4080S_DEV,        MSI_SUB_VEN,    MSI_RTX4080S_GAMING_X_SLIM_SUB_DEV,            0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4080 SUPER 16GB Gaming X Slim White",    DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4080S_DEV,        MSI_SUB_VEN,    MSI_RTX4080S_GAMING_X_SLIM_WHITE_SUB_DEV,      0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4080 SUPER 16GB Suprim X",               DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4080S_DEV,        MSI_SUB_VEN,    MSI_RTX4080_SUPRIM_X_SUB_DEV,                  0x68);
+REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4080 SUPER 16GB Gaming X Trio",          DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4080S_DEV,        MSI_SUB_VEN,    MSI_RTX4080S_GAMING_X_TRIO_SUB_DEV,            0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4090 24GB Gaming X Trio",                DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         MSI_SUB_VEN,    MSI_RTX4090_GAMING_X_TRIO_SUB_DEV,             0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4090 24GB Gaming X Slim",                DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         MSI_SUB_VEN,    MSI_RTX4090_GAMING_X_SLIM_SUB_DEV,             0x68);
 REGISTER_I2C_PCI_DETECTOR("MSI GeForce RTX 4090 24GB Suprim Liquid X",              DetectMSIGPUv2Controllers,    NVIDIA_VEN,     NVIDIA_RTX4090_DEV,         MSI_SUB_VEN,    MSI_RTX4090_SUPRIM_LIQUID_X_SUB_DEV,           0x68);

Controllers/MSIGPUController/MSIGPUv2Controller/RGBController_MSIGPUv2.cpp

@@ -169,6 +169,7 @@ RGBController_MSIGPUv2::RGBController_MSIGPUv2(MSIGPUv2Controller * msi_gpu_ptr,
         case MSI_RTX4060TI_GAMING_X_16G_SLIM_WHITE_SUB_DEV | NVIDIA_RTX4060TI_16G_DEV << 16:
         case MSI_RTX4070S_GAMING_X_SLIM_SUB_DEV | NVIDIA_RTX4070S_DEV << 16:
         case MSI_RTX4070TI_GAMING_X_TRIO_WHITE_SUB_DEV | NVIDIA_RTX4070TIS_DEV << 16:
+        case MSI_RTX4080S_GAMING_X_TRIO_SUB_DEV | NVIDIA_RTX4080S_DEV << 16:
         case MSI_RTX4080S_GAMING_X_SLIM_WHITE_SUB_DEV | NVIDIA_RTX4080_DEV << 16:
         case MSI_RTX4080S_GAMING_X_SLIM_WHITE_SUB_DEV | NVIDIA_RTX4080S_DEV << 16:
             break;

Controllers/MSIMysticLightController/MSIMysticLight112Controller/MSIMysticLight112Controller.cpp

@@ -395,10 +395,9 @@ void MSIMysticLight112Controller::ReadName()
     hid_get_manufacturer_string(dev, tname, 256);
 
     /*-----------------------------------------------------*\
-    | Convert wchar_t into std::wstring into std::string    |
+    | Convert to std::string                                |
     \*-----------------------------------------------------*/
-    std::wstring wname = std::wstring(tname);
-    name = std::string(wname.begin(), wname.end());
+    name = StringUtils::wstring_to_string(tname);
 
     /*-----------------------------------------------------*\
     | Get the product string from HID                       |
@@ -408,8 +407,7 @@ void MSIMysticLight112Controller::ReadName()
     /*-----------------------------------------------------*\
     | Append the product string to the manufacturer string  |
     \*-----------------------------------------------------*/
-    wname = std::wstring(tname);
-    name.append(" ").append(std::string(wname.begin(), wname.end()));
+    name.append(" ").append(StringUtils::wstring_to_string(tname));
 }
 
 MSI_MODE MSIMysticLight112Controller::GetMode()

Controllers/MSIMysticLightController/MSIMysticLight162Controller/MSIMysticLight162Controller.cpp

@@ -418,10 +418,9 @@ void MSIMysticLight162Controller::ReadName()
     hid_get_manufacturer_string(dev, tname, 256);
 
     /*-----------------------------------------------------*\
-    | Convert wchar_t into std::wstring into std::string    |
+    | Convert to std::string                                |
     \*-----------------------------------------------------*/
-    std::wstring wname = std::wstring(tname);
-    name = std::string(wname.begin(), wname.end());
+    name = StringUtils::wstring_to_string(tname);
 
     /*-----------------------------------------------------*\
     | Get the product string from HID                       |
@@ -431,8 +430,7 @@ void MSIMysticLight162Controller::ReadName()
     /*-----------------------------------------------------*\
     | Append the product string to the manufacturer string  |
     \*-----------------------------------------------------*/
-    wname = std::wstring(tname);
-    name.append(" ").append(std::string(wname.begin(), wname.end()));
+    name.append(" ").append(StringUtils::wstring_to_string(tname));
 }
 
 MSI_MODE MSIMysticLight162Controller::GetMode()

Controllers/MSIMysticLightController/MSIMysticLight185Controller/MSIMysticLight185Controller.cpp

@@ -263,11 +263,11 @@ static const mystic_light_185_config board_configs[] =
     { 0x7C95, 6,  0,  0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // B550M PRO-VDH WIFI
     { 0x7C98, 6,  0,  0, 1, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // Z490 PLUS
     { 0x7D03, 0, 15, 18, 1, &zones_set8,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MPG Z590 GODLIKE
-    { 0x7D06, 4,  4,  0, 1, &zones_set3,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },      // MPG Z590 GAMING FORCE
+    { 0x7D06, 4,  4,  0, 1, &zones_set3,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MPG Z590 GAMING FORCE
     { 0x7D07, 4,  5,  0, 2, &zones_set7,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MPG Z590 GAMING EDGE WIFI
     { 0x7D08, 6,  0,  0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG Z590 TOMAHAWK
     { 0x7D09, 6,  0,  0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // Z590-A PRO WIFI
-    { 0x7D13, 6,  0,  0, 1, &zones_set1,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },      // MEG B550 UNIFY
+    { 0x7D13, 6,  0,  0, 1, &zones_set1,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },      // MEG B550 UNIFY
     { 0x7D15, 6,  0,  0, 2, &zones_set0,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG B560 TOMAHAWK WIFI
     { 0x7D17, 6,  0,  0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG B560M MORTAR
     { 0x7D18, 6,  0,  0, 2, &zones_set5,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG B560M PRO-VDH
@@ -276,7 +276,7 @@ static const mystic_light_185_config board_configs[] =
     { 0x7D25, 6,  0,  0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // PRO Z690-A WIFI DDR4
     { 0x7D27, 6,  0,  0, 2, &zones_set1,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MEG Z690 ACE
     { 0x7D28, 6,  0,  0, 1, &zones_set1,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MEG Z690 UNIFY-X
-    { 0x7D29, 6,  0,  0, 0, &zones_set6,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },      // MEG Z690I UNIFY
+    { 0x7D29, 6,  0,  0, 0, &zones_set6,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MEG Z690I UNIFY
     { 0x7D30, 6,  6,  0, 2, &zones_set3,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MPG Z690 CARBON WIFI
     { 0x7D31, 4,  8,  0, 2, &zones_set12, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MPG EDGE WIFI DDR4
     { 0x7D32, 1,  0,  0, 1, &zones_set10, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG Z690 TOMAHAWK WIFI DDR4
@@ -300,13 +300,16 @@ static const mystic_light_185_config board_configs[] =
     { 0x7D74, 0,  6,  0, 1, &zones_set18, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MPG B650 CARBON WIFI
     { 0x7D75, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG B650 TOMAHAWK WIFI
     { 0x7D76, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG B650M MORTAR WIFI
-    { 0x7D77, 6,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // PRO B650M-A WIFI
+    { 0x7D77, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // PRO B650M-A WIFI
     { 0x7D78, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // PRO B650-P WIFI
     { 0x7D86, 0, 18,  4, 1, &zones_set16, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MEG Z790 ACE
     { 0x7D89, 0,  6,  0, 1, &zones_set4,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MPG Z790 CARBON WIFI
     { 0x7D90, 0,  0,  0, 1, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // B760M BOMBER DDR4
     { 0x7D91, 1,  0,  0, 1, &zones_set10, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG Z790 TOMAHAWK WIFI
+    { 0x7D93, 6,  0,  0, 1, &zones_set2,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // Z790 GAMING PRO WIFI
+    { 0x7D96, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG B760 TOMAHAWK WIFI DDR5
     { 0x7D97, 6,  0,  0, 2, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG B660 MORTAR MAX WIFI DDR4
+    { 0x7D98, 6,  0,  0, 1, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // PRO B760-P WIFI DDR4
     { 0x7D99, 6,  0,  0, 1, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // PRO B760M-A WIFI DDR4
     { 0x7E01, 0,  0,  0, 1, &zones_set11, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG B760M MORTAR MAX
     { 0x7E03, 6,  0,  0, 0, &zones_set6,  MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MPG Z790I EDGE WIFI
@@ -314,6 +317,8 @@ static const mystic_light_185_config board_configs[] =
     { 0x7E07, 0,  0,  0, 2, &zones_set10, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // PRO Z790-A WIFI DDR4
     { 0x7E10, 0,  6,  0, 2, &zones_set17, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MPG B650 EDGE WIFI
     { 0x7E12, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // MAG X670E TOMAHAWK WIFI
+    { 0x7E16, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // X670E GAMING PLUS WIFI
+    { 0x7E24, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // B650M GAMING PLUS WIFI
     { 0x7E26, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // B650 GAMING PLUS WIFI
     { 0x7E27, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // PRO B650M-P
 };
@@ -1052,10 +1057,9 @@ void MSIMysticLight185Controller::ReadName()
     hid_get_manufacturer_string(dev, tname, 256);
 
     /*-----------------------------------------------------*\
-    | Convert wchar_t into std::wstring into std::string    |
+    | Convert to std::string                                |
     \*-----------------------------------------------------*/
-    std::wstring wname = std::wstring(tname);
-    name = std::string(wname.begin(), wname.end());
+    name = StringUtils::wstring_to_string(tname);
 
     /*-----------------------------------------------------*\
     | Get the product string from HID                       |
@@ -1065,8 +1069,7 @@ void MSIMysticLight185Controller::ReadName()
     /*-----------------------------------------------------*\
     | Append the product string to the manufacturer string  |
     \*-----------------------------------------------------*/
-    wname = std::wstring(tname);
-    name.append(" ").append(std::string(wname.begin(), wname.end()));
+    name.append(" ").append(StringUtils::wstring_to_string(tname));
 }
 
 MSI_MODE MSIMysticLight185Controller::GetMode()

Controllers/MSIMysticLightController/MSIMysticLight64Controller/MSIMysticLight64Controller.cpp

@@ -70,10 +70,9 @@ std::string MSIMysticLight64Controller::GetDeviceName()
     hid_get_manufacturer_string(dev, tname, 256);
 
     /*-----------------------------------------------------*\
-    | Convert wchar_t into std::wstring into std::string    |
+    | Convert to std::string                                |
     \*-----------------------------------------------------*/
-    std::wstring wname = std::wstring(tname);
-    std::string name = std::string(wname.begin(), wname.end());
+    std::string name = StringUtils::wstring_to_string(tname);
 
     /*-----------------------------------------------------*\
     | Get the product string from HID                       |
@@ -83,9 +82,9 @@ std::string MSIMysticLight64Controller::GetDeviceName()
     /*-----------------------------------------------------*\
     | Append the product string to the manufacturer string  |
     \*-----------------------------------------------------*/
-    wname = std::wstring(tname);
-    name.append(" ").append(std::string(wname.begin(), wname.end()));
-    return name;
+    name.append(" ").append(StringUtils::wstring_to_string(tname));
+
+    return(name);
 }
 
 std::string MSIMysticLight64Controller::GetFWVersion()

Controllers/MSIMysticLightController/MSIMysticLight64Controller/RGBController_MSIMysticLight64.cpp

@@ -85,7 +85,7 @@ void RGBController_MSIMysticLight64::DeviceUpdateLEDs()
     unsigned int num_colors = 0;
     if(Mode.flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
     {
-        num_colors = Mode.colors.size();
+        num_colors = (unsigned int)Mode.colors.size();
         for(unsigned int i = 0; i < num_colors; i++)
         {
             led_colors[i].R = RGBGetRValue(Mode.colors[i]);

Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp

@@ -182,7 +182,10 @@ REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D86",    DetectMSIMysticLightCont
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D89",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D89,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D90",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D90,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D91",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D91,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D93",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D93,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D96",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D96,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D97",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D97,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D98",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D98,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D99",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7D99,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E01",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7E01,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7E03",    DetectMSIMysticLightControllers,   MSI_USB_VID,    0x7E03,   0x0001, 0x00);

Controllers/NVIDIAIlluminationController/NVIDIAIlluminationControllerDetect_Windows_Linux.cpp

@@ -1,5 +1,5 @@
 /*---------------------------------------------------------*\
-| NVIDIAIlluminationControllerDetect_Windows.cpp            |
+| NVIDIAIlluminationControllerDetect_Windows_Linux.cpp      |
 |                                                           |
 |   Detector for NVIDIA Illumination GPU                    |
 |                                                           |
@@ -15,7 +15,7 @@
 #include "Detector.h"
 #include "LogManager.h"
 #include "RGBController.h"
-#include "RGBController_NVIDIAIllumination_Windows.h"
+#include "RGBController_NVIDIAIllumination_Windows_Linux.h"
 #include "pci_ids.h"
 
 enum
@@ -32,7 +32,7 @@ typedef struct
     int             gpu_rgb_version;
     bool            treats_rgbw_as_rgb;
     const char *    name;
-} gpu_pci_device;
+} nv_gpu_pci_device;
 
 
 #define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
@@ -44,33 +44,35 @@ typedef struct
 #define TREATS_RGBW_AS_RGB  true
 #define TREATS_RGBW_AS_RGBW false
 
-static const gpu_pci_device device_list[] =
+static const nv_gpu_pci_device device_list[] =
 {
-    {NVIDIA_VEN,    NVIDIA_RTX2070S_DEV,            NVIDIA_VEN,     NVIDIA_RTX2070_FE_SUPER_SUB_DEV,                NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 2070 SUPER FE"                  },
-    {NVIDIA_VEN,    NVIDIA_RTX2080_A_DEV,           NVIDIA_VEN,     NVIDIA_RTX2080_FE_SUB_DEV,                      NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 2080 FE"                        },
-    {NVIDIA_VEN,    NVIDIA_RTX2080S_DEV,            NVIDIA_VEN,     NVIDIA_RTX2080S_FE_SUB_DEV,                     NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 2080 FE"                        },
-    {NVIDIA_VEN,    NVIDIA_RTX3050_DEV,             NVIDIA_VEN,     GAINWARD_RTX3050_SUB_DEV,                       NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Gainward RTX 3050 LHR"                     },
-    {NVIDIA_VEN,    NVIDIA_RTX3060_LHR_DEV,         NVIDIA_VEN,     NVIDIA_RTX3060_LHR_DEV,                         NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Palit RTX 3060 LHR"                        },
-    {NVIDIA_VEN,    NVIDIA_RTX3060_LHR_DEV,         PNY_SUB_VEN,    PNY_RTX_3060_XLR8_REVEL_EPIC_X_SUB_DEV,         NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY RTX 3060 XLR8 REVEL EPIC-X"            },
-    {NVIDIA_VEN,    NVIDIA_RTX3060_GA104_DEV,       PNY_SUB_VEN,    PNY_RTX_3060_XLR8_REVEL_EPIC_X_SUB_DEV,         NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY RTX 3060 XLR8 REVEL EPIC-X"            },
-    {NVIDIA_VEN,    NVIDIA_RTX3060_GA104_DEV,       NVIDIA_VEN,     NVIDIA_RTX3060_GA104_DEV,                       NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Palit RTX 3060 LHR (GA104)"                },
-    {NVIDIA_VEN,    NVIDIA_RTX3060TI_LHR_DEV,       PNY_SUB_VEN,    PNY_RTX_3060TI_XLR8_REVEL_EPIC_X_SUB_DEV,       NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY RTX 3060 Ti XLR8 REVEL EPIC-X"         },
-    {NVIDIA_VEN,    NVIDIA_RTX3060TI_LHR_DEV,       NVIDIA_VEN,     PNY_RTX_3060TI_XLR8_REVEL_EPIC_X_SUB_DEV,       NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY RTX 3060 Ti XLR8 REVEL EPIC-X"         },
-    {NVIDIA_VEN,    NVIDIA_RTX3060TI_V1_LHR_DEV,    NVIDIA_VEN,     NVIDIA_RTX3060TI_V1_LHR_DEV,                    NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "NVIDIA RTX 3060 Ti V1 LHR"                 },
-    {NVIDIA_VEN,    NVIDIA_RTX3060TI_LHR_DEV,       NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,                       NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "NVIDIA RTX 3060 Ti LHR"                    },
-    {NVIDIA_VEN,    NVIDIA_RTX3070TI_DEV,           PNY_SUB_VEN,    PNY_RTX_3070TI_XLR8_UPRISING_EPIC_X_SUB_DEV,    NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 3070 Ti XLR8 Uprising EPIC-X"   },
-    {NVIDIA_VEN,    NVIDIA_RTX3080_DEV,             NVIDIA_VEN,     NVIDIA_RTX3080_FE_SUB_DEV,                      NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 3080 FE"                        },
-    {NVIDIA_VEN,    NVIDIA_RTX3080TI_DEV,           NVIDIA_VEN,     NVIDIA_RTX3080TI_FE_SUB_DEV,                    NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 3080 Ti FE"                     },
-    {NVIDIA_VEN,    NVIDIA_RTX3080TI_DEV,           NVIDIA_VEN,     MANLI_RTX3080TI_GALLARDO_SUB_DEV,               NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "MANLI RTX 3080 Ti GALLARDO"                },
-    {NVIDIA_VEN,    NVIDIA_RTX3090_DEV,             NVIDIA_VEN,     NVIDIA_RTX3090_FE_SUB_DEV,                      NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 3090 FE"                        },
-    {NVIDIA_VEN,    NVIDIA_RTX3090TI_DEV,           NVIDIA_VEN,     NVIDIA_RTX3090TI_FE_SUB_DEV,                    NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 3090 Ti FE"                     },
-    {NVIDIA_VEN,    NVIDIA_RTX4070_DEV,             PALIT_SUB_VEN,  PALIT_RTX4070_SUB_DEV,                          NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Palit RTX 4070"                            },
-    {NVIDIA_VEN,    NVIDIA_RTX4070S_DEV,            PALIT_SUB_VEN,  PALIT_RTX4070S_SUB_DEV,                         NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Palit RTX 4070 SUPER Dual"                 },
-    {NVIDIA_VEN,    NVIDIA_RTX4080_DEV,             NVIDIA_VEN,     NVIDIA_RTX4080_FE_SUB_DEV,                      NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 4080 FE"                        },
-    {NVIDIA_VEN,    NVIDIA_RTX4080_DEV,             NVIDIA_VEN,     NVIDIA_RTX4080_FE_SUB_DEV2,                     NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 4080 FE"                        },
-    {NVIDIA_VEN,    NVIDIA_RTX4080S_DEV,            NVIDIA_VEN,     NVIDIA_RTX4080S_FE_SUB_DEV,                     NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 4080 SUPER FE"                  },
-    {NVIDIA_VEN,    NVIDIA_RTX4090_DEV,             NVIDIA_VEN,     NVIDIA_RTX4090_FE_SUB_DEV,                      NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 4090 FE"                        },
-    {NVIDIA_VEN,    NVIDIA_RTX4090_DEV,             NVIDIA_VEN,     NVIDIA_RTX4090_FE_SUB_DEV2,                     NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 4090 FE"                        },
+    {NVIDIA_VEN,    NVIDIA_RTX2070S_DEV,            NVIDIA_VEN,       NVIDIA_RTX2070_FE_SUPER_SUB_DEV,                NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 2070 SUPER FE"                  },
+    {NVIDIA_VEN,    NVIDIA_RTX2080_A_DEV,           NVIDIA_VEN,       NVIDIA_RTX2080_FE_SUB_DEV,                      NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 2080 FE"                        },
+    {NVIDIA_VEN,    NVIDIA_RTX2080S_DEV,            NVIDIA_VEN,       NVIDIA_RTX2080S_FE_SUB_DEV,                     NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 2080 FE"                        },
+    {NVIDIA_VEN,    NVIDIA_RTX3050_DEV,             NVIDIA_VEN,       GAINWARD_RTX3050_SUB_DEV,                       NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Gainward RTX 3050 LHR"                     },
+    {NVIDIA_VEN,    NVIDIA_RTX3060_LHR_DEV,         NVIDIA_VEN,       NVIDIA_RTX3060_LHR_DEV,                         NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Palit RTX 3060 LHR"                        },
+    {NVIDIA_VEN,    NVIDIA_RTX3060_LHR_DEV,         PNY_SUB_VEN,      PNY_RTX_3060_XLR8_REVEL_EPIC_X_SUB_DEV,         NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY RTX 3060 XLR8 REVEL EPIC-X"            },
+    {NVIDIA_VEN,    NVIDIA_RTX3060_GA104_DEV,       PNY_SUB_VEN,      PNY_RTX_3060_XLR8_REVEL_EPIC_X_SUB_DEV,         NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY RTX 3060 XLR8 REVEL EPIC-X"            },
+    {NVIDIA_VEN,    NVIDIA_RTX3060_GA104_DEV,       NVIDIA_VEN,       NVIDIA_RTX3060_GA104_DEV,                       NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Palit RTX 3060 LHR (GA104)"                },
+    {NVIDIA_VEN,    NVIDIA_RTX3060TI_LHR_DEV,       PNY_SUB_VEN,      PNY_RTX_3060TI_XLR8_REVEL_EPIC_X_SUB_DEV,       NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY RTX 3060 Ti XLR8 REVEL EPIC-X"         },
+    {NVIDIA_VEN,    NVIDIA_RTX3060TI_LHR_DEV,       NVIDIA_VEN,       PNY_RTX_3060TI_XLR8_REVEL_EPIC_X_SUB_DEV,       NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "PNY RTX 3060 Ti XLR8 REVEL EPIC-X"         },
+    {NVIDIA_VEN,    NVIDIA_RTX3060TI_V1_LHR_DEV,    NVIDIA_VEN,       NVIDIA_RTX3060TI_V1_LHR_DEV,                    NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "NVIDIA RTX 3060 Ti V1 LHR"                 },
+    {NVIDIA_VEN,    NVIDIA_RTX3060TI_LHR_DEV,       NVIDIA_VEN,       NVIDIA_RTX3060TI_LHR_DEV,                       NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "NVIDIA RTX 3060 Ti LHR"                    },
+    {NVIDIA_VEN,    NVIDIA_RTX3070TI_DEV,           PNY_SUB_VEN,      PNY_RTX_3070TI_XLR8_UPRISING_EPIC_X_SUB_DEV,    NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 3070 Ti XLR8 Uprising EPIC-X"   },
+    {NVIDIA_VEN,    NVIDIA_RTX3080_DEV,             NVIDIA_VEN,       NVIDIA_RTX3080_FE_SUB_DEV,                      NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 3080 FE"                        },
+    {NVIDIA_VEN,    NVIDIA_RTX3080TI_DEV,           NVIDIA_VEN,       NVIDIA_RTX3080TI_FE_SUB_DEV,                    NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 3080 Ti FE"                     },
+    {NVIDIA_VEN,    NVIDIA_RTX3080TI_DEV,           NVIDIA_VEN,       MANLI_RTX3080TI_GALLARDO_SUB_DEV,               NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "MANLI RTX 3080 Ti GALLARDO"                },
+    {NVIDIA_VEN,    NVIDIA_RTX3090_DEV,             NVIDIA_VEN,       NVIDIA_RTX3090_FE_SUB_DEV,                      NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 3090 FE"                        },
+    {NVIDIA_VEN,    NVIDIA_RTX3090TI_DEV,           NVIDIA_VEN,       NVIDIA_RTX3090TI_FE_SUB_DEV,                    NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 3090 Ti FE"                     },
+    {NVIDIA_VEN,    NVIDIA_RTX4060_DEV,             PALIT_SUB_VEN,    PALIT_RTX4060_SUB_DEV,                          NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Palit RTX 4060 Dual"                       },
+    {NVIDIA_VEN,    NVIDIA_RTX4070_DEV,             PALIT_SUB_VEN,    PALIT_RTX4070_SUB_DEV,                          NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Palit RTX 4070"                            },
+    {NVIDIA_VEN,    NVIDIA_RTX4070S_DEV,            PALIT_SUB_VEN,    PALIT_RTX4070S_SUB_DEV,                         NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGB,     "Palit RTX 4070 SUPER Dual"                 },
+    {NVIDIA_VEN,    NVIDIA_RTX4070_DEV,             GAINWARD_SUB_VEN, GAINWARD_RTX_4070_GHOST_SUB_DEV,                NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "Gainward 4070 Ghost"                       },
+    {NVIDIA_VEN,    NVIDIA_RTX4080_DEV,             NVIDIA_VEN,       NVIDIA_RTX4080_FE_SUB_DEV,                      NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 4080 FE"                        },
+    {NVIDIA_VEN,    NVIDIA_RTX4080_DEV,             NVIDIA_VEN,       NVIDIA_RTX4080_FE_SUB_DEV2,                     NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 4080 FE"                        },
+    {NVIDIA_VEN,    NVIDIA_RTX4080S_DEV,            NVIDIA_VEN,       NVIDIA_RTX4080S_FE_SUB_DEV,                     NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 4080 SUPER FE"                  },
+    {NVIDIA_VEN,    NVIDIA_RTX4090_DEV,             NVIDIA_VEN,       NVIDIA_RTX4090_FE_SUB_DEV,                      NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 4090 FE"                        },
+    {NVIDIA_VEN,    NVIDIA_RTX4090_DEV,             NVIDIA_VEN,       NVIDIA_RTX4090_FE_SUB_DEV2,                     NVIDIA_ILLUMINATION_V1,     TREATS_RGBW_AS_RGBW,    "NVIDIA RTX 4090 FE"                        },
 };
 
 void DetectNVIDIAIllumGPUs()

Controllers/NVIDIAIlluminationController/NVIDIAIlluminationV1Controller_Windows_Linux.cpp

@@ -1,5 +1,5 @@
 /*---------------------------------------------------------*\
-| NVIDIAIlluminationV1Controller_Windows.cpp                |
+| NVIDIAIlluminationV1Controller_Windows_Linux.cpp          |
 |                                                           |
 |   Driver for NVIDIA Illumination V1 GPU                   |
 |                                                           |
@@ -9,7 +9,7 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/
 
-#include "NVIDIAIlluminationV1Controller_Windows.h"
+#include "NVIDIAIlluminationV1Controller_Windows_Linux.h"
 
 NVIDIAIlluminationV1Controller::NVIDIAIlluminationV1Controller(nvapi_accessor* nvapi_ptr, bool treats_rgbw_as_rgb)
 {

Controllers/NVIDIAIlluminationController/NVIDIAIlluminationV1Controller_Windows_Linux.h

@@ -1,5 +1,5 @@
 /*---------------------------------------------------------*\
-| NVIDIAIlluminationV1Controller_Windows.h                  |
+| NVIDIAIlluminationV1Controller_Windows_Linux.h            |
 |                                                           |
 |   Driver for NVIDIA Illumination V1 GPU                   |
 |                                                           |
@@ -14,7 +14,7 @@
 #include <cstring>
 #include <string>
 #include <vector>
-#include "nvapi_accessor_Windows.h"
+#include "nvapi_accessor_Windows_Linux.h"
 #include "RGBController.h"
 #include "LogManager.h"
 

Controllers/NVIDIAIlluminationController/RGBController_NVIDIAIllumination_Windows_Linux.cpp

@@ -1,5 +1,5 @@
 /*---------------------------------------------------------*\
-| RGBController_NVIDIAIllumination.cpp                      |
+| RGBController_NVIDIAIllumination_Windows_Linux.cpp        |
 |                                                           |
 |   RGBController for NVIDIA Illumination GPU               |
 |                                                           |
@@ -10,7 +10,7 @@
 \*---------------------------------------------------------*/
 
 #include <array>
-#include "RGBController_NVIDIAIllumination_Windows.h"
+#include "RGBController_NVIDIAIllumination_Windows_Linux.h"
 
 /**------------------------------------------------------------------*\
     @name NVIDIA Illumination

Controllers/NVIDIAIlluminationController/RGBController_NVIDIAIllumination_Windows_Linux.h

@@ -1,5 +1,5 @@
 /*---------------------------------------------------------*\
-| RGBController_NVIDIAIllumination.h                        |
+| RGBController_NVIDIAIllumination_Windows_Linux.h          |
 |                                                           |
 |   RGBController for NVIDIA Illumination GPU               |
 |                                                           |
@@ -13,7 +13,7 @@
 
 #include <map>
 #include "RGBController.h"
-#include "NVIDIAIlluminationV1Controller_Windows.h"
+#include "NVIDIAIlluminationV1Controller_Windows_Linux.h"
 
 #define NVIDIA_FOUNDERS_V1_CONTROLLER_NAME   "NVIDIA_FOUNDERS_V1"
 

Controllers/NVIDIAIlluminationController/nvapi_accessor_Windows_Linux.cpp

@@ -1,5 +1,5 @@
 /*---------------------------------------------------------*\
-| nvapi_accessor_Windows.cpp                                |
+| nvapi_accessor_Windows_Linux.cpp                          |
 |                                                           |
 |   NVAPI accessor for NVIDIA NVAPI illumination API        |
 |                                                           |
@@ -11,7 +11,7 @@
 
 #include <chrono>
 #include <thread>
-#include "nvapi_accessor_Windows.h"
+#include "nvapi_accessor_Windows_Linux.h"
 
 nvapi_accessor::nvapi_accessor(NV_PHYSICAL_GPU_HANDLE handle)
 {

Controllers/NVIDIAIlluminationController/nvapi_accessor_Windows_Linux.h

@@ -1,5 +1,5 @@
 /*---------------------------------------------------------*\
-| nvapi_accessor_Windows.h                                  |
+| nvapi_accessor_Windows_Linux.h                            |
 |                                                           |
 |   NVAPI accessor for NVIDIA NVAPI illumination API        |
 |                                                           |

Controllers/NZXTHue2Controller/FanController_NZXTHue2.cpp

@@ -0,0 +1,55 @@
+/*-----------------------------------------*\
+|  FanController_NZXTHue2.cpp               |
+|                                           |
+|  Generic Fan Interface for NZXT Hue 2     |
+|  (Smart Device V2, Fan & RGB) controller  |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/22/2020   |
+\*-----------------------------------------*/
+
+#include "FanController_NZXTHue2.h"
+
+FanController_NZXTHue2::FanController_NZXTHue2(NZXTHue2Controller* hue2_ptr)
+{
+    hue2 = hue2_ptr;
+
+    name        = "NZXT Hue 2 Device";
+    description = "NZXT Hue 2 Device";
+    version     = hue2->GetFirmwareVersion();
+
+    for(std::size_t fan_index = 0; fan_index < hue2->GetNumFanChannels(); fan_index++)
+    {
+        fan new_fan;
+
+        hue2->UpdateStatus();
+
+        new_fan.name        = "NZXT Fan ";
+        new_fan.name.append(std::to_string(fan_index + 1));
+        new_fan.speed_min   = 0;
+        new_fan.speed_max   = 100;
+        new_fan.speed_cmd   = hue2->GetFanCommand(fan_index);
+        new_fan.rpm_rdg     = hue2->GetFanRPM(fan_index);
+
+        fans.push_back(new_fan);
+    }
+
+    UpdateControl();
+}
+
+void FanController_NZXTHue2::UpdateControl()
+{
+    for(std::size_t fan_index = 0; fan_index < fans.size(); fan_index++)
+    {
+        hue2->SendFan(fan_index, 0, fans[fan_index].speed_cmd);
+    }
+}
+
+void FanController_NZXTHue2::UpdateReading()
+{
+    hue2->UpdateStatus();
+
+    for(std::size_t fan_index = 0; fan_index < fans.size(); fan_index++)
+    {
+        fans[fan_index].rpm_rdg = hue2->GetFanRPM(fan_index);
+    }
+}

Controllers/NZXTHue2Controller/FanController_NZXTHue2.h

@@ -0,0 +1,24 @@
+/*-----------------------------------------*\
+|  FanController_NZXTHue2.h                 |
+|                                           |
+|  Generic Fan Interface for NZXT Hue 2     |
+|  (Smart Device V2, Fan & RGB) controller  |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/22/2020   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "FanController.h"
+#include "NZXTHue2Controller.h"
+
+class FanController_NZXTHue2 : public FanController
+{
+public:
+    FanController_NZXTHue2(NZXTHue2Controller* hue2_ptr);
+
+    void        UpdateControl();
+    void        UpdateReading();
+
+private:
+    NZXTHue2Controller* hue2;
+};

Controllers/NZXTHue2Controller/NZXTHue2Controller.cpp

@@ -30,6 +30,48 @@ NZXTHue2Controller::NZXTHue2Controller(hid_device* dev_handle, unsigned int rgb_
 
     fan_cmd.resize(num_fan_channels);
     fan_rpm.resize(num_fan_channels);
+
+    unsigned char usb_buf[64];
+    unsigned int  ret_val = 0;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Fan Reporting Interval packet                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x60;
+    usb_buf[0x01]   = 0x02;
+    usb_buf[0x02]   = 0x01;
+    usb_buf[0x03]   = 0xE8;
+    usb_buf[0x04]   = 0x03;
+    usb_buf[0x05]   = 0x01;
+    usb_buf[0x06]   = 0xE8;
+    usb_buf[0x07]   = 0x03;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 64);
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Enable Fan Reporting packet                    |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x60;
+    usb_buf[0x01]   = 0x03;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 64);
+
     UpdateStatus();
 }
 
@@ -249,7 +291,7 @@ void NZXTHue2Controller::UpdateStatus()
     unsigned char usb_buf[64];
     unsigned int  ret_val = 0;
 
-    if(false)//num_fan_channels > 0)
+    if(num_fan_channels > 0)
     {
         /*-----------------------------------------------------*\
         | Zero out buffer                                       |

Controllers/NZXTHue2Controller/NZXTHue2ControllerDetect.cpp

@@ -12,6 +12,8 @@
 #include <hidapi.h>
 #include "Detector.h"
 #include "NZXTHue2Controller.h"
+#include "FanController.h"
+#include "FanController_NZXTHue2.h"
 #include "RGBController.h"
 #include "RGBController_NZXTHue2.h"
 
@@ -45,6 +47,13 @@ static void spawn_hue(hid_device_info* info, const std::string& name, int rgb_ch
         rgb_controller->name                   = name;
 
         ResourceManager::get()->RegisterRGBController(rgb_controller);
+
+        if(fan_channels > 0)
+        {
+            FanController_NZXTHue2* fan_controller = new FanController_NZXTHue2(controller);
+            fan_controller->name = name;
+            ResourceManager::get()->RegisterFanController(fan_controller);
+        }
     }
 }
 

Controllers/NZXTKrakenController/FanController_NZXTKraken.cpp

@@ -0,0 +1,71 @@
+/*-----------------------------------------*\
+|  FanController_NZXTKraken.cpp             |
+|                                           |
+|  Generic Fan Interface for NZXT Kraken    |
+|                                           |
+|  swilde 5/2021                            |
+\*-----------------------------------------*/
+
+#include "FanController_NZXTKraken.h"
+
+FanController_NZXTKraken::FanController_NZXTKraken(NZXTKrakenController* kraken_ptr)
+{
+    kraken      = kraken_ptr;
+
+    name        = "NZXT Kraken X2";
+    description = "NZXT Kraken X42/X52/X62/X72";
+    version     = kraken->GetFirmwareVersion();
+    location    = kraken->GetLocation();
+    serial      = kraken->GetSerialString();
+
+    kraken->UpdateStatus();
+
+    fan new_fan;
+
+    /*---------------------------------------------------------*\
+    | Add fan                                                   |
+    | X52 has a max fan RPM of 200, the X42 and X62 max is 1800 |
+    \*---------------------------------------------------------*/
+    new_fan.name        = "NZXT Kraken Fan";
+    new_fan.speed_min   = 25;
+    new_fan.speed_max   = 100;
+    new_fan.speed_cmd   = 100 * kraken->fan_speed / 2000;
+    new_fan.prev_speed_cmd = 0;
+    new_fan.rpm_rdg     = kraken->fan_speed;
+    fans.push_back(new_fan);
+
+    /*---------------------------------------------------------*\
+    | Add pump                                                  |
+    \*---------------------------------------------------------*/
+    new_fan.name        = "NZXT Kraken Pump";
+    new_fan.speed_min   = 50;
+    new_fan.speed_max   = 100;
+    new_fan.speed_cmd   = 100 * kraken->pump_speed / 2800;
+    new_fan.prev_speed_cmd = 0;
+    new_fan.rpm_rdg     = kraken->pump_speed;
+    fans.push_back(new_fan);
+
+    UpdateControl();
+}
+
+void FanController_NZXTKraken::UpdateControl()
+{
+    if(fans[0].speed_cmd != fans[0].prev_speed_cmd)
+    {
+        kraken->SetSpeed(NZXT_KRAKEN_CHANNEL_FAN, fans[0].speed_cmd);
+        fans[0].prev_speed_cmd = fans[0].speed_cmd;
+    }
+    if(fans[1].speed_cmd != fans[1].prev_speed_cmd)
+    {
+        kraken->SetSpeed(NZXT_KRAKEN_CHANNEL_PUMP, fans[1].speed_cmd);
+        fans[1].prev_speed_cmd = fans[1].speed_cmd;
+    }
+}
+
+void FanController_NZXTKraken::UpdateReading()
+{
+    kraken->UpdateStatus();
+
+    fans[0].rpm_rdg = kraken->fan_speed;
+    fans[1].rpm_rdg = kraken->pump_speed;
+}

Controllers/NZXTKrakenController/FanController_NZXTKraken.h

@@ -0,0 +1,23 @@
+/*-----------------------------------------*\
+|  FanController_NZXTKraken.h               |
+|                                           |
+|  Generic Fan Interface for NZXT Kraken    |
+|                                           |
+|  swilde 5/2021                            |
+\*-----------------------------------------*/
+
+#pragma once
+#include "FanController.h"
+#include "NZXTKrakenController.h"
+
+class FanController_NZXTKraken : public FanController
+{
+public:
+    FanController_NZXTKraken(NZXTKrakenController* kraken_ptr);
+
+    void        UpdateControl();
+    void        UpdateReading();
+
+private:
+    NZXTKrakenController* kraken;
+};

Controllers/NZXTKrakenController/NZXTKrakenController.cpp

@@ -41,6 +41,9 @@ NZXTKrakenController::NZXTKrakenController(hid_device* dev_handle, const char* p
     | Get the firmware version                              |
     \*-----------------------------------------------------*/
     UpdateStatus();
+
+    int major_firmware_version = std::stoi(firmware_version.substr(0, firmware_version.find(".")));
+    supports_cooling_profiles = major_firmware_version >= 3;
 }
 
 NZXTKrakenController::~NZXTKrakenController()
@@ -196,3 +199,135 @@ void NZXTKrakenController::SendEffect
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 64);
 }
+
+void NZXTKrakenController::SetSpeed(unsigned char channel, unsigned int speed_cmd)
+{
+    unsigned char duty;
+
+    /*-----------------------------------------------------*\
+    | Verify channel                                        |
+    \*-----------------------------------------------------*/
+    if(channel == NZXT_KRAKEN_CHANNEL_FAN)
+    {
+        duty = std::max((unsigned char) 25, std::min((unsigned char) 100, (unsigned char) speed_cmd));
+    }
+    else if(channel == NZXT_KRAKEN_CHANNEL_PUMP)
+    {
+        duty = std::max((unsigned char) 50, std::min((unsigned char) 100, (unsigned char) speed_cmd));
+    }
+    else
+    {
+        return;
+    }
+
+    /*-----------------------------------------------------*\
+    | Write speed                                           |
+    \*-----------------------------------------------------*/
+    if(supports_cooling_profiles)
+    {
+        SetFixedSpeedProfile(channel, duty);
+    }
+    else
+    {
+        SetInstantaneousSpeed(channel, duty);
+    }
+}
+
+void NZXTKrakenController::SetFixedSpeedProfile(unsigned char channel, unsigned char duty)
+{
+    unsigned char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set to fan write                                      |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x02;
+    usb_buf[0x01]   = 0x4d;
+
+    usb_buf[0x02]   = channel;
+
+    /*-----------------------------------------------------*\
+    | Generate steps                                        |
+    \*-----------------------------------------------------*/
+    unsigned char temps[36];
+    for(int i = 0; i < 30; i++)
+    {
+        temps[i] = 20 + i;
+    }
+    for(int i = 0; i <= 5; i++)
+    {
+        temps[30 + i] = 50 + 2*i;
+    }
+
+    /*-----------------------------------------------------*\
+    | Write temp speed pairs                                |
+    \*-----------------------------------------------------*/
+    unsigned char curr_duty = duty;
+    for(int i = 0; i < 36; i++)
+    {
+        if(temps[i] == 60)
+        {
+            curr_duty = 100;
+        }
+
+        /*-----------------------------------------------------*\
+        | Set channel and index                                 |
+        \*-----------------------------------------------------*/
+        usb_buf[0x02]   = channel + i;
+
+        /*-----------------------------------------------------*\
+        | Set temp                                              |
+        \*-----------------------------------------------------*/
+        usb_buf[0x03]   = temps[i];
+
+        /*-----------------------------------------------------*\
+        | Set duty                                              |
+        \*-----------------------------------------------------*/
+        usb_buf[0x04]   = curr_duty;
+
+        /*-----------------------------------------------------*\
+        | Write speed                                           |
+        \*-----------------------------------------------------*/
+        hid_write(dev, usb_buf, 64);
+    }
+}
+
+void NZXTKrakenController::SetInstantaneousSpeed(unsigned char channel, unsigned char duty)
+{
+    unsigned char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set to fan write                                      |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x02;
+    usb_buf[0x01]   = 0x4d;
+
+    /*-----------------------------------------------------*\
+    | Set channel                                           |
+    \*-----------------------------------------------------*/
+    usb_buf[0x02]   = channel;
+
+    /*-----------------------------------------------------*\
+    | Set temp (0 for instantaneous speed)                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x03]   = 0;
+
+    /*-----------------------------------------------------*\
+    | Set duty                                              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x04]   = duty;
+
+    /*-----------------------------------------------------*\
+    | Write speed                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 64);
+}

Controllers/NZXTKrakenController/NZXTKrakenController.h

@@ -48,6 +48,12 @@ enum
     NZXT_KRAKEN_SPEED_FASTEST           = 0x04, /* Fastest speed                */
 };
 
+enum
+{
+    NZXT_KRAKEN_CHANNEL_FAN             = 0x80, /* Fan channel                  */
+    NZXT_KRAKEN_CHANNEL_PUMP            = 0xc0, /* Pump channel                 */
+};
+
 class NZXTKrakenController
 {
 public:
@@ -58,6 +64,12 @@ public:
     std::string GetLocation();
     std::string GetSerialString();
 
+    void SetSpeed
+        (
+        unsigned char   channel,
+        unsigned int    speed_cmd
+        );
+
     void UpdateEffect
         (
         NZXTKrakenChannel_t channel,
@@ -68,9 +80,12 @@ public:
         std::vector<RGBColor> colors
         );
 
-private:
     void UpdateStatus();
 
+    unsigned int            fan_speed;
+    unsigned int            pump_speed;
+
+private:
     void SendEffect
         (
         unsigned char   channel,
@@ -83,12 +98,23 @@ private:
         int             size = 0
         );
 
+    void SetFixedSpeedProfile
+        (
+        unsigned char   channel,
+        unsigned char   duty
+        );
+    void SetInstantaneousSpeed
+        (
+        unsigned char   channel,
+        unsigned char   duty
+        );
+
     hid_device*   dev;
 
     // -- status
     std::string             firmware_version;
     double                  liquid_temperature;
     std::string             location;
-    unsigned int            fan_speed;
-    unsigned int            pump_speed;
+
+    bool                    supports_cooling_profiles;
 };

Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp

@@ -13,6 +13,7 @@
 #include <hidapi.h>
 #include "Detector.h"
 #include "NZXTKrakenController.h"
+#include "FanController_NZXTKraken.h"
 #include "RGBController.h"
 #include "RGBController_NZXTKraken.h"
 
@@ -37,6 +38,17 @@ void DetectNZXTKrakenControllers(hid_device_info* info, const std::string& name)
         RGBController_NZXTKraken* rgb_controller = new RGBController_NZXTKraken(controller);
         rgb_controller->name = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
+
+        if(info->product_id == NZXT_KRAKEN_X2_PID)
+        {
+            /*---------------------------------------------*\
+            | Kraken M22 doesn't have liquid temp sensor or |
+            | ability to report or set fan or pump speeds   |
+            \*---------------------------------------------*/
+            FanController_NZXTKraken* fan_controller = new FanController_NZXTKraken(controller);
+            fan_controller->name = name;
+            ResourceManager::get()->RegisterFanController(fan_controller);
+        }
     }
 }   /* DetectNZXTKrakenControllers() */
 

Controllers/QMKOpenRGBController/QMKOpenRGBRev9Controller/RGBController_QMKOpenRGBRev9.cpp

@@ -571,8 +571,8 @@ void RGBController_QMKOpenRGBRev9::PlaceLEDsInMaps
         VectorMatrix&               underglow_map_xl
      )
 {
-    matrix_map_xl                   = MakeEmptyMatrixMap(unique_rows.size(), std::round(255/divisor) + 10);
-    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), std::round(255/divisor) + 10);
+    matrix_map_xl                   = MakeEmptyMatrixMap(unique_rows.size(), (std::size_t)(std::round(255 / divisor) + 10));
+    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), (std::size_t)(std::round(255 / divisor) + 10));
 
     unsigned int x                  = 0;
     unsigned int y                  = 0;
@@ -584,8 +584,8 @@ void RGBController_QMKOpenRGBRev9::PlaceLEDsInMaps
         {
             bool underglow          = led_flags[i] & 2;
 
-            x                       = std::round(led_points[i].x/divisor);
-            y                       = std::distance(unique_rows.begin(), unique_rows.find(led_points[i].y));
+            x                       = (unsigned int)(std::round(led_points[i].x / divisor));
+            y                       = (unsigned int)(std::distance(unique_rows.begin(), unique_rows.find(led_points[i].y)));
 
             if(!underglow)
             {
@@ -612,14 +612,14 @@ void RGBController_QMKOpenRGBRev9::PlaceLEDsInMaps
 
 VectorMatrix RGBController_QMKOpenRGBRev9::MakeEmptyMatrixMap
     (
-        unsigned int height,
-        unsigned int width
+        std::size_t height,
+        std::size_t width
     )
 {
     std::vector<std::vector<unsigned int> > matrix_map(height);
-    for (unsigned int i = 0; i < height; i++)
+    for(std::size_t i = 0; i < height; i++)
     {
-        for (unsigned int j = 0; j < width; j++)
+        for(std::size_t j = 0; j < width; j++)
         {
             matrix_map[i].push_back(NO_LED);
         }

Controllers/QMKOpenRGBController/QMKOpenRGBRev9Controller/RGBController_QMKOpenRGBRev9.h

@@ -80,8 +80,8 @@ private:
 
     VectorMatrix                            MakeEmptyMatrixMap
                                             (
-                                            unsigned int height,
-                                            unsigned int width
+                                                std::size_t height,
+                                                std::size_t width
                                             );
 
     void                                    CleanMatrixMaps

Controllers/QMKOpenRGBController/QMKOpenRGBRevBController/RGBController_QMKOpenRGBRevB.cpp

@@ -612,8 +612,8 @@ void RGBController_QMKOpenRGBRevB::PlaceLEDsInMaps
         VectorMatrix&               underglow_map_xl
      )
 {
-    matrix_map_xl                   = MakeEmptyMatrixMap(unique_rows.size(), std::round(255/divisor) + 10);
-    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), std::round(255/divisor) + 10);
+    matrix_map_xl                   = MakeEmptyMatrixMap(unique_rows.size(), (std::size_t)(std::round(255 / divisor) + 10));
+    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), (std::size_t)(std::round(255 / divisor) + 10));
 
     unsigned int x                  = 0;
     unsigned int y                  = 0;
@@ -625,8 +625,8 @@ void RGBController_QMKOpenRGBRevB::PlaceLEDsInMaps
         {
             bool underglow          = led_flags[i] & 2;
 
-            x                       = std::round(led_points[i].x/divisor);
-            y                       = std::distance(unique_rows.begin(), unique_rows.find(led_points[i].y));
+            x                       = (unsigned int)(std::round(led_points[i].x / divisor));
+            y                       = (unsigned int)(std::distance(unique_rows.begin(), unique_rows.find(led_points[i].y)));
 
             if(!underglow)
             {
@@ -653,14 +653,14 @@ void RGBController_QMKOpenRGBRevB::PlaceLEDsInMaps
 
 VectorMatrix RGBController_QMKOpenRGBRevB::MakeEmptyMatrixMap
     (
-        unsigned int height,
-        unsigned int width
+        std::size_t height,
+        std::size_t width
     )
 {
     std::vector<std::vector<unsigned int> > matrix_map(height);
-    for (unsigned int i = 0; i < height; i++)
+    for(std::size_t i = 0; i < height; i++)
     {
-        for (unsigned int j = 0; j < width; j++)
+        for(std::size_t j = 0; j < width; j++)
         {
             matrix_map[i].push_back(NO_LED);
         }

Controllers/QMKOpenRGBController/QMKOpenRGBRevBController/RGBController_QMKOpenRGBRevB.h

@@ -82,8 +82,8 @@ private:
 
     VectorMatrix                            MakeEmptyMatrixMap
                                             (
-                                            unsigned int height,
-                                            unsigned int width
+                                                std::size_t height,
+                                                std::size_t width
                                             );
 
     void                                    CleanMatrixMaps

Controllers/QMKOpenRGBController/QMKOpenRGBRevDController/RGBController_QMKOpenRGBRevD.cpp

@@ -613,8 +613,8 @@ void RGBController_QMKOpenRGBRevD::PlaceLEDsInMaps
         VectorMatrix&               underglow_map_xl
      )
 {
-    matrix_map_xl                   = MakeEmptyMatrixMap(unique_rows.size(), std::round(255/divisor) + 10);
-    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), std::round(255/divisor) + 10);
+    matrix_map_xl                   = MakeEmptyMatrixMap(unique_rows.size(), (std::size_t)(std::round(255 / divisor) + 10));
+    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), (std::size_t)(std::round(255 / divisor) + 10));
 
     unsigned int x                  = 0;
     unsigned int y                  = 0;
@@ -626,8 +626,8 @@ void RGBController_QMKOpenRGBRevD::PlaceLEDsInMaps
         {
             bool underglow          = led_flags[i] & 2;
 
-            x                       = std::round(led_points[i].x/divisor);
-            y                       = std::distance(unique_rows.begin(), unique_rows.find(led_points[i].y));
+            x                       = (unsigned int)(std::round(led_points[i].x / divisor));
+            y                       = (unsigned int)(std::distance(unique_rows.begin(), unique_rows.find(led_points[i].y)));
 
             if(!underglow)
             {
@@ -654,14 +654,14 @@ void RGBController_QMKOpenRGBRevD::PlaceLEDsInMaps
 
 VectorMatrix RGBController_QMKOpenRGBRevD::MakeEmptyMatrixMap
     (
-        unsigned int height,
-        unsigned int width
+        std::size_t height,
+        std::size_t width
     )
 {
     std::vector<std::vector<unsigned int> > matrix_map(height);
-    for (unsigned int i = 0; i < height; i++)
+    for(std::size_t i = 0; i < height; i++)
     {
-        for (unsigned int j = 0; j < width; j++)
+        for(std::size_t j = 0; j < width; j++)
         {
             matrix_map[i].push_back(NO_LED);
         }

Controllers/QMKOpenRGBController/QMKOpenRGBRevDController/RGBController_QMKOpenRGBRevD.h

@@ -81,8 +81,8 @@ private:
 
     VectorMatrix                            MakeEmptyMatrixMap
                                             (
-                                            unsigned int height,
-                                            unsigned int width
+                                                std::size_t height,
+                                                std::size_t width
                                             );
 
     void                                    CleanMatrixMaps

Controllers/QMKOpenRGBController/QMKOpenRGBRevEController/RGBController_QMKOpenRGBRevE.cpp

@@ -629,8 +629,8 @@ void RGBController_QMKOpenRGBRevE::PlaceLEDsInMaps
         VectorMatrix&               underglow_map_xl
      )
 {
-    matrix_map_xl                   = MakeEmptyMatrixMap(unique_rows.size(), std::round(255/divisor) + 10);
-    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), std::round(255/divisor) + 10);
+    matrix_map_xl                   = MakeEmptyMatrixMap(unique_rows.size(), (std::size_t)(std::round(255 / divisor) + 10));
+    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), (std::size_t)(std::round(255 / divisor) + 10));
 
     unsigned int x                  = 0;
     unsigned int y                  = 0;
@@ -642,8 +642,8 @@ void RGBController_QMKOpenRGBRevE::PlaceLEDsInMaps
         {
             bool underglow          = led_flags[i] & 2;
 
-            x                       = std::round(led_points[i].x/divisor);
-            y                       = std::distance(unique_rows.begin(), unique_rows.find(led_points[i].y));
+            x                       = (unsigned int)(std::round(led_points[i].x / divisor));
+            y                       = (unsigned int)(std::distance(unique_rows.begin(), unique_rows.find(led_points[i].y)));
 
             if(!underglow)
             {
@@ -670,14 +670,14 @@ void RGBController_QMKOpenRGBRevE::PlaceLEDsInMaps
 
 VectorMatrix RGBController_QMKOpenRGBRevE::MakeEmptyMatrixMap
     (
-        unsigned int height,
-        unsigned int width
+        std::size_t height,
+        std::size_t width
     )
 {
     std::vector<std::vector<unsigned int> > matrix_map(height);
-    for (unsigned int i = 0; i < height; i++)
+    for(std::size_t i = 0; i < height; i++)
     {
-        for (unsigned int j = 0; j < width; j++)
+        for(std::size_t j = 0; j < width; j++)
         {
             matrix_map[i].push_back(NO_LED);
         }