Add XPG Spectrix S20G to detectors for S40G

* Added `0x896B` to pci_ids.h
* Registered detector in ENESMBusControllerDetect.cpp
* Link to [webpage](https://rog.asus.com/graphics-cards/graphics-cards/rog-strix/rog-strix-rtx4070tis-o16g-gaming/)
* Resolves #4119

.gitlab-ci.yml

@@ -61,7 +61,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 32 AppImage":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
   stage: build
   script:
   - export $(dpkg-architecture)
@@ -87,7 +87,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 64 AppImage":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
   stage: build
   script:
   - export $(dpkg-architecture)

.gitlab/merge_request_templates/New Device.md

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

AutoStart/AutoStart-FreeBSD.cpp

@@ -1,17 +1,20 @@
-#include "AutoStart-FreeBSD.h"
-#include "LogManager.h"
-#include "filesystem.h"
+/*---------------------------------------------------------*\
+| AutoStart-FreeBSD.cpp                                     |
+|                                                           |
+|   Autostart implementation for FreeBSD                    |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include <fstream>
 #include <iostream>
 #include <limits.h>
 #include <unistd.h>
 #include <sstream>
-
-/*-----------------------------------------------------*\
-| FreeBSD AutoStart Implementation                      |
-| Public Methods                                        |
-\*-----------------------------------------------------*/
+#include "AutoStart-FreeBSD.h"
+#include "LogManager.h"
+#include "filesystem.h"
 
 AutoStart::AutoStart(std::string name)
 {

AutoStart/AutoStart-FreeBSD.h

@@ -1,3 +1,12 @@
+/*---------------------------------------------------------*\
+| AutoStart-FreeBSD.h                                       |
+|                                                           |
+|   Autostart implementation for FreeBSD                    |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
 #pragma once
 
 #include <string>

AutoStart/AutoStart-Linux.cpp

@@ -1,16 +1,20 @@
-#include "AutoStart-Linux.h"
-#include "LogManager.h"
-#include "filesystem.h"
+/*---------------------------------------------------------*\
+| AutoStart-Linux.cpp                                       |
+|                                                           |
+|   Autostart implementation for Linux                      |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include <fstream>
 #include <iostream>
+#include <sstream>
 #include <unistd.h>
 #include <linux/limits.h>
-
-/*-----------------------------------------------------*\
-| Linux AutoStart Implementation                        |
-| Public Methods                                        |
-\*-----------------------------------------------------*/
+#include "AutoStart-Linux.h"
+#include "LogManager.h"
+#include "filesystem.h"
 
 AutoStart::AutoStart(std::string name)
 {
@@ -121,7 +125,7 @@ std::string AutoStart::GetExePath()
     char exepath[ PATH_MAX ];
 
     ssize_t count = readlink("/proc/self/exe", exepath, PATH_MAX);
-    
+
     return(std::string(exepath, (count > 0) ? count : 0));
 }
 
@@ -158,7 +162,7 @@ std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
     }
 
     fileContents << std::endl;
-    
+
     return(fileContents.str());
 }
 
@@ -197,7 +201,7 @@ void AutoStart::InitAutoStart(std::string name)
         std::error_code ec;
 
         bool success = true;
-        
+
         if(!filesystem::exists(autostart_dir))
         {
             success = filesystem::create_directories(autostart_dir, ec);

AutoStart/AutoStart-Linux.h

@@ -1,3 +1,12 @@
+/*---------------------------------------------------------*\
+| AutoStart-Linux.h                                         |
+|                                                           |
+|   Autostart implementation for Linux                      |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
 #pragma once
 
 #include <string>

AutoStart/AutoStart-MacOS.cpp

@@ -1,18 +1,20 @@
-#include "AutoStart-MacOS.h"
-#include "LogManager.h"
-#include "filesystem.h"
+/*---------------------------------------------------------*\
+| AutoStart-MacOS.cpp                                       |
+|                                                           |
+|   Autostart implementation for MacOS                      |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include <fstream>
 #include <sstream>
 #include <iostream>
 #include <unistd.h>
-
 #include <mach-o/dyld.h>
-
-/*-----------------------------------------------------*\
-| MacOS AutoStart Implementation                        |
-| Public Methods                                        |
-\*-----------------------------------------------------*/
+#include "AutoStart-MacOS.h"
+#include "LogManager.h"
+#include "filesystem.h"
 
 AutoStart::AutoStart(std::string name)
 {
@@ -152,7 +154,7 @@ std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
     fileContents << "    <key>ProgramArguments</key>"                                                                               << std::endl;
     fileContents << "    <array>"                                                                                                   << std::endl;
     fileContents << "        <string>" << autostart_info.path << "</string>"                                                        << std::endl;
-    
+
     if(autostart_info.args != "")
     {
         std::istringstream arg_parser(autostart_info.args);
@@ -163,12 +165,12 @@ std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
             fileContents << "        <string>" << arg << "</string>"                                                                << std::endl;
         }
     }
-    
+
     fileContents << "    </array>"                                                                                                  << std::endl;
     fileContents << "    <key>RunAtLoad</key><true/>"                                                                               << std::endl;
     fileContents << "</dict>"                                                                                                       << std::endl;
     fileContents << "</plist>"                                                                                                      << std::endl;
-    
+
     return(fileContents.str());
 }
 
@@ -193,7 +195,7 @@ void AutoStart::InitAutoStart(std::string name)
         std::error_code ec;
 
         bool success = true;
-        
+
         if(!filesystem::exists(autostart_dir))
         {
             success = filesystem::create_directories(autostart_dir, ec);

AutoStart/AutoStart-MacOS.h

@@ -1,3 +1,12 @@
+/*---------------------------------------------------------*\
+| AutoStart-MacOS.h                                         |
+|                                                           |
+|   Autostart implementation for MacOS                      |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
 #pragma once
 
 #include <string>

AutoStart/AutoStart-Windows.cpp

@@ -1,17 +1,19 @@
-#include "AutoStart-Windows.h"
-#include "LogManager.h"
-#include "filesystem.h"
+/*---------------------------------------------------------*\
+| AutoStart-Windows.cpp                                     |
+|                                                           |
+|   Autostart implementation for Windows                    |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include <fstream>
 #include <iostream>
-
-#include "windows.h"
 #include <shlobj.h>
-
-/*-----------------------------------------------------*\
-| Windows AutoStart Implementation                      |
-| Public Methods                                        |
-\*-----------------------------------------------------*/
+#include "AutoStart-Windows.h"
+#include "LogManager.h"
+#include "filesystem.h"
+#include "windows.h"
 
 AutoStart::AutoStart(std::string name)
 {
@@ -41,7 +43,7 @@ bool AutoStart::DisableAutoStart()
         else
         {
             success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
-            
+
             if(!success)
             {
                 LOG_ERROR("An error occurred removing the auto start file.");
@@ -97,11 +99,11 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
             shellLink->SetArguments(argumentsw.c_str());
             shellLink->SetDescription(descriptionw.c_str());
             shellLink->SetIconLocation(iconw.c_str(), 0);
-            
+
             IPersistFile* persistFile;
-            
+
             result                                  = shellLink->QueryInterface(IID_IPersistFile, (void**)&persistFile);
-            
+
             if(SUCCEEDED(result))
             {
                 result                              = persistFile->Save(startupfilepathw.c_str(), TRUE);
@@ -151,7 +153,7 @@ std::string AutoStart::GetExePath()
     char exepath[MAX_PATH] = "";
 
     DWORD count = GetModuleFileNameA(NULL, exepath, MAX_PATH);
-    
+
     return(std::string(exepath, (count > 0) ? count : 0));
 }
 
@@ -197,8 +199,8 @@ std::wstring AutoStart::utf8_decode(const std::string& str)
     int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), nullptr, 0);
 
     std::wstring wstrTo(size_needed, 0);
-    
+
     MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), &wstrTo[0], size_needed);
-    
+
     return(wstrTo);
 }

AutoStart/AutoStart-Windows.h

@@ -1,3 +1,12 @@
+/*---------------------------------------------------------*\
+| AutoStart-Windows.h                                       |
+|                                                           |
+|   Autostart implementation for Windows                    |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
 #pragma once
 
 #include <string>

AutoStart/AutoStart.cpp

@@ -1,9 +1,13 @@
-#include "AutoStart.h"
+/*---------------------------------------------------------*\
+| AutoStart.cpp                                             |
+|                                                           |
+|   Autostart common implementation                         |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
-/*-----------------------------------------------------*\
-| Common AutoStart Implementation                       |
-| Public Methods                                        |
-\*-----------------------------------------------------*/
+#include "AutoStart.h"
 
 std::string AutoStartInterface::GetAutoStartFile()
 {

AutoStart/AutoStart.h

@@ -1,3 +1,12 @@
+/*---------------------------------------------------------*\
+| AutoStart.h                                               |
+|                                                           |
+|   Autostart common implementation                         |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
 #pragma once
 
 #include <string>

CONTRIBUTING.md

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

Colors.h

@@ -1,3 +1,12 @@
+/*---------------------------------------------------------*\
+| Colors.h                                                  |
+|                                                           |
+|   List of named color constants                           |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
 #ifndef COLORS_H
 #define COLORS_H
 

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -1,3 +1,15 @@
+/*---------------------------------------------------------*\
+| A4TechDetector.cpp                                        |
+|                                                           |
+|   Detector for A4Tech Devices                             |
+|                                                           |
+|   Chris M (Dr_No)                             30 Jun 2022 |
+|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
 /*-----------------------------------------------------*\
 | OpenRGB includes                                      |
 \*-----------------------------------------------------*/
@@ -9,6 +21,7 @@
 | A4 Tech specific includes                             |
 \*-----------------------------------------------------*/
 #include "RGBController_BloodyMouse.h"
+#include "RGBController_BloodyB820R.h"
 
 /*-----------------------------------------------------*\
 | A4 Tech USB vendor ID                                 |
@@ -29,6 +42,21 @@ void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name
     }
 }
 
+void DetectBloodyB820R(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path);
+        RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
+        rgb_controller->name                      = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
 REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
 REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
+REGISTER_HID_DETECTOR_IPU("A4Tech Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);

Controllers/A4TechController/BloodyB820RController/BloodyB820RController.cpp

@@ -0,0 +1,102 @@
+/*---------------------------------------------------------*\
+| BloodyB820RController.cpp                                 |
+|                                                           |
+|   Driver for A4Tech Bloody B820R Keyboard                 |
+|                                                           |
+|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include "BloodyB820RController.h"
+
+/*-------------------------------------------------------------------------------------*\
+| The controller for this device should pass a packet of 64 bytes where the subsequent  |
+| two packets are for RED, GREEN, and BLUE respectively. The first 6 bytes are control  |
+| or information bytes and colors bytes starts from index 6. Moreover, the first pack-  |
+| et of each RGB contains color for 58 keys and the rest (104 - 58 == 46) are send on   |
+| the second packet.                                                                    |
+\*-------------------------------------------------------------------------------------*/
+
+BloodyB820RController::BloodyB820RController(hid_device* dev_handle, const char* path)
+{
+    dev                 = dev_handle;
+    location            = path;
+
+    SendControlPacket(BLOODY_B820R_GAIN_CONTROL);
+}
+
+BloodyB820RController::~BloodyB820RController()
+{
+    SendControlPacket(BLOODY_B820R_RELEASE_CONTROL);
+    hid_close(dev);
+}
+
+std::string BloodyB820RController::GetSerial()
+{
+    const int szTemp    = HID_MAX_STR;
+    wchar_t   tmpName[szTemp];
+
+    hid_get_serial_number_string(dev, tmpName, szTemp);
+    std::wstring wName  = std::wstring(tmpName);
+    std::string serial  = std::string(wName.begin(), wName.end());
+
+    return(serial);
+}
+
+std::string BloodyB820RController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+void  BloodyB820RController::SendControlPacket(uint8_t data)
+{
+    uint8_t buffer[BLOODY_B820R_PACKET_SIZE]    = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
+
+    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
+
+    buffer[BLOODY_B820R_MODE_BYTE]              = 0;
+    buffer[BLOODY_B820R_DATA_BYTE]              = data;
+
+    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
+}
+
+void BloodyB820RController::SetLEDDirect(std::vector<RGBColor> colors)
+{
+
+    uint8_t r1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x07, 0x00, 0x00 };
+    uint8_t r2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x08, 0x00, 0x00 };
+    uint8_t g1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x09, 0x00, 0x00 };
+    uint8_t g2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0A, 0x00, 0x00 };
+    uint8_t b1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0B, 0x00, 0x00 };
+    uint8_t b2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0C, 0x00, 0x00 };
+
+    /*-----------------------------------------------------------------*\
+    | Set up Direct packet                                              |
+    |   packet_map is the index of the Key from full_matrix_map and     |
+    |   the value is the position in the direct packet buffer           |
+    \*-----------------------------------------------------------------*/
+    for(size_t i = 0; i < colors.size(); i++)
+    {
+        RGBColor    color                       = colors[i];
+        uint8_t     offset                      = BLOODY_B820R_RGB_OFFSET;
+        uint8_t     buffer_idx                  = offset + i % BLOODY_B820R_RGB_BUFFER_SIZE;
+        uint8_t*    buffers[2][3]               =
+                {
+                        {r1_buffer, g1_buffer, b1_buffer},
+                        {r2_buffer, g2_buffer, b2_buffer}
+                };
+
+        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][0][buffer_idx] = RGBGetRValue(color);
+        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][1][buffer_idx] = RGBGetGValue(color);
+        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][2][buffer_idx] = RGBGetBValue(color);
+    }
+
+    hid_send_feature_report(dev, r1_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, r2_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, g1_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, g2_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, b1_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, b2_buffer, BLOODY_B820R_PACKET_SIZE);
+}

Controllers/A4TechController/BloodyB820RController/BloodyB820RController.h

@@ -0,0 +1,53 @@
+/*---------------------------------------------------------*\
+| BloodyB820RController.h                                   |
+|                                                           |
+|   Driver for A4Tech Bloody B820R Keyboard                 |
+|                                                           |
+|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
+#define HID_MAX_STR                     255
+
+#define BLOODY_B820R_RGB_BUFFER_SIZE    58
+#define BLOODY_B820R_RGB_OFFSET         6
+#define BLOODY_B820R_PACKET_SIZE        64
+#define BLOODY_B820R_KEYCOUNT           104
+#define BLOODY_B820R_MODE_BYTE          3
+#define BLOODY_B820R_DATA_BYTE          8
+#define BLOODY_B820R_GAIN_CONTROL       0x01
+#define BLOODY_B820R_RELEASE_CONTROL    0x00
+
+/*---------------------------------------------------------*\
+| Bloody B820R product ID                                   |
+\*---------------------------------------------------------*/
+#define BLOODY_B820R_PID                            0xFA10
+
+enum
+{
+    BLOODY_B820R_MODE_DIRECT     = 0x01,    // Direct LED control - Independently set LEDs in zone
+};
+
+class BloodyB820RController
+{
+public:
+    BloodyB820RController(hid_device* dev_handle, const char* path);
+    ~BloodyB820RController();
+
+    std::string     GetSerial();
+    std::string     GetLocation();
+
+    void            SetLEDDirect(std::vector<RGBColor> colors);
+    void            SendControlPacket(uint8_t data);
+private:
+    std::string     location;
+    hid_device*     dev;
+};

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.cpp

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

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.h

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------*\
+| RGBController_BloodyB820R.h                               |
+|                                                           |
+|   RGBController for A4Tech Bloody B820R Keyboard          |
+|                                                           |
+|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <vector>
+#include "RGBController.h"
+#include "BloodyB820RController.h"
+
+class RGBController_BloodyB820R : public RGBController
+{
+public:
+    RGBController_BloodyB820R(BloodyB820RController* controller_ptr);
+    ~RGBController_BloodyB820R();
+
+    void    SetupZones();
+    void    ResizeZone(int zone, int new_size);
+
+    void    DeviceUpdateLEDs();
+    void    UpdateZoneLEDs(int zone);
+    void    UpdateSingleLED(int led);
+
+    void    DeviceUpdateMode();
+
+private:
+    BloodyB820RController* controller;
+};

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.cpp

@@ -1,11 +1,13 @@
-/*---------------------------------------------------------------------*\
-|  BloodyMouseController.cpp                                            |
-|                                                                       |
-|  Driver for BloodyMouse USB Controller                                |
-|                                                                       |
-|  Chris M (Dr_No)          30 Jun 2022                                 |
-|                                                                       |
-\*---------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| BloodyMouseController.cpp                                 |
+|                                                           |
+|   Driver for A4Tech Bloody Mouse                          |
+|                                                           |
+|   Chris M (Dr_No)                             30 Jun 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "BloodyMouseController.h"
 #include "LogManager.h"
@@ -26,7 +28,7 @@ BloodyMouseController::~BloodyMouseController()
 
 uint16_t BloodyMouseController::GetPid()
 {
-    return pid;
+    return(pid);
 }
 
 std::string BloodyMouseController::GetSerial()
@@ -45,7 +47,7 @@ std::string BloodyMouseController::GetSerial()
     std::wstring w_tmp  = std::wstring(tmp);
     std::string serial  = std::string(w_tmp.begin(), w_tmp.end());
 
-    return serial;
+    return(serial);
 }
 
 std::string BloodyMouseController::GetLocation()
@@ -53,7 +55,7 @@ std::string BloodyMouseController::GetLocation()
     return("HID: " + location);
 }
 
-void  BloodyMouseController::InitDevice()
+void BloodyMouseController::InitDevice()
 {
     uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
 
@@ -65,7 +67,7 @@ void  BloodyMouseController::InitDevice()
     hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
 }
 
-void  BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors)
+void BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors)
 {
     uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00 };
 

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.h

@@ -1,18 +1,20 @@
-/*---------------------------------------------------------------------*\
-|  BloodyMouseController.h                                              |
-|                                                                       |
-|  Driver for BloodyMouse USB Controller                                |
-|                                                                       |
-|  Chris M (Dr_No)          30 Jun 2022                                 |
-|                                                                       |
-\*---------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| BloodyMouseController.h                                   |
+|                                                           |
+|   Driver for A4Tech Bloody Mouse                          |
+|                                                           |
+|   Chris M (Dr_No)                             30 Jun 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
 
 #include <string>
 #include <hidapi/hidapi.h>
 #include "RGBController.h"
 
-#pragma once
-
 /*-----------------------------------------------------*\
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
@@ -24,7 +26,7 @@
 \*-----------------------------------------------------*/
 #define BLOODY_MP_50RS_PID                          0xFA60
 
-#define HID_MAX_STR 255
+#define HID_MAX_STR                     255
 #define BLOODYMOUSE_WRITE_PACKET_SIZE   64
 
 #define BLOODYMOUSE_BRIGHTNESS_MIN      0
@@ -54,6 +56,7 @@ public:
     std::string     GetLocation();
 
     void            SetLedsDirect(std::vector<RGBColor> colors);
+
 private:
     uint16_t        pid;
     std::string     location;

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.cpp

@@ -1,11 +1,13 @@
-/*---------------------------------------------------------------------*\
-|  RGBController_BloodyMouse.cpp                                        |
-|                                                                       |
-|  Driver for BloodyMouse USB Controller                                |
-|                                                                       |
-|  Chris M (Dr_No)          30 Jun 2022                                 |
-|                                                                       |
-\*---------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_BloodyMouse.cpp                             |
+|                                                           |
+|   RGBController for A4Tech Bloody Mouse                   |
+|                                                           |
+|   Chris M (Dr_No)                             30 Jun 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "RGBController_BloodyMouse.h"
 
@@ -125,7 +127,7 @@ void RGBController_BloodyMouse::SetupZones()
 
         zone new_zone;
         new_zone.name           = mz.name;
-        new_zone.leds_min       = mz.zone_leds.size();
+        new_zone.leds_min       = (unsigned int)mz.zone_leds.size();
         new_zone.leds_max       = new_zone.leds_min;
         new_zone.leds_count     = new_zone.leds_min;
         new_zone.type           = bool_single ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.h

@@ -1,13 +1,16 @@
-/*---------------------------------------------------------------------*\
-|  RGBController_BloodyMouse.h                                          |
-|                                                                       |
-|  Driver for BloodyMouse USB Controller                                |
-|                                                                       |
-|  Chris M (Dr_No)          30 Jun 2022                                 |
-|                                                                       |
-\*---------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_BloodyMouse.h                               |
+|                                                           |
+|   RGBController for A4Tech Bloody Mouse                   |
+|                                                           |
+|   Chris M (Dr_No)                             30 Jun 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
+
 #include <vector>
 #include "RGBController.h"
 #include "BloodyMouseController.h"

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -1,21 +1,23 @@
-/*-----------------------------------------*\
-|  AMDWraithPrismController.h               |
-|                                           |
-|  Driver for AMD Wraith Prism RGB lighting |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/6/2019   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AMDWraithPrismController.cpp                              |
+|                                                           |
+|   Driver for AMD Wraith Prism                             |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
-#include "AMDWraithPrismController.h"
 #include <cstring>
 #include <stdio.h>
 #include <stdlib.h>
+#include "AMDWraithPrismController.h"
 
 AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const char* path)
 {
-    dev         = dev_handle;
-    location    = path;
+    dev                         = dev_handle;
+    location                    = path;
 
     current_fan_mode            = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
     current_fan_speed           = 0xFF;

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

@@ -1,19 +1,20 @@
-/*-----------------------------------------*\
-|  AMDWraithPrismController.h               |
-|                                           |
-|  Definitions and types for AMD Wraith     |
-|  Prism lighting controller                |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/6/2019   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AMDWraithPrismController.h                                |
+|                                                           |
+|   Driver for AMD Wraith Prism                             |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
 
 #include <string>
 #include <hidapi/hidapi.h>
-
 #include "RGBController.h"
 
-#pragma once
-
 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX     0xFF
 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_CYCLE_MAX       0x7F
 

Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp

@@ -1,11 +1,29 @@
+/*---------------------------------------------------------*\
+| AMDWraithPrismControllerDetect.cpp                        |
+|                                                           |
+|   Detector for AMD Wraith Prism                           |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <hidapi/hidapi.h>
 #include "Detector.h"
 #include "AMDWraithPrismController.h"
 #include "RGBController.h"
 #include "RGBController_AMDWraithPrism.h"
-#include <hidapi/hidapi.h>
 
-#define AMD_WRAITH_PRISM_VID 0x2516
-#define AMD_WRAITH_PRISM_PID 0x0051
+/*---------------------------------------------------------*\
+| AMD Wraith Prism vendor ID                                |
+\*---------------------------------------------------------*/
+#define AMD_WRAITH_PRISM_VID                        0x2516
+
+/*---------------------------------------------------------*\
+| AMD Wraith Prism product ID                               |
+\*---------------------------------------------------------*/
+#define AMD_WRAITH_PRISM_PID                        0x0051
 
 /******************************************************************************************\
 *                                                                                          *

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -1,11 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_AMDWraithPrism.cpp         |
-|                                           |
-|  Generic RGB Interface for AMD Wraith     |
-|  Prism                                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/25/2019  |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AMDWraithPrism.cpp                          |
+|                                                           |
+|   RGBController for AMD Wraith Prism                      |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                25 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "RGBController_AMDWraithPrism.h"
 
@@ -25,14 +27,14 @@
 
 RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismController* controller_ptr)
 {
-    controller  = controller_ptr;
+    controller                  = controller_ptr;
 
-    name        = "AMD Wraith Prism";
-    vendor      = "Cooler Master";
-    type        = DEVICE_TYPE_COOLER;
-    description = "AMD Wraith Prism Device";
-    version     = controller->GetFirmwareVersionString();
-    location    = controller->GetLocationString();
+    name                        = "AMD Wraith Prism";
+    vendor                      = "Cooler Master";
+    type                        = DEVICE_TYPE_COOLER;
+    description                 = "AMD Wraith Prism Device";
+    version                     = controller->GetFirmwareVersionString();
+    location                    = controller->GetLocationString();
 
     mode Direct;
     Direct.name                 = "Direct";
@@ -138,8 +140,8 @@ void RGBController_AMDWraithPrism::SetupZones()
     /*---------------------------------------------------------*\
     | LED maps                                                  |
     \*---------------------------------------------------------*/
-    const unsigned int logo_leds[1] =   { 0x00 };
-    const unsigned int fan_leds[1] =    { 0x01 };
+    const unsigned int logo_leds[1]  =  { 0x00 };
+    const unsigned int fan_leds[1]   =  { 0x01 };
     const unsigned int ring_leds[14] =  { 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x10, 0x0F,
                                           0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09 };
 
@@ -179,24 +181,24 @@ void RGBController_AMDWraithPrism::SetupZones()
     for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
     {
         led logo_led;
-        logo_led.name = "Logo LED";
-        logo_led.value = logo_leds[led_idx];
+        logo_led.name       = "Logo LED";
+        logo_led.value      = logo_leds[led_idx];
         leds.push_back(logo_led);
     }
 
     for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
     {
         led fan_led;
-        fan_led.name = "Fan LED";
-        fan_led.value = fan_leds[led_idx];
+        fan_led.name        = "Fan LED";
+        fan_led.value       = fan_leds[led_idx];
         leds.push_back(fan_led);
     }
 
     for(unsigned int led_idx = 0; led_idx < 14; led_idx++)
     {
         led ring_led;
-        ring_led.name = "Ring LED";
-        ring_led.value = ring_leds[led_idx];
+        ring_led.name       = "Ring LED";
+        ring_led.value      = ring_leds[led_idx];
         leds.push_back(ring_led);
     }
 

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.h

@@ -1,13 +1,16 @@
-/*-----------------------------------------*\
-|  RGBController_AMDWraithPrism.h           |
-|                                           |
-|  Generic RGB Interface for AMD Wraith     |
-|  Prism                                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/25/2019  |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AMDWraithPrism.h                            |
+|                                                           |
+|   RGBController for AMD Wraith Prism                      |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                25 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
+
 #include "RGBController.h"
 #include "AMDWraithPrismController.h"
 

Controllers/AOCKeyboardController/AOCKeyboardController.cpp

@@ -1,17 +1,18 @@
-/*-----------------------------------------*\
-|  AOCKeyboardController.cpp                |
-|                                           |
-|  Driver for AOC Keyboard lighting         |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/10/2023   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AOCKeyboardController.cpp                                 |
+|                                                           |
+|   Driver for AOC keyboard                                 |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                10 May 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
-#include "AOCKeyboardController.h"
-
-#include <cstring>
 #include <chrono>
+#include <cstring>
 #include <thread>
+#include "AOCKeyboardController.h"
 
 using namespace std::chrono_literals;
 

Controllers/AOCKeyboardController/AOCKeyboardController.h

@@ -1,18 +1,20 @@
-/*-----------------------------------------*\
-|  AOCKeyboardController.h                  |
-|                                           |
-|  Definitions and types for AOC keyboard   |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/10/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-#include <string>
+/*---------------------------------------------------------*\
+| AOCKeyboardController.h                                   |
+|                                                           |
+|   Driver for AOC keyboard                                 |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                10 May 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
 
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
 /*-----------------------------------------*\
 | AOC Keyboard Modes                        |
 \*-----------------------------------------*/

Controllers/AOCKeyboardController/AOCKeyboardControllerDetect.cpp

@@ -1,13 +1,25 @@
+/*---------------------------------------------------------*\
+| AOCKeyboardControllerDetect.cpp                           |
+|                                                           |
+|   Detector for AOC keyboard                               |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                10 May 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
 #include "Detector.h"
 #include "AOCKeyboardController.h"
 #include "RGBController.h"
 #include "RGBController_AOCKeyboard.h"
 
 /*-----------------------------------------------------*\
-| AOC Mousemat IDs                                      |
+| AOC Keyboard IDs                                      |
 \*-----------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GK500_PID                               0x1178
+#define AOC_GK500_PID_2                             0x1229
 
 /******************************************************************************************\
 *                                                                                          *
@@ -32,3 +44,4 @@ void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name
 }
 
 REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID,   0xFF19, 0xFF19);
+REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID_2, 0xFF19, 0xFF19);

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp

@@ -1,10 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_AOCKeyboard.cpp            |
-|                                           |
-|  Generic RGB Interface for AOC keyboard   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/10/2023   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AOCKeyboard.cpp                             |
+|                                                           |
+|   RGBController for AOC keyboard                          |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                10 May 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "RGBController_AOCKeyboard.h"
 #include "KeyboardLayoutManager.h"
@@ -47,14 +50,14 @@ layout_values aoc_keyboard_offset_values =
 
 RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* controller_ptr)
 {
-    controller  = controller_ptr;
+    controller                      = controller_ptr;
 
-    name        = "AOC Keyboard Device";
-    vendor      = "AOC";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "AOC Keyboard Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
+    name                            = "AOC Keyboard Device";
+    vendor                          = "AOC";
+    type                            = DEVICE_TYPE_KEYBOARD;
+    description                     = "AOC Keyboard Device";
+    location                        = controller->GetDeviceLocation();
+    serial                          = controller->GetSerialString();
 
     mode Static;
     Static.name                     = "Static";
@@ -288,7 +291,7 @@ void RGBController_AOCKeyboard::SetupZones()
     | Create LEDs for the Matrix zone                           |
     |   Place keys in the layout to populate the matrix         |
     \*---------------------------------------------------------*/
-    for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
+    for(unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
     {
         led new_led;
 
@@ -299,8 +302,6 @@ void RGBController_AOCKeyboard::SetupZones()
 
     zones.push_back(new_zone);
 
-
-
     SetupColors();
 }
 

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.h

@@ -1,10 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_AOCKeyboard.h              |
-|                                           |
-|  Generic RGB Interface for AOC keyboard   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/10/2023   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AOCKeyboard.h                               |
+|                                                           |
+|   RGBController for AOC keyboard                          |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                10 May 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
 

Controllers/AOCMouseController/AOCMouseController.cpp

@@ -1,14 +1,16 @@
-/*-----------------------------------------*\
-|  AOCMouseController.cpp                   |
-|                                           |
-|  Driver for AOC Mouse lighting controller |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/20/2023   |
-\*-----------------------------------------*/
-
-#include "AOCMouseController.h"
+/*---------------------------------------------------------*\
+| AOCMouseController.cpp                                    |
+|                                                           |
+|   Driver for AOC mouse                                    |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include <cstring>
+#include "AOCMouseController.h"
 
 AOCMouseController::AOCMouseController(hid_device* dev_handle, const char* path)
 {

Controllers/AOCMouseController/AOCMouseController.h

@@ -1,18 +1,20 @@
-/*-----------------------------------------*\
-|  AOCMouseController.h                     |
-|                                           |
-|  Definitions and types for AOC mouse      |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/20/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-#include <string>
+/*---------------------------------------------------------*\
+| AOCMouseController.h                                      |
+|                                                           |
+|   Driver for AOC mouse                                    |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
 
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
 /*-----------------------------------------*\
 | AOC Mousemat Modes                        |
 |   Note: The 0x80 bit is the random flag   |

Controllers/AOCMouseController/AOCMouseControllerDetect.cpp

@@ -1,10 +1,21 @@
+/*---------------------------------------------------------*\
+| AOCMouseControllerDetect.cpp                              |
+|                                                           |
+|   Detector for AOC mouse                                  |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
 #include "Detector.h"
 #include "AOCMouseController.h"
 #include "RGBController.h"
 #include "RGBController_AOCMouse.h"
 
 /*-----------------------------------------------------*\
-| AOC Mousemat IDs                                      |
+| AOC Mouse IDs                                         |
 \*-----------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GM500_PID                               0x1179

Controllers/AOCMouseController/RGBController_AOCMouse.cpp

@@ -1,10 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_AOCMouse.cpp               |
-|                                           |
-|  Generic RGB Interface for AOC mouse      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/20/2023   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AOCMouse.cpp                                |
+|                                                           |
+|   RGBController for AOC mouse                             |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "RGBController_AOCMouse.h"
 
@@ -21,14 +24,14 @@
 
 RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_ptr)
 {
-    controller  = controller_ptr;
+    controller                      = controller_ptr;
 
-    name        = "AOC Mouse Device";
-    vendor      = "AOC";
-    type        = DEVICE_TYPE_MOUSE;
-    description = "AOC Mouse Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
+    name                            = "AOC Mouse Device";
+    vendor                          = "AOC";
+    type                            = DEVICE_TYPE_MOUSE;
+    description                     = "AOC Mouse Device";
+    location                        = controller->GetDeviceLocation();
+    serial                          = controller->GetSerialString();
 
     mode Direct;
     Direct.name                     = "Direct";

Controllers/AOCMouseController/RGBController_AOCMouse.h

@@ -1,10 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_AOCMouse.h                 |
-|                                           |
-|  Generic RGB Interface for AOC mouse      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/20/2023   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AOCMouse.h                                  |
+|                                                           |
+|   RGBController for AOC mouse                             |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
 

Controllers/AOCMousematController/AOCMousematController.cpp

@@ -1,15 +1,16 @@
-/*-----------------------------------------*\
-|  AOCMousematController.cpp                |
-|                                           |
-|  Driver for AOC Mousemat lighting         |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/15/2023   |
-\*-----------------------------------------*/
-
-#include "AOCMousematController.h"
+/*---------------------------------------------------------*\
+| AOCMousematController.cpp                                 |
+|                                                           |
+|   Driver for AOC mousemat                                 |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include <cstring>
+#include "AOCMousematController.h"
 
 AOCMousematController::AOCMousematController(hid_device* dev_handle, const char* path)
 {

Controllers/AOCMousematController/AOCMousematController.h

@@ -1,18 +1,20 @@
-/*-----------------------------------------*\
-|  AOCMousematController.h                  |
-|                                           |
-|  Definitions and types for AOC mousemat   |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/15/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-#include <string>
+/*---------------------------------------------------------*\
+| AOCMousematController.h                                   |
+|                                                           |
+|   Driver for AOC mousemat                                 |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
 
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
 /*-----------------------------------------*\
 | AOC Mousemat Modes                        |
 |   Note: The 0x80 bit is the random flag   |

Controllers/AOCMousematController/AOCMousematControllerDetect.cpp

@@ -1,3 +1,14 @@
+/*---------------------------------------------------------*\
+| AOCMousematControllerDetect.cpp                           |
+|                                                           |
+|   Detector for AOC mousemat                               |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
 #include "Detector.h"
 #include "AOCMousematController.h"
 #include "RGBController.h"
@@ -31,4 +42,4 @@ void DetectAOCMousematControllers(hid_device_info* info, const std::string& name
     }
 }
 
-REGISTER_HID_DETECTOR_IPU("AOC AGON AMM700",    DetectAOCMousematControllers,   AOC_VID,    AOC_AMM700_PID, 1,  0xFF19,  0xFF19);
+REGISTER_HID_DETECTOR_IPU("AOC AGON AMM700",    DetectAOCMousematControllers,   AOC_VID,    AOC_AMM700_PID, 1,  0xFF19,  0xFF19);

Controllers/AOCMousematController/RGBController_AOCMousemat.cpp

@@ -1,10 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_AOCMousemat.cpp            |
-|                                           |
-|  Generic RGB Interface for AOC mousemat   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/15/2023   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AOCMousemat.cpp                             |
+|                                                           |
+|   RGBController for AOC mousemat                          |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "RGBController_AOCMousemat.h"
 
@@ -21,14 +24,14 @@
 
 RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* controller_ptr)
 {
-    controller  = controller_ptr;
+    controller                      = controller_ptr;
 
-    name        = "AOC Mousemat Device";
-    vendor      = "AOC";
-    type        = DEVICE_TYPE_MOUSEMAT;
-    description = "AOC Mousemat Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
+    name                            = "AOC Mousemat Device";
+    vendor                          = "AOC";
+    type                            = DEVICE_TYPE_MOUSEMAT;
+    description                     = "AOC Mousemat Device";
+    location                        = controller->GetDeviceLocation();
+    serial                          = controller->GetSerialString();
 
     mode Direct;
     Direct.name                     = "Direct";

Controllers/AOCMousematController/RGBController_AOCMousemat.h

@@ -1,10 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_AOCMousemat.h              |
-|                                           |
-|  Generic RGB Interface for AOC mousemat   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/15/2023   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AOCMousemat.h                               |
+|                                                           |
+|   RGBController for AOC mousemat                          |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -1,20 +1,22 @@
-/*-----------------------------------------*\
-|  ASRockPolychromeUSBController.cpp        |
-|                                           |
-|  Driver for ASRock Polychrome USB         |
-|  lighting controller                      |
-|                                           |
-|  Ed Kambulow (dredvard) 12/20/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| ASRockPolychromeUSBController.cpp                         |
+|                                                           |
+|   Driver for ASRock Polychrome USB motherboards           |
+|                                                           |
+|   Ed Kambulow (dredvard)                      20 Dec 2020 |
+|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
 #include <cstring>
 #include <stdio.h>
-
 #include "RGBController.h"
 #include "ResourceManager.h"
 #include "SettingsManager.h"
 #include "ASRockPolychromeUSBController.h"
-#include "dependencies/dmiinfo.h"
+#include "dmiinfo.h"
 
 #define POLYCHROME_USB_READ_ZONE_CONFIG 0x11
 #define POLYCHROME_USB_READ_HEADER      0x14
@@ -55,7 +57,7 @@ PolychromeUSBController::~PolychromeUSBController()
 
 unsigned int PolychromeUSBController::GetChannelCount()
 {
-    return(device_info.size());
+    return((unsigned int)device_info.size());
 }
 
 std::string PolychromeUSBController::GetDeviceLocation()
@@ -381,7 +383,7 @@ void PolychromeUSBController::WriteRGSwap
     bool chnl8
     )
 {
-    unsigned char rgconfig[1] = {static_cast<unsigned char>(((chnl8 << 7) | (pcb << 6) | (io << 5) | (pch << 4) | (ahdr1 << 3) | (ahdr0 << 2) | (hdr1 << 1) | hdr0))};
+    unsigned char rgconfig[1] = {static_cast<unsigned char>((((unsigned char)chnl8 << 7) | ((unsigned char)pcb << 6) | ((unsigned char)io << 5) | ((unsigned char)pch << 4) | ((unsigned char)ahdr1 << 3) | ((unsigned char)ahdr0 << 2) | ((unsigned char)hdr1 << 1) | (unsigned char)hdr0))};
     WriteHeader(POLYCHROME_USB_RGSWAP_CFG, rgconfig, 1);
 }
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

@@ -1,19 +1,21 @@
-/*-----------------------------------------*\
-|  ASRockPolychromeUSBController.h          |
-|                                           |
-|  Driver for ASRock Polychrome USB         |
-|  lighting controller                      |
-|                                           |
-|  Ed Kambulow (dredvard) 12/20/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-#include <string>
+/*---------------------------------------------------------*\
+| ASRockPolychromeUSBController.h                           |
+|                                                           |
+|   Driver for ASRock Polychrome USB motherboards           |
+|                                                           |
+|   Ed Kambulow (dredvard)                      20 Dec 2020 |
+|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
 
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
 /*----------------------------------------------------------------------------------------------*\
 | Definitions for Polychrome USB                                                                 |
 \*----------------------------------------------------------------------------------------------*/
@@ -159,7 +161,7 @@ private:
     unsigned char configtable[12];
     bool          rgswapconfig[8] = { 0 };
 
-    void SetDeviceInfo();    
+    void SetDeviceInfo();
     void ReadConfigTables();
     void Commit();
 };

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBControllerDetect.cpp

@@ -1,13 +1,25 @@
+/*---------------------------------------------------------*\
+| ASRockPolychromeUSBControllerDetect.cpp                   |
+|                                                           |
+|   Detector for ASRock Polychrome USB motherboards         |
+|                                                           |
+|   Ed Kambulow (dredvard)                      20 Dec 2020 |
+|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <hidapi/hidapi.h>
 #include "Detector.h"
 #include "ASRockPolychromeUSBController.h"
 #include "RGBController.h"
 #include "RGBController_ASRockPolychromeUSB.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-#include <hidapi/hidapi.h>
 
 /*---------------------------------------------------------*\
 | ASRock vendor ID                                          |
@@ -32,5 +44,5 @@ void DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*
     }
 }
 
-REGISTER_HID_DETECTOR("ASRock Polychrome USB", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);
-REGISTER_HID_DETECTOR("ASRock Deskmini Addressable LED Strip", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID);
+REGISTER_HID_DETECTOR("ASRock Polychrome USB",                  DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);
+REGISTER_HID_DETECTOR("ASRock Deskmini Addressable LED Strip",  DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID);

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -1,15 +1,17 @@
-/*-----------------------------------------*\
-|  RGBController_ASRockPolychromeUSB.cpp    |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  ASRock Polychrome USB Driver             |
-|                                           |
-|  Ed Kambulow (Dredvard) 12/26/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_ASRockPolychromeUSB.cpp                     |
+|                                                           |
+|   RGBController for ASRock Polychrome USB motherboards    |
+|                                                           |
+|   Ed Kambulow (dredvard)                      20 Dec 2020 |
+|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
-#include "RGBController_ASRockPolychromeUSB.h"
 #include <string.h>
+#include "RGBController_ASRockPolychromeUSB.h"
 
 #define ASROCK_USB_MAX_ZONES        8
 #define ASROCK_ADDRESSABLE_MAX_LEDS 100
@@ -293,7 +295,7 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
             set_mode = active_mode;
         }
 
-        controller->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
+        controller->WriteZone((unsigned char)zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
     }
 }
 

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -1,12 +1,14 @@
-/*-----------------------------------------*\
-|  RGBController_ASRockPolychromeUSB.h      |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  ASRock Polychrome USB Driver             |
-|                                           |
-|  Ed Kambulow (Dredvard) 12/26/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_ASRockPolychromeUSB.h                       |
+|                                                           |
+|   RGBController for ASRock Polychrome USB motherboards    |
+|                                                           |
+|   Ed Kambulow (dredvard)                      20 Dec 2020 |
+|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
 

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/ASRockASRRGBSMBusController.cpp

@@ -1,15 +1,17 @@
-/*-----------------------------------------*\
-|  ASRockPolychromeSMBusController.cpp      |
-|                                           |
-|  Driver for for ASRock ASR LED and        |
-|  Polychrome RGB lighting controller       |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/14/2019  |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| ASRockASRRGBSMBusController.cpp                           |
+|                                                           |
+|   Driver for SMBus ASRock ASR RGB motherboards            |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "ASRockASRRGBSMBusController.h"
 #include <cstring>
-#include "dependencies/dmiinfo.h"
+#include "dmiinfo.h"
 #include "LogManager.h"
 
 #define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
@@ -64,7 +66,7 @@ void ASRockASRRGBSMBusController::SetColorsAndSpeed(uint8_t led, uint8_t red, ui
 {
     uint8_t color_speed_pkt[4] = { red, green, blue, active_speed };
     uint8_t select_led_pkt[1]  = { led };
-    
+
     /*-----------------------------------------------------*\
     | Select LED                                            |
     \*-----------------------------------------------------*/

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/ASRockASRRGBSMBusController.h

@@ -1,18 +1,19 @@
-/*-----------------------------------------*\
-|  ASRockASRRGBSMBusController.h        |
-|                                           |
-|  Definitions and types for ASRock         |
-|  ASR LED and Polychrome RGB lighting      |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/13/2019  |
-\*-----------------------------------------*/
-
-#include "i2c_smbus.h"
-#include <string>
+/*---------------------------------------------------------*\
+| ASRockASRRGBSMBusController.h                             |
+|                                                           |
+|   Driver for SMBus ASRock ASR RGB motherboards            |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
 
+#include <string>
+#include "i2c_smbus.h"
+
 typedef uint8_t	polychrome_dev_id;
 
 #define ASROCK_ASR_CONTROLLER_NAME  "ASRock ASR RGB SMBus Controller"
@@ -63,7 +64,7 @@ public:
     uint8_t                 GetMode();
     void                    SetColorsAndSpeed(uint8_t led, uint8_t red, uint8_t green, uint8_t blue);
     void                    SetMode(uint8_t zone, uint8_t mode, uint8_t speed);
-    
+
     uint16_t                fw_version;
 
 private:

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.cpp

@@ -1,11 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_ASRockPolychromeSMBus.cpp  |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  ASRock ASR LED and Polychrome RGB Driver |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/15/2019  |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_ASRRGBSMBus.cpp                             |
+|                                                           |
+|   RGBController for SMBus ASRock ASR LED motherboards     |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "RGBController_ASRockASRRGBSMBus.h"
 
@@ -167,7 +169,7 @@ void RGBController_ASRockASRRGBSMBus::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_ASRockASRRGBSMBus::DeviceUpdateLEDs()
 {
-    for (std::size_t led = 0; led < colors.size(); led++)
+    for(int led = 0; led < colors.size(); led++)
     {
         UpdateSingleLED(led);
     }

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.h

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------*\
+| RGBController_ASRRGBSMBus.h                               |
+|                                                           |
+|   RGBController for SMBus ASRock ASR RGB motherboards     |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockASRRGBSMBusController.h"
+
+class RGBController_ASRockASRRGBSMBus : public RGBController
+{
+public:
+    RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMBusController* controller_ptr);
+    ~RGBController_ASRockASRRGBSMBus();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    ASRockASRRGBSMBusController* controller;
+};

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/ASRockPolychromeV1SMBusController.cpp

@@ -1,15 +1,17 @@
-/*-----------------------------------------*\
-|  ASRockPolychromeV1SMBusController.cpp    |
-|                                           |
-|  Driver for for ASRock ASR LED and        |
-|  Polychrome RGB lighting controller       |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/14/2019  |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| ASRockPolychromeV1SMBusController.cpp                     |
+|                                                           |
+|   Driver for SMBus ASRock Polychrome V1 motherboards      |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
-#include "ASRockPolychromeV1SMBusController.h"
 #include <cstring>
-#include "dependencies/dmiinfo.h"
+#include "ASRockPolychromeV1SMBusController.h"
+#include "dmiinfo.h"
 #include "LogManager.h"
 
 #define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/ASRockPolychromeV1SMBusController.h

@@ -1,19 +1,20 @@
-/*-----------------------------------------*\
-|  ASRockPolychromeV1SMBusController.h      |
-|                                           |
-|  Definitions and types for ASRock         |
-|  ASR LED and Polychrome RGB lighting      |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/13/2019  |
-\*-----------------------------------------*/
-
-#include "i2c_smbus.h"
-#include "RGBController.h"
-#include <string>
+/*---------------------------------------------------------*\
+| ASRockPolychromeV1SMBusController.h                       |
+|                                                           |
+|   Driver for SMBus ASRock Polychrome V1 motherboards      |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
 
+#include <string>
+#include "i2c_smbus.h"
+#include "RGBController.h"
+
 typedef uint8_t	polychrome_dev_id;
 
 #define ASROCK_V1_CONTROLLER_NAME  "ASRock Polychrome v1 SMBus Controller"

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.cpp

@@ -1,11 +1,14 @@
-/*-----------------------------------------*\
-|  RGBController_ASRockPolychromeSMBus.cpp  |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  ASRock ASR LED and Polychrome RGB Driver |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/15/2019  |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_ASRockPolychromeV1SMBus.cpp                 |
+|                                                           |
+|   RGBController for SMBus ASRock Polychrome V1            |
+|   motherboards                                            |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "LogManager.h"
 #include "RGBController_ASRockPolychromeV1SMBus.h"

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.h

@@ -0,0 +1,38 @@
+/*---------------------------------------------------------*\
+| RGBController_ASRockPolychromeV1SMBus.h                   |
+|                                                           |
+|   RGBController for SMBus ASRock Polychrome V1            |
+|   motherboards                                            |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockPolychromeV1SMBusController.h"
+
+class RGBController_ASRockPolychromeV1SMBus : public RGBController
+{
+public:
+    RGBController_ASRockPolychromeV1SMBus(ASRockPolychromeV1SMBusController* controller_ptr);
+    ~RGBController_ASRockPolychromeV1SMBus();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    ASRockPolychromeV1SMBusController* controller;
+    uint8_t                 getModeIndex(uint8_t mode_value);
+    std::vector<uint8_t>    zoneIndexMap;
+};

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/ASRockPolychromeV2SMBusController.cpp

@@ -1,15 +1,17 @@
-/*-----------------------------------------*\
-|  ASRockPolychromeV2SMBusController.cpp    |
-|                                           |
-|  Driver for for ASRock ASR LED and        |
-|  Polychrome RGB lighting controller       |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/14/2019  |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| ASRockPolychromeV2SMBusController.cpp                     |
+|                                                           |
+|   Driver for SMBus ASRock Polychrome V2 motherboards      |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
-#include "ASRockPolychromeV2SMBusController.h"
 #include <cstring>
-#include "dependencies/dmiinfo.h"
+#include "ASRockPolychromeV2SMBusController.h"
+#include "dmiinfo.h"
 #include "LogManager.h"
 
 #define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/ASRockPolychromeV2SMBusController.h

@@ -1,18 +1,19 @@
-/*-----------------------------------------*\
-|  ASRockPolychromeSMBusController.h        |
-|                                           |
-|  Definitions and types for ASRock         |
-|  ASR LED and Polychrome RGB lighting      |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/13/2019  |
-\*-----------------------------------------*/
-
-#include "i2c_smbus.h"
-#include <string>
+/*---------------------------------------------------------*\
+| ASRockPolychromeV2SMBusController.h                       |
+|                                                           |
+|   Driver for SMBus ASRock Polychrome V2 motherboards      |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
 
+#include <string>
+#include "i2c_smbus.h"
+
 typedef uint8_t polychrome_dev_id;
 
 #define ASROCK_V2_CONTROLLER_NAME  "ASRock Polychrome v2 SMBus Controller"
@@ -132,7 +133,7 @@ public:
 
     uint8_t                 zone_led_count[6];
     uint16_t                fw_version;
-    
+
 private:
     std::string             device_name;
     uint8_t                 active_zone;

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

@@ -1,11 +1,14 @@
-/*-----------------------------------------*\
-|  RGBController_ASRockPolychromeV2SMBus.cpp|
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  ASRock ASR LED and Polychrome RGB Driver |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/15/2019  |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_ASRockPolychromeV2SMBus.cpp                 |
+|                                                           |
+|   RGBController for SMBus ASRock Polychrome V2            |
+|   motherboards                                            |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "RGBController_ASRockPolychromeV2SMBus.h"
 
@@ -287,7 +290,7 @@ void RGBController_ASRockPolychromeV2SMBus::ResizeZone(int /*zone*/, int /*new_s
 
 void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateLEDs()
 {
-    for (std::size_t led = 0; led < colors.size(); led++)
+    for(int led = 0; led < colors.size(); led++)
     {
         UpdateSingleLED(led);
     }

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.h

@@ -0,0 +1,36 @@
+/*---------------------------------------------------------*\
+| RGBController_ASRockPolychromeV2SMBus.h                   |
+|                                                           |
+|   RGBController for SMBus ASRock Polychrome V2            |
+|   motherboards                                            |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockPolychromeV2SMBusController.h"
+
+class RGBController_ASRockPolychromeV2SMBus : public RGBController
+{
+public:
+    RGBController_ASRockPolychromeV2SMBus(ASRockPolychromeV2SMBusController* controller_ptr);
+    ~RGBController_ASRockPolychromeV2SMBus();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    ASRockPolychromeV2SMBusController* controller;
+};

Controllers/ASRockSMBusController/ASRockSMBusControllerDetect.cpp

@@ -1,3 +1,18 @@
+/*---------------------------------------------------------*\
+| ASRockSMBusControllerDetect.cpp                           |
+|                                                           |
+|   Detector for SMBus ASRock ASR RGB and Polychrome        |
+|   motherboards                                            |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
 #include "Detector.h"
 #include "ASRockASRRGBSMBusController.h"
 #include "ASRockPolychromeV1SMBusController.h"
@@ -9,9 +24,6 @@
 #include "RGBController_ASRockPolychromeV2SMBus.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
 
 /*******************************************************************************************\
 *                                                                                           *

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.h

@@ -1,35 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_ASRockPolychromeV1SMBus.h  |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  ASRock ASR LED and Polychrome RGB Driver |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/15/2019  |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "ASRockPolychromeV1SMBusController.h"
-
-class RGBController_ASRockPolychromeV1SMBus : public RGBController
-{
-public:
-    RGBController_ASRockPolychromeV1SMBus(ASRockPolychromeV1SMBusController* controller_ptr);
-    ~RGBController_ASRockPolychromeV1SMBus();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    ASRockPolychromeV1SMBusController* controller;
-    uint8_t                 getModeIndex(uint8_t mode_value);
-    std::vector<uint8_t>    zoneIndexMap;
-};

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV2SMBus.h

@@ -1,33 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_ASRockPolychromev2SMBus.h  |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  ASRock ASR LED and Polychrome RGB Driver |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/15/2019  |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "ASRockPolychromeV2SMBusController.h"
-
-class RGBController_ASRockPolychromeV2SMBus : public RGBController
-{
-public:
-    RGBController_ASRockPolychromeV2SMBus(ASRockPolychromeV2SMBusController* controller_ptr);
-    ~RGBController_ASRockPolychromeV2SMBus();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    ASRockPolychromeV2SMBusController* controller;
-};

Controllers/AlienwareController/AlienwareController.cpp

@@ -1,13 +1,14 @@
-/*-----------------------------------------*\
-|  AlienwareController.cpp                  |
-|                                           |
-|  Driver for Alienware lighting controller |
-|                                           |
-|  Gabriel Marcano (gemarcano) 4/21/2021    |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AlienwareController.cpp                                   |
+|                                                           |
+|   Driver for Dell Alienware RGB USB controller            |
+|                                                           |
+|   Gabriel Marcano (gemarcano)                 21 Apr 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
-#include "RGBController.h"
-#include "AlienwareController.h"
 #include <cstring>
 #include <cstdint>
 #include <map>
@@ -15,6 +16,8 @@
 #include <chrono>
 #include <algorithm>
 #include <sstream>
+#include "RGBController.h"
+#include "AlienwareController.h"
 #include "LogManager.h"
 
 typedef uint32_t alienware_platform_id;
@@ -167,7 +170,7 @@ AlienwareController::~AlienwareController()
 
 unsigned int AlienwareController::GetZoneCount()
 {
-    return(zones.size());
+    return((unsigned int)zones.size());
 }
 
 std::vector<const char*> AlienwareController::GetZoneNames()
@@ -272,7 +275,7 @@ bool AlienwareController::Dim(std::vector<uint8_t> zones, double percent)
     /*-----------------------------------------------------*\
     | Set up message packet with leading 00, per hidapi     |
     \*-----------------------------------------------------*/
-    uint16_t num_zones  = zones.size();
+    uint16_t num_zones  = (uint16_t)zones.size();
 
     usb_buf[0x00]       = 0x00;
     usb_buf[0x01]       = 0x03;
@@ -376,7 +379,7 @@ bool AlienwareController::SelectZones(const std::vector<uint8_t>& zones)
     /*-----------------------------------------------------*\
     | Set up message packet with leading 00, per hidapi     |
     \*-----------------------------------------------------*/
-    uint16_t num_zones  = zones.size();
+    uint16_t num_zones  = (uint16_t)zones.size();
 
     usb_buf[0x00]       = 0x00;
     usb_buf[0x01]       = 0x03;
@@ -515,7 +518,7 @@ bool AlienwareController::SetColorDirect(RGBColor color, std::vector<uint8_t> zo
     /*-----------------------------------------------------*\
     | Set up message packet with leading 00, per hidapi     |
     \*-----------------------------------------------------*/
-    uint16_t num_zones      = zones.size();
+    uint16_t num_zones      = (uint16_t)zones.size();
 
     usb_buf[0x00]           = 0x00;
     usb_buf[0x01]           = 0x03;

Controllers/AlienwareController/AlienwareController.h

@@ -1,18 +1,20 @@
-/*-----------------------------------------*\
-|  AlienwareController.h                    |
-|                                           |
-|  Driver for Dell Alienware RGB USB        |
-|  controller                               |
-|                                           |
-|  Gabriel Marcano (gemarcano) 4/19/2021    |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-#include <string>
+/*---------------------------------------------------------*\
+| AlienwareController.h                                     |
+|                                                           |
+|   Driver for Dell Alienware RGB USB controller            |
+|                                                           |
+|   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
 
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
 /*----------------------------------------------------------------------------------------------*\
 | Definitions for Alienware Controller                                                           |
 \*----------------------------------------------------------------------------------------------*/

Controllers/AlienwareController/AlienwareControllerDetect.cpp

@@ -1,3 +1,12 @@
+/*---------------------------------------------------------*\
+| AlienwareControllerDetect.cpp                             |
+|                                                           |
+|   Detector for Dell Alienware RGB USB controller          |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
 #include "Detector.h"
 #include "AlienwareController.h"
 #include "RGBController.h"
@@ -11,7 +20,7 @@
 /*---------------------------------------------------------*\
 | Alienware product ID                                      |
 \*---------------------------------------------------------*/
-#define ALIENWARE_G_SERIES_PID                         0x0550
+#define ALIENWARE_G_SERIES_PID                      0x0550
 
 void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
 {

Controllers/AlienwareController/RGBController_Alienware.cpp

@@ -1,16 +1,17 @@
-/*-----------------------------------------*\
-|  RGBController_Alienware.cpp              |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  Alienware USB Driver                     |
-|                                           |
-|  Gabriel Marcano (gemarcano) 4/19/2021    |
-\*-----------------------------------------*/
-
-#include "RGBController_Alienware.h"
+/*---------------------------------------------------------*\
+| RGBController_Alienware.cpp                               |
+|                                                           |
+|   RGBController for Dell Alienware RGB USB controller     |
+|                                                           |
+|   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include <thread>
 #include <chrono>
+#include "RGBController_Alienware.h"
 
 /**------------------------------------------------------------------*\
     @name Alienware
@@ -213,7 +214,7 @@ void RGBController_Alienware::DeviceUpdateMode()
         /*-----------------------------------------------------*\
         | Setup state per zone                                  |
         \*-----------------------------------------------------*/
-        for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+        for(uint8_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
         {
             zone current_zone = zones[zone_idx];
 

Controllers/AlienwareController/RGBController_Alienware.h

@@ -1,19 +1,20 @@
-/*-----------------------------------------*\
-|  RGBController_Alienware.h                |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  Alienware RGB USB Driver                 |
-|                                           |
-|  Gabriel Marcano (gemarcano) 4/19/2021    |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_Alienware.h                                 |
+|                                                           |
+|   RGBController for Dell Alienware RGB USB controller     |
+|                                                           |
+|   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
 
+#include <chrono>
 #include "RGBController.h"
 #include "AlienwareController.h"
 
-#include <chrono>
-
 class RGBController_Alienware : public RGBController
 {
 public:

Controllers/AlienwareKeyboardController/AlienwareAW410KController/AlienwareAW410KController.cpp

@@ -0,0 +1,448 @@
+/*---------------------------------------------------------*\
+| AlienwareAW410KController.cpp                             |
+|                                                           |
+|   Driver for Alienware AW410K keyboard                    |
+|                                                           |
+|   based on AW510K controller by Mohamad Sallal (msallal)  |
+|   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <cstring>
+#include "AlienwareAW410KController.h"
+
+AlienwareAW410KController::AlienwareAW410KController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+
+    SendCommit();
+}
+
+AlienwareAW410KController::~AlienwareAW410KController()
+{
+    hid_close(dev);
+}
+
+std::string AlienwareAW410KController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AlienwareAW410KController::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+void AlienwareAW410KController::SendCommit()
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x0A]           = 0x10;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0C]           = 0x01;
+    usb_buf[0x0D]           = 0x02;
+    usb_buf[0x0E]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 20 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(20));
+}
+
+void AlienwareAW410KController::SendfeatureReport
+    (
+    unsigned char   first_byte,
+    unsigned char   second_byte,
+    unsigned char   third_byte,
+    unsigned char   forth_byte
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Feature report packet                          |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = first_byte;
+    usb_buf[0x02]           = second_byte;
+    usb_buf[0x03]           = third_byte;
+    usb_buf[0x04]           = forth_byte;
+
+    /*-----------------------------------------------------*\
+    | Send Feature report packet                            |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 10 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+}
+
+void AlienwareAW410KController::SendEdit()
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Edit packet                                    |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x01;
+    usb_buf[0x02]           = 0x00;
+    usb_buf[0x03]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 2 milliseconds                                  |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+}
+
+void AlienwareAW410KController::SendInitialize()
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x0E;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = 0x00;
+    usb_buf[0x04]           = 0x01;
+    usb_buf[0x05]           = 0xAD;
+    usb_buf[0x06]           = 0x80;
+    usb_buf[0x07]           = 0x10;
+    usb_buf[0x08]           = 0xA5;
+    usb_buf[0x0A]           = 0x0A;
+    usb_buf[0x12]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 2 milliseconds                                  |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+}
+
+void AlienwareAW410KController::SetDirect
+    (
+    unsigned char   /*zone*/,
+    unsigned char   r,
+    unsigned char   g,
+    unsigned char   b
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Lighting Control packet                        |
+    \*-----------------------------------------------------*/
+
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = 0x01;
+    usb_buf[0x04]           = r;
+    usb_buf[0x05]           = g;
+    usb_buf[0x06]           = b;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0D]           = 0x01;
+    usb_buf[0x0E]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 2 milliseconds                                  |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(2));
+}
+
+void AlienwareAW410KController::SendDirectOn
+    (
+    std::vector<SelectedButtons>     &frame_data
+    )
+{
+    SendfeatureReport(0x0E, (unsigned char)frame_data.size(), 0x00, 0x01);
+
+    /*-----------------------------------------------*\
+    | To Guarantee the data are always %4 =0 append   |
+    | zeros at end of last packet                     |
+    \*-----------------------------------------------*/
+    for(unsigned int i = 0; i < (frame_data.size() % 4); i++)
+    {
+        SelectedButtons key;
+        key.idx     = 0x00;
+        key.red     = 0x00;
+        key.green   = 0x00;
+        key.blue    = 0x00;
+
+        frame_data.push_back(key);
+    }
+
+    unsigned char usb_buf[65];
+    unsigned int  frame_idx = 0;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, 65);
+
+    for(unsigned int packet_idx = 0; packet_idx < frame_data.size(); packet_idx++)
+    {
+        usb_buf[0x00]           = 0x00;
+        usb_buf[0x01]           = 0x0E;
+        usb_buf[0x02]           = 0x01;
+        usb_buf[0x03]           = 0x00;
+        usb_buf[0x04]           = ++frame_idx;
+        usb_buf[0x05]           = frame_data[packet_idx].idx;
+        usb_buf[0x06]           = 0x81;
+        usb_buf[0x07]           = 0x00;
+        usb_buf[0x08]           = 0xA5;
+        usb_buf[0x0A]           = 0x0A;
+        usb_buf[0x0B]           = frame_data[packet_idx].red;
+        usb_buf[0x0C]           = frame_data[packet_idx].green;
+        usb_buf[0x0D]           = frame_data[packet_idx].blue;
+        usb_buf[0x12]           = 0x01;
+
+        usb_buf[0x14]           = frame_data[++packet_idx].idx;
+        usb_buf[0x15]           = 0x81;
+        usb_buf[0x16]           = 0x00;
+        usb_buf[0x17]           = 0xA5;
+        usb_buf[0x19]           = 0x0A;
+        usb_buf[0x1A]           = frame_data[packet_idx].red;
+        usb_buf[0x1B]           = frame_data[packet_idx].green;
+        usb_buf[0x1C]           = frame_data[packet_idx].blue;
+        usb_buf[0x21]           = 0x01;
+
+        usb_buf[0x23]           = frame_data[++packet_idx].idx;
+        usb_buf[0x24]           = 0x81;
+        usb_buf[0x25]           = 0x00;
+        usb_buf[0x26]           = 0xA5;
+        usb_buf[0x28]           = 0x0A;
+        usb_buf[0x29]           = frame_data[packet_idx].red;
+        usb_buf[0x2A]           = frame_data[packet_idx].green;
+        usb_buf[0x2B]           = frame_data[packet_idx].blue;
+        usb_buf[0x30]           = 0x01;
+
+        usb_buf[0x32]           = frame_data[++packet_idx].idx;
+        usb_buf[0x33]           = 0x81;
+        usb_buf[0x34]           = 0x00;
+        usb_buf[0x35]           = 0xA5;
+        usb_buf[0x37]           = 0x0A;
+        usb_buf[0x38]           = frame_data[packet_idx].red;
+        usb_buf[0x39]           = frame_data[packet_idx].green;
+        usb_buf[0x3A]           = frame_data[packet_idx].blue;
+        usb_buf[0x3F]           = 0x01;
+
+        hid_write(dev, (unsigned char *)usb_buf, 65);
+    }
+}
+
+
+void AlienwareAW410KController::SetMode
+    (
+    unsigned char   mode,
+    unsigned char   speed,
+    unsigned char   direction,
+    unsigned char   colorMode,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    SendMode(ALIENWARE_AW410K_ZONE_MODE_KEYBOARD, mode, speed, direction, colorMode, red, green, blue);
+    SendCommit();
+}
+
+void AlienwareAW410KController::UpdateSingleLED
+    (
+    unsigned char   led,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    SendfeatureReport(0x0E, 0x01, 0x00, 0x01);
+
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Single LED packet                              |
+    \*-----------------------------------------------------*/
+
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x0E;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = 0x00;
+    usb_buf[0x04]           = 0x01;
+    usb_buf[0x05]           = led;
+    usb_buf[0x06]           = 0x81;
+    usb_buf[0x07]           = 0x00;
+    usb_buf[0x08]           = 0xA5;
+    usb_buf[0x09]           = 0x00;
+    usb_buf[0x0A]           = 0x0A;
+    usb_buf[0x0B]           = red;
+    usb_buf[0x0C]           = green;
+    usb_buf[0x0D]           = blue;
+    usb_buf[0x12]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Delay 20 milliseconds                                 |
+    \*-----------------------------------------------------*/
+    std::this_thread::sleep_for(std::chrono::milliseconds(20));
+
+}
+void AlienwareAW410KController::SendMode
+    (
+    unsigned char   /*zone*/,
+    unsigned char   mode,
+    unsigned char   speed,
+    unsigned char   direction,
+    unsigned char   colorMode,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Mode Control packet                            |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = mode;
+    usb_buf[0x04]           = red;
+    usb_buf[0x05]           = green;
+    usb_buf[0x06]           = blue;
+    usb_buf[0x0A]           = speed;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0D]           = 0x01;
+    usb_buf[0x0E]           = colorMode;
+    usb_buf[0x0F]           = direction;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+}
+
+void AlienwareAW410KController::SetMorphMode
+    (
+    unsigned char   mode,
+    unsigned char   speed,
+    unsigned char   red1,
+    unsigned char   green1,
+    unsigned char   blue1,
+    unsigned char   red2,
+    unsigned char   green2,
+    unsigned char   blue2
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Morph Mode packet                              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x05;
+    usb_buf[0x02]           = 0x01;
+    usb_buf[0x03]           = mode;
+    usb_buf[0x04]           = red1;
+    usb_buf[0x05]           = green1;
+    usb_buf[0x06]           = blue1;
+    usb_buf[0x07]           = red2;
+    usb_buf[0x08]           = green2;
+    usb_buf[0x09]           = blue2;
+    usb_buf[0x0E]           = 0x02;
+    usb_buf[0x0A]           = speed;
+    usb_buf[0x0B]           = 0x0A;
+    usb_buf[0x0D]           = 0x01;
+    usb_buf[0x0E]           = ALIENWARE_AW410K_TWO_USER_DEFINED_COLOR_MODE;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+}

Controllers/AlienwareKeyboardController/AlienwareAW410KController/AlienwareAW410KController.h

@@ -0,0 +1,155 @@
+/*---------------------------------------------------------*\
+| AlienwareAW410KController.h                               |
+|                                                           |
+|   Driver for Alienware AW410K keyboard                    |
+|                                                           |
+|   based on AW510K controller by Mohamad Sallal (msallal)  |
+|   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
+enum
+{
+    ALIENWARE_AW410K_ZONE_MODE_KEYBOARD         = 0x01,
+};
+
+enum
+{
+    ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD       = 0x01,
+    ALIENWARE_AW410K_ZONE_DIRECT_MEDIA          = 0x02,
+    ALIENWARE_AW410K_ZONE_DIRECT_INDICATORS     = 0x40,
+};
+
+enum
+{
+    ALIENWARE_AW410K_MODE_OFF                   = 0x00,
+    ALIENWARE_AW410K_MODE_DIRECT                = 0x01,
+    ALIENWARE_AW410K_MODE_PULSE                 = 0x02,
+    ALIENWARE_AW410K_MODE_MORPH                 = 0x03,
+    ALIENWARE_AW410K_MODE_BREATHING             = 0x07,
+    ALIENWARE_AW410K_MODE_SPECTRUM              = 0x08,
+    ALIENWARE_AW410K_MODE_SINGLE_WAVE           = 0x0F,
+    ALIENWARE_AW410K_MODE_RAINBOW_WAVE          = 0x10,
+    ALIENWARE_AW410K_MODE_SCANNER               = 0x11,
+    ALIENWARE_AW410K_MODE_STATIC                = 0x13,
+};
+
+enum
+{
+    ALIENWARE_AW410K_SPEED_SLOWEST              = 0x2D,     /* Slowest speed                                */
+    ALIENWARE_AW410K_SPEED_NORMAL               = 0x19,     /* Normal speed                                 */
+    ALIENWARE_AW410K_SPEED_FASTEST              = 0x0A,     /* Fastest speed                                */
+};
+
+enum
+{
+    ALIENWARE_AW410K_DIRECTION_LEFT_TO_RIGHT    = 0x01,
+    ALIENWARE_AW410K_DIRECTION_RIGHT_TO_LEFT    = 0x02,
+    ALIENWARE_AW410K_DIRECTION_TOP_TO_BOTTOM    = 0x03,
+    ALIENWARE_AW410K_DIRECTION_BOTTOM_TO_TOP    = 0x04,
+};
+
+enum
+{
+    ALIENWARE_AW410K_SINGLE_COLOR_MODE          = 0x01,
+    ALIENWARE_AW410K_TWO_USER_DEFINED_COLOR_MODE= 0x02,
+    ALIENWARE_AW410K_RANBOW_COLOR_MODE          = 0x03,
+};
+
+struct SelectedButtons
+{
+    unsigned char idx;
+    unsigned char red;
+    unsigned char green;
+    unsigned char blue;
+};
+
+class AlienwareAW410KController
+{
+public:
+    AlienwareAW410KController(hid_device* dev_handle, const char* path);
+    ~AlienwareAW410KController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void        SendInitialize();
+    void        SendCommit();
+    void        SendfeatureReport
+                    (
+                    unsigned char   first_byte,
+                    unsigned char   second_byte,
+                    unsigned char   third_byte,
+                    unsigned char   forth_byte
+                    );
+
+    void        SendEdit();
+
+    void        SetDirect
+                    (
+                    unsigned char   zone,
+                    unsigned char   r,
+                    unsigned char   g,
+                    unsigned char   b
+                    );
+
+    void    SendDirectOn
+                    (
+                    std::vector<SelectedButtons>     &frame_data
+                    );
+
+    void        SetMode
+                    (
+                    unsigned char   mode,
+                    unsigned char   speed,
+                    unsigned char   direction,
+                    unsigned char   colorMode,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+
+    void        SetMorphMode
+                    (
+                    unsigned char   mode,
+                    unsigned char   speed,
+                    unsigned char   red1,
+                    unsigned char   green1,
+                    unsigned char   blue1,
+                    unsigned char   red2,
+                    unsigned char   green2,
+                    unsigned char   blue2
+                    );
+
+    void        UpdateSingleLED
+                    (
+                    unsigned char   led,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+
+private:
+    hid_device*             dev;
+    std::string             location;
+
+    void        SendMode
+                    (
+                    unsigned char   zone,
+                    unsigned char   mode,
+                    unsigned char   speed,
+                    unsigned char   direction,
+                    unsigned char   colorMode,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+};

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.cpp

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

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.h

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------*\
+| RGBController_AlienwareAW410K.h                           |
+|                                                           |
+|   RGBController for Alienware AW410K keyboard             |
+|                                                           |
+|   based on AW510K controller by Mohamad Sallal (msallal)  |
+|   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AlienwareAW410KController.h"
+
+class RGBController_AlienwareAW410K : public RGBController
+{
+public:
+    RGBController_AlienwareAW410K(AlienwareAW410KController* controller_ptr);
+    ~RGBController_AlienwareAW410K();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AlienwareAW410KController*  controller;
+    std::vector<RGBColor>       current_colors;
+};

Controllers/AlienwareKeyboardController/AlienwareAW510KController/AlienwareAW510KController.cpp

@@ -1,14 +1,16 @@
-/*-----------------------------------------*\
-|  AlienwareAW510KController.cpp            |
-|                                           |
-|  Driver for Alienware AW510K              |
-|  keyboard light controller                |
-|                                           |
-|  Mohamad Sallal - msallal      05/22/2021 |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AlienwareAW510KController.cpp                             |
+|                                                           |
+|   Driver for Alienware AW510K keyboard                    |
+|                                                           |
+|   Mohamad Sallal (msallal)                    22 May 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
-#include "AlienwareAW510KController.h"
 #include <cstring>
+#include "AlienwareAW510KController.h"
 
 AlienwareAW510KController::AlienwareAW510KController(hid_device* dev_handle, const char* path)
 {
@@ -41,7 +43,7 @@ std::string AlienwareAW510KController::GetSerialString()
 
 void AlienwareAW510KController::SendCommit()
 {
-    char usb_buf[65];
+    unsigned char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -63,7 +65,7 @@ void AlienwareAW510KController::SendCommit()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 20 milliseconds                                 |
@@ -71,7 +73,6 @@ void AlienwareAW510KController::SendCommit()
     std::this_thread::sleep_for(std::chrono::milliseconds(20));
 }
 
-
 void AlienwareAW510KController::SendfeatureReport
     (
     unsigned char   first_byte,
@@ -80,7 +81,7 @@ void AlienwareAW510KController::SendfeatureReport
     unsigned char   forth_byte
     )
 {
-    char usb_buf[65];
+    unsigned char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -99,7 +100,7 @@ void AlienwareAW510KController::SendfeatureReport
     /*-----------------------------------------------------*\
     | Send Feature report packet                            |
     \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, (unsigned char *)usb_buf, 65);
+    hid_send_feature_report(dev, usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 10 milliseconds                                 |
@@ -109,7 +110,7 @@ void AlienwareAW510KController::SendfeatureReport
 
 void AlienwareAW510KController::SendEdit()
 {
-    char usb_buf[65];
+    unsigned char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -127,7 +128,7 @@ void AlienwareAW510KController::SendEdit()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 2 milliseconds                                  |
@@ -137,7 +138,7 @@ void AlienwareAW510KController::SendEdit()
 
 void AlienwareAW510KController::SendInitialize()
 {
-    char usb_buf[65];
+    unsigned char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -162,7 +163,7 @@ void AlienwareAW510KController::SendInitialize()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 2 milliseconds                                  |
@@ -216,7 +217,7 @@ void AlienwareAW510KController::SendDirectOn
     std::vector<SelectedKeys>     &frame_data
     )
 {
-    SendfeatureReport(0x0E, frame_data.size(), 0x00, 0x01);
+    SendfeatureReport(0x0E, (unsigned char)frame_data.size(), 0x00, 0x01);
 
     /*-----------------------------------------------*\
     | To Guarantee the data are always %4 =0 append   |
@@ -296,7 +297,7 @@ void AlienwareAW510KController::SendDirectOn
 void AlienwareAW510KController::SetMode
     (
     unsigned char   mode,
-    unsigned short  speed,
+    unsigned char   speed,
     unsigned char   direction,
     unsigned char   colorMode,
     unsigned char   red,
@@ -318,7 +319,7 @@ void AlienwareAW510KController::UpdateSingleLED
 {
     SendfeatureReport(0x0E, 0x01, 0x00, 0x01);
 
-    char usb_buf[65];
+    unsigned char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -348,7 +349,7 @@ void AlienwareAW510KController::UpdateSingleLED
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 20 milliseconds                                 |
@@ -360,7 +361,7 @@ void AlienwareAW510KController::SendMode
     (
     unsigned char   /*zone*/,
     unsigned char   mode,
-    unsigned short  speed,
+    unsigned char   speed,
     unsigned char   direction,
     unsigned char   colorMode,
     unsigned char   red,
@@ -368,7 +369,7 @@ void AlienwareAW510KController::SendMode
     unsigned char   blue
     )
 {
-    char usb_buf[65];
+    unsigned char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -394,13 +395,13 @@ void AlienwareAW510KController::SendMode
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, usb_buf, 65);
 }
 
 void AlienwareAW510KController::SetMorphMode
     (
     unsigned char   mode,
-    unsigned short  speed,
+    unsigned char   speed,
     unsigned char   red1,
     unsigned char   green1,
     unsigned char   blue1,
@@ -409,7 +410,7 @@ void AlienwareAW510KController::SetMorphMode
     unsigned char   blue2
     )
 {
-    char usb_buf[65];
+    unsigned char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -438,5 +439,5 @@ void AlienwareAW510KController::SetMorphMode
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, usb_buf, 65);
 }

Controllers/AlienwareKeyboardController/AlienwareAW510KController/AlienwareAW510KController.h

@@ -1,18 +1,19 @@
-/*-----------------------------------------*\
-|  AlienwareAW510KController.h              |
-|                                           |
-|  Definitions and types for alienware      |
-|  AW510K Keyboard                          |
-|                                           |
-|  Mohamad Sallal - msallal      05/22/2021 |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AlienwareAW510KController.h                               |
+|                                                           |
+|   Driver for Alienware AW510K keyboard                    |
+|                                                           |
+|   Mohamad Sallal (msallal)                    22 May 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
-#include "RGBController.h"
+#pragma once
 
 #include <string>
 #include <hidapi/hidapi.h>
-
-#pragma once
+#include "RGBController.h"
 
 enum
 {
@@ -110,7 +111,7 @@ public:
     void        SetMode
                     (
                     unsigned char   mode,
-                    unsigned short  speed,
+                    unsigned char   speed,
                     unsigned char   direction,
                     unsigned char   colorMode,
                     unsigned char   red,
@@ -121,7 +122,7 @@ public:
     void        SetMorphMode
                     (
                     unsigned char   mode,
-                    unsigned short  speed,
+                    unsigned char   speed,
                     unsigned char   red1,
                     unsigned char   green1,
                     unsigned char   blue1,
@@ -146,7 +147,7 @@ private:
                     (
                     unsigned char   zone,
                     unsigned char   mode,
-                    unsigned short  speed,
+                    unsigned char   speed,
                     unsigned char   direction,
                     unsigned char   colorMode,
                     unsigned char   red,

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.cpp

@@ -1,15 +1,17 @@
-/*-----------------------------------------*\
-|  RGBController_AlienwareAW510K.cpp        |
-|                                           |
-|  Generic RGB Interface for alienware      |
-|  AW510K Keyboard                          |
-|                                           |
-|  Mohamad Sallal - msallal      05/22/2021 |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AlienwareAW510K.cpp                         |
+|                                                           |
+|   RGBController for Alienware AW510K keyboard             |
+|                                                           |
+|   Mohamad Sallal (msallal)                    22 May 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
+#include <iterator>
 #include "RGBControllerKeyNames.h"
 #include "RGBController_AlienwareAW510K.h"
-#include <iterator>
 
 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.h

@@ -0,0 +1,36 @@
+/*---------------------------------------------------------*\
+| RGBController_AlienwareAW510K.h                           |
+|                                                           |
+|   RGBController for Alienware AW510K keyboard             |
+|                                                           |
+|   Mohamad Sallal (msallal)                    22 May 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AlienwareAW510KController.h"
+
+class RGBController_AlienwareAW510K : public RGBController
+{
+public:
+    RGBController_AlienwareAW510K(AlienwareAW510KController* controller_ptr);
+    ~RGBController_AlienwareAW510K();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AlienwareAW510KController*  controller;
+    std::vector<RGBColor>       current_colors;
+};

Controllers/AlienwareKeyboardController/AlienwareKeyboardControllerDetect.cpp

@@ -1,18 +1,30 @@
+/*---------------------------------------------------------*\
+| AlienwareKeyboardControllerDetect.cpp                     |
+|                                                           |
+|   Detector for Alienware Keyboard                         |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <hidapi/hidapi.h>
 #include "Detector.h"
 #include "AlienwareAW510KController.h"
+#include "AlienwareAW410KController.h"
 #include "RGBController.h"
 #include "RGBController_AlienwareAW510K.h"
-#include <hidapi/hidapi.h>
+#include "RGBController_AlienwareAW410K.h"
 
 /*-----------------------------------------------------*\
 | Alienware vendor ID                                   |
 \*-----------------------------------------------------*/
-#define ALIENWARE_VID           0x04F2
+#define ALIENWARE_VID                           0x04F2
 
 /*-----------------------------------------------------*\
 | Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
-#define ALIENWARE_AW510K_PID    0x1830
+#define ALIENWARE_AW510K_PID                    0x1830
+#define ALIENWARE_AW410K_PID                    0x1968
 
 /******************************************************************************************\
 *                                                                                          *
@@ -32,7 +44,20 @@ void DetectAlienwareAW510KControllers(hid_device_info* info, const std::string&
         rgb_controller->name = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-}   /* DetectAlienwareKeyboardControllers() */
+}
+
+void DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
+    {
+        AlienwareAW410KController*     controller     = new AlienwareAW410KController(dev, info->path);
+        RGBController_AlienwareAW410K* rgb_controller = new RGBController_AlienwareAW410K(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}/* DetectAlienwareKeyboardControllers() */
 
 
 REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);
+REGISTER_HID_DETECTOR_IPU("Alienware AW410K",   DetectAlienwareAW410KControllers,   ALIENWARE_VID,  ALIENWARE_AW410K_PID,   0x02,   0xFF00, 0x01);

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.h

@@ -1,34 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AlienwareAW510K.h          |
-|                                           |
-|  Generic RGB Interface for Alienware      |
-|  AW510K keyboard                          |
-|                                           |
-|  Mohamad Sallal - msallal      05/22/2021 |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AlienwareAW510KController.h"
-
-class RGBController_AlienwareAW510K : public RGBController
-{
-public:
-    RGBController_AlienwareAW510K(AlienwareAW510KController* controller_ptr);
-    ~RGBController_AlienwareAW510K();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-    
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AlienwareAW510KController*  controller;
-    std::vector<RGBColor>       current_colors;
-};

Controllers/AnnePro2Controller/AnnePro2Controller.cpp

@@ -1,32 +1,35 @@
-/*-----------------------------------------*\
-|  AnnePro2Controller.cpp                   |
-|                                           |
-|  Driver for Obins Lab AnnePro2 keyboard   |
-|                                           |
-|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AnnePro2Controller.cpp                                    |
+|                                                           |
+|   Driver for Obins Lab AnnePro2 keyboard                  |
+|                                                           |
+|   Sergey Gavrilov (DrZlo13)                   06 Jun 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "AnnePro2Controller.h"
 
 using namespace std::chrono_literals;
 
-AnnePro2Controller::AnnePro2Controller(hid_device* dev_handle, const char* path) 
+AnnePro2Controller::AnnePro2Controller(hid_device* dev_handle, const char* path)
 {
     dev         = dev_handle;
     location    = path;
 }
 
-AnnePro2Controller::~AnnePro2Controller() 
+AnnePro2Controller::~AnnePro2Controller()
 {
     hid_close(dev);
 }
 
-std::string AnnePro2Controller::GetDeviceLocation() 
+std::string AnnePro2Controller::GetDeviceLocation()
 {
     return("HID: " + location);
 }
 
-std::string AnnePro2Controller::GetSerialString() 
+std::string AnnePro2Controller::GetSerialString()
 {
     wchar_t serial_string[128];
     int ret = hid_get_serial_number_string(dev, serial_string, 128);
@@ -42,7 +45,7 @@ std::string AnnePro2Controller::GetSerialString()
     return(return_string);
 }
 
-void AnnePro2Controller::SendDirect(unsigned char frame_count, unsigned char * frame_data) 
+void AnnePro2Controller::SendDirect(unsigned char frame_count, unsigned char * frame_data)
 {
     /*-------------------------------------------------------------*\
     | Reverse engineered by https://github.com/manualmanul/Annemone |
@@ -74,7 +77,7 @@ void AnnePro2Controller::SendDirect(unsigned char frame_count, unsigned char * f
     {
         const unsigned char e = (messages_to_send_amount << 4) + p;
         const unsigned char a = ((messages_to_send_amount - 1) == p) ? val_2 + real_command_info_length : max_message_length + real_command_info_length;
-        
+
         /*---------------------------------------------------------*\
         | Service data                                              |
         \*---------------------------------------------------------*/

Controllers/AnnePro2Controller/AnnePro2Controller.h

@@ -1,19 +1,20 @@
-/*-----------------------------------------*\
-|  AnnePro2Controller.h                     |
-|                                           |
-|  Driver for Obins Lab AnnePro2 keyboard   |
-|                                           |
-|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AnnePro2Controller.h                                      |
+|                                                           |
+|   Driver for Obins Lab AnnePro2 keyboard                  |
+|                                                           |
+|   Sergey Gavrilov (DrZlo13)                   06 Jun 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
-#include "RGBController.h"
 
 #include <string>
 #include <vector>
 #include <hidapi/hidapi.h>
-
-#pragma once
+#include "RGBController.h"
 
 class AnnePro2Controller
 {
@@ -33,4 +34,4 @@ public:
 private:
     hid_device*                 dev;
     std::string                 location;
-};
+};

Controllers/AnnePro2Controller/AnnePro2ControllerDetect.cpp

@@ -1,15 +1,34 @@
+/*---------------------------------------------------------*\
+| AnnePro2ControllerDetect.cpp                              |
+|                                                           |
+|   Detector for Obins Lab AnnePro2 keyboard                |
+|                                                           |
+|   Sergey Gavrilov (DrZlo13)                   06 Jun 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
 #include "Detector.h"
 #include "AnnePro2Controller.h"
 #include "RGBController.h"
 #include "RGBController_AnnePro2.h"
 #include <hidapi/hidapi.h>
 
-#define ANNE_PRO_2_VID 0x04D9
-#define ANNE_PRO_2_PID_1 0x8008
-#define ANNE_PRO_2_PID_2 0x8009
-#define ANNE_PRO_2_PID_3 0xA292
-#define ANNE_PRO_2_PID_4 0xA293
-#define ANNE_PRO_2_PID_5 0xA297
+/*---------------------------------------------------------*\
+| Anne Pro 2 vendor IDs                                     |
+\*---------------------------------------------------------*/
+#define ANNE_PRO_2_VID_1                            0x04D9
+#define ANNE_PRO_2_VID_2                            0x3311
+
+/*---------------------------------------------------------*\
+| Anne Pro 2 product IDs                                    |
+\*---------------------------------------------------------*/
+#define ANNE_PRO_2_PID_1                            0x8008
+#define ANNE_PRO_2_PID_2                            0x8009
+#define ANNE_PRO_2_PID_3                            0xA292
+#define ANNE_PRO_2_PID_4                            0xA293
+#define ANNE_PRO_2_PID_5                            0xA297
 
 /******************************************************************************************\
 *                                                                                          *
@@ -31,8 +50,8 @@ void DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
     }
 }
 
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_1, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_2, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_3, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_4, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_5, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_1, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_2, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_3, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_4, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_2, ANNE_PRO_2_PID_5, 1);

Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp

@@ -1,11 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_AnnePro2.cpp               |
-|                                           |
-|  Generic RGB Interface for Obins Lab      |
-|  AnnePro2 keyboard                        |
-|                                           |
-|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AnnePro2.cpp                                |
+|                                                           |
+|   RGBController for Obins Lab AnnePro2 keyboard           |
+|                                                           |
+|   Sergey Gavrilov (DrZlo13)                   06 Jun 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "RGBControllerKeyNames.h"
 #include "RGBController_AnnePro2.h"

Controllers/AnnePro2Controller/RGBController_AnnePro2.h

@@ -1,13 +1,16 @@
-/*-----------------------------------------*\
-|  RGBController_AnnePro2.h                 |
-|                                           |
-|  Generic RGB Interface for Obins Lab      |
-|  AnnePro2 keyboard                        |
-|                                           |
-|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AnnePro2.h                                  |
+|                                                           |
+|   RGBController for Obins Lab AnnePro2 keyboard           |
+|                                                           |
+|   Sergey Gavrilov (DrZlo13)                   06 Jun 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
+
 #include "RGBController.h"
 #include "AnnePro2Controller.h"
 

Controllers/ArcticController/ArcticController.cpp

@@ -1,13 +1,16 @@
-/*-----------------------------------------*\
-|  ArcticController.h                       |
-|                                           |
-|  Controller Interface for Arctic devices  |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| ArcticController.cpp                                      |
+|                                                           |
+|   Driver for Arctic devices                               |
+|                                                           |
+|   Armin Wolf (Wer-Wolf)                       09 Jan 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
-#include "ArcticController.h"
 #include <cstring>
+#include "ArcticController.h"
 
 using namespace std::chrono_literals;
 

Controllers/ArcticController/ArcticController.h

@@ -1,14 +1,17 @@
-/*-----------------------------------------*\
-|  ArcticController.h                       |
-|                                           |
-|  Controller Interface for Arctic devices  |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| ArcticController.h                                        |
+|                                                           |
+|   Driver for Arctic devices                               |
+|                                                           |
+|   Armin Wolf (Wer-Wolf)                       09 Jan 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
-#include <algorithm>
 
+#include <algorithm>
 #include "RGBController.h"
 #include "serial_port.h"
 

Controllers/ArcticController/ArcticControllerDetect.cpp

@@ -1,19 +1,22 @@
-/*-----------------------------------------*\
-|  ArcticControllerDetect.cpp               |
-|                                           |
-|  Detect Arctic RGB controllers            |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| ArcticControllerDetect.cpp                                |
+|                                                           |
+|   Detector for Arctic devices                             |
+|                                                           |
+|   Armin Wolf (Wer-Wolf)                       09 Jan 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
 #include "Detector.h"
 #include "ArcticController.h"
 #include "RGBController.h"
 #include "RGBController_Arctic.h"
 #include "find_usb_serial_port.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
 
 #define CH341_VID   0x1A86
 #define CH341_PID   0x7523

Controllers/ArcticController/RGBController_Arctic.cpp

@@ -1,13 +1,16 @@
-/*-----------------------------------------*\
-|  RGBController_Arctic.h                   |
-|                                           |
-|  Generic RGB Interface for Arctic devices |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_Arctic.cpp                                  |
+|                                                           |
+|   RGBController for Arctic devices                        |
+|                                                           |
+|   Armin Wolf (Wer-Wolf)                       09 Jan 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
-#include "RGBController_Arctic.h"
 #include <math.h>
+#include "RGBController_Arctic.h"
 
 using namespace std::chrono_literals;
 

Controllers/ArcticController/RGBController_Arctic.h

@@ -1,17 +1,21 @@
-/*-----------------------------------------*\
-|  RGBController_Arctic.h                   |
-|                                           |
-|  Generic RGB Interface for Arctic devices |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 27/08/2023         |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_Arctic.h                                    |
+|                                                           |
+|   RGBController for Arctic devices                        |
+|                                                           |
+|   Armin Wolf (Wer-Wolf)                       09 Jan 2023 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
+
+#include <chrono>
+#include <thread>
 #include "ArcticController.h"
 #include "RGBController.h"
 #include "serial_port.h"
-#include <chrono>
-#include <thread>
 
 class RGBController_Arctic : public RGBController
 {

Controllers/AsusAuraCoreController/AsusAuraCoreController/AsusAuraCoreController.cpp

@@ -1,14 +1,16 @@
-/*-----------------------------------------*\
-|  AsusAuraCoreController.cpp               | 
-|                                           |
-|  Driver for ASUS ROG Aura Core RGB        |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/13/2020   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusAuraCoreController.cpp                                |
+|                                                           |
+|   Driver for ASUS ROG Aura Core                           |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                13 Apr 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
-#include "AsusAuraCoreController.h"
 #include <cstring>
+#include "AsusAuraCoreController.h"
 
 #define AURA_CORE_MAX_MESSAGE_SIZE  64
 

Controllers/AsusAuraCoreController/AsusAuraCoreController/AsusAuraCoreController.h

@@ -1,18 +1,19 @@
-/*-----------------------------------------*\
-|  AsusAuraCoreController.h                 |
-|                                           |
-|  Definitions and types for ASUS ROG Aura  |
-|  Core RGB lighting controller             |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/13/2020   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusAuraCoreController.h                                  |
+|                                                           |
+|   Driver for ASUS ROG Aura Core                           |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                13 Apr 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
-#include "RGBController.h"
+#pragma once
 
 #include <string>
 #include <hidapi/hidapi.h>
-
-#pragma once
+#include "RGBController.h"
 
 enum AuraCoreDeviceType
 {
@@ -119,5 +120,4 @@ private:
     void    Handshake();
     void    SendIdString();
     void    SendQuery();
-
 };

Controllers/AsusAuraCoreController/AsusAuraCoreController/RGBController_AsusAuraCore.cpp

@@ -1,10 +1,13 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraCore.cpp           |
-|                                           |
-|  Generic RGB Interface for ROG Aura Core  |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/17/2020   |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusAuraCore.cpp                            |
+|                                                           |
+|   RGBController for ASUS ROG Aura Core                    |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                13 Apr 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "RGBController_AsusAuraCore.h"
 

Controllers/AsusAuraCoreController/AsusAuraCoreController/RGBController_AsusAuraCore.h

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------*\
+| RGBController_AsusAuraCore.h                              |
+|                                                           |
+|   RGBController for ASUS ROG Aura Core                    |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                13 Apr 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AsusAuraCoreController.h"
+
+class RGBController_AuraCore : public RGBController
+{
+public:
+    RGBController_AuraCore(AuraCoreController* controller_ptr);
+    ~RGBController_AuraCore();
+
+    void        SetupKeyboard();
+    void        SetupGA15DH();
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AuraCoreController* controller;
+};

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

@@ -1,3 +1,15 @@
+/*---------------------------------------------------------*\
+| AsusAuraCoreControllerDetect.cpp                          |
+|                                                           |
+|   Detector for ASUS ROG Aura Core                         |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                13 Apr 2020 |
+|   Chris M (Dr_No)                             28 Jul 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
 #include "Detector.h"
 #include "AsusAuraCoreController.h"
 #include "RGBController.h"

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.cpp

@@ -1,14 +1,15 @@
-/*---------------------------------------------------------------------*\
-|  AsusAuraCoreLaptopController.cpp                                     |
-|                                                                       |
-|  Driver for Asus Aura Core Laptop USB Controller                      |
-|                                                                       |
-|  Chris M (Dr_No)          28 Jul 2022                                 |
-|                                                                       |
-\*---------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusAuraCoreLaptopController.cpp                          |
+|                                                           |
+|   Driver for ASUS ROG Aura Core Laptop                    |
+|                                                           |
+|   Chris M (Dr_No)                             28 Jul 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "AsusAuraCoreLaptopController.h"
-
 #include "SettingsManager.h"
 
 static uint8_t packet_map[ASUSAURACORELAPTOP_KEYCOUNT       +
@@ -169,14 +170,14 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor> colors)
 
     for(size_t i = 0; i < key_set; i+=leds_per_packet)
     {
-        uint8_t leds_remaining  = key_set - i;
+        uint8_t leds_remaining  = key_set - (uint8_t)i;
 
         if(leds_remaining < leds_per_packet)
         {
             buffer[07]          = leds_remaining;
         }
 
-        buffer[06]              = i;
+        buffer[06]              = (uint8_t)i;
         memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * i], (3 * buffer[07]));
 
         hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.h

@@ -1,11 +1,15 @@
-/*---------------------------------------------------------------------*\
-|  AsusAuraCoreLaptopController.h                                       |
-|                                                                       |
-|  Driver for AsusAuraCoreLaptop USB Controller                         |
-|                                                                       |
-|  Chris M (Dr_No)          28 Jul 2022                                 |
-|                                                                       |
-\*---------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusAuraCoreLaptopController.h                            |
+|                                                           |
+|   Driver for ASUS ROG Aura Core Laptop                    |
+|                                                           |
+|   Chris M (Dr_No)                             28 Jul 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
 
 #include <string>
 #include <vector>
@@ -15,8 +19,6 @@
 #include "ResourceManager.h"
 #include "RGBControllerKeyNames.h"
 
-#pragma once
-
 #define NA                                      0xFFFFFFFF
 #define HID_MAX_STR                             255
 #define ASUSAURACORELAPTOP_TIMEOUT              250

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.cpp

@@ -1,11 +1,13 @@
-/*---------------------------------------------------------------------*\
-|  RGBController_AsusAuraCoreLaptop.cpp                                 |
-|                                                                       |
-|  Driver for AsusAuraCoreLaptop USB Controller                         |
-|                                                                       |
-|  Chris M (Dr_No)          28 Jul 2022                                 |
-|                                                                       |
-\*---------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusAuraCoreLaptop.cpp                      |
+|                                                           |
+|   RGBController for ASUS ROG Aura Core Laptop             |
+|                                                           |
+|   Chris M (Dr_No)                             28 Jul 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #include "RGBController_AsusAuraCoreLaptop.h"
 
@@ -434,7 +436,7 @@ void RGBController_AsusAuraCoreLaptop::SetupZones()
     \*---------------------------------------------------------*/
     for(std::size_t zone_index = 0; zone_index < zones.size(); zone_index++)
     {
-        int zone_offset = leds.size();
+        int zone_offset = (int)leds.size();
 
         for(unsigned int led_index = 0; led_index < zones[zone_index].leds_count; led_index++)
         {

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.h

@@ -1,11 +1,13 @@
-/*---------------------------------------------------------------------*\
-|  RGBController_AsusAuraCoreLaptop.h                                   |
-|                                                                       |
-|  Driver for AsusAuraCoreLaptop USB Controller                         |
-|                                                                       |
-|  Chris M (Dr_No)          28 Jul 2022                                 |
-|                                                                       |
-\*---------------------------------------------------------------------*/
+/*---------------------------------------------------------*\
+| RGBController_AsusAuraCoreLaptop.h                        |
+|                                                           |
+|   RGBController for ASUS ROG Aura Core Laptop             |
+|                                                           |
+|   Chris M (Dr_No)                             28 Jul 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
 #pragma once
 

Controllers/AsusAuraGPUController/AsusAuraGPUController.cpp

@@ -1,13 +1,17 @@
-/*-----------------------------------------*\
-|  AsusAuraGPUController.cpp                |
-|                                           |
-|  Driver for ASUS Aura RGB on GPUs         |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusAuraGPUController.cpp                                 |
+|                                                           |
+|   Driver for ASUS Aura GPU                                |
+|                                                           |
+|   Jan Rettig (Klapstuhl)                      14 Feb 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
-#include "AsusAuraGPUController.h"
 #include <cstring>
+#include "AsusAuraGPUController.h"
+#include "pci_ids.h"
 
 AuraGPUController::AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id dev)
 {
@@ -52,25 +56,16 @@ unsigned char AuraGPUController::GetLEDBlue()
     return(AuraGPURegisterRead(AURA_GPU_REG_BLUE));
 }
 
-void AuraGPUController::SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue)                  // Direct Mode is just Static Mode without applying color changes
+void AuraGPUController::SetLEDColors(unsigned char red, unsigned char green, unsigned char blue)
 {
     AuraGPURegisterWrite(AURA_GPU_REG_RED, red);
     AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green);
     AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue);
 }
 
-void AuraGPUController::SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
-{
-    AuraGPURegisterWrite(AURA_GPU_REG_RED, red);
-    AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green);
-    AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue);
-    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
-}
-
 void AuraGPUController::SetMode(unsigned char mode)
 {
     AuraGPURegisterWrite(AURA_GPU_REG_MODE, mode);
-    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
 }
 
 unsigned char AuraGPUController::AuraGPURegisterRead(unsigned char reg)
@@ -81,4 +76,21 @@ unsigned char AuraGPUController::AuraGPURegisterRead(unsigned char reg)
 void AuraGPUController::AuraGPURegisterWrite(unsigned char reg, unsigned char val)
 {
     bus->i2c_smbus_write_byte_data(dev, reg, val);
-}
+}
+
+bool AuraGPUController::SaveOnlyApplies()
+{
+    switch (bus->pci_subsystem_device)
+    {
+        case ASUS_VEGA64_STRIX:
+            return false;
+    }
+    // Behavior on other GPU models is unknown and needs to be tested.
+    // Assume the safest option to prevent damaage from excessive writes.
+    return false;
+}
+
+void AuraGPUController::Save()
+{
+    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
+}

Controllers/AsusAuraGPUController/AsusAuraGPUController.h

@@ -1,16 +1,19 @@
-/*-----------------------------------------*\
-|  AsusAuraGPUController.h                  |
-|                                           |
-|  Definitions for ASUS Aura RGB on GPUs    |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusAuraGPUController.h                                   |
+|                                                           |
+|   Driver for ASUS Aura GPU                                |
+|                                                           |
+|   Jan Rettig (Klapstuhl)                      14 Feb 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
 
 #include <string>
 #include "i2c_smbus.h"
 
-#pragma once
-
 typedef unsigned char aura_gpu_dev_id;
 
 #define AURA_GPU_MAGIC_VAL 0x1589                   /* This magic value is present in all Aura GPU controllers */
@@ -23,7 +26,7 @@ enum
     AURA_GPU_REG_BLUE                       = 0x06,    /* AURA GPU BLUE Register           */
     AURA_GPU_REG_MODE                       = 0x07,    /* AURA GPU Mode Selection Register */
     AURA_GPU_REG_SYNC                       = 0x0C,    /* AURA GPU "Sync" Register         */
-    AURA_GPU_REG_APPLY                      = 0x0E,    /* AURA GPU Apply Chnages Register  */
+    AURA_GPU_REG_APPLY                      = 0x0E,    /* AURA GPU Save or Apply Register  */
 };
 
 enum
@@ -48,17 +51,18 @@ public:
     unsigned char GetLEDRed();
     unsigned char GetLEDGreen();
     unsigned char GetLEDBlue();
-    void          SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
-    void          SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetLEDColors(unsigned char red, unsigned char green, unsigned char blue);
     void          SetMode(unsigned char mode);
+    void          Save();
 
     unsigned char AuraGPURegisterRead(unsigned char reg);
     void          AuraGPURegisterWrite(unsigned char reg, unsigned char val);
 
+    bool          SaveOnlyApplies();
     bool          direct = false;                                                // Temporary solution to check if we are in "Direct" mode
 
 private:
     char                    device_name[16];
     i2c_smbus_interface *   bus;
     aura_gpu_dev_id         dev;
-};
+};

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -1,11 +1,17 @@
-/*-----------------------------------------*\
-|  AsusAuraGPUControllerDetect.cpp          |
-|                                           |
-|  Driver for ASUS Aura RGB on GPUs         |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
+/*---------------------------------------------------------*\
+| AsusAuraGPUControllerDetect.cpp                           |
+|                                                           |
+|   Detector for ASUS Aura GPU                              |
+|                                                           |
+|   Jan Rettig (Klapstuhl)                      14 Feb 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
 
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
 #include "Detector.h"
 #include "AsusAuraGPUController.h"
 #include "LogManager.h"
@@ -13,9 +19,6 @@
 #include "RGBController_AsusAuraGPU.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
 
 #define ASUSGPU_CONTROLLER_NAME "ASUS Aura GPU"
 
@@ -69,68 +72,69 @@ void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
 |  NVidia GPUs                              |
 \*-----------------------------------------*/
 
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 O2G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI 4G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1060 Strix 6G Gaming"             , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX_6G_GAMING,               0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1060 Strix"                       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX,                         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1070 Strix Gaming"                , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_GAMING,                  0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1070 Strix OC"                    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_OC,                      0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1070 Ti 8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1070 Ti A8G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1080 Strix OC"                    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_GTX1080_STRIX,                         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 A8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 O8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 O8G 11Gbps"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_11GBPS,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti Gaming"          , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti 11G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti O11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX1080 Ti O11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650S OC 4G"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660S O6G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1660 Ti OC 6G"                , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_GTX1660TI_OC,                      0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G EVO Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S 8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G EVO Gaming"   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S 8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G V2 Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING,       0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G White"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C,   0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060 Ti 8G Gaming OC"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 O2G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti 4G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti O4G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti O4G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1060 Strix 6G Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX_6G_GAMING,               0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1060 Strix"                      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX,                         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1070 Strix Gaming"               , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_GAMING,                  0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1070 Strix OC"                   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_OC,                      0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1070 Ti 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1070 Ti A8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1080 Strix OC"                   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_GTX1080_STRIX,                         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 A8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 O8G 11Gbps"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_11GBPS,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650 SUPER OC 4G"          , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 SUPER O6G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 SUPER 6G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_6G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 Ti OC 6G"             , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_GTX1660TI_OC,                      0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 EVO Gaming 6G"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G EVO Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER 8G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER A8G EVO Gaming" , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER 8G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G V2 Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER O8G White"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C,   0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060 Ti 8G Gaming OC"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A);
 
 /*-----------------------------------------*\
 |  AMD GPUs                                 |
 \*-----------------------------------------*/
 
-REGISTER_I2C_PCI_DETECTOR("ASUS AREZ Strix RX Vega 56 O8G"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS Vega 64 Strix"                        , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 5600XT Strix O6G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix 08G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING,             0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX470 O4G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX480 Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX560 Gaming"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O4G Gaming OC"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O8G Gaming OC"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O8G_GAMING_OC,             0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming OC"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_OC,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming TOP"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS AREZ Strix RX Vega 56 O8G"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Vega 64 Strix"                       , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5600 XT Strix O6G Gaming"         , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5700 XT Strix Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5700 XT Strix 08G Gaming"         , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING,             0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 470 O4G Gaming"             , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 480 Gaming OC"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 560 Gaming"                 , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 570 Strix O4G Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 570 Strix O8G Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O8G_GAMING_OC,             0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 580 Strix Gaming OC"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_OC,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 580 Strix Gaming TOP"             , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);