Initial commit for Raspberry Pi GPIO ARGB controller

.gitlab-ci.yml

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

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -57,7 +57,6 @@ 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,7 +19,6 @@
 | 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,7 +109,6 @@ 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,    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,
+        /* 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,
         /* 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,8 +31,7 @@ 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
-    { 0x0E0A,   4 }     // Dell G15   5530
+    { 0x0E03,   4 }     // Dell G15   5511
 
 };
 
@@ -48,8 +47,7 @@ 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"    } },
-    { 0x0E0A,   { "Left",           "Middle",       "Right",        "Numpad"    } }
+    { 0x0E03,   { "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,8 +20,7 @@
 /*---------------------------------------------------------*\
 | Alienware product ID                                      |
 \*---------------------------------------------------------*/
-#define ALIENWARE_G_SERIES_PID1                      0x0550
-#define ALIENWARE_G_SERIES_PID2                      0x0551
+#define ALIENWARE_G_SERIES_PID                      0x0550
 
 void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
 {
@@ -36,5 +35,4 @@ void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
     }
 }
 
-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);
+REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID);

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

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

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.cpp

@@ -10,10 +10,45 @@
 \*---------------------------------------------------------*/
 
 #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",
@@ -32,40 +67,20 @@ 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;
 
     /*---------------------------------------------------------*\
-    | The motherboard name will uniquely ID the laptop to       |
-    |   determine the metadata of the device.                   |
+    | Get device name from HID manufacturer and product strings |
     \*---------------------------------------------------------*/
-    DMIInfo dmi_info;
-    std::string dmi_name    = dmi_info.getMainboard();
-    bool not_found          = true;
+    wchar_t name_string[HID_MAX_STR];
 
-    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_manufacturer_string(dev, name_string, HID_MAX_STR);
+    device_name = 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;
-    }
+    hid_get_product_string(dev, name_string, HID_MAX_STR);
+    device_name.append(" ").append(StringUtils::wstring_to_string(name_string));
 
-    /*---------------------------------------------------------*\
-    | Only set power config for known devices                   |
-    \*---------------------------------------------------------*/
     SetPowerConfigFromJSON();
 }
 
@@ -74,66 +89,9 @@ AsusAuraCoreLaptopController::~AsusAuraCoreLaptopController()
     hid_close(dev);
 }
 
-const aura_core_laptop_device* AsusAuraCoreLaptopController::GetDeviceData()
+std::string AsusAuraCoreLaptopController::GetDeviceName()
 {
-    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;
+    return device_name;
 }
 
 std::string AsusAuraCoreLaptopController::GetSerial()
@@ -143,8 +101,6 @@ 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("");
     }
 
@@ -176,50 +132,35 @@ 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::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)
+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                               = colors.size();
-    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                                = 178;
+    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                                 = new uint8_t[map_size];
+    uint8_t key_buf[map_size];
 
     memset(key_buf, 0, map_size);
 
-    for(size_t led_index = 0; led_index < led_count; led_index++)
+    for(size_t led_index = 0; led_index < colors.size(); led_index++)
     {
-        std::size_t buf_idx     = (led_index * 3);
+        uint16_t offset         = 3 * packet_map[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]);
+        key_buf[offset]         = RGBGetRValue(colors[led_index]);
+        key_buf[offset + 1]     = RGBGetGValue(colors[led_index]);
+        key_buf[offset + 2]     = RGBGetBValue(colors[led_index]);
     }
 
     for(size_t i = 0; i < key_set; i+=leds_per_packet)
@@ -229,20 +170,11 @@ 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);
     }
 
@@ -250,31 +182,15 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor *> colors)
     buffer[5] = 0x00;
     buffer[6] = 0x00;
     buffer[7] = 0x00;
-
-    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);
+    memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * key_set], (3 * (led_count - key_set)));
 
     hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
-    delete[] key_buf;
 }
 
 void AsusAuraCoreLaptopController::SendBrightness()
 {
-    const uint8_t index                                     = 5;
-    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_BRIGHTNESS, 0xC5, 0xC4};
+    const uint8_t index                                     = 2;
+    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_BRIGHTNESS };
 
     memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
     buffer[4] = current_brightness;
@@ -367,8 +283,6 @@ 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
     {
@@ -379,9 +293,7 @@ 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",
-                          aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
-                          key_name.c_str(), ((power_config[i].state) ? "On" : "Off"));
+                LOG_DEBUG("[%s] Reading power config for %s: %s", device_name.c_str(), key_name.c_str(), ((power_config[i].state) ? "On" : "Off"));
             }
         }
     }
@@ -391,7 +303,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[32] =
+    bool flag_array[] =
     {
         power_config[0].state,      power_config[4].state,
         power_config[1].state,      power_config[5].state,
@@ -408,9 +320,7 @@ 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",
-              aura_core_laptop_device_list[device_index]->dmi_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", device_name.c_str(), (flags & 0xFF), ((flags >> 8)  & 0xFF), ((flags >> 16)  & 0xFF), flags);
     SendPowerConfig(flags);
 }
 

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.h

@@ -18,7 +18,6 @@
 #include "RGBController.h"
 #include "ResourceManager.h"
 #include "RGBControllerKeyNames.h"
-#include "AsusAuraCoreLaptopDevices.h"
 
 #define NA                                      0xFFFFFFFF
 #define HID_MAX_STR                             255
@@ -34,7 +33,7 @@
 #define ASUSAURACORELAPTOP_POWER_ZONES          4
 #define ASUSAURACORELAPTOP_POWER_STATES         4
 #define ASUSAURACORELAPTOP_BRIGHTNESS_MIN       0
-#define ASUSAURACORELAPTOP_BRIGHTNESS_MAX       3 // No device has proven to have 256 keyboard brightness levels, only 0..3
+#define ASUSAURACORELAPTOP_BRIGHTNESS_MAX       255
 
 enum
 {
@@ -84,7 +83,6 @@ enum
     ASUSAURACORELAPTOP_CMD_UPDATE               = 0xB3,
     ASUSAURACORELAPTOP_CMD_APPLY                = 0xB4,
     ASUSAURACORELAPTOP_CMD_SET                  = 0xB5,
-    ASUSAURACORELAPTOP_CMD_LAYOUT               = 0x05,
 };
 
 enum
@@ -94,12 +92,6 @@ 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;
@@ -112,36 +104,33 @@ public:
     AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path);
     ~AsusAuraCoreLaptopController();
 
-    const aura_core_laptop_device*  GetDeviceData();
-    std::string                     GetDeviceDescription();
-    std::string                     GetSerial();
-    unsigned int                    GetKeyboardLayout();
-    std::string                     GetLocation();
+    std::string             GetDeviceName();
+    std::string             GetSerial();
+    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                            SendInitDirectMode();
+    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);
 private:
-    hid_device*                     dev;
-    uint16_t                        device_index;
-    std::string                     location;
+    std::string             device_name;
+    std::string             location;
+    hid_device*             dev;
 
-    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

@@ -1,347 +0,0 @@
-#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

@@ -1,50 +0,0 @@
-#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,6 +11,129 @@
 
 #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
@@ -27,24 +150,18 @@
         * 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;
-    const aura_core_laptop_device* aura_dev = controller->GetDeviceData();
+    controller                  = controller_ptr;
 
-    name                                    = aura_dev->dmi_name;
-    vendor                                  = "Asus";
-    type                                    = DEVICE_TYPE_KEYBOARD;
-    description                             = controller->GetDeviceDescription();
-    serial                                  = controller->GetSerial();
-    location                                = controller->GetLocation();
+    name                        = "Asus Aura Core Laptop";
+    vendor                      = "Asus";
+    type                        = DEVICE_TYPE_KEYBOARD;
+    description                 = controller->GetDeviceName();
+    serial                      = controller->GetSerial();
+    location                    = controller->GetLocation();
 
     mode Direct;
     Direct.name                 = "Direct";
@@ -258,9 +375,8 @@ 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()
@@ -268,131 +384,70 @@ 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()
 {
-    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);
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
 
     /*---------------------------------------------------------*\
-    | Fill in zones from the device data                        |
+    | Set up zones                                              |
     \*---------------------------------------------------------*/
-    for(size_t i = 0; i < AURA_CORE_LAPTOP_ZONES_MAX; i++)
+    for(std::size_t zone_index = 0; zone_index < zones.size(); zone_index++)
     {
-        LOG_DEBUG("[%s] setting up zone %d", description.c_str(), i);
+        int zone_offset = (int)leds.size();
 
-        if(aura_dev->zones[i] == NULL)
+        for(unsigned int led_index = 0; led_index < zones[zone_index].leds_count; led_index++)
         {
-            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);
+            led new_led;
+            new_led.value   = led_index + zone_offset;
+            new_led.name    = led_names[new_led.value];
+            leds.push_back(new_led);
         }
     }
 
     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*/)
@@ -404,35 +459,36 @@ void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/
 
 void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs()
 {
-    for(size_t i = 85; i < leds.size(); i++)
+    controller->SetLedsDirect(colors);
+}
+
+void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int zone)
+{
+    std::vector<RGBColor> colour;
+    for(size_t i = 0; i < zones[zone].leds_count; 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]));
+        colour.push_back(zones[zone].colors[i]);
     }
 
-    controller->SetLedsDirect(buffer_map);
+    controller->SetLedsDirect(colour);
 }
 
-void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int led)
 {
-    controller->SetLedsDirect(buffer_map);
-}
+    std::vector<RGBColor> colour;
+    colour.push_back(colors[led]);
 
-void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int /*led*/)
-{
-    controller->SetLedsDirect(buffer_map);
+    controller->SetLedsDirect(colour);
 }
 
 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,7 +11,6 @@
 
 #pragma once
 
-#include <algorithm>
 #include <vector>
 #include "RGBController.h"
 #include "AsusAuraCoreLaptopController.h"
@@ -32,8 +31,7 @@ public:
     void                DeviceUpdateMode();
 
 private:
-    RGBColor                            null_color              = 0;
-    std::vector<RGBColor *>             buffer_map;
+    void                Init_Controller();
 
-    AsusAuraCoreLaptopController*       controller;
+    AsusAuraCoreLaptopController*      controller;
 };

Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseDevices.h

@@ -55,7 +55,6 @@
 #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
@@ -637,20 +636,6 @@ 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,19 +14,17 @@
 
 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 device is closed in the base class                    |
-    \*---------------------------------------------------------*/
+	hid_close(dev);
 }
 
 std::string AsusAuraRyuoAIOController::GetLocation()
@@ -36,10 +34,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,7 +39,6 @@ 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,7 +415,6 @@ 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,7 +9,6 @@
 
 #include <string>
 #include "Detector.h"
-#include "FanController_AsusTUFLaptop_Windows.h"
 #include "RGBController_AsusTUFLaptop_Windows.h"
 #include "wmi.h"
 
@@ -45,10 +44,8 @@ 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

@@ -1,44 +0,0 @@
-#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

@@ -1,18 +0,0 @@
-#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,27 +49,26 @@ 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 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);
+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);

Controllers/CoolerMasterController/CMKeyboardController/CMKeyboardDevices.cpp

@@ -63,25 +63,6 @@ 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%)                                         |
 \*-------------------------------------------------------------*/
@@ -228,7 +209,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,
 };
@@ -335,64 +316,6 @@ 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,
@@ -734,24 +657,6 @@ 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,
@@ -881,8 +786,6 @@ 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 // [openrgb #4292]
-#define COOLERMASTER_KEYBOARD_SK620W_PID          0x0159 // [openrgb #4292, signal]
+#define COOLERMASTER_KEYBOARD_SK620B_PID          0x0157 // unsupported
+#define COOLERMASTER_KEYBOARD_SK620W_PID          0x0159 // [signal]
 #define COOLERMASTER_KEYBOARD_SK622B_PID          0x0149 // [openrgb #3110, signal #217(closed)]
 #define COOLERMASTER_KEYBOARD_SK622W_PID          0x014B // [signal]
 #define COOLERMASTER_KEYBOARD_SK630_PID           0x0089 // [openrgb #967, libcmmk !21]

Controllers/CoolerMasterController/CMKeyboardController/CMKeyboardV2Controller.cpp

@@ -14,7 +14,6 @@
 #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)
 {
@@ -99,7 +98,7 @@ std::string CMKeyboardV2Controller::_GetFirmwareVersion()
     }
 
     std::u16string usFirmwareVersion(reinterpret_cast<const char16_t*>(cVersionStr+8));
-    std::string sFirmwareVersion(StringUtils::u16string_to_string(usFirmwareVersion));
+    std::string sFirmwareVersion(usFirmwareVersion.begin(), usFirmwareVersion.end());
 
     LOG_VERBOSE("[%s] GetFirmwareVersion(): [%s]", m_deviceName.c_str(), sFirmwareVersion.c_str());
 

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -297,8 +297,6 @@ 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,72 +59,6 @@ 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);
@@ -269,92 +203,6 @@ 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,12 +23,6 @@
 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                  */
@@ -69,17 +63,6 @@ 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                           */
@@ -102,23 +85,12 @@ 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();
@@ -146,24 +118,6 @@ 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,64 +1,55 @@
-/*---------------------------------------------------------*\
-| CorsairLightingNodeControllerDetect.cpp                   |
-|                                                           |
-|   Detector for Corsair Lighting Node devices              |
-|                                                           |
-|   Adam Honse ([email protected])      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
+/*---------------------------------------------------------*\
+| CorsairLightingNodeControllerDetect.cpp                   |
+|                                                           |
+|   Detector for Corsair Lighting Node devices              |
+|                                                           |
+|   Adam Honse ([email protected])      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

Controllers/CorsairLightingNodeController/FanController_CorsairCommander.cpp

@@ -1,57 +0,0 @@
-/*-----------------------------------------*\
-|  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

@@ -1,24 +0,0 @@
-/*-----------------------------------------*\
-|  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 = std::max(result, (uint16_t)CORSAIR_V2_WRITE_SIZE);
+    pkt_sze = result;
     LOG_DEBUG("[%s] Packet length set to %d", device_name.c_str(), pkt_sze);
 
     /*---------------------------------------------------------*\
@@ -78,8 +78,6 @@ 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,9 +71,7 @@ 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,32 +99,6 @@ 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,
@@ -790,38 +764,6 @@ 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                                |
 |                                                               |
@@ -897,7 +839,7 @@ static const corsair_v2_zone k70_rgb_pro_zone =
 {
     ZONE_EN_KEYBOARD,
     ZONE_TYPE_MATRIX,
-    7,
+    6,
     21
 };
 
@@ -905,7 +847,7 @@ static const corsair_v2_device k70_rgb_pro_device =
 {
     CORSAIR_K70_RGB_PRO_PID,
     DEVICE_TYPE_KEYBOARD,
-    7,
+    6,
     21,
     {
         &k70_rgb_pro_zone,
@@ -915,31 +857,7 @@ static const corsair_v2_device k70_rgb_pro_device =
         nullptr,
         nullptr
     },
-    &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
+    &corsair_k70_layout
 };
 
 /*-------------------------------------------------------------*\
@@ -1235,9 +1153,7 @@ 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,9 +72,7 @@ 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

@@ -1,83 +0,0 @@
-/*---------------------------------------------------------*\
-| 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/DreamCheekyControllerDetect.cpp

@@ -1,40 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,94 +0,0 @@
-/*---------------------------------------------------------*\
-| 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/EKController/EKController.cpp

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

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -426,7 +426,6 @@ 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,11 +25,9 @@
 #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
@@ -124,7 +122,5 @@ 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,31 +34,6 @@ 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,12 +21,9 @@ public:
     FanBusController(FanBusInterface* bus_ptr, unsigned char dev_addr);
     ~FanBusController();
 
-    std::string     GetLocation();
+    std::string GetLocation();
 
-    unsigned char   GetFanPWM();
-    unsigned short  GetFanRPM();
-    void            SetFanPWM(unsigned char fan_pwm);
-    void            SetLEDs(std::vector<RGBColor> colors);
+    void        SetLEDs(std::vector<RGBColor> colors);
 
 private:
     std::string         port_name;

Controllers/FanBusController/FanBusControllerDetect.cpp

@@ -11,7 +11,6 @@
 
 #include "Detector.h"
 #include "FanBusController.h"
-#include "FanController_FanBus.h"
 #include "RGBController_FanBus.h"
 #include "SettingsManager.h"
 
@@ -46,10 +45,6 @@ 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

@@ -1,43 +0,0 @@
-/*-----------------------------------------*\
-|  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

@@ -1,24 +0,0 @@
-/*-----------------------------------------*\
-|  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,24 +102,18 @@ 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_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 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 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);
@@ -146,16 +140,13 @@ 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,30 +114,24 @@ 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_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 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 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_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 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 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_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 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 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_SINGLE;
+    Mic.type       = ZONE_TYPE_LINEAR;
     Mic.leds_min   = 2;
     Mic.leds_max   = 2;
     Mic.leds_count = 2;

Controllers/InstantMouseController/InstantMouseController.cpp

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

Controllers/InstantMouseController/InstantMouseController.h

@@ -29,13 +29,7 @@ enum
     INSTANT_MOUSE_LOOP_MODE                     = 0x04,
     INSTANT_MOUSE_SPECTRUM_CYCLE_MODE           = 0x06,
     INSTANT_MOUSE_RAINBOW_WAVE_MODE             = 0x07,
-    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,
-
+    INSTANT_MOUSE_BREATHING_MODE                = 0x08
 };
 
 enum
@@ -54,7 +48,6 @@ 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);
@@ -64,5 +57,4 @@ private:
     hid_device* dev;
     std::string location;
     std::string version;
-    uint16_t pid;
 };

Controllers/InstantMouseController/InstantMouseControllerDetect.cpp

@@ -13,8 +13,11 @@
 #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)
 {
@@ -32,5 +35,3 @@ 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

@@ -1,19 +0,0 @@
-/*---------------------------------------------------------*\
-| 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,7 +10,6 @@
 \*---------------------------------------------------------*/
 
 #include "RGBController_InstantMouse.h"
-#include "InstantMouseDevices.h"
 
 /**------------------------------------------------------------------*\
     @name Instant mouse
@@ -22,8 +21,7 @@
     @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,
-    Ant Esports GM600
+    GTA 250 (GX72-A725), Anko KM43243952 (GM8-A825), Anko KM43277483
 \*-------------------------------------------------------------------*/
 
 RGBController_InstantMouse::RGBController_InstantMouse(InstantMouseController* controller_ptr)
@@ -68,10 +66,7 @@ RGBController_InstantMouse::RGBController_InstantMouse(InstantMouseController* c
 
     mode breathing;
     breathing.name                      = "Breathing";
-    /*------------------------------------------------------------------*\
-    |    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.value                     = 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);
@@ -107,47 +102,6 @@ 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,7 +558,6 @@ 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,13 +398,15 @@ void RGBController_LenovoUSB::DeviceUpdateLEDs()
 
         prev_zone_id = zone_id;
 
-        curr_color_map.push_back({(uint8_t)(leds[i].value & 0xFF), colors[i]});
+        curr_color_map.push_back({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 < (uint8_t)max_key_per_color; i++)
+                for(uint8_t i = 0; i < max_key_per_color; i++)
                 {
-                    if((bi + i) < (uint8_t)x.second.size())
+                    if(bi + i < 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;
-    unsigned char feature_4522_idx;
-    unsigned char device_index;
-    unsigned char feature_8040_idx;
-    unsigned char feature_8071_idx;
-    unsigned char feature_8081_idx;
+    hid_device* dev_handle;
+    char feature_4522_idx;
+    char device_index;
+    char feature_8040_idx;
+    char feature_8071_idx;
+    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) < (uint8_t)x.second.size())
+                    if(bi + i < 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,7 +11,6 @@
 
 #include <cstring>
 #include "LogitechLightspeedController.h"
-#include "StringUtils.h"
 
 LogitechLightspeedController::LogitechLightspeedController(hid_device* dev_handle, const char* path)
 {
@@ -47,7 +46,8 @@ std::string LogitechLightspeedController::GetSerialString()
             return("");
         }
 
-        std::string return_string(StringUtils::wstring_to_string(serial_string));
+        std::wstring return_wstring = serial_string;
+        std::string return_string(return_wstring.begin(), return_wstring.end());
 
         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((uint8_t)i);
+            logitech_led new_led                    = controller->lightspeed->getLED_info(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               = (unsigned int)i;
+            Lightspeed_logo_led.value               = i;
             leds.push_back(Lightspeed_logo_led);
         }
     }

Controllers/LuxaforController/LuxaforController.cpp

@@ -1,129 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,58 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,40 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,239 +0,0 @@
-/*---------------------------------------------------------*\
-| 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

@@ -1,52 +0,0 @@
-/*---------------------------------------------------------*\
-| 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 = (int)mode;
+            active_mode = mode;
             break;
         }
     }
@@ -36,11 +36,11 @@ int RGBController_MSIGPU::GetModeSpeed()
     {
         if(speed_values[speed] == mode_speed)
         {
-            return((int)speed);
+            return speed;
         }
     }
 
-    return(0);
+    return 0;
 }
 
 /**------------------------------------------------------------------*\

Controllers/MSIGPUController/MSIGPUv2Controller/MSIGPUv2ControllerDetect.cpp

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

Controllers/MSIMysticLightController/MSIMysticLight162Controller/MSIMysticLight162Controller.cpp

@@ -418,9 +418,10 @@ void MSIMysticLight162Controller::ReadName()
     hid_get_manufacturer_string(dev, tname, 256);
 
     /*-----------------------------------------------------*\
-    | Convert to std::string                                |
+    | Convert wchar_t into std::wstring into std::string    |
     \*-----------------------------------------------------*/
-    name = StringUtils::wstring_to_string(tname);
+    std::wstring wname = std::wstring(tname);
+    name = std::string(wname.begin(), wname.end());
 
     /*-----------------------------------------------------*\
     | Get the product string from HID                       |
@@ -430,7 +431,8 @@ void MSIMysticLight162Controller::ReadName()
     /*-----------------------------------------------------*\
     | Append the product string to the manufacturer string  |
     \*-----------------------------------------------------*/
-    name.append(" ").append(StringUtils::wstring_to_string(tname));
+    wname = std::wstring(tname);
+    name.append(" ").append(std::string(wname.begin(), wname.end()));
 }
 
 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_PER_LED },       // MPG Z590 GAMING FORCE
+    { 0x7D06, 4,  4,  0, 1, &zones_set3,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },      // 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_PER_LED },      // MEG B550 UNIFY
+    { 0x7D13, 6,  0,  0, 1, &zones_set1,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },      // 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_PER_LED },       // MEG Z690I UNIFY
+    { 0x7D29, 6,  0,  0, 0, &zones_set6,  MSIMysticLight185Controller::DIRECT_MODE_DISABLED },      // 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,16 +300,13 @@ 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, 0,  0,  0, 2, &zones_set13, MSIMysticLight185Controller::DIRECT_MODE_PER_LED },       // PRO B650M-A WIFI
+    { 0x7D77, 6,  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
@@ -317,8 +314,6 @@ 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
 };
@@ -1057,9 +1052,10 @@ void MSIMysticLight185Controller::ReadName()
     hid_get_manufacturer_string(dev, tname, 256);
 
     /*-----------------------------------------------------*\
-    | Convert to std::string                                |
+    | Convert wchar_t into std::wstring into std::string    |
     \*-----------------------------------------------------*/
-    name = StringUtils::wstring_to_string(tname);
+    std::wstring wname = std::wstring(tname);
+    name = std::string(wname.begin(), wname.end());
 
     /*-----------------------------------------------------*\
     | Get the product string from HID                       |
@@ -1069,7 +1065,8 @@ void MSIMysticLight185Controller::ReadName()
     /*-----------------------------------------------------*\
     | Append the product string to the manufacturer string  |
     \*-----------------------------------------------------*/
-    name.append(" ").append(StringUtils::wstring_to_string(tname));
+    wname = std::wstring(tname);
+    name.append(" ").append(std::string(wname.begin(), wname.end()));
 }
 
 MSI_MODE MSIMysticLight185Controller::GetMode()

Controllers/MSIMysticLightController/MSIMysticLight64Controller/MSIMysticLight64Controller.cpp

@@ -70,9 +70,10 @@ std::string MSIMysticLight64Controller::GetDeviceName()
     hid_get_manufacturer_string(dev, tname, 256);
 
     /*-----------------------------------------------------*\
-    | Convert to std::string                                |
+    | Convert wchar_t into std::wstring into std::string    |
     \*-----------------------------------------------------*/
-    std::string name = StringUtils::wstring_to_string(tname);
+    std::wstring wname = std::wstring(tname);
+    std::string name = std::string(wname.begin(), wname.end());
 
     /*-----------------------------------------------------*\
     | Get the product string from HID                       |
@@ -82,9 +83,9 @@ std::string MSIMysticLight64Controller::GetDeviceName()
     /*-----------------------------------------------------*\
     | Append the product string to the manufacturer string  |
     \*-----------------------------------------------------*/
-    name.append(" ").append(StringUtils::wstring_to_string(tname));
-
-    return(name);
+    wname = std::wstring(tname);
+    name.append(" ").append(std::string(wname.begin(), wname.end()));
+    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 = (unsigned int)Mode.colors.size();
+        num_colors = 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,10 +182,7 @@ 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.cpp

@@ -1,5 +1,5 @@
 /*---------------------------------------------------------*\
-| NVIDIAIlluminationControllerDetect_Windows_Linux.cpp      |
+| NVIDIAIlluminationControllerDetect_Windows.cpp            |
 |                                                           |
 |   Detector for NVIDIA Illumination GPU                    |
 |                                                           |
@@ -15,7 +15,7 @@
 #include "Detector.h"
 #include "LogManager.h"
 #include "RGBController.h"
-#include "RGBController_NVIDIAIllumination_Windows_Linux.h"
+#include "RGBController_NVIDIAIllumination_Windows.h"
 #include "pci_ids.h"
 
 enum
@@ -32,7 +32,7 @@ typedef struct
     int             gpu_rgb_version;
     bool            treats_rgbw_as_rgb;
     const char *    name;
-} nv_gpu_pci_device;
+} gpu_pci_device;
 
 
 #define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
@@ -44,35 +44,33 @@ typedef struct
 #define TREATS_RGBW_AS_RGB  true
 #define TREATS_RGBW_AS_RGBW false
 
-static const nv_gpu_pci_device device_list[] =
+static const 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_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"                        },
+    {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"                        },
 };
 
 void DetectNVIDIAIllumGPUs()

Controllers/NVIDIAIlluminationController/NVIDIAIlluminationV1Controller_Windows.cpp

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

Controllers/NVIDIAIlluminationController/NVIDIAIlluminationV1Controller_Windows.h

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

Controllers/NVIDIAIlluminationController/RGBController_NVIDIAIllumination_Windows.cpp

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

Controllers/NVIDIAIlluminationController/RGBController_NVIDIAIllumination_Windows.h

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

Controllers/NVIDIAIlluminationController/nvapi_accessor_Windows.cpp

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

Controllers/NVIDIAIlluminationController/nvapi_accessor_Windows.h

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

Controllers/NZXTHue2Controller/FanController_NZXTHue2.cpp

@@ -1,55 +0,0 @@
-/*-----------------------------------------*\
-|  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

@@ -1,24 +0,0 @@
-/*-----------------------------------------*\
-|  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,48 +30,6 @@ 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();
 }
 
@@ -291,7 +249,7 @@ void NZXTHue2Controller::UpdateStatus()
     unsigned char usb_buf[64];
     unsigned int  ret_val = 0;
 
-    if(num_fan_channels > 0)
+    if(false)//num_fan_channels > 0)
     {
         /*-----------------------------------------------------*\
         | Zero out buffer                                       |

Controllers/NZXTHue2Controller/NZXTHue2ControllerDetect.cpp

@@ -12,8 +12,6 @@
 #include <hidapi.h>
 #include "Detector.h"
 #include "NZXTHue2Controller.h"
-#include "FanController.h"
-#include "FanController_NZXTHue2.h"
 #include "RGBController.h"
 #include "RGBController_NZXTHue2.h"
 
@@ -47,13 +45,6 @@ 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

@@ -1,71 +0,0 @@
-/*-----------------------------------------*\
-|  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

@@ -1,23 +0,0 @@
-/*-----------------------------------------*\
-|  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,9 +41,6 @@ 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()
@@ -199,135 +196,3 @@ 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,12 +48,6 @@ 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:
@@ -64,12 +58,6 @@ public:
     std::string GetLocation();
     std::string GetSerialString();
 
-    void SetSpeed
-        (
-        unsigned char   channel,
-        unsigned int    speed_cmd
-        );
-
     void UpdateEffect
         (
         NZXTKrakenChannel_t channel,
@@ -80,12 +68,9 @@ public:
         std::vector<RGBColor> colors
         );
 
+private:
     void UpdateStatus();
 
-    unsigned int            fan_speed;
-    unsigned int            pump_speed;
-
-private:
     void SendEffect
         (
         unsigned char   channel,
@@ -98,23 +83,12 @@ 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;
-
-    bool                    supports_cooling_profiles;
+    unsigned int            fan_speed;
+    unsigned int            pump_speed;
 };

Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp

@@ -13,7 +13,6 @@
 #include <hidapi.h>
 #include "Detector.h"
 #include "NZXTKrakenController.h"
-#include "FanController_NZXTKraken.h"
 #include "RGBController.h"
 #include "RGBController_NZXTKraken.h"
 
@@ -38,17 +37,6 @@ 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::size_t)(std::round(255 / divisor) + 10));
-    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), (std::size_t)(std::round(255 / divisor) + 10));
+    matrix_map_xl                   = MakeEmptyMatrixMap(unique_rows.size(), std::round(255/divisor) + 10);
+    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), 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                       = (unsigned int)(std::round(led_points[i].x / divisor));
-            y                       = (unsigned int)(std::distance(unique_rows.begin(), unique_rows.find(led_points[i].y)));
+            x                       = std::round(led_points[i].x/divisor);
+            y                       = 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
     (
-        std::size_t height,
-        std::size_t width
+        unsigned int height,
+        unsigned int width
     )
 {
     std::vector<std::vector<unsigned int> > matrix_map(height);
-    for(std::size_t i = 0; i < height; i++)
+    for (unsigned int i = 0; i < height; i++)
     {
-        for(std::size_t j = 0; j < width; j++)
+        for (unsigned int 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
                                             (
-                                                std::size_t height,
-                                                std::size_t width
+                                            unsigned int height,
+                                            unsigned int 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::size_t)(std::round(255 / divisor) + 10));
-    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), (std::size_t)(std::round(255 / divisor) + 10));
+    matrix_map_xl                   = MakeEmptyMatrixMap(unique_rows.size(), std::round(255/divisor) + 10);
+    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), 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                       = (unsigned int)(std::round(led_points[i].x / divisor));
-            y                       = (unsigned int)(std::distance(unique_rows.begin(), unique_rows.find(led_points[i].y)));
+            x                       = std::round(led_points[i].x/divisor);
+            y                       = 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
     (
-        std::size_t height,
-        std::size_t width
+        unsigned int height,
+        unsigned int width
     )
 {
     std::vector<std::vector<unsigned int> > matrix_map(height);
-    for(std::size_t i = 0; i < height; i++)
+    for (unsigned int i = 0; i < height; i++)
     {
-        for(std::size_t j = 0; j < width; j++)
+        for (unsigned int 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
                                             (
-                                                std::size_t height,
-                                                std::size_t width
+                                            unsigned int height,
+                                            unsigned int 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::size_t)(std::round(255 / divisor) + 10));
-    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), (std::size_t)(std::round(255 / divisor) + 10));
+    matrix_map_xl                   = MakeEmptyMatrixMap(unique_rows.size(), std::round(255/divisor) + 10);
+    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), 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                       = (unsigned int)(std::round(led_points[i].x / divisor));
-            y                       = (unsigned int)(std::distance(unique_rows.begin(), unique_rows.find(led_points[i].y)));
+            x                       = std::round(led_points[i].x/divisor);
+            y                       = 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
     (
-        std::size_t height,
-        std::size_t width
+        unsigned int height,
+        unsigned int width
     )
 {
     std::vector<std::vector<unsigned int> > matrix_map(height);
-    for(std::size_t i = 0; i < height; i++)
+    for (unsigned int i = 0; i < height; i++)
     {
-        for(std::size_t j = 0; j < width; j++)
+        for (unsigned int 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
                                             (
-                                                std::size_t height,
-                                                std::size_t width
+                                            unsigned int height,
+                                            unsigned int 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::size_t)(std::round(255 / divisor) + 10));
-    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), (std::size_t)(std::round(255 / divisor) + 10));
+    matrix_map_xl                   = MakeEmptyMatrixMap(unique_rows.size(), std::round(255/divisor) + 10);
+    underglow_map_xl                = MakeEmptyMatrixMap(unique_rows.size(), 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                       = (unsigned int)(std::round(led_points[i].x / divisor));
-            y                       = (unsigned int)(std::distance(unique_rows.begin(), unique_rows.find(led_points[i].y)));
+            x                       = std::round(led_points[i].x/divisor);
+            y                       = 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
     (
-        std::size_t height,
-        std::size_t width
+        unsigned int height,
+        unsigned int width
     )
 {
     std::vector<std::vector<unsigned int> > matrix_map(height);
-    for(std::size_t i = 0; i < height; i++)
+    for (unsigned int i = 0; i < height; i++)
     {
-        for(std::size_t j = 0; j < width; j++)
+        for (unsigned int j = 0; j < width; j++)
         {
             matrix_map[i].push_back(NO_LED);
         }

Controllers/QMKOpenRGBController/QMKOpenRGBRevEController/RGBController_QMKOpenRGBRevE.h

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

Controllers/RaspberryPiController/RGBController_RaspberryPi_Linux.cpp

@@ -0,0 +1,138 @@
+/*---------------------------------------------------------*\
+| RGBController_RaspberryPi_Linux.cpp                       |
+|                                                           |
+|   RGBController for Raspberry Pi GPIO ARGB                |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                21 Jul 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include "RGBController_RaspberryPi_Linux.h"
+
+/**------------------------------------------------------------------*\
+    @name Raspberry Pi
+    @category Motherboard
+    @type GPIO
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectRaspberryPiControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_RaspberryPi::RGBController_RaspberryPi(RaspberryPiController* controller_ptr)
+{
+    controller              = controller_ptr;
+
+    name                    = "Raspberry Pi";
+    type                    = DEVICE_TYPE_MOTHERBOARD;
+    vendor                  = "Raspberry Pi";
+    description             = "Raspberry Pi GPIO Device";
+    location                = controller->GetDeviceLocation();
+
+    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();
+}
+
+void RGBController_RaspberryPi::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Only set LED count on the first run               |
+    \*-------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
+    {
+        first_run = true;
+    }
+
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+    zones.resize(1);
+
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    for (unsigned int channel_idx = 0; channel_idx < 1; channel_idx++)
+    {
+        char ch_idx_string[2];
+        snprintf(ch_idx_string, 2, "%d", channel_idx + 1);
+
+        zones[channel_idx].name     = "Channel ";
+        zones[channel_idx].name.append(ch_idx_string);
+        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
+        zones[channel_idx].leds_min = 0;
+        zones[channel_idx].leds_max = 1000;
+
+        if(first_run)
+        {
+            zones[channel_idx].leds_count = 0;
+        }
+
+        zones[channel_idx].matrix_map = NULL;
+
+        for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
+        {
+            char led_idx_string[4];
+            snprintf(led_idx_string, 4, "%d", led_ch_idx + 1);
+
+            led new_led;
+            new_led.name = "Channel ";
+            new_led.name.append(ch_idx_string);
+            new_led.name.append(", LED ");
+            new_led.name.append(led_idx_string);
+
+            leds.push_back(new_led);
+        }
+    }
+
+    controller->SetSize(zones[0].leds_count);
+
+    SetupColors();
+}
+
+void RGBController_RaspberryPi::ResizeZone(int zone, int new_size)
+{
+    if((size_t) zone >= zones.size())
+    {
+        return;
+    }
+
+    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    {
+        zones[zone].leds_count = new_size;
+
+        SetupZones();
+    }
+}
+
+void RGBController_RaspberryPi::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_RaspberryPi::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_RaspberryPi::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_RaspberryPi::DeviceUpdateMode()
+{
+    controller->SetColors(&colors[0]);
+}