Test Razer Blade Stealth Late 2020

+ Add id to pci_ids.h
+ Register detector in NVIDIAIlluminationControllerDetect.cpp
+ Link to [webpage](https://www.pny.com/geforce-rtx-3060-12gb-xlr8-gaming-revel-epic-x-rgb-df)

.gitignore

@@ -5,6 +5,7 @@
 OpenRGB
 openrgb
 OpenRGB-x86_64.AppImage
+60-openrgb.rules
 
 # Directories
 .build/
@@ -37,17 +38,19 @@ Thumbs.db
 !dependencies/**/*.bat
 
 # C++ objects and libs
-*.slo
-*.lo
-*.o
 *.a
+*.dll
+*.dylib
+*.ii
 *.la
 *.lai
+*.lo
+*.o
+*.s
+*.slo
 *.so
 *.so.*
-*.dll
 !dependencies/**/*.dll
-*.dylib
 
 # Qt-es
 object_script.*.Release
@@ -87,8 +90,7 @@ compile_commands.json
 
 # QtCreator local machine specific files for imported projects
 *creator.user*
-
-*_qmlcache.qrc
+*.qrc
 
 # Visual Studio generated files
 *.ib_pdb_index
@@ -110,4 +112,8 @@ compile_commands.json
 *.Release
 
 # Clang tooling files
-compile_commands.json
+compile_commands.json
+
+# Generated i18n files
+*.qm
+

.gitlab-ci.yml

@@ -27,6 +27,31 @@ before_script:
     - export QT_SELECT=qt5
     - export APPIMAGE_EXTRACT_AND_RUN=1
 
+#-----------------------------------------------------------------------#
+# Supported Devices Build Target                                        #
+#-----------------------------------------------------------------------#
+"Supported Devices":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
+  stage: build
+  script:
+  - qmake
+  - make -j$(nproc)
+  - ./scripts/build-supported-devices-md.sh $CI_PROJECT_DIR $CI_COMMIT_SHORT_SHA
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Supported_Devices_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - ./*.md
+    exclude:
+    - README.md
+    - CONTRIBUTING.md
+    expire_in: 30 days
+
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+
 #-----------------------------------------------------------------------#
 # Linux (AppImage) 32-bit Build Target                                  #
 #-----------------------------------------------------------------------#
@@ -156,8 +181,8 @@ before_script:
   image: fedora:35
   stage: build
   script:
-  - dnf install rpmdevtools dnf-plugins-core -y 
-  - rpmdev-setuptree 
+  - dnf install rpmdevtools dnf-plugins-core -y
+  - rpmdev-setuptree
   - ls /root/
   - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
   - cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
@@ -380,6 +405,10 @@ before_script:
   - Pop-Location
   - _fold_final_
 
+  - _fold_start_ 'Generate qm files'
+  - .\_qt\5.15.0\msvc2019\bin\lrelease OpenRGB.pro
+  - _fold_final_
+
   - _fold_start_ 'run qmake and generate the msvc nmake makefile'
   - mkdir _build; cd _build
   - ..\_qt\5.15.0\msvc2019\bin\qmake ..\OpenRGB.pro
@@ -449,6 +478,10 @@ before_script:
   - Pop-Location
   - _fold_final_
 
+  - _fold_start_ 'Generate qm files'
+  - .\_qt\5.15.0\msvc2019_64\bin\lrelease OpenRGB.pro
+  - _fold_final_
+
   - _fold_start_ 'run qmake and generate the msvc nmake makefile'
   - mkdir _build; cd _build
   - ..\_qt\5.15.0\msvc2019_64\bin\qmake ..\OpenRGB.pro

AutoStart/AutoStart-FreeBSD.cpp

@@ -4,6 +4,7 @@
 
 #include <fstream>
 #include <iostream>
+#include <limits.h>
 #include <unistd.h>
 #include <sstream>
 
@@ -120,7 +121,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));
 }
 
@@ -159,7 +160,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);

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -0,0 +1,34 @@
+/*-----------------------------------------------------*\
+| OpenRGB includes                                      |
+\*-----------------------------------------------------*/
+#include <hidapi/hidapi.h>
+#include "Detector.h"
+#include "LogManager.h"
+#include "RGBController.h"
+
+/*-----------------------------------------------------*\
+| A4 Tech specific includes                             |
+\*-----------------------------------------------------*/
+#include "RGBController_BloodyMouse.h"
+
+/*-----------------------------------------------------*\
+| A4 Tech USB vendor ID                                 |
+\*-----------------------------------------------------*/
+#define A4_TECH_VID                                 0x09DA
+
+void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        BloodyMouseController* controller           = new BloodyMouseController(dev, info->path, info->product_id);
+        RGBController_BloodyMouse* rgb_controller   = new RGBController_BloodyMouse(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 MP 50RS",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);

Controllers/A4TechController/BloodyMouseController.cpp

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------------------*\
+|  BloodyMouseController.cpp                                            |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
+
+#include "BloodyMouseController.h"
+
+BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id)
+{
+    dev                 = dev_handle;
+    location            = path;
+    pid                 = product_id;
+
+    InitDevice();
+}
+
+BloodyMouseController::~BloodyMouseController()
+{
+    hid_close(dev);
+}
+
+uint16_t BloodyMouseController::GetPid()
+{
+    return pid;
+}
+
+std::string BloodyMouseController::GetSerial()
+{
+    const uint8_t   sz  = HID_MAX_STR;
+    wchar_t         tmp[sz];
+
+    int ret             = hid_get_serial_number_string(dev, tmp, sz);
+
+    if (ret != 0)
+    {
+        LOG_DEBUG("[BloodyMouse] Get HID Serial string failed");
+        return("");
+    }
+
+    std::wstring w_tmp  = std::wstring(tmp);
+    std::string serial  = std::string(w_tmp.begin(), w_tmp.end());
+
+    return serial;
+}
+
+std::string BloodyMouseController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+void  BloodyMouseController::InitDevice()
+{
+    uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
+
+    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
+
+    buffer[BLOODYMOUSE_MODE_BYTE]                   = 0;
+    buffer[BLOODYMOUSE_DATA_BYTE]                   = 1;
+
+    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
+}
+
+void  BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors)
+{
+    uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00 };
+
+    for(uint8_t i = 0; i < colors.size(); i++)
+    {
+        uint8_t offset                              = 3 * (colors[i] >> 24) + BLOODYMOUSE_DATA_BYTE;
+
+        buffer[offset]                              = RGBGetRValue(colors[i]);
+        buffer[offset + 1]                          = RGBGetGValue(colors[i]);
+        buffer[offset + 2]                          = RGBGetBValue(colors[i]);
+    }
+
+    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
+}

Controllers/A4TechController/BloodyMouseController.h

@@ -0,0 +1,63 @@
+/*---------------------------------------------------------------------*\
+|  BloodyMouseController.h                                              |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include "LogManager.h"
+#include "RGBController.h"
+
+#pragma once
+
+/*-----------------------------------------------------*\
+| Mouse product IDs                                     |
+\*-----------------------------------------------------*/
+#define BLOODY_W60_PRO_PID                          0x37EA
+
+/*-----------------------------------------------------*\
+| Mousemat product IDs                                  |
+\*-----------------------------------------------------*/
+#define BLOODY_MP_50RS_PID                          0xFA60
+
+#define HID_MAX_STR 255
+#define BLOODYMOUSE_WRITE_PACKET_SIZE   64
+
+#define BLOODYMOUSE_BRIGHTNESS_MIN      0
+#define BLOODYMOUSE_BRIGHTNESS_MAX      255
+
+enum
+{
+    BLOODYMOUSE_MODE_DIRECT             = 0x01, //Direct Led Control - Independently set LEDs in zone
+};
+
+enum
+{
+    BLOODYMOUSE_REPORT_BYTE             = 1,
+    BLOODYMOUSE_COMMAND_BYTE            = 2,
+    BLOODYMOUSE_MODE_BYTE               = 3,
+    BLOODYMOUSE_DATA_BYTE               = 8,
+};
+
+class BloodyMouseController
+{
+public:
+    BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id);
+    ~BloodyMouseController();
+
+    uint16_t        GetPid();
+    std::string     GetSerial();
+    std::string     GetLocation();
+
+    void            SetLedsDirect(std::vector<RGBColor> colors);
+private:
+    uint16_t        pid;
+    std::string     location;
+    hid_device*     dev;
+
+    void            InitDevice();
+};

Controllers/A4TechController/RGBController_BloodyMouse.cpp

@@ -0,0 +1,181 @@
+/*---------------------------------------------------------------------*\
+|  RGBController_BloodyMouse.cpp                                        |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
+
+#include "RGBController_BloodyMouse.h"
+
+static const mouse_layout w60_pro
+{
+    {
+        "Scroll Wheel", { 14 }
+    },
+    {
+        "Mid Line",     {  0,  1,  2,  9,  3,  4,  5,  6 }
+    },
+    {
+        "Logo",         { 10 }
+    },
+    {
+        "Rear",         {  8,  7, 13, 12, 11 }
+    }
+};
+
+static const mouse_layout mp_50rs
+{
+    {
+        "Mouse Pad",    {  0,  1,  2,  3,  4,  5,  6,  7,  8,  9 }
+    }
+};
+
+/**------------------------------------------------------------------*\
+    @name BloodyMouse
+    @category Mouse
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectA4TechMouseControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    switch(controller->GetPid())
+    {
+        case BLOODY_MP_50RS_PID:
+            type                = DEVICE_TYPE_MOUSEMAT;
+            break;
+        default:
+            type                = DEVICE_TYPE_MOUSE;
+    }
+
+    name                        = "BloodyMouse";
+    vendor                      = "Bloody";
+    description                 = "Controller compatible with the Bloody W60 Pro and MP 50RS";
+    serial                      = controller->GetSerial();
+    location                    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = BLOODYMOUSE_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_BloodyMouse::~RGBController_BloodyMouse()
+{
+    delete controller;
+}
+
+void RGBController_BloodyMouse::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+
+    /*-------------------------------------------------*\
+    | Select layout from PID                            |
+    \*-------------------------------------------------*/
+    mouse_layout layout;
+    switch(controller->GetPid())
+    {
+        case BLOODY_W60_PRO_PID:
+            layout = w60_pro;
+            break;
+        case BLOODY_MP_50RS_PID:
+            layout = mp_50rs;
+            break;
+    }
+
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    for(uint8_t zone_idx = 0; zone_idx < layout.size(); zone_idx++)
+    {
+        mouse_zone mz           = layout[zone_idx];
+        bool bool_single        = mz.zone_leds.size() == 1;
+
+        zone new_zone;
+        new_zone.name           = mz.name;
+        new_zone.leds_min       = 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;
+        new_zone.matrix_map     = NULL;
+        zones.push_back(new_zone);
+
+        for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
+        {
+            led new_led;
+
+            new_led.value       = mz.zone_leds[lp_idx];
+
+            if(bool_single)
+            {
+                new_led.name    = mz.name + " LED";
+            }
+            else
+            {
+                new_led.name    = mz.name;
+                new_led.name.append(" LED " + std::to_string(lp_idx));
+            }
+
+            leds.push_back(new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_BloodyMouse::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_BloodyMouse::DeviceUpdateLEDs()
+{
+    std::vector<RGBColor> colour;
+    for(size_t i = 0; i < colors.size(); i++)
+    {
+        RGBColor c = colors[i] | (leds[i].value << 24);
+        colour.push_back(c);
+    }
+
+    controller->SetLedsDirect(colour);
+}
+
+void RGBController_BloodyMouse::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_BloodyMouse::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_BloodyMouse::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_BloodyMouse::DeviceUpdateMode()
+{
+    /*---------------------------------------------------------*\
+    | This device only supports Direct mode                     |
+    \*---------------------------------------------------------*/
+}

Controllers/A4TechController/RGBController_BloodyMouse.h

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------*\
+|  RGBController_BloodyMouse.h                                          |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
+
+#pragma once
+#include <vector>
+#include "LogManager.h"
+#include "RGBController.h"
+#include "BloodyMouseController.h"
+
+struct mouse_zone
+{
+    std::string             name;
+    std::vector<uint8_t>    zone_leds;
+};
+
+typedef std::vector<mouse_zone> mouse_layout;
+
+class RGBController_BloodyMouse : public RGBController
+{
+public:
+    RGBController_BloodyMouse(BloodyMouseController* controller_ptr);
+    ~RGBController_BloodyMouse();
+
+    void                    SetupZones();
+    void                    ResizeZone(int zone, int new_size);
+
+    void                    DeviceUpdateLEDs();
+    void                    UpdateZoneLEDs(int zone);
+    void                    UpdateSingleLED(int led);
+
+    void                    SetCustomMode();
+    void                    DeviceUpdateMode();
+
+private:
+    BloodyMouseController*  controller;
+};

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -11,10 +11,11 @@
 
 /**------------------------------------------------------------------*\
     @name AMD Wraith Prism
+    @category Cooler
     @type USB
-    @save :x:
+    @save :o:
     @direct :white_check_mark:
-    @effects :warning:
+    @effects :tools:
     @detectors DetectAMDWraithPrismControllers
     @comment The Wraith Prism comes with 2 cables but is only detectable
         and controlable when using the USB cable. `Morse Code` and `Mirage`
@@ -62,7 +63,7 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
     modes.push_back(Breathing);
 
     mode ColorCycle;
-    ColorCycle.name             = "Color Cycle";
+    ColorCycle.name             = "Spectrum Cycle";
     ColorCycle.value            = AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE;
     ColorCycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
     ColorCycle.speed_min        = AMD_WRAITH_PRISM_SPEED_SLOWEST;
@@ -75,7 +76,7 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
     modes.push_back(ColorCycle);
 
     mode Rainbow;
-    Rainbow.name                = "Rainbow";
+    Rainbow.name                = "Rainbow Wave";
     Rainbow.value               = AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW;
     Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
     Rainbow.speed_min           = AMD_WRAITH_PRISM_SPEED_SLOWEST;
@@ -258,7 +259,7 @@ void RGBController_AMDWraithPrism::DeviceUpdateMode()
             controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
             controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
             break;
-        
+
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
             controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
             controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp

@@ -1,353 +0,0 @@
-/*-----------------------------------------*\
-|  ASRockPolychromeSMBusController.cpp      |
-|                                           |
-|  Driver for for ASRock ASR LED and        |
-|  Polychrome RGB lighting controller       |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/14/2019  |
-\*-----------------------------------------*/
-
-#include "ASRockPolychromeSMBusController.h"
-#include <cstring>
-#include "dependencies/dmiinfo.h"
-#include "LogManager.h"
-
-#define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
-
-using namespace std::chrono_literals;
-
-PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-
-    DMIInfo dmi;
-
-    device_name =   "ASRock " + dmi.getMainboard();
-    fw_version =    ReadFirmwareVersion();
-    unsigned char   major_version = fw_version >> 8;
-
-    /*-----------------------------------------------------*\
-    | Determine whether the device uses ASR LED or          |
-    | Polychrome protocol by checking firmware version.     |
-    | Versions: 1.xx are ASR RGB LED                        |
-    |           2.xx are Polychrome v1                      |
-    |           3.xx are Polychrome v2                      |
-    \*-----------------------------------------------------*/
-    switch(major_version)
-    {
-        case ASROCK_TYPE_ASRLED:
-            LOG_TRACE("[%s] Device type is ASR RGB LED", ASROCK_CONTROLLER_NAME);
-            asrock_type = ASROCK_TYPE_ASRLED;
-            memset(zone_led_count, 0, sizeof(zone_led_count));
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V1:
-            LOG_TRACE("[%s] Device type is Polychrome v1", ASROCK_CONTROLLER_NAME);
-            asrock_type = ASROCK_TYPE_POLYCHROME_V1;
-            ReadLEDConfiguration();
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V2:
-            LOG_TRACE("[%s] Device type is Polychrome v2", ASROCK_CONTROLLER_NAME);
-            asrock_type = ASROCK_TYPE_POLYCHROME_V2;
-            ReadLEDConfiguration();
-            break;
-
-        default:
-            LOG_TRACE("[%s] Got Unknown version!", ASROCK_CONTROLLER_NAME);
-            asrock_type = ASROCK_TYPE_UNKNOWN;
-            break;
-    }
-}
-
-PolychromeController::~PolychromeController()
-{
-
-}
-
-unsigned int PolychromeController::GetASRockType()
-{
-    return(asrock_type);
-}
-
-std::string PolychromeController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-std::string PolychromeController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string PolychromeController::GetFirmwareVersion()
-{
-    unsigned char  major_version = fw_version >> 8;
-    unsigned char  minor_version = fw_version & 0xFF;
-
-    return(std::to_string(major_version) + "." + std::to_string(minor_version));
-}
-
-unsigned short PolychromeController::ReadFirmwareVersion()
-{
-    // The firmware register holds two bytes, so the first read should return 2
-    // If not, report invalid firmware revision FFFF
-    LOG_DEBUG("[%s] Reading back device firmware version", ASROCK_CONTROLLER_NAME);
-    // Version response array needs to be 32 bytes to prevent non ASRock board from stack smashing
-    unsigned char asrock_version[I2C_SMBUS_BLOCK_MAX] = { 0x00, 0x00 };
-    if (bus->i2c_smbus_read_block_data(dev, ASROCK_REG_FIRMWARE_VER, asrock_version) == 0x02)
-    {
-        unsigned char major = asrock_version[0];
-        unsigned char minor = asrock_version[1];
-
-        LOG_DEBUG("[%s] Device firmware version: v%02d.%02d", ASROCK_CONTROLLER_NAME, major, minor);
-        return((major << 8) | minor);
-    }
-    else
-    {
-        LOG_WARNING("[%s] Firmware readback failed; Returning 0xFFFF", ASROCK_CONTROLLER_NAME);
-        return(0xFFFF);
-    }
-}
-
-void PolychromeController::ReadLEDConfiguration()
-{
-    /*---------------------------------------------------------------------------------*\
-    | The LED configuration register holds 6 bytes, so the first read should return 6   |
-    | If not, set all zone sizes to zero                                                |
-    \*---------------------------------------------------------------------------------*/
-    LOG_DEBUG("[%s] Reading LED config from controller", ASROCK_CONTROLLER_NAME);
-    unsigned char asrock_zone_count[I2C_SMBUS_BLOCK_MAX] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
-    if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_REG_LED_CONFIG, asrock_zone_count) == 0x06)
-    {
-        zone_led_count[POLYCHROME_ZONE_1]           = asrock_zone_count[0];
-        zone_led_count[POLYCHROME_ZONE_2]           = asrock_zone_count[1];
-        zone_led_count[POLYCHROME_ZONE_3]           = asrock_zone_count[2];
-        zone_led_count[POLYCHROME_ZONE_4]           = asrock_zone_count[3];
-        zone_led_count[POLYCHROME_ZONE_5]           = asrock_zone_count[4];
-        zone_led_count[POLYCHROME_ZONE_ADDRESSABLE] = asrock_zone_count[5];
-        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_1, zone_led_count[POLYCHROME_ZONE_1]);
-        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_2, zone_led_count[POLYCHROME_ZONE_2]);
-        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_3, zone_led_count[POLYCHROME_ZONE_3]);
-        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_4, zone_led_count[POLYCHROME_ZONE_4]);
-        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_5, zone_led_count[POLYCHROME_ZONE_5]);
-        LOG_DEBUG("[%s] Addressable Zone LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_ADDRESSABLE]);
-    }
-    else
-    {
-        LOG_WARNING("[%s] LED config read failed", ASROCK_CONTROLLER_NAME);
-        memset(zone_led_count, 0, sizeof(zone_led_count));
-    }
-}
-
-unsigned int PolychromeController::GetMode()
-{
-    return(active_mode);
-}
-
-void PolychromeController::SetColorsAndSpeed(unsigned char led, unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char color_speed_pkt[4] = { red, green, blue, active_speed };
-    unsigned char select_led_pkt[1]  = { led };
-    
-    switch(asrock_type)
-    {
-        case ASROCK_TYPE_ASRLED:
-            /*-----------------------------------------------------*\
-            | Select LED                                            |
-            \*-----------------------------------------------------*/
-            if(active_mode != ASRLED_MODE_OFF)
-            {
-                bus->i2c_smbus_write_block_data(dev, ASROCK_REG_LED_SELECT, 1, select_led_pkt);
-                std::this_thread::sleep_for(1ms);
-            }
-
-            switch(active_mode)
-            {
-                /*-----------------------------------------------------*\
-                | These modes take 4 bytes in R/G/B/S order             |
-                \*-----------------------------------------------------*/
-                case ASRLED_MODE_BREATHING:
-                case ASRLED_MODE_STROBE:
-                case ASRLED_MODE_SPECTRUM_CYCLE:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 4, color_speed_pkt);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take 3 bytes in R/G/B order               |
-                \*-----------------------------------------------------*/
-                default:
-                case ASRLED_MODE_STATIC:
-                case ASRLED_MODE_MUSIC:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 3, color_speed_pkt);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take 1 byte - speed                       |
-                \*-----------------------------------------------------*/
-                case ASRLED_MODE_RANDOM:
-                case ASRLED_MODE_WAVE:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 1, &active_speed);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take no bytes                             |
-                \*-----------------------------------------------------*/
-                case ASRLED_MODE_OFF:
-                    break;
-            }
-            std::this_thread::sleep_for(1ms);
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V1:
-            /*-----------------------------------------------------*\
-            | Select LED                                            |
-            \*-----------------------------------------------------*/
-            if(active_mode != ASRLED_MODE_OFF)
-            {
-                bus->i2c_smbus_write_block_data(dev, ASROCK_REG_LED_SELECT, 1, select_led_pkt);
-                std::this_thread::sleep_for(1ms);
-            }
-
-            switch(active_mode)
-            {
-                /*-----------------------------------------------------*\
-                | These modes take 4 bytes in R/G/B/S order             |
-                \*-----------------------------------------------------*/
-                case POLYCHROME_V1_MODE_BREATHING:
-                case POLYCHROME_V1_MODE_STROBE:
-                case POLYCHROME_V1_MODE_SPECTRUM_CYCLE:
-                case POLYCHROME_V1_MODE_SPRING:
-                case POLYCHROME_V1_MODE_METEOR:
-                case POLYCHROME_V1_MODE_STACK:
-                case POLYCHROME_V1_MODE_CRAM:
-                case POLYCHROME_V1_MODE_SCAN:
-                case POLYCHROME_V1_MODE_NEON:
-                case POLYCHROME_V1_MODE_WATER:
-
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 4, color_speed_pkt);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take 3 bytes in R/G/B order               |
-                \*-----------------------------------------------------*/
-                default:
-                case POLYCHROME_V1_MODE_STATIC:
-                case POLYCHROME_V1_MODE_MUSIC:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 3, color_speed_pkt);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take 1 byte - speed                       |
-                \*-----------------------------------------------------*/
-                case POLYCHROME_V1_MODE_RANDOM:
-                case POLYCHROME_V1_MODE_WAVE:
-                case POLYCHROME_V1_MODE_RAINBOW:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 1, &active_speed);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take no bytes                             |
-                \*-----------------------------------------------------*/
-                case POLYCHROME_V1_MODE_OFF:
-                    break;
-            }
-            std::this_thread::sleep_for(1ms);
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V2:
-            /*-----------------------------------------------------*\
-            | Select LED                                            |
-            \*-----------------------------------------------------*/
-            switch(active_mode)
-            {
-                case POLYCHROME_V2_MODE_OFF:
-                case POLYCHROME_V2_MODE_RAINBOW:
-                case POLYCHROME_V2_MODE_SPECTRUM_CYCLE:
-                    break;
-
-                default:
-                    bus->i2c_smbus_write_block_data(dev, ASROCK_REG_LED_SELECT, 1, select_led_pkt);
-                    std::this_thread::sleep_for(1ms);
-
-                    /*-----------------------------------------------------*\
-                    | Polychrome firmware always writes color to fixed reg  |
-                    \*-----------------------------------------------------*/
-                    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V2_REG_COLOR, 3, color_speed_pkt);
-                    std::this_thread::sleep_for(1ms);
-                    break;
-            }
-            break;
-    }
-}
-
-void PolychromeController::SetMode(unsigned char zone,unsigned char mode, unsigned char speed)
-{
-    unsigned char led_count_pkt[1]  = { 0x00 };
-    active_zone                     = zone;
-    active_mode                     = mode;
-    active_speed                    = speed;
-
-    switch(asrock_type)
-    {
-        case ASROCK_TYPE_ASRLED:
-            bus->i2c_smbus_write_block_data(dev, ASROCK_REG_MODE, 1, &active_mode);
-            std::this_thread::sleep_for(1ms);
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V1:
-            /*-----------------------------------------------------*\
-            | Make sure set all register is set to 0                |
-            \*-----------------------------------------------------*/
-            bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_SET_ALL, 1, led_count_pkt);
-            std::this_thread::sleep_for(1ms);
-
-            /*-----------------------------------------------------*\
-            | Set the zone we are working on                        |
-            \*-----------------------------------------------------*/
-            bus->i2c_smbus_write_block_data(dev, ASROCK_REG_LED_SELECT, 1, &active_zone);
-            std::this_thread::sleep_for(1ms);
-
-            /*-----------------------------------------------------*\
-            | Write the mode                                        |
-            \*-----------------------------------------------------*/
-            bus->i2c_smbus_write_block_data(dev, ASROCK_REG_MODE, 1, &active_mode);
-            std::this_thread::sleep_for(1ms);
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V2:
-            bus->i2c_smbus_write_block_data(dev, ASROCK_REG_MODE, 1, &active_mode);
-            std::this_thread::sleep_for(1ms);
-
-            /*-----------------------------------------------------*\
-            | Select a single LED                                   |
-            \*-----------------------------------------------------*/
-            bus->i2c_smbus_write_block_data(dev, POLYCHROME_V2_REG_LED_COUNT, 0, led_count_pkt);
-            std::this_thread::sleep_for(1ms);
-
-            switch(active_mode)
-            {
-                /*-----------------------------------------------------*\
-                | These modes don't take a speed                        |
-                \*-----------------------------------------------------*/
-                case POLYCHROME_V2_MODE_OFF:
-                case POLYCHROME_V2_MODE_STATIC:
-                    break;
-
-                /*-----------------------------------------------------*\
-                | All other modes, write speed to active mode register  |
-                \*-----------------------------------------------------*/
-                default:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 1, &speed);
-                    std::this_thread::sleep_for(1ms);
-                    break;
-            }
-            break;
-    }    
-}

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h

@@ -1,271 +0,0 @@
-/*-----------------------------------------*\
-|  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>
-
-#pragma once
-
-typedef unsigned char	polychrome_dev_id;
-
-#define ASROCK_CONTROLLER_NAME  "ASRock Polychrome SMBus Controller"
-#define ASROCK_DETECTOR_NAME    "ASRock Polychrome SMBus Detect"
-#define VENDOR_NAME             "ASRock"
-#define SMBUS_ADDRESS           0x6A
-
-enum
-{
-    ASROCK_TYPE_UNKNOWN                     = 0x00,     /* Unknown Type or Not ASRock Device    */
-    ASROCK_TYPE_ASRLED                      = 0x01,     /* ASRock Firmware 1.x - ASR LED        */
-    ASROCK_TYPE_POLYCHROME_V1               = 0x02,     /* ASRock Firmware 2.x - Polychrome V1  */
-    ASROCK_TYPE_POLYCHROME_V2               = 0x03,     /* ASRock Firmware 3.x - Polychrome V2  */
-};
-
-enum
-{
-    /*------------------------------------------------------------------------------------------*\
-    | ASRock Common Registers                                                                    |
-    \*------------------------------------------------------------------------------------------*/
-    ASROCK_REG_FIRMWARE_VER                 = 0x00,     /* Firmware version Major.Minor         */
-    ASROCK_REG_MODE                         = 0x30,     /* Mode selection register              */
-    ASROCK_REG_LED_SELECT                   = 0x31,     /* LED selection register               */
-    /*------------------------------------------------------------------------------------------*\
-    | ASRock Polychrome V1/V2 Common Registers                                                   |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_REG_LED_CONFIG               = 0x33,     /* LED configuration register           */
-    /*------------------------------------------------------------------------------------------*\
-    | ASRock Polychrome V1 (Firmware 2.x) Registers                                              |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_REG_SET_ALL               = 0x32,     /* Set All register 0x1 = set all       */
-    POLYCHROME_V1_REG_ARGB_GRB              = 0x35,     /* ARGB bistream reversing register     */
-    /*------------------------------------------------------------------------------------------*\
-    | ASRock Polychrome V2 (Firmware 3.x) Registers                                              |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V2_REG_LED_COUNT             = 0x32,     /* Additional LED count register        */
-    POLYCHROME_V2_REG_COLOR                 = 0x34,     /* Color register: Red, Green, Blue     */
-    POLYCHROME_V2_REG_ARGB_GRB              = 0x35,     /* ARGB bistream reversing register     */
-};
-
-enum
-{
-    POLYCHROME_ZONE_1                       = 0x00,     /* RGB LED 1 Header                     */
-    POLYCHROME_ZONE_2                       = 0x01,     /* RGB LED 2 Header                     */
-    POLYCHROME_ZONE_3                       = 0x02,     /* Audio/PCH Zone LEDs                  */
-    POLYCHROME_ZONE_4                       = 0x03,     /* Audio/PCH Zone LEDs                  */
-    POLYCHROME_ZONE_5                       = 0x04,     /* IO Cover Zone LEDs                   */
-    POLYCHROME_ZONE_ADDRESSABLE             = 0x05,     /* Addressable LED header               */
-    POLYCHROME_ZONE_COUNT                   = 0x06,     /* Total number of zones                */
-    POLYCHROME_ZONE_ADDRESSABLE_MAX         = 0x64,     /* Maxinum number of ARGB LEDs          */
-};
-
-/*----------------------------------------------------------------------------------------------*\
-| Definitions for ASR LED                                                                        |
-\*----------------------------------------------------------------------------------------------*/
-#define ASRLED_NUM_MODES                    8           /* Number of ASR LED modes              */
-
-enum
-{
-    ASRLED_MODE_OFF                         = 0x10,     /* OFF mode                             */
-    ASRLED_MODE_STATIC                      = 0x11,     /* Static color mode                    */
-    ASRLED_MODE_BREATHING                   = 0x12,     /* Breathing effect mode                */
-    ASRLED_MODE_STROBE                      = 0x13,     /* Strobe effect mode                   */
-    ASRLED_MODE_SPECTRUM_CYCLE              = 0x14,     /* Spectrum Cycle effect mode           */
-    ASRLED_MODE_RANDOM                      = 0x15,     /* Random effect mode                   */
-    ASRLED_MODE_MUSIC                       = 0x17,     /* Music effect mode                    */
-    ASRLED_MODE_WAVE                        = 0x18,     /* Wave effect mode                     */
-};
-
-enum
-{
-    ASRLED_SPEED_MIN                        = 0x05,     /* Slowest speed                        */
-    ASRLED_SPEED_DEFAULT                    = 0x03,     /* Default speed                        */
-    ASRLED_SPEED_MAX                        = 0x00,     /* Fastest speed                        */
-};
-
-/*----------------------------------------------------------------------------------------------*\
-| Definitions for Polychrome V1                                                                  |
-\*----------------------------------------------------------------------------------------------*/
-#define POLYCHROME_V1_NUM_MODES             16          /* Number of Polychrome V1 modes        */
-
-enum
-{
-    POLYCHROME_V1_MODE_OFF                  = 0x10,     /* OFF mode                             */
-    POLYCHROME_V1_MODE_STATIC               = 0x11,     /* Static color mode                    */
-    POLYCHROME_V1_MODE_BREATHING            = 0x12,     /* Breating effect mode                 */
-    POLYCHROME_V1_MODE_STROBE               = 0x13,     /* Strobe effect mode                   */
-    POLYCHROME_V1_MODE_SPECTRUM_CYCLE       = 0x14,     /* Spectrum Cycle effect mode           */
-    POLYCHROME_V1_MODE_RANDOM               = 0x15,     /* Random effect mode                   */
-    POLYCHROME_V1_MODE_MUSIC                = 0x17,     /* Music effect mode                    */
-    POLYCHROME_V1_MODE_WAVE                 = 0x18,     /* Wave effect mode                     */
-    /*------------------------------------------------------------------------------------------*\
-    | Modes only available on ARGB headers                                                       |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_MODE_SPRING               = 0x19,     /* Spring effect mode                   */
-    POLYCHROME_V1_MODE_METEOR               = 0x1A,     /* Meteor effect mode                   */
-    POLYCHROME_V1_MODE_STACK                = 0x1B,     /* Stack effect mode                    */
-    POLYCHROME_V1_MODE_CRAM                 = 0x1C,     /* Cram effect mode                     */
-    POLYCHROME_V1_MODE_SCAN                 = 0x1D,     /* Scan effect mode                     */
-    POLYCHROME_V1_MODE_NEON                 = 0x1E,     /* Neon effect mode                     */
-    POLYCHROME_V1_MODE_WATER                = 0x1F,     /* Water effect mode                    */
-    POLYCHROME_V1_MODE_RAINBOW              = 0x20,     /* Rainbow chase effect mode            */
-};
-
-enum
-{
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_BREATHING                                                               |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_BREATHING       = 0x0A,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_BREATHING   = 0x02,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_BREATHING       = 0x02,     /* Fastest speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_STROBE                                                                  |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_STROBE          = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_STROBE      = 0x14,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_STROBE          = 0x05,     /* Fastest speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_SPECTRUM_CYCLE                                                          |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_CYCLE           = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_CYCLE       = 0x14,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_CYCLE           = 0x0A,     /* Fastest speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_RANDOM                                                                  |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_RANDOM          = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_RANDOM      = 0x28,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_RANDOM          = 0x05,     /* Fastest speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_WAVE                                                                    |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_WAVE            = 0x06,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_WAVE        = 0x02,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_WAVE            = 0x01,     /* Fastest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_SPRING      = 0x04,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_METEOR      = 0x0A,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_STACK       = 0x04,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_CRAM        = 0x04,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_SCAN        = 0x0A,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_NEON        = 0x20,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_WATER       = 0x0A,     /* Default speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_RAINBOW                                                                 |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_RAINBOW         = 0x12,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_RAINBOW     = 0x0A,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_RAINBOW         = 0x01,     /* Fastest speed                        */
-    POLYCHROME_V1_SPEED_MIN_ARGB            = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_MAX_ARGB            = 0x02,     /* Fastest speed                        */
-};
-
-/*----------------------------------------------------------------------------------------------*\
-| Definitions for Polychrome V2                                                                  |
-\*----------------------------------------------------------------------------------------------*/
-#define POLYCHROME_V2_NUM_MODES             14          /* Number of Polychrome V2 modes        */
-
-enum
-{
-    POLYCHROME_V2_MODE_OFF                  = 0x10,     /* OFF mode                             */
-    POLYCHROME_V2_MODE_STATIC               = 0x11,     /* Static color mode                    */
-    POLYCHROME_V2_MODE_BREATHING            = 0x12,     /* Breating effect mode                 */
-    POLYCHROME_V2_MODE_STROBE               = 0x13,     /* Strobe effect mode                   */
-    POLYCHROME_V2_MODE_SPECTRUM_CYCLE       = 0x14,     /* Spectrum Cycle effect mode           */
-    POLYCHROME_V2_MODE_RANDOM               = 0x15,     /* Random effect mode                   */
-    POLYCHROME_V2_MODE_WAVE                 = 0x17,     /* Wave effect mode                     */
-    POLYCHROME_V2_MODE_SPRING               = 0x18,     /* Spring effect mode                   */
-    POLYCHROME_V2_MODE_STACK                = 0x19,     /* Stack effect mode                    */
-    POLYCHROME_V2_MODE_CRAM                 = 0x1A,     /* Cram effect mode                     */
-    POLYCHROME_V2_MODE_SCAN                 = 0x1B,     /* Scan effect mode                     */
-    POLYCHROME_V2_MODE_NEON                 = 0x1C,     /* Neon effect mode                     */
-    POLYCHROME_V2_MODE_WATER                = 0x1D,     /* Water effect mode                    */
-    POLYCHROME_V2_MODE_RAINBOW              = 0x1E,     /* Rainbow effect mode                  */
-};
-
-enum
-{
-    POLYCHROME_V2_BREATHING_SPEED_MIN               = 0x0A,     /* Slowest speed                        */
-    POLYCHROME_V2_BREATHING_SPEED_DEFAULT           = 0x06,     /* Default speed                        */
-    POLYCHROME_V2_BREATHING_SPEED_MAX               = 0x02,     /* Fastest speed                        */
-
-    POLYCHROME_V2_STROBE_SPEED_MIN                  = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V2_STROBE_SPEED_DEFAULT              = 0x4D,     /* Default speed                        */
-    POLYCHROME_V2_STROBE_SPEED_MAX                  = 0x05,     /* Fastest speed                        */
-
-    POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MIN          = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_DEFAULT      = 0x50,     /* Default speed                        */
-    POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MAX          = 0x0A,     /* Fastest speed                        */
-
-    POLYCHROME_V2_RANDOM_SPEED_MIN                  = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V2_RANDOM_SPEED_DEFAULT              = 0x4D,     /* Default speed                        */
-    POLYCHROME_V2_RANDOM_SPEED_MAX                  = 0x05,     /* Fastest speed                        */
-
-    POLYCHROME_V2_WAVE_SPEED_MIN                    = 0x06,     /* Slowest speed                        */
-    POLYCHROME_V2_WAVE_SPEED_DEFAULT                = 0x03,     /* Default speed                        */
-    POLYCHROME_V2_WAVE_SPEED_MAX                    = 0x01,     /* Fastest speed                        */
-
-    POLYCHROME_V2_SPRING_SPEED_MIN                  = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V2_SPRING_SPEED_DEFAULT              = 0x11,     /* Default speed                        */
-    POLYCHROME_V2_SPRING_SPEED_MAX                  = 0x02,     /* Fastest speed                        */
-
-    POLYCHROME_V2_STACK_SPEED_MIN                   = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V2_STACK_SPEED_DEFAULT               = 0x11,     /* Default speed                        */
-    POLYCHROME_V2_STACK_SPEED_MAX                   = 0x02,     /* Fastest speed                        */
-
-    POLYCHROME_V2_CRAM_SPEED_MIN                    = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V2_CRAM_SPEED_DEFAULT                = 0x11,     /* Default speed                        */
-    POLYCHROME_V2_CRAM_SPEED_MAX                    = 0x02,     /* Fastest speed                        */
-
-    POLYCHROME_V2_SCAN_SPEED_MIN                    = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V2_SCAN_SPEED_DEFAULT                = 0x11,     /* Default speed                        */
-    POLYCHROME_V2_SCAN_SPEED_MAX                    = 0x02,     /* Fastest speed                        */
-
-    POLYCHROME_V2_NEON_SPEED_MIN                    = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V2_NEON_SPEED_DEFAULT                = 0x11,     /* Default speed                        */
-    POLYCHROME_V2_NEON_SPEED_MAX                    = 0x02,     /* Fastest speed                        */
-
-    POLYCHROME_V2_WATER_SPEED_MIN                   = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V2_WATER_SPEED_DEFAULT               = 0x11,     /* Default speed                        */
-    POLYCHROME_V2_WATER_SPEED_MAX                   = 0x02,     /* Fastest speed                        */
-
-    POLYCHROME_V2_RAINBOW_SPEED_MIN                 = 0x12,     /* Slowest speed                        */
-    POLYCHROME_V2_RAINBOW_SPEED_DEFAULT             = 0x08,     /* Default speed                        */
-    POLYCHROME_V2_RAINBOW_SPEED_MAX                 = 0x02,     /* Fastest speed                        */
-};
-
-class PolychromeController
-{
-public:
-    PolychromeController(i2c_smbus_interface* bus, polychrome_dev_id dev);
-    ~PolychromeController();
-
-    std::string     GetDeviceLocation();
-    std::string     GetDeviceName();
-    std::string     GetFirmwareVersion();
-    unsigned int    GetMode();
-    unsigned int    GetASRockType();
-    void            SetColorsAndSpeed(unsigned char led, unsigned char red, unsigned char green, unsigned char blue);
-    void            SetMode(unsigned char zone, unsigned char mode, unsigned char speed);
-
-    unsigned char           zone_led_count[6];
-    
-private:
-    unsigned int            asrock_type;
-    unsigned short          fw_version;
-    std::string             device_name;
-    unsigned char           active_zone;
-    unsigned char           active_mode;
-    unsigned char           active_speed;
-    i2c_smbus_interface*    bus;
-    polychrome_dev_id       dev;
-
-    unsigned short  ReadFirmwareVersion();
-    void            ReadLEDConfiguration();
-};

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusControllerDetect.cpp

@@ -1,89 +0,0 @@
-#include "Detector.h"
-#include "ASRockPolychromeSMBusController.h"
-#include "LogManager.h"
-#include "RGBController.h"
-#include "RGBController_ASRockPolychromeSMBus.h"
-#include "i2c_smbus.h"
-#include "pci_ids.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForPolychromeSMBusController                                                       *
-*                                                                                          *
-*       Tests the given address to see if an ASRock Polychrome RGB controller exists there.*
-*       First does a quick write to test for a response                                    *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-
-    if (res >= 0)
-    {
-        pass = true;
-    }
-
-    return(pass);
-
-}   /* TestForPolychromeController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectPolychromeControllers                                                            *
-*                                                                                          *
-*       Detect ASRock Polychrome RGB SMBus controllers on the enumerated I2C busses at     *
-*       address 0x6A.                                                                      *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Polychrome device is connected      *
-*           dev - I2C address of Polychrome device                                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
-{
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
-        {
-            if(busses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
-            {
-                LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
-                // Check for Polychrome controller at 0x6A
-                if(TestForPolychromeSMBusController(busses[bus], SMBUS_ADDRESS))
-                {
-                    LOG_DEBUG("[%s] Detected a device at address %02X, testing for a known controller",  ASROCK_DETECTOR_NAME, SMBUS_ADDRESS);
-                    PolychromeController* controller = new PolychromeController(busses[bus], SMBUS_ADDRESS);
-
-                    if(controller->GetASRockType() != ASROCK_TYPE_UNKNOWN)
-                    {
-                        LOG_DEBUG("[%s] Found a known Polychrome device", ASROCK_DETECTOR_NAME);
-                        RGBController_Polychrome* rgb_controller = new RGBController_Polychrome(controller);
-                        ResourceManager::get()->RegisterRGBController(rgb_controller);
-                    }
-                    else
-                    {
-                        LOG_DEBUG("[%s] Not a Polychrome device or unknown type", ASROCK_DETECTOR_NAME);
-                        delete controller;
-                    }
-                }
-                else
-                {
-                    LOG_DEBUG("[%s] Bus %02d no response at %02X", ASROCK_DETECTOR_NAME, bus, SMBUS_ADDRESS);
-                }
-            }
-            else
-            {
-                LOG_DEBUG(SMBUS_CHECK_DEVICE_FAILURE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME);
-            } 
-        }
-    }
-
-}   /* DetectSMBusPolychromeControllers() */
-
-REGISTER_I2C_DETECTOR("ASRock Polychrome SMBus", DetectPolychromeSMBusControllers);

Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.cpp

@@ -1,656 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_ASRockPolychromeSMBus.cpp  |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  ASRock ASR LED and Polychrome RGB Driver |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/15/2019  |
-\*-----------------------------------------*/
-
-#include "RGBController_ASRockPolychromeSMBus.h"
-
-#define ASROCK_MAX_ZONES    4
-#define ASROCK_MAX_LEDS     22
-
-static const char* polychrome_v1_zone_names[] =
-{
-    "RGB LED 1 Header",
-    "RGB LED 2 Header",
-    "PCH",
-    "IO Cover",
-    "Audio",
-    "Addressable Header"
-};
-
-static const char* polychrome_v2_zone_names[] =
-{
-    "RGB LED 1 Header",
-    "RGB LED 2 Header",
-    "Audio",
-    "PCH",
-    "IO Cover",
-    "Addressable Header"
-};
-
-/**------------------------------------------------------------------*\
-    @name ASRock Polychrome SMBus
-    @type SMBus
-    @save :warning:
-    @direct :x:
-    @effects :white_check_mark:
-    @detectors DetectPolychromeSMBusControllers
-    @comment ASRock Polychrome controllers will save with each update.
-        Per ARGB LED support is not possible with these devices.
-\*-------------------------------------------------------------------*/
-
-RGBController_Polychrome::RGBController_Polychrome(PolychromeController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = controller->GetDeviceName();
-    vendor      = "ASRock";
-    version     = controller->GetFirmwareVersion();
-    type        = DEVICE_TYPE_MOTHERBOARD;
-    location    = controller->GetDeviceLocation();
-
-    switch(controller->GetASRockType())
-    {
-        case ASROCK_TYPE_ASRLED:
-            {
-                description = "ASRock ASR RGB LED Device";
-
-                mode Off;
-                Off.name                    = "Off";
-                Off.value                   = ASRLED_MODE_OFF;
-                Off.flags                   = 0;
-                Off.color_mode              = MODE_COLORS_NONE;
-                modes.push_back(Off);
-
-                mode Static;
-                Static.name                 = "Static";
-                Static.value                = ASRLED_MODE_STATIC;
-                Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-                Static.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Static);
-
-                mode Breathing;
-                Breathing.name              = "Breathing";
-                Breathing.value             = ASRLED_MODE_BREATHING;
-                Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Breathing.speed_min         = ASRLED_SPEED_MIN;
-                Breathing.speed_max         = ASRLED_SPEED_MAX;
-                Breathing.speed             = ASRLED_SPEED_DEFAULT;
-                Breathing.color_mode        = MODE_COLORS_PER_LED;
-                modes.push_back(Breathing);
-
-                mode Strobe;
-                Strobe.name                 = "Strobe";
-                Strobe.value                = ASRLED_MODE_STROBE;
-                Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Strobe.speed_min            = ASRLED_SPEED_MIN;
-                Strobe.speed_max            = ASRLED_SPEED_MAX;
-                Strobe.speed                = ASRLED_SPEED_DEFAULT;
-                Strobe.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Strobe);
-
-                mode SpectrumCycle;
-                SpectrumCycle.name          = "Spectrum Cycle";
-                SpectrumCycle.value         = ASRLED_MODE_SPECTRUM_CYCLE;
-                SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED;
-                SpectrumCycle.speed_min     = ASRLED_SPEED_MIN;
-                SpectrumCycle.speed_max     = ASRLED_SPEED_MAX;
-                SpectrumCycle.speed         = ASRLED_SPEED_DEFAULT;
-                SpectrumCycle.color_mode    = MODE_COLORS_NONE;
-                modes.push_back(SpectrumCycle);
-
-                mode Random;
-                Random.name                 = "Random";
-                Random.value                = ASRLED_MODE_RANDOM;
-                Random.flags                = MODE_FLAG_HAS_SPEED;
-                Random.speed_min            = ASRLED_SPEED_MIN;
-                Random.speed_max            = ASRLED_SPEED_MAX;
-                Random.speed                = ASRLED_SPEED_DEFAULT;
-                Random.color_mode           = MODE_COLORS_NONE;
-                modes.push_back(Random);
-
-                mode Music;
-                Music.name                  = "Music";
-                Music.value                 = ASRLED_MODE_MUSIC;
-                Music.flags                 = MODE_FLAG_HAS_PER_LED_COLOR;
-                Music.color_mode            = MODE_COLORS_PER_LED;
-                modes.push_back(Music);
-
-                mode Wave;
-                Wave.name                   = "Wave";
-                Wave.value                  = ASRLED_MODE_WAVE;
-                Wave.flags                  = MODE_FLAG_HAS_SPEED;
-                Wave.speed_min              = ASRLED_SPEED_MIN;
-                Wave.speed_max              = ASRLED_SPEED_MAX;
-                Wave.speed                  = ASRLED_SPEED_DEFAULT;
-                Wave.color_mode             = MODE_COLORS_NONE;
-                modes.push_back(Wave);
-            }
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V1:
-            {
-                description = "ASRock Polychrome v1 Device";
-
-                mode Off;
-                Off.name                    = "Off";
-                Off.value                   = POLYCHROME_V1_MODE_OFF;
-                Off.flags                   = 0;
-                Off.color_mode              = MODE_COLORS_NONE;
-                modes.push_back(Off);
-
-                mode Static;
-                Static.name                 = "Static";
-                Static.value                = POLYCHROME_V1_MODE_STATIC;
-                Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-                Static.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Static);
-
-                mode Breathing;
-                Breathing.name              = "Breathing";
-                Breathing.value             = POLYCHROME_V1_MODE_BREATHING;
-                Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Breathing.speed_min         = POLYCHROME_V1_SPEED_MIN_BREATHING;
-                Breathing.speed_max         = POLYCHROME_V1_SPEED_MAX_BREATHING;
-                Breathing.speed             = POLYCHROME_V1_SPEED_DEFAULT_BREATHING;
-                Breathing.color_mode        = MODE_COLORS_PER_LED;
-                modes.push_back(Breathing);
-
-                mode Strobe;
-                Strobe.name                 = "Strobe";
-                Strobe.value                = POLYCHROME_V1_MODE_STROBE;
-                Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Strobe.speed_min            = POLYCHROME_V1_SPEED_MIN_STROBE;
-                Strobe.speed_max            = POLYCHROME_V1_SPEED_MAX_STROBE;
-                Strobe.speed                = POLYCHROME_V1_SPEED_DEFAULT_STROBE;
-                Strobe.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Strobe);
-
-                mode SpectrumCycle;
-                SpectrumCycle.name          = "Spectrum Cycle";
-                SpectrumCycle.value         = POLYCHROME_V1_MODE_SPECTRUM_CYCLE;
-                SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED;
-                SpectrumCycle.speed_min     = POLYCHROME_V1_SPEED_MIN_CYCLE;
-                SpectrumCycle.speed_max     = POLYCHROME_V1_SPEED_MAX_CYCLE;
-                SpectrumCycle.speed         = POLYCHROME_V1_SPEED_DEFAULT_CYCLE;
-                SpectrumCycle.color_mode    = MODE_COLORS_NONE;
-                modes.push_back(SpectrumCycle);
-
-                mode Random;
-                Random.name                 = "Random";
-                Random.value                = POLYCHROME_V1_MODE_RANDOM;
-                Random.flags                = MODE_FLAG_HAS_SPEED;
-                Random.speed_min            = POLYCHROME_V1_SPEED_MIN_RANDOM;
-                Random.speed_max            = POLYCHROME_V1_SPEED_MAX_RANDOM;
-                Random.speed                = POLYCHROME_V1_SPEED_DEFAULT_RANDOM;
-                Random.color_mode           = MODE_COLORS_NONE;
-                modes.push_back(Random);
-
-                mode Music;
-                Music.name                 = "Music";
-                Music.value                = POLYCHROME_V1_MODE_MUSIC;
-                Music.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-                Music.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Music);
-
-                mode Wave;
-                Wave.name                   = "Wave";
-                Wave.value                  = POLYCHROME_V1_MODE_WAVE;
-                Wave.flags                  = MODE_FLAG_HAS_SPEED;
-                Wave.speed_min              = POLYCHROME_V1_SPEED_MIN_WAVE;
-                Wave.speed_max              = POLYCHROME_V1_SPEED_MAX_WAVE;
-                Wave.speed                  = POLYCHROME_V1_SPEED_DEFAULT_WAVE;
-                Wave.color_mode             = MODE_COLORS_NONE;
-                modes.push_back(Wave);
-
-                /*---------------------------------------------------------------------*\
-                | Comment out until per zone modes are working. These are only for ARGB |
-                \*---------------------------------------------------------------------*/
-                /*
-                mode Spring;
-                Spring.name                 = "Spring";
-                Spring.value                = POLYCHROME_V1_MODE_SPRING;
-                Spring.flags                = MODE_FLAG_HAS_SPEED;
-                Spring.speed_min            = POLYCHROME_V1_SPEED_MIN_ARGB;
-                Spring.speed_max            = POLYCHROME_V1_SPEED_MAX_ARGB;
-                Spring.speed                = POLYCHROME_V1_SPEED_DEFAULT_SPRING;
-                Spring.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Spring);
-
-                mode Stack;
-                Stack.name                  = "Stack";
-                Stack.value                 = POLYCHROME_V1_MODE_STACK;
-                Stack.flags                 = MODE_FLAG_HAS_SPEED;
-                Stack.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
-                Stack.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
-                Stack.speed                 = POLYCHROME_V1_SPEED_DEFAULT_STACK;
-                Stack.color_mode            = MODE_COLORS_PER_LED;
-                modes.push_back(Stack);
-
-                mode Cram;
-                Cram.name                   = "Cram";
-                Cram.value                  = POLYCHROME_V1_MODE_CRAM;
-                Cram.flags                  = MODE_FLAG_HAS_SPEED;
-                Cram.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
-                Cram.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
-                Cram.speed                  = POLYCHROME_V1_SPEED_DEFAULT_CRAM;
-                Cram.color_mode             = MODE_COLORS_PER_LED;
-                modes.push_back(Cram);
-
-                mode Scan;
-                Scan.name                   = "Scan";
-                Scan.value                  = POLYCHROME_V1_MODE_SCAN;
-                Scan.flags                  = MODE_FLAG_HAS_SPEED;
-                Scan.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
-                Scan.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
-                Scan.speed                  = POLYCHROME_V1_SPEED_DEFAULT_SCAN;
-                Scan.color_mode             = MODE_COLORS_PER_LED;
-                modes.push_back(Scan);
-
-                mode Neon;
-                Neon.name                   = "Neon";
-                Neon.value                  = POLYCHROME_V1_MODE_NEON;
-                Neon.flags                  = MODE_FLAG_HAS_SPEED;
-                Neon.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
-                Neon.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
-                Neon.speed                  = POLYCHROME_V1_SPEED_DEFAULT_NEON;
-                Neon.color_mode             = MODE_COLORS_PER_LED;
-                modes.push_back(Neon);
-
-                mode Water;
-                Water.name                  = "Water";
-                Water.value                 = POLYCHROME_V1_MODE_WATER;
-                Water.flags                 = MODE_FLAG_HAS_SPEED;
-                Water.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
-                Water.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
-                Water.speed                 = POLYCHROME_V1_SPEED_DEFAULT_WATER;
-                Water.color_mode            = MODE_COLORS_PER_LED;
-                modes.push_back(Water);
-
-                mode Rainbow;
-                Rainbow.name                = "Rainbow";
-                Rainbow.value               = POLYCHROME_V1_MODE_RAINBOW;
-                Rainbow.flags               = MODE_FLAG_HAS_SPEED;
-                Rainbow.speed_min           = POLYCHROME_V1_SPEED_MIN_RAINBOW;
-                Rainbow.speed_max           = POLYCHROME_V1_SPEED_MAX_RAINBOW;
-                Rainbow.speed               = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW;
-                Rainbow.color_mode          = MODE_COLORS_NONE;
-                modes.push_back(Rainbow);
-                */
-            }
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V2:
-            {
-                description = "ASRock Polychrome v2 Device";
-
-                mode Off;
-                Off.name                    = "Off";
-                Off.value                   = POLYCHROME_V2_MODE_OFF;
-                Off.flags                   = 0;
-                Off.color_mode              = MODE_COLORS_NONE;
-                modes.push_back(Off);
-
-                mode Static;
-                Static.name                 = "Static";
-                Static.value                = POLYCHROME_V2_MODE_STATIC;
-                Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-                Static.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Static);
-
-                mode Breathing;
-                Breathing.name              = "Breathing";
-                Breathing.value             = POLYCHROME_V2_MODE_BREATHING;
-                Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Breathing.speed_min         = POLYCHROME_V2_BREATHING_SPEED_MIN;
-                Breathing.speed_max         = POLYCHROME_V2_BREATHING_SPEED_MAX;
-                Breathing.speed             = POLYCHROME_V2_BREATHING_SPEED_DEFAULT;
-                Breathing.color_mode        = MODE_COLORS_PER_LED;
-                modes.push_back(Breathing);
-
-                mode Strobe;
-                Strobe.name                 = "Strobe";
-                Strobe.value                = POLYCHROME_V2_MODE_STROBE;
-                Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Strobe.speed_min            = POLYCHROME_V2_STROBE_SPEED_MIN;
-                Strobe.speed_max            = POLYCHROME_V2_STROBE_SPEED_MAX;
-                Strobe.speed                = POLYCHROME_V2_STROBE_SPEED_DEFAULT;
-                Strobe.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Strobe);
-
-                mode SpectrumCycle;
-                SpectrumCycle.name          = "Spectrum Cycle";
-                SpectrumCycle.value         = POLYCHROME_V2_MODE_SPECTRUM_CYCLE;
-                SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED;
-                SpectrumCycle.speed_min     = POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MIN;
-                SpectrumCycle.speed_max     = POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MAX;
-                SpectrumCycle.speed         = POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_DEFAULT;
-                SpectrumCycle.color_mode    = MODE_COLORS_NONE;
-                modes.push_back(SpectrumCycle);
-
-                mode Random;
-                Random.name                 = "Random";
-                Random.value                = POLYCHROME_V2_MODE_RANDOM;
-                Random.flags                = MODE_FLAG_HAS_SPEED;
-                Random.speed_min            = POLYCHROME_V2_RANDOM_SPEED_MIN;
-                Random.speed_max            = POLYCHROME_V2_RANDOM_SPEED_MAX;
-                Random.speed                = POLYCHROME_V2_RANDOM_SPEED_DEFAULT;
-                Random.color_mode           = MODE_COLORS_NONE;
-                modes.push_back(Random);
-
-                mode Wave;
-                Wave.name                   = "Wave";
-                Wave.value                  = POLYCHROME_V2_MODE_WAVE;
-                Wave.flags                  = MODE_FLAG_HAS_SPEED;
-                Wave.speed_min              = POLYCHROME_V2_WAVE_SPEED_MIN;
-                Wave.speed_max              = POLYCHROME_V2_WAVE_SPEED_MAX;
-                Wave.speed                  = POLYCHROME_V2_WAVE_SPEED_DEFAULT;
-                Wave.color_mode             = MODE_COLORS_NONE;
-                modes.push_back(Wave);
-
-                mode Spring;
-                Spring.name                 = "Spring";
-                Spring.value                = POLYCHROME_V2_MODE_SPRING;
-                Spring.flags                = MODE_FLAG_HAS_SPEED;
-                Spring.speed_min            = POLYCHROME_V2_SPRING_SPEED_MIN;
-                Spring.speed_max            = POLYCHROME_V2_SPRING_SPEED_MAX;
-                Spring.speed                = POLYCHROME_V2_SPRING_SPEED_DEFAULT;
-                Spring.color_mode           = MODE_COLORS_NONE;
-                modes.push_back(Spring);
-
-                mode Stack;
-                Stack.name                  = "Stack";
-                Stack.value                 = POLYCHROME_V2_MODE_STACK;
-                Stack.flags                 = MODE_FLAG_HAS_SPEED;
-                Stack.speed_min             = POLYCHROME_V2_STACK_SPEED_MIN;
-                Stack.speed_max             = POLYCHROME_V2_STACK_SPEED_MAX;
-                Stack.speed                 = POLYCHROME_V2_STACK_SPEED_DEFAULT;
-                Stack.color_mode            = MODE_COLORS_NONE;
-                modes.push_back(Stack);
-
-                mode Cram;
-                Cram.name                   = "Cram";
-                Cram.value                  = POLYCHROME_V2_MODE_CRAM;
-                Cram.flags                  = MODE_FLAG_HAS_SPEED;
-                Cram.speed_min              = POLYCHROME_V2_CRAM_SPEED_MIN;
-                Cram.speed_max              = POLYCHROME_V2_CRAM_SPEED_MAX;
-                Cram.speed                  = POLYCHROME_V2_CRAM_SPEED_DEFAULT;
-                Cram.color_mode             = MODE_COLORS_NONE;
-                modes.push_back(Cram);
-
-                mode Scan;
-                Scan.name                   = "Scan";
-                Scan.value                  = POLYCHROME_V2_MODE_SCAN;
-                Scan.flags                  = MODE_FLAG_HAS_SPEED;
-                Scan.speed_min              = POLYCHROME_V2_SCAN_SPEED_MIN;
-                Scan.speed_max              = POLYCHROME_V2_SCAN_SPEED_MAX;
-                Scan.speed                  = POLYCHROME_V2_SCAN_SPEED_DEFAULT;
-                Scan.color_mode             = MODE_COLORS_NONE;
-                modes.push_back(Scan);
-
-                mode Neon;
-                Neon.name                   = "Neon";
-                Neon.value                  = POLYCHROME_V2_MODE_NEON;
-                Neon.flags                  = MODE_FLAG_HAS_SPEED;
-                Neon.speed_min              = POLYCHROME_V2_NEON_SPEED_MIN;
-                Neon.speed_max              = POLYCHROME_V2_NEON_SPEED_MAX;
-                Neon.speed                  = POLYCHROME_V2_NEON_SPEED_DEFAULT;
-                Neon.color_mode             = MODE_COLORS_NONE;
-                modes.push_back(Neon);
-
-                mode Water;
-                Water.name                  = "Water";
-                Water.value                 = POLYCHROME_V2_MODE_WATER;
-                Water.flags                 = MODE_FLAG_HAS_SPEED;
-                Water.speed_min             = POLYCHROME_V2_WATER_SPEED_MIN;
-                Water.speed_max             = POLYCHROME_V2_WATER_SPEED_MAX;
-                Water.speed                 = POLYCHROME_V2_WATER_SPEED_DEFAULT;
-                Water.color_mode            = MODE_COLORS_NONE;
-                modes.push_back(Water);
-
-                mode Rainbow;
-                Rainbow.name                = "Rainbow";
-                Rainbow.value               = POLYCHROME_V2_MODE_RAINBOW;
-                Rainbow.flags               = MODE_FLAG_HAS_SPEED;
-                Rainbow.speed_min           = POLYCHROME_V2_RAINBOW_SPEED_MIN;
-                Rainbow.speed_max           = POLYCHROME_V2_RAINBOW_SPEED_MAX;
-                Rainbow.speed               = POLYCHROME_V2_RAINBOW_SPEED_DEFAULT;
-                Rainbow.color_mode          = MODE_COLORS_NONE;
-                modes.push_back(Rainbow);
-            }
-            break;
-    }
-
-    SetupZones();
-}
-
-RGBController_Polychrome::~RGBController_Polychrome()
-{
-    delete controller;
-}
-
-void RGBController_Polychrome::SetupZones()
-{
-    switch(controller->GetASRockType())
-    {
-        /*---------------------------------------------------------*\
-        | ASR LED motherboards only have a single zone/LED          |
-        \*---------------------------------------------------------*/
-        case ASROCK_TYPE_ASRLED:
-            {
-                /*---------------------------------------------------------*\
-                | Set up zones                                              |
-                \*---------------------------------------------------------*/
-                zone* new_zone = new zone();
-
-                /*---------------------------------------------------------*\
-                | Set single zone name to "Motherboard"                     |
-                \*---------------------------------------------------------*/
-                new_zone->name          = "Motherboard";
-                new_zone->type          = ZONE_TYPE_SINGLE;
-                new_zone->leds_min      = 1;
-                new_zone->leds_max      = 1;
-                new_zone->leds_count    = 1;
-                new_zone->matrix_map    = NULL;
-
-                /*---------------------------------------------------------*\
-                | Push new zone to zones vector                             |
-                \*---------------------------------------------------------*/
-                zones.push_back(*new_zone);
-
-                /*---------------------------------------------------------*\
-                | Set up LEDs                                               |
-                \*---------------------------------------------------------*/
-                led* new_led = new led();
-
-                /*---------------------------------------------------------*\
-                | Set single LED name to "Motherboard"                      |
-                \*---------------------------------------------------------*/
-                new_led->name           = "Motherboard";
-
-                /*---------------------------------------------------------*\
-                | Push new LED to LEDs vector                               |
-                \*---------------------------------------------------------*/
-                leds.push_back(*new_led);
-            }
-            break;
-
-        /*---------------------------------------------------------*\
-        | Polychrome motherboards should set up zones based on LED  |
-        | configuration register read from device                   |
-        \*---------------------------------------------------------*/
-        case ASROCK_TYPE_POLYCHROME_V1:
-        case ASROCK_TYPE_POLYCHROME_V2:
-            {
-                /*---------------------------------------------------------*\
-                | Set up zones                                              |
-                \*---------------------------------------------------------*/
-                for(unsigned int zone_idx = 0; zone_idx < POLYCHROME_ZONE_COUNT; zone_idx++)
-                {
-                    if(controller->zone_led_count[zone_idx] > 0)
-                    {
-                        zone* new_zone = new zone();
-
-                        /*---------------------------------------------------------*\
-                        | Set zone name to channel name                             |
-                        \*---------------------------------------------------------*/
-                        if(controller->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
-                        {
-                            new_zone->name          = polychrome_v1_zone_names[zone_idx];
-                        }
-                        else
-                        {
-                            new_zone->name          = polychrome_v2_zone_names[zone_idx];
-                        }
-                        
-                        if(zone_idx == POLYCHROME_ZONE_ADDRESSABLE)
-                        {
-                            new_zone->leds_min      = 1;
-                            new_zone->leds_max      = 1;
-                            new_zone->leds_count    = 1;
-                        }
-                        else
-                        {
-                            new_zone->leds_min      = controller->zone_led_count[zone_idx];
-                            new_zone->leds_max      = controller->zone_led_count[zone_idx];
-                            new_zone->leds_count    = controller->zone_led_count[zone_idx];
-                        }
-
-                        if(new_zone->leds_count > 1)
-                        {
-                            new_zone->type          = ZONE_TYPE_LINEAR;
-                        }
-                        else
-                        {
-                            new_zone->type          = ZONE_TYPE_SINGLE;
-                        }
-
-                        new_zone->matrix_map        = NULL;
-
-                        /*---------------------------------------------------------*\
-                        | Push new zone to zones vector                             |
-                        \*---------------------------------------------------------*/
-                        zones.push_back(*new_zone);
-                    }
-                }
-
-                unsigned int led_count = 0;
-                /*---------------------------------------------------------*\
-                | Set up LEDs                                               |
-                \*---------------------------------------------------------*/
-                for(unsigned int zone_idx = 0; zone_idx < POLYCHROME_ZONE_COUNT; zone_idx++)
-                {
-                    if(controller->zone_led_count[zone_idx] > 0)
-                    {
-                        for(unsigned int led_idx = 0; led_idx < controller->zone_led_count[zone_idx]; led_idx++)
-                        {
-                            /*---------------------------------------------------------*\
-                            | Each zone only has one LED                                |
-                            \*---------------------------------------------------------*/
-                            led* new_led = new led();
-
-                            if(controller->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
-                                {
-                                    new_led->name           = polychrome_v1_zone_names[zone_idx];
-                                }
-                                else
-                                {
-                                    new_led->name           = polychrome_v2_zone_names[zone_idx];
-                                }
-
-                            new_led->name.append(" " + std::to_string(led_idx + 1));
-                            new_led->value = 0;
-
-                            if(controller->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
-                            {
-                                new_led->value              = zone_idx;
-                            }
-                            else if(zone_idx == POLYCHROME_ZONE_ADDRESSABLE)
-                            {
-                                new_led->value              = 0x19;
-                            }
-
-                            /*---------------------------------------------------------*\
-                            | Push new LED to LEDs vector                               |
-                            \*---------------------------------------------------------*/
-                            leds.push_back(*new_led);
-
-                            led_count++;
-
-                            if(zone_idx == POLYCHROME_ZONE_ADDRESSABLE)
-                            {
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-            break;
-    }
-
-    SetupColors();
-}
-
-void RGBController_Polychrome::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_Polychrome::DeviceUpdateLEDs()
-{
-    for (std::size_t led = 0; led < colors.size(); led++)
-    {
-        UpdateSingleLED(led);
-    }
-}
-
-void RGBController_Polychrome::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_Polychrome::UpdateSingleLED(int led)
-{
-    unsigned char red = RGBGetRValue(colors[led]);
-    unsigned char grn = RGBGetGValue(colors[led]);
-    unsigned char blu = RGBGetBValue(colors[led]);
-
-    /*---------------------------------------------------------*\
-    | If the LED value is non-zero, this LED overrides the LED  |
-    | index                                                     |
-    \*---------------------------------------------------------*/
-    if(leds[led].value != 0)
-    {
-        led = leds[led].value;
-    }
-
-    controller->SetColorsAndSpeed(led, red, grn, blu);
-}
-
-void RGBController_Polychrome::SetCustomMode()
-{
-    active_mode = 1;
-}
-
-void RGBController_Polychrome::DeviceUpdateMode()
-{
-    if(controller->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
-    {
-        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
-        {
-            controller->SetMode(led_idx, modes[active_mode].value, modes[active_mode].speed);
-        }
-    }
-    else
-    {
-        controller->SetMode(0, modes[active_mode].value, modes[active_mode].speed);
-    }
-
-    DeviceUpdateLEDs();
-}

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -15,8 +15,9 @@
 
 /**------------------------------------------------------------------*\
     @name ASrock Polychrome USB
+    @category Motherboard
     @type USB
-    @save :warning:
+    @save :robot:
     @direct :x:
     @effects :white_check_mark:
     @detectors DetectPolychromeUSBControllers
@@ -203,15 +204,15 @@ void RGBController_PolychromeUSB::SetupZones()
             zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
             zones[channel_idx].leds_min   = 0;
             zones[channel_idx].leds_max   = ASROCK_ADDRESSABLE_MAX_LEDS;
-            zones[channel_idx].leds_count = device_info.num_leds; 
+            zones[channel_idx].leds_count = device_info.num_leds;
         }
-        else if(device_info.device_type==PolychromeDeviceType::FIXED) 
+        else if(device_info.device_type==PolychromeDeviceType::FIXED)
         {
             zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
             zones[channel_idx].leds_min   = device_info.num_leds;
             zones[channel_idx].leds_max   = device_info.num_leds;
-            zones[channel_idx].leds_count = device_info.num_leds; 
-        }       
+            zones[channel_idx].leds_count = device_info.num_leds;
+        }
 
 
         for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
@@ -247,7 +248,7 @@ void RGBController_PolychromeUSB::SetupZones()
      for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
     {
         PolychromeZoneInfo zoneinfo;
-        zoneinfo = controller->GetZoneConfig(channel_idx); 
+        zoneinfo = controller->GetZoneConfig(channel_idx);
         zones_info.push_back(zoneinfo);
     }
 
@@ -320,7 +321,7 @@ unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)
     dev_mode    = controller->GetZoneConfig(zone).mode;
     active_mode = dev_mode;
 
-    return(active_mode);  
+    return(active_mode);
 }
 
 void RGBController_PolychromeUSB::SetCustomMode()
@@ -337,10 +338,10 @@ void RGBController_PolychromeUSB::DeviceUpdateMode()
             unsigned char set_mode      =(unsigned char) modes[active_mode].value;
             zones_info[zone_idx].mode   =(unsigned char) modes[active_mode].value;
             zones_info[zone_idx].speed  =(unsigned char) modes[active_mode].speed;
-            
+
             if(set_mode > modes.size())
             {
-                set_mode = active_mode;                    
+                set_mode = active_mode;
             }
 
             controller->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController.cpp

@@ -0,0 +1,122 @@
+/*-----------------------------------------*\
+|  ASRockPolychromeSMBusController.cpp      |
+|                                           |
+|  Driver for for ASRock ASR LED and        |
+|  Polychrome RGB lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/14/2019  |
+\*-----------------------------------------*/
+
+#include "ASRockASRRGBSMBusController.h"
+#include <cstring>
+#include "dependencies/dmiinfo.h"
+#include "LogManager.h"
+
+#define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
+
+using namespace std::chrono_literals;
+
+ASRockASRRGBSMBusController::ASRockASRRGBSMBusController(i2c_smbus_interface* bus, polychrome_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+
+    DMIInfo dmi;
+
+    device_name =   "ASRock " + dmi.getMainboard();
+
+}
+
+ASRockASRRGBSMBusController::~ASRockASRRGBSMBusController()
+{
+
+}
+
+std::string ASRockASRRGBSMBusController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+std::string ASRockASRRGBSMBusController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string ASRockASRRGBSMBusController::GetFirmwareVersion()
+{
+    uint8_t  major_version = fw_version >> 8;
+    uint8_t  minor_version = fw_version & 0xFF;
+
+    return(std::to_string(major_version) + "." + std::to_string(minor_version));
+}
+
+uint8_t ASRockASRRGBSMBusController::GetMode()
+{
+    return(active_mode);
+}
+
+void ASRockASRRGBSMBusController::SetColorsAndSpeed(uint8_t led, uint8_t red, uint8_t green, uint8_t blue)
+{
+    uint8_t color_speed_pkt[4] = { red, green, blue, active_speed };
+    uint8_t select_led_pkt[1]  = { led };
+    
+    /*-----------------------------------------------------*\
+    | Select LED                                            |
+    \*-----------------------------------------------------*/
+    if(active_mode != ASRLED_MODE_OFF)
+    {
+        bus->i2c_smbus_write_block_data(dev, ASROCK_ASR_REG_LED_SELECT, 1, select_led_pkt);
+        std::this_thread::sleep_for(1ms);
+    }
+
+    switch(active_mode)
+    {
+        /*-----------------------------------------------------*\
+        | These modes take 4 bytes in R/G/B/S order             |
+        \*-----------------------------------------------------*/
+        case ASRLED_MODE_BREATHING:
+        case ASRLED_MODE_STROBE:
+        case ASRLED_MODE_SPECTRUM_CYCLE:
+            bus->i2c_smbus_write_block_data(dev, active_mode, 4, color_speed_pkt);
+            break;
+
+        /*-----------------------------------------------------*\
+        | These modes take 3 bytes in R/G/B order               |
+        \*-----------------------------------------------------*/
+        default:
+        case ASRLED_MODE_STATIC:
+        case ASRLED_MODE_MUSIC:
+            bus->i2c_smbus_write_block_data(dev, active_mode, 3, color_speed_pkt);
+            break;
+
+        /*-----------------------------------------------------*\
+        | These modes take 1 byte - speed                       |
+        \*-----------------------------------------------------*/
+        case ASRLED_MODE_RANDOM:
+        case ASRLED_MODE_WAVE:
+            bus->i2c_smbus_write_block_data(dev, active_mode, 1, &active_speed);
+            break;
+
+        /*-----------------------------------------------------*\
+        | These modes take no bytes                             |
+        \*-----------------------------------------------------*/
+        case ASRLED_MODE_OFF:
+            break;
+    }
+    std::this_thread::sleep_for(1ms);
+}
+
+void ASRockASRRGBSMBusController::SetMode(uint8_t zone,uint8_t mode, uint8_t speed)
+{
+    active_zone                     = zone;
+    active_mode                     = mode;
+    active_speed                    = speed;
+
+    bus->i2c_smbus_write_block_data(dev, ASROCK_ASR_REG_MODE, 1, &active_mode);
+    std::this_thread::sleep_for(1ms);
+}

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController.h

@@ -0,0 +1,76 @@
+/*-----------------------------------------*\
+|  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>
+
+#pragma once
+
+typedef uint8_t	polychrome_dev_id;
+
+#define ASROCK_ASR_CONTROLLER_NAME  "ASRock ASR RGB SMBus Controller"
+
+enum
+{
+    /*------------------------------------------------------------------------------------------*\
+    | ASRock Common Registers                                                                    |
+    \*------------------------------------------------------------------------------------------*/
+    ASROCK_ASR_REG_FIRMWARE_VER             = 0x00,     /* Firmware version Major.Minor         */
+    ASROCK_ASR_REG_MODE                     = 0x30,     /* Mode selection register              */
+    ASROCK_ASR_REG_LED_SELECT               = 0x31,     /* LED selection register               */
+};
+
+/*----------------------------------------------------------------------------------------------*\
+| Definitions for ASR LED                                                                        |
+\*----------------------------------------------------------------------------------------------*/
+#define ASRLED_NUM_MODES                    8           /* Number of ASR LED modes              */
+
+enum
+{
+    ASRLED_MODE_OFF                         = 0x10,     /* OFF mode                             */
+    ASRLED_MODE_STATIC                      = 0x11,     /* Static color mode                    */
+    ASRLED_MODE_BREATHING                   = 0x12,     /* Breathing effect mode                */
+    ASRLED_MODE_STROBE                      = 0x13,     /* Strobe effect mode                   */
+    ASRLED_MODE_SPECTRUM_CYCLE              = 0x14,     /* Spectrum Cycle effect mode           */
+    ASRLED_MODE_RANDOM                      = 0x15,     /* Random effect mode                   */
+    ASRLED_MODE_MUSIC                       = 0x17,     /* Music effect mode                    */
+    ASRLED_MODE_WAVE                        = 0x18,     /* Wave effect mode                     */
+};
+
+enum
+{
+    ASRLED_SPEED_MIN                        = 0x05,     /* Slowest speed                        */
+    ASRLED_SPEED_DEFAULT                    = 0x03,     /* Default speed                        */
+    ASRLED_SPEED_MAX                        = 0x00,     /* Fastest speed                        */
+};
+
+class ASRockASRRGBSMBusController
+{
+public:
+    ASRockASRRGBSMBusController(i2c_smbus_interface* bus, polychrome_dev_id dev);
+    ~ASRockASRRGBSMBusController();
+
+    std::string             GetDeviceLocation();
+    std::string             GetDeviceName();
+    std::string             GetFirmwareVersion();
+    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:
+    std::string             device_name;
+    uint8_t                 active_zone;
+    uint8_t                 active_mode;
+    uint8_t                 active_speed;
+    i2c_smbus_interface*    bus;
+    polychrome_dev_id       dev;
+};

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.cpp

@@ -0,0 +1,180 @@
+/*-----------------------------------------*\
+|  ASRockPolychromeV1SMBusController.cpp    |
+|                                           |
+|  Driver for for ASRock ASR LED and        |
+|  Polychrome RGB lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/14/2019  |
+\*-----------------------------------------*/
+
+#include "ASRockPolychromeV1SMBusController.h"
+#include <cstring>
+#include "dependencies/dmiinfo.h"
+#include "LogManager.h"
+
+#define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
+
+using namespace std::chrono_literals;
+
+ASRockPolychromeV1SMBusController::ASRockPolychromeV1SMBusController(i2c_smbus_interface* bus, polychrome_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+
+    DMIInfo dmi;
+
+    device_name =   "ASRock " + dmi.getMainboard();
+
+    ReadLEDConfiguration();
+}
+
+ASRockPolychromeV1SMBusController::~ASRockPolychromeV1SMBusController()
+{
+
+}
+
+std::string ASRockPolychromeV1SMBusController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+std::string ASRockPolychromeV1SMBusController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string ASRockPolychromeV1SMBusController::GetFirmwareVersion()
+{
+    uint8_t  major_version = fw_version >> 8;
+    uint8_t  minor_version = fw_version & 0xFF;
+
+    return(std::to_string(major_version) + "." + std::to_string(minor_version));
+}
+
+void ASRockPolychromeV1SMBusController::ReadLEDConfiguration()
+{
+    /*---------------------------------------------------------------------------------*\
+    | The LED configuration register holds 6 bytes, so the first read should return 6   |
+    | If not, set all zone sizes to zero                                                |
+    \*---------------------------------------------------------------------------------*/
+    LOG_DEBUG("[%s] Reading LED config from controller", device_name.c_str());
+    uint8_t asrock_zone_count[I2C_SMBUS_BLOCK_MAX] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
+    if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_LED_CONFIG, asrock_zone_count) == 0x06)
+    {
+        zone_led_count[POLYCHROME_V1_ZONE_1]           = asrock_zone_count[0];
+        zone_led_count[POLYCHROME_V1_ZONE_2]           = asrock_zone_count[1];
+        zone_led_count[POLYCHROME_V1_ZONE_3]           = asrock_zone_count[2];
+        zone_led_count[POLYCHROME_V1_ZONE_4]           = asrock_zone_count[3];
+        zone_led_count[POLYCHROME_V1_ZONE_5]           = asrock_zone_count[4];
+        zone_led_count[POLYCHROME_V1_ZONE_ADDRESSABLE] = asrock_zone_count[5];
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V1_ZONE_1, zone_led_count[POLYCHROME_V1_ZONE_1]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V1_ZONE_2, zone_led_count[POLYCHROME_V1_ZONE_2]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V1_ZONE_3, zone_led_count[POLYCHROME_V1_ZONE_3]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V1_ZONE_4, zone_led_count[POLYCHROME_V1_ZONE_4]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V1_ZONE_5, zone_led_count[POLYCHROME_V1_ZONE_5]);
+        LOG_DEBUG("[%s] Addressable Zone LED count: %02d", device_name.c_str(), zone_led_count[POLYCHROME_V1_ZONE_ADDRESSABLE]);
+    }
+    else
+    {
+        LOG_WARNING("[%s] LED config read failed", device_name.c_str());
+        memset(zone_led_count, 0, sizeof(zone_led_count));
+    }
+}
+
+uint8_t ASRockPolychromeV1SMBusController::GetMode()
+{
+    return(active_mode);
+}
+
+void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t red, uint8_t green, uint8_t blue)
+{
+    uint8_t color_speed_pkt[4] = { red, green, blue, active_speed };
+    uint8_t select_led_pkt[1]  = { led };
+    
+
+    /*-----------------------------------------------------*\
+    | Select LED                                            |
+    \*-----------------------------------------------------*/
+    if(active_mode != POLYCHROME_V1_MODE_OFF)
+    {
+        bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_LED_SELECT, 1, select_led_pkt);
+        std::this_thread::sleep_for(1ms);
+    }
+
+    switch(active_mode)
+    {
+        /*-----------------------------------------------------*\
+        | These modes take 4 bytes in R/G/B/S order             |
+        \*-----------------------------------------------------*/
+        case POLYCHROME_V1_MODE_BREATHING:
+        case POLYCHROME_V1_MODE_STROBE:
+        case POLYCHROME_V1_MODE_SPECTRUM_CYCLE:
+        case POLYCHROME_V1_MODE_SPRING:
+        case POLYCHROME_V1_MODE_METEOR:
+        case POLYCHROME_V1_MODE_STACK:
+        case POLYCHROME_V1_MODE_CRAM:
+        case POLYCHROME_V1_MODE_SCAN:
+        case POLYCHROME_V1_MODE_NEON:
+        case POLYCHROME_V1_MODE_WATER:
+
+            bus->i2c_smbus_write_block_data(dev, active_mode, 4, color_speed_pkt);
+            break;
+
+        /*-----------------------------------------------------*\
+        | These modes take 3 bytes in R/G/B order               |
+        \*-----------------------------------------------------*/
+        default:
+        case POLYCHROME_V1_MODE_STATIC:
+        case POLYCHROME_V1_MODE_MUSIC:
+            bus->i2c_smbus_write_block_data(dev, active_mode, 3, color_speed_pkt);
+            break;
+
+        /*-----------------------------------------------------*\
+        | These modes take 1 byte - speed                       |
+        \*-----------------------------------------------------*/
+        case POLYCHROME_V1_MODE_RANDOM:
+        case POLYCHROME_V1_MODE_WAVE:
+        case POLYCHROME_V1_MODE_RAINBOW:
+            bus->i2c_smbus_write_block_data(dev, active_mode, 1, &active_speed);
+            break;
+
+        /*-----------------------------------------------------*\
+        | These modes take no bytes                             |
+        \*-----------------------------------------------------*/
+        case POLYCHROME_V1_MODE_OFF:
+            break;
+    }
+    std::this_thread::sleep_for(1ms);
+
+}
+
+void ASRockPolychromeV1SMBusController::SetMode(uint8_t zone,uint8_t mode, uint8_t speed)
+{
+    uint8_t led_count_pkt[1]  = { 0x00 };
+    active_zone                     = zone;
+    active_mode                     = mode;
+    active_speed                    = speed;
+
+    /*-----------------------------------------------------*\
+    | Make sure set all register is set to 0                |
+    \*-----------------------------------------------------*/
+    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_SET_ALL, 1, led_count_pkt);
+    std::this_thread::sleep_for(1ms);
+
+    /*-----------------------------------------------------*\
+    | Set the zone we are working on                        |
+    \*-----------------------------------------------------*/
+    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_LED_SELECT, 1, &active_zone);
+    std::this_thread::sleep_for(1ms);
+
+    /*-----------------------------------------------------*\
+    | Write the mode                                        |
+    \*-----------------------------------------------------*/
+    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_MODE, 1, &active_mode);
+    std::this_thread::sleep_for(1ms);    
+}

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.h

@@ -0,0 +1,147 @@
+/*-----------------------------------------*\
+|  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 <string>
+
+#pragma once
+
+typedef uint8_t	polychrome_dev_id;
+
+#define ASROCK_V1_CONTROLLER_NAME  "ASRock Polychrome v1 SMBus Controller"
+
+enum
+{
+    /*------------------------------------------------------------------------------------------*\
+    | ASRock Polychrome v1 Registers                                                             |
+    \*------------------------------------------------------------------------------------------*/
+    POLYCHROME_V1_REG_FIRMWARE_VER          = 0x00,     /* Firmware version Major.Minor         */
+    POLYCHROME_V1_REG_MODE                  = 0x30,     /* Mode selection register              */
+    POLYCHROME_V1_REG_LED_SELECT            = 0x31,     /* LED selection register               */
+    POLYCHROME_V1_REG_SET_ALL               = 0x32,     /* Set All register 0x1 = set all       */
+    POLYCHROME_V1_REG_LED_CONFIG            = 0x33,     /* LED configuration register           */
+    POLYCHROME_V1_REG_ARGB_GRB              = 0x35,     /* ARGB bistream reversing register     */
+};
+
+enum
+{
+    POLYCHROME_V1_ZONE_1                    = 0x00,     /* RGB LED 1 Header                     */
+    POLYCHROME_V1_ZONE_2                    = 0x01,     /* RGB LED 2 Header                     */
+    POLYCHROME_V1_ZONE_3                    = 0x02,     /* Audio/PCH Zone LEDs                  */
+    POLYCHROME_V1_ZONE_4                    = 0x03,     /* Audio/PCH Zone LEDs                  */
+    POLYCHROME_V1_ZONE_5                    = 0x04,     /* IO Cover Zone LEDs                   */
+    POLYCHROME_V1_ZONE_ADDRESSABLE          = 0x05,     /* Addressable LED header               */
+    POLYCHROME_V1_ZONE_COUNT                = 0x06,     /* Total number of zones                */
+    POLYCHROME_V1_ZONE_ADDRESSABLE_MAX      = 0x64,     /* Maxinum number of ARGB LEDs          */
+};
+
+/*----------------------------------------------------------------------------------------------*\
+| Definitions for Polychrome V1                                                                  |
+\*----------------------------------------------------------------------------------------------*/
+#define POLYCHROME_V1_NUM_MODES             16          /* Number of Polychrome V1 modes        */
+
+enum
+{
+    POLYCHROME_V1_MODE_OFF                  = 0x10,     /* OFF mode                             */
+    POLYCHROME_V1_MODE_STATIC               = 0x11,     /* Static color mode                    */
+    POLYCHROME_V1_MODE_BREATHING            = 0x12,     /* Breating effect mode                 */
+    POLYCHROME_V1_MODE_STROBE               = 0x13,     /* Strobe effect mode                   */
+    POLYCHROME_V1_MODE_SPECTRUM_CYCLE       = 0x14,     /* Spectrum Cycle effect mode           */
+    POLYCHROME_V1_MODE_RANDOM               = 0x15,     /* Random effect mode                   */
+    POLYCHROME_V1_MODE_MUSIC                = 0x17,     /* Music effect mode                    */
+    POLYCHROME_V1_MODE_WAVE                 = 0x18,     /* Wave effect mode                     */
+    /*------------------------------------------------------------------------------------------*\
+    | Modes only available on ARGB headers                                                       |
+    \*------------------------------------------------------------------------------------------*/
+    POLYCHROME_V1_MODE_SPRING               = 0x19,     /* Spring effect mode                   */
+    POLYCHROME_V1_MODE_METEOR               = 0x1A,     /* Meteor effect mode                   */
+    POLYCHROME_V1_MODE_STACK                = 0x1B,     /* Stack effect mode                    */
+    POLYCHROME_V1_MODE_CRAM                 = 0x1C,     /* Cram effect mode                     */
+    POLYCHROME_V1_MODE_SCAN                 = 0x1D,     /* Scan effect mode                     */
+    POLYCHROME_V1_MODE_NEON                 = 0x1E,     /* Neon effect mode                     */
+    POLYCHROME_V1_MODE_WATER                = 0x1F,     /* Water effect mode                    */
+    POLYCHROME_V1_MODE_RAINBOW              = 0x20,     /* Rainbow chase effect mode            */
+};
+
+enum
+{
+    /*------------------------------------------------------------------------------------------*\
+    | POLYCHROME_V1_MODE_BREATHING                                                               |
+    \*------------------------------------------------------------------------------------------*/
+    POLYCHROME_V1_SPEED_MIN_BREATHING       = 0x0A,     /* Slowest speed                        */
+    POLYCHROME_V1_SPEED_DEFAULT_BREATHING   = 0x02,     /* Default speed                        */
+    POLYCHROME_V1_SPEED_MAX_BREATHING       = 0x02,     /* Fastest speed                        */
+    /*------------------------------------------------------------------------------------------*\
+    | POLYCHROME_V1_MODE_STROBE                                                                  |
+    \*------------------------------------------------------------------------------------------*/
+    POLYCHROME_V1_SPEED_MIN_STROBE          = 0xA0,     /* Slowest speed                        */
+    POLYCHROME_V1_SPEED_DEFAULT_STROBE      = 0x14,     /* Default speed                        */
+    POLYCHROME_V1_SPEED_MAX_STROBE          = 0x05,     /* Fastest speed                        */
+    /*------------------------------------------------------------------------------------------*\
+    | POLYCHROME_V1_MODE_SPECTRUM_CYCLE                                                          |
+    \*------------------------------------------------------------------------------------------*/
+    POLYCHROME_V1_SPEED_MIN_CYCLE           = 0xA0,     /* Slowest speed                        */
+    POLYCHROME_V1_SPEED_DEFAULT_CYCLE       = 0x14,     /* Default speed                        */
+    POLYCHROME_V1_SPEED_MAX_CYCLE           = 0x0A,     /* Fastest speed                        */
+    /*------------------------------------------------------------------------------------------*\
+    | POLYCHROME_V1_MODE_RANDOM                                                                  |
+    \*------------------------------------------------------------------------------------------*/
+    POLYCHROME_V1_SPEED_MIN_RANDOM          = 0xA0,     /* Slowest speed                        */
+    POLYCHROME_V1_SPEED_DEFAULT_RANDOM      = 0x28,     /* Default speed                        */
+    POLYCHROME_V1_SPEED_MAX_RANDOM          = 0x05,     /* Fastest speed                        */
+    /*------------------------------------------------------------------------------------------*\
+    | POLYCHROME_V1_MODE_WAVE                                                                    |
+    \*------------------------------------------------------------------------------------------*/
+    POLYCHROME_V1_SPEED_MIN_WAVE            = 0x06,     /* Slowest speed                        */
+    POLYCHROME_V1_SPEED_DEFAULT_WAVE        = 0x02,     /* Default speed                        */
+    POLYCHROME_V1_SPEED_MAX_WAVE            = 0x01,     /* Fastest speed                        */
+    POLYCHROME_V1_SPEED_DEFAULT_SPRING      = 0x04,     /* Default speed                        */
+    POLYCHROME_V1_SPEED_DEFAULT_METEOR      = 0x0A,     /* Default speed                        */
+    POLYCHROME_V1_SPEED_DEFAULT_STACK       = 0x04,     /* Default speed                        */
+    POLYCHROME_V1_SPEED_DEFAULT_CRAM        = 0x04,     /* Default speed                        */
+    POLYCHROME_V1_SPEED_DEFAULT_SCAN        = 0x0A,     /* Default speed                        */
+    POLYCHROME_V1_SPEED_DEFAULT_NEON        = 0x20,     /* Default speed                        */
+    POLYCHROME_V1_SPEED_DEFAULT_WATER       = 0x0A,     /* Default speed                        */
+    /*------------------------------------------------------------------------------------------*\
+    | POLYCHROME_V1_MODE_RAINBOW                                                                 |
+    \*------------------------------------------------------------------------------------------*/
+    POLYCHROME_V1_SPEED_MIN_RAINBOW         = 0x12,     /* Slowest speed                        */
+    POLYCHROME_V1_SPEED_DEFAULT_RAINBOW     = 0x0A,     /* Default speed                        */
+    POLYCHROME_V1_SPEED_MAX_RAINBOW         = 0x01,     /* Fastest speed                        */
+    POLYCHROME_V1_SPEED_MIN_ARGB            = 0x20,     /* Slowest speed                        */
+    POLYCHROME_V1_SPEED_MAX_ARGB            = 0x02,     /* Fastest speed                        */
+};
+
+class ASRockPolychromeV1SMBusController
+{
+public:
+    ASRockPolychromeV1SMBusController(i2c_smbus_interface* bus, polychrome_dev_id dev);
+    ~ASRockPolychromeV1SMBusController();
+
+    std::string             GetDeviceLocation();
+    std::string             GetDeviceName();
+    std::string             GetFirmwareVersion();
+    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);
+
+    uint8_t                 zone_led_count[6];
+    uint16_t                fw_version;
+    
+private:
+    std::string             device_name;
+    uint8_t                 active_zone;
+    uint8_t                 active_mode;
+    uint8_t                 active_speed;
+    i2c_smbus_interface*    bus;
+    polychrome_dev_id       dev;
+
+    void                ReadLEDConfiguration();
+};

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController.cpp

@@ -0,0 +1,156 @@
+/*-----------------------------------------*\
+|  ASRockPolychromeV2SMBusController.cpp    |
+|                                           |
+|  Driver for for ASRock ASR LED and        |
+|  Polychrome RGB lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/14/2019  |
+\*-----------------------------------------*/
+
+#include "ASRockPolychromeV2SMBusController.h"
+#include <cstring>
+#include "dependencies/dmiinfo.h"
+#include "LogManager.h"
+
+#define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
+
+using namespace std::chrono_literals;
+
+ASRockPolychromeV2SMBusController::ASRockPolychromeV2SMBusController(i2c_smbus_interface* bus, polychrome_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+
+    DMIInfo dmi;
+
+    device_name =   "ASRock " + dmi.getMainboard();
+
+    ReadLEDConfiguration();
+}
+
+ASRockPolychromeV2SMBusController::~ASRockPolychromeV2SMBusController()
+{
+
+}
+
+std::string ASRockPolychromeV2SMBusController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+std::string ASRockPolychromeV2SMBusController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string ASRockPolychromeV2SMBusController::GetFirmwareVersion()
+{
+    uint8_t  major_version = fw_version >> 8;
+    uint8_t  minor_version = fw_version & 0xFF;
+
+    return(std::to_string(major_version) + "." + std::to_string(minor_version));
+}
+
+
+void ASRockPolychromeV2SMBusController::ReadLEDConfiguration()
+{
+    /*---------------------------------------------------------------------------------*\
+    | The LED configuration register holds 6 bytes, so the first read should return 6   |
+    | If not, set all zone sizes to zero                                                |
+    \*---------------------------------------------------------------------------------*/
+    LOG_DEBUG("[%s] Reading LED config from controller", device_name.c_str());
+    uint8_t asrock_zone_count[I2C_SMBUS_BLOCK_MAX] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
+    if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_V2_REG_LED_CONFIG, asrock_zone_count) == 0x06)
+    {
+        zone_led_count[POLYCHROME_V2_ZONE_1]           = asrock_zone_count[0];
+        zone_led_count[POLYCHROME_V2_ZONE_2]           = asrock_zone_count[1];
+        zone_led_count[POLYCHROME_V2_ZONE_3]           = asrock_zone_count[2];
+        zone_led_count[POLYCHROME_V2_ZONE_4]           = asrock_zone_count[3];
+        zone_led_count[POLYCHROME_V2_ZONE_5]           = asrock_zone_count[4];
+        zone_led_count[POLYCHROME_V2_ZONE_ADDRESSABLE] = asrock_zone_count[5];
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V2_ZONE_1, zone_led_count[POLYCHROME_V2_ZONE_1]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V2_ZONE_2, zone_led_count[POLYCHROME_V2_ZONE_2]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V2_ZONE_3, zone_led_count[POLYCHROME_V2_ZONE_3]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V2_ZONE_4, zone_led_count[POLYCHROME_V2_ZONE_4]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V2_ZONE_5, zone_led_count[POLYCHROME_V2_ZONE_5]);
+        LOG_DEBUG("[%s] Addressable Zone LED count: %02d", device_name.c_str(), zone_led_count[POLYCHROME_V2_ZONE_ADDRESSABLE]);
+    }
+    else
+    {
+        LOG_WARNING("[%s] LED config read failed", device_name.c_str());
+        memset(zone_led_count, 0, sizeof(zone_led_count));
+    }
+}
+
+uint8_t ASRockPolychromeV2SMBusController::GetMode()
+{
+    return(active_mode);
+}
+
+void ASRockPolychromeV2SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t red, uint8_t green, uint8_t blue)
+{
+    uint8_t color_speed_pkt[4] = { red, green, blue, active_speed };
+    uint8_t select_led_pkt[1]  = { led };
+
+    /*-----------------------------------------------------*\
+    | Select LED                                            |
+    \*-----------------------------------------------------*/
+    switch(active_mode)
+    {
+        case POLYCHROME_V2_MODE_OFF:
+        case POLYCHROME_V2_MODE_RAINBOW:
+        case POLYCHROME_V2_MODE_SPECTRUM_CYCLE:
+            break;
+
+        default:
+            bus->i2c_smbus_write_block_data(dev, POLYCHROME_V2_REG_LED_SELECT, 1, select_led_pkt);
+            std::this_thread::sleep_for(1ms);
+
+            /*-----------------------------------------------------*\
+            | Polychrome firmware always writes color to fixed reg  |
+            \*-----------------------------------------------------*/
+            bus->i2c_smbus_write_block_data(dev, POLYCHROME_V2_REG_COLOR, 3, color_speed_pkt);
+            std::this_thread::sleep_for(1ms);
+            break;
+    }
+}
+
+void ASRockPolychromeV2SMBusController::SetMode(uint8_t zone,uint8_t mode, uint8_t speed)
+{
+    uint8_t       led_count_pkt[1]  = { 0x00 };
+    active_zone                     = zone;
+    active_mode                     = mode;
+    active_speed                    = speed;
+
+    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V2_REG_MODE, 1, &active_mode);
+    std::this_thread::sleep_for(1ms);
+
+    /*-----------------------------------------------------*\
+    | Select a single LED                                   |
+    \*-----------------------------------------------------*/
+    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V2_REG_LED_COUNT, 0, led_count_pkt);
+    std::this_thread::sleep_for(1ms);
+
+    switch(active_mode)
+    {
+        /*-----------------------------------------------------*\
+        | These modes don't take a speed                        |
+        \*-----------------------------------------------------*/
+        case POLYCHROME_V2_MODE_OFF:
+        case POLYCHROME_V2_MODE_STATIC:
+            break;
+
+        /*-----------------------------------------------------*\
+        | All other modes, write speed to active mode register  |
+        \*-----------------------------------------------------*/
+        default:
+            bus->i2c_smbus_write_block_data(dev, active_mode, 1, &speed);
+            std::this_thread::sleep_for(1ms);
+            break;
+    }
+}

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController.h

@@ -0,0 +1,145 @@
+/*-----------------------------------------*\
+|  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>
+
+#pragma once
+
+typedef uint8_t polychrome_dev_id;
+
+#define ASROCK_V2_CONTROLLER_NAME  "ASRock Polychrome v2 SMBus Controller"
+
+enum
+{
+    /*------------------------------------------------------------------------------------------*\
+    | ASRock Polychrome v2 Registers                                                             |
+    \*------------------------------------------------------------------------------------------*/
+    POLYCHROME_V2_REG_FIRMWARE_VER          = 0x00,     /* Firmware version Major.Minor         */
+    POLYCHROME_V2_REG_MODE                  = 0x30,     /* Mode selection register              */
+    POLYCHROME_V2_REG_LED_SELECT            = 0x31,     /* LED selection register               */
+    POLYCHROME_V2_REG_LED_COUNT             = 0x32,     /* Additional LED count register        */
+    POLYCHROME_V2_REG_LED_CONFIG            = 0x33,     /* LED configuration register           */
+    POLYCHROME_V2_REG_COLOR                 = 0x34,     /* Color register: Red, Green, Blue     */
+    POLYCHROME_V2_REG_ARGB_GRB              = 0x35,     /* ARGB bistream reversing register     */
+};
+
+enum
+{
+    POLYCHROME_V2_ZONE_1                    = 0x00,     /* RGB LED 1 Header                     */
+    POLYCHROME_V2_ZONE_2                    = 0x01,     /* RGB LED 2 Header                     */
+    POLYCHROME_V2_ZONE_3                    = 0x02,     /* Audio/PCH Zone LEDs                  */
+    POLYCHROME_V2_ZONE_4                    = 0x03,     /* Audio/PCH Zone LEDs                  */
+    POLYCHROME_V2_ZONE_5                    = 0x04,     /* IO Cover Zone LEDs                   */
+    POLYCHROME_V2_ZONE_ADDRESSABLE          = 0x05,     /* Addressable LED header               */
+    POLYCHROME_V2_ZONE_COUNT                = 0x06,     /* Total number of zones                */
+    POLYCHROME_V2_ZONE_ADDRESSABLE_MAX      = 0x64,     /* Maxinum number of ARGB LEDs          */
+};
+
+/*----------------------------------------------------------------------------------------------*\
+| Definitions for Polychrome V2                                                                  |
+\*----------------------------------------------------------------------------------------------*/
+#define POLYCHROME_V2_NUM_MODES             14          /* Number of Polychrome V2 modes        */
+
+enum
+{
+    POLYCHROME_V2_MODE_OFF                  = 0x10,     /* OFF mode                             */
+    POLYCHROME_V2_MODE_STATIC               = 0x11,     /* Static color mode                    */
+    POLYCHROME_V2_MODE_BREATHING            = 0x12,     /* Breating effect mode                 */
+    POLYCHROME_V2_MODE_STROBE               = 0x13,     /* Strobe effect mode                   */
+    POLYCHROME_V2_MODE_SPECTRUM_CYCLE       = 0x14,     /* Spectrum Cycle effect mode           */
+    POLYCHROME_V2_MODE_RANDOM               = 0x15,     /* Random effect mode                   */
+    POLYCHROME_V2_MODE_WAVE                 = 0x17,     /* Wave effect mode                     */
+    POLYCHROME_V2_MODE_SPRING               = 0x18,     /* Spring effect mode                   */
+    POLYCHROME_V2_MODE_STACK                = 0x19,     /* Stack effect mode                    */
+    POLYCHROME_V2_MODE_CRAM                 = 0x1A,     /* Cram effect mode                     */
+    POLYCHROME_V2_MODE_SCAN                 = 0x1B,     /* Scan effect mode                     */
+    POLYCHROME_V2_MODE_NEON                 = 0x1C,     /* Neon effect mode                     */
+    POLYCHROME_V2_MODE_WATER                = 0x1D,     /* Water effect mode                    */
+    POLYCHROME_V2_MODE_RAINBOW              = 0x1E,     /* Rainbow effect mode                  */
+};
+
+enum
+{
+    POLYCHROME_V2_BREATHING_SPEED_MIN               = 0x0A,     /* Slowest speed                        */
+    POLYCHROME_V2_BREATHING_SPEED_DEFAULT           = 0x06,     /* Default speed                        */
+    POLYCHROME_V2_BREATHING_SPEED_MAX               = 0x02,     /* Fastest speed                        */
+
+    POLYCHROME_V2_STROBE_SPEED_MIN                  = 0xA0,     /* Slowest speed                        */
+    POLYCHROME_V2_STROBE_SPEED_DEFAULT              = 0x4D,     /* Default speed                        */
+    POLYCHROME_V2_STROBE_SPEED_MAX                  = 0x05,     /* Fastest speed                        */
+
+    POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MIN          = 0xA0,     /* Slowest speed                        */
+    POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_DEFAULT      = 0x50,     /* Default speed                        */
+    POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MAX          = 0x0A,     /* Fastest speed                        */
+
+    POLYCHROME_V2_RANDOM_SPEED_MIN                  = 0xA0,     /* Slowest speed                        */
+    POLYCHROME_V2_RANDOM_SPEED_DEFAULT              = 0x4D,     /* Default speed                        */
+    POLYCHROME_V2_RANDOM_SPEED_MAX                  = 0x05,     /* Fastest speed                        */
+
+    POLYCHROME_V2_WAVE_SPEED_MIN                    = 0x06,     /* Slowest speed                        */
+    POLYCHROME_V2_WAVE_SPEED_DEFAULT                = 0x03,     /* Default speed                        */
+    POLYCHROME_V2_WAVE_SPEED_MAX                    = 0x01,     /* Fastest speed                        */
+
+    POLYCHROME_V2_SPRING_SPEED_MIN                  = 0x20,     /* Slowest speed                        */
+    POLYCHROME_V2_SPRING_SPEED_DEFAULT              = 0x11,     /* Default speed                        */
+    POLYCHROME_V2_SPRING_SPEED_MAX                  = 0x02,     /* Fastest speed                        */
+
+    POLYCHROME_V2_STACK_SPEED_MIN                   = 0x20,     /* Slowest speed                        */
+    POLYCHROME_V2_STACK_SPEED_DEFAULT               = 0x11,     /* Default speed                        */
+    POLYCHROME_V2_STACK_SPEED_MAX                   = 0x02,     /* Fastest speed                        */
+
+    POLYCHROME_V2_CRAM_SPEED_MIN                    = 0x20,     /* Slowest speed                        */
+    POLYCHROME_V2_CRAM_SPEED_DEFAULT                = 0x11,     /* Default speed                        */
+    POLYCHROME_V2_CRAM_SPEED_MAX                    = 0x02,     /* Fastest speed                        */
+
+    POLYCHROME_V2_SCAN_SPEED_MIN                    = 0x20,     /* Slowest speed                        */
+    POLYCHROME_V2_SCAN_SPEED_DEFAULT                = 0x11,     /* Default speed                        */
+    POLYCHROME_V2_SCAN_SPEED_MAX                    = 0x02,     /* Fastest speed                        */
+
+    POLYCHROME_V2_NEON_SPEED_MIN                    = 0x20,     /* Slowest speed                        */
+    POLYCHROME_V2_NEON_SPEED_DEFAULT                = 0x11,     /* Default speed                        */
+    POLYCHROME_V2_NEON_SPEED_MAX                    = 0x02,     /* Fastest speed                        */
+
+    POLYCHROME_V2_WATER_SPEED_MIN                   = 0x20,     /* Slowest speed                        */
+    POLYCHROME_V2_WATER_SPEED_DEFAULT               = 0x11,     /* Default speed                        */
+    POLYCHROME_V2_WATER_SPEED_MAX                   = 0x02,     /* Fastest speed                        */
+
+    POLYCHROME_V2_RAINBOW_SPEED_MIN                 = 0x12,     /* Slowest speed                        */
+    POLYCHROME_V2_RAINBOW_SPEED_DEFAULT             = 0x08,     /* Default speed                        */
+    POLYCHROME_V2_RAINBOW_SPEED_MAX                 = 0x02,     /* Fastest speed                        */
+};
+
+class ASRockPolychromeV2SMBusController
+{
+public:
+    ASRockPolychromeV2SMBusController(i2c_smbus_interface* bus, polychrome_dev_id dev);
+    ~ASRockPolychromeV2SMBusController();
+
+    std::string             GetDeviceLocation();
+    std::string             GetDeviceName();
+    std::string             GetFirmwareVersion();
+    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);
+
+    uint8_t                 zone_led_count[6];
+    uint16_t                fw_version;
+    
+private:
+    std::string             device_name;
+    uint8_t                 active_zone;
+    uint8_t                 active_mode;
+    uint8_t                 active_speed;
+    i2c_smbus_interface*    bus;
+    polychrome_dev_id       dev;
+
+    void            ReadLEDConfiguration();
+};

Controllers/ASRockSMBusController/ASRockSMBusControllerDetect.cpp

@@ -0,0 +1,168 @@
+#include "Detector.h"
+#include "ASRockASRRGBSMBusController.h"
+#include "ASRockPolychromeV1SMBusController.h"
+#include "ASRockPolychromeV2SMBusController.h"
+#include "LogManager.h"
+#include "RGBController.h"
+#include "RGBController_ASRockASRRGBSMBus.h"
+#include "RGBController_ASRockPolychromeV1SMBus.h"
+#include "RGBController_ASRockPolychromeV2SMBus.h"
+#include "i2c_smbus.h"
+#include "pci_ids.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+/*******************************************************************************************\
+*                                                                                           *
+*   TestForPolychromeSMBusController                                                        *
+*                                                                                           *
+*       Tests the given address to see if an ASRock RGB controller exists there.            *
+*       First does a quick write to test for a response                                     *
+*                                                                                           *
+\*******************************************************************************************/
+
+#define ASROCK_DETECTOR_NAME        "ASRock SMBus Detectector"
+#define VENDOR_NAME                 "ASRock"
+#define SMBUS_ADDRESS               0x6A
+
+enum
+{
+    ASROCK_TYPE_UNKNOWN                     = 0x00,     /* Unknown Type or Not ASRock Device    */
+    ASROCK_TYPE_ASRLED                      = 0x01,     /* ASRock Firmware 1.x - ASR LED        */
+    ASROCK_TYPE_POLYCHROME_V1               = 0x02,     /* ASRock Firmware 2.x - Polychrome V1  */
+    ASROCK_TYPE_POLYCHROME_V2               = 0x03,     /* ASRock Firmware 3.x - Polychrome V2  */
+    ASROCK_REG_FIRMWARE_VER                 = 0x00,     /* Firmware version Major.Minor         */
+};
+
+union u16_to_u8
+{
+    uint16_t   u16;
+    struct
+    {
+        uint8_t lsb;
+        uint8_t msb;
+    };
+};
+
+bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, uint8_t address)
+{
+    bool pass = false;
+
+    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
+
+    if (res >= 0)
+    {
+        pass = true;
+    }
+
+    return(pass);
+
+}   /* TestForPolychromeController() */
+
+uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
+{
+    // The firmware register holds two bytes, so the first read should return 2
+    // If not, report invalid firmware revision
+    LOG_DEBUG("[%s] Reading back device firmware version", ASROCK_DETECTOR_NAME);
+    u16_to_u8 asrock_version_u16;
+
+    // Version response array needs to be 32 bytes to prevent non ASRock board from stack smashing
+    uint8_t asrock_version[I2C_SMBUS_BLOCK_MAX] = { 0x00, 0x00 };
+
+    if (bus->i2c_smbus_read_block_data(address, ASROCK_REG_FIRMWARE_VER, asrock_version) == 0x02)
+    {
+        asrock_version_u16.msb = asrock_version[0];
+        asrock_version_u16.lsb = asrock_version[1];
+
+        LOG_DEBUG("[%s] Device firmware version: v%02d.%02d", ASROCK_DETECTOR_NAME, asrock_version_u16.msb, asrock_version_u16.lsb);
+        return(asrock_version_u16.u16);
+    }
+    else
+    {
+        LOG_WARNING("[%s] Firmware readback failed; Returning Unknown Version", ASROCK_DETECTOR_NAME);
+        return(ASROCK_TYPE_UNKNOWN);
+    }
+}
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectPolychromeControllers                                                            *
+*                                                                                          *
+*       Detect ASRock Polychrome RGB SMBus controllers on the enumerated I2C busses at     *
+*       address 0x6A.                                                                      *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where Polychrome device is connected      *
+*           dev - I2C address of Polychrome device                                         *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
+{
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        {
+            if(busses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
+            {
+                LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
+                // Check for Polychrome controller at 0x6A
+                if(TestForPolychromeSMBusController(busses[bus], SMBUS_ADDRESS))
+                {
+                    LOG_DEBUG("[%s] Detected a device at address 0x%02X, testing for a known controller",  ASROCK_DETECTOR_NAME, SMBUS_ADDRESS);
+
+                    u16_to_u8 version;
+                    version.u16 = GetFirmwareVersion(busses[bus], SMBUS_ADDRESS);
+
+                    switch (version.msb)
+                    {
+                        case ASROCK_TYPE_ASRLED:
+                            {
+                                LOG_DEBUG("[%s] Found a ASR RGB LED Controller", ASROCK_DETECTOR_NAME);
+                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(busses[bus], SMBUS_ADDRESS);
+                                controller-> fw_version = version.u16;
+                                RGBController_ASRockASRRGBSMBus* rgb_controller = new RGBController_ASRockASRRGBSMBus(controller);
+                                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                            }
+                            break;
+
+                            case ASROCK_TYPE_POLYCHROME_V1:
+                            {
+                                LOG_DEBUG("[%s] Found a Polychrome v1 Controller", ASROCK_DETECTOR_NAME);
+                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(busses[bus], SMBUS_ADDRESS);
+                                controller-> fw_version = version.u16;
+                                RGBController_ASRockPolychromeV1SMBus* rgb_controller = new RGBController_ASRockPolychromeV1SMBus(controller);
+                                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                            }
+                            break;
+
+                            case ASROCK_TYPE_POLYCHROME_V2:
+                            {
+                                LOG_DEBUG("[%s] Found a Polychrome v2 Controller", ASROCK_DETECTOR_NAME);
+                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(busses[bus], SMBUS_ADDRESS);
+                                controller-> fw_version = version.u16;
+                                RGBController_ASRockPolychromeV2SMBus* rgb_controller = new RGBController_ASRockPolychromeV2SMBus(controller);
+                                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                            }
+                            break;
+
+                            default:
+                                LOG_DEBUG("[%s] Not a Polychrome device or unknown type", ASROCK_DETECTOR_NAME);
+                                break;
+                    }
+                }
+                else
+                {
+                    LOG_DEBUG("[%s] Bus %02d has no response at 0x%02X", ASROCK_DETECTOR_NAME, bus, SMBUS_ADDRESS);
+                }
+            }
+            else
+            {
+                LOG_DEBUG(SMBUS_CHECK_DEVICE_FAILURE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME);
+            }
+        }
+    }
+
+}   /* DetectSMBusPolychromeControllers() */
+
+REGISTER_I2C_DETECTOR("ASRock Motherboard SMBus Controllers", DetectASRockSMBusControllers);

Controllers/ASRockSMBusController/RGBController_ASRockASRRGBSMBus.cpp

@@ -0,0 +1,210 @@
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeSMBus.cpp  |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#include "RGBController_ASRockASRRGBSMBus.h"
+
+#define ASROCK_MAX_ZONES    4
+#define ASROCK_MAX_LEDS     22
+
+/**------------------------------------------------------------------*\
+    @name ASRock ASR RGB SMBus
+    @category Motherboard
+    @type SMBus
+    @save :robot:
+    @direct :x:
+    @effects :white_check_mark:
+    @detectors DetectASRockSMBusControllers
+    @comment ASRock ASR RGB LED controllers will save with each update.
+        Per ARGB LED support is not possible with these devices.
+\*-------------------------------------------------------------------*/
+
+RGBController_ASRockASRRGBSMBus::RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMBusController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = controller->GetDeviceName();
+    vendor      = "ASRock";
+    version     = controller->GetFirmwareVersion();
+    type        = DEVICE_TYPE_MOTHERBOARD;
+    description = "ASRock ASR RGB LED Device";
+    location    = controller->GetDeviceLocation();
+
+    mode Off;
+    Off.name                    = "Off";
+    Off.value                   = ASRLED_MODE_OFF;
+    Off.flags                   = MODE_FLAG_AUTOMATIC_SAVE;
+    Off.color_mode              = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = ASRLED_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Static.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = ASRLED_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Breathing.speed_min         = ASRLED_SPEED_MIN;
+    Breathing.speed_max         = ASRLED_SPEED_MAX;
+    Breathing.speed             = ASRLED_SPEED_DEFAULT;
+    Breathing.color_mode        = MODE_COLORS_PER_LED;
+    modes.push_back(Breathing);
+
+    mode Strobe;
+    Strobe.name                 = "Strobe";
+    Strobe.value                = ASRLED_MODE_STROBE;
+    Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Strobe.speed_min            = ASRLED_SPEED_MIN;
+    Strobe.speed_max            = ASRLED_SPEED_MAX;
+    Strobe.speed                = ASRLED_SPEED_DEFAULT;
+    Strobe.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Strobe);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name          = "Spectrum Cycle";
+    SpectrumCycle.value         = ASRLED_MODE_SPECTRUM_CYCLE;
+    SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    SpectrumCycle.speed_min     = ASRLED_SPEED_MIN;
+    SpectrumCycle.speed_max     = ASRLED_SPEED_MAX;
+    SpectrumCycle.speed         = ASRLED_SPEED_DEFAULT;
+    SpectrumCycle.color_mode    = MODE_COLORS_NONE;
+    modes.push_back(SpectrumCycle);
+
+    mode Random;
+    Random.name                 = "Random";
+    Random.value                = ASRLED_MODE_RANDOM;
+    Random.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Random.speed_min            = ASRLED_SPEED_MIN;
+    Random.speed_max            = ASRLED_SPEED_MAX;
+    Random.speed                = ASRLED_SPEED_DEFAULT;
+    Random.color_mode           = MODE_COLORS_NONE;
+    modes.push_back(Random);
+
+    mode Music;
+    Music.name                  = "Music";
+    Music.value                 = ASRLED_MODE_MUSIC;
+    Music.flags                 = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Music.color_mode            = MODE_COLORS_PER_LED;
+    modes.push_back(Music);
+
+    mode Wave;
+    Wave.name                   = "Wave";
+    Wave.value                  = ASRLED_MODE_WAVE;
+    Wave.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Wave.speed_min              = ASRLED_SPEED_MIN;
+    Wave.speed_max              = ASRLED_SPEED_MAX;
+    Wave.speed                  = ASRLED_SPEED_DEFAULT;
+    Wave.color_mode             = MODE_COLORS_NONE;
+    modes.push_back(Wave);
+
+    SetupZones();
+}
+
+RGBController_ASRockASRRGBSMBus::~RGBController_ASRockASRRGBSMBus()
+{
+    delete controller;
+}
+
+void RGBController_ASRockASRRGBSMBus::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | ASR LED motherboards only have a single zone/LED          |
+    \*---------------------------------------------------------*/
+
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    zone* new_zone = new zone();
+
+    /*---------------------------------------------------------*\
+    | Set single zone name to "Motherboard"                     |
+    \*---------------------------------------------------------*/
+    new_zone->name          = "Motherboard";
+    new_zone->type          = ZONE_TYPE_SINGLE;
+    new_zone->leds_min      = 1;
+    new_zone->leds_max      = 1;
+    new_zone->leds_count    = 1;
+    new_zone->matrix_map    = NULL;
+
+    /*---------------------------------------------------------*\
+    | Push new zone to zones vector                             |
+    \*---------------------------------------------------------*/
+    zones.push_back(*new_zone);
+
+    /*---------------------------------------------------------*\
+    | Set up LEDs                                               |
+    \*---------------------------------------------------------*/
+    led* new_led = new led();
+
+    /*---------------------------------------------------------*\
+    | Set single LED name to "Motherboard"                      |
+    \*---------------------------------------------------------*/
+    new_led->name           = "Motherboard";
+
+    /*---------------------------------------------------------*\
+    | Push new LED to LEDs vector                               |
+    \*---------------------------------------------------------*/
+    leds.push_back(*new_led);
+
+    SetupColors();
+}
+
+void RGBController_ASRockASRRGBSMBus::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_ASRockASRRGBSMBus::DeviceUpdateLEDs()
+{
+    for (std::size_t led = 0; led < colors.size(); led++)
+    {
+        UpdateSingleLED(led);
+    }
+}
+
+void RGBController_ASRockASRRGBSMBus::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_ASRockASRRGBSMBus::UpdateSingleLED(int led)
+{
+    unsigned char red = RGBGetRValue(colors[led]);
+    unsigned char grn = RGBGetGValue(colors[led]);
+    unsigned char blu = RGBGetBValue(colors[led]);
+
+    /*---------------------------------------------------------*\
+    | If the LED value is non-zero, this LED overrides the LED  |
+    | index                                                     |
+    \*---------------------------------------------------------*/
+    if(leds[led].value != 0)
+    {
+        led = leds[led].value;
+    }
+
+    controller->SetColorsAndSpeed(led, red, grn, blu);
+}
+
+void RGBController_ASRockASRRGBSMBus::SetCustomMode()
+{
+    active_mode = 1;
+}
+
+void RGBController_ASRockASRRGBSMBus::DeviceUpdateMode()
+{
+
+    controller->SetMode(0, modes[active_mode].value, modes[active_mode].speed);
+
+    DeviceUpdateLEDs();
+}

Controllers/ASRockSMBusController/RGBController_ASRockASRRGBSMBus.h

@@ -10,13 +10,13 @@
 #pragma once
 
 #include "RGBController.h"
-#include "ASRockPolychromeSMBusController.h"
+#include "ASRockASRRGBSMBusController.h"
 
-class RGBController_Polychrome : public RGBController
+class RGBController_ASRockASRRGBSMBus : public RGBController
 {
 public:
-    RGBController_Polychrome(PolychromeController* controller_ptr);
-    ~RGBController_Polychrome();
+    RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMBusController* controller_ptr);
+    ~RGBController_ASRockASRRGBSMBus();
 
     void        SetupZones();
 
@@ -30,5 +30,5 @@ public:
     void        DeviceUpdateMode();
 
 private:
-    PolychromeController* controller;
+    ASRockASRRGBSMBusController* controller;
 };

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.cpp

@@ -0,0 +1,327 @@
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeSMBus.cpp  |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#include "RGBController_ASRockPolychromeV1SMBus.h"
+
+static const char* polychrome_v1_zone_names[] =
+{
+    "RGB LED 1 Header",
+    "RGB LED 2 Header",
+    "PCH",
+    "IO Cover",
+    "Audio",
+    "Addressable Header"
+};
+
+/**------------------------------------------------------------------*\
+    @name ASRock Polychrome v1 SMBus
+    @category Motherboard
+    @type SMBus
+    @save :robot:
+    @direct :x:
+    @effects :white_check_mark:
+    @detectors DetectASRockSMBusControllers
+    @comment ASRock Polychrome v1 controllers will save with each update.
+        Per ARGB LED support is not possible with these devices.
+\*-------------------------------------------------------------------*/
+
+RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASRockPolychromeV1SMBusController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = controller->GetDeviceName();
+    vendor      = "ASRock";
+    version     = controller->GetFirmwareVersion();
+    type        = DEVICE_TYPE_MOTHERBOARD;
+    description = "ASRock Polychrome v1 Device";
+    location    = controller->GetDeviceLocation();
+
+
+    mode Off;
+    Off.name                    = "Off";
+    Off.value                   = POLYCHROME_V1_MODE_OFF;
+    Off.flags                   = 0;
+    Off.color_mode              = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = POLYCHROME_V1_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = POLYCHROME_V1_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.speed_min         = POLYCHROME_V1_SPEED_MIN_BREATHING;
+    Breathing.speed_max         = POLYCHROME_V1_SPEED_MAX_BREATHING;
+    Breathing.speed             = POLYCHROME_V1_SPEED_DEFAULT_BREATHING;
+    Breathing.color_mode        = MODE_COLORS_PER_LED;
+    modes.push_back(Breathing);
+
+    mode Strobe;
+    Strobe.name                 = "Strobe";
+    Strobe.value                = POLYCHROME_V1_MODE_STROBE;
+    Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    Strobe.speed_min            = POLYCHROME_V1_SPEED_MIN_STROBE;
+    Strobe.speed_max            = POLYCHROME_V1_SPEED_MAX_STROBE;
+    Strobe.speed                = POLYCHROME_V1_SPEED_DEFAULT_STROBE;
+    Strobe.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Strobe);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name          = "Spectrum Cycle";
+    SpectrumCycle.value         = POLYCHROME_V1_MODE_SPECTRUM_CYCLE;
+    SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED;
+    SpectrumCycle.speed_min     = POLYCHROME_V1_SPEED_MIN_CYCLE;
+    SpectrumCycle.speed_max     = POLYCHROME_V1_SPEED_MAX_CYCLE;
+    SpectrumCycle.speed         = POLYCHROME_V1_SPEED_DEFAULT_CYCLE;
+    SpectrumCycle.color_mode    = MODE_COLORS_NONE;
+    modes.push_back(SpectrumCycle);
+
+    mode Random;
+    Random.name                 = "Random";
+    Random.value                = POLYCHROME_V1_MODE_RANDOM;
+    Random.flags                = MODE_FLAG_HAS_SPEED;
+    Random.speed_min            = POLYCHROME_V1_SPEED_MIN_RANDOM;
+    Random.speed_max            = POLYCHROME_V1_SPEED_MAX_RANDOM;
+    Random.speed                = POLYCHROME_V1_SPEED_DEFAULT_RANDOM;
+    Random.color_mode           = MODE_COLORS_NONE;
+    modes.push_back(Random);
+
+    mode Music;
+    Music.name                 = "Music";
+    Music.value                = POLYCHROME_V1_MODE_MUSIC;
+    Music.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Music.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Music);
+
+    mode Wave;
+    Wave.name                   = "Wave";
+    Wave.value                  = POLYCHROME_V1_MODE_WAVE;
+    Wave.flags                  = MODE_FLAG_HAS_SPEED;
+    Wave.speed_min              = POLYCHROME_V1_SPEED_MIN_WAVE;
+    Wave.speed_max              = POLYCHROME_V1_SPEED_MAX_WAVE;
+    Wave.speed                  = POLYCHROME_V1_SPEED_DEFAULT_WAVE;
+    Wave.color_mode             = MODE_COLORS_NONE;
+    modes.push_back(Wave);
+
+    /*---------------------------------------------------------------------*\
+    | Comment out until per zone modes are working. These are only for ARGB |
+    \*---------------------------------------------------------------------*/
+    /*
+    mode Spring;
+    Spring.name                 = "Spring";
+    Spring.value                = POLYCHROME_V1_MODE_SPRING;
+    Spring.flags                = MODE_FLAG_HAS_SPEED;
+    Spring.speed_min            = POLYCHROME_V1_SPEED_MIN_ARGB;
+    Spring.speed_max            = POLYCHROME_V1_SPEED_MAX_ARGB;
+    Spring.speed                = POLYCHROME_V1_SPEED_DEFAULT_SPRING;
+    Spring.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Spring);
+
+    mode Stack;
+    Stack.name                  = "Stack";
+    Stack.value                 = POLYCHROME_V1_MODE_STACK;
+    Stack.flags                 = MODE_FLAG_HAS_SPEED;
+    Stack.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
+    Stack.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
+    Stack.speed                 = POLYCHROME_V1_SPEED_DEFAULT_STACK;
+    Stack.color_mode            = MODE_COLORS_PER_LED;
+    modes.push_back(Stack);
+
+    mode Cram;
+    Cram.name                   = "Cram";
+    Cram.value                  = POLYCHROME_V1_MODE_CRAM;
+    Cram.flags                  = MODE_FLAG_HAS_SPEED;
+    Cram.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
+    Cram.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
+    Cram.speed                  = POLYCHROME_V1_SPEED_DEFAULT_CRAM;
+    Cram.color_mode             = MODE_COLORS_PER_LED;
+    modes.push_back(Cram);
+
+    mode Scan;
+    Scan.name                   = "Scan";
+    Scan.value                  = POLYCHROME_V1_MODE_SCAN;
+    Scan.flags                  = MODE_FLAG_HAS_SPEED;
+    Scan.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
+    Scan.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
+    Scan.speed                  = POLYCHROME_V1_SPEED_DEFAULT_SCAN;
+    Scan.color_mode             = MODE_COLORS_PER_LED;
+    modes.push_back(Scan);
+
+    mode Neon;
+    Neon.name                   = "Neon";
+    Neon.value                  = POLYCHROME_V1_MODE_NEON;
+    Neon.flags                  = MODE_FLAG_HAS_SPEED;
+    Neon.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
+    Neon.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
+    Neon.speed                  = POLYCHROME_V1_SPEED_DEFAULT_NEON;
+    Neon.color_mode             = MODE_COLORS_PER_LED;
+    modes.push_back(Neon);
+
+    mode Water;
+    Water.name                  = "Water";
+    Water.value                 = POLYCHROME_V1_MODE_WATER;
+    Water.flags                 = MODE_FLAG_HAS_SPEED;
+    Water.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
+    Water.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
+    Water.speed                 = POLYCHROME_V1_SPEED_DEFAULT_WATER;
+    Water.color_mode            = MODE_COLORS_PER_LED;
+    modes.push_back(Water);
+
+    mode Rainbow;
+    Rainbow.name                = "Rainbow";
+    Rainbow.value               = POLYCHROME_V1_MODE_RAINBOW;
+    Rainbow.flags               = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min           = POLYCHROME_V1_SPEED_MIN_RAINBOW;
+    Rainbow.speed_max           = POLYCHROME_V1_SPEED_MAX_RAINBOW;
+    Rainbow.speed               = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW;
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    modes.push_back(Rainbow);
+    */
+
+    SetupZones();
+}
+
+RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
+{
+    delete controller;
+}
+
+void RGBController_ASRockPolychromeV1SMBus::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Polychrome motherboards should set up zones based on LED  |
+    | configuration register read from device                   |
+    \*---------------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    for(uint8_t zone_idx = 0; zone_idx < POLYCHROME_V1_ZONE_COUNT; zone_idx++)
+    {
+        if(controller->zone_led_count[zone_idx] > 0)
+        {
+            zone* new_zone = new zone();
+
+            /*---------------------------------------------------------*\
+            | Set zone name to channel name                             |
+            \*---------------------------------------------------------*/
+
+            new_zone->name          = polychrome_v1_zone_names[zone_idx];
+
+            new_zone->leds_min      = 1;
+            new_zone->leds_max      = 1;
+            //new_zone->leds_count    = zone_led_count[zone_idx];
+            new_zone->leds_count    = 1;
+
+            new_zone->type          = ZONE_TYPE_SINGLE;
+
+            new_zone->matrix_map    = NULL;
+
+            /*---------------------------------------------------------*\
+            | Push new zone to zones vector                             |
+            \*---------------------------------------------------------*/
+            zones.push_back(*new_zone);
+        }
+    }
+
+    uint8_t led_count = 0;
+    /*---------------------------------------------------------*\
+    | Set up LEDs                                               |
+    \*---------------------------------------------------------*/
+    for(uint8_t zone_idx = 0; zone_idx < POLYCHROME_V1_ZONE_COUNT; zone_idx++)
+    {
+        if(controller->zone_led_count[zone_idx] > 0)
+        {
+            for(uint8_t led_idx = 0; led_idx < controller->zone_led_count[zone_idx]; led_idx++)
+            {
+                /*---------------------------------------------------------*\
+                | Each zone only has one LED                                |
+                \*---------------------------------------------------------*/
+                led* new_led = new led();
+
+                new_led->name           = polychrome_v1_zone_names[zone_idx];
+
+                new_led->name.append(" " + std::to_string(led_idx + 1));
+                new_led->value = 0;
+
+                new_led->value              = zone_idx;
+
+                /*---------------------------------------------------------*\
+                | Push new LED to LEDs vector                               |
+                \*---------------------------------------------------------*/
+                leds.push_back(*new_led);
+
+                led_count++;
+
+                if(zone_idx == POLYCHROME_V1_ZONE_ADDRESSABLE)
+                {
+                    break;
+                }
+            }
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateLEDs()
+{
+    for (std::size_t led = 0; led < colors.size(); led++)
+    {
+        UpdateSingleLED(led);
+    }
+}
+
+void RGBController_ASRockPolychromeV1SMBus::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_ASRockPolychromeV1SMBus::UpdateSingleLED(int led)
+{
+    unsigned char red = RGBGetRValue(colors[led]);
+    unsigned char grn = RGBGetGValue(colors[led]);
+    unsigned char blu = RGBGetBValue(colors[led]);
+
+    /*---------------------------------------------------------*\
+    | If the LED value is non-zero, this LED overrides the LED  |
+    | index                                                     |
+    \*---------------------------------------------------------*/
+    if(leds[led].value != 0)
+    {
+        led = leds[led].value;
+    }
+
+    controller->SetColorsAndSpeed(led, red, grn, blu);
+}
+
+void RGBController_ASRockPolychromeV1SMBus::SetCustomMode()
+{
+    active_mode = 1;
+}
+
+void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateMode()
+{
+    for(uint8_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        controller->SetMode(led_idx, modes[active_mode].value, modes[active_mode].speed);
+    }
+    DeviceUpdateLEDs();
+}

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.h

@@ -0,0 +1,34 @@
+/*-----------------------------------------*\
+|  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        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    ASRockPolychromeV1SMBusController* controller;
+};

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

@@ -0,0 +1,330 @@
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeV2SMBus.cpp|
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#include "RGBController_ASRockPolychromeV2SMBus.h"
+
+static const char* polychrome_v2_zone_names[] =
+{
+    "RGB LED 1 Header",
+    "RGB LED 2 Header",
+    "Audio",
+    "PCH",
+    "IO Cover",
+    "Addressable Header"
+};
+
+/**------------------------------------------------------------------*\
+    @name ASRock Polychrome v2 SMBus
+    @category Motherboard
+    @type SMBus
+    @save :robot:
+    @direct :x:
+    @effects :white_check_mark:
+    @detectors DetectASRockSMBusControllers
+    @comment ASRock Polychrome v2 controllers will save with each update.
+        Per ARGB LED support is not possible with these devices.
+\*-------------------------------------------------------------------*/
+
+RGBController_ASRockPolychromeV2SMBus::RGBController_ASRockPolychromeV2SMBus(ASRockPolychromeV2SMBusController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = controller->GetDeviceName();
+    vendor      = "ASRock";
+    version     = controller->GetFirmwareVersion();
+    type        = DEVICE_TYPE_MOTHERBOARD;
+    description = "ASRock Polychrome v2 Device";
+    location    = controller->GetDeviceLocation();
+
+
+    mode Off;
+    Off.name                    = "Off";
+    Off.value                   = POLYCHROME_V2_MODE_OFF;
+    Off.flags                   = MODE_FLAG_AUTOMATIC_SAVE;
+    Off.color_mode              = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = POLYCHROME_V2_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Static.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = POLYCHROME_V2_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Breathing.speed_min         = POLYCHROME_V2_BREATHING_SPEED_MIN;
+    Breathing.speed_max         = POLYCHROME_V2_BREATHING_SPEED_MAX;
+    Breathing.speed             = POLYCHROME_V2_BREATHING_SPEED_DEFAULT;
+    Breathing.color_mode        = MODE_COLORS_PER_LED;
+    modes.push_back(Breathing);
+
+    mode Strobe;
+    Strobe.name                 = "Strobe";
+    Strobe.value                = POLYCHROME_V2_MODE_STROBE;
+    Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Strobe.speed_min            = POLYCHROME_V2_STROBE_SPEED_MIN;
+    Strobe.speed_max            = POLYCHROME_V2_STROBE_SPEED_MAX;
+    Strobe.speed                = POLYCHROME_V2_STROBE_SPEED_DEFAULT;
+    Strobe.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Strobe);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name          = "Spectrum Cycle";
+    SpectrumCycle.value         = POLYCHROME_V2_MODE_SPECTRUM_CYCLE;
+    SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    SpectrumCycle.speed_min     = POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MIN;
+    SpectrumCycle.speed_max     = POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MAX;
+    SpectrumCycle.speed         = POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_DEFAULT;
+    SpectrumCycle.color_mode    = MODE_COLORS_NONE;
+    modes.push_back(SpectrumCycle);
+
+    mode Random;
+    Random.name                 = "Random";
+    Random.value                = POLYCHROME_V2_MODE_RANDOM;
+    Random.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Random.speed_min            = POLYCHROME_V2_RANDOM_SPEED_MIN;
+    Random.speed_max            = POLYCHROME_V2_RANDOM_SPEED_MAX;
+    Random.speed                = POLYCHROME_V2_RANDOM_SPEED_DEFAULT;
+    Random.color_mode           = MODE_COLORS_NONE;
+    modes.push_back(Random);
+
+    mode Wave;
+    Wave.name                   = "Wave";
+    Wave.value                  = POLYCHROME_V2_MODE_WAVE;
+    Wave.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Wave.speed_min              = POLYCHROME_V2_WAVE_SPEED_MIN;
+    Wave.speed_max              = POLYCHROME_V2_WAVE_SPEED_MAX;
+    Wave.speed                  = POLYCHROME_V2_WAVE_SPEED_DEFAULT;
+    Wave.color_mode             = MODE_COLORS_NONE;
+    modes.push_back(Wave);
+
+    mode Spring;
+    Spring.name                 = "Spring";
+    Spring.value                = POLYCHROME_V2_MODE_SPRING;
+    Spring.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Spring.speed_min            = POLYCHROME_V2_SPRING_SPEED_MIN;
+    Spring.speed_max            = POLYCHROME_V2_SPRING_SPEED_MAX;
+    Spring.speed                = POLYCHROME_V2_SPRING_SPEED_DEFAULT;
+    Spring.color_mode           = MODE_COLORS_NONE;
+    modes.push_back(Spring);
+
+    mode Stack;
+    Stack.name                  = "Stack";
+    Stack.value                 = POLYCHROME_V2_MODE_STACK;
+    Stack.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Stack.speed_min             = POLYCHROME_V2_STACK_SPEED_MIN;
+    Stack.speed_max             = POLYCHROME_V2_STACK_SPEED_MAX;
+    Stack.speed                 = POLYCHROME_V2_STACK_SPEED_DEFAULT;
+    Stack.color_mode            = MODE_COLORS_NONE;
+    modes.push_back(Stack);
+
+    mode Cram;
+    Cram.name                   = "Cram";
+    Cram.value                  = POLYCHROME_V2_MODE_CRAM;
+    Cram.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Cram.speed_min              = POLYCHROME_V2_CRAM_SPEED_MIN;
+    Cram.speed_max              = POLYCHROME_V2_CRAM_SPEED_MAX;
+    Cram.speed                  = POLYCHROME_V2_CRAM_SPEED_DEFAULT;
+    Cram.color_mode             = MODE_COLORS_NONE;
+    modes.push_back(Cram);
+
+    mode Scan;
+    Scan.name                   = "Scan";
+    Scan.value                  = POLYCHROME_V2_MODE_SCAN;
+    Scan.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Scan.speed_min              = POLYCHROME_V2_SCAN_SPEED_MIN;
+    Scan.speed_max              = POLYCHROME_V2_SCAN_SPEED_MAX;
+    Scan.speed                  = POLYCHROME_V2_SCAN_SPEED_DEFAULT;
+    Scan.color_mode             = MODE_COLORS_NONE;
+    modes.push_back(Scan);
+
+    mode Neon;
+    Neon.name                   = "Neon";
+    Neon.value                  = POLYCHROME_V2_MODE_NEON;
+    Neon.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Neon.speed_min              = POLYCHROME_V2_NEON_SPEED_MIN;
+    Neon.speed_max              = POLYCHROME_V2_NEON_SPEED_MAX;
+    Neon.speed                  = POLYCHROME_V2_NEON_SPEED_DEFAULT;
+    Neon.color_mode             = MODE_COLORS_NONE;
+    modes.push_back(Neon);
+
+    mode Water;
+    Water.name                  = "Water";
+    Water.value                 = POLYCHROME_V2_MODE_WATER;
+    Water.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Water.speed_min             = POLYCHROME_V2_WATER_SPEED_MIN;
+    Water.speed_max             = POLYCHROME_V2_WATER_SPEED_MAX;
+    Water.speed                 = POLYCHROME_V2_WATER_SPEED_DEFAULT;
+    Water.color_mode            = MODE_COLORS_NONE;
+    modes.push_back(Water);
+
+    mode Rainbow;
+    Rainbow.name                = "Rainbow";
+    Rainbow.value               = POLYCHROME_V2_MODE_RAINBOW;
+    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Rainbow.speed_min           = POLYCHROME_V2_RAINBOW_SPEED_MIN;
+    Rainbow.speed_max           = POLYCHROME_V2_RAINBOW_SPEED_MAX;
+    Rainbow.speed               = POLYCHROME_V2_RAINBOW_SPEED_DEFAULT;
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    modes.push_back(Rainbow);
+
+    SetupZones();
+}
+
+RGBController_ASRockPolychromeV2SMBus::~RGBController_ASRockPolychromeV2SMBus()
+{
+    delete controller;
+}
+
+void RGBController_ASRockPolychromeV2SMBus::SetupZones()
+{
+
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_idx = 0; zone_idx < POLYCHROME_V2_ZONE_COUNT; zone_idx++)
+    {
+        if(controller->zone_led_count[zone_idx] > 0)
+        {
+            zone* new_zone = new zone();
+
+            /*---------------------------------------------------------*\
+            | Set zone name to channel name                             |
+            \*---------------------------------------------------------*/
+
+            new_zone->name          = polychrome_v2_zone_names[zone_idx];
+
+
+            if(zone_idx == POLYCHROME_V2_ZONE_ADDRESSABLE)
+            {
+                new_zone->leds_min      = 1;
+                new_zone->leds_max      = 1;
+                new_zone->leds_count    = 1;
+            }
+            else
+            {
+                new_zone->leds_min      = controller->zone_led_count[zone_idx];
+                new_zone->leds_max      = controller->zone_led_count[zone_idx];
+                new_zone->leds_count    = controller->zone_led_count[zone_idx];
+            }
+
+            if(new_zone->leds_count > 1)
+            {
+                new_zone->type          = ZONE_TYPE_LINEAR;
+            }
+            else
+            {
+                new_zone->type          = ZONE_TYPE_SINGLE;
+            }
+
+            new_zone->matrix_map        = NULL;
+
+            /*---------------------------------------------------------*\
+            | Push new zone to zones vector                             |
+            \*---------------------------------------------------------*/
+            zones.push_back(*new_zone);
+        }
+    }
+
+    unsigned int led_count = 0;
+    /*---------------------------------------------------------*\
+    | Set up LEDs                                               |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_idx = 0; zone_idx < POLYCHROME_V2_ZONE_COUNT; zone_idx++)
+    {
+        if(controller->zone_led_count[zone_idx] > 0)
+        {
+            for(unsigned int led_idx = 0; led_idx < controller->zone_led_count[zone_idx]; led_idx++)
+            {
+                /*---------------------------------------------------------*\
+                | Each zone only has one LED                                |
+                \*---------------------------------------------------------*/
+                led* new_led = new led();
+
+                new_led->name           = polychrome_v2_zone_names[zone_idx];
+
+                new_led->name.append(" " + std::to_string(led_idx + 1));
+                new_led->value = 0;
+
+                if(zone_idx == POLYCHROME_V2_ZONE_ADDRESSABLE)
+                {
+                    new_led->value              = 0x19;
+                }
+
+                /*---------------------------------------------------------*\
+                | Push new LED to LEDs vector                               |
+                \*---------------------------------------------------------*/
+                leds.push_back(*new_led);
+
+                led_count++;
+
+                if(zone_idx == POLYCHROME_V2_ZONE_ADDRESSABLE)
+                {
+                    break;
+                }
+            }
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_ASRockPolychromeV2SMBus::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateLEDs()
+{
+    for (std::size_t led = 0; led < colors.size(); led++)
+    {
+        UpdateSingleLED(led);
+    }
+}
+
+void RGBController_ASRockPolychromeV2SMBus::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_ASRockPolychromeV2SMBus::UpdateSingleLED(int led)
+{
+    unsigned char red = RGBGetRValue(colors[led]);
+    unsigned char grn = RGBGetGValue(colors[led]);
+    unsigned char blu = RGBGetBValue(colors[led]);
+
+    /*---------------------------------------------------------*\
+    | If the LED value is non-zero, this LED overrides the LED  |
+    | index                                                     |
+    \*---------------------------------------------------------*/
+    if(leds[led].value != 0)
+    {
+        led = leds[led].value;
+    }
+
+    controller->SetColorsAndSpeed(led, red, grn, blu);
+}
+
+void RGBController_ASRockPolychromeV2SMBus::SetCustomMode()
+{
+    active_mode = 1;
+}
+
+void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateMode()
+{
+
+    controller->SetMode(0, modes[active_mode].value, modes[active_mode].speed);
+
+    DeviceUpdateLEDs();
+}

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV2SMBus.h

@@ -0,0 +1,34 @@
+/*-----------------------------------------*\
+|  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        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    ASRockPolychromeV2SMBusController* controller;
+};

Controllers/AlienwareController/RGBController_Alienware.cpp

@@ -14,6 +14,7 @@
 
 /**------------------------------------------------------------------*\
     @name Alienware
+    @category Keyboard
     @type USB
     @save :x:
     @direct :x:
@@ -147,7 +148,7 @@ void RGBController_Alienware::SetupZones()
     for(unsigned int led_idx = 0; led_idx < zones.size(); led_idx++)
     {
         led new_led;
-        
+
         new_led.name        = zones[led_idx].name + std::string(" LED");
 
         leds.emplace_back(new_led);
@@ -228,7 +229,7 @@ void RGBController_Alienware::DeviceUpdateMode()
             uint16_t period = 0x07d0;
 
             controller->SetMode(zone_idx, current_mode.value);
-            
+
             switch(current_mode_idx)
             {
                 case ALIENWARE_MODE_COLOR:

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.cpp

@@ -160,6 +160,7 @@ static const led_type led_names[] =
 
 /**------------------------------------------------------------------*\
     @name Alienware AW510 Keyboard
+    @category Keyboard
     @type USB
     @save :x:
     @direct :white_check_mark:

Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp

@@ -18,7 +18,7 @@ static unsigned int matrix_map[5][14] =
     { { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 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, NA },
-      { 41, NA, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, NA }, 
+      { 41, NA, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, NA },
       { 53, NA, 54, 55, NA, NA, 56, NA, NA, 57, 58, 59, 60, NA } };
 
 static const char* zone_names[] =
@@ -110,6 +110,7 @@ static const led_type led_names[] =
 
 /**------------------------------------------------------------------*\
     @name Anne Pro 2
+    @category Keyboard
     @type USB
     @save :x:
     @direct :white_check_mark:
@@ -118,7 +119,7 @@ static const led_type led_names[] =
     @comment
 \*-------------------------------------------------------------------*/
 
-RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_ptr) 
+RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_ptr)
 {
     controller  = controller_ptr;
 
@@ -139,12 +140,12 @@ RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_pt
     SetupZones();
 }
 
-RGBController_AnnePro2::~RGBController_AnnePro2() 
+RGBController_AnnePro2::~RGBController_AnnePro2()
 {
     delete controller;
 }
 
-void RGBController_AnnePro2::SetupZones() 
+void RGBController_AnnePro2::SetupZones()
 {
     /*---------------------------------------------------------*\
     | Set up zones                                              |
@@ -187,14 +188,14 @@ void RGBController_AnnePro2::SetupZones()
     SetupColors();
 }
 
-void RGBController_AnnePro2::ResizeZone(int /*zone*/, int /*new_size*/) 
+void RGBController_AnnePro2::ResizeZone(int /*zone*/, int /*new_size*/)
 {
     /*---------------------------------------------------------*\
     | This device does not support resizing zones               |
     \*---------------------------------------------------------*/
 }
 
-void RGBController_AnnePro2::DeviceUpdateLEDs() 
+void RGBController_AnnePro2::DeviceUpdateLEDs()
 {
     const unsigned char frame_buf_length = LED_REAL_COUNT * 3;
     unsigned char frame_buf[frame_buf_length];
@@ -225,22 +226,22 @@ void RGBController_AnnePro2::DeviceUpdateLEDs()
     controller->SendDirect(frame_buf_length, frame_buf);
 }
 
-void RGBController_AnnePro2::UpdateZoneLEDs(int /*zone*/) 
+void RGBController_AnnePro2::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AnnePro2::UpdateSingleLED(int /*led*/) 
+void RGBController_AnnePro2::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AnnePro2::SetCustomMode() 
+void RGBController_AnnePro2::SetCustomMode()
 {
     active_mode = 0;
 }
 
-void RGBController_AnnePro2::DeviceUpdateMode() 
+void RGBController_AnnePro2::DeviceUpdateMode()
 {
-    
+
 }

Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.cpp

@@ -10,9 +10,10 @@
 
 /**------------------------------------------------------------------*\
     @name Asus AURA Core
+    @category Keyboard,LEDStrip
     @type USB
     @save :x:
-    @direct :warning:
+    @direct :rotating_light:
     @effects :white_check_mark:
     @detectors DetectAsusAuraCoreControllers
     @comment
@@ -25,7 +26,7 @@ RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_pt
     name        = "ASUS Aura Core Device";
     vendor      = "ASUS";
     location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();    
+    serial      = controller->GetSerialString();
     description = "ASUS Aura Core Device";
     type        = DEVICE_TYPE_UNKNOWN;
 

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -17,75 +17,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-using namespace std::chrono_literals;
-
-typedef struct
-{
-    int             pci_vendor;
-    int             pci_device;
-    int             pci_subsystem_vendor;
-    int             pci_subsystem_device;
-    unsigned char   controller_address;
-    const char *    name;
-} gpu_pci_device;
-
 #define ASUSGPU_CONTROLLER_NAME "ASUS Aura GPU"
-#define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const gpu_pci_device device_list[] =
-{
-    { NVIDIA_VEN,       NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,       ASUS_GTX1050_STRIX_O2G_GAMING,              0x29,   "ASUS ROG Strix GTX 1050 O2G Gaming"        },
-    { NVIDIA_VEN,       NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29,   "ASUS ROG Strix GTX 1050 TI O4G Gaming"     },
-    { NVIDIA_VEN,       NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29,   "ASUS ROG Strix GTX 1050 TI O4G Gaming"     },
-    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX_6G_GAMING,               0x29,   "ASUS GTX 1060 Strix 6G Gaming"             },
-    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX,                         0x29,   "ASUS GTX 1060 Strix"                       },
-    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_GAMING,                  0x29,   "ASUS GTX 1070 Strix Gaming"                },
-    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_OC,                      0x29,   "ASUS GTX 1070 Strix OC"                    },
-    { NVIDIA_VEN,       NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29,   "ASUS ROG Strix GTX1070 Ti 8G Gaming"       },
-    { NVIDIA_VEN,       NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29,   "ASUS ROG Strix GTX1070 Ti A8G Gaming"      },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_GTX1080_STRIX,                         0x29,   "ASUS GTX 1080 Strix OC"                    },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29,   "ASUS ROG Strix GTX1080 A8G Gaming"         },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29,   "ASUS ROG Strix GTX1080 O8G Gaming"         },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29,   "ASUS ROG Strix GTX1080 Ti Gaming"          },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29,   "ASUS ROG Strix GTX1080 Ti 11G Gaming"      },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29,   "ASUS ROG Strix GTX1080 Ti O11G Gaming"     },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29,   "ASUS ROG Strix GTX1080 Ti O11G Gaming"     },
-    { NVIDIA_VEN,       NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A,   "ASUS ROG Strix GTX 1650S OC 4G"            },
-    { NVIDIA_VEN,       NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A,   "ASUS ROG Strix GTX 1660S O6G Gaming"       },
-    { NVIDIA_VEN,       NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_GTX1660TI_OC,                      0x2A,   "ASUS ROG GTX 1660 Ti OC 6G"                },
-    { NVIDIA_VEN,       NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2060 O6G Gaming 6G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2060 O6G EVO Gaming"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2060S 8G Gaming 8G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2060S A8G EVO Gaming 8G"},
-    { NVIDIA_VEN,       NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2060S O8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2060S A8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2070 A8G Gaming 8G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2070 O8G Gaming 8G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A,   "ASUS ROG STRIX RTX 2070S O8G Gaming"       },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A,   "ASUS ROG STRIX RTX 2070S 8G Gaming"        },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2070S O8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2080 O8G Gaming"        },
-    { NVIDIA_VEN,       NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2080S A8G Gaming"       },
-    { NVIDIA_VEN,       NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2080S O8G Gaming"       },
-    { NVIDIA_VEN,       NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A,   "ASUS ROG STRIX RTX 2080S O8G White"        },
-    { NVIDIA_VEN,       NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A,   "ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A,   "ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A,   "ASUS ROG STRIX RTX 2080 Ti A11G Gaming"    },
-    { NVIDIA_VEN,       NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,       ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A,   "ASUS TUF RTX 3060 Ti 8G Gaming OC"         },
-    { AMD_GPU_VEN,      AMD_VEGA10_DEV,             ASUS_SUB_VEN,       ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29,   "ASUS AREZ Strix RX Vega 56 O8G"            },
-    { AMD_GPU_VEN,      AMD_VEGA10_DEV,             ASUS_SUB_VEN,       ASUS_VEGA64_STRIX,                          0x29,   "ASUS Vega 64 Strix"                        },
-    { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A,   "ASUS RX 5600XT Strix O6G Gaming"           },
-    { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A,   "ASUS RX 5700XT Strix Gaming OC"            },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX480_STRIX_GAMING_OC,                 0x29,   "ASUS ROG STRIX RX480 Gaming OC"            },
-    { AMD_GPU_VEN,      AMD_POLARIS11,              ASUS_SUB_VEN,       ASUS_RX560_STRIX_4G_GAMING,                 0x29,   "ASUS ROG STRIX RX560 Gaming"               },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29,   "ASUS RX 570 Strix O4G Gaming OC"           },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_OC,                 0x29,   "ASUS RX 580 Strix Gaming OC"               },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_TOP,                0x29,   "ASUS RX 580 Strix Gaming TOP"              },
-};  
 
 /******************************************************************************************\
 *                                                                                          *
@@ -99,8 +31,8 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres
 {
     bool pass = false;
 
-    unsigned char aura_gpu_magic_high = bus->i2c_smbus_read_byte_data(address, 0x20);                        // High Byte of magic (0x15)                        
-    unsigned char aura_gpu_magic_low = bus->i2c_smbus_read_byte_data(address, 0x21);                         // Low Byte of magic (0x89)
+    unsigned char aura_gpu_magic_high = bus->i2c_smbus_read_byte_data(address, 0x20);   // High Byte of magic (0x15)
+    unsigned char aura_gpu_magic_low  = bus->i2c_smbus_read_byte_data(address, 0x21);   // Low Byte of magic (0x89)
 
     LOG_DEBUG("[%s] Test GPU expect: 0x1589 received: 0x%02X%02X", ASUSGPU_CONTROLLER_NAME, aura_gpu_magic_high, aura_gpu_magic_low);
 
@@ -121,29 +53,69 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses)
+void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    if(TestForAsusAuraGPUController(bus, i2c_addr))
     {
-        for(unsigned int dev_idx = 0; dev_idx < GPU_NUM_DEVICES; dev_idx++)
-        {
-            if(busses[bus]->pci_vendor           == device_list[dev_idx].pci_vendor           &&
-               busses[bus]->pci_device           == device_list[dev_idx].pci_device           &&
-               busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
-               busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
-            {
-                LOG_DEBUG(GPU_DETECT_MESSAGE, ASUSGPU_CONTROLLER_NAME, bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name );
-                
-                if(TestForAsusAuraGPUController(busses[bus], device_list[dev_idx].controller_address))
-                {
-                    AuraGPUController*     controller     = new AuraGPUController(busses[bus], device_list[dev_idx].controller_address);
-                    RGBController_AuraGPU* rgb_controller = new RGBController_AuraGPU(controller);
-                    rgb_controller->name = device_list[dev_idx].name;
-                    ResourceManager::get()->RegisterRGBController(rgb_controller);
-                }
-            }
-        }
+        AuraGPUController*     controller     = new AuraGPUController(bus, i2c_addr);
+        RGBController_AuraGPU* rgb_controller = new RGBController_AuraGPU(controller);
+        rgb_controller->name                  = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 } /* DetectAsusAuraGPUControllers() */
 
-REGISTER_I2C_DETECTOR(ASUSGPU_CONTROLLER_NAME, DetectAsusAuraGPUControllers);
+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 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 6G"     , 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 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 8G"     , 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 8G", 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 8G"    , 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 8G"    , 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 8G"     , 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 8G"     , 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 8G"    , 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 8G"    , 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 8G"    , 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 8G"    , 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 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 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 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 O11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       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 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 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 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 580 Strix Gaming OC"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_OC,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming TOP"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp

@@ -18,7 +18,7 @@ int RGBController_AuraGPU::GetDeviceMode()
         if (controller->direct)
         {
             dev_mode = AURA_GPU_MODE_DIRECT;
-        } 
+        }
     }
 
     switch(dev_mode)
@@ -35,7 +35,7 @@ int RGBController_AuraGPU::GetDeviceMode()
         {
             active_mode            = mode;
             modes[mode].color_mode = color_mode;
-        }   
+        }
     }
 
     return(active_mode);
@@ -43,10 +43,11 @@ int RGBController_AuraGPU::GetDeviceMode()
 
 /**------------------------------------------------------------------*\
     @name Asus Aura GPU
+    @category GPU
     @type SMBus
     @save :x:
     @direct :white_check_mark:
-    @effects :white_check_mark::
+    @effects :white_check_mark:
     @detectors DetectAsusAuraGPUControllers
     @comment
 \*-------------------------------------------------------------------*/
@@ -165,7 +166,7 @@ void RGBController_AuraGPU::DeviceUpdateLEDs()
         {
             controller->SetLEDColorsDirect(red, grn, blu);
         }
-        else 
+        else
         {
             controller->SetLEDColorsEffect(red, grn, blu);
         }
@@ -191,7 +192,7 @@ void RGBController_AuraGPU::DeviceUpdateMode()
 {
     int new_mode       = modes[active_mode].value;
     controller->direct = false;
-    
+
     switch(new_mode)
     {
         // Set all LEDs to 0 and Mode to static as a workaround for the non existing Off Mode
@@ -199,7 +200,7 @@ void RGBController_AuraGPU::DeviceUpdateMode()
             controller->SetLEDColorsEffect(0, 0, 0);
             new_mode           = AURA_GPU_MODE_STATIC;
             break;
-        
+
         // Direct mode is done by switching to Static and not applying color changes
         case AURA_GPU_MODE_DIRECT:
             controller->direct = true;

Controllers/AsusAuraUSBController/AsusAuraMonitorController.cpp

@@ -12,10 +12,11 @@
 #include <cstring>
 #include "LogManager.h"
 
-AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path)
+AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid)
 {
     dev         = dev_handle;
     location    = path;
+    device_pid  = pid;
 }
 
 AuraMonitorController::~AuraMonitorController()
@@ -44,6 +45,27 @@ std::string AuraMonitorController::GetSerialString()
     return(return_string);
 }
 
+void AuraMonitorController::BeginUpdate()
+{
+    unsigned char usb_buf[8];
+
+    if (device_pid == AURA_ROG_PG32UQ_PID)
+    {
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+
+        usb_buf[0x00]   = 0x03;
+        usb_buf[0x01]   = 0x02;
+        usb_buf[0x02]   = 0xA1;
+        usb_buf[0x03]   = 0x80;
+
+        usb_buf[0x04]   = 0x20;
+        hid_send_feature_report(dev, usb_buf, 8);
+
+        usb_buf[0x04]   = 0x30;
+        hid_send_feature_report(dev, usb_buf, 8);
+    }
+}
+
 void AuraMonitorController::UpdateLed
     (
     int             led,
@@ -58,7 +80,7 @@ void AuraMonitorController::UpdateLed
 
     usb_buf[0x00]   = 0x03;
     usb_buf[0x01]   = 0x02;
-    usb_buf[0x02]   = 0xa1;
+    usb_buf[0x02]   = 0xA1;
     usb_buf[0x03]   = 0x80;
 
     usb_buf[0x04]   = 16 + led * 3;
@@ -85,9 +107,9 @@ void AuraMonitorController::ApplyChanges()
 
     usb_buf[0x00]   = 0x03;
     usb_buf[0x01]   = 0x02;
-    usb_buf[0x02]   = 0xa1;
+    usb_buf[0x02]   = 0xA1;
     usb_buf[0x03]   = 0x80;
-    usb_buf[0x04]   = 0xa0;
+    usb_buf[0x04]   = 0xA0;
     usb_buf[0x05]   = 0x01;
     
     hid_send_feature_report(dev, usb_buf, 8);

Controllers/AsusAuraUSBController/AsusAuraMonitorController.h

@@ -13,18 +13,28 @@
 
 #pragma once
 
+enum
+{
+    AURA_ROG_STRIX_XG27AQ_PID    = 0x198C,
+    AURA_ROG_PG32UQ_PID          = 0x19B9,
+};
+
+
 class AuraMonitorController
 {
 public:
-    AuraMonitorController(hid_device* dev_handle, const char* path);
+    AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid);
     virtual ~AuraMonitorController();
 
     std::string GetDeviceLocation();
     std::string GetSerialString();
 
+    void BeginUpdate();
     void UpdateLed(int led, unsigned char red, unsigned char green, unsigned char blue);
     void ApplyChanges();
 
+    uint16_t                    device_pid;
+
 private:
     hid_device*                 dev;
     std::string                 location;

Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h

@@ -11,27 +11,35 @@
 
 #pragma once
 
-#define AURA_ROG_GLADIUS_II_CORE_PID            0x18DD
-#define AURA_ROG_GLADIUS_II_PID                 0x1845
-#define AURA_ROG_GLADIUS_II_ORIGIN_PID          0x1877
-#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID  0x18CD
-#define AURA_ROG_GLADIUS_II_ORIGIN_COD_PID      0x18B1
-#define AURA_ROG_GLADIUS_II_WIRELESS_1_PID      0x189E
-#define AURA_ROG_GLADIUS_II_WIRELESS_2_PID      0x18A0
-#define AURA_ROG_CHAKRAM_WIRELESS_PID           0x18E5
-#define AURA_ROG_CHAKRAM_WIRED_1_PID            0x18E3
-#define AURA_ROG_CHAKRAM_CORE_PID               0x1958
-#define AURA_ROG_PUGIO_PID                      0x1846
-#define AURA_ROG_PUGIO_II_WIRED_PID             0x1906
-#define AURA_ROG_PUGIO_II_WIRELESS_PID          0x1908
-#define AURA_ROG_STRIX_IMPACT_PID               0x1847
-#define AURA_ROG_STRIX_IMPACT_II_PID            0x18E1
-#define AURA_ROG_KERIS                          0x195C
-#define AURA_ROG_KERIS_WIRELESS_USB_PID         0x195E
-#define AURA_ROG_KERIS_WIRELESS_2_4_PID         0x1960
-#define AURA_ROG_KERIS_WIRELESS_BT_PID          0x1962
-#define AURA_TUF_M3_PID                         0x1910
-#define AURA_TUF_M5_PID                         0x1898
+#define AURA_ROG_GLADIUS_II_CORE_PID                0x18DD
+#define AURA_ROG_GLADIUS_II_PID                     0x1845
+#define AURA_ROG_GLADIUS_II_ORIGIN_PID              0x1877
+#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID      0x18CD
+#define AURA_ROG_GLADIUS_II_ORIGIN_COD_PID          0x18B1
+#define AURA_ROG_GLADIUS_II_WIRELESS_1_PID          0x189E
+#define AURA_ROG_GLADIUS_II_WIRELESS_2_PID          0x18A0
+#define AURA_ROG_GLADIUS_III_WIRELESS_USB_PID       0x197D
+#define AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID       0x197F
+#define AURA_ROG_GLADIUS_III_WIRELESS_BT_PID        0x1981
+#define AURA_ROG_CHAKRAM_WIRELESS_PID               0x18E5
+#define AURA_ROG_CHAKRAM_WIRED_1_PID                0x18E3
+#define AURA_ROG_CHAKRAM_CORE_PID                   0x1958
+#define AURA_ROG_PUGIO_PID                          0x1846
+#define AURA_ROG_PUGIO_II_WIRED_PID                 0x1906
+#define AURA_ROG_PUGIO_II_WIRELESS_PID              0x1908
+#define AURA_ROG_STRIX_IMPACT_PID                   0x1847
+#define AURA_ROG_STRIX_IMPACT_II_PID                0x18E1
+#define AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID         0x189E
+#define AURA_ROG_STRIX_IMPACT_II_PUNK_PID           0x1956
+#define AURA_ROG_STRIX_IMPACT_II_WHITE_PID          0x19D2
+#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID   0x1947
+#define AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID   0x1949
+#define AURA_ROG_KERIS                              0x195C
+#define AURA_ROG_KERIS_WIRELESS_USB_PID             0x195E
+#define AURA_ROG_KERIS_WIRELESS_2_4_PID             0x1960
+#define AURA_ROG_KERIS_WIRELESS_BT_PID              0x1962
+#define AURA_TUF_M3_PID                             0x1910
+#define AURA_TUF_M5_PID                             0x1898
 
 enum
 {
@@ -57,6 +65,8 @@ typedef struct
 {
     uint8_t                 speed_min;
     uint8_t                 speed_max;
+    uint8_t                 brightness_min;
+    uint8_t                 brightness_max;
     bool                    wireless;
     int                     version_protocol;
     std::vector<uint8_t>    mouse_zones;
@@ -76,10 +86,12 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_GLADIUS_II_CORE_PID, // ROG Gladius II Core
         {
-            0,    //Speed Min - The Asus Mouse protocol defines larger numbers as slow
-            0,    //Speed Max
-            false,
-            1,
+            0,      // Speed Min - The Asus Mouse protocol defines larger numbers as slow
+            0,      // Speed Max
+            0,      // Brightness Min
+            4,      // Brightness Max
+            false,  // is wireless? (important for fetching the version)
+            1,      // version protocol
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -89,6 +101,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            0,
+            4,
             false,
             0,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -100,6 +114,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            0,
+            4,
             false,
             0,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -111,6 +127,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            0,
+            4,
             false,
             0,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -122,6 +140,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            0,
+            4,
             false,
             0,
             { AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -133,6 +153,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             0,
             0,
+            0,
+            4,
             true,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
@@ -144,17 +166,60 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             0,
             0,
+            0,
+            4,
             true,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
     },
+    {
+        AURA_ROG_GLADIUS_III_WIRELESS_USB_PID, // ROG Gladius III Wireless USB
+        {
+            255,
+            1,
+            0,
+            64,
+            false,
+            1,
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
+    {
+        AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID, // ROG Gladius III Wireless 2.4 GHz Dongle
+        {
+            255,
+            1,
+            0,
+            64,
+            true,
+            1,
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
+    {
+        AURA_ROG_GLADIUS_III_WIRELESS_BT_PID, // ROG Gladius III Wireless Bluetooth
+        {
+            255,
+            1,
+            0,
+            64,
+            true,
+            1,
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
     {
         AURA_ROG_CHAKRAM_WIRELESS_PID, // ROG Chakram Wireless
         {
             15,
             1,
+            0,
+            4,
             true,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -166,6 +231,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             15,
             1,
+            0,
+            4,
             false,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -177,6 +244,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             0,
             0,
+            0,
+            4,
             false,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
@@ -188,6 +257,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            0,
+            4,
             false,
             0,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -199,6 +270,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             15,
             1,
+            0,
+            4,
             false,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -210,6 +283,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             15,
             1,
+            0,
+            4,
             true,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -221,6 +296,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             0,
             0,
+            0,
+            4,
             false,
             3,
             { AURA_MOUSE_ZONE_LOGO },
@@ -232,17 +309,86 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             0,
             0,
+            0,
+            4,
             false,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
     },
+    {
+        AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID, // ROG Strix Impact II Gundam
+        {
+            0,
+            0,
+            0,
+            4,
+            false,
+            1,
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
+        }
+    },
+    {
+        AURA_ROG_STRIX_IMPACT_II_PUNK_PID, // ROG Strix Impact II Electro Punk
+        {
+            0,
+            0,
+            0,
+            4,
+            false,
+            1,
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
+        }
+    },
+    {
+        AURA_ROG_STRIX_IMPACT_II_WHITE_PID, // ROG Strix Impact II Moonlight White
+        {
+            0,
+            0,
+            0,
+            4,
+            false,
+            1,
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
+        }
+    },
+    {
+        AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID, // ROG Strix Impact II Wireless USB
+        {
+            0,
+            0,
+            0,
+            4,
+            false,
+            1, // not tested, but likely same as ROG Strix Impact II non wireless
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
+    {
+        AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID, // ROG Strix Impact II Wireless 2.4 GHz Dongle
+        {
+            0,
+            0,
+            0,
+            4,
+            true,
+            1, // not tested, but likely same as ROG Strix Impact II non wireless
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
     {
         AURA_ROG_KERIS, // ROG Keris
         {
             0,
             0,
+            0,
+            4,
             false,
             1, // might be the wrong protocol for version
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
@@ -254,6 +400,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             0,
             0,
+            0,
+            4,
             true,
             1, // might be the wrong protocol for version
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
@@ -265,6 +413,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             0,
             0,
+            0,
+            4,
             true,
             1, // might be the wrong protocol for version
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
@@ -276,6 +426,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             0,
             0,
+            0,
+            4,
             true,
             1, // might be the wrong protocol for version
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
@@ -287,6 +439,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             0,
             0,
+            0,
+            4,
             false,
             1,
             { AURA_MOUSE_ZONE_LOGO },
@@ -298,6 +452,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             0,
             0,
+            0,
+            4,
             false,
             2,
             { AURA_MOUSE_ZONE_LOGO },

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.cpp

@@ -0,0 +1,121 @@
+/*-------------------------------------------------------------------*\
+|  AsusAuraRyuoAIOController.cpp                                      |
+|                                                                     |
+|  Driver for the ASUS Aura Ryuo AIO                                  |
+|    lighting controller                                              |
+|                                                                     |
+|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
+|  using snipets from Chris M (Dr.No)                                 |
+\*-------------------------------------------------------------------*/
+
+#include "AsusAuraRyuoAIOController.h"
+
+AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
+{
+	const int szTemp = ASUSAURARYUOAIOCONTROLLER_HID_MAX_STR;
+	wchar_t tmpName[szTemp];
+
+	/*-----------------------------------------------------*\
+	| Add addressable devices                               |
+	|    Manually adding device info for now                |
+	|    TODO: Implement config table accurately            |
+	\*-----------------------------------------------------*/
+	device_info.push_back({0x00, 0x00, 12, 0, AuraDeviceType::FIXED});
+}
+
+AsusAuraRyuoAIOController::~AsusAuraRyuoAIOController()
+{
+	hid_close(dev);
+}
+
+std::string AsusAuraRyuoAIOController::GetLocation()
+{
+	return("HID: " + location);
+}
+
+void AsusAuraRyuoAIOController::SetMode(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu)
+{
+	/*---------------------------------------------------------*\
+	| This interface is not used in this controller however is  |
+	|   required by the abstract class                          |
+	\*---------------------------------------------------------*/
+}
+
+void AsusAuraRyuoAIOController::SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour)
+{
+	//check if update is needed
+	if(!((current_mode == mode) && (ToRGBColor(current_red, current_green, current_blue) == colour) && (current_speed == speed) && (current_direction == direction)))
+	{
+		current_mode        = mode;
+		current_speed       = speed;
+		current_direction   = direction;
+		current_red         = RGBGetRValue(colour);
+		current_green       = RGBGetGValue(colour);
+		current_blue        = RGBGetBValue(colour);
+		SendUpdate();
+	}
+}
+
+void AsusAuraRyuoAIOController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
+{
+	/*---------------------------------------------------------*\
+	| This interface is not used in this controller however is  |
+	|   required by the abstract class                          |
+	\*---------------------------------------------------------*/
+}
+
+void AsusAuraRyuoAIOController::SetLedsDirect(RGBColor * led_colours, uint8_t led_count)
+{
+	uint8_t buffer[write_packet_size]   = { 0xEC, 0x40, 0x80, 0x00, led_count };
+
+	/*---------------------------------------------------------*\
+	| Set the colour bytes in the packet                        |
+	\*---------------------------------------------------------*/
+	for(uint8_t index = 0; index < led_count; index++)
+	{
+		uint8_t offset      = (index * 3) + RED_BYTE;
+
+		buffer[offset + 0]  = RGBGetRValue(led_colours[index]);
+		buffer[offset + 1]  = RGBGetGValue(led_colours[index]);
+		buffer[offset + 2]  = RGBGetBValue(led_colours[index]);
+	}
+
+	hid_write(dev, buffer, write_packet_size);
+}
+
+void AsusAuraRyuoAIOController::GetStatus()
+{
+	uint8_t buffer[write_packet_size]   = { 0xEC, 0x01, 0x02 };
+
+	hid_write(dev, buffer, write_packet_size);
+	hid_read_timeout(dev, buffer, read_packet_size, ASUSAURARYUOAIOCONTROLLER_TIMEOUT);
+
+	current_red   = buffer[RED_BYTE - 1];
+	current_green = buffer[GREEN_BYTE - 1];
+	current_blue  = buffer[BLUE_BYTE - 1];
+}
+
+void AsusAuraRyuoAIOController::SendUpdate()
+{
+	uint8_t buffer[write_packet_size];
+
+	/*-----------------------------------------------------*\
+	| Zero out buffer                                       |
+	\*-----------------------------------------------------*/
+	memset(buffer, 0x00, write_packet_size);
+
+	buffer[REPORTID_BYTE] = reportid;
+	buffer[COMMAND_BYTE]  = modefx;
+	buffer[ZONE_BYTE]     = 0;
+	buffer[PROGRAM_ID_BYTE]  = program_id;
+	buffer[MODE_BYTE]     = current_mode;
+	buffer[RED_BYTE]      = current_red;
+	buffer[GREEN_BYTE]    = current_green;
+	buffer[BLUE_BYTE]     = current_blue;
+
+	buffer[DIRECTION_BYTE]= current_direction;
+	buffer[SPEED_BYTE]    = current_speed;
+
+	hid_write(dev, buffer, write_packet_size);
+}
+

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.h

@@ -0,0 +1,94 @@
+/*-------------------------------------------------------------------*\
+|  AsusAuraRyuoAIOController.h                                        |
+|                                                                     |
+|  Driver for the ASUS Aura Ryuo AIO                                  |
+|    lighting controller                                              |
+|                                                                     |
+|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
+|  using snipets from Chris M (Dr.No)                                 |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+#include "AsusAuraUSBController.h"
+
+#pragma once
+
+#define ASUSAURARYUOAIOCONTROLLER_TIMEOUT        250
+#define ASUSAURARYUOAIOCONTROLLER_HID_MAX_STR    255
+
+#define ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN 0
+#define ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX 255
+
+class AsusAuraRyuoAIOController : public AuraUSBController
+{
+public:
+    enum
+    {
+        MODE_DIRECT       = 0xFF, //Direct Led Control - Independently set LEDs in zone
+        MODE_STATIC       = 0x01, //Static Mode - Set entire zone to a single color.
+        MODE_BREATHING    = 0x02, //Breathing Mode - Fades between fully off and fully on.
+        MODE_FLASHING     = 0x03, //Flashing Mode - Abruptly changing between fully off and fully on.
+        MODE_SPECTRUM     = 0x04, //Spectrum Cycle Mode - Cycles through the color spectrum on all lights on the device
+        MODE_RAINBOW      = 0x05, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs
+        MODE_FLASHANDDASH = 0x0A, //Flash n Dash - Flash twice and then flash in direction
+    };
+
+    enum PacketMap
+    {
+        REPORTID_BYTE  = 0,
+        COMMAND_BYTE   = 1,
+        ZONE_BYTE      = 2,
+        PROGRAM_ID_BYTE= 3,
+        MODE_BYTE      = 4,
+        RED_BYTE       = 5,
+        GREEN_BYTE     = 6,
+        BLUE_BYTE      = 7,
+        DIRECTION_BYTE = 8,
+        SPEED_BYTE     = 9,
+    };
+
+    enum
+    {
+        SPEED_SLOWEST     = 0x04, // Slowest speed
+        SPEED_SLOW        = 0x03, // Slower speed
+        SPEED_NORMAL      = 0x02, // Normal speed
+        SPEED_FAST        = 0x01, // Fast speed
+        SPEED_FASTEST     = 0x00, // Fastest speed
+    };
+
+    AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path);
+    ~AsusAuraRyuoAIOController();
+
+    std::string             GetLocation();
+
+    void                    SetChannelLEDs(unsigned char channel, RGBColor *colors, unsigned int num_colors);
+    void                    SetLedsDirect(RGBColor * led_colours, uint8_t led_count);
+
+    void                    SetMode(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu);
+    void                    SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour);
+private:
+    static const uint8_t    read_packet_size    = 65;
+    static const uint8_t    write_packet_size   = 65;
+    static const uint8_t    modefx   = 0x3B;
+    static const uint8_t    direct   = 0x40;
+    static const uint8_t    reportid = 0xEC;
+    static const uint8_t    program_id = 0x22;
+
+    std::string             location;
+
+    uint8_t                 zone_index;
+    uint8_t                 current_mode;
+    uint8_t                 current_speed;
+
+    uint8_t                 current_red;
+    uint8_t                 current_green;
+    uint8_t                 current_blue;
+    uint8_t                 current_direction;
+
+    void                    GetStatus();
+    void                    SendUpdate();
+    void                    SendEffect(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu);
+    void                    SendDirectApply(unsigned char channel);
+};

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -8,6 +8,7 @@
 #include "AsusAuraMousematController.h"
 #include "AsusAuraStrixEvolveController.h"
 #include "AsusAuraMonitorController.h"
+#include "AsusAuraRyuoAIOController.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraUSB.h"
 #include "RGBController_AsusAuraHeadsetStand.h"
@@ -18,6 +19,7 @@
 #include "RGBController_ROGStrixLC_Controller.h"
 #include "RGBController_AsusAuraStrixEvolve.h"
 #include "RGBController_AsusAuraMonitor.h"
+#include "RGBController_AsusAuraRyuoAIO.h"
 #include <stdexcept>
 #include <hidapi/hidapi.h>
 #include "dependencies/dmiinfo.h"
@@ -65,6 +67,7 @@
 \*-----------------------------------------------------------------*/
 
 #define AURA_ROG_STRIX_XG27AQ_PID               0x198C
+#define AURA_ROG_PG32UQ_PID                     0x19B9
 
 /*-----------------------------------------------------------------*\
 | HEADSETSTANDS                                                     |
@@ -79,6 +82,7 @@
 \*-----------------------------------------------------------------*/
 #define AURA_TERMINAL_PID                       0x1889
 #define ROG_STRIX_LC120_PID                     0x879E
+#define AURA_RYUO_AIO_PID                       0x1887
 
 AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
 {
@@ -208,6 +212,19 @@ void DetectAsusAuraUSBROGStrixLC(hid_device_info* info, const std::string& name)
     }
 }
 
+void DetectAsusAuraUSBRyuoAIO(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AsusAuraRyuoAIOController* controller         = new AsusAuraRyuoAIOController(dev, info->path);
+        RGBController_AsusAuraRyuoAIO* rgb_controller = new RGBController_AsusAuraRyuoAIO(controller);
+        rgb_controller->name                          = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -253,7 +270,7 @@ void DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
 
     if(dev)
     {
-        AuraMonitorController*     controller           = new AuraMonitorController(dev, info->path);
+        AuraMonitorController*     controller           = new AuraMonitorController(dev, info->path, info->product_id);
         RGBController_AuraMonitor* rgb_controller       = new RGBController_AuraMonitor(controller);
         rgb_controller->name                            = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -263,70 +280,80 @@ void DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
 /*-----------------------------------------------------------------*\
 |  MOTHERBOARDS                                                     |
 \*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_1_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_2_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_3_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_4_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",               DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_1_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",               DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_2_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",               DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_3_PID);
+REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",                       DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_1_PID);
+REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",                       DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_2_PID);
+REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",                       DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_3_PID);
+REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",                       DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_4_PID);
+REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_1_PID);
+REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_2_PID);
+REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_3_PID);
 
 /*-----------------------------------------------------------------*\
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",           DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,              1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,           1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                 1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,         1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                 1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",             DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,              1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL",            DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID,             1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7",                  DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                   1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                  DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                   1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",                   DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,                  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,               1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                     1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,             1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                     1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",                     DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,                  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL",                    DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID,                 1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                       1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                       1,  0xFF00);
 
 /*-----------------------------------------------------------------*\
 |  MICE                                                             |
 \*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,             0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,                  2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin",          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID,           2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID,   2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID,       2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,       1,  0xFF13);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,       2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",         DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,            0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,             0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram Core",               DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID,                0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_PID,                       2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,              0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,           0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact",               DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID,                0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PID,             0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS,                           0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless USB",         DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_USB_PID,          0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless 2.4Ghz",      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_2_4_PID,          0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless Bluetooth",   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_BT_PID,           0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3",                  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M3_PID,                          1,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M5_PID,                          2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,                 0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",                         DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,                      2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin",                  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID,               2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID,       2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID,           2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,           1,  0xFF13);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,           2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless USB",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_USB_PID,        0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless 2.4Ghz",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID,        0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth",     DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_BT_PID,         0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,                0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,                 0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram Core",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID,                    0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio",                              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_PID,                           2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",                   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,                  0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,               0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID,                    0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PID,                 0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Gundam",             DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID,          0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Electro Punk",       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PUNK_PID,            0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Moonlight White",    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WHITE_PID,           0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless USB",       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_USB_PID,    0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Wireless 2.4 Ghz",   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_WIRELESS_2_4_PID,    0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris",                              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS,                               0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless USB",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_USB_PID,              0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless 2.4Ghz",              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_2_4_PID,              0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless Bluetooth",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_BT_PID,               0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3",                          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M3_PID,                              1,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M5_PID,                              2,  0xFF01);
 
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Evolve",               DetectAsusAuraUSBStrixEvolve,   AURA_USB_VID, AURA_ROG_STRIX_EVOLVE_PID,                1,  0x0008);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Evolve",                       DetectAsusAuraUSBStrixEvolve,   AURA_USB_VID, AURA_ROG_STRIX_EVOLVE_PID,                    1,  0x0008);
 
 /*-----------------------------------------------------------------*\
 | MOUSEMATS                                                         |
 \*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus",                    DetectAsusAuraUSBMousemats,     AURA_USB_VID, AURA_ROG_BALTEUS_PID,                     0xFF06, 1);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus Qi",                 DetectAsusAuraUSBMousemats,     AURA_USB_VID, AURA_ROG_BALTEUS_QI_PID,                  0xFF06, 1);
+REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus",                            DetectAsusAuraUSBMousemats,     AURA_USB_VID, AURA_ROG_BALTEUS_PID,                         0xFF06, 1);
+REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus Qi",                         DetectAsusAuraUSBMousemats,     AURA_USB_VID, AURA_ROG_BALTEUS_QI_PID,                      0xFF06, 1);
 
 /*-----------------------------------------------------------------*\
 | MONITORS                                                          |
 \*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQ",               DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27AQ_PID,                0xFFA0, 1);
+REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQ",                       DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27AQ_PID,                    0xFFA0, 1);
+REGISTER_HID_DETECTOR_PU("ASUS ROG PG32UQ",                             DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_PG32UQ_PID,                          0xFFA0, 1);
 
 /*-----------------------------------------------------------------*\
 |  OTHER                                                            |
 \*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR    ("ASUS ROG AURA Terminal",             DetectAsusAuraUSBTerminal,      AURA_USB_VID, AURA_TERMINAL_PID);
-REGISTER_HID_DETECTOR_PU ("ASUS ROG Strix LC",                  DetectAsusAuraUSBROGStrixLC,    AURA_USB_VID, ROG_STRIX_LC120_PID,                      0x00FF, 1);
-REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne",                    DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_PID,                      0);
-REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI",                 DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID,                   0);
-REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI GUNDAM",          DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_GUNDAM_PID,            0);
+REGISTER_HID_DETECTOR    ("ASUS ROG AURA Terminal",                     DetectAsusAuraUSBTerminal,      AURA_USB_VID, AURA_TERMINAL_PID);
+REGISTER_HID_DETECTOR_PU ("ASUS ROG Strix LC",                          DetectAsusAuraUSBROGStrixLC,    AURA_USB_VID, ROG_STRIX_LC120_PID,                          0x00FF, 1);
+REGISTER_HID_DETECTOR_PU ("ASUS ROG Ryuo AIO",                          DetectAsusAuraUSBRyuoAIO,       AURA_USB_VID, AURA_RYUO_AIO_PID,                        0xFF72, 0x00A1);
+REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne",                            DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_PID,                          0);
+REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI",                         DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID,                       0);
+REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI GUNDAM",                  DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_GUNDAM_PID,                0);

Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp

@@ -11,6 +11,7 @@
 
 /**------------------------------------------------------------------*\
     @name Asus Aura Headset Stand
+    @category HeadsetStand
     @type USB
     @save :white_check_mark:
     @direct :white_check_mark:

Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp

@@ -40,7 +40,7 @@ static unsigned int scope_tkl_matrix_map[6][18] =
 static unsigned int falchion_matrix_map[5][16] =
     { {   0,   5,   9,  14,  18,  22,  26,  31,  35,  39,  44,  49,  54,  58,  NA,  63 },
       {   1,  NA,   6,  10,  15,  19,  23,  27,  32,  36,  40,  45,  50,  55,  59,  64 },
-      {   2,  NA,   7,  11,  16,  20,  24,  28,  33,  37,  41,  46,  51,  60,  NA,  65 }, 
+      {   2,  NA,   7,  11,  16,  20,  24,  28,  33,  37,  41,  46,  51,  60,  NA,  65 },
       {   3,  NA,  12,  17,  21,  25,  29,  34,  38,  42,  47,  52,  56,  NA,  61,  66 },
       {   4,   8,  13,  NA,  NA,  NA,  30,  NA,  NA,  NA,  43,  48,  53,  57,  62,  67 } };
 
@@ -345,6 +345,7 @@ static const std::vector<led_type> default_65pct_led_names =
 
 /**------------------------------------------------------------------*\
     @name Asus Aura Keyboard
+    @category Keyboard
     @type USB
     @save :x:
     @direct :white_check_mark:

Controllers/AsusAuraUSBController/RGBController_AsusAuraMonitor.cpp

@@ -11,6 +11,7 @@
 
 /**------------------------------------------------------------------*\
     @name Asus Aura Monitor
+    @category LEDStrip
     @type USB
     @save :x:
     @direct :white_check_mark:
@@ -79,6 +80,8 @@ void RGBController_AuraMonitor::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AuraMonitor::DeviceUpdateLEDs()
 {
+    controller->BeginUpdate();
+
     for (int i = 0; i < 3; i++)
     {
         unsigned char red   = RGBGetRValue(colors[i]);
@@ -98,6 +101,8 @@ void RGBController_AuraMonitor::UpdateZoneLEDs(int /*zone*/)
 
 void RGBController_AuraMonitor::UpdateSingleLED(int led)
 {
+    controller->BeginUpdate();
+
     unsigned char red   = RGBGetRValue(colors[led]);
     unsigned char green = RGBGetGValue(colors[led]);
     unsigned char blue  = RGBGetBValue(colors[led]);

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp

@@ -18,6 +18,7 @@ static std::string aura_mouse_zone_names[3]
 
 /**------------------------------------------------------------------*\
     @name Asus Aura Mouse
+    @category Mouse
     @type USB
     @save :white_check_mark:
     @direct :white_check_mark:
@@ -54,9 +55,9 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
                     Direct.name                 = "Direct";
                     Direct.value                = mode_value;
                     Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-                    Direct.brightness_min       = AURA_MOUSE_BRIGHTNESS_MIN;
-                    Direct.brightness_max       = AURA_MOUSE_BRIGHTNESS_MAX;
-                    Direct.brightness           = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Direct.brightness_min       = aura_mouse_devices[pid].brightness_min;
+                    Direct.brightness_max       = aura_mouse_devices[pid].brightness_max;
+                    Direct.brightness           = aura_mouse_devices[pid].brightness_max;
                     Direct.color_mode           = MODE_COLORS_PER_LED;
                     modes.push_back(Direct);
                 }
@@ -68,9 +69,9 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
                     Breathing.name              = "Breathing";
                     Breathing.value             = mode_value;
                     Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-                    Breathing.brightness_min    = AURA_MOUSE_BRIGHTNESS_MIN;
-                    Breathing.brightness_max    = AURA_MOUSE_BRIGHTNESS_MAX;
-                    Breathing.brightness        = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Breathing.brightness_min    = aura_mouse_devices[pid].brightness_min;
+                    Breathing.brightness_max    = aura_mouse_devices[pid].brightness_max;
+                    Breathing.brightness        = aura_mouse_devices[pid].brightness_max;
                     Breathing.color_mode        = MODE_COLORS_PER_LED;
                     modes.push_back(Breathing);
                 }
@@ -82,9 +83,9 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
                     ColorCycle.name             = "Spectrum Cycle";
                     ColorCycle.value            = mode_value;
                     ColorCycle.flags            = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE ;
-                    ColorCycle.brightness_min   = AURA_MOUSE_BRIGHTNESS_MIN;
-                    ColorCycle.brightness_max   = AURA_MOUSE_BRIGHTNESS_MAX;
-                    ColorCycle.brightness       = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    ColorCycle.brightness_min   = aura_mouse_devices[pid].brightness_min;
+                    ColorCycle.brightness_max   = aura_mouse_devices[pid].brightness_max;
+                    ColorCycle.brightness       = aura_mouse_devices[pid].brightness_max;
                     ColorCycle.color_mode       = MODE_COLORS_NONE;
                     modes.push_back(ColorCycle);
                 }
@@ -100,9 +101,9 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
                     Wave.speed_min              = aura_mouse_devices[pid].speed_min;
                     Wave.speed_max              = aura_mouse_devices[pid].speed_max;
                     Wave.speed                  = (aura_mouse_devices[pid].speed_min + aura_mouse_devices[pid].speed_max) / 2;
-                    Wave.brightness_min         = AURA_MOUSE_BRIGHTNESS_MIN;
-                    Wave.brightness_max         = AURA_MOUSE_BRIGHTNESS_MAX;
-                    Wave.brightness             = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Wave.brightness_min         = aura_mouse_devices[pid].brightness_min;
+                    Wave.brightness_max         = aura_mouse_devices[pid].brightness_max;
+                    Wave.brightness             = aura_mouse_devices[pid].brightness_max;
                     Wave.color_mode             = MODE_COLORS_NONE;
                     modes.push_back(Wave);
                 }
@@ -114,9 +115,9 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
                     Reactive.name               = "Reactive";
                     Reactive.value              = mode_value;
                     Reactive.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-                    Reactive.brightness_min     = AURA_MOUSE_BRIGHTNESS_MIN;
-                    Reactive.brightness_max     = AURA_MOUSE_BRIGHTNESS_MAX;
-                    Reactive.brightness         = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Reactive.brightness_min     = aura_mouse_devices[pid].brightness_min;
+                    Reactive.brightness_max     = aura_mouse_devices[pid].brightness_max;
+                    Reactive.brightness         = aura_mouse_devices[pid].brightness_max;
                     Reactive.color_mode         = MODE_COLORS_PER_LED;
                     modes.push_back(Reactive);
                 }
@@ -128,9 +129,9 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
                     Comet.name                  = "Comet";
                     Comet.value                 = mode_value;
                     Comet.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-                    Comet.brightness_min        = AURA_MOUSE_BRIGHTNESS_MIN;
-                    Comet.brightness_max        = AURA_MOUSE_BRIGHTNESS_MAX;
-                    Comet.brightness            = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Comet.brightness_min        = aura_mouse_devices[pid].brightness_min;
+                    Comet.brightness_max        = aura_mouse_devices[pid].brightness_max;
+                    Comet.brightness            = aura_mouse_devices[pid].brightness_max;
                     Comet.color_mode            = MODE_COLORS_MODE_SPECIFIC;
                     Comet.direction             = 0;
                     Comet.colors_min            = 1;
@@ -146,9 +147,9 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
                     BatteryMode.name            = "Battery";
                     BatteryMode.value           = mode_value;
                     BatteryMode.flags           = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-                    BatteryMode.brightness_min  = AURA_MOUSE_BRIGHTNESS_MIN;
-                    BatteryMode.brightness_max  = AURA_MOUSE_BRIGHTNESS_MAX;
-                    BatteryMode.brightness      = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    BatteryMode.brightness_min  = aura_mouse_devices[pid].brightness_min;
+                    BatteryMode.brightness_max  = aura_mouse_devices[pid].brightness_max;
+                    BatteryMode.brightness      = aura_mouse_devices[pid].brightness_max;
                     BatteryMode.color_mode      = MODE_COLORS_NONE;
                     modes.push_back(BatteryMode);
                 }

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.h

@@ -11,12 +11,6 @@
 #include "RGBController.h"
 #include "AsusAuraMouseController.h"
 
-enum {
-    AURA_MOUSE_BRIGHTNESS_MIN     = 0,
-    AURA_MOUSE_BRIGHTNESS_MAX     = 4,
-    AURA_MOUSE_BRIGHTNESS_DEFAULT = 4
-};
-
 class RGBController_AuraMouse : public RGBController
 {
 public:

Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.cpp

@@ -11,6 +11,7 @@
 
 /**------------------------------------------------------------------*\
     @name Asus Aura Mousemat
+    @category Mousemat
     @type USB
     @save :white_check_mark:
     @direct :white_check_mark:
@@ -259,7 +260,7 @@ void RGBController_AuraMousemat::DeviceUpdateMode()
             case AURA_MOUSEMAT_MODE_WAVE:
                 pattern = modes[active_mode].colors.size() * 16 + modes[active_mode].direction;
                 break;
-            case AURA_MOUSEMAT_MODE_WAVE_PLANE:       
+            case AURA_MOUSEMAT_MODE_WAVE_PLANE:
                 switch(modes[active_mode].direction)
                 {
                     case MODE_DIRECTION_LEFT:

Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.cpp

@@ -0,0 +1,223 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_AsusAuraRyuoAIO.cpp                                  |
+|                                                                     |
+|  Driver for the ASUS Aura Ryuo AIO                                  |
+|    lighting controller                                              |
+|                                                                     |
+|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
+|  using snipets from Chris M (Dr.No)                                 |
+\*-------------------------------------------------------------------*/
+
+#include "RGBControllerKeyNames.h"
+#include "RGBController_AsusAuraRyuoAIO.h"
+
+/**------------------------------------------------------------------*\
+    @name Asus Aura Ryuo AIO 
+    @type USB
+    @save :white_check_mark:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAsusAuraUSBMousemats
+    @category Cooler
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AsusAuraRyuoAIO::RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOController *controller_ptr)
+{
+    controller                  = controller_ptr;
+    uint8_t speed               = controller->SPEED_NORMAL;
+
+    name                        = "ROG Ryuo AIO";
+    vendor                      = "ASUS";
+    type                        = DEVICE_TYPE_COOLER;
+    description                 = "ASUS Liquid Cooler with 120mm and 240mm radiators.";
+    location                    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = controller->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                = controller->MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(Static.colors_max);
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = controller->MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
+    Breathing.colors.resize(Breathing.colors_max);
+    Breathing.brightness_min    = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Breathing.brightness        = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Breathing.speed_min         = controller->SPEED_SLOWEST;
+    Breathing.speed_max         = controller->SPEED_FASTEST;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed             = speed;
+    modes.push_back(Breathing);
+
+    mode Flashing;
+    Flashing.name               = "Flashing";
+    Flashing.value              = controller->MODE_FLASHING;
+    Flashing.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Flashing.colors_min         = 1;
+    Flashing.colors_max         = 1;
+    Flashing.colors.resize(Flashing.colors_max);
+    Flashing.brightness_min     = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
+    Flashing.brightness_max     = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Flashing.brightness         = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Flashing.speed_min          = controller->SPEED_SLOWEST;
+    Flashing.speed_max          = controller->SPEED_FASTEST;
+    Flashing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Flashing.speed              = speed;
+    modes.push_back(Flashing);
+
+    mode Spectrum;
+    Spectrum.name               = "Spectrum";
+    Spectrum.value              = controller->MODE_SPECTRUM;
+    Spectrum.flags              = MODE_FLAG_HAS_SPEED;
+    Spectrum.brightness_min     = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
+    Spectrum.brightness_max     = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Spectrum.brightness         = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Spectrum.speed_min          = controller->SPEED_SLOWEST;
+    Spectrum.speed_max          = controller->SPEED_FASTEST;
+    Spectrum.color_mode         = MODE_COLORS_NONE;
+    Spectrum.speed              = speed;
+    modes.push_back(Spectrum);
+
+    mode Rainbow;
+    Rainbow.name                = "Rainbow";
+    Rainbow.value               = controller->MODE_RAINBOW;
+    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Rainbow.brightness_min      = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
+    Rainbow.brightness_max      = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Rainbow.brightness          = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    Rainbow.speed_min           = controller->SPEED_SLOWEST;
+    Rainbow.speed_max           = controller->SPEED_FASTEST;
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    Rainbow.speed               = speed;
+    modes.push_back(Rainbow);
+
+    mode FlashAndDash;
+    FlashAndDash.name           = "Flash and Dash";
+    FlashAndDash.value          = controller->MODE_FLASHANDDASH;
+    FlashAndDash.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    FlashAndDash.brightness_min = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
+    FlashAndDash.brightness_max = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    FlashAndDash.brightness     = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
+    FlashAndDash.speed_min      = controller->SPEED_SLOWEST;
+    FlashAndDash.speed_max      = controller->SPEED_FASTEST;
+    FlashAndDash.color_mode     = MODE_COLORS_NONE;
+    FlashAndDash.speed          = speed;
+    modes.push_back(FlashAndDash);
+
+    SetupZones();
+}
+
+RGBController_AsusAuraRyuoAIO::~RGBController_AsusAuraRyuoAIO()
+{
+    delete controller;
+}
+
+void RGBController_AsusAuraRyuoAIO::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Set up zones                                      |
+    \*-------------------------------------------------*/
+    LOG_DEBUG("[%s] - Get channel count: %i", name.c_str(), controller->GetChannelCount());
+
+    zones.resize(controller->GetChannelCount());
+
+    LOG_DEBUG("[%s] - Creating Zones and LEDs", name.c_str());
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        AuraDeviceInfo device_info = controller->GetAuraDevices()[zone_idx];
+        LOG_INFO("[%s] %s Zone %i - Header Count %i LED Count %i FX %02X Direct %02X", name.c_str(),
+                 ((device_info.device_type == AuraDeviceType::FIXED) ? "Fixed" : "Addressable"),
+                 zone_idx, device_info.num_headers, device_info.num_leds, device_info.effect_channel, device_info.direct_channel);
+
+        zones[zone_idx].name = name + " Zone ";
+        zones[zone_idx].name.append(std::to_string(zone_idx));
+        zones[zone_idx].type = ZONE_TYPE_LINEAR;
+        zones[zone_idx].leds_min = device_info.num_leds;
+        zones[zone_idx].leds_max = device_info.num_leds;
+        zones[zone_idx].leds_count = device_info.num_leds;
+
+        for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
+        {
+            led new_led;
+
+            new_led.name = zones[zone_idx].name;
+            new_led.name.append(" LED " + std::to_string(lp_idx));
+            new_led.value = lp_idx;
+
+            leds.push_back(new_led);
+        }
+    }
+
+    LOG_DEBUG("[%s] - Device zones and LEDs set", name.c_str());
+    SetupColors();
+}
+
+void RGBController_AsusAuraRyuoAIO::ResizeZone(int zone, int new_size)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AsusAuraRyuoAIO::DeviceUpdateLEDs()
+{
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        UpdateZoneLEDs(zone_idx);
+    }
+}
+
+void RGBController_AsusAuraRyuoAIO::UpdateZoneLEDs(int zone)
+{
+    controller->SetLedsDirect(zones[zone].colors, zones[zone].leds_count);
+}
+
+void RGBController_AsusAuraRyuoAIO::UpdateSingleLED(int led)
+{
+    UpdateZoneLEDs(GetLED_Zone(led));
+}
+
+void RGBController_AsusAuraRyuoAIO::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_AsusAuraRyuoAIO::DeviceUpdateMode()
+{
+    RGBColor colour = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
+
+    controller->SetMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, colour);
+}
+
+int RGBController_AsusAuraRyuoAIO::GetLED_Zone(int led_idx)
+{
+    for(size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        int zone_start = zones[zone_idx].start_idx;
+        int zone_end = zone_start + zones[zone_idx].leds_count - 1;
+
+        if( zone_start <= led_idx && zone_end >= led_idx)
+        {
+            return(zone_idx);
+        }
+    }
+
+    return -1;
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.h

@@ -0,0 +1,38 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_AsusAuraRyuoAIO.h                                    |
+|                                                                     |
+|  Driver for the ASUS Aura Ryuo AIO                                  |
+|    lighting controller                                              |
+|                                                                     |
+|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
+|  using snipets from Chris M (Dr.No)                                 |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "LogManager.h"
+#include "RGBController.h"
+#include "AsusAuraRyuoAIOController.h"
+#include <vector>
+
+class RGBController_AsusAuraRyuoAIO : public RGBController
+{
+public:
+    RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOController* controller_ptr);
+    ~RGBController_AsusAuraRyuoAIO();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
+
+    void SetCustomMode();
+    void DeviceUpdateMode();
+private:
+    int  GetDeviceMode();
+    int  GetLED_Zone(int led_idx);
+
+    AsusAuraRyuoAIOController* controller;
+};
+

Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp

@@ -11,6 +11,7 @@
 
 /**------------------------------------------------------------------*\
     @name Asus Aura Strix Evolve
+    @category Mouse
     @type USB
     @save :white_check_mark:
     @direct :white_check_mark:

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -13,6 +13,7 @@
 
 /**------------------------------------------------------------------*\
     @name Asus Aura TUF Keyboard
+    @category Keyboard
     @type USB
     @save :white_check_mark:
     @direct :white_check_mark:
@@ -276,7 +277,7 @@ void RGBController_AuraTUFKeyboard::SetCustomMode()
 }
 
 void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
-{   
+{
     unsigned char color_mode;
     std::vector<RGBColor> mode_colors;
 

Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -11,12 +11,13 @@
 
 /**------------------------------------------------------------------*\
     @name Asus Aura USB
+    @category Motherboard
     @type USB
     @save :x:
     @direct :white_check_mark:
     @effects :white_check_mark:
     @detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable,DetectAsusAuraUSBMotherboards
-    @comment The Asus AUra USB controller applies to most AMD and
+    @comment The Asus Aura USB controller applies to most AMD and
         Intel mainboards from the x470 and z390 chipsets onwards.
 \*-------------------------------------------------------------------*/
 

Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.cpp

@@ -13,6 +13,7 @@
 
 /**------------------------------------------------------------------*\
     @name Asus ROG Strix Liquid Cooler
+    @category Cooler
     @type USB
     @save :x:
     @direct :white_check_mark:

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.cpp

@@ -12,6 +12,7 @@ using namespace std::chrono_literals;
 
 /**------------------------------------------------------------------*\
     @name Asus TUF Laptop
+    @category Keyboard
     @type WMI
     @save :x:
     @direct :white_check_mark:

Controllers/BlinkyTapeController/BlinkyTapeControllerDetect.cpp

@@ -34,3 +34,8 @@ void DetectBlinkyTapeControllers(std::vector<RGBController*> &rgb_controllers)
 }
 
 REGISTER_DETECTOR("BlinkyTape", DetectBlinkyTapeControllers);
+/*---------------------------------------------------------------------------------------------------------*\
+| Entries for dynamic UDEV rules                                                                            |
+|                                                                                                           |
+| DUMMY_DEVICE_DETECTOR("BlinkyTape", DetectBlinkyTapeControllers, 0x1D50, 0x605E )                         |
+\*---------------------------------------------------------------------------------------------------------*/

Controllers/BlinkyTapeController/RGBController_BlinkyTape.cpp

@@ -10,6 +10,7 @@
 
 /**------------------------------------------------------------------*\
     @name Blinky Tape
+    @category LEDStrip
     @type Serial
     @save :x:
     @direct :white_check_mark:

Controllers/CoolerMasterController/RGBController_CMARGBController.cpp

@@ -11,8 +11,9 @@
 
 /**------------------------------------------------------------------*\
     @name Coolermaster ARGB
+    @category LEDStrip
     @type USB
-    @save :warning:
+    @save :robot:
     @direct :white_check_mark:
     @effects :white_check_mark:
     @detectors DetectCoolerMasterARGB

Controllers/CoolerMasterController/RGBController_CMMKController.cpp

@@ -22,8 +22,9 @@ using namespace std::chrono_literals;
 
 /**------------------------------------------------------------------*\
     @name Coolermaster Masterkeys Keyboards
+    @category Keyboard
     @type USB
-    @save :warning:
+    @save :robot:
     @direct :white_check_mark:
     @effects :white_check_mark:
     @detectors DetectCoolerMasterKeyboards
@@ -41,7 +42,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
     version                     = controller->GetFirmwareVersion();
     serial                      = "";
     location                    = controller->GetLocation();
-    
+
     mode Direct;
     Direct.name                 = "Direct";
     Direct.value                = CMMK_MODE_MANUAL;
@@ -58,7 +59,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
     Static.colors_max           = 1;
     Static.colors.resize(1);
     modes.push_back(Static);
-    
+
     mode Breathing;
     Breathing.name              = "Breathing";
     Breathing.value             = CMMK_EFFECT_BREATHE;
@@ -108,7 +109,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
     Wave.colors_max             = 1;
     Wave.colors.resize(1);
     modes.push_back(Wave);
-    
+
     mode Ripple;
     Ripple.name                 = "Ripple Effect";
     Ripple.value                = CMMK_EFFECT_RIPPLE;
@@ -121,7 +122,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
     Ripple.colors_max           = 2;
     Ripple.colors.resize(2);
     modes.push_back(Ripple);
-    
+
     mode Cross;
     Cross.name                  = "Cross";
     Cross.value                 = CMMK_EFFECT_CROSS;
@@ -147,7 +148,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
     Raindrops.colors_max        = 2;
     Raindrops.colors.resize(2);
     modes.push_back(Raindrops);
-    
+
     mode Stars;
     Stars.name                  = "Starfield";
     Stars.value                 = CMMK_EFFECT_STARS;
@@ -224,7 +225,7 @@ void RGBController_CMMKController::SetupZones()
             std::stringstream namestrm;
 
             led key;
-            
+
             namestrm << "Key @ Row " << (y + 1) << ", Column" << (x + 1);
 
             key.name = namestrm.str();
@@ -365,7 +366,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
         case CMMK_MODE_FIRMWARE:
             controller->SetFirmwareControl();
             break;
-        
+
         case CMMK_MODE_MANUAL:
             controller->SetManualControl();
             break;
@@ -400,7 +401,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                 controller->SetMode(cycle_effect);
             }
             break;
-        
+
         case CMMK_EFFECT_SINGLE:
             {
                 cmmk_effect_single single_effect;
@@ -412,7 +413,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                 controller->SetMode(single_effect);
             }
             break;
-        
+
         case CMMK_EFFECT_WAVE:
             {
                 cmmk_effect_wave wave_effect;
@@ -424,7 +425,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                 controller->SetMode(wave_effect);
             }
             break;
-        
+
         case CMMK_EFFECT_RIPPLE:
             {
                 cmmk_effect_ripple ripple_effect;
@@ -445,7 +446,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                 controller->SetMode(ripple_effect);
             }
             break;
-        
+
         case CMMK_EFFECT_CROSS:
             {
                 cmmk_effect_cross cross_effect;
@@ -457,7 +458,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                 controller->SetMode(cross_effect);
             }
             break;
-        
+
         case CMMK_EFFECT_RAINDROPS:
             {
                 cmmk_effect_raindrops raindrops_effect;
@@ -474,12 +475,12 @@ void RGBController_CMMKController::DeviceUpdateMode()
         case CMMK_EFFECT_STARS:
             {
                 cmmk_effect_stars stars_effect;
-                
+
                 stars_effect.speed      = (uint8_t)modes[active_mode].speed;
                 stars_effect.interval   = CMMK_SPEED_MID;
                 stars_effect.active     = map_to_cmmk_rgb(modes[active_mode].colors[0]);
                 stars_effect.rest       = map_to_cmmk_rgb(modes[active_mode].colors[1]);
-    
+
                 controller->SetMode(stars_effect);
             }
             break;
@@ -487,7 +488,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
         case CMMK_EFFECT_SNAKE:
             {
                 cmmk_effect_snake snake_effect;
-                
+
                 snake_effect.speed = (uint8_t)modes[active_mode].speed;
 
                 controller->SetMode(snake_effect);

Controllers/CoolerMasterController/RGBController_CMMM711Controller.cpp

@@ -13,8 +13,9 @@
 
 /**------------------------------------------------------------------*\
     @name Coolermaster Master Mouse
+    @category Mouse
     @type USB
-    @save :warning:
+    @save :robot:
     @direct :white_check_mark:
     @effects :white_check_mark:
     @detectors DetectCoolerMasterMouse

Controllers/CoolerMasterController/RGBController_CMMMController.cpp

@@ -14,6 +14,7 @@
 
 /**------------------------------------------------------------------*\
     @name Coolermaster Master Mouse
+    @category Mouse
     @type USB
     @save :white_check_mark:
     @direct :white_check_mark:

Controllers/CoolerMasterController/RGBController_CMMP750Controller.cpp

@@ -11,8 +11,9 @@
 
 /**------------------------------------------------------------------*\
     @name Coolermaster Mouse Pad
+    @category Mousemat
     @type USB
-    @save :warning:
+    @save :robot:
     @direct :x:
     @effects :white_check_mark:
     @detectors DetectCoolerMasterMousemats

Controllers/CoolerMasterController/RGBController_CMR6000Controller.cpp

@@ -10,6 +10,7 @@
 
 /**------------------------------------------------------------------*\
     @name AMD Radeon 6000
+    @category GPU
     @type USB
     @save :x:
     @direct :white_check_mark:
@@ -77,7 +78,7 @@ RGBController_CMR6000Controller::RGBController_CMR6000Controller(CMR6000Controll
     Breathing.colors_max = 1;
     Breathing.colors.resize(1);
     Breathing.speed      = speed;
-    modes.push_back(Breathing);    
+    modes.push_back(Breathing);
 
     SetupZones();
     active_mode = 1;

Controllers/CoolerMasterController/RGBController_CMRGBController.cpp

@@ -45,8 +45,9 @@
 
 /**------------------------------------------------------------------*\
     @name Coolermaster RGB
+    @category LEDStrip
     @type USB
-    @save :warning:
+    @save :robot:
     @direct :x:
     @effects :white_check_mark:
     @detectors DetectCoolerMasterRGB

Controllers/CoolerMasterController/RGBController_CMSmallARGBController.cpp

@@ -11,8 +11,9 @@
 
 /**------------------------------------------------------------------*\
     @name Coolermaster Small ARGB
+    @category LEDStrip
     @type USB
-    @save :warning:
+    @save :robot:
     @direct :white_check_mark:
     @effects :white_check_mark:
     @detectors DetectCoolerMasterSmallARGB

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.cpp

@@ -20,6 +20,8 @@ CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_h
     location                = path;
     keepalive_thread_run    = 1;
     controller_ready        = 0;
+    packet_size             = CORSAIR_COMMANDER_CORE_PACKET_SIZE_V2;
+    command_res_size        = packet_size - 4;
 
     /*-----------------------------------------------------*\
     | Initialize controller                                 |
@@ -50,18 +52,38 @@ CorsairCommanderCoreController::~CorsairCommanderCoreController()
 void CorsairCommanderCoreController::InitController()
 {
     /*-----------------------------------------------------*\
-    | Packet sequence to put controller into direct mode    |
+    | Get version                                           |
     \*-----------------------------------------------------*/
-    unsigned char buffarray[][5] =
+    unsigned char command[2] = {0x02, 0x13};
+    unsigned char* res = new unsigned char[command_res_size];
+    SendCommand(command, NULL, 0, res);
+    version[0] = res[0];
+    version[1] = res[1];
+    version[2] = res[2];
+    delete[] res;
+
+    if(version[0] == 1)
     {
-        {0x08, 0x01, 0x03, 0x00, 0x02},
-        {0x08, 0x0D, 0x00, 0x22, 0x00},
-    };
+        packet_size = CORSAIR_COMMANDER_CORE_PACKET_SIZE_V1;
+        command_res_size = packet_size - 4;
+    }
+
+    /*-----------------------------------------------------*\
+    | Wake up device                                        |
+    \*-----------------------------------------------------*/
+    command[0] = 0x01;
+    command[1] = 0x03;
+    unsigned char cmd_data[2] = {0x00, 0x02};
+    SendCommand(command, cmd_data, 2, NULL);
 
-    SendMultiPkt(buffarray, sizeof(buffarray) / sizeof(buffarray[0]), sizeof(buffarray)[0] / sizeof(buffarray[0][0]));
     SetFanMode();
 }
 
+std::string CorsairCommanderCoreController::GetFirmwareString()
+{
+    return "v"+std::to_string(version[0]) + "." + std::to_string(version[1]) + "." + std::to_string(version[2]);
+}
+
 std::string CorsairCommanderCoreController::GetLocationString()
 {
     return("HID: " + location);
@@ -93,56 +115,126 @@ void CorsairCommanderCoreController::SendCommit()
     }
     else
     {
-        unsigned char   usb_buf[1025];
-
-        /*-----------------------------------------------------*\
-        | Zero out buffer                                       |
-        \*-----------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
         /*-----------------------------------------------------*\
         | Update last commit time                               |
         \*-----------------------------------------------------*/
         last_commit_time    = std::chrono::steady_clock::now();
 
         /*-----------------------------------------------------*\
-        | Set up Commit packet                                  |
+        | Send packet                                           |
         \*-----------------------------------------------------*/
-        memset(usb_buf, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
-
-        usb_buf[0]          = 0x00;
-        usb_buf[1]          = 0x08;
-        usb_buf[2]          = 0x06;
-        usb_buf[4]          = 0xBD;
-        usb_buf[5]          = 0x02;
-        usb_buf[8]          = 0x12;
-
-        hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+        unsigned char command[2] = {0x01, 0x03};
+        unsigned char cmd_data[2] = {0x00, 0x02};
+        SendCommand(command, cmd_data, 2, NULL);
     }
 }
 
 
-void CorsairCommanderCoreController::SendMultiPkt(unsigned char buffarray[][5], int r, int c)
+void CorsairCommanderCoreController::SendCommand(unsigned char command[2], unsigned char data[], unsigned short int data_len, unsigned char res[])
 {
     /*---------------------------------------------------------*\
-    | Private function to send multiple packets                 |
+    | Private function to send a command                        |
+    | data_len must be <= 93 for V2 or <= 1021 for V1           |
     \*---------------------------------------------------------*/
-    unsigned char* hidtemp = new unsigned char[CORSAIR_COMMANDER_CORE_PACKET_SIZE];
+    unsigned char* buf = new unsigned char[packet_size];
 
-    for(unsigned int i = 0; i < r; i++)
+    memset(buf, 0, packet_size);
+    buf[0] = 0x00;
+    buf[1] = 0x08;
+
+    memcpy(&buf[2], command, 2);
+    if(data != NULL)
     {
-        memset(hidtemp, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
-    
-        for(unsigned int j = 0; j < c; j++)
-        {
-            hidtemp[j+1] = buffarray[i][j];
-        }
-
-        hid_write(dev, hidtemp, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
-        hid_read(dev, hidtemp, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+        memcpy(&buf[4], data, data_len);
     }
 
-    delete[] hidtemp;
+    hid_write(dev, buf, packet_size);
+    do
+    {
+        hid_read(dev, buf, packet_size);
+    }
+    while (buf[0] != 0x00);
+
+    if(res != NULL)
+    {
+        memcpy(res, &buf[3], command_res_size);
+    }
+
+    delete[] buf;
+}
+
+void CorsairCommanderCoreController::WriteData(unsigned char endpoint[2], unsigned char data_type[2], unsigned char data[], unsigned short int data_len)
+{
+    /*---------------------------------------------------------*\
+    | Private function to write data to an endpoint             |
+    \*---------------------------------------------------------*/
+
+    /*---------------------------------------------------------*\
+    | Open endpoint                                             |
+    \*---------------------------------------------------------*/
+    unsigned char command[2] = {0x0d, 0x00};
+    SendCommand(command, endpoint, 2, NULL);
+
+
+    /*---------------------------------------------------------*\
+    | Write data                                                |
+    \*---------------------------------------------------------*/
+    unsigned short int data_start_index = 0;
+    while(data_start_index < data_len)
+    {
+        if(data_start_index == 0)
+        {
+            /*---------------------------------------------------------*\
+            | First packet                                              |
+            \*---------------------------------------------------------*/
+            int packet_data_len = packet_size - 10;
+            if(data_len < packet_data_len)
+            {
+                packet_data_len = data_len;
+            }
+            unsigned char* buf = new unsigned char[packet_data_len+6];
+            unsigned short int real_len = data_len+2;
+            /*---------------------------------------------------------*\
+            | Convert length to little endian                           |
+            \*---------------------------------------------------------*/
+            buf[0] = (unsigned char) real_len & 0xFF;
+            buf[1] = (unsigned char) (real_len >> 8) & 0xFF;
+            buf[2] = 0x00;
+            buf[3] = 0x00;
+            memcpy(&buf[4], data_type, 2);
+            memcpy(&buf[6], data, packet_data_len);
+
+            command[0] = 0x06;
+            command[1] = 0x00;
+            SendCommand(command, buf, packet_data_len+6, NULL);
+            delete[] buf;
+            data_start_index += packet_data_len;
+        }
+        else
+        {
+            /*-----------------------------------------------------------------------------------------------------*\
+            | The rest of the packets                                                                               |
+            | This command is not in v1 but it should never be reached as all data should fit in the first packet   |
+            \*-----------------------------------------------------------------------------------------------------*/
+            int packet_data_len = packet_size - 4;
+            if(data_len-data_start_index < packet_data_len)
+            {
+                packet_data_len = data_len-data_start_index;
+            }
+
+            command[0] = 0x07;
+            command[1] = 0x00;
+            SendCommand(command, &data[data_start_index], packet_data_len, NULL);
+            data_start_index += packet_data_len;
+        }
+    }
+
+    /*---------------------------------------------------------*\
+    | Close endpoint                                            |
+    \*---------------------------------------------------------*/
+    command[0] = 0x05;
+    command[1] = 0x01;
+    SendCommand(command, NULL, 0, NULL);
 }
 
 void CorsairCommanderCoreController::SetDirectColor
@@ -155,22 +247,12 @@ void CorsairCommanderCoreController::SetDirectColor
     {
         lastcolors              = colors;
         lastzones               = zones;
-        int packet_offset       = CORSAIR_COMMANDER_CORE_PREAMBLE_OFFSET;
+        int packet_offset       = 0;
         int led_idx             = 0;
         int channel_idx         = 0;
-        unsigned char* usb_buf  = new unsigned char[CORSAIR_COMMANDER_CORE_PACKET_SIZE];
+        unsigned char* usb_buf  = new unsigned char[CORSAIR_COMMANDER_CORE_RGB_DATA_LENGTH];
 
-        memset(usb_buf, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
-
-        /*-----------------------------------------------------*\
-        | Prepare color information packet                      |
-        \*-----------------------------------------------------*/
-        usb_buf[0]              = 0x00;
-        usb_buf[1]              = 0x08;
-        usb_buf[2]              = 0x06;
-        usb_buf[4]              = 0xBD;
-        usb_buf[5]              = 0x02;
-        usb_buf[8]              = 0x12;
+        memset(usb_buf, 0, CORSAIR_COMMANDER_CORE_RGB_DATA_LENGTH);
 
         for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
         {
@@ -183,25 +265,24 @@ void CorsairCommanderCoreController::SetDirectColor
                 usb_buf[packet_offset+1] = RGBGetGValue(colors[i]);
                 usb_buf[packet_offset+2] = RGBGetBValue(colors[i]);
 
-                packet_offset = packet_offset + 3;
+                packet_offset += 3;
             }
 
             led_idx = led_idx + zones[zone_idx].leds_count;
 
             /*-------------------------------------------------*\
-            | Move offset for pump zone with less than 33 LEDs  |
+            | Move offset for pump zone with less than 29 LEDs  |
             \*-------------------------------------------------*/
             if(zone_idx == 0)
             {
-                packet_offset = packet_offset + 3 * (33 - zones[zone_idx].leds_count);
+                packet_offset += 3 * (29 - zones[zone_idx].leds_count);
             }
-
+            else
+            {
             /*-------------------------------------------------*\
             | Move offset for fans with less than 34 LEDs       |
             \*-------------------------------------------------*/
-            if(zone_idx != 0)
-            {
-                packet_offset = packet_offset + 3 * (34 - zones[zone_idx].leds_count);
+                packet_offset += 3 * (34 - zones[zone_idx].leds_count);
             }
 
             channel_idx++;
@@ -212,7 +293,9 @@ void CorsairCommanderCoreController::SetDirectColor
         \*-----------------------------------------------------*/
         last_commit_time = std::chrono::steady_clock::now();
 
-        hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+        unsigned char endpoint[2] = {0x22, 0x00};
+        unsigned char data_type[2] = {0x12, 0x00};
+        WriteData(endpoint, data_type, usb_buf, packet_offset);
 
         delete[] usb_buf;
     }
@@ -224,57 +307,27 @@ void CorsairCommanderCoreController::SetFanMode()
     | Force controller to 6 QL fan mode to expose maximum number of LEDs per rgb port (34 LEDs per port) |
     \*--------------------------------------------------------------------------------------------------*/
 
-    unsigned char usb_buf[1025];
+    unsigned char endpoint[2]  = {0x1E, 0x00};
+    unsigned char data_type[2] = {0x0D, 0x00};
+    unsigned char buf[15];
 
-    unsigned char buffarray4[][5] =
+    /*-----------------------------------------------------*\
+    | Set AIO mode                                          |
+    \*-----------------------------------------------------*/
+    buf[0]         = 0x07;
+    buf[1]         = 0x01;
+    buf[2]         = 0x08;
+
+    /*-----------------------------------------------------*\
+    | SET fan modes                                         |
+    \*-----------------------------------------------------*/
+    for(unsigned int i = 3; i < 15; i = i + 2)
     {
-        {0x08, 0x05, 0x01, 0x01, 0x00},
-        {0x08, 0x0D, 0x01, 0x1E, 0x00},
-        {0x08, 0x09, 0x01, 0x00, 0x00}
-    };
-
-    SendMultiPkt(buffarray4, sizeof(buffarray4) / sizeof(buffarray4[0]), sizeof(buffarray4)[0] / sizeof(buffarray4[0][0]));
-
-    memset(usb_buf, 0, sizeof(usb_buf));
-
-    usb_buf[0]          = 0x00;
-    usb_buf[1]          = 0x08;
-    usb_buf[2]          = 0x06;
-    usb_buf[3]          = 0x01;
-    usb_buf[4]          = 0x11;
-    usb_buf[8]          = 0x0D;
-    usb_buf[10]         = 0x07;
-    usb_buf[11]         = 0x01;
-    usb_buf[12]         = 0x08;
-
-    for(unsigned int i = 13; i < 25; i = i + 2)
-    {
-        usb_buf[i]      = 0x01;
-        usb_buf[i + 1]  = 0x06;
+        buf[i]      = 0x01;
+        buf[i + 1]  = 0x06;
     }
 
-    hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
-    hid_read(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
-
-    unsigned char buffarray2[][5] =
-    {
-        {0x08, 0x05, 0x01, 0x01, 0x00},
-        {0x08, 0x15, 0x01, 0x00, 0x00}
-    };
-
-    SendMultiPkt(buffarray2, sizeof(buffarray2) / sizeof(buffarray2[0]), sizeof(buffarray2)[0] / sizeof(buffarray2[0][0]));
-
-    memset(usb_buf, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
-
-    usb_buf[0]          = 0x00;
-    usb_buf[1]          = 0x08;
-    usb_buf[2]          = 0x06;
-    usb_buf[4]          = 0xBD;
-    usb_buf[5]          = 0x02;
-    usb_buf[8]          = 0x12;
-
-    hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
-    hid_read(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    WriteData(endpoint, data_type, buf, 15);
     
     controller_ready    = 1;
 }

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.h

@@ -15,9 +15,9 @@
 
 #pragma once
 
-#define CORSAIR_COMMANDER_CORE_PACKET_SIZE      1025
-#define CORSAIR_COMMANDER_CORE_PREAMBLE_OFFSET  10
-#define CORSAIR_ELITE_CAPELLIX_PUMP_LED_OFFSET  87
+#define CORSAIR_COMMANDER_CORE_PACKET_SIZE_V1   1025 // First bit is the report bit
+#define CORSAIR_COMMANDER_CORE_PACKET_SIZE_V2   97   // First bit is the report bit
+#define CORSAIR_COMMANDER_CORE_RGB_DATA_LENGTH  699
 #define CORSAIR_QL_FAN_ZONE_OFFSET              102
 #define CORSAIR_COMMANDER_CORE_NUM_CHANNELS     6
 
@@ -32,6 +32,7 @@ public:
     CorsairCommanderCoreController(hid_device* dev_handle, const char* path);
     ~CorsairCommanderCoreController();
 
+    std::string GetFirmwareString();
     std::string GetLocationString();
 
     void        SetDirectColor
@@ -51,14 +52,13 @@ private:
     std::string             location;
     std::vector<RGBColor>   lastcolors;
     std::vector<zone>       lastzones;
+    unsigned short int      version[3] = {0, 0, 0};
+    int                     packet_size;
+    int                     command_res_size;
     std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
 
-    void        SendMultiPkt
-                (
-                    unsigned char buffarray[][5],
-                    int r,
-                    int c
-                );
+    void        SendCommand(unsigned char command[2], unsigned char data[], unsigned short int data_len, unsigned char res[]);
+    void        WriteData(unsigned char endpoint[2], unsigned char data_type[2], unsigned char data[], unsigned short int data_len);
 
     void        SendCommit();
     void        InitController();

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreControllerDetect.cpp

@@ -13,7 +13,7 @@
 /*-----------------------------------------------------*\
 | Commander Core product IDs                            |
 \*-----------------------------------------------------*/
-#define CORSAIR_H150I_COMMANDER_CORE_PID    0x0C1C
+#define CORSAIR_COMMANDER_CORE_PID          0x0C1C
 
 /******************************************************************************************\
 *                                                                                          *
@@ -38,4 +38,4 @@ void DetectCorsairCapellixHIDControllers(hid_device_info* info, const std::strin
     }
 }
 
-REGISTER_HID_DETECTOR_PU("Corsair Commander Core",  DetectCorsairCapellixHIDControllers, CORSAIR_VID, CORSAIR_H150I_COMMANDER_CORE_PID, 0xFF42, 0x01);
+REGISTER_HID_DETECTOR_IPU("Corsair Commander Core",  DetectCorsairCapellixHIDControllers, CORSAIR_VID, CORSAIR_COMMANDER_CORE_PID, 0x00, 0xFF42, 0x01);

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.cpp

@@ -11,6 +11,7 @@
 
 /**------------------------------------------------------------------*\
     @name Corsair Commander Core
+    @category Cooler
     @type USB
     @save :x:
     @direct :white_check_mark:
@@ -19,12 +20,25 @@
     @comment
 \*-------------------------------------------------------------------*/
 
+#define NA 0xFFFFFFFF
+static unsigned int matrix_map[7][7] =
+{
+    { 28,  NA,  27,  NA,  26,  NA,  25 },
+    { NA,  16,  NA,  15,  NA,  14,  NA },
+    { 17,  NA,   0,   5,   3,  NA,  24 },
+    { NA,   9,   4,   8,   6,  13,  NA },
+    { 18,  NA,   1,   7,   2,  NA,  23 },
+    { NA,  10,  NA,  11,  NA,  12,  NA },
+    { 19,  NA,  20,  NA,  21,  NA,  22 },
+};
+
 RGBController_CorsairCommanderCore::RGBController_CorsairCommanderCore(CorsairCommanderCoreController* controller_ptr)
 {
     controller  = controller_ptr;
 
     vendor      = "Corsair";
     description = "Corsair Commander Core";
+    version     = controller->GetFirmwareString();
     type        = DEVICE_TYPE_COOLER;
     location    = controller->GetLocationString();
 
@@ -55,9 +69,14 @@ void RGBController_CorsairCommanderCore::SetupZones()
 
     zones.resize(7);
     zones[0].name                   = "Pump";
-    zones[0].type                   = ZONE_TYPE_LINEAR;
-    zones[0].leds_min               = 0;
-    zones[0].leds_max               = 33;
+    zones[0].type                   = ZONE_TYPE_MATRIX;
+    zones[0].leds_min               = 29;
+    zones[0].leds_max               = 29;
+    zones[0].leds_count             = 29;
+    zones[0].matrix_map             = new matrix_map_type;
+    zones[0].matrix_map->height     = 7;
+    zones[0].matrix_map->width      = 7;
+    zones[0].matrix_map->map        = (unsigned int *)&matrix_map;
 
     for(unsigned int i = 1; i < (CORSAIR_COMMANDER_CORE_NUM_CHANNELS + 1); i++)
     {

Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.cpp

@@ -10,6 +10,7 @@
 
 /**------------------------------------------------------------------*\
     @name Corsair Dominator Platinum
+    @category RAM
     @type SMBus
     @save :x:
     @direct :white_check_mark:

Controllers/CorsairHydroController/CorsairHydroControllerDetect.cpp

@@ -71,10 +71,17 @@ void DetectCorsairHydroControllers(std::vector<RGBController*>& rgb_controllers)
             RGBController_CorsairHydro* rgb_controller = new RGBController_CorsairHydro(controller);
 
             rgb_controller->name = device_list[device_idx].name;
-            
+
             rgb_controllers.push_back(rgb_controller);
         }
     }
 }   /* DetectCorsairHydroControllers() */
 
 REGISTER_DETECTOR("Corsair Hydro Series", DetectCorsairHydroControllers);
+/*---------------------------------------------------------------------------------------------------------*\
+| Entries for dynamic UDEV rules                                                                            |
+|                                                                                                           |
+| DUMMY_DEVICE_DETECTOR("Corsair Hydro Series", DetectCorsairHydroControllers, 0x1B1C, x0C12 )              |
+| DUMMY_DEVICE_DETECTOR("Corsair Hydro Series", DetectCorsairHydroControllers, 0x1B1C, x0C13 )              |
+| DUMMY_DEVICE_DETECTOR("Corsair Hydro Series", DetectCorsairHydroControllers, 0x1B1C, x0C15 )              |
+\*---------------------------------------------------------------------------------------------------------*/

Controllers/CorsairHydroController/RGBController_CorsairHydro.cpp

@@ -11,6 +11,7 @@
 
 /**------------------------------------------------------------------*\
     @name Corsair Hydro
+    @category Cooler
     @type USB
     @save :x:
     @direct :white_check_mark:
@@ -86,7 +87,7 @@ RGBController_CorsairHydro::~RGBController_CorsairHydro()
 void RGBController_CorsairHydro::SetupZones()
 {
     zone new_zone;
-    
+
     new_zone.name       = "Pump Zone";
     new_zone.type       = ZONE_TYPE_SINGLE;
     new_zone.leds_min   = 1;

Controllers/CorsairHydroPlatinumController/CorsairHydroPlatinumControllerDetect.cpp

@@ -24,7 +24,9 @@
 #define CORSAIR_HYDRO_H100I_PLATINUM_PID    0x0C18
 #define CORSAIR_HYDRO_H100I_PLATINUM_SE_PID 0x0C19
 #define CORSAIR_HYDRO_H115I_PLATINUM_PID    0x0C17
+#define CORSAIR_HYDRO_H60I_PRO_XT_PID       0x0C29
 #define CORSAIR_HYDRO_H100I_PRO_XT_PID      0x0C20
+#define CORSAIR_HYDRO_H100I_PRO_XT_V2_PID   0x0C2D
 #define CORSAIR_HYDRO_H115I_PRO_XT_PID      0x0C21
 #define CORSAIR_HYDRO_H150I_PRO_XT_PID      0x0C22
 
@@ -44,6 +46,8 @@ void DetectCorsairHydroPlatinumControllers(hid_device_info* info, const std::str
 REGISTER_HID_DETECTOR("Corsair Hydro H100i Platinum",       DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H100I_PLATINUM_PID    );
 REGISTER_HID_DETECTOR("Corsair Hydro H100i Platinum SE",    DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H100I_PLATINUM_SE_PID );
 REGISTER_HID_DETECTOR("Corsair Hydro H115i Platinum",       DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H115I_PLATINUM_PID    );
+REGISTER_HID_DETECTOR("Corsair Hydro H60i Pro XT",          DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H60I_PRO_XT_PID       );
 REGISTER_HID_DETECTOR("Corsair Hydro H100i Pro XT",         DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H100I_PRO_XT_PID      );
+REGISTER_HID_DETECTOR("Corsair Hydro H100i Pro XT v2",      DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H100I_PRO_XT_V2_PID   );
 REGISTER_HID_DETECTOR("Corsair Hydro H115i Pro XT",         DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H115I_PRO_XT_PID      );
-REGISTER_HID_DETECTOR("Corsair Hydro H150i Pro XT",         DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H150I_PRO_XT_PID      );
+REGISTER_HID_DETECTOR("Corsair Hydro H150i Pro XT",         DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H150I_PRO_XT_PID      );

Controllers/CorsairHydroPlatinumController/RGBController_CorsairHydroPlatinum.cpp

@@ -21,6 +21,7 @@ static unsigned int matrix_map[5][5] =
 
 /**------------------------------------------------------------------*\
     @name Corsair Hydro Platinum
+    @category Cooler
     @type USB
     @save :x:
     @direct :white_check_mark:

Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp

@@ -11,8 +11,9 @@
 
 /**------------------------------------------------------------------*\
     @name Corsair Lighting Node
+    @category LEDStrip
     @type USB
-    @save :warning:
+    @save :robot:
     @direct :white_check_mark:
     @effects :white_check_mark:
     @detectors DetectCorsairLightingNodeControllers
@@ -259,7 +260,7 @@ void RGBController_CorsairLightingNode::SetupZones()
         }
 
         zones[channel_idx].matrix_map = NULL;
-        
+
         for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
         {
             char led_idx_string[4];

Controllers/CorsairPeripheralController/CorsairK95PlatinumXTController.cpp

@@ -0,0 +1,142 @@
+/*-----------------------------------------*\
+|  CorsairK195PlatinumXTController.h        |
+|                                           |
+|  Driver for Corsair K95 Platinum XT       |
+|  Keyboard                                 |
+|  Guimard Morgan (morg) 6/07/2022          |
+\*-----------------------------------------*/
+#include "CorsairK95PlatinumXTController.h"
+
+CorsairK95PlatinumXTController::CorsairK95PlatinumXTController(hid_device* dev_handle, const char* path)
+{
+    dev             = dev_handle;
+    location        = path;
+
+    Init();
+}
+
+CorsairK95PlatinumXTController::~CorsairK95PlatinumXTController()
+{
+    hid_close(dev);
+}
+
+std::string CorsairK95PlatinumXTController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string CorsairK95PlatinumXTController::GetFirmwareString()
+{
+    return "";
+}
+
+std::string CorsairK95PlatinumXTController::GetName()
+{
+    return name;
+}
+
+std::string CorsairK95PlatinumXTController::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 CorsairK95PlatinumXTController::Init()
+{
+    unsigned char usb_buf[K95_PLATINUM_XT_REPORT_LENGTH];
+
+    memset(usb_buf, 0x00, K95_PLATINUM_XT_REPORT_LENGTH);
+    usb_buf[0x01] = K95_PLATINUM_XT_REPORT_ID;
+    usb_buf[0x02] = 0x01;
+    usb_buf[0x03] = 0x03;
+    usb_buf[0x05] = 0x02;
+    hid_write(dev, usb_buf, K95_PLATINUM_XT_REPORT_LENGTH);
+
+    memset(usb_buf, 0x00, K95_PLATINUM_XT_REPORT_LENGTH);
+    usb_buf[0x01] = K95_PLATINUM_XT_REPORT_ID;
+    usb_buf[0x02] = 0x02;
+    usb_buf[0x03] = 0x6E;
+    hid_write(dev, usb_buf, K95_PLATINUM_XT_REPORT_LENGTH);
+
+    memset(usb_buf, 0x00, K95_PLATINUM_XT_REPORT_LENGTH);
+    usb_buf[0x01] = K95_PLATINUM_XT_REPORT_ID;
+    usb_buf[0x02] = 0x0D;
+    usb_buf[0x03] = 0x01;
+    usb_buf[0x04] = 0x01;
+    hid_write(dev, usb_buf, K95_PLATINUM_XT_REPORT_LENGTH);
+}
+
+void CorsairK95PlatinumXTController::SendDirect(const std::vector<RGBColor>& colors, const std::vector<std::tuple<std::string,unsigned int>>& leds_positions)
+{
+    /*-----------------------------------------------------*\
+    | RGB indexes                                           |
+    \*-----------------------------------------------------*/
+    unsigned int red_start = 0x008;
+    unsigned int grn_start = 0x0A4;
+    unsigned int blu_start = 0x140;
+
+    /*-----------------------------------------------------*\
+    | Fill the color data array                             |
+    \*-----------------------------------------------------*/
+    unsigned char color_data[K95_PLATINUM_XT_COLOR_DATA_LENGTH];
+    memset(color_data, 0x00, K95_PLATINUM_XT_COLOR_DATA_LENGTH);
+
+    color_data[0x00] = 0xD4;
+    color_data[0x01] = 0x01;
+
+    for(unsigned int c = 0; c < colors.size(); c++)
+    {
+        unsigned char red               = RGBGetRValue(colors[c]);
+        unsigned char grn               = RGBGetGValue(colors[c]);
+        unsigned char blu               = RGBGetBValue(colors[c]);
+        unsigned int  led_pos           = std::get<1>(leds_positions[c]);
+
+        color_data[led_pos + red_start] = red;
+        color_data[led_pos + grn_start] = grn;
+        color_data[led_pos + blu_start] = blu;
+    }
+
+    /*-----------------------------------------------------*\
+    | Send the 8 pages of colors                            |
+    \*-----------------------------------------------------*/
+    unsigned char usb_buf[K95_PLATINUM_XT_REPORT_LENGTH];
+
+    usb_buf[0x00] = 0x00;
+    usb_buf[0x01] = K95_PLATINUM_XT_REPORT_ID;
+    usb_buf[0x02] = 0x06;
+    usb_buf[0x03] = 0x01;
+
+    for(unsigned int i = 0; i < K95_PLATINUM_XT_NUMBER_OF_PAGES; i++)
+    {        
+        /*-----------------------------------------------------*\
+        | Copy colors in current page                           |
+        \*-----------------------------------------------------*/
+        memcpy
+        (
+            &usb_buf[0x04],
+            &color_data[(K95_PLATINUM_XT_REPORT_LENGTH - 4) * i],
+            K95_PLATINUM_XT_REPORT_LENGTH - 4
+        );
+
+        /*-----------------------------------------------------*\
+        | Send the buffer                                       |
+        \*-----------------------------------------------------*/
+        hid_write(dev, usb_buf, K95_PLATINUM_XT_REPORT_LENGTH);
+
+        /*-----------------------------------------------------*\
+        | Next pages start with 0x07                            |
+        \*-----------------------------------------------------*/
+        usb_buf[0x02] = 0x07;
+    }
+
+}

Controllers/CorsairPeripheralController/CorsairK95PlatinumXTController.h

@@ -0,0 +1,44 @@
+/*-----------------------------------------*\
+|  CorsairK95PlatinumXTController.h         |
+|                                           |
+|  Driver for Corsair K95 Platinum XT       |
+|  Keyboard                                 |
+|                                           |
+|  Guimard Morgan (morg) 6/07/2022          |
+\*-----------------------------------------*/
+#pragma once
+
+#include "RGBController.h"
+#include <string.h>
+#include <hidapi/hidapi.h>
+
+#define K95_PLATINUM_XT_REPORT_LENGTH           65
+#define K95_PLATINUM_XT_COLOR_DATA_LENGTH       488
+#define K95_PLATINUM_XT_REPORT_ID               0x08
+#define K95_PLATINUM_XT_NUMBER_OF_PAGES         0x08
+#define K95_PLATINUM_XT_READ_COMMAND            0x02
+#define K95_PLATINUM_XT_DIRECT_START_STREAM     0x07
+#define K95_PLATINUM_XT_DIRECT_BLOCK_STREAM     0x06
+
+class CorsairK95PlatinumXTController
+{
+public:
+    CorsairK95PlatinumXTController(hid_device* dev_handle, const char* path);
+    ~CorsairK95PlatinumXTController();
+
+    std::string     GetDeviceLocation();
+    std::string     GetFirmwareString();
+    std::string     GetName();
+    std::string     GetSerialString();
+
+    void            SendDirect(const std::vector<RGBColor>& colors, const std::vector<std::tuple<std::string,unsigned int>>& leds_positions);
+
+private:
+    hid_device*     dev;
+
+    std::string     firmware_version;
+    std::string     location;
+    std::string     name;
+
+    void            Init();
+};

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -338,18 +338,48 @@ void CorsairPeripheralController::SetName(std::string device_name)
     name = device_name;
 }
 
+void CorsairPeripheralController::SwitchMode(bool software)
+{
+    if(software)
+    {
+        if (logical_layout == CORSAIR_TYPE_K55 || logical_layout == CORSAIR_TYPE_K95_PLAT || logical_layout == CORSAIR_TYPE_K70_MK2 || logical_layout == CORSAIR_TYPE_K68)
+        {
+            SpecialFunctionControl();
+        }
+
+        LightingControl();
+
+        if (logical_layout == CORSAIR_TYPE_K55 || logical_layout == CORSAIR_TYPE_K95_PLAT || logical_layout == CORSAIR_TYPE_K70_MK2 || logical_layout == CORSAIR_TYPE_K68)
+        {
+            SetupK55AndK95LightingControl();
+        }
+    }
+    else
+    {
+        unsigned char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
+
+        memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+
+        usb_buf[1] = CORSAIR_COMMAND_WRITE;
+        usb_buf[2] = CORSAIR_PROPERTY_SPECIAL_FUNCTION;
+        usb_buf[3] = CORSAIR_LIGHTING_CONTROL_HARDWARE;
+
+        hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+    }
+}
+
 /*-------------------------------------------------------------------------------------------------*\
 | Private packet sending functions.                                                                 |
 \*-------------------------------------------------------------------------------------------------*/
 
 void CorsairPeripheralController::LightingControl()
 {
-    char usb_buf[65];
+    char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
     \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
+    memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 
     /*-----------------------------------------------------*\
     | Set up Lighting Control packet                        |
@@ -386,7 +416,7 @@ void CorsairPeripheralController::LightingControl()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 }
 
 /*-----------------------------------------------------*\
@@ -395,12 +425,12 @@ void CorsairPeripheralController::LightingControl()
 
 void CorsairPeripheralController::SetupK55AndK95LightingControl()
 {
-    char usb_buf[65];
+    char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
     \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
+    memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 
     /*-----------------------------------------------------*\
     | Set up a packet                                       |
@@ -415,7 +445,7 @@ void CorsairPeripheralController::SetupK55AndK95LightingControl()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 
     unsigned int* skipped_identifiers = key_mapping_k95_plat_ansi;
     int skipped_identifiers_count = sizeof(key_mapping_k95_plat_ansi) / sizeof(key_mapping_k95_plat_ansi[0]);
@@ -440,7 +470,7 @@ void CorsairPeripheralController::SetupK55AndK95LightingControl()
         /*-----------------------------------------------------*\
         | Zero out buffer                                       |
         \*-----------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
+        memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 
         /*-----------------------------------------------------*\
         | Set up a packet - a sequence of 120 ids               |
@@ -467,18 +497,18 @@ void CorsairPeripheralController::SetupK55AndK95LightingControl()
         /*-----------------------------------------------------*\
         | Send packet                                           |
         \*-----------------------------------------------------*/
-        hid_write(dev, (unsigned char *)usb_buf, 65);
+        hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
     }
 }
 
 void CorsairPeripheralController::SpecialFunctionControl()
 {
-    char usb_buf[65];
+    char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
     \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
+    memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 
     /*-----------------------------------------------------*\
     | Set up Lighting Control packet                        |
@@ -491,19 +521,19 @@ void CorsairPeripheralController::SpecialFunctionControl()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 }
 
 void CorsairPeripheralController::ReadFirmwareInfo()
 {
     int  actual;
-    char usb_buf[65];
+    char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
     char offset = 0;
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
     \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
+    memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 
     /*-----------------------------------------------------*\
     | Set up Read Firmware Info packet                      |
@@ -517,15 +547,15 @@ void CorsairPeripheralController::ReadFirmwareInfo()
     | If that fails, repeat the send and read the reply as  |
     | a feature report.                                     |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char*)usb_buf, 65);
-    actual = hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000);
+    hid_write(dev, (unsigned char*)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+    actual = hid_read_timeout(dev, (unsigned char*)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH, 1000);
 
     if(actual == 0)
     {
         /*-------------------------------------------------*\
         | Zero out buffer                                   |
         \*-------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
+        memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 
         /*-------------------------------------------------*\
         | Set up Read Firmware Info packet                  |
@@ -534,8 +564,8 @@ void CorsairPeripheralController::ReadFirmwareInfo()
         usb_buf[0x01]   = CORSAIR_COMMAND_READ;
         usb_buf[0x02]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
 
-        hid_send_feature_report(dev, (unsigned char*)usb_buf, 65);
-        actual = hid_get_feature_report(dev, (unsigned char*)usb_buf, 65);
+        hid_send_feature_report(dev, (unsigned char*)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+        actual = hid_get_feature_report(dev, (unsigned char*)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
         offset = 1;
     }
 
@@ -659,12 +689,12 @@ void CorsairPeripheralController::StreamPacket
     unsigned char*  data_ptr
     )
 {
-    char usb_buf[65];
+    char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
     \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
+    memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 
     /*-----------------------------------------------------*\
     | Set up Stream packet                                  |
@@ -682,7 +712,107 @@ void CorsairPeripheralController::StreamPacket
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+}
+
+void CorsairPeripheralController::SetHardwareMode
+    (
+        int mode_value,
+        unsigned int color_mode,
+        std::vector<RGBColor> colors,
+        unsigned int speed,
+        unsigned int direction,
+        unsigned char brightness
+    )
+{
+    unsigned char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
+    memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+
+    /*-----------------------------------------------------*\
+    | Set the brightness                                    |
+    \*-----------------------------------------------------*/
+    usb_buf[1] = CORSAIR_COMMAND_WRITE;
+    usb_buf[2] = 0x05;
+    usb_buf[3] = 0x02;
+    usb_buf[5] = brightness;
+
+    hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+
+    /*-----------------------------------------------------*\
+    | Send "lght_00.d"                                      |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+
+    usb_buf[1]  = CORSAIR_COMMAND_WRITE;
+    usb_buf[2]  = 0x17;
+    usb_buf[3]  = 0x05;
+    usb_buf[5]  = 0x6c;
+    usb_buf[6]  = 0x67;
+    usb_buf[7]  = 0x68;
+    usb_buf[8]  = 0x74;
+    usb_buf[9]  = 0x5F;
+    usb_buf[10] = 0x30;
+    usb_buf[11] = 0x30;
+    usb_buf[12] = 0x2E;
+    usb_buf[13] = 0x64;
+
+    hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+
+    /*-----------------------------------------------------*\
+    | Stream the mode data                                  |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+
+    usb_buf[1] = CORSAIR_COMMAND_STREAM;
+    usb_buf[2] = 0x01;
+    usb_buf[3] = 0x0D;
+    usb_buf[5] = mode_value;
+    usb_buf[8] = direction;
+
+    if(mode_value == CORSAIR_HW_MODE_TYPE_KEY_VALUE)
+    {
+        usb_buf[9] = speed;
+    }
+    else
+    {
+        usb_buf[6] = speed;
+    }
+
+    if(color_mode == MODE_COLORS_RANDOM)
+    {
+        usb_buf[7] = 0x01;
+    }
+    else if (color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        usb_buf[7] = 0x03;
+
+        usb_buf[10] = RGBGetRValue(colors[0]);
+        usb_buf[11] = RGBGetGValue(colors[0]);
+        usb_buf[12] = RGBGetBValue(colors[0]);
+        usb_buf[13] = 0xFF;
+
+        usb_buf[14] = RGBGetRValue(colors[1]);
+        usb_buf[15] = RGBGetGValue(colors[1]);
+        usb_buf[16] = RGBGetBValue(colors[1]);
+        usb_buf[17] = 0xFF;
+    }
+
+    hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+
+    /*-----------------------------------------------------*\
+    | Stop stream and commit                                |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+
+    usb_buf[1]  = CORSAIR_COMMAND_WRITE;
+    usb_buf[2]  = 0x17;
+    usb_buf[3]  = 0x09;
+
+    hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
+
+    usb_buf[3]  = 0x08;
+
+    hid_write(dev, usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 }
 
 void CorsairPeripheralController::SubmitKeyboardFullColors
@@ -692,12 +822,12 @@ void CorsairPeripheralController::SubmitKeyboardFullColors
     unsigned char   finish_val
     )
 {
-    char usb_buf[65];
+    char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
     \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
+    memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 
     /*-----------------------------------------------------*\
     | Set up Submit Keyboard 24-Bit Colors packet           |
@@ -712,7 +842,7 @@ void CorsairPeripheralController::SubmitKeyboardFullColors
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 }
 
 void CorsairPeripheralController::SubmitKeyboardZonesColors
@@ -722,7 +852,7 @@ void CorsairPeripheralController::SubmitKeyboardZonesColors
     RGBColor right
     )
 {
-    char usb_buf[65];
+    char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -750,7 +880,7 @@ void CorsairPeripheralController::SubmitKeyboardZonesColors
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 }
 
 void CorsairPeripheralController::SubmitKeyboardLimitedColors
@@ -758,7 +888,7 @@ void CorsairPeripheralController::SubmitKeyboardLimitedColors
     unsigned char   byte_count
     )
 {
-    char usb_buf[65];
+    char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -776,7 +906,7 @@ void CorsairPeripheralController::SubmitKeyboardLimitedColors
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 }
 
 void CorsairPeripheralController::SubmitMouseColors
@@ -785,12 +915,12 @@ void CorsairPeripheralController::SubmitMouseColors
     RGBColor *      color_data
     )
 {
-    char usb_buf[65];
+    char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
     \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
+    memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 
     /*-----------------------------------------------------*\
     | Set up Submit Mouse Colors packet                     |
@@ -815,7 +945,7 @@ void CorsairPeripheralController::SubmitMouseColors
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 }
 
 void CorsairPeripheralController::SubmitMousematColors
@@ -824,12 +954,12 @@ void CorsairPeripheralController::SubmitMousematColors
     RGBColor *      color_data
     )
 {
-    char usb_buf[65];
+    char usb_buf[CORSAIR_PERIPHERAL_PACKET_LENGTH];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
     \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
+    memset(usb_buf, 0x00, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 
     /*-----------------------------------------------------*\
     | Set up Submit Mouse Colors packet                     |
@@ -854,5 +984,5 @@ void CorsairPeripheralController::SubmitMousematColors
     | Send packet using feature reports, as headset stand   |
     | seems to not update completely using HID writes       |
     \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, CORSAIR_PERIPHERAL_PACKET_LENGTH);
 }

Controllers/CorsairPeripheralController/CorsairPeripheralController.h

@@ -15,6 +15,8 @@
 
 #pragma once
 
+#define CORSAIR_PERIPHERAL_PACKET_LENGTH 65
+
 enum
 {
     CORSAIR_COMMAND_WRITE       = 0x07,
@@ -67,6 +69,28 @@ enum
     CORSAIR_TYPE_K68                = 5
 };
 
+enum
+{
+    CORSAIR_MODE_DIRECT_VALUE           = 0xFF,
+    CORSAIR_HW_MODE_COLOR_PULSE_VALUE   = 0x01,
+    CORSAIR_HW_MODE_COLOR_SHIFT_VALUE   = 0x00,
+    CORSAIR_HW_MODE_COLOR_WAVE_VALUE    = 0x04,
+    CORSAIR_HW_MODE_RAINBOW_WAVE_VALUE  = 0x03,
+    CORSAIR_HW_MODE_RAIN_VALUE          = 0x06,
+    CORSAIR_HW_MODE_SPIRAL_VALUE        = 0x02,
+    CORSAIR_HW_MODE_TYPE_KEY_VALUE      = 0x08,
+    CORSAIR_HW_MODE_TYPE_RIPPLE_VALUE   = 0x09,
+    CORSAIR_HW_MODE_VISOR_VALUE         = 0x05
+};
+
+enum
+{
+    CORSAIR_HW_MODE_SPEED_MIN           = 0x01,
+    CORSAIR_HW_MODE_SPEED_MAX           = 0x03,
+    CORSAIR_HW_MODE_BRIGHTNESS_MIN      = 0x00,
+    CORSAIR_HW_MODE_BRIGHTNESS_MAX      = 0x03
+};
+
 class CorsairPeripheralController
 {
 public:
@@ -87,6 +111,18 @@ public:
     void            SetLEDsMouse(std::vector<RGBColor> colors);
     void            SetLEDsMousemat(std::vector<RGBColor> colors);
     void            SetName(std::string device_name);
+    void            SetHardwareMode
+                    (
+                        int mode_value,
+                        unsigned int color_mode,
+                        std::vector<RGBColor> colors,
+                        unsigned int speed,
+                        unsigned int direction,
+                        unsigned char brightness
+                    );
+
+
+    void SwitchMode(bool software);
 
 private:
     hid_device*             dev;

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -8,6 +8,7 @@
 #include "RGBController_CorsairK100.h"
 #include "RGBController_CorsairK55RGBPRO.h"
 #include "RGBController_CorsairK65Mini.h"
+#include "RGBController_CorsairK95PlatinumXT.h"
 #include <hidapi/hidapi.h>
 
 #define CORSAIR_PERIPHERAL_CONTROLLER_NAME "Corsair peripheral"
@@ -57,6 +58,7 @@
 #define CORSAIR_M65_PRO_PID             0x1B2E
 #define CORSAIR_M65_RGB_ELITE_PID       0x1B5A
 #define CORSAIR_NIGHTSWORD_PID          0x1B5C
+#define CORSAIR_SCIMITAR_RGB_PID        0x1B1E
 #define CORSAIR_SCIMITAR_PRO_RGB_PID    0x1B3E
 #define CORSAIR_SCIMITAR_ELITE_RGB_PID  0x1B8B
 #define CORSAIR_SABRE_RGB_PID           0x1B2F
@@ -79,6 +81,24 @@
 \*-----------------------------------------------------*/
 #define CORSAIR_K100_PID                0x1B7C
 
+/*-----------------------------------------------------*\
+| Corsair K55 RGB PRO Keyboard product ID               |
+| This keyboard uses a separate driver                  |
+\*-----------------------------------------------------*/
+#define CORSAIR_K55_RGB_PRO_PID         0x1BA4
+
+/*-----------------------------------------------------*\
+| Corsair K65 Mini Keyboard product ID                  |
+| This keyboard uses a separate driver                  |
+\*-----------------------------------------------------*/
+#define CORSAIR_K65_MINI_PID            0x1BAF
+
+/*-----------------------------------------------------*\
+| Corsair K95 Platinum XT Keyboard product ID           |
+| This keyboard uses a separate driver                  |
+\*-----------------------------------------------------*/
+#define CORSAIR_K95_PLATINUM_XT_PID     0x1B89
+
 void DetectCorsairK100Controllers(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -100,12 +120,6 @@ void DetectCorsairK100Controllers(hid_device_info* info, const std::string& name
     }
 }   /* DetectCorsairPeripheralControllers() */
 
-/*-----------------------------------------------------*\
-| Corsair K55 RGB PRO Keyboard product ID               |
-| This keyboard uses a separate driver                  |
-\*-----------------------------------------------------*/
-#define CORSAIR_K55_RGB_PRO_PID         0x1BA4
-
 void DetectCorsairK55RGBPROControllers(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -119,25 +133,31 @@ void DetectCorsairK55RGBPROControllers(hid_device_info* info, const std::string&
     }
 }   /* DetectCorsairK55RGBPROControllers() */
 
-/*-----------------------------------------------------*\
-| Corsair K65 Mini Keyboard product ID                  |
-| This keyboard uses a separate driver                  |
-\*-----------------------------------------------------*/
-#define CORSAIR_K65_MINI_PID            0x1BAF
-
 void DetectCorsairK65MiniControllers(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
-        CorsairK65MiniController*     controller        = new CorsairK65MiniController(dev, info->path);       
+        CorsairK65MiniController*     controller        = new CorsairK65MiniController(dev, info->path);
         RGBController_CorsairK65Mini* rgb_controller    = new RGBController_CorsairK65Mini(controller);
         rgb_controller->name                            = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }   /* DetectCorsairK65MiniControllers() */
 
+void DetectCorsairK95PlatinumXTControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        CorsairK95PlatinumXTController*     controller      = new CorsairK95PlatinumXTController(dev, info->path);
+        RGBController_CorsairK95PlatinumXT* rgb_controller  = new RGBController_CorsairK95PlatinumXT(controller);
+        rgb_controller->name                                = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}   /* DetectCorsairK65MiniControllers() */
 
 /******************************************************************************************\
 *                                                                                          *
@@ -159,7 +179,11 @@ void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string
 
         if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
         {
-            RGBController_CorsairPeripheral* rgb_controller = new RGBController_CorsairPeripheral(controller);
+            bool supports_hardware_modes =
+                    (info->product_id == CORSAIR_K70_RGB_MK2_PID) ||
+                    (info->product_id == CORSAIR_K70_RGB_MK2_LP_PID);
+
+            RGBController_CorsairPeripheral* rgb_controller = new RGBController_CorsairPeripheral(controller, supports_hardware_modes);
             ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
         else
@@ -201,6 +225,7 @@ REGISTER_HID_DETECTOR_IP("Corsair M65",                     DetectCorsairPeriphe
 REGISTER_HID_DETECTOR_IP("Corsair M65 PRO",                 DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_PRO_PID,           1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair M65 RGB Elite",           DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_RGB_ELITE_PID,     1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Nightsword",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_NIGHTSWORD_PID,        1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Scimitar RGB",            DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_RGB_PID,      1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Scimitar PRO RGB",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_PRO_RGB_PID,  1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Scimitar Elite RGB",      DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_ELITE_RGB_PID,1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Sabre RGB",               DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SABRE_RGB_PID,         1, 0xFFC2);
@@ -235,4 +260,8 @@ REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO",             DetectCorsairK55RGBP
 /*-----------------------------------------------------------------------------------------------------*\
 | Corsair K65 Mini Keyboard                                                                             |
 \*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Corsair K65 Mini",                DetectCorsairK65MiniControllers,    CORSAIR_VID, CORSAIR_K65_MINI_PID,         1, 0, 0);
+REGISTER_HID_DETECTOR_I("Corsair K65 Mini",                DetectCorsairK65MiniControllers,    CORSAIR_VID, CORSAIR_K65_MINI_PID,         1);
+/*-----------------------------------------------------------------------------------------------------*\
+| Corsair K95 Platinum XT Keyboard                                                                      |
+\*-----------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("Corsair K95 RGB PLATINUM XT",      DetectCorsairK95PlatinumXTControllers, CORSAIR_VID, CORSAIR_K95_PLATINUM_XT_PID,   1, 0xFF42);

Controllers/CorsairPeripheralController/RGBController_CorsairK100.cpp

@@ -221,6 +221,7 @@ typedef struct
 
 /**------------------------------------------------------------------*\
     @name Corsair K100 Keyboard
+    @category Keyboard
     @type USB
     @save :x:
     @direct :white_check_mark:

Controllers/CorsairPeripheralController/RGBController_CorsairK55RGBPRO.cpp

@@ -11,6 +11,7 @@ using namespace std::chrono_literals;
 
 /**------------------------------------------------------------------*\
     @name Corsair K55 RGB Pro
+    @category Keyboard
     @type USB
     @save :x:
     @direct :white_check_mark:

Controllers/CorsairPeripheralController/RGBController_CorsairK65Mini.cpp

@@ -122,6 +122,7 @@ std::vector<std::tuple<unsigned int, std::string>> keys =
 
 /**------------------------------------------------------------------*\
     @name Corsair K65 Mini
+    @category Keyboard
     @type USB
     @save :x:
     @direct :white_check_mark:

Controllers/CorsairPeripheralController/RGBController_CorsairK95PlatinumXT.cpp

@@ -0,0 +1,362 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairK95PlatinumXT.h     |
+|                                           |
+|                                           |
+|  Guimard Morgan (morg) 6/07/2022          |
+\*-----------------------------------------*/
+
+#include "RGBControllerKeyNames.h"
+#include "RGBController_CorsairK95PlatinumXT.h"
+#include "RGBControllerKeyNames.h"
+
+#define NA  0xFFFFFFFF
+
+#define K95_PLATINUM_BAR_LENGTH 19
+#define K95_PLATINUM_XT_HEIGHT  7
+#define K95_PLATINUM_XT_WIDTH 23
+
+static unsigned int k95_platinum_xt_matrix_map[K95_PLATINUM_XT_HEIGHT][K95_PLATINUM_XT_WIDTH] =
+{
+    { NA, NA,  NA,  NA,  22,  28,  34,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,   96,   NA,   NA,    NA},
+    {  0,  6,  NA,  16,  23,  29,  35,  NA,  45,  50,  55,  60,  66,  72,  76,  78,  83,  87,  92,   97,  103,  108,   114},
+    {  1,  7,  12,  17,  24,  30,  36,  40,  46,  51,  56,  61,  67,  73,  NA,  79,  84,  88,  93,   98,  104,  109,   115},
+    {  2,  8,  13,  18,  25,  31,  37,  41,  47,  52,  57,  62,  68,  74,  NA,  80,  85,  89,  94,   99,  105,  110,   116},
+    {  3,  9,  14,  19,  26,  32,  38,  42,  48,  53,  58,  63,  69,  NA,  NA,  81,  NA,  NA,  NA,  100,  106,  111,    NA},
+    {  4, 10,  NA,  20,  27,  33,  39,  43,  49,  54,  59,  64,  70,  NA,  77,  NA,  NA,  90,  NA,  101,  107,  112,   117},
+    {  5, 11,  15,  21,  NA,  NA,  NA,  44,  NA,  NA,  NA,  65,  71,  75,  NA,  82,  86,  91,  95,  102,   NA,  113,    NA}
+};
+
+
+static std::vector<std::tuple<std::string, unsigned int>> k95_platinum_xt_leds_names_and_positions =
+{
+    // Top Bar
+    {"LED: 1",                  133},
+    {"LED: 2",                  134},
+    {"LED: 3",                  135},
+    {"LED: 4",                  136},
+    {"LED: 5",                  137},
+    {"LED: 6",                  138},
+    {"LED: 7",                  139},
+    {"LED: 8",                  140},
+    {"LED: 9",                  141},
+    {"LED: 10",                 142},
+    {"LED: 11",                 143},
+    {"LED: 12",                 144},
+    {"LED: 13",                 145},
+    {"LED: 14",                 146},
+    {"LED: 15",                 147},
+    {"LED: 16",                 148},
+    {"LED: 17",                 149},
+    {"LED: 18",                 150},
+    {"LED: 19",                 151},
+
+    // COL 1
+    {"Key: G1",                 127},
+    {"Key: G2",                 128},
+    {"Key: G3",                 129},
+    {"Key: G4",                 130},
+    {"Key: G5",                 131},
+    {"Key: G6",                 132},
+
+    // COL 2
+    {KEY_EN_ESCAPE,             37},
+    {KEY_EN_BACK_TICK,          49},
+    {KEY_EN_TAB,                39},
+    {KEY_EN_CAPS_LOCK,          53},
+    {KEY_EN_LEFT_SHIFT,         102},
+    {KEY_EN_LEFT_CONTROL,       101},
+
+    // COL 3
+    {KEY_EN_1,                  26},
+    {KEY_EN_Q,                  16},
+    {KEY_EN_A,                  0},
+    {KEY_EN_LEFT_WINDOWS,       104},
+
+    // COL 4
+    {KEY_EN_F1,                 54},
+    {KEY_EN_2,                  27},
+    {KEY_EN_W,                  22},
+    {KEY_EN_S,                  18},
+    {KEY_EN_Z,                  25},
+    {KEY_EN_LEFT_ALT,           103},
+
+    // COL 5
+    {"Key: User",               124},
+    {KEY_EN_F2,                 55},
+    {KEY_EN_3,                  28},
+    {KEY_EN_E,                  4},
+    {KEY_EN_D,                  3},
+    {KEY_EN_X,                  23},
+
+    // COL 6
+    {"Key: Brightness",         109},
+    {KEY_EN_F3,                 56},
+    {KEY_EN_4,                  29},
+    {KEY_EN_R,                  17},
+    {KEY_EN_F,                  5},
+    {KEY_EN_C,                  2},
+
+    // COL 7
+    {"Key: Lock",               110},
+    {KEY_EN_F4,                 57},
+    {KEY_EN_5,                  30},
+    {KEY_EN_T,                  19},
+    {KEY_EN_G,                  6},
+    {KEY_EN_V,                  21},
+
+    // COL 8
+    {KEY_EN_6,                  31},
+    {KEY_EN_Y,                  24},
+    {KEY_EN_H,                  7},
+    {KEY_EN_B,                  1},
+    {KEY_EN_SPACE,              40},
+
+    // COL 9
+    {KEY_EN_F5,                 58},
+    {KEY_EN_7,                  32},
+    {KEY_EN_U,                  20},
+    {KEY_EN_J,                  9},
+    {KEY_EN_N,                  13},
+
+    // COL 10
+    {KEY_EN_F6,                 59},
+    {KEY_EN_8,                  33},
+    {KEY_EN_I,                  8},
+    {KEY_EN_K,                  10},
+    {KEY_EN_M,                  12},
+
+    // COL 11
+    {KEY_EN_F7,                 60},
+    {KEY_EN_9,                  34},
+    {KEY_EN_O,                  14},
+    {KEY_EN_L,                  11},
+    {KEY_EN_COMMA,              50},
+
+    // COL 12
+    {KEY_EN_F8,                 61},
+    {KEY_EN_0,                  35},
+    {KEY_EN_P,                  15},
+    {KEY_EN_SEMICOLON,          47},
+    {KEY_EN_PERIOD,             51},
+    {KEY_EN_RIGHT_ALT,          107},
+
+    // COL 13
+    {KEY_EN_F9,                 62},
+    {KEY_EN_MINUS,              41},
+    {KEY_EN_LEFT_BRACKET,       43},
+    {KEY_EN_QUOTE,              48},
+    {KEY_EN_FORWARD_SLASH,      52},
+    {KEY_EN_RIGHT_WINDOWS,      108},
+
+    // COL 14
+    {KEY_EN_F10,                63},
+    {KEY_EN_EQUALS,             42},
+    {KEY_EN_RIGHT_BRACKET,      44},
+    {KEY_EN_MENU,               97},
+
+    // COL 15
+    {KEY_EN_F11,                64},
+    {KEY_EN_RIGHT_SHIFT,        106},
+
+    // COL 16
+    {KEY_EN_F12,                65},
+    {KEY_EN_BACKSPACE,          38},
+    {KEY_EN_ANSI_BACK_SLASH,    45},
+    {KEY_EN_ANSI_ENTER,         36},
+    {KEY_EN_RIGHT_CONTROL,      105},
+
+
+    // COL 17
+    {KEY_EN_PRINT_SCREEN,       66},
+    {KEY_EN_INSERT,             69},
+    {KEY_EN_DELETE,             72},
+    {KEY_EN_LEFT_ARROW,         76},
+
+    // COL 18
+    {KEY_EN_SCROLL_LOCK,        67},
+    {KEY_EN_HOME,               70},
+    {KEY_EN_END,                73},
+    {KEY_EN_UP_ARROW,           78},
+    {KEY_EN_DOWN_ARROW,         77},
+
+    // COL 19
+    {KEY_EN_PAUSE_BREAK,        68},
+    {KEY_EN_PAGE_UP,            71},
+    {KEY_EN_PAGE_DOWN,          74},
+    {KEY_EN_RIGHT_ARROW,        75},
+
+
+    // COL 20
+    {KEY_EN_MEDIA_MUTE,         98},
+    {KEY_EN_MEDIA_STOP,         119},
+    {KEY_EN_NUMPAD_LOCK,        79},
+    {KEY_EN_NUMPAD_7,           91},
+    {KEY_EN_NUMPAD_4,           88},
+    {KEY_EN_NUMPAD_1,           85},
+    {KEY_EN_NUMPAD_0,           94},
+
+    // COL 21
+    {KEY_EN_MEDIA_PREVIOUS,    122},
+    {KEY_EN_NUMPAD_DIVIDE,      80},
+    {KEY_EN_NUMPAD_8,           92},
+    {KEY_EN_NUMPAD_5,           89},
+    {KEY_EN_NUMPAD_2,           86},
+
+    // COL 22
+    {KEY_EN_MEDIA_PLAY_PAUSE,   120},
+    {KEY_EN_NUMPAD_TIMES,       81},
+    {KEY_EN_NUMPAD_9,           93},
+    {KEY_EN_NUMPAD_6,           90},
+    {KEY_EN_NUMPAD_3,           87},
+    {KEY_EN_NUMPAD_PERIOD,      95},
+
+    // COL 23
+    {KEY_EN_MEDIA_NEXT,         121},
+    {KEY_EN_NUMPAD_MINUS,       82},
+    {KEY_EN_NUMPAD_PLUS,        83},
+    {KEY_EN_NUMPAD_ENTER,       84}
+};
+
+/**------------------------------------------------------------------*\
+    @name Corsair K95 Platinum XT Keyboard
+    @category Keyboard
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectCorsairK95PlatinumXTControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_CorsairK95PlatinumXT::RGBController_CorsairK95PlatinumXT(CorsairK95PlatinumXTController* controller_ptr)
+{
+    controller      = controller_ptr;
+
+    name            = controller->GetName();
+    vendor          = "Corsair";
+    description     = "Corsair K95 Platinum XT Keyboard Device";
+    type            = DEVICE_TYPE_KEYBOARD;
+    version         = controller->GetFirmwareString();
+    location        = controller->GetDeviceLocation();
+    serial          = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_CorsairK95PlatinumXT::~RGBController_CorsairK95PlatinumXT()
+{    
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].type == ZONE_TYPE_MATRIX)
+        {
+            delete zones[zone_index].matrix_map;
+        }
+    }
+
+    delete controller;
+}
+
+void RGBController_CorsairK95PlatinumXT::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Top bar zone setup                                        |
+    \*---------------------------------------------------------*/
+    zone top_bar_zone;
+
+    top_bar_zone.name                   = "Top Bar";
+    top_bar_zone.type                   = ZONE_TYPE_LINEAR;
+    top_bar_zone.leds_min               = K95_PLATINUM_BAR_LENGTH;
+    top_bar_zone.leds_max               = K95_PLATINUM_BAR_LENGTH;
+    top_bar_zone.leds_count             = K95_PLATINUM_BAR_LENGTH;
+    top_bar_zone.matrix_map             = nullptr;
+
+    for(unsigned int i = 0; i < top_bar_zone.leds_count; i++)
+    {
+        led new_led;
+        new_led.name = std::get<0>(k95_platinum_xt_leds_names_and_positions[i]);
+        leds.push_back(new_led);
+    }
+
+    zones.push_back(top_bar_zone);
+
+    /*---------------------------------------------------------*\
+    | Keyboard zone setup                                       |
+    \*---------------------------------------------------------*/
+    zone keyboard_zone;
+
+    keyboard_zone.name                  = "Keyboard";
+    keyboard_zone.type                  = ZONE_TYPE_MATRIX;
+    keyboard_zone.matrix_map            = new matrix_map_type;
+    keyboard_zone.matrix_map->height    = K95_PLATINUM_XT_HEIGHT;
+    keyboard_zone.matrix_map->width     = K95_PLATINUM_XT_WIDTH;
+    keyboard_zone.matrix_map->map       = new unsigned int[K95_PLATINUM_XT_HEIGHT * K95_PLATINUM_XT_WIDTH];
+
+    unsigned int keyboard_leds_count = 0;
+
+    for(unsigned int w = 0; w < K95_PLATINUM_XT_WIDTH; w++)
+    {
+        for(unsigned int h = 0; h < K95_PLATINUM_XT_HEIGHT; h++)
+        {
+            unsigned int key = k95_platinum_xt_matrix_map[h][w];
+            keyboard_zone.matrix_map->map[h * K95_PLATINUM_XT_WIDTH + w] = key;
+
+            if(key != NA)
+            {
+                led new_led;
+                new_led.name = std::get<0>(k95_platinum_xt_leds_names_and_positions[top_bar_zone.leds_count + keyboard_leds_count]);
+                leds.push_back(new_led);
+                keyboard_leds_count++;
+            }
+        }
+    }
+
+    keyboard_zone.leds_min   = keyboard_leds_count;
+    keyboard_zone.leds_max   = keyboard_leds_count;
+    keyboard_zone.leds_count = keyboard_leds_count;
+
+    zones.push_back(keyboard_zone);
+
+    SetupColors();
+}
+
+void RGBController_CorsairK95PlatinumXT::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_CorsairK95PlatinumXT::DeviceUpdateLEDs()
+{
+    controller->SendDirect(colors, k95_platinum_xt_leds_names_and_positions);
+}
+
+void RGBController_CorsairK95PlatinumXT::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CorsairK95PlatinumXT::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CorsairK95PlatinumXT::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_CorsairK95PlatinumXT::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}

Controllers/CorsairPeripheralController/RGBController_CorsairK95PlatinumXT.h

@@ -0,0 +1,28 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairK95PlatinumXT.h     |
+|                                           |
+|                                           |
+|  Guimard Morgan (morg) 6/07/2022          |
+\*-----------------------------------------*/
+#pragma once
+
+#include "RGBController.h"
+#include "CorsairK95PlatinumXTController.h"
+
+class RGBController_CorsairK95PlatinumXT : public RGBController
+{
+public:
+    RGBController_CorsairK95PlatinumXT(CorsairK95PlatinumXTController* controller_ptr);
+    ~RGBController_CorsairK95PlatinumXT();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
+    void DeviceUpdateMode();
+    void SetCustomMode();
+
+private:
+    CorsairK95PlatinumXTController*                              controller;    
+};

Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.cpp

@@ -1,4 +1,4 @@
-/*-----------------------------------------*\
+/*-----------------------------------------*\
 |  RGBController_CorsairPeripheral.cpp      |
 |                                           |
 |  Generic RGB Interface for Corsair RGB    |
@@ -756,15 +756,20 @@ static const char* corsair_harpoon_pro_leds[] =
 
 /**------------------------------------------------------------------*\
     @name Corsair Peripheral
+    @category Keyboard,Mouse,Mousemat,HeadsetStand
     @type USB
-    @save :white_check_mark: or :warning: or :x:
+    @save :x:
     @direct :white_check_mark:
-    @effects :x:
+    @effects :tools:
     @detectors DetectCorsairPeripheralControllers
     @comment
+    All controllers support `Direct` mode
+    Currently HW modes are implemented for the following devices:
+    * Corsair K70 RGB MK.2
+    * Corsair K70 RGB MK.2 Low Profile
 \*-------------------------------------------------------------------*/
 
-RGBController_CorsairPeripheral::RGBController_CorsairPeripheral(CorsairPeripheralController* controller_ptr)
+RGBController_CorsairPeripheral::RGBController_CorsairPeripheral(CorsairPeripheralController* controller_ptr, bool supports_hardware_modes)
 {
     controller      = controller_ptr;
 
@@ -781,11 +786,142 @@ RGBController_CorsairPeripheral::RGBController_CorsairPeripheral(CorsairPeripher
 
     mode Direct;
     Direct.name       = "Direct";
-    Direct.value      = 0;
+    Direct.value      = CORSAIR_MODE_DIRECT_VALUE;
     Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
     Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
+    if(supports_hardware_modes)
+    {
+        mode ColorPulse;
+        ColorPulse.name                 = "ColorPulse";
+        ColorPulse.value                = CORSAIR_HW_MODE_COLOR_PULSE_VALUE;
+        ColorPulse.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+        ColorPulse.color_mode           = MODE_COLORS_RANDOM;
+        ColorPulse.speed                = CORSAIR_HW_MODE_SPEED_MIN;
+        ColorPulse.speed_min            = CORSAIR_HW_MODE_SPEED_MIN;
+        ColorPulse.speed_max            = CORSAIR_HW_MODE_SPEED_MAX;
+        ColorPulse.brightness           = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
+        ColorPulse.brightness_min       = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
+        ColorPulse.brightness_max       = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
+        ColorPulse.colors.resize(2);
+        modes.push_back(ColorPulse);
+
+        mode ColorShift;
+        ColorShift.name                 = "ColorShift";
+        ColorShift.value                = CORSAIR_HW_MODE_COLOR_SHIFT_VALUE;
+        ColorShift.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+        ColorShift.color_mode           = MODE_COLORS_RANDOM;
+        ColorShift.speed                = CORSAIR_HW_MODE_SPEED_MIN;
+        ColorShift.speed_min            = CORSAIR_HW_MODE_SPEED_MIN;
+        ColorShift.speed_max            = CORSAIR_HW_MODE_SPEED_MAX;
+        ColorShift.brightness           = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
+        ColorShift.brightness_min       = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
+        ColorShift.brightness_max       = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
+        ColorShift.colors.resize(2);
+        modes.push_back(ColorShift);
+
+        mode ColorWave;
+        ColorWave.name                  = "ColorWave";
+        ColorWave.value                 = CORSAIR_HW_MODE_COLOR_WAVE_VALUE;
+        ColorWave.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+        ColorWave.color_mode            = MODE_COLORS_RANDOM;
+        ColorWave.direction             = MODE_DIRECTION_LEFT;
+        ColorWave.speed                 = CORSAIR_HW_MODE_SPEED_MIN;
+        ColorWave.speed_min             = CORSAIR_HW_MODE_SPEED_MIN;
+        ColorWave.speed_max             = CORSAIR_HW_MODE_SPEED_MAX;
+        ColorWave.brightness            = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
+        ColorWave.brightness_min        = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
+        ColorWave.brightness_max        = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
+        ColorWave.colors.resize(2);
+        modes.push_back(ColorWave);
+
+        mode RainbowWave;
+        RainbowWave.name                = "RainbowWave";
+        RainbowWave.value               = CORSAIR_HW_MODE_RAINBOW_WAVE_VALUE;
+        RainbowWave.flags               = MODE_FLAG_HAS_SPEED |  MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+        RainbowWave.color_mode          = MODE_COLORS_NONE;
+        RainbowWave.direction           = MODE_DIRECTION_LEFT;
+        RainbowWave.speed               = CORSAIR_HW_MODE_SPEED_MIN;
+        RainbowWave.speed_min           = CORSAIR_HW_MODE_SPEED_MIN;
+        RainbowWave.speed_max           = CORSAIR_HW_MODE_SPEED_MAX;
+        RainbowWave.brightness          = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
+        RainbowWave.brightness_min      = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
+        RainbowWave.brightness_max      = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
+        modes.push_back(RainbowWave);
+
+        mode Rain;
+        Rain.name                       = "Rain";
+        Rain.value                      = CORSAIR_HW_MODE_RAIN_VALUE;
+        Rain.flags                      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+        Rain.color_mode                 = MODE_COLORS_RANDOM;
+        Rain.speed                      = CORSAIR_HW_MODE_SPEED_MIN;
+        Rain.speed_min                  = CORSAIR_HW_MODE_SPEED_MIN;
+        Rain.speed_max                  = CORSAIR_HW_MODE_SPEED_MAX;
+        Rain.brightness                 = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
+        Rain.brightness_min             = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
+        Rain.brightness_max             = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
+        Rain.colors.resize(2);
+        modes.push_back(Rain);
+
+        mode Spiral;
+        Spiral.name                     = "Spiral";
+        Spiral.value                    = CORSAIR_HW_MODE_SPIRAL_VALUE;
+        Spiral.flags                    = MODE_FLAG_HAS_SPEED |  MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+        Spiral.color_mode               = MODE_COLORS_NONE;
+        Spiral.speed                    = CORSAIR_HW_MODE_SPEED_MIN;
+        Spiral.speed_min                = CORSAIR_HW_MODE_SPEED_MIN;
+        Spiral.speed_max                = CORSAIR_HW_MODE_SPEED_MAX;
+        Spiral.brightness               = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
+        Spiral.brightness_min           = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
+        Spiral.brightness_max           = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
+        Spiral.direction                = MODE_DIRECTION_LEFT;
+        modes.push_back(Spiral);
+
+        mode TypeKey;
+        TypeKey.name                    = "TypeKey";
+        TypeKey.value                   = CORSAIR_HW_MODE_TYPE_KEY_VALUE;
+        TypeKey.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+        TypeKey.color_mode              = MODE_COLORS_RANDOM;
+        TypeKey.speed                   = CORSAIR_HW_MODE_SPEED_MIN;
+        TypeKey.speed_min               = CORSAIR_HW_MODE_SPEED_MIN;
+        TypeKey.speed_max               = CORSAIR_HW_MODE_SPEED_MAX;
+        TypeKey.brightness              = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
+        TypeKey.brightness_min          = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
+        TypeKey.brightness_max          = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
+        TypeKey.colors.resize(2);
+        modes.push_back(TypeKey);
+
+        mode TypeRipple;
+        TypeRipple.name                 = "TypeRipple";
+        TypeRipple.value                = CORSAIR_HW_MODE_TYPE_RIPPLE_VALUE;
+        TypeRipple.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+        TypeRipple.color_mode           = MODE_COLORS_RANDOM;
+        TypeRipple.speed                = CORSAIR_HW_MODE_SPEED_MIN;
+        TypeRipple.speed_min            = CORSAIR_HW_MODE_SPEED_MIN;
+        TypeRipple.speed_max            = CORSAIR_HW_MODE_SPEED_MAX;
+        TypeRipple.brightness           = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
+        TypeRipple.brightness_min       = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
+        TypeRipple.brightness_max       = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
+        TypeRipple.colors.resize(2);
+        modes.push_back(TypeRipple);
+
+        mode Visor;
+        Visor.name                      = "Visor";
+        Visor.value                     = CORSAIR_HW_MODE_VISOR_VALUE;
+        Visor.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+        Visor.color_mode                = MODE_COLORS_RANDOM;
+        Visor.speed                     = CORSAIR_HW_MODE_SPEED_MIN;
+        Visor.speed_min                 = CORSAIR_HW_MODE_SPEED_MIN;
+        Visor.speed_max                 = CORSAIR_HW_MODE_SPEED_MAX;
+        Visor.brightness                = CORSAIR_HW_MODE_BRIGHTNESS_MAX / 2;
+        Visor.brightness_min            = CORSAIR_HW_MODE_BRIGHTNESS_MIN;
+        Visor.brightness_max            = CORSAIR_HW_MODE_BRIGHTNESS_MAX;
+        Visor.colors.resize(2);
+        modes.push_back(Visor);
+    }
+
+
     SetupZones();
 }
 
@@ -1037,14 +1173,14 @@ void RGBController_CorsairPeripheral::SetupZones()
                     new_led.name = corsair_mouse_leds[led_idx];
                 }
                 break;
-            
+
             case DEVICE_TYPE_MOUSEMAT:
             case DEVICE_TYPE_HEADSET_STAND:
                 new_led.name = "Mousemat LED ";
                 new_led.name.append(std::to_string(led_idx + 1));
                 break;
         }
-        
+
         leds.push_back(new_led);
     }
 
@@ -1081,4 +1217,29 @@ void RGBController_CorsairPeripheral::SetCustomMode()
 void RGBController_CorsairPeripheral::DeviceUpdateMode()
 {
 
+    if(modes[active_mode].value == CORSAIR_MODE_DIRECT_VALUE)
+    {
+        controller->SwitchMode(true);
+    }
+    else
+    {
+        const mode& active = modes[active_mode];
+
+        unsigned int direction = active.direction;
+
+        if(active.flags & MODE_FLAG_HAS_DIRECTION_LR || active.flags & MODE_FLAG_HAS_DIRECTION_UD)
+        {
+            direction += 1;
+
+            if(active.value == CORSAIR_HW_MODE_SPIRAL_VALUE)
+            {
+                direction += 4;
+            }
+        }
+
+        controller->SetHardwareMode(active.value, active.color_mode, active.colors, active.speed, direction, active.brightness);
+
+        controller->SwitchMode(false);
+    }
+
 }

Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.h

@@ -14,7 +14,7 @@
 class RGBController_CorsairPeripheral : public RGBController
 {
 public:
-    RGBController_CorsairPeripheral(CorsairPeripheralController* controller_ptr);
+    RGBController_CorsairPeripheral(CorsairPeripheralController* controller_ptr, bool supports_hardware_modes);
     ~RGBController_CorsairPeripheral();
 
     int         physical_layout;
@@ -31,6 +31,7 @@ public:
     void        SetCustomMode();
     void        DeviceUpdateMode();
 
+
 private:
     CorsairPeripheralController* controller;
 };

Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.cpp

@@ -11,8 +11,9 @@
 
 /**------------------------------------------------------------------*\
     @name Corsair Vengeance
+    @category RAM
     @type SMBus
-    @save :warning:
+    @save :robot:
     @direct :x:
     @effects :white_check_mark:
     @detectors DetectCorsairVengeanceControllers

Controllers/CorsairVengeanceProController/RGBController_CorsairVengeancePro.cpp

@@ -11,8 +11,9 @@
 
 /**------------------------------------------------------------------*\
     @name Corsair Vengeance Pro
+    @category RAM
     @type SMBus
-    @save :warning:
+    @save :robot:
     @direct :white_check_mark:
     @effects :white_check_mark:
     @detectors DetectCorsairVengeanceProControllers
@@ -291,7 +292,7 @@ void RGBController_CorsairVengeancePro::DeviceUpdateMode()
             mode_colors[3] = RGBGetRValue(modes[active_mode].colors[1]);
             mode_colors[4] = RGBGetGValue(modes[active_mode].colors[1]);
             mode_colors[5] = RGBGetBValue(modes[active_mode].colors[1]);
-        }        
+        }
     }
 
     if (modes[active_mode].name == "Direct")

Controllers/CorsairWirelessController/RGBController_CorsairWireless.cpp

@@ -182,6 +182,7 @@ static const char* led_names[] =
 
 /**------------------------------------------------------------------*\
     @name Corsair Wireless Peripheral
+    @category Keyboard
     @type USB
     @save :x:
     @direct :white_check_mark:

Controllers/CougarController/RGBController_CougarRevengerST.cpp

@@ -14,6 +14,7 @@
 
 /**------------------------------------------------------------------*\
     @name Cougar Revenger ST
+    @category Mouse
     @type USB
     @save :x:
     @direct :white_check_mark:

Controllers/CreativeController/RGBController_CreativeSoundBlasterXG6.cpp

@@ -2,6 +2,7 @@
 
 /**------------------------------------------------------------------*\
     @name Creative Sound BlasterX G6
+    @category Headset
     @type USB
     @save :x:
     @direct :white_check_mark:

Controllers/CrucialController/RGBController_Crucial.cpp

@@ -11,6 +11,7 @@
 
 /**------------------------------------------------------------------*\
     @name Crucial RAM
+    @category RAM
     @type SMBus
     @save :x:
     @direct :white_check_mark:
@@ -43,7 +44,7 @@ RGBController_Crucial::RGBController_Crucial(CrucialController* controller_ptr)
     Shift.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
     Shift.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Shift);
-    
+
     mode GradientShift;
     GradientShift.name       = "Gradient Shift";
     GradientShift.value      = CRUCIAL_MODE_GRADIENT_SHIFT;

Controllers/DarkProject/RGBController_DarkProjectKeyboard.cpp

@@ -116,8 +116,9 @@ static const char *led_names[] =
     KEY_EN_RIGHT_ARROW
 };
 
-/**
+/**------------------------------------------------------------------*\
     @name Dark Project Keyboard
+    @category Keyboard
     @type USB
     @save :x:
     @direct :white_check_mark:
@@ -125,7 +126,7 @@ static const char *led_names[] =
     @detectors DetectDarkProjectKeyboardControllers
     @comment The Dark Project keyboard controller currently supports
         the full size KD3B Version 2 (ANSI layout).
-*/
+\*-------------------------------------------------------------------*/
 
 RGBController_DarkProjectKeyboard::RGBController_DarkProjectKeyboard(DarkProjectKeyboardController *controller_ptr)
 {

Controllers/DasKeyboardController/RGBController_DasKeyboard.cpp

@@ -192,6 +192,7 @@ static const char *led_names[] =
 
 /**------------------------------------------------------------------*\
     @name Das Keyboard
+    @category Keyboard
     @type USB
     @save :x:
     @direct :white_check_mark:

Controllers/DebugController/RGBController_Debug.cpp

@@ -5,6 +5,7 @@
 
 /**------------------------------------------------------------------*\
     @name Debug
+    @category Unknown
     @type I2C
     @save :x:
     @direct :x:
@@ -43,7 +44,7 @@ void RGBController_Debug::ResizeZone(int index, int new_size)
 
     // Add the new ammount of LEDs to the old ammount
     size_t new_leds_size = leds.size() - old_size + new_size;
-    
+
     leds.resize(std::max(old_leds_size, new_leds_size));
 
     memmove(&leds[zones[index].start_idx] + old_leds_size, &leds[zones[index].start_idx] + new_leds_size, (old_leds_size - zones[index].start_idx - old_size) * sizeof(led));
@@ -54,6 +55,6 @@ void RGBController_Debug::ResizeZone(int index, int new_size)
     {
         leds[zones[index].start_idx + i].name = "Linear LED " + std::to_string(i);
     }
-    
+
     SetupColors();
 }

Controllers/DuckyKeyboardController/RGBController_DuckyKeyboard.cpp

@@ -188,9 +188,10 @@ static const char *led_names[] =
 
 /**------------------------------------------------------------------*\
     @name Ducky Keyboard
+    @category Keyboard
     @type USB
     @save :x:
-    @direct :white_check_mark
+    @direct :white_check_mark:
     @effects :x:
     @detectors DetectDuckyKeyboardControllers
     @comment
@@ -291,11 +292,11 @@ void RGBController_DuckyKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
     | This device does not support resizing zones               |
     \*---------------------------------------------------------*/
 }
-    
+
 void RGBController_DuckyKeyboard::DeviceUpdateLEDs()
 {
     unsigned char colordata[155*3];
-    
+
     for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
     {
         colordata[(color_idx*3)+0] = RGBGetRValue(colors[color_idx]);

Controllers/DygmaRaiseController/DygmaRaiseControllerDetect.cpp

@@ -37,3 +37,8 @@ void DetectDygmaRaiseControllers(std::vector<RGBController*> &rgb_controllers)
 }
 
 REGISTER_DETECTOR("Dygma Raise", DetectDygmaRaiseControllers);
+/*---------------------------------------------------------------------------------------------------------*\
+| Entries for dynamic UDEV rules                                                                            |
+|                                                                                                           |
+| DUMMY_DEVICE_DETECTOR("Dygma Raise", DetectDygmaRaiseControllers, 0x1209, 0x2201 )                        |
+\*---------------------------------------------------------------------------------------------------------*/

Controllers/DygmaRaiseController/RGBController_DygmaRaise.cpp

@@ -17,8 +17,8 @@ static unsigned int kb_matrix_map_ISO[6][14] =
     { {  0,  1,  2,  3,  4,  5,  6, 39, 38, 37, 36, 35, 34, 33 },
       {  7,  8,  9, 10, 11, 12, 47, 46, 45, 44, 43, 42, 41, 40 },
       { 13, 14, 15, 16, 17, 18, 54, 53, 52, 51, 50, 49, 48, NA },
-      { 19, 20, 21, 22, 23, 24, 25, 60, 59, 58, 57, 56, 55, NA }, 
-      { 26, 27, 28, NA, 29, 30, NA, 66, 65, NA, 64, 63, 62, 61 }, 
+      { 19, 20, 21, 22, 23, 24, 25, 60, 59, 58, 57, 56, 55, NA },
+      { 26, 27, 28, NA, 29, 30, NA, 66, 65, NA, 64, 63, 62, 61 },
       { NA, NA, NA, NA, 31, 32, NA, 68, 67, NA, NA, NA, NA, NA } };
 
 static unsigned int underglow_matrix[11][14] =
@@ -77,20 +77,20 @@ static const char* led_names[] =
     KEY_EN_D,
     KEY_EN_F,
     KEY_EN_G,
-    KEY_EN_LEFT_SHIFT,             
-    KEY_EN_ISO_BACK_SLASH,               
+    KEY_EN_LEFT_SHIFT,
+    KEY_EN_ISO_BACK_SLASH,
     KEY_EN_Z,
     KEY_EN_X,
     KEY_EN_C,
     KEY_EN_V,
     KEY_EN_B,
-    KEY_EN_LEFT_CONTROL,           
-    KEY_EN_LEFT_WINDOWS,           
+    KEY_EN_LEFT_CONTROL,
+    KEY_EN_LEFT_WINDOWS,
     KEY_EN_LEFT_ALT,
-    "Key: T1",                     
-    "Key: T2",                     
-    "Key: T3",                     
-    "Key: T4",                     
+    "Key: T1",
+    "Key: T2",
+    "Key: T3",
+    "Key: T4",
     KEY_EN_BACKSPACE,
     KEY_EN_EQUALS,
     KEY_EN_MINUS,
@@ -98,9 +98,9 @@ static const char* led_names[] =
     KEY_EN_9,
     KEY_EN_8,
     KEY_EN_7,
-    KEY_EN_ANSI_ENTER,                  
-    KEY_EN_RIGHT_BRACKET,                      
-    KEY_EN_LEFT_BRACKET,                      
+    KEY_EN_ANSI_ENTER,
+    KEY_EN_RIGHT_BRACKET,
+    KEY_EN_LEFT_BRACKET,
     KEY_EN_P,
     KEY_EN_O,
     KEY_EN_I,
@@ -113,24 +113,25 @@ static const char* led_names[] =
     KEY_EN_K,
     KEY_EN_J,
     KEY_EN_H,
-    KEY_EN_RIGHT_SHIFT,            
-    KEY_EN_FORWARD_SLASH,                      
+    KEY_EN_RIGHT_SHIFT,
+    KEY_EN_FORWARD_SLASH,
     KEY_EN_PERIOD,
     KEY_EN_COMMA,
     KEY_EN_M,
     KEY_EN_N,
-    KEY_EN_RIGHT_CONTROL,          
-    KEY_EN_RIGHT_WINDOWS,          
-    KEY_EN_RIGHT_FUNCTION,               
-    KEY_EN_RIGHT_ALT,              
-    "Key: T6",                     
-    "Key: T5",                     
-    "Key: T8",                     
-    "Key: T7",             
+    KEY_EN_RIGHT_CONTROL,
+    KEY_EN_RIGHT_WINDOWS,
+    KEY_EN_RIGHT_FUNCTION,
+    KEY_EN_RIGHT_ALT,
+    "Key: T6",
+    "Key: T5",
+    "Key: T8",
+    "Key: T7",
 };
 
 /**------------------------------------------------------------------*\
     @name Dygma Raise Keyboard
+    @category Keyboard
     @type Serial
     @save :x:
     @direct :white_check_mark:
@@ -139,7 +140,7 @@ static const char* led_names[] =
     @comment
 \*-------------------------------------------------------------------*/
 
-RGBController_DygmaRaise::RGBController_DygmaRaise(DygmaRaiseController* controller_ptr) 
+RGBController_DygmaRaise::RGBController_DygmaRaise(DygmaRaiseController* controller_ptr)
 {
     controller      = controller_ptr;
 
@@ -159,12 +160,12 @@ RGBController_DygmaRaise::RGBController_DygmaRaise(DygmaRaiseController* control
     SetupZones();
 }
 
-RGBController_DygmaRaise::~RGBController_DygmaRaise() 
+RGBController_DygmaRaise::~RGBController_DygmaRaise()
 {
     delete controller;
 }
 
-void RGBController_DygmaRaise::SetupZones() 
+void RGBController_DygmaRaise::SetupZones()
 {
     /*---------------------------------------------------------*\
     | Set up zones                                              |
@@ -192,10 +193,10 @@ void RGBController_DygmaRaise::SetupZones()
             new_zone.matrix_map->width      = 14;
             new_zone.matrix_map->map        = (unsigned int *)&underglow_matrix;
         }
-        
+
         zones.push_back(new_zone);
     }
-    
+
     /*---------------------------------------------------------*\
     | Set up keyboard LEDs                                      |
     \*---------------------------------------------------------*/
@@ -226,7 +227,7 @@ void RGBController_DygmaRaise::SetupZones()
     SetupColors();
 }
 
-void RGBController_DygmaRaise::ResizeZone(int /*zone*/, int /*new_size*/) 
+void RGBController_DygmaRaise::ResizeZone(int /*zone*/, int /*new_size*/)
 {
     /*---------------------------------------------------------*\
     | This device does not support resizing zones               |
@@ -234,27 +235,27 @@ void RGBController_DygmaRaise::ResizeZone(int /*zone*/, int /*new_size*/)
 }
 
 
-void RGBController_DygmaRaise::DeviceUpdateLEDs() 
+void RGBController_DygmaRaise::DeviceUpdateLEDs()
 {
     controller->SendDirect(colors,leds.size());
 }
 
-void RGBController_DygmaRaise::UpdateZoneLEDs(int /*zone*/) 
+void RGBController_DygmaRaise::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_DygmaRaise::UpdateSingleLED(int /*led*/) 
+void RGBController_DygmaRaise::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_DygmaRaise::SetCustomMode() 
+void RGBController_DygmaRaise::SetCustomMode()
 {
     active_mode = 0;
 }
 
-void RGBController_DygmaRaise::DeviceUpdateMode() 
+void RGBController_DygmaRaise::DeviceUpdateMode()
 {
-    
+
 }

Controllers/E131Controller/RGBController_E131.cpp

@@ -15,6 +15,7 @@ using namespace std::chrono_literals;
 
 /**------------------------------------------------------------------*\
     @name E1.31 Devices
+    @category LEDStrip
     @type E1.31
     @save :x:
     @direct :white_check_mark:
@@ -114,7 +115,7 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
     for(unsigned int univ_list_idx = 0; univ_list_idx < universe_list.size(); univ_list_idx++)
     {
         location += std::to_string(universe_list[univ_list_idx]);
-        
+
         if(univ_list_idx < (universe_list.size() - 1))
         {
             location += ", ";
@@ -135,7 +136,7 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
     | Create E1.31 socket                       |
     \*-----------------------------------------*/
     sockfd = e131_socket();
-    
+
     keepalive_delay = 0ms;
 
     SetupZones();
@@ -291,7 +292,7 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
             }
             zones[device_idx].matrix_map = new_map;
         }
-	}
+    }
 
     if(keepalive_delay.count() > 0)
     {
@@ -380,7 +381,7 @@ void RGBController_E131::DeviceUpdateLEDs()
     int color_idx = 0;
 
     last_update_time = std::chrono::steady_clock::now();
-    
+
     for(std::size_t device_idx = 0; device_idx < devices.size(); device_idx++)
     {
         float universe_size = devices[device_idx].universe_size;
@@ -441,12 +442,12 @@ void RGBController_E131::DeviceUpdateLEDs()
 
 void RGBController_E131::UpdateZoneLEDs(int /*zone*/)
 {
-	DeviceUpdateLEDs();
+    DeviceUpdateLEDs();
 }
 
 void RGBController_E131::UpdateSingleLED(int /*led*/)
 {
-	DeviceUpdateLEDs();
+    DeviceUpdateLEDs();
 }
 
 void RGBController_E131::SetCustomMode()

Controllers/EKController/RGBController_EKController.cpp

@@ -11,8 +11,9 @@
 
 /**------------------------------------------------------------------*\
     @name EK Loop Connect
+    @category LEDStrip
     @type USB
-    @save :warning:
+    @save :robot:
     @direct :x:
     @effects :white_check_mark:
     @detectors DetectEKControllers

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -68,61 +68,6 @@ static const unsigned char aura_mobo_addresses[] =
     0x4F
 };
 
-/*---------------------------------------------------------------------------------*\
-| This list contains ASUS GPUs which use an ENE RGB controller                      |
-\*---------------------------------------------------------------------------------*/
-
-typedef struct
-{
-    int             pci_vendor;
-    int             pci_device;
-    int             pci_subsystem_vendor;
-    int             pci_subsystem_device;
-    unsigned char   controller_address;
-    const char *    name;
-} gpu_pci_device;
-
-#define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const gpu_pci_device device_list[] =
-{
-    { NVIDIA_VEN,       NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,       ASUS_KO_RTX_3060_OC_O12G_GAMING,            0x67,   "ASUS KO RTX 3060 OC O12G GAMING"           },
-    { NVIDIA_VEN,       NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,       ASUS_TUF_RTX_3060_O12G_GAMING,              0x67,   "ASUS TUF 3060 O12G GAMING"                 },
-    { NVIDIA_VEN,       NVIDIA_RTX3060_GA104_DEV,   ASUS_SUB_VEN,       ASUS_TUF_RTX_3060_O12G_V2_GAMING,           0x67,   "ASUS TUF 3060 O12G V2 GAMING"              },
-    { NVIDIA_VEN,       NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,       ASUS_TUF_RTX_3060_O12G_LHR_GAMING,          0x67,   "ASUS TUF 3060 O12G V2 GAMING"              },
-    { NVIDIA_VEN,       NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3060_O12G_GAMING,        0x67,   "ASUS ROG STRIX 3060 O12G GAMING"           },
-    { NVIDIA_VEN,       NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3060_O12G_LHR_GAMING,    0x67,   "ASUS ROG STRIX 3060 O12G V2 GAMING"        },
-    { NVIDIA_VEN,       NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,       ASUS_KO_RTX3060TI_O8G_V2_GAMING,            0x67,   "ASUS KO RTX 3060Ti O8G V2 GAMING"          },
-    { NVIDIA_VEN,       NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,       ASUS_TUF_RTX_3060_TI_O8G_OC,                0x67,   "ASUS TUF RTX 3060Ti O8G OC"                },
-    { NVIDIA_VEN,       NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_3060_TI_O8G_OC,              0x67,   "ASUS ROG STRIX 3060Ti O8G OC"              },
-    { NVIDIA_VEN,       NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,       ASUS_TUF_RTX_3060_TI_O8G_OC_V2,             0x67,   "ASUS TUF RTX 3060Ti O8G OC"                },
-    { NVIDIA_VEN,       NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3070_OC,                 0x67,   "ASUS ROG STRIX 3070 OC"                    },
-    { NVIDIA_VEN,       NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3070_O8G_WHITE,          0x67,   "ASUS ROG STRIX 3070 O8G White"             },
-    { NVIDIA_VEN,       NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3070_08G_V2_GAMING,      0x67,   "ASUS ROG STRIX 3070 O8G V2 GAMING"         },
-    { NVIDIA_VEN,       NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,       ASUS_TUF_RTX_3070_O8G_GAMING,               0x67,   "ASUS TUF RTX 3070 O8G GAMING"              },
-    { NVIDIA_VEN,       NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,       ASUS_KO_RTX_3070_O8G_GAMING,                0x67,   "ASUS KO RTX 3070 O8G V2 GAMING"            },
-    { NVIDIA_VEN,       NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,       ASUS_TUF_RTX_3070_O8G_V2_GAMING,            0x67,   "ASUS TUF RTX 3070 O8G V2 GAMING"           },
-    { NVIDIA_VEN,       NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3070TI_O8G_GAMING,       0x67,   "ASUS ROG STRIX 3070Ti O8G GAMING"          },
-    { NVIDIA_VEN,       NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,       ASUS_TUF_RTX_3070TI_O8G_V2_GAMING,          0x67,   "ASUS TUF RTX 3070Ti O8G V2 GAMING"         },
-    { NVIDIA_VEN,       NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,       ASUS_TUF_RTX_3070TI_O8G_GAMING,             0x67,   "ASUS TUF RTX 3070Ti O8G GAMING"            },
-    { NVIDIA_VEN,       NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3080_O10G_GAMING,        0x67,   "ASUS ROG STRIX 3080 O10G GAMING"           },
-    { NVIDIA_VEN,       NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3080_O10G_WHITE,         0x67,   "ASUS ROG STRIX 3080 O10G WHITE"            },
-    { NVIDIA_VEN,       NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3080_O10G_V2_WHITE,      0x67,   "ASUS ROG STRIX 3080 O10G V2 WHITE"         },
-    { NVIDIA_VEN,       NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,       ASUS_TUF_RTX_3080_10G_GAMING_PD,            0x67,   "ASUS TUF RTX 3080 10G GAMING"              },
-    { NVIDIA_VEN,       NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,       ASUS_TUF_RTX_3080_O10G_OC,                  0x67,   "ASUS TUF RTX 3080 O10G OC"                 },
-    { NVIDIA_VEN,       NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,       ASUS_TUF_RTX_3080_O10G_V2_GAMING_8822,      0x67,   "ASUS TUF RTX 3080 O10G V2 GAMING"          },
-    { NVIDIA_VEN,       NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,       ASUS_TUF_RTX_3080_O10G_V2_GAMING,           0x67,   "ASUS TUF RTX 3080 O10G V2 GAMING"          },
-    { NVIDIA_VEN,       NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3080_O10G_V2_GAMING,     0x67,   "ASUS ROG STRIX RTX 3080 O10G V2 GAMING"    },
-    { NVIDIA_VEN,       NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,       ASUS_TUF_RTX_3080TI_O12G_GAMING,            0x67,   "ASUS TUF RTX 3080Ti O12G GAMING"           },
-    { NVIDIA_VEN,       NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3080TI_O12G_GAMING,      0x67,   "ASUS ROG STRIX 3080Ti O12G GAMING"         },
-    { NVIDIA_VEN,       NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3090_24G_GAMING,         0x67,   "ASUS ROG STRIX 3090 24G GAMING"            },
-    { NVIDIA_VEN,       NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3090_O24G_GAMING,        0x67,   "ASUS ROG STRIX 3090 O24G GAMING"           },
-    { NVIDIA_VEN,       NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3090_O24G_GAMING_WHITE,  0x67,   "ASUS ROG STRIX 3090 O24G GAMING White OC"  },
-    { NVIDIA_VEN,       NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,       ASUS_TUF_RTX_3090_O24G,                     0x67,   "ASUS TUF RTX 3090 O24G"                    },
-    { NVIDIA_VEN,       NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,       ASUS_TUF_RTX_3090_O24G_OC,                  0x67,   "ASUS TUF RTX 3090 O24G OC"                 },
-};
-
-
 /******************************************************************************************\
 *                                                                                          *
 *   ENERegisterRead                                                                        *
@@ -358,41 +303,68 @@ void DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &bus
 *                                                                                          *
 \******************************************************************************************/
 
-#define GPU_CHECK_DEVICE_MESSAGE_EN     "[%s] Bus %02d is a GPU and the subvendor matches the one for %s, looking for a device at %02X"
+#define GPU_CHECK_DEVICE_MESSAGE_EN     "[%s] Bus %02d is a GPU and the subvendor matches the one for %s, looking for a device at 0x%02X"
 
-void DetectENESMBusGPUControllers(std::vector<i2c_smbus_interface*> &busses)
+void DetectENESMBusGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    if(TestForENESMBusController(bus, i2c_addr))
     {
-        for(unsigned int dev_idx = 0; dev_idx < GPU_NUM_DEVICES; dev_idx++)
-        {
-            if(busses[bus]->pci_vendor           == device_list[dev_idx].pci_vendor           &&
-               busses[bus]->pci_device           == device_list[dev_idx].pci_device           &&
-               busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
-               busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
-            {
-                LOG_DEBUG(GPU_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, device_list[dev_idx].controller_address);
+        ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(bus);
+        ENESMBusController*          controller     = new ENESMBusController(interface, i2c_addr);
+        RGBController_ENESMBus*      rgb_controller = new RGBController_ENESMBus(controller);
 
-                if(TestForENESMBusController(busses[bus], device_list[dev_idx].controller_address))
-                {
-                    ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(busses[bus]);
-                    ENESMBusController*          controller     = new ENESMBusController(interface, device_list[dev_idx].controller_address);
-                    RGBController_ENESMBus*      rgb_controller = new RGBController_ENESMBus(controller);
+        rgb_controller->name                        = name;
+        rgb_controller->type                        = DEVICE_TYPE_GPU;
 
-                    rgb_controller->name = device_list[dev_idx].name;
-                    rgb_controller->type = DEVICE_TYPE_GPU;
-
-                    ResourceManager::get()->RegisterRGBController(rgb_controller);
-                }
-                else
-                {
-                    LOG_DEBUG("[ENE SMBus ASUS GPU] Testing for controller at %d failed", device_list[dev_idx].controller_address);
-                }
-            }
-        }
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+    else
+    {
+        LOG_DEBUG("[ENE SMBus ASUS GPU] Testing for controller at %d failed", i2c_addr);
     }
 } /* DetectENESMBusGPUControllers() */
 
 REGISTER_I2C_DETECTOR("ENE SMBus DRAM",                 DetectENESMBusDRAMControllers);
 REGISTER_I2C_DETECTOR("ASUS Aura SMBus Motherboard",    DetectENESMBusMotherboardControllers);
-REGISTER_I2C_DETECTOR("ASUS Aura GPU (ENE)",            DetectENESMBusGPUControllers);
+
+REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060 OC O12G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_KO_RTX_3060_OC_O12G_GAMING,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF 3060 O12G GAMING",                  DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_O12G_GAMING,              0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF 3060 O12G V2 GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_GA104_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_O12G_V2_GAMING,           0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF 3060 O12G V2 GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_O12G_LHR_GAMING,          0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060 O12G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060_O12G_GAMING,        0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060 O12G V2 GAMING",         DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060_O12G_LHR_GAMING,    0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060 O12G V2 GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,     ASUS_SUB_VEN,   ASUS_KO_RTX_3060_O12G_V2_GAMING,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3060Ti O8G V2 GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_KO_RTX3060TI_O8G_V2_GAMING,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060Ti O8G OC",                 DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060Ti O8G OC",               DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_3060_TI_O8G_OC,              0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060Ti O8G OC",                 DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC_V2,             0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3060Ti O8G V2",               DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3060TI_O8G_V2_GAMING,    0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 OC",                     DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_OC,                 0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G White",              DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_O8G_WHITE,          0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070 O8G V2 GAMING",          DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070_08G_V2_GAMING,      0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070 O8G GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3070_O8G_GAMING,               0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS KO RTX 3070 O8G V2 GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_KO_RTX_3070_O8G_GAMING,                0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070 O8G V2 GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3070_O8G_V2_GAMING,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3070Ti O8G GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3070TI_O8G_GAMING,       0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070Ti O8G V2 GAMING",          DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3070TI_O8G_V2_GAMING,          0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3070Ti O8G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3070TI_O8G_GAMING,             0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 10G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_10G_GAMING,         0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 O10G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O10G_GAMING,        0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 O10G WHITE",             DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O10G_WHITE,         0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080 O10G V2 WHITE",          DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O10G_V2_WHITE,      0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 10G GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_10G_GAMING_PD,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 10G GAMING",               DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_10G_GAMING,               0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O10G OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_O10G_OC,                  0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O10G V2 GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_O10G_V2_GAMING_8822,      0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O10G V2 GAMING",           DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_O10G_V2_GAMING,           0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080 O12G GAMING",              DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_12G_LHR_DEV, ASUS_SUB_VEN,   ASUS_TUF_RTX_3080_O12G_GAMING,              0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 3080 O12G OC",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_12G_LHR_DEV, ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O12G_OC,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 3080 O10G V2 GAMING",     DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080_O10G_V2_GAMING,     0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080Ti 12G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3080TI_12G_GAMING,             0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3080Ti O12G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,   ASUS_TUF_RTX_3080TI_O12G_GAMING,            0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3080Ti O12G GAMING",          DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3080TI_O12G_GAMING,      0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3090 24G GAMING",             DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3090_24G_GAMING,         0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3090 O24G GAMING",            DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3090_O24G_GAMING,        0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX 3090 O24G GAMING White OC",   DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX_3090_O24G_GAMING_WHITE,  0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3090 O24G",                     DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3090_O24G,                     0x67);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3090 O24G OC",                  DetectENESMBusGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,   ASUS_TUF_RTX_3090_O24G_OC,                  0x67);

Controllers/ENESMBusController/RGBController_ENESMBus.cpp

@@ -10,6 +10,7 @@
 
 /**------------------------------------------------------------------*\
     @name ENE SMBus Device
+    @category RAM,Motherboard,GPU,Storage
     @type SMBus
     @save :white_check_mark:
     @direct :white_check_mark:
@@ -64,7 +65,7 @@ RGBController_ENESMBus::RGBController_ENESMBus(ENESMBusController * controller_p
     Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
     Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
-    
+
     mode Breathing;
     Breathing.name       = "Breathing";
     Breathing.value      = ENE_MODE_BREATHING;
@@ -361,7 +362,7 @@ void RGBController_ENESMBus::SetupZones()
             }
 
             new_zone->matrix_map = NULL;
-            
+
             /*---------------------------------------------------------*\
             | Push new zone to zones vector                             |
             \*---------------------------------------------------------*/