Improved the ResourceManager device list management

Commit amended for code style by Adam Honse <[email protected]>
Logitech code cleanup
2020-11-24 03:35:42 -06:00 · 2020-11-24 08:07:22 +00:00 · 2020-11-23 02:59:05 -06:00 · 2020-11-23 17:58:35 +11:00 · 2020-11-21 23:01:34 -06:00 · 2020-11-21 07:41:33 +00:00
154 changed files with 2694 additions and 1264 deletions
@@ -6,3 +6,4 @@ qrc_*
 OpenRGB
 Makefile
 OpenRGB-x86_64.AppImage
+.qmake.stash
@@ -134,12 +134,28 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0a34", TAG+="uacces
 #                                                               #
 #  Keyboards:                                                   #
 #       HyperX Alloy Elite                                      #
+#                                                               #
+#  Mice:                                                        #
+#       HyperX Pulsefire Surge                                  #
+#                                                               #
+#  Mousemats:                                                   #
+#       HyperX Fury Ultra                                       #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16be", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16d3", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="1705", TAG+="uaccess"

 #---------------------------------------------------------------#
 #  Logitech Peripheral Devices                                  #
 #                                                               #
+#   Keyboards:                                                  #
+#       Logitech G213                                           #
+#       Logitech G512                                           #
+#       Logitech G512 RGB                                       #
+#       Logitech G610                                           #
+#       Logitech G810 #1                                        #
+#       Logitech G810 #2                                        #
+#                                                               #
 #  Mice:                                                        #
 #       Logitech G203 Prodigy                                   #
 #       Logitech G203 Lightsync                                 #
@@ -148,27 +164,28 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16be", TAG+="uacces
 #       Logitech G502 Proteus Spectrum                          #
 #       Logitech G Lightspeed Wireless Gaming Mouse             #
 #       Logitech G Pro Wireless Gaming Mouse (Wired)            #
+#                                                               #
+#  Mousemats:                                                   #
 #       Logitech G Powerplay Mousepad with Lightspeed           #
 #                                                               #
-#   Keyboards:                                                  #
-#       Logitech G512                                           #
-#       Logitech G512 RGB                                       #
-#       Logitech G810 #1                                        #
-#       Logitech G810 #2                                        #
 #---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c336", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c342", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33c", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c333", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c331", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c337", TAG+="uaccess"
+
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c084", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c092", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c083", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08f", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c332", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08b", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c539", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c088", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uaccess"

-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c342", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c337", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c331", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uaccess"

 #---------------------------------------------------------------#
 #  MSI Mysticlight                                              #
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  PolychromeController.cpp                 |
+|  ASRockPolychromeSMBusController.cpp      |
 |                                           |
 |  Driver for for ASRock ASR LED and        |
 |  Polychrome RGB lighting controller       |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 12/14/2019  |
 \*-----------------------------------------*/

-#include "PolychromeController.h"
+#include "ASRockPolychromeSMBusController.h"
 #include <cstring>

 using namespace std::chrono_literals;
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  PolychromeController.h                   |
+|  ASRockPolychromeSMBusController.h        |
 |                                           |
 |  Definitions and types for ASRock         |
 |  ASR LED and Polychrome RGB lighting      |
@@ -1,7 +1,7 @@
 #include "Detector.h"
-#include "PolychromeController.h"
+#include "ASRockPolychromeSMBusController.h"
 #include "RGBController.h"
-#include "RGBController_Polychrome.h"
+#include "RGBController_ASRockPolychromeSMBus.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
 #include <vector>
@@ -10,14 +10,14 @@

 /******************************************************************************************\
 *                                                                                          *
-*   TestForPolychromeController                                                            *
+*   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 TestForPolychromeController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, unsigned char address)
 {
    bool pass = false;

@@ -36,15 +36,15 @@ bool TestForPolychromeController(i2c_smbus_interface* bus, unsigned char address
 *                                                                                          *
 *   DetectPolychromeControllers                                                            *
 *                                                                                          *
-*       Detect ASRock Polychrome RGB controllers on the enumerated I2C busses at address   *
-*       0x6A.                                                                              *
+*       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 DetectPolychromeControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
+void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
 {
    PolychromeController* new_polychrome;
    RGBController_Polychrome* new_controller;
@@ -54,7 +54,7 @@ void DetectPolychromeControllers(std::vector<i2c_smbus_interface*>& busses, std:
        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
        {
            // Check for Polychrome controller at 0x6A
-            if (TestForPolychromeController(busses[bus], 0x6A))
+            if (TestForPolychromeSMBusController(busses[bus], 0x6A))
            {
                new_polychrome = new PolychromeController(busses[bus], 0x6A);

@@ -71,6 +71,6 @@ void DetectPolychromeControllers(std::vector<i2c_smbus_interface*>& busses, std:
        }
    }

-}   /* DetectPolychromeControllers() */
+}   /* DetectSMBusPolychromeControllers() */

-REGISTER_I2C_DETECTOR("ASRock Polychrome", DetectPolychromeControllers);
+REGISTER_I2C_DETECTOR("ASRock Polychrome SMBus", DetectPolychromeSMBusControllers);
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_Polychrome.cpp             |
+|  RGBController_ASRockPolychromeSMBus.cpp  |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  ASRock ASR LED and Polychrome RGB Driver |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 12/15/2019  |
 \*-----------------------------------------*/

-#include "RGBController_Polychrome.h"
+#include "RGBController_ASRockPolychromeSMBus.h"

 #define ASROCK_MAX_ZONES    4
 #define ASROCK_MAX_LEDS     22
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_Polychrome.h               |
+|  RGBController_ASRockPolychromeSMBus.h    |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  ASRock ASR LED and Polychrome RGB Driver |
@@ -10,7 +10,7 @@
 #pragma once

 #include "RGBController.h"
-#include "PolychromeController.h"
+#include "ASRockPolychromeSMBusController.h"

 class RGBController_Polychrome : public RGBController
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraCoreController.cpp                   | 
+|  AsusAuraCoreController.cpp               | 
 |                                           |
 |  Driver for ASUS ROG Aura Core RGB        |
 |  lighting controller                      |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 4/13/2020   |
 \*-----------------------------------------*/

-#include "AuraCoreController.h"
+#include "AsusAuraCoreController.h"
 #include <cstring>

 AuraCoreController::AuraCoreController(hid_device* dev_handle)
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraCoreController.h                     |
+|  AsusAuraCoreController.h                 |
 |                                           |
 |  Definitions and types for ASUS ROG Aura  |
 |  Core RGB lighting controller             |
@@ -1,7 +1,7 @@
 #include "Detector.h"
-#include "AuraCoreController.h"
+#include "AsusAuraCoreController.h"
 #include "RGBController.h"
-#include "RGBController_AuraCore.h"
+#include "RGBController_AsusAuraCore.h"
 #include <vector>
 #include <hidapi/hidapi.h>

@@ -23,7 +23,7 @@ static const unsigned short pid_table[] =
 *                                                                                          *
 \******************************************************************************************/

-void DetectAuraCoreControllers(std::vector<RGBController*>& rgb_controllers)
+void DetectAsusAuraCoreControllers(std::vector<RGBController*>& rgb_controllers)
 {
    hid_device* dev;

@@ -45,4 +45,4 @@ void DetectAuraCoreControllers(std::vector<RGBController*>& rgb_controllers)
    }
 }

-REGISTER_DETECTOR("ASUS Aura Core", DetectAuraCoreControllers);
+REGISTER_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers);
@@ -1,12 +1,12 @@
 /*-----------------------------------------*\
-|  RGBController_AuraCore.cpp               |
+|  RGBController_AsusAuraCore.cpp           |
 |                                           |
 |  Generic RGB Interface for ROG Aura Core  |
 |                                           |
 |  Adam Honse (CalcProgrammer1) 4/17/2020   |
 \*-----------------------------------------*/

-#include "RGBController_AuraCore.h"
+#include "RGBController_AsusAuraCore.h"

 RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* aura_ptr)
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AuraCore.h                 |
+|  RGBController_AsusAuraCore.h             |
 |                                           |
 |  Generic RGB Interface for ROG Aura Core  |
 |                                           |
@@ -9,7 +9,7 @@
 #pragma once

 #include "RGBController.h"
-#include "AuraCoreController.h"
+#include "AsusAuraCoreController.h"

 class RGBController_AuraCore : public RGBController
 {
@@ -1,12 +1,12 @@
 /*-----------------------------------------*\
-|  AuraGPUController.cpp                    |
+|  AsusAuraGPUController.cpp                |
 |                                           |
 |  Driver for ASUS Aura RGB on GPUs         |
 |                                           |
 |  Jan Rettig (Klapstuhl) 14.02.2020        |
 \*-----------------------------------------*/

-#include "AuraGPUController.h"
+#include "AsusAuraGPUController.h"
 #include <cstring>

 AuraGPUController::AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id dev)
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraGPUController.h                      |
+|  AsusAuraGPUController.h                  |
 |                                           |
 |  Definitions for ASUS Aura RGB on GPUs    |
 |                                           |
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraGPUControllerDetect.cpp              |
+|  AsusAuraGPUControllerDetect.cpp          |
 |                                           |
 |  Driver for ASUS Aura RGB on GPUs         |
 |                                           |
@@ -7,9 +7,9 @@
 \*-----------------------------------------*/

 #include "Detector.h"
-#include "AuraGPUController.h"
+#include "AsusAuraGPUController.h"
 #include "RGBController.h"
-#include "RGBController_AuraGPU.h"
+#include "RGBController_AsusAuraGPU.h"
 #include "i2c_smbus.h"
 #include <vector>
 #include <stdio.h>
@@ -38,7 +38,7 @@ static const unsigned char aura_gpu_addresses[] =
 *                                                                                          *
 \******************************************************************************************/

-bool TestForAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
 {
    bool pass = false;

@@ -63,7 +63,7 @@ bool TestForAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
 *                                                                                          *
 \******************************************************************************************/

-void DetectAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
 {
    AuraGPUController* new_aura_gpu;
    RGBController_AuraGPU* new_controller;
@@ -73,7 +73,7 @@ void DetectAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::ve
        // Add Aura-enabled GPU controllers
        for (unsigned int address_list_idx = 0; address_list_idx < AURA_GPU_ADDRESS_COUNT; address_list_idx++)
        {
-            if (TestForAuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]))
+            if (TestForAsusAuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]))
            {
                new_aura_gpu = new AuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]);
                new_controller = new RGBController_AuraGPU(new_aura_gpu);
@@ -85,4 +85,4 @@ void DetectAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::ve
    }
 } /* DetectAuraGPUControllers() */

-REGISTER_I2C_DETECTOR("ASUS Aura GPU", DetectAuraGPUControllers);
+REGISTER_I2C_DETECTOR("ASUS Aura GPU", DetectAsusAuraGPUControllers);
@@ -1,12 +1,12 @@
 /*-----------------------------------------*\
-|  RGBController_AuraGPU.h                  |
+|  RGBController_AsusAuraGPU.h              |
 |                                           |
 |  Generic RGB Interface for Asus Aura GPU  |
 |                                           |
 |  Jan Rettig (Klapstuhl) 14.02.2020        |
 \*-----------------------------------------*/

-#include "RGBController_AuraGPU.h"
+#include "RGBController_AsusAuraGPU.h"

 int RGBController_AuraGPU::GetDeviceMode()
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AuraGPU.h                  |
+|  RGBController_AsusAuraGPU.h              |
 |                                           |
 |  Generic RGB Interface for Asus Aura GPU  |
 |                                           |
@@ -9,7 +9,7 @@
 #pragma once

 #include "RGBController.h"
-#include "AuraGPUController.h"
+#include "AsusAuraGPUController.h"

 class RGBController_AuraGPU : public RGBController
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraSMBusController.cpp                  |
+|  AsusAuraSMBusController.cpp              |
 |                                           |
 |  Driver for ASUS Aura RGB lighting        |
 |  controller                               |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 8/19/2018   |
 \*-----------------------------------------*/

-#include "AuraSMBusController.h"
+#include "AsusAuraSMBusController.h"
 #include <cstring>

 static const char* aura_channels[] =                /* Aura channel strings                 */
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraSMBusController.h                    |
+|  AsusAuraSMBusController.h                |
 |                                           |
 |  Definitions and types for ASUS Aura RGB  |
 |  lighting controller                      |
@@ -1,7 +1,7 @@
 #include "Detector.h"
-#include "AuraSMBusController.h"
+#include "AsusAuraSMBusController.h"
 #include "RGBController.h"
-#include "RGBController_AuraSMBus.h"
+#include "RGBController_AsusAuraSMBus.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
 #include <vector>
@@ -64,7 +64,7 @@ static const unsigned char aura_mobo_addresses[] =
 *                                                                                          *
 \******************************************************************************************/

-void AuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_register reg, unsigned char val)
+void AsusAuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_register reg, unsigned char val)
 {
    //Write Aura register
    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
@@ -83,7 +83,7 @@ void AuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_register
 *                                                                                          *
 \******************************************************************************************/

-bool TestForAuraSMBusController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char address)
 {
    bool pass = false;

@@ -122,7 +122,7 @@ bool TestForAuraSMBusController(i2c_smbus_interface* bus, unsigned char address)
 *                                                                                          *
 \******************************************************************************************/

-void DetectAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
 {
    AuraSMBusController* new_aura;
    RGBController_AuraSMBus* new_controller;
@@ -159,15 +159,15 @@ void DetectAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::

                if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
                {
-                    AuraRegisterWrite(busses[bus], 0x77, AURA_REG_SLOT_INDEX, slot);
-                    AuraRegisterWrite(busses[bus], 0x77, AURA_REG_I2C_ADDRESS, (aura_ram_addresses[address_list_idx] << 1));
+                    AsusAuraRegisterWrite(busses[bus], 0x77, AURA_REG_SLOT_INDEX, slot);
+                    AsusAuraRegisterWrite(busses[bus], 0x77, AURA_REG_I2C_ADDRESS, (aura_ram_addresses[address_list_idx] << 1));
                }
            }

            // Add Aura-enabled controllers at their remapped addresses
            for (unsigned int address_list_idx = 0; address_list_idx < AURA_RAM_ADDRESS_COUNT; address_list_idx++)
            {
-                if (TestForAuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]))
+                if (TestForAsusAuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]))
                {
                    new_aura = new AuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]);
                    new_controller = new RGBController_AuraSMBus(new_aura);
@@ -183,7 +183,7 @@ void DetectAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::
        {
            for (unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
            {
-                if (TestForAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
+                if (TestForAsusAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
                {
                    new_aura = new AuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]);
                    new_controller = new RGBController_AuraSMBus(new_aura);
@@ -197,4 +197,4 @@ void DetectAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::

 }   /* DetectAuraSMBusControllers() */

-REGISTER_I2C_DETECTOR("ASUS Aura SMBus", DetectAuraSMBusControllers);
+REGISTER_I2C_DETECTOR("ASUS Aura SMBus", DetectAsusAuraSMBusControllers);
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AuraSMBus.cpp              |
+|  RGBController_AsusAuraSMBus.cpp          |
 |                                           |
 |  Generic RGB Interface for OpenAuraSDK    |
 |  Asus Aura SMBus driver                   |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 6/13/2019   |
 \*-----------------------------------------*/

-#include "RGBController_AuraSMBus.h"
+#include "RGBController_AsusAuraSMBus.h"

 int RGBController_AuraSMBus::GetDeviceMode()
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AuraSMBus.h                |
+|  RGBController_AsusAuraSMBus.h            |
 |                                           |
 |  Generic RGB Interface for OpenAuraSDK    |
 |  Asus Aura SMBus driver                   |
@@ -10,7 +10,7 @@
 #pragma once

 #include "RGBController.h"
-#include "AuraSMBusController.h"
+#include "AsusAuraSMBusController.h"

 class RGBController_AuraSMBus : public RGBController
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraAddressableController.cpp            |
+|  AsusAuraAddressableController.cpp        |
 |                                           |
 |  Driver for ASUS Aura RGB Addressable     |
 |  lighting controller                      |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 1/18/2020   |
 \*-----------------------------------------*/

-#include "AuraAddressableController.h"
+#include "AsusAuraAddressableController.h"
 #include <cstring>

 AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraAddressableController.h              |
+|  AsusAuraAddressableController.h          |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  Addressable RGB lighting controller      |
@@ -8,7 +8,7 @@
 \*-----------------------------------------*/

 #include "RGBController.h"
-#include "AuraUSBController.h"
+#include "AsusAuraUSBController.h"

 #include <string>
 #include <hidapi/hidapi.h>
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraMainboardController.cpp              |
+|  AsusAuraMainboardController.cpp          |
 |                                           |
 |  Driver for ASUS Aura RGB USB mainboard   |
 |  lighting controller                      |
@@ -7,7 +7,7 @@
 |  Martin Hartl (inlart) 4/25/2020          |
 \*-----------------------------------------*/

-#include "AuraMainboardController.h"
+#include "AsusAuraMainboardController.h"
 #include <cstring>

 AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path), mode(AURA_MODE_DIRECT)
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraMainboardController.h                |
+|  AsusAuraMainboardController.h            |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  USB Mainboard RGB lighting controller    |
@@ -8,7 +8,7 @@
 \*-----------------------------------------*/

 #include "RGBController.h"
-#include "AuraUSBController.h"
+#include "AsusAuraUSBController.h"

 #include <string>
 #include <hidapi/hidapi.h>
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraMouseController.cpp                  |
+|  AsusAuraMouseController.cpp              |
 |                                           |
 |  Driver for ASUS Aura RGB USB             |
 |  lighting controller                      |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 10/23/2020  |
 \*-----------------------------------------*/

-#include "AuraMouseController.h"
+#include "AsusAuraMouseController.h"

 #include <cstring>

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraMouseController.h                    |
+|  AsusAuraMouseController.h                |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  USB RGB lighting controller              |
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraUSBController.cpp                    |
+|  AsusAuraUSBController.cpp                |
 |                                           |
 |  Driver for ASUS Aura RGB USB             |
 |  lighting controller                      |
@@ -7,7 +7,7 @@
 |  Martin Hartl (inlart) 4/25/2020          |
 \*-----------------------------------------*/

-#include "AuraUSBController.h"
+#include "AsusAuraUSBController.h"
 #include <cstring>
 #include <stdexcept>

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraUSBController.h                      |
+|  AsusAuraUSBController.h                  |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  USB RGB lighting controller              |
@@ -1,10 +1,10 @@
 #include "Detector.h"
-#include "AuraAddressableController.h"
-#include "AuraMainboardController.h"
-#include "AuraMouseController.h"
+#include "AsusAuraAddressableController.h"
+#include "AsusAuraMainboardController.h"
+#include "AsusAuraMouseController.h"
 #include "RGBController.h"
-#include "RGBController_AuraUSB.h"
-#include "RGBController_AuraMouse.h"
+#include "RGBController_AsusAuraUSB.h"
+#include "RGBController_AsusAuraMouse.h"
 #include <vector>
 #include <stdexcept>
 #include <hidapi/hidapi.h>
@@ -63,7 +63,7 @@ static const aura_device mouse_device_list[] =
    { AURA_USB_VID,     AURA_ROG_GLADIUS_II_ORIGIN_PID, 2,  "ASUS ROG Gladius II Origin"    },
 };

-void DetectAuraUSBControllers(std::vector<RGBController*>& rgb_controllers)
+void DetectAsusAuraUSBControllers(std::vector<RGBController*>& rgb_controllers)
 {
    hid_device_info* info = NULL;

@@ -167,4 +167,4 @@ void DetectAuraUSBControllers(std::vector<RGBController*>& rgb_controllers)

 }  /* DetectAuraUSBControllers() */

-REGISTER_DETECTOR("ASUS Aura USB", DetectAuraUSBControllers);
+REGISTER_DETECTOR("ASUS Aura USB", DetectAsusAuraUSBControllers);
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AuraMouse.cpp              |
+|  RGBController_AsusAuraMouse.cpp          |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
 |  USB controller driver                    |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 10/25/2020  |
 \*-----------------------------------------*/

-#include "RGBController_AuraMouse.h"
+#include "RGBController_AsusAuraMouse.h"

 RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AuraMouse.h                |
+|  RGBController_AsusAuraMouse.h            |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
 |  USB controller driver                    |
@@ -9,7 +9,7 @@

 #pragma once
 #include "RGBController.h"
-#include "AuraMouseController.h"
+#include "AsusAuraMouseController.h"

 class RGBController_AuraMouse : public RGBController
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AuraUSB.cpp                |
+|  RGBController_AsusAuraUSB.cpp            |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
 |  USB controller driver                    |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 1/18/2020   |
 \*-----------------------------------------*/

-#include "RGBController_AuraUSB.h"
+#include "RGBController_AsusAuraUSB.h"

 RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* aura_ptr)
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AuraUSB.h                  |
+|  RGBController_AsusAuraUSB.h              |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
 |  USB controller driver                    |
@@ -9,7 +9,7 @@

 #pragma once
 #include "RGBController.h"
-#include "AuraUSBController.h"
+#include "AsusAuraUSBController.h"

 #define AURA_ADDRESSABLE_MAX_LEDS       120

@@ -27,20 +27,25 @@ static unsigned char speed_mode_data[][9] =
    { 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 } /* Colour Breath                */
 };

-CMMP750Controller::CMMP750Controller(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path)
+CMMP750Controller::CMMP750Controller(hid_device* dev_handle, char *_path)
 {
-    std::size_t tmp_size    = wcslen(_vendor);
-    dev                     = dev_handle;
-    location                = _path;
+    dev             = dev_handle;
+    location        = _path;

-    for(std::size_t i = 0; (i < tmp_size) && (i < CM_DEVICE_NAME_SIZE); i++)
-    {
-        device_name[i] = (char)_vendor[i];
-    }
-    for(std::size_t j = 0; (j < wcslen(_vendor)) && (tmp_size + j < CM_DEVICE_NAME_SIZE); j++)
-    {
-        device_name[tmp_size + j] = (char)_device_name[j];
-    }
+    const int szTemp = 256;
+    wchar_t tmpName[szTemp];
+
+    hid_get_manufacturer_string(dev, tmpName, szTemp);
+    std::wstring wName = std::wstring(tmpName);
+    device_name        = std::string(wName.begin(), wName.end());
+
+    hid_get_product_string(dev, tmpName, szTemp);
+    wName  = std::wstring(tmpName);
+    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
+
+    hid_get_serial_number_string(dev, tmpName, szTemp);
+    wName  = std::wstring(tmpName);
+    serial = std::string(wName.begin(), wName.end());

    GetStatus();        //When setting up device get current status
 }
@@ -82,12 +87,12 @@ void CMMP750Controller::GetStatus()
    }
 }

-char* CMMP750Controller::GetDeviceName()
+std::string CMMP750Controller::GetDeviceName()
 {
    return device_name;
 }

-char* CMMP750Controller::GetSerial()
+std::string CMMP750Controller::GetSerial()
 {
    return serial;
 }
@@ -60,11 +60,11 @@ enum
 class CMMP750Controller
 {
 public:
-    CMMP750Controller(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path);
+    CMMP750Controller(hid_device* dev_handle, char *_path);
    ~CMMP750Controller();

-    char* GetDeviceName();
-    char* GetSerial();
+    std::string GetDeviceName();
+    std::string GetSerial();
    std::string GetLocation();

    unsigned char GetMode();
@@ -76,8 +76,8 @@ public:
    void SetColor(unsigned char red, unsigned char green, unsigned char blue);

 private:
-    char                    device_name[32];
-    char                    serial[32];
+    std::string             device_name;
+    std::string             serial;
    std::string             location;
    hid_device*             dev;

@@ -74,7 +74,7 @@ void DetectCoolerMasterControllers(std::vector<RGBController*>& rgb_controllers)
        {
            if (dev_type == DEVICE_TYPE_MOUSEMAT)
            {
-                CMMP750Controller* controller                   = new CMMP750Controller(dev, info->manufacturer_string, info->product_string, info->path);
+                CMMP750Controller* controller                   = new CMMP750Controller(dev, info->path);
                RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
                rgb_controllers.push_back(rgb_controller);
            }
@@ -18,7 +18,7 @@ RGBController_CMMP750Controller::RGBController_CMMP750Controller(CMMP750Controll
    type                = DEVICE_TYPE_MOUSEMAT;
    description         = cmmp750->GetDeviceName();
    version             = "1.0";
-    serial              = "";
+    serial              = cmmp750->GetSerial();
    location            = cmmp750->GetLocation();

    mode Static;
@@ -143,25 +143,5 @@ void RGBController_CMMP750Controller::SetCustomMode()

 void RGBController_CMMP750Controller::DeviceUpdateMode()
 {
-    switch(modes[active_mode].value)
-    {
-        case MP750_MODE_STATIC:
-            cmmp750->SetMode(MP750_MODE_STATIC, modes[active_mode].speed);
-            break;
-        case MP750_MODE_BLINK:
-            cmmp750->SetMode(MP750_MODE_BLINK, modes[active_mode].speed);
-            break;
-        case MP750_MODE_BREATHING:
-            cmmp750->SetMode(MP750_MODE_BREATHING, modes[active_mode].speed);
-            break;
-        case MP750_MODE_COLOR_CYCLE:
-            cmmp750->SetMode(MP750_MODE_COLOR_CYCLE, modes[active_mode].speed);
-            break;
-        case MP750_MODE_BREATH_CYCLE:
-            cmmp750->SetMode(MP750_MODE_BREATH_CYCLE, modes[active_mode].speed);
-            break;
-        default:
-            cmmp750->SetMode(MP750_MODE_BREATHING, modes[active_mode].speed);
-            break;
-    }
+    cmmp750->SetMode(modes[active_mode].value, modes[active_mode].speed);
 }
@@ -11,32 +11,8 @@
 #include <string>
 #include <cstring>

-//Include thread libraries for Windows or Linux
-#ifdef WIN32
-#include <process.h>
-#else
-#include "pthread.h"
-#include "unistd.h"
-#endif
-
-//Thread functions have different types in Windows and Linux
-#ifdef WIN32
-#define THREAD static void
-#define THREADRETURN
-#else
-#define THREAD static void*
-#define THREADRETURN return(NULL);
-#endif
-
 using namespace std::chrono_literals;

-THREAD keepalive_thread(void *param)
-{
-    CorsairLightingNodeController* corsair = static_cast<CorsairLightingNodeController*>(param);
-    corsair->KeepaliveThread();
-    THREADRETURN
-}
-
 CorsairLightingNodeController::CorsairLightingNodeController(hid_device* dev_handle, const char* path)
 {
    dev         = dev_handle;
@@ -50,21 +26,20 @@ CorsairLightingNodeController::CorsairLightingNodeController(hid_device* dev_han
    | to not revert back into rainbow mode.  Start a thread |
    | to continuously send a keepalive packet every 5s      |
    \*-----------------------------------------------------*/
-#ifdef WIN32
-    _beginthread(keepalive_thread, 0, this);
-#else
-    pthread_t thread;
-    pthread_create(&thread, NULL, &keepalive_thread, this);
-#endif
+    keepalive_thread_run = 1;
+    keepalive_thread = new std::thread(&CorsairLightingNodeController::KeepaliveThread, this);
 }

 CorsairLightingNodeController::~CorsairLightingNodeController()
 {
+    keepalive_thread_run = 0;
+    keepalive_thread->join();
+    delete keepalive_thread;
 }

 void CorsairLightingNodeController::KeepaliveThread()
 {
-    while(1)
+    while(keepalive_thread_run.load())
    {
        if((std::chrono::steady_clock::now() - last_commit_time) > std::chrono::seconds(5))
        {
@@ -112,6 +112,8 @@ private:
    hid_device*             dev;
    std::string             firmware_version;
    std::string             location;
+    std::thread*            keepalive_thread;
+    std::atomic<bool>       keepalive_thread_run;
    std::chrono::time_point<std::chrono::steady_clock> last_commit_time;

    void            SendFirmwareRequest();
@@ -15,6 +15,9 @@ CrucialController::CrucialController(i2c_smbus_interface* bus, crucial_dev_id de
 {
    this->bus = bus;
    this->dev = dev;
+
+    // We don't know what mode the sticks are in until we set one.
+    this->last_mode = CRUCIAL_MODE_UNKNOWN;
 }

 CrucialController::~CrucialController()
@@ -44,7 +47,11 @@ unsigned int CrucialController::GetLEDCount()

 void CrucialController::SetMode(unsigned char mode)
 {
+    // Don't set a mode if we've already set the same one before.
+    // This is mostly useful for direct mode and updating colors often.
+    if (mode == last_mode) return;
    SendEffectMode(mode, 0x10);
+    last_mode = mode;
 }

 void CrucialController::SetAllColorsDirect(RGBColor* colors)
@@ -80,6 +87,8 @@ void CrucialController::SendEffectMode(unsigned char mode, unsigned char speed)

 void CrucialController::SendDirectColors(RGBColor* color_buf)
 {
+    SetMode(CRUCIAL_MODE_STATIC);
+
    //Red Channels
    CrucialRegisterWrite(0x8300, RGBGetRValue(color_buf[0]));
    CrucialRegisterWrite(0x8301, RGBGetRValue(color_buf[1]));
@@ -18,6 +18,7 @@ typedef unsigned short	crucial_register;

 enum
 {
+    CRUCIAL_MODE_UNKNOWN            = 0x00,     /* We don't know what the mode is   */
    CRUCIAL_MODE_SHIFT              = 0x1F,     /* Shift effect mode                */
    CRUCIAL_MODE_GRADIENT_SHIFT     = 0x2F,     /* Gradient shift mode              */
    CRUCIAL_MODE_FILL               = 0x3F,     /* Fill effect mode                 */
@@ -53,6 +54,7 @@ private:
    unsigned char           config_table[64];
    unsigned int            led_count;
    unsigned char           channel_cfg;
+    unsigned char           last_mode;
    i2c_smbus_interface *   bus;
    crucial_dev_id          dev;

@@ -261,12 +261,21 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)

    if(keepalive_delay.count() > 0)
    {
-        KeepaliveThread = new std::thread(&RGBController_E131::KeepaliveThreadFunction, this);
+        keepalive_thread_run = 1;
+        keepalive_thread = new std::thread(&RGBController_E131::KeepaliveThreadFunction, this);
+    }
+    else
+    {
+        keepalive_thread_run = 0;
+        keepalive_thread = nullptr;
    }
 }

 RGBController_E131::~RGBController_E131()
 {
+    keepalive_thread_run = 0;
+    keepalive_thread->join();
+    delete keepalive_thread;
    /*---------------------------------------------------------*\
    | Delete the matrix map                                     |
    \*---------------------------------------------------------*/
@@ -413,7 +422,7 @@ void RGBController_E131::DeviceUpdateMode()

 void RGBController_E131::KeepaliveThreadFunction()
 {
-    while(1)
+    while(keepalive_thread_run.load())
    {
        if((std::chrono::steady_clock::now() - last_update_time) > ( keepalive_delay * 0.95f ) )
        {
@@ -78,7 +78,8 @@ private:
 	std::vector<e131_addr_t> 	dest_addrs;
 	std::vector<unsigned int> 	universes;
 	int 						sockfd;
-    std::thread *               KeepaliveThread;
+    std::thread *               keepalive_thread;
+    std::atomic<bool>           keepalive_thread_run;
    std::chrono::milliseconds                           keepalive_delay;
    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
 };
@@ -9,7 +9,7 @@

 #include "EKController.h"

-static unsigned char colour_mode_data[][16] =
+static unsigned char ek_colour_mode_data[][16] =
 {
    { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
      0x00, 0x10, 0x20, 0x01, 0x01, 0x00, 0xFF, 0x64},          // Static
@@ -31,7 +31,7 @@ static unsigned char colour_mode_data[][16] =
      0x00, 0x10, 0x20, 0x01, 0x09, 0x00, 0xFF, 0x64},          // Candle
 };

-static unsigned char speed_mode_data[][9] =
+static unsigned char ek_speed_mode_data[][9] =
 {
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   // Static
    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Breathing
@@ -44,21 +44,24 @@ static unsigned char speed_mode_data[][9] =
    { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 }    // Candle
 };

-EKController::EKController(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path)
+EKController::EKController(hid_device* dev_handle, char *_path)
 {
-    std::size_t tmp_size = wcslen(_vendor);
+    const int szTemp = 256;
+    wchar_t tmpName[szTemp];

    dev = dev_handle;

-    for(std::size_t i = 0; (i < tmp_size) && (i < EK_DEVICE_NAME_SIZE); i++)
-    {
-        device_name[i] = (char)_vendor[i];
-    }
+    hid_get_manufacturer_string(dev, tmpName, szTemp);
+    std::wstring wName = std::wstring(tmpName);
+    device_name = std::string(wName.begin(), wName.end());

-    for(std::size_t j = 0; (j < wcslen(_vendor)) && ((tmp_size + j) < EK_DEVICE_NAME_SIZE); j++)
-    {
-        device_name[tmp_size + j] = (char)_device_name[j];
-    }
+    hid_get_product_string(dev, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
+
+    hid_get_serial_number_string(dev, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    serial = std::string(wName.begin(), wName.end());

    location = _path;

@@ -68,18 +71,15 @@ EKController::EKController(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_d

 EKController::~EKController()
 {
-    if(dev)
-    {
-        hid_close(dev);
-    }
+    hid_close(dev);
 }

-char* EKController::GetDeviceName()
+std::string EKController::GetDeviceName()
 {
    return device_name;
 }

-char* EKController::GetSerial()
+std::string EKController::GetSerial()
 {
    return serial;
 }
@@ -113,14 +113,14 @@ void EKController::SendUpdate()

    for(std::size_t i = 0; i < EK_COLOUR_MODE_DATA_SIZE; i++)
    {
-        buffer[i] = colour_mode_data[current_mode][i];
+        buffer[i] = ek_colour_mode_data[current_mode][i];
    }

    //Set the relevant colour info
    buffer[EK_RED_BYTE]   = current_red;
    buffer[EK_GREEN_BYTE] = current_green;
    buffer[EK_BLUE_BYTE]  = current_blue;
-    buffer[EK_SPEED_BYTE] = speed_mode_data[current_mode][current_speed];
+    buffer[EK_SPEED_BYTE] = ek_speed_mode_data[current_mode][current_speed];

    buffer[10] = 0x10;
    buffer[47] = 0xFF;
@@ -13,7 +13,7 @@
 #include <string>
 #include <hidapi/hidapi.h>

-#define EK_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
+#define EK_COLOUR_MODE_DATA_SIZE (sizeof(ek_colour_mode_data[0]) / sizeof(ek_colour_mode_data[0][0]))
 #define EK_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
 #define EK_PACKET_LENGTH    0x3F

@@ -55,19 +55,19 @@ enum
 class EKController
 {
 public:
-    EKController(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path);
+    EKController(hid_device* dev_handle, char *_path);
    ~EKController();

-    char* GetDeviceName();
-    char* GetSerial();
+    std::string GetDeviceName();
+    std::string GetSerial();
    std::string GetLocation();

    void SetMode(unsigned char mode, unsigned char speed);
    void SetColor(unsigned char red, unsigned char green, unsigned char blue);

 private:
-    char                    device_name[32];
-    char                    serial[32];
+    std::string             device_name;
+    std::string             serial;
    std::string             location;
    hid_device*             dev;

@@ -4,21 +4,24 @@
 #include "RGBController_EKController.h"
 #include <hidapi/hidapi.h>

-#define EK_VID                0x0483
+#define EK_VID                  0x0483

-#define EK_LOOP_CONNECT       0x5750
+#define EK_LOOP_CONNECT_PID     0x5750

 #define EK_NUM_DEVICES (sizeof(ek_pids) / sizeof(ek_pids[ 0 ]))

-enum
+struct ek_device
 {
-    EK_PID = 0,
-    EK_INTERFACE = 1
+    unsigned int    product_id;
+    unsigned short  interface;
+    unsigned int    usage_page;
+    unsigned int    usage;
+    device_type     type;
 };

-static const unsigned int ek_pids[][2] =
-{  // PID,      Interface
-    { EK_LOOP_CONNECT,        0x00 }     //EK Loop Connect
+static const ek_device ek_pids[] =
+{  // PID,                  Interface,  Usage_Page, Usage,  Device_Type
+   { EK_LOOP_CONNECT_PID,   0x00,       0xFFA0,     0x01,   DEVICE_TYPE_LEDSTRIP  }      //EK Loop Connect
 };

 /******************************************************************************************\
@@ -33,9 +36,9 @@ void DetectEKControllers(std::vector<RGBController*>& rgb_controllers)
 {
    hid_device_info* info = NULL;

-    //Look for the passed in cm_pids
+    //Look for the passed in ek_pids
    hid_init();
-    info = hid_enumerate(EK_VID, 0x0);
+    info = hid_enumerate(0, 0x0);

    while(info)
    {
@@ -44,8 +47,13 @@ void DetectEKControllers(std::vector<RGBController*>& rgb_controllers)
        {
            for(unsigned int ek_pid_idx = 0; ek_pid_idx < EK_NUM_DEVICES; ek_pid_idx++)
            {
-                if((info->product_id        == ek_pids[ek_pid_idx][EK_PID])
-                 &&(info->interface_number  == ek_pids[ek_pid_idx][EK_INTERFACE]))
+                if((info->product_id            == ek_pids[ek_pid_idx].product_id)
+#ifdef USE_HID_USAGE
+                    &&(info->usage              == ek_pids[ek_pid_idx].usage)     //Usage and usage page required to get the correct interface
+                    &&(info->usage_page         == ek_pids[ek_pid_idx].usage_page))
+#else
+                    &&(info->interface_number   == ek_pids[ek_pid_idx].interface))
+#endif  //USE_HID_USAGE
                {
                    dev = hid_open_path(info->path);
                    break;
@@ -55,7 +63,7 @@ void DetectEKControllers(std::vector<RGBController*>& rgb_controllers)

        if(dev)
        {
-            EKController* controller = new EKController(dev, info->manufacturer_string, info->product_string, info->path);
+            EKController* controller = new EKController(dev, info->path);
            RGBController_EKController* rgb_controller = new RGBController_EKController(controller);
            rgb_controllers.push_back(rgb_controller);
        }
@@ -7,7 +7,6 @@
 |                                                                     |
 \*-------------------------------------------------------------------*/

-
 #include "RGBController_EKController.h"

 RGBController_EKController::RGBController_EKController(EKController* _dev)
@@ -31,6 +31,7 @@ typedef struct
 static const gpu_pci_device device_list[] =
 {
    { NVIDIA_VEN,   NVIDIA_GTX1070_DEV,     EVGA_SUB_VEN,   EVGA_GTX1070_FTW_SUB_DEV,       EVGA_RGB_V1,    "EVGA GeForce GTX 1070 FTW"             },
+    { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,     EVGA_SUB_VEN,   EVGA_GTX1080_FTW_SUB_DEV,       EVGA_RGB_V1,    "EVGA GeForce GTX 1080 FTW"             },
    { NVIDIA_VEN,   NVIDIA_RTX2070_OC_DEV,  EVGA_SUB_VEN,   EVGA_RTX2070_XC_OC_SUB_DEV,     EVGA_RGB_V2,    "EVGA GeForce RTX 2070 XC OC"           },
    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,    EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_SUB_DEV, EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER XC ULTRA"  },
    { NVIDIA_VEN,   NVIDIA_RTX2080_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_GAMING_SUB_DEV, EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC GAMING"       },
@@ -30,6 +30,11 @@ std::string EVGAGPUv1Controller::GetDeviceLocation()
    return("I2C: " + return_string);
 }

+unsigned char EVGAGPUv1Controller::GetMode()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V1_REG_MODE));
+}
+
 unsigned char EVGAGPUv1Controller::GetRed()
 {
    return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V1_REG_RED));
@@ -38,6 +38,7 @@ public:

    std::string     GetDeviceLocation();

+    unsigned char   GetMode();
    unsigned char   GetRed();
    unsigned char   GetGreen();
    unsigned char   GetBlue();
@@ -49,8 +49,26 @@ RGBController_EVGAGPUv1::RGBController_EVGAGPUv1(EVGAGPUv1Controller* evga_ptr)

    SetupZones();

-    // Initialize active mode
+    // Initialize active mode and stored color
+
+    unsigned char raw_active_mode = evga->GetMode();
+
    active_mode = 0;
+    for(unsigned int i = 0; i < modes.size(); i++)
+    {
+        if (modes[i].value == raw_active_mode)
+        {
+            active_mode = i;
+            break;
+        }
+    }
+
+    unsigned char r = evga->GetRed();
+    unsigned char g = evga->GetGreen();
+    unsigned char b = evga->GetBlue();
+
+    RGBColor color = ToRGBColor(r, g, b);
+    colors[0] = color;
 }

 void RGBController_EVGAGPUv1::SetupZones()
@@ -84,4 +84,4 @@ void DetectAorusCPUCoolerControllers(std::vector<RGBController*>& rgb_controller
    }
 }

-REGISTER_DETECTOR("Aorus CPU Coolers", DetectAorusCPUCoolerControllers);
+REGISTER_DETECTOR("Gigabyte Aorus CPU Coolers", DetectAorusCPUCoolerControllers);
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBFusion2DRAMController.cpp             |
+|  GigabyteRGBFusion2DRAMController.cpp     |
 |                                           |
 |  Driver for Gigabyte Aorus RGB Fusion 2   |
 |  DRAM lighting controller                 |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 6/7/2020    |
 \*-----------------------------------------*/

-#include "RGBFusion2DRAMController.h"
+#include "GigabyteRGBFusion2DRAMController.h"

 #include <cstring>
 #include <stdio.h>
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBFusion2DRAMController.h               |
+|  GigabyteRGBFusion2DRAMController.h       |
 |                                           |
 |  Definitions and types for Gigabyte Aorus |
 |  RGB Fusion 2 DRAM lighting controller    |
@@ -1,7 +1,7 @@
 #include "Detector.h"
-#include "RGBFusion2DRAMController.h"
+#include "GigabyteRGBFusion2DRAMController.h"
 #include "RGBController.h"
-#include "RGBController_RGBFusion2DRAM.h"
+#include "RGBController_GigabyteRGBFusion2DRAM.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
 #include <vector>
@@ -11,14 +11,14 @@

 /******************************************************************************************\
 *                                                                                          *
-*   TestForRGBFusion2DRAMController                                                        *
+*   TestForGigabyteRGBFusion2DRAMController                                                *
 *                                                                                          *
 *       Tests the given address to see if an RGB 2 Fusion DRAMcontroller exists there.     *
 *       First does a quick write to test for a response                                    *
 *                                                                                          *
 \******************************************************************************************/

-bool TestForRGBFusion2DRAMController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForGigabyteRGBFusion2DRAMController(i2c_smbus_interface* bus, unsigned char address)
 {
    bool pass = false;

@@ -37,20 +37,20 @@ bool TestForRGBFusion2DRAMController(i2c_smbus_interface* bus, unsigned char add

    return(pass);

-}   /* TestForRGBFusion2DRAMController() */
+}   /* TestForGigabyteRGBFusion2DRAMController() */

-/******************************************************************************************\
-*                                                                                          *
-*   DetectRGBFusion2DRAMControllers                                                        *
-*                                                                                          *
-*       Detect RGB Fusion 2 controllers on the enumerated I2C busses at address 0x67.      *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where RGB Fusion device is connected      *
-*           dev - I2C address of RGB Fusion device                                         *
-*                                                                                          *
-\******************************************************************************************/
+/***********************************************************************************************\
+*                                                                                               *
+*   DetectGigabyteRGBFusion2DRAMControllers                                                     *
+*                                                                                               *
+*       Detect Gigabyte RGB Fusion 2 controllers on the enumerated I2C buses at address 0x67.   * 
+*                                                                                               *
+*           bus - pointer to i2c_smbus_interface where RGB Fusion device is connected           *
+*           dev - I2C address of RGB Fusion device                                              *
+*                                                                                               *
+\***********************************************************************************************/

-void DetectRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
+void DetectGigabyteRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
 {
    RGBFusion2DRAMController* new_rgb_fusion;
    RGBController_RGBFusion2DRAM* new_controller;
@@ -60,7 +60,7 @@ void DetectRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>& busses,
        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
        {
            // Check for RGB Fusion 2 DRAM controller at 0x67
-            if (TestForRGBFusion2DRAMController(busses[bus], 0x67))
+            if (TestForGigabyteRGBFusion2DRAMController(busses[bus], 0x67))
            {
                new_rgb_fusion = new RGBFusion2DRAMController(busses[bus], 0x67);
                new_controller = new RGBController_RGBFusion2DRAM(new_rgb_fusion);
@@ -69,7 +69,7 @@ void DetectRGBFusion2DRAMControllers(std::vector<i2c_smbus_interface*>& busses,
        }
    }

-}   /* DetectRGBFusion2DRAMControllers() */
+}   /* DetectGigabyteRGBFusion2DRAMControllers() */

 // This detector is disabled as proper detection isn't implemented
-//REGISTER_I2C_DETECTOR("Gigabyte RGB Fusion 2 DRAM", DetectRGBFusion2DRAMControllers);
+//REGISTER_I2C_DETECTOR("Gigabyte RGB Fusion 2 DRAM", DetectGigabyteRGBFusion2DRAMControllers);
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_RGBFusion2DRAM.cpp         |
+|  GigabyteRGBController_RGBFusion2DRAM.cpp |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  Gigabyte RGB Fusion 2 DRAM Driver        |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 6/7/2020    |
 \*-----------------------------------------*/

-#include "RGBController_RGBFusion2DRAM.h"
+#include "RGBController_GigabyteRGBFusion2DRAM.h"

 RGBController_RGBFusion2DRAM::RGBController_RGBFusion2DRAM(RGBFusion2DRAMController* rgb_fusion_ptr)
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_RGBFusion2DRAM.h           |
+|  RGBController_GigabyteRGBFusion2DRAM.h   |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  Gigabyte RGB Fusion 2 DRAM Driver        |
@@ -10,7 +10,7 @@
 #pragma once

 #include "RGBController.h"
-#include "RGBFusion2DRAMController.h"
+#include "GigabyteRGBFusion2DRAMController.h"

 class RGBController_RGBFusion2DRAM : public RGBController
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBFusion2SMBusController.cpp            |
+|  GigabyteRGBFusion2SMBusController.cpp    |
 |                                           |
 |  Driver for Gigabyte Aorus RGB Fusion 2   |
 |  SMBus lighting controller                |
@@ -8,7 +8,7 @@
 |  Matt Harper                  5/5/2020    |
 \*-----------------------------------------*/

-#include "RGBFusion2SMBusController.h"
+#include "GigabyteRGBFusion2SMBusController.h"
 #include <cstring>
 #include <stdio.h>
 #include <stdlib.h>
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBFusion2SMBusController.h              |
+|  GigabyteRGBFusion2SMBusController.h      |
 |                                           |
 |  Definitions and types for Gigabyte Aorus |
 |  RGB Fusion 2 SMBus lighting controller   |
@@ -1,7 +1,7 @@
 #include "Detector.h"
-#include "RGBFusion2SMBusController.h"
+#include "GigabyteRGBFusion2SMBusController.h"
 #include "RGBController.h"
-#include "RGBController_RGBFusion2SMBus.h"
+#include "RGBController_GigabyteRGBFusion2SMBus.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
 #include <vector>
@@ -21,29 +21,30 @@ typedef struct
 const motherboard_info rgb_fusion_2_smbus_motherboards[] =
 {
    { "Gigabyte Technology Co., Ltd.",      "B450 AORUS ELITE"              },
-    { "Gigabyte Technology Co., Ltd.",      "X470 AORUS ULTRA GAMING-CF"    },
-    { "Gigabyte Technology Co., Ltd.",      "X470 AORUS ULTRA GAMING"       },
-    { "Gigabyte Technology Co., Ltd.",      "X470 AORUS GAMING 5 WIFI"      },
    { "Gigabyte Technology Co., Ltd.",      "B450 AORUS M"                  },
+    { "Gigabyte Technology Co., Ltd.",      "B450 AORUS PRO WIFI-CF"        },
+    { "Gigabyte Technology Co., Ltd.",      "B450 AORUS PRO-CF"             },
+    { "Gigabyte Technology Co., Ltd.",      "B450 AORUS PRO-CF4"            },
+    { "Gigabyte Technology Co., Ltd.",      "B450 I AORUS PRO WIFI-CF"      },
+    { "Gigabyte Technology Co., Ltd.",      "B450M DS3H-CF"                 },
    { "Gigabyte Technology Co., Ltd.",      "X399 AORUS XTREME-CF"          },
    { "Gigabyte Technology Co., Ltd.",      "X399 DESIGNARE EX-CF"          },
-    { "Gigabyte Technology Co., Ltd.",      "B450 I AORUS PRO WIFI-CF"      },
-    { "Gigabyte Technology Co., Ltd.",      "B450 AORUS PRO-CF"             },    
-    { "Gigabyte Technology Co., Ltd.",      "B450 AORUS PRO-CF4"            },
+    { "Gigabyte Technology Co., Ltd.",      "X470 AORUS GAMING 5 WIFI"      },
    { "Gigabyte Technology Co., Ltd.",      "X470 AORUS GAMING 7 WIFI-CF"   },
-    { "Gigabyte Technology Co., Ltd.",      "B450 AORUS PRO WIFI-CF"        },
+    { "Gigabyte Technology Co., Ltd.",      "X470 AORUS ULTRA GAMING"       },
+    { "Gigabyte Technology Co., Ltd.",      "X470 AORUS ULTRA GAMING-CF"    },
 };

 /******************************************************************************************\
 *                                                                                          *
-*   TestForRGBFusion2SMBusController                                                       *
+*   TestForGigabyteRGBFusion2SMBusController                                               *
 *                                                                                          *
 *       Tests the given address to see if an RGB 2 Fusion controller exists there.  First  *
 *       does a quick write to test for a response                                          *
 *                                                                                          *
 \******************************************************************************************/

-bool TestForRGBFusion2SMBusController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForGigabyteRGBFusion2SMBusController(i2c_smbus_interface* bus, unsigned char address)
 {
    bool pass = false;

@@ -60,7 +61,7 @@ bool TestForRGBFusion2SMBusController(i2c_smbus_interface* bus, unsigned char ad

 /******************************************************************************************\
 *                                                                                          *
-*   DetectRGBFusion2SMBusControllers                                                       *
+*   DetectGigabyteRGBFusion2SMBusControllers                                               *
 *                                                                                          *
 *       Detect RGB Fusion 2 controllers on the enumerated I2C busses at address 0x68.      *
 *                                                                                          *
@@ -69,7 +70,7 @@ bool TestForRGBFusion2SMBusController(i2c_smbus_interface* bus, unsigned char ad
 *                                                                                          *
 \******************************************************************************************/

-void DetectRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
+void DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
 {
    RGBFusion2SMBusController* new_rgb_fusion;
    RGBController_RGBFusion2SMBus* new_controller;
@@ -98,7 +99,7 @@ void DetectRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses,
                if (device_name.find("dmdc") == std::string::npos)
                {
                    // Check for RGB Fusion 2 controller at 0x68
-                    if (TestForRGBFusion2SMBusController(busses[bus], 0x68))
+                    if (TestForGigabyteRGBFusion2SMBusController(busses[bus], 0x68))
                    {
                        new_rgb_fusion = new RGBFusion2SMBusController(busses[bus], 0x68);
                        new_controller = new RGBController_RGBFusion2SMBus(new_rgb_fusion);
@@ -111,4 +112,4 @@ void DetectRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses,

 }   /* DetectRGBFusion2SMBusControllers() */

-REGISTER_I2C_DETECTOR("Gigabyte RGB Fusion 2 SMBus", DetectRGBFusion2SMBusControllers);
+REGISTER_I2C_DETECTOR("Gigabyte RGB Fusion 2 SMBus", DetectGigabyteRGBFusion2SMBusControllers);
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_RGBFusion2SMBus.cpp        |
+|  RGBController_GigabyteRGBFusion2SMBus.cpp|
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  Gigabyte RGB Fusion 2 SMBUS Driver       |
@@ -7,7 +7,7 @@
 |  Matt Harper (5/5/2020)		            |
 \*-----------------------------------------*/

-#include "RGBController_RGBFusion2SMBus.h"
+#include "RGBController_GigabyteRGBFusion2SMBus.h"

 /* TODO - Validate all of these
 *	CPU
@@ -1,6 +1,6 @@

 /*-----------------------------------------*\
-|  RGBController_RGBFusion2SMBus.h          |
+|  RGBController_GigabyteRGBFusion2SMBus.h  |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  Gigabyte RGB Fusion 2 SMBUS Driver       |
@@ -11,7 +11,7 @@
 #pragma once

 #include "RGBController.h"
-#include "RGBFusion2SMBusController.h"
+#include "GigabyteRGBFusion2SMBusController.h"

 class RGBController_RGBFusion2SMBus : public RGBController
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBFusion2USBController.cpp              |
+|  GigabyteRGBFusion2USBController.cpp      |
 |                                           |
 |  Driver for Gigabyte Aorus RGB Fusion 2.0 |
 |  USB lighting controller                  |
@@ -7,7 +7,7 @@
 |  jackun 1/8/2020                          |
 \*-----------------------------------------*/

-#include "RGBFusion2USBController.h"
+#include "GigabyteRGBFusion2USBController.h"
 #include <algorithm>
 #include <array>
 #include <thread>
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBFusion2USBController.h                |
+|  GigabyteRGBFusion2USBController.h        |
 |                                           |
 |  Definitions and types for Gigabyte Aorus |
 |  RGB Fusion 2.0 USB lighting controller   |
@@ -1,6 +1,6 @@
 #include "Detector.h"
-#include "RGBFusion2USBController.h"
-#include "RGBController_RGBFusion2USB.h"
+#include "GigabyteRGBFusion2USBController.h"
+#include "RGBController_GigabyteRGBFusion2USB.h"
 #include "dependencies/dmiinfo.h"

 #define IT8297_VID              0x048D
@@ -17,13 +17,13 @@ static const unsigned short RGBFusion2_pids[] =

 /******************************************************************************************\
 *                                                                                          *
-*   DetectRGBFusion2USBControllers                                                         *
+*   DetectGigabyteRGBFusion2USBControllers                                                 *
 *                                                                                          *
-*       Detect RGB Fusion 2 devices that use IT8297 RGB controller                         *
+*       Detect GigabyteRGB Fusion 2 devices that use IT8297 RGB controller                 *
 *                                                                                          *
 \******************************************************************************************/

-void DetectRGBFusion2USBControllers(std::vector<RGBController*> &rgb_controllers)
+void DetectGigabyteRGBFusion2USBControllers(std::vector<RGBController*> &rgb_controllers)
 {
    hid_device_info*    info;
    hid_device*         dev;
@@ -68,6 +68,6 @@ void DetectRGBFusion2USBControllers(std::vector<RGBController*> &rgb_controllers
    }

    hid_free_enumeration(info);
-}   /* DetectRGBFusion2USBControllers() */
+}   /* DetectGigabyteRGBFusion2USBControllers() */

-REGISTER_DETECTOR("Gigabyte RGB Fusion 2 USB", DetectRGBFusion2USBControllers);
+REGISTER_DETECTOR("Gigabyte RGB Fusion 2 USB", DetectGigabyteRGBFusion2USBControllers);
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_RGBFusion2USB.cpp          |
+|  RGBController_GigabyteRGBFusion2USB.cpp  |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  Gigabyte RGB Fusion 2.0 USB Driver       |
@@ -7,7 +7,7 @@
 |  jackun 1/8/2020                          |
 \*-----------------------------------------*/

-#include "RGBController_RGBFusion2USB.h"
+#include "RGBController_GigabyteRGBFusion2USB.h"
 #include <sstream>
 #include <array>

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_RGBFusion2USB.h            |
+|  RGBController_GigabyteRGBFusion2USB.h    |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  Gigabyte RGB Fusion 2.0 USB Driver       |
@@ -9,7 +9,7 @@

 #pragma once
 #include "RGBController.h"
-#include "RGBFusion2USBController.h"
+#include "GigabyteRGBFusion2USBController.h"
 #include <map>
 #include <vector>

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBFusionController.cpp                  |
+|  GigabyteRGBFusionController.cpp          |
 |                                           |
 |  Driver for Gigabyte Aorus RGB Fusion     |
 |  lighting controller                      |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 12/10/2019  |
 \*-----------------------------------------*/

-#include "RGBFusionController.h"
+#include "GigabyteRGBFusionController.h"
 #include <cstring>
 #include <stdio.h>
 #include <stdlib.h>
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBFusionController.h                    |
+|  GigabyteRGBFusionController.h            |
 |                                           |
 |  Definitions and types for Gigabyte Aorus |
 |  RGB Fusion lighting controller           |
@@ -1,7 +1,7 @@
 #include "Detector.h"
-#include "RGBFusionController.h"
+#include "GigabyteRGBFusionController.h"
 #include "RGBController.h"
-#include "RGBController_RGBFusion.h"
+#include "RGBController_GigabyteRGBFusion.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
 #include <vector>
@@ -10,14 +10,14 @@

 /******************************************************************************************\
 *                                                                                          *
-*   TestForRGBFusionController                                                             *
+*   TestForGigabyteRGBFusionController                                                     *
 *                                                                                          *
 *       Tests the given address to see if an RGB Fusion controller exists there.  First    *
 *       does a quick write to test for a response                                          *
 *                                                                                          *
 \******************************************************************************************/

-bool TestForRGBFusionController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForGigabyteRGBFusionController(i2c_smbus_interface* bus, unsigned char address)
 {
    bool pass = false;

@@ -37,11 +37,11 @@ bool TestForRGBFusionController(i2c_smbus_interface* bus, unsigned char address)

    return(pass);

-}   /* TestForRGBFusionController() */
+}   /* TestForGigabyteRGBFusionController() */

 /******************************************************************************************\
 *                                                                                          *
-*   DetectRGBFusionControllers                                                             *
+*   DetectGigabyteRGBFusionControllers                                                     *
 *                                                                                          *
 *       Detect RGB Fusion controllers on the enumerated I2C busses at address 0x28.        *
 *                                                                                          *
@@ -50,7 +50,7 @@ bool TestForRGBFusionController(i2c_smbus_interface* bus, unsigned char address)
 *                                                                                          *
 \******************************************************************************************/

-void DetectRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
+void DetectGigabyteRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
 {
    RGBFusionController* new_rgb_fusion;
    RGBController_RGBFusion* new_controller;
@@ -60,7 +60,7 @@ void DetectRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses, std::
        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
        {
            // Check for RGB Fusion controller at 0x28
-            if (TestForRGBFusionController(busses[bus], 0x28))
+            if (TestForGigabyteRGBFusionController(busses[bus], 0x28))
            {
                new_rgb_fusion = new RGBFusionController(busses[bus], 0x28);
                new_controller = new RGBController_RGBFusion(new_rgb_fusion);
@@ -69,6 +69,6 @@ void DetectRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses, std::
        }
    }

-}   /* DetectRGBFusionControllers() */
+}   /* DetectGigabyteRGBFusionControllers() */

-REGISTER_I2C_DETECTOR("Gigabyte RGB Fusion", DetectRGBFusionControllers);
+REGISTER_I2C_DETECTOR("Gigabyte RGB Fusion", DetectGigabyteRGBFusionControllers);
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_RGBFusion.cpp              |
+|  RGBController_GigabyteRGBFusion.cpp      |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  Gigabyte RGB Fusion Driver               |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 12/11/2019  |
 \*-----------------------------------------*/

-#include "RGBController_RGBFusion.h"
+#include "RGBController_GigabyteRGBFusion.h"

 static const char* rgb_fusion_zone_names[] =
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_RGBFusion.h                |
+|  RGBController_GigabyteRGBFusion.h        |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  Gigabyte RGB Fusion Driver               |
@@ -10,7 +10,7 @@
 #pragma once

 #include "RGBController.h"
-#include "RGBFusionController.h"
+#include "GigabyteRGBFusionController.h"

 class RGBController_RGBFusion : public RGBController
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBFusionGPUController.cpp               |
+|  GigabyteRGBFusionGPUController.cpp       |
 |                                           |
 |  Driver for Gigabyte Aorus RGB Fusion GPU |
 |  lighting controller                      |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 2/20/2020   |
 \*-----------------------------------------*/

-#include "RGBFusionGPUController.h"
+#include "GigabyteRGBFusionGPUController.h"

 RGBFusionGPUController::RGBFusionGPUController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev)
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBFusionGPUController.h                 |
+|  GigabyteRGBFusionGPUController.h         |
 |                                           |
 |  Definitions and types for Gigabyte Aorus |
 |  RGB Fusion GPU lighting controller       |
@@ -1,7 +1,7 @@
 #include "Detector.h"
-#include "RGBFusionGPUController.h"
+#include "GigabyteRGBFusionGPUController.h"
 #include "RGBController.h"
-#include "RGBController_RGBFusionGPU.h"
+#include "RGBController_GigabyteRGBFusionGPU.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
 #include <vector>
@@ -22,20 +22,21 @@ typedef struct

 static const gpu_pci_device device_list[] =
 {
-    { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080_G1_GAMING_SUB_DEV, 0x48,   "Gigabyte GTX1080 G1 Gaming"        },    
-    { NVIDIA_VEN,   NVIDIA_GTX1080TI_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080TI_XTREME_SUB_DEV,  0x47,   "Gigabyte GTX1080Ti Xtreme Edition" },
+    { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080_G1_GAMING_SUB_DEV, 0x48,   "Gigabyte GTX1080 G1 Gaming"        },    
+    { NVIDIA_VEN,   NVIDIA_GTX1080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080TI_XTREME_SUB_DEV,  0x47,   "Gigabyte GTX1080Ti Xtreme Edition" },
+    { NVIDIA_VEN,   NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_SUB_DEV, 0x47,   "Gigabyte RTX2060 Gaming OC"        },
 };

 /******************************************************************************************\
 *                                                                                          *
-*   TestForRGBFusionGPUController                                                          *
+*   TestForGigabyteRGBFusionGPUController                                                  *
 *                                                                                          *
 *       Tests the given address to see if an RGB Fusion controller exists there.  First    *
 *       does a quick write to test for a response                                          *
 *                                                                                          *
 \******************************************************************************************/

-bool TestForRGBFusionGPUController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForGigabyteRGBFusionGPUController(i2c_smbus_interface* bus, unsigned char address)
 {
    bool pass = false;
    int res;
@@ -77,14 +78,14 @@ bool TestForRGBFusionGPUController(i2c_smbus_interface* bus, unsigned char addre
 *                                                                                          *
 *   DetectRGBFusionGPUControllers                                                          *
 *                                                                                          *
-*       Detect RGB Fusion controllers on the enumerated I2C busses at address 0x47.        *
+*       Detect GigabyteRGB Fusion controllers on the enumerated I2C busses at address 0x47.*
 *                                                                                          *
 *           bus - pointer to i2c_smbus_interface where RGB Fusion device is connected      *
 *           dev - I2C address of RGB Fusion device                                         *
 *                                                                                          *
 \******************************************************************************************/

-void DetectRGBFusionGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
+void DetectGigabyteRGBFusionGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
 {
    RGBFusionGPUController* new_rgb_fusion;
    RGBController_RGBFusionGPU* new_controller;
@@ -99,7 +100,7 @@ void DetectRGBFusionGPUControllers(std::vector<i2c_smbus_interface*>& busses, st
               busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
            {
                // Check for RGB Fusion controller
-                if (TestForRGBFusionGPUController(busses[bus], device_list[dev_idx].controller_address))
+                if (TestForGigabyteRGBFusionGPUController(busses[bus], device_list[dev_idx].controller_address))
                {
                    new_rgb_fusion = new RGBFusionGPUController(busses[bus], device_list[dev_idx].controller_address);
                    new_controller = new RGBController_RGBFusionGPU(new_rgb_fusion);
@@ -110,6 +111,6 @@ void DetectRGBFusionGPUControllers(std::vector<i2c_smbus_interface*>& busses, st
        }
    }

-}   /* DetectRGBFusionGPUControllers() */
+}   /* DetectGigabyteRGBFusionGPUControllers() */

-REGISTER_I2C_DETECTOR("Gigabyte RGB Fusion GPU", DetectRGBFusionGPUControllers);
+REGISTER_I2C_DETECTOR("Gigabyte RGB Fusion GPU", DetectGigabyteRGBFusionGPUControllers);
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_RGBFusionGPU.cpp           |
+|  RGBController_GigabyteRGBFusionGPU.cpp   |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  Gigabyte RGB Fusion GPU Driver           |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 2/23/2020   |
 \*-----------------------------------------*/

-#include "RGBController_RGBFusionGPU.h"
+#include "RGBController_GigabyteRGBFusionGPU.h"

 RGBController_RGBFusionGPU::RGBController_RGBFusionGPU(RGBFusionGPUController* rgb_fusion_ptr)
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_RGBFusionGPU.h             |
+|  RGBController_GigabyteRGBFusionGPU.h     |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  Gigabyte RGB Fusion GPU Driver           |
@@ -10,7 +10,7 @@
 #pragma once

 #include "RGBController.h"
-#include "RGBFusionGPUController.h"
+#include "GigabyteRGBFusionGPUController.h"

 class RGBController_RGBFusionGPU : public RGBController
 {
@@ -9,32 +9,8 @@

 #include "RGBController_HyperXAlloyOrigins.h"

-//Include thread libraries for Windows or Linux
-#ifdef WIN32
-#include <process.h>
-#else
-#include "pthread.h"
-#include "unistd.h"
-#endif
-
-//Thread functions have different types in Windows and Linux
-#ifdef WIN32
-#define THREAD static void
-#define THREADRETURN
-#else
-#define THREAD static void*
-#define THREADRETURN return(NULL);
-#endif
-
 using namespace std::chrono_literals;

-THREAD keepalive_thread(void *param)
-{
-    RGBController_HyperXAlloyOrigins* controller = static_cast<RGBController_HyperXAlloyOrigins*>(param);
-    controller->KeepaliveThread();
-    THREADRETURN
-}
-
 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF

@@ -215,16 +191,16 @@ RGBController_HyperXAlloyOrigins::RGBController_HyperXAlloyOrigins(HyperXAlloyOr
    | to not revert back into rainbow mode.  Start a thread |
    | to continuously send a keepalive packet every 5s      |
    \*-----------------------------------------------------*/
-#ifdef WIN32
-    _beginthread(keepalive_thread, 0, this);
-#else
-    pthread_t thread;
-    pthread_create(&thread, NULL, &keepalive_thread, this);
-#endif
+    keepalive_thread_run = 1;
+    keepalive_thread = new std::thread(&RGBController_HyperXAlloyOrigins::KeepaliveThread, this);
 }

 RGBController_HyperXAlloyOrigins::~RGBController_HyperXAlloyOrigins()
 {
+    keepalive_thread_run = 0;
+    keepalive_thread->join();
+    delete keepalive_thread;
+
    /*---------------------------------------------------------*\
    | Delete the matrix map                                     |
    \*---------------------------------------------------------*/
@@ -313,13 +289,13 @@ void RGBController_HyperXAlloyOrigins::DeviceUpdateMode()

 void RGBController_HyperXAlloyOrigins::KeepaliveThread()
 {
-    while(1)
+    while(keepalive_thread_run.load())
    {
        if(active_mode == 0)
        {
            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50))
            {
-                UpdateLEDs();
+                DeviceUpdateLEDs();
            }
        }
        std::this_thread::sleep_for(10ms);;
@@ -34,6 +34,7 @@ public:
    
 private:
    HyperXAlloyOriginsController*   hyperx;
-
+    std::thread*                    keepalive_thread;
+    std::atomic<bool>               keepalive_thread_run;
    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
 };
@@ -230,15 +230,15 @@ RGBController_HyperXKeyboard::RGBController_HyperXKeyboard(HyperXKeyboardControl
    | to not revert back into rainbow mode.  Start a thread |
    | to continuously send a keepalive packet every 5s      |
    \*-----------------------------------------------------*/
-    KeepaliveThreadRunning = true;
-    KeepaliveThread = new std::thread(&RGBController_HyperXKeyboard::KeepaliveThreadFunction, this);
+    keepalive_thread_run = true;
+    keepalive_thread = new std::thread(&RGBController_HyperXKeyboard::KeepaliveThreadFunction, this);
 }

 RGBController_HyperXKeyboard::~RGBController_HyperXKeyboard()
 {
-    KeepaliveThreadRunning = false;
-    KeepaliveThread->join();
-    delete KeepaliveThread;
+    keepalive_thread_run = false;
+    keepalive_thread->join();
+    delete keepalive_thread;

    /*---------------------------------------------------------*\
    | Delete the matrix map                                     |
@@ -345,13 +345,13 @@ void RGBController_HyperXKeyboard::DeviceUpdateMode()

 void RGBController_HyperXKeyboard::KeepaliveThreadFunction()
 {
-    while(KeepaliveThreadRunning)
+    while(keepalive_thread_run)
    {
        if(active_mode == 0)
        {
            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50))
            {
-                UpdateLEDs();
+                DeviceUpdateLEDs();
            }
        }
        std::this_thread::sleep_for(10ms);;
@@ -36,9 +36,7 @@ public:
    
 private:
    HyperXKeyboardController*   hyperx;
-
-    std::atomic<bool>   KeepaliveThreadRunning;
-    std::thread*        KeepaliveThread;
-
+    std::atomic<bool>   keepalive_thread_run;
+    std::thread*        keepalive_thread;
    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
 };
@@ -9,32 +9,8 @@

 #include "RGBController_HyperXPulsefireSurge.h"

-//Include thread libraries for Windows or Linux
-#ifdef WIN32
-#include <process.h>
-#else
-#include "pthread.h"
-#include "unistd.h"
-#endif
-
-//Thread functions have different types in Windows and Linux
-#ifdef WIN32
-#define THREAD static void
-#define THREADRETURN
-#else
-#define THREAD static void*
-#define THREADRETURN return(NULL);
-#endif
-
 using namespace std::chrono_literals;

-THREAD keepalive_thread(void *param)
-{
-    RGBController_HyperXPulsefireSurge* controller = static_cast<RGBController_HyperXPulsefireSurge*>(param);
-    controller->KeepaliveThread();
-    THREADRETURN
-}
-
 RGBController_HyperXPulsefireSurge::RGBController_HyperXPulsefireSurge(HyperXPulsefireSurgeController* hyperx_ptr)
 {
    hyperx = hyperx_ptr;
@@ -59,17 +35,15 @@ RGBController_HyperXPulsefireSurge::RGBController_HyperXPulsefireSurge(HyperXPul
    | to not revert back into rainbow mode.  Start a thread |
    | to continuously send a keepalive packet every 5s      |
    \*-----------------------------------------------------*/
-#ifdef WIN32
-    _beginthread(keepalive_thread, 0, this);
-#else
-    pthread_t thread;
-    pthread_create(&thread, NULL, &keepalive_thread, this);
-#endif
+    keepalive_thread_run = 1;
+    keepalive_thread = new std::thread(&RGBController_HyperXPulsefireSurge::KeepaliveThread, this);
 };

 RGBController_HyperXPulsefireSurge::~RGBController_HyperXPulsefireSurge()
 {
-
+    keepalive_thread_run = 0;
+    keepalive_thread->join();
+    delete keepalive_thread;
 }

 void RGBController_HyperXPulsefireSurge::SetupZones()
@@ -156,13 +130,13 @@ void RGBController_HyperXPulsefireSurge::DeviceUpdateMode()

 void RGBController_HyperXPulsefireSurge::KeepaliveThread()
 {
-    while(1)
+    while(keepalive_thread_run.load())
    {
        if(active_mode == 0)
        {
            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50))
            {
-                UpdateLEDs();
+                DeviceUpdateLEDs();
            }
        }
        std::this_thread::sleep_for(10ms);
@@ -34,6 +34,7 @@ public:
    
 private:
    HyperXPulsefireSurgeController* hyperx;
-
+    std::thread*                    keepalive_thread;
+    std::atomic<bool>               keepalive_thread_run;
    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
 };
@@ -9,32 +9,8 @@

 #include "RGBController_HyperXMousemat.h"

-//Include thread libraries for Windows or Linux
-#ifdef WIN32
-#include <process.h>
-#else
-#include "pthread.h"
-#include "unistd.h"
-#endif
-
-//Thread functions have different types in Windows and Linux
-#ifdef WIN32
-#define THREAD static void
-#define THREADRETURN
-#else
-#define THREAD static void*
-#define THREADRETURN return(NULL);
-#endif
-
 using namespace std::chrono_literals;

-THREAD keepalive_thread(void *param)
-{
-    RGBController_HyperXMousemat* controller = static_cast<RGBController_HyperXMousemat*>(param);
-    controller->KeepaliveThread();
-    THREADRETURN
-}
-
 RGBController_HyperXMousemat::RGBController_HyperXMousemat(HyperXMousematController* hyperx_ptr)
 {
    hyperx = hyperx_ptr;
@@ -59,17 +35,15 @@ RGBController_HyperXMousemat::RGBController_HyperXMousemat(HyperXMousematControl
    | to not revert back into rainbow mode.  Start a thread |
    | to continuously send a keepalive packet every 5s      |
    \*-----------------------------------------------------*/
-#ifdef WIN32
-    _beginthread(keepalive_thread, 0, this);
-#else
-    pthread_t thread;
-    pthread_create(&thread, NULL, &keepalive_thread, this);
-#endif
+    keepalive_thread_run = 1;
+    keepalive_thread = new std::thread(&RGBController_HyperXMousemat::KeepaliveThread, this);
 };

 RGBController_HyperXMousemat::~RGBController_HyperXMousemat()
 {
-
+    keepalive_thread_run = 0;
+    keepalive_thread->join();
+    delete keepalive_thread;
 }

 void RGBController_HyperXMousemat::SetupZones()
@@ -156,13 +130,13 @@ void RGBController_HyperXMousemat::DeviceUpdateMode()

 void RGBController_HyperXMousemat::KeepaliveThread()
 {
-    while(1)
+    while(keepalive_thread_run.load())
    {
        if(active_mode == 0)
        {
            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50))
            {
-                UpdateLEDs();
+                DeviceUpdateLEDs();
            }
        }
        std::this_thread::sleep_for(10ms);
@@ -34,6 +34,7 @@ public:
    
 private:
    HyperXMousematController* hyperx;
-
+    std::thread*              keepalive_thread;
+    std::atomic<bool>         keepalive_thread_run;
    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
 };
@@ -26,11 +26,12 @@
 /*-----------------------------------------------------*\
 | Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
-#define LOGITECH_G810_1_PID                     0xC337
-#define LOGITECH_G810_2_PID                     0xC331
+#define LOGITECH_G213_PID                       0xC336
 #define LOGITECH_G512_PID                       0xC342
 #define LOGITECH_G512_RGB_PID                   0xC33C
-#define LOGITECH_G213_PID                       0xC336
+#define LOGITECH_G610_PID                       0xC333
+#define LOGITECH_G810_1_PID                     0xC331
+#define LOGITECH_G810_2_PID                     0xC337
 /*-----------------------------------------------------*\
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
@@ -41,7 +42,12 @@
 #define LOGITECH_G502_PS_PID                    0xC332
 #define LOGITECH_G502H_PID                      0xC08B
 #define LOGITECH_G_LIGHTSPEED_WIRELESS_PID      0xC539
+#define LOGITECH_GPRO_WIRED_PID                 0xC085
+#define LOGITECH_GPRO_HERO_WIRED_PID            0xC08C
 #define LOGITECH_GPRO_WIRELESS_PID              0xC088
+/*-----------------------------------------------------*\
+| Mousemat product IDs                                  |
+\*-----------------------------------------------------*/
 #define LOGITECH_G_LIGHTSPEED_POWERPLAY_PID     0xC53A

 typedef struct
@@ -60,11 +66,12 @@ static const logitech_device device_list[] =
    /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
    | Keyboards                                                                                                                                         |
    \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-    { LOGITECH_VID,             LOGITECH_G810_1_PID,                    1,  DEVICE_TYPE_KEYBOARD,   "Logitech G810 Orion Spectrum"                      },
-    { LOGITECH_VID,             LOGITECH_G810_2_PID,                    1,  DEVICE_TYPE_KEYBOARD,   "Logitech G810 Orion Spectrum"                      },
+    { LOGITECH_VID,             LOGITECH_G213_PID,                      1,  DEVICE_TYPE_KEYBOARD,   "Logitech G213"                                     },
    { LOGITECH_VID,             LOGITECH_G512_PID,                      1,  DEVICE_TYPE_KEYBOARD,   "Logitech G512"                                     },
    { LOGITECH_VID,             LOGITECH_G512_RGB_PID,                  1,  DEVICE_TYPE_KEYBOARD,   "Logitech G512 RGB"                                 },
-    { LOGITECH_VID,             LOGITECH_G213_PID,                      1,  DEVICE_TYPE_KEYBOARD,   "Logitech G213"                                     },
+    { LOGITECH_VID,             LOGITECH_G610_PID,                      1,  DEVICE_TYPE_KEYBOARD,   "Logitech G610 Orion"                               },
+    { LOGITECH_VID,             LOGITECH_G810_1_PID,                    1,  DEVICE_TYPE_KEYBOARD,   "Logitech G810 Orion Spectrum"                      },
+    { LOGITECH_VID,             LOGITECH_G810_2_PID,                    1,  DEVICE_TYPE_KEYBOARD,   "Logitech G810 Orion Spectrum"                      },
    /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
    | Mice                                                                                                                                              |
    \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
@@ -74,12 +81,14 @@ static const logitech_device device_list[] =
    { LOGITECH_VID,             LOGITECH_G403H_PID,                     1,  DEVICE_TYPE_MOUSE,      "Logitech G403 Hero"                                },
    { LOGITECH_VID,             LOGITECH_G502_PS_PID,                   1,  DEVICE_TYPE_MOUSE,      "Logitech G502 Proteus Spectrum"                    },
    { LOGITECH_VID,             LOGITECH_G502H_PID,                     1,  DEVICE_TYPE_MOUSE,      "Logitech G502 Hero"                                },
+    { LOGITECH_VID,             LOGITECH_GPRO_WIRED_PID,                1,  DEVICE_TYPE_MOUSE,      "Logitech G Pro Gaming Mouse"                       },
+    { LOGITECH_VID,             LOGITECH_GPRO_HERO_WIRED_PID,           1,  DEVICE_TYPE_MOUSE,      "Logitech G Pro (HERO) Gaming Mouse"                },
    { LOGITECH_VID,             LOGITECH_G_LIGHTSPEED_WIRELESS_PID,     2,  DEVICE_TYPE_MOUSE,      "Logitech G Lightspeed Wireless Gaming Mouse"       },
    { LOGITECH_VID,             LOGITECH_GPRO_WIRELESS_PID,             2,  DEVICE_TYPE_MOUSE,      "Logitech G Pro Wireless Gaming Mouse (Wired)"      },
-    { LOGITECH_VID,             LOGITECH_G_LIGHTSPEED_POWERPLAY_PID,    2,  DEVICE_TYPE_MOUSE,      "Logitech G Powerplay Mousepad with Lightspeed"     },
    /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
    | Mousemats                                                                                                                                         |
    \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+    { LOGITECH_VID,             LOGITECH_G_LIGHTSPEED_POWERPLAY_PID,    2,  DEVICE_TYPE_MOUSEMAT,   "Logitech G Powerplay Mousepad with Lightspeed"     },
 };

 /******************************************************************************************\
@@ -125,79 +134,79 @@ void DetectLogitechControllers(std::vector<RGBController*>& rgb_controllers)
 #ifdef USE_HID_USAGE
                            switch(device_list[device_idx].usb_pid)
                            {
-                            case LOGITECH_G810_1_PID:
-                            case LOGITECH_G810_2_PID:
-                            case LOGITECH_G512_PID:
-                            case LOGITECH_G512_RGB_PID:
-                                {
-                                    hid_device_info* tmp_info_0x0604 = info;
-
-                                    while(tmp_info_0x0604)
+                                case LOGITECH_G213_PID:
                                    {
-                                        if((tmp_info_0x0604->vendor_id == device_list[device_idx].usb_vid)
-                                        &&(tmp_info_0x0604->product_id == device_list[device_idx].usb_pid)
-                                        &&(tmp_info_0x0604->interface_number == device_list[device_idx].usb_interface)
-                                        &&(tmp_info_0x0604->usage_page == 0xFF43)
-                                        &&(tmp_info_0x0604->usage == 0x0604))
-                                        {
-                                            hid_device* dev_usage_0x0604 = hid_open_path(tmp_info_0x0604->path);
+                                        LogitechG213Controller* controller = new LogitechG213Controller(dev_usage_0x0602);

-                                            if(dev_usage_0x0604)
-                                            {
-                                                LogitechG810Controller* controller = new LogitechG810Controller(dev_usage_0x0602, dev_usage_0x0604);
+                                        RGBController_LogitechG213* rgb_controller = new RGBController_LogitechG213(controller);

-                                                RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
-
-                                                rgb_controller->name = device_list[device_idx].name;
-                                                rgb_controllers.push_back(rgb_controller);
-                                            }
-                                        }
-                                        tmp_info_0x0604 = tmp_info_0x0604->next;
+                                        rgb_controller->name = device_list[device_idx].name;
+                                        rgb_controllers.push_back(rgb_controller);
                                    }
-                                }
-                                break;
+                                    break;

-                            case LOGITECH_G213_PID:
-                                {
-                                    LogitechG213Controller* controller = new LogitechG213Controller(dev_usage_0x0602);
+                                case LOGITECH_G512_PID:
+                                case LOGITECH_G512_RGB_PID:
+                                case LOGITECH_G610_PID:
+                                case LOGITECH_G810_1_PID:
+                                case LOGITECH_G810_2_PID:
+                                    {
+                                        hid_device_info* tmp_info_0x0604 = info;

-                                    RGBController_LogitechG213* rgb_controller = new RGBController_LogitechG213(controller);
+                                        while(tmp_info_0x0604)
+                                        {
+                                            if((tmp_info_0x0604->vendor_id == device_list[device_idx].usb_vid)
+                                            &&(tmp_info_0x0604->product_id == device_list[device_idx].usb_pid)
+                                            &&(tmp_info_0x0604->interface_number == device_list[device_idx].usb_interface)
+                                            &&(tmp_info_0x0604->usage_page == 0xFF43)
+                                            &&(tmp_info_0x0604->usage == 0x0604))
+                                            {
+                                                hid_device* dev_usage_0x0604 = hid_open_path(tmp_info_0x0604->path);

-                                    rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(rgb_controller);
-                                }
-                                break;
+                                                if(dev_usage_0x0604)
+                                                {
+                                                    LogitechG810Controller* controller = new LogitechG810Controller(dev_usage_0x0602, dev_usage_0x0604);

+                                                    RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
+
+                                                    rgb_controller->name = device_list[device_idx].name;
+                                                    rgb_controllers.push_back(rgb_controller);
+                                                }
+                                            }
+                                            tmp_info_0x0604 = tmp_info_0x0604->next;
+                                        }
+                                    }
+                                    break;
                            }
 #else
                            switch(device_list[device_idx].usb_pid)
                            {
-                            case LOGITECH_G810_1_PID:
-                            case LOGITECH_G810_2_PID:
-                            case LOGITECH_G512_PID:
-                            case LOGITECH_G512_RGB_PID:                            
-                                {
-                                    LogitechG810Controller* controller = new LogitechG810Controller(dev_usage_0x0602, dev_usage_0x0602);
+                                case LOGITECH_G213_PID:
+                                    {
+                                        LogitechG213Controller* controller = new LogitechG213Controller(dev_usage_0x0602);

-                                    RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
+                                        RGBController_LogitechG213* rgb_controller = new RGBController_LogitechG213(controller);

-                                    rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(rgb_controller);
-                                }
-                                break;
+                                        rgb_controller->name = device_list[device_idx].name;
+                                        rgb_controllers.push_back(rgb_controller);
+                                    }
+                                    break;

-                            case LOGITECH_G213_PID:
-                                {
-                                    LogitechG213Controller* controller = new LogitechG213Controller(dev_usage_0x0602);
+                                case LOGITECH_G512_PID:
+                                case LOGITECH_G512_RGB_PID:
+                                case LOGITECH_G610_PID:
+                                case LOGITECH_G810_1_PID:
+                                case LOGITECH_G810_2_PID:
+                                    {
+                                        LogitechG810Controller* controller = new LogitechG810Controller(dev_usage_0x0602, dev_usage_0x0602);

-                                    RGBController_LogitechG213* rgb_controller = new RGBController_LogitechG213(controller);
+                                        RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);

-                                    rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(rgb_controller);
-                                }
-                                break;
+                                        rgb_controller->name = device_list[device_idx].name;
+                                        rgb_controllers.push_back(rgb_controller);
+                                    }
+                                    break;
                            }
-
 #endif
                        }
                    }
@@ -232,82 +241,114 @@ void DetectLogitechControllers(std::vector<RGBController*>& rgb_controllers)
                        {
                            switch(device_list[device_idx].usb_pid)
                            {
-                            case LOGITECH_G203_PID:
-                                {
-                                    LogitechG203Controller* controller = new LogitechG203Controller(dev, info->path);
+                                case LOGITECH_G203_PID:
+                                case LOGITECH_GPRO_WIRED_PID:
+                                case LOGITECH_GPRO_HERO_WIRED_PID:
+                                    {
+                                        LogitechG203Controller* controller = new LogitechG203Controller(dev, info->path);

-                                    RGBController_LogitechG203* rgb_controller = new RGBController_LogitechG203(controller);
+                                        RGBController_LogitechG203* rgb_controller = new RGBController_LogitechG203(controller);

-                                    rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(rgb_controller);
-                                }
-                                break;
+                                        rgb_controller->name = device_list[device_idx].name;
+                                        rgb_controllers.push_back(rgb_controller);
+                                    }
+                                    break;

-                            case LOGITECH_G203L_PID:
-                                {
-                                    LogitechG203LController* controller = new LogitechG203LController(dev, info->path);
+                                case LOGITECH_G203L_PID:
+                                    {
+                                        LogitechG203LController* controller = new LogitechG203LController(dev, info->path);

-                                    RGBController_LogitechG203L* rgb_controller = new RGBController_LogitechG203L(controller);
+                                        RGBController_LogitechG203L* rgb_controller = new RGBController_LogitechG203L(controller);

-                                    rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(rgb_controller);
-                                }
-                                break;
+                                        rgb_controller->name = device_list[device_idx].name;
+                                        rgb_controllers.push_back(rgb_controller);
+                                    }
+                                    break;

-                            case LOGITECH_G403_PID:
-                            case LOGITECH_G403H_PID:
-                                {
-                                    LogitechG403Controller* controller = new LogitechG403Controller(dev, info->path);
+                                case LOGITECH_G403_PID:
+                                case LOGITECH_G403H_PID:
+                                    {
+                                        LogitechG403Controller* controller = new LogitechG403Controller(dev, info->path);

-                                    RGBController_LogitechG403* rgb_controller = new RGBController_LogitechG403(controller);
+                                        RGBController_LogitechG403* rgb_controller = new RGBController_LogitechG403(controller);

-                                    rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(rgb_controller);
-                                }
-                                break;
+                                        rgb_controller->name = device_list[device_idx].name;
+                                        rgb_controllers.push_back(rgb_controller);
+                                    }
+                                    break;

-                            case LOGITECH_G502_PS_PID:
-                            case LOGITECH_G502H_PID:
-                                {
-                                    LogitechG502PSController* controller = new LogitechG502PSController(dev, info->path);
+                                case LOGITECH_G502_PS_PID:
+                                case LOGITECH_G502H_PID:
+                                    {
+                                        LogitechG502PSController* controller = new LogitechG502PSController(dev, info->path);

-                                    RGBController_LogitechG502PS* rgb_controller = new RGBController_LogitechG502PS(controller);
+                                        RGBController_LogitechG502PS* rgb_controller = new RGBController_LogitechG502PS(controller);

-                                    rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(rgb_controller);
-                                }
-                                break;
-                            
-                            case LOGITECH_GPRO_WIRELESS_PID:
-                            case LOGITECH_G_LIGHTSPEED_WIRELESS_PID:
-                                {
-                                    LogitechGProWirelessController* controller = new LogitechGProWirelessController(dev, info->path);
+                                        rgb_controller->name = device_list[device_idx].name;
+                                        rgb_controllers.push_back(rgb_controller);
+                                    }
+                                    break;

-                                    RGBController_LogitechGProWireless* rgb_controller = new RGBController_LogitechGProWireless(controller);
+                                case LOGITECH_GPRO_WIRELESS_PID:
+                                case LOGITECH_G_LIGHTSPEED_WIRELESS_PID:
+                                    {
+                                        LogitechGProWirelessController* controller = new LogitechGProWirelessController(dev, info->path);

-                                    rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(rgb_controller);
-                                }
-                                break;
-                            case LOGITECH_G_LIGHTSPEED_POWERPLAY_PID:
-                                {
-                                    //Add mouse
-                                    LogitechGProWirelessController* mouse_controller = new LogitechGProWirelessController(dev, info->path);
+                                        RGBController_LogitechGProWireless* rgb_controller = new RGBController_LogitechGProWireless(controller);

-                                    RGBController_LogitechGProWireless* mouse_rgb_controller = new RGBController_LogitechGProWireless(mouse_controller);
+                                        rgb_controller->name = device_list[device_idx].name;
+                                        rgb_controllers.push_back(rgb_controller);
+                                    }
+                                    break;
+                            }
+                        }
+                    }
+                    info = info->next;
+                }
+                hid_free_enumeration(info);
+            }
+            break;
+        case DEVICE_TYPE_MOUSEMAT:
+            {
+                hid_device_info* info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);

-                                    mouse_rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(mouse_rgb_controller);
-                                    
-                                    //Add Powerplay mousemat
-                                    LogitechGPowerPlayController* mousemat_controller = new LogitechGPowerPlayController(dev, info->path);
+                while(info)
+                {
+                    if((info->vendor_id == device_list[device_idx].usb_vid)
+                    &&(info->product_id == device_list[device_idx].usb_pid)
+#ifdef USE_HID_USAGE                    
+                    &&(info->interface_number == device_list[device_idx].usb_interface)
+                    &&(info->usage_page == 0xFF00)
+                    &&(info->usage == 2))
+#else
+                    &&(info->interface_number == device_list[device_idx].usb_interface))
+#endif
+                    {
+                        hid_device* dev = hid_open_path(info->path);

-                                    RGBController_LogitechGPowerPlay* mousemat_rgb_controller = new RGBController_LogitechGPowerPlay(mousemat_controller);
+                        if(dev)
+                        {
+                            switch(device_list[device_idx].usb_pid)
+                            {
+                                case LOGITECH_G_LIGHTSPEED_POWERPLAY_PID:
+                                    {
+                                        //Add mouse
+                                        LogitechGProWirelessController* mouse_controller = new LogitechGProWirelessController(dev, info->path);

-                                    mousemat_rgb_controller->name = device_list[device_idx].name;
-                                    rgb_controllers.push_back(mousemat_rgb_controller);
-                                }
-                                break;
+                                        RGBController_LogitechGProWireless* mouse_rgb_controller = new RGBController_LogitechGProWireless(mouse_controller);
+
+                                        mouse_rgb_controller->name = device_list[device_idx].name;
+                                        rgb_controllers.push_back(mouse_rgb_controller);
+
+                                        //Add Powerplay mousemat
+                                        LogitechGPowerPlayController* mousemat_controller = new LogitechGPowerPlayController(dev, info->path);
+
+                                        RGBController_LogitechGPowerPlay* mousemat_rgb_controller = new RGBController_LogitechGPowerPlay(mousemat_controller);
+
+                                        mousemat_rgb_controller->name = device_list[device_idx].name;
+                                        rgb_controllers.push_back(mousemat_rgb_controller);
+                                    }
+                                    break;
                            }
                        }
                    }
@@ -60,15 +60,15 @@ void LogitechG203Controller::SendMouseMode
    speed = 100 * speed;
    if(mode == LOGITECH_G203_MODE_CYCLE)
    {
-        usb_buf[0x0B]   = speed >> 8;
-        usb_buf[0x0C]   = speed & 0xFF;
-        usb_buf[0x0D]   = 0x64;
+        usb_buf[0x0B]       = speed >> 8;
+        usb_buf[0x0C]       = speed & 0xFF;
+        usb_buf[0x0D]       = 0x64;
    }
    else if(mode == LOGITECH_G203_MODE_BREATHING)
    {
-        usb_buf[0x09]   = speed >> 8;
-        usb_buf[0x0A]   = speed & 0xFF;
-        usb_buf[0x0C]   = 0x64;
+        usb_buf[0x09]       = speed >> 8;
+        usb_buf[0x0A]       = speed & 0xFF;
+        usb_buf[0x0C]       = 0x64;
    }

    /*-----------------------------------------------------*\
@@ -24,7 +24,7 @@ enum

 /*---------------------------------------------------------------------------------------------*\
 | Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are mutipled by 100 later to give lots of GUI steps.                                   |
+| Values are multiplied by 100 later to give lots of GUI steps.                                 |
 \*---------------------------------------------------------------------------------------------*/
 enum
 {
@@ -62,15 +62,15 @@ void LogitechG403Controller::SendMouseMode
    speed = 100 * speed;
    if(mode == LOGITECH_G403_MODE_CYCLE)
    {
-        usb_buf[0x0B]   = speed >> 8;
-        usb_buf[0x0C]   = speed & 0xFF;
-        usb_buf[0x0D]   = 0x64;
+        usb_buf[0x0B]       = speed >> 8;
+        usb_buf[0x0C]       = speed & 0xFF;
+        usb_buf[0x0D]       = 0x64;
    }
    else if(mode == LOGITECH_G403_MODE_BREATHING)
    {
-        usb_buf[0x09]   = speed >> 8;
-        usb_buf[0x0A]   = speed & 0xFF;
-        usb_buf[0x0C]   = 0x64;
+        usb_buf[0x09]       = speed >> 8;
+        usb_buf[0x0A]       = speed & 0xFF;
+        usb_buf[0x0C]       = 0x64;
    }

    /*-----------------------------------------------------*\
@@ -24,7 +24,7 @@ enum

 /*---------------------------------------------------------------------------------------------*\
 | Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are mutipled by 100 later to give lots of GUI steps.                                   |
+| Values are multiplied by 100 later to give lots of GUI steps.                                 |
 \*---------------------------------------------------------------------------------------------*/
 enum
 {
@@ -62,17 +62,17 @@ void LogitechG502PSController::SendMouseMode
    speed = 100 * speed;
    if(mode == LOGITECH_G502_PS_MODE_CYCLE)
    {
-        usb_buf[0x0B]   = speed >> 8;
-        usb_buf[0x0C]   = speed & 0xFF;
-        usb_buf[0x0D]   = 0x64;
+        usb_buf[0x0B]       = speed >> 8;
+        usb_buf[0x0C]       = speed & 0xFF;
+        usb_buf[0x0D]       = 0x64;
    }
    else if(mode == LOGITECH_G502_PS_MODE_BREATHING)
    {
-        usb_buf[0x09]   = speed >> 8;
-        usb_buf[0x0A]   = speed & 0xFF;
-        usb_buf[0x0C]   = 0x64;
+        usb_buf[0x09]       = speed >> 8;
+        usb_buf[0x0A]       = speed & 0xFF;
+        usb_buf[0x0C]       = 0x64;
    }else if(mode == LOGITECH_G502_PS_MODE_STATIC){
-        usb_buf[0x09]   = 0x02;
+        usb_buf[0x09]       = 0x02;
    }

    /*-----------------------------------------------------*\
@@ -25,7 +25,7 @@ enum

 /*---------------------------------------------------------------------------------------------*\
 | Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are mutipled by 100 later to give lots of GUI steps.                                   |
+| Values are multiplied by 100 later to give lots of GUI steps.                                 |
 \*---------------------------------------------------------------------------------------------*/
 enum
 {
@@ -147,18 +147,18 @@ void LogitechG810Controller::SendMode
    usb_buf[0x07]           = green;
    usb_buf[0x08]           = blue;

-    speed = 1000 + 4750 * (LOGITECH_G810_SPEED_FASTEST - speed);
+    speed = 100 * speed;
    if(mode == LOGITECH_G810_MODE_CYCLE)
    {
-        usb_buf[0x0B]   = speed >> 8;
-        usb_buf[0x0C]   = speed & 0xFF;
-        usb_buf[0x0D]   = 0x64;
+        usb_buf[0x0B]       = speed >> 8;
+        usb_buf[0x0C]       = speed & 0xFF;
+        usb_buf[0x0D]       = 0x64;
    }
    else if(mode == LOGITECH_G810_MODE_BREATHING)
    {
-        usb_buf[0x09]   = speed >> 8;
-        usb_buf[0x0A]   = speed & 0xFF;
-        usb_buf[0x0C]   = 0x64;
+        usb_buf[0x09]       = speed >> 8;
+        usb_buf[0x0A]       = speed & 0xFF;
+        usb_buf[0x0C]       = 0x64;
    }

    /*-----------------------------------------------------*\
@@ -37,13 +37,15 @@ enum
    LOGITECH_G810_MODE_WAVE              = 0x04,
 };

+/*---------------------------------------------------------------------------------------------*\
+| Speed is 1000 for fast and 20000 for slow.                                                    |
+| Values are multiplied by 100 later to give lots of GUI steps.                                 |
+\*---------------------------------------------------------------------------------------------*/
 enum
 {
-    LOGITECH_G810_SPEED_SLOWEST          = 0x00, /* Slowest speed                */
-    LOGITECH_G810_SPEED_SLOW             = 0x01, /* Slow speed                   */
-    LOGITECH_G810_SPEED_NORMAL           = 0x02, /* Normal speed                 */
-    LOGITECH_G810_SPEED_FAST             = 0x03, /* Fast speed                   */
-    LOGITECH_G810_SPEED_FASTEST          = 0x04, /* Fastest speed                */
+    LOGITECH_G810_SPEED_SLOWEST          = 0xC8,     /* Slowest speed                       */
+    LOGITECH_G810_SPEED_NORMAL           = 0x32,     /* Normal speed                        */
+    LOGITECH_G810_SPEED_FASTEST          = 0x0A,     /* Fastest speed                       */
 };

 class LogitechG810Controller
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
k1-801	15163eea0d	Improved the ResourceManager device list management Commit amended for code style by Adam Honse <[email protected]>	2020-11-24 03:35:42 -06:00
TheRogueZeta	2850bd1a19	Logitech code cleanup	2020-11-24 08:07:22 +00:00
Adam Honse	bcd49298cd	Call DeviceUpdateLEDs rather than UpdateLEDs for HyperX keepalive threads	2020-11-23 02:59:05 -06:00
Chris	5458692192	EK Code cleanup	2020-11-23 17:58:35 +11:00
Adam Honse	b35474d711	Update udev rules to add more HyperX devices	2020-11-21 23:01:34 -06:00
K900	207e05ba27	gitignore: don't track qmake stash	2020-11-21 07:41:33 +00:00
K900	3ea73ee80c	CrucialController: keep track of the last set mode This saves an extra control transfer when applying settings that have already been applied. Mostly useful for direct mode.	2020-11-21 07:41:33 +00:00
K900	7cfdaaa501	CrucialController: force mode to static before setting direct colors This fixes some misbehaving Ballistix sticks that require a mode reset before they actually apply colors as intended.	2020-11-21 07:41:33 +00:00
silas	6347feb575	Add the dark theme files Commit amended for code style and to remove duplicate code by Adam Honse <[email protected]>	2020-11-21 01:37:05 -06:00
Jonas Malaco	8dd0d85104	Get active mode and last color set from EVGA v1 cards Improve the user experience by allowing the UI to be initialized with the settings that are currently active on the hardware.	2020-11-21 01:21:38 -06:00
TheRogueZeta	c1715f25f4	Add Gigabyte RTX 2060 Gaming OC	2020-11-20 19:42:27 +00:00
TheRogueZeta	9b9ec69f57	Add MSI RTX 3070 8 GB Gaming X Trio	2020-11-20 11:16:43 -08:00
Jonas Malaco	3cae2bccb5	Add PID for Logitech G PRO HERO Wired This mouse is a variant of the G PRO Wired, with the new sensor. The protocol appears to have been kept the same. $ lsusb Bus 001 Device 002: ID 046d:c08c Logitech, Inc. G PRO Gaming Mouse ... Related: https://github.com/libratbag/libratbag/commit/6ee1c0a591884db414a3af695b61f06a44b88f83	2020-11-19 17:18:38 -03:00
Adam Honse	a2e21e606c	Add include to fix linux build	2020-11-18 15:13:26 -06:00
Adam Honse	c7a7eaf670	Fix case in Roccat Kone file name	2020-11-18 15:03:00 -06:00
TheRogueZeta	ca6c61d47f	Add Logitech G Pro Wired	2020-11-18 20:20:23 +00:00
Martin Hartl	2346095994	NZXT Kraken: Remove water cooler resize	2020-11-18 20:19:59 +00:00
enlight3d	7abd511306	add filter for roccat kone aimo detection and clean up controller	2020-11-18 20:17:00 +00:00
TheRogueZeta	f99aa4c4ff	Add new devices for openrazer v2.9.0	2020-11-17 18:45:37 +00:00
TheRogueZeta	55af558e0e	Logitech code cleanup	2020-11-17 17:48:49 +00:00
Jonas Malaco	4f47e166dd	Enable support for EVGA 1080 FTW using V1 controller	2020-11-17 00:45:26 -03:00
Adam Honse	6cf624e56b	Update OpenRazer-Win32 to version 2.9.0	2020-11-16 15:13:26 -06:00
Adam Honse	e98d43776a	Fix ASRock on Linux again	2020-11-15 15:24:43 -06:00
Adam Honse	34d8edb629	Fix inconsistent case in Polychrome filenames that was breaking Linux builds	2020-11-15 14:30:58 -06:00
TheRogueZeta	8ffd302a57	Name cleanup: adding brand names to all controllers	2020-11-15 20:25:51 +00:00
k1-801	dde857dfb4	Tiny threads fixes & a little bit of safety	2020-11-15 13:28:29 -06:00
Chris	9a53709db0	Adding "B450M DS3H-CF" to RGBFusion2SMBus * Requested by Discord user stephencoons	2020-11-15 00:49:51 -06:00
Chris	b495c7723f	Code Cleanup for Coolermaster MP750	2020-11-15 00:48:46 -06:00
Florian Kraupa	dd36a7362a	This commit adds support for the Logitech G610 Orion Keyboard. Its not RGB, but behaves exactly like the G810. Cycle animation doesn't work for obvious reasons.	2020-11-15 00:45:24 -06:00
Chris	a4d02d1c32	Adding Razer Viper Ultimate to openrazerdevices.h to fix #728 * Includes both Wired and Wireless modes	2020-11-15 00:42:28 -06:00
Chris M	75bd29126e	Adding Razer Lancehead V2 to OpenRazerDevices.h to fix #668 * As referenced from upstream this mouse has both wired and wireless modes (refer issue for link)	2020-11-15 01:11:32 +00:00