Add read support to XPG Spectrix S40G in Windows

* Check serial_string to ensure only ASCII characters are returned

Commit amended to remove unnecessary logging by Adam Honse <[email protected]>

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "razer-drivers-win32"]
-	path = razer-drivers-win32
-	url = https://github.com/rsandoz/razer-drivers-win32

60-openrgb.rules

@@ -35,8 +35,8 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1044", ATTR{idProduct}=="7a42", TAG+="uacces
 #   ASRock Polychrome USB                                       #
 #   ASRock Deskmini Addressable LED Strip                       #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="26CE", ATTR{idProduct}=="01A2", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="26CE", ATTR{idProduct}=="01A6", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="26ce", ATTR{idProduct}=="01a2", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="26ce", ATTR{idProduct}=="01a6", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  ASUS Aura Core Devices                                       #
@@ -57,30 +57,30 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a5", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1939", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18af", TAG+="uaccess"
 
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="193c", TAG+="uaccess"          #ROG Falchion Wired
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="193e", TAG+="uaccess"          #ROG Falchion Wireless
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1875", TAG+="uaccess"          #ROG Strix Flare
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cf", TAG+="uaccess"          #ROG Strix Flare Pink
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18f8", TAG+="uaccess"          #ROG Strix Scope
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1951", TAG+="uaccess"          #ROG Strix Scope RX
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="190c", TAG+="uaccess"          #ROG Strix Scope TKL
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a0", TAG+="uaccess"          #TUF K7 Gaming
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="193c", TAG+="uaccess", TAG+="ROG_Falchion_Wired"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="193e", TAG+="uaccess", TAG+="ROG_Falchion_Wireless"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1875", TAG+="uaccess", TAG+="ROG_Strix_Flare"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cf", TAG+="uaccess", TAG+="ROG_Strix_Flare_Pink"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18f8", TAG+="uaccess", TAG+="ROG_Strix_Scope"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1951", TAG+="uaccess", TAG+="ROG_Strix_Scope_RX"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="190c", TAG+="uaccess", TAG+="ROG_Strix_Scope_TKL"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a0", TAG+="uaccess", TAG+="TUF_K7_Gaming"
 
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18dd", TAG+="uaccess"          #ROG Gladius II Core
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1845", TAG+="uaccess"          #ROG Gladius II
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1877", TAG+="uaccess"          #ROG Gladius II Origin
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cd", TAG+="uaccess"          #ROG Gladius II Origin Pink
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18b1", TAG+="uaccess"          #ROG Gladius II Origin COD
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="189e", TAG+="uaccess"          #ROG Gladius II Wireless1
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a0", TAG+="uaccess"          #ROG Gladius II Wireless2
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e5", TAG+="uaccess"          #ROG Chakram Wireless
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e3", TAG+="uaccess"          #ROG Chakram Wired1
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1958", TAG+="uaccess"          #ROG Chakram Wired2
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1846", TAG+="uaccess"          #ROG Pugio
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1906", TAG+="uaccess"          #ROG Pugio II Wired
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1908", TAG+="uaccess"          #ROG Pugio II Wireless
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e1", TAG+="uaccess"          #ROG Strix Impact II
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1910", TAG+="uaccess"          #TUF M3 & M7
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18dd", TAG+="uaccess", TAG+="ROG_Gladius_II_Core"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1845", TAG+="uaccess", TAG+="ROG_Gladius_II"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1877", TAG+="uaccess", TAG+="ROG_Gladius_II_Origin"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cd", TAG+="uaccess", TAG+="ROG_Gladius_II_Origin_Pink"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18b1", TAG+="uaccess", TAG+="ROG_Gladius_II_Origin_COD"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="189e", TAG+="uaccess", TAG+="ROG_Gladius_II_Wireless1"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a0", TAG+="uaccess", TAG+="ROG_Gladius_II_Wireless2"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e5", TAG+="uaccess", TAG+="ROG_Chakram_Wireless"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e3", TAG+="uaccess", TAG+="ROG_Chakram_Wired1"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1958", TAG+="uaccess", TAG+="ROG_Chakram_Wired2"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1846", TAG+="uaccess", TAG+="ROG_Pugio"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1906", TAG+="uaccess", TAG+="ROG_Pugio_II_Wired"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1908", TAG+="uaccess", TAG+="ROG_Pugio_II_Wireless"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e1", TAG+="uaccess", TAG+="ROG_Strix_Impact_II"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1910", TAG+="uaccess", TAG+="TUF_M3_&_M7"
 
 #---------------------------------------------------------------#
 #  ASUS TUF Laptops (faustus)                                   #
@@ -98,6 +98,7 @@ ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /s
 #                                                               #
 #  Mice:                                                        #
 #       Cooler Master MM711                                     #
+#       Cooler Master MM720                                     #
 #  Mousemats:                                                   #
 #       Cooler Master MP750                                     #
 #  Controllers:                                                 #
@@ -113,19 +114,20 @@ ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /s
 #       Masterkeys SK630                                        #
 #       Masterkeys SK650                                        #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0101", TAG+="uaccess"          #MM711
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0109", TAG+="uaccess"          #MP750 XL
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0105", TAG+="uaccess"          #MP750 M
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="1011", TAG+="uaccess"          #ARGB
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="1000", TAG+="uaccess"          #Small ARGB
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="004f", TAG+="uaccess"          #RGB
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="014d", TAG+="uaccess"          #Radeon 6000
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="003b", TAG+="uaccess"          #Masterkeys Pro L
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0047", TAG+="uaccess"          #Masterkeys Pro L White
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="003c", TAG+="uaccess"          #Masterkeys Pro S
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0067", TAG+="uaccess"          #Masterkeys MK750
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0089", TAG+="uaccess"          #Masterkeys SK630
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="008d", TAG+="uaccess"          #Masterkeys SK650
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0101", TAG+="uaccess", TAG+="MM711"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0141", TAG+="uaccess", TAG+="MM720"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0109", TAG+="uaccess", TAG+="MP750_XL"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0105", TAG+="uaccess", TAG+="MP750_M"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="1011", TAG+="uaccess", TAG+="ARGB"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="1000", TAG+="uaccess", TAG+="Small_ARGB"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="004f", TAG+="uaccess", TAG+="RGB"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="014d", TAG+="uaccess", TAG+="Radeon_6000"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="003b", TAG+="uaccess", TAG+="Masterkeys_Pro_L"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0047", TAG+="uaccess", TAG+="Masterkeys_Pro_L_White"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="003c", TAG+="uaccess", TAG+="Masterkeys_Pro_S"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0067", TAG+="uaccess", TAG+="Masterkeys_MK750"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0089", TAG+="uaccess", TAG+="Masterkeys_SK630"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="008d", TAG+="uaccess", TAG+="Masterkeys_SK650"
 
 
 #---------------------------------------------------------------#
@@ -360,6 +362,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0cf2", ATTR{idProduct}=="7750", TAG+="uacces
 #       Logitech G502 Hero                                      #
 #       Logitech G502 Wireless                                  #
 #       Logitech G703 Wireless                                  #
+#       Logitech G703 Hero Wireless                             #
 #       Logitech G900 Wireless                                  #
 #       Logitech G903 Wireless                                  #
 #       Logitech G Lightspeed Wireless Gaming Mouse             #
@@ -388,9 +391,9 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c331", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c337", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c232", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33f", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c335", TAG+="uaccess"          #G910
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c541", TAG+="uaccess"          #G915 Receiver
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33e", TAG+="uaccess"          #G915 Wired
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c335", TAG+="uaccess", TAG+="G910"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c541", TAG+="uaccess", TAG+="G915_Receiver"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33e", TAG+="uaccess", TAG+="G915_Wired"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c084", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c092", TAG+="uaccess"
@@ -402,8 +405,10 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c332", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08b", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08d", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="407f", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c087", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4070", TAG+="uaccess"          #G703 Virtual PID
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c087", TAG+="uaccess", TAG+="G703"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4070", TAG+="uaccess", TAG+="G703_Virtual"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c090", TAG+="uaccess", TAG+="G703_Hero"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4086", TAG+="uaccess", TAG+="G703_Hero_Virtual"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c081", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4053", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c086", TAG+="uaccess"
@@ -414,16 +419,16 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08c", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c088", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4079", TAG+="uaccess"
 
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uaccess"          #Powerplay Mat Reciever
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="405F", TAG+="uaccess"          #Powerplay Mat Virtual PID
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uaccess", TAG+="Powerplay_Mat_Reciever"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="405f", TAG+="uaccess", TAG+="Powerplay_Mat_Virtual"
 
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a78", TAG+="uaccess"          #G560
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a78", TAG+="uaccess", TAG+="G560"
 
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a5b", TAG+="uaccess"          #G933
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0ab5", TAG+="uaccess"          #G733
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a5b", TAG+="uaccess", TAG+="G933"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0ab5", TAG+="uaccess", TAG+="G733"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0738", ATTR{idProduct}=="2221", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0738", ATTR{idProduct}=="A221", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0738", ATTR{idProduct}=="a221", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  Metadot Das Keyboard 4Q + 5Q                                 #
@@ -434,62 +439,63 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="24f0", ATTR{idProduct}=="2020", TAG+="uacces
 #---------------------------------------------------------------#
 #  MSI Mysticlight                                              #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="3EA4", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="3ea4", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="4459", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B10", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B12", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B17", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B85", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B93", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B94", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B96", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C34", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C35", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C36", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C37", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C42", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C56", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C59", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C60", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C67", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C70", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C71", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C73", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C75", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C76", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C77", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C79", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C80", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C81", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C82", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C83", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C84", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C85", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C86", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C87", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C88", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C89", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C90", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C91", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C92", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C94", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C95", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C96", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C98", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C99", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7D06", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7D09", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="905D", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7b10", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7b12", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7b17", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7b85", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7b93", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7b94", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7b96", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c34", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c35", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c36", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c37", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c42", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c56", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c59", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c60", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c67", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c70", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c71", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c73", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c75", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c76", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c77", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c79", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c80", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c81", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c82", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c83", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c84", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c85", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c86", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c87", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c88", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c89", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c90", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c91", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c92", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c94", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c95", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c96", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c98", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c99", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7d06", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7d07", TAG+="uaccess", TAG+="MPG_Z590_GAMING_EDGE_WIFI"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7d09", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="905d", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  MSI/SteelSeries 3-Zone Laptop Keyboard                       #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1770", ATTR{idProduct}=="FF00", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1770", ATTR{idProduct}=="ff00", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  NZXT Hue+                                                    #
 #---------------------------------------------------------------#
-KERNEL=="ttyACM[0-9]*", ATTR{idVendor}=="04D8", ATTR{idProduct}=="00DF", TAG+="uaccess"
+KERNEL=="ttyACM[0-9]*", ATTR{idVendor}=="04d8", ATTR{idProduct}=="00df", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  NZXT Hue 2 Devices                                           #
@@ -507,7 +513,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2005", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2006", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2007", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2009", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="200D", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="200d", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  NZXT Kraken                                                  #
@@ -518,103 +524,106 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="1715", TAG+="uacces
 #---------------------------------------------------------------#
 #  Razer Devices                                                #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0241", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0203", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0209", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0221", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0228", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0237", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0235", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0211", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0216", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="021A", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="020F", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0241", TAG+="uaccess", TAG+="Blackwidow_2019"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0203", TAG+="uaccess", TAG+="Blackwidow_Chroma"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0209", TAG+="uaccess", TAG+="Blackwidow_Chroma_TE"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0221", TAG+="uaccess", TAG+="Blackwidow_Chroma_V2"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0228", TAG+="uaccess", TAG+="Blackwidow_Elite"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0237", TAG+="uaccess", TAG+="Blackwidow_Essential"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0235", TAG+="uaccess", TAG+="Blackwidow_Lite"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0211", TAG+="uaccess", TAG+="Blackwidow_Overwatch"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="025a", TAG+="uaccess", TAG+="Blackwidow_V3_Pro-Wired"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="025b", TAG+="uaccess", TAG+="Blackwidow_V3_Pro-Bluetooth"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="025c", TAG+="uaccess", TAG+="Blackwidow_V3_Pro-Wireless"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0a24", TAG+="uaccess", TAG+="Blackwidow_V3_TKL"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0216", TAG+="uaccess", TAG+="Blackwidow_X Chroma"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="021a", TAG+="uaccess", TAG+="Blackwidow_X_Chroma_TE"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="020f", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0224", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0233", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="023B", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="023b", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0240", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="023A", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="023a", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0246", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0245", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="024D", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="024d", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0253", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0255", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="026A", TAG+="uaccess"      # Razer Book 13 (2020)
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="026F", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="026a", TAG+="uaccess", TAG+="Razer_Book_13-2020"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="026f", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0210", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0225", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022F", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022f", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0234", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="024C", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="024c", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0205", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0220", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022D", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022d", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0232", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0239", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="024A", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="024a", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0252", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0259", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022A", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="023F", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="025E", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022a", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="023f", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="025e", TAG+="uaccess", TAG+="Cynosa_Chroma_V2"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0204", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0226", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0227", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0257", TAG+="uaccess"      #Huntsman Mini
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0257", TAG+="uaccess", TAG+="Huntsman_Mini"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0243", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0207", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="021E", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="025D", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="021e", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="025d", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0208", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022B", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022b", TAG+="uaccess"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0020", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005E", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006A", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006B", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005e", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006a", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006b", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0042", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005B", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005b", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0062", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0064", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0065", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0086", TAG+="uaccess"          #Basilisk Ultimate
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0088", TAG+="uaccess"          #Basilisk Ultimate (Wireless)
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0086", TAG+="uaccess", TAG+="Basilisk_Ultimate"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0088", TAG+="uaccess", TAG+="Basilisk_Ultimate-Wireless"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0083", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0083", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0085", TAG+="uaccess"          #Basilisk V2
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0085", TAG+="uaccess", TAG+="Basilisk_V2"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0038", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="004F", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="004f", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0037", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0016", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0054", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0043", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005C", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006E", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005c", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006e", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0071", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="008C", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="008c", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0084", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007C", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007D", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="004C", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="002F", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007c", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007d", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="004c", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="002f", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0060", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0059", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005A", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005a", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0070", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006F", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006f", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0024", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0025", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0044", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0045", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0073", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0072", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006C", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006c", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0046", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="002E", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="002e", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0040", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0053", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="003F", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="003E", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="003f", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="003e", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0041", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0036", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0050", TAG+="uaccess"
@@ -624,36 +633,38 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0039", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0048", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0032", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0034", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="008A", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="008a", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0078", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007A", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007B", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007a", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007b", TAG+="uaccess"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0506", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0501", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F19", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0f19", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0504", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0527", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0510", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F03", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0f03", TAG+="uaccess"
 
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F08", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F20", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F26", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F1F", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F09", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F07", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F0E", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0f08", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0f20", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0f26", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0f1f", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0f09", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0f07", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0f0e", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0215", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0068", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0C00", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0C04", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0C02", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0C01", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F1D", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007E", TAG+="uaccess"          #Razer Mouse Dock Chroma
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0c00", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0c04", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0c02", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0c01", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0f1d", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007e", TAG+="uaccess", TAG+="Razer_Mouse_Dock_Chroma"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0517", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0518", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0f13", TAG+="uaccess", TAG+="O11_Dynamic_Razer_Ed"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0f1b", TAG+="uaccess", TAG+="Razer_Seiren_Emote"
 
 #---------------------------------------------------------------#
 #  Roccat Devices                                               #
@@ -735,6 +746,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="0ba0", TAG+="uacces
 #  Headsets:                                                    #
 #       SteelSeries Siberia 350                                 #
 #  Keyboards:                                                   #
+#       SteelSeries Apex 3                                      #
 #       SteelSeries Apex 5                                      #
 #       SteelSeries Apex 7                                      #
 #       SteelSeries Apex 7 TKL                                  #
@@ -744,7 +756,10 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="0ba0", TAG+="uacces
 #       SteelSeries Apex OG                                     #
 #       SteelSeries Apex 350                                    #
 #  Mousemats:                                                   #
-#       SteelSeries QCK Prism Cloth                             #
+#       SteelSeries QCK Prism Cloth Medium                      #
+#       SteelSeries QCK Prism Cloth XL                          #
+#       SteelSeries QCK Prism Cloth 3XL                         #
+#       SteelSeries QCK Prism Cloth 4XL                         #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1702", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="170c", TAG+="uaccess"
@@ -764,9 +779,9 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1832", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1834", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1722", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1726", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="172B", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1824", TAG+="uaccess"          #Rival3_Old
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="184c", TAG+="uaccess"          #Rival3
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="172b", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1824", TAG+="uaccess", TAG+="Rival3_Old"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="184c", TAG+="uaccess", TAG+="Rival3"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1229", TAG+="uaccess"
 
@@ -775,12 +790,15 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1612", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1618", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1610", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1614", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="161a", TAG+="uaccess", TAG+="Apex3"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="0616", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1202", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1206", TAG+="uaccess"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="150a", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="150d", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1516", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1518", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  Tecknet Devices                                              #
@@ -795,18 +813,23 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="3006", TAG+="uacces
 #---------------------------------------------------------------#
 #  Thermaltake Riing Controllers                                #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FA[5-9]", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FA[A-F]", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FB[0-5]", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1fa[5-9]", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1fa[a-f]", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1fb[0-5]", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="226[0-3]", TAG+="uaccess"
 
+#---------------------------------------------------------------#
+#  ThingM Controllers                                           #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="27b8", ATTR{idProduct}=="01ed", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  Wooting Devices                                              #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff01", TAG+="uaccess"          #WootingOne
-SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff02", TAG+="uaccess"          #WootingTwo
-SUBSYSTEMS=="usb", ATTR{idVendor}=="31e3", ATTR{idProduct}=="1210", TAG+="uaccess"          #WootingTwo LE
-SUBSYSTEMS=="usb", ATTR{idVendor}=="31e3", ATTR{idProduct}=="1220", TAG+="uaccess"          #WootingTwo HE
+SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff01", TAG+="uaccess", TAG+="WootingOne"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff02", TAG+="uaccess", TAG+="WootingTwo"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="31e3", ATTR{idProduct}=="1210", TAG+="uaccess", TAG+="WootingTwo_LE"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="31e3", ATTR{idProduct}=="1220", TAG+="uaccess", TAG+="WootingTwo_HE"
 
 #---------------------------------------------------------------#
 #  Zalman ZSync Devices                                         #

AutoStart/AutoStart-Windows.cpp

@@ -83,7 +83,7 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
         if(result == CO_E_NOTINITIALIZED)
         {
             weInitialised                           = true;
-            CoInitializeEx(NULL, COINIT_MULTITHREADED);
+            CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
             result                                  = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);
         }
 

Colors.h

@@ -0,0 +1,152 @@
+#ifndef COLORS_H
+#define COLORS_H
+
+#define COLOR_BLACK 0x000000
+#define COLOR_NAVY 0x000080
+#define COLOR_DARKBLUE 0x00008b
+#define COLOR_MEDIUMBLUE 0x0000cd
+#define COLOR_BLUE 0x0000ff
+#define COLOR_DARKGREEN 0x006400
+#define COLOR_GREEN 0x008000
+#define COLOR_TEAL 0x008080
+#define COLOR_DARKCYAN 0x008b8b
+#define COLOR_DEEPSKYBLUE 0x00bfff
+#define COLOR_DARKTURQUOISE 0x00ced1
+#define COLOR_MEDIUMSPRINGGREEN 0x00fa9a
+#define COLOR_LIME 0x00ff00
+#define COLOR_SPRINGGREEN 0x00ff7f
+#define COLOR_AQUA 0x00ffff
+#define COLOR_CYAN 0x00ffff
+#define COLOR_MIDNIGHTBLUE 0x191970
+#define COLOR_DODGERBLUE 0x1e90ff
+#define COLOR_LIGHTSEAGREEN 0x20b2aa
+#define COLOR_FORESTGREEN 0x228b22
+#define COLOR_SEAGREEN 0x2e8b57
+#define COLOR_DARKSLATEGRAY 0x2f4f4f
+#define COLOR_DARKSLATEGREY 0x2f4f4f
+#define COLOR_LIMEGREEN 0x32cd32
+#define COLOR_MEDIUMSEAGREEN 0x3cb371
+#define COLOR_TURQUOISE 0x40e0d0
+#define COLOR_ROYALBLUE 0x4169e1
+#define COLOR_STEELBLUE 0x4682b4
+#define COLOR_DARKSLATEBLUE 0x483d8b
+#define COLOR_MEDIUMTURQUOISE 0x48d1cc
+#define COLOR_INDIGO 0x4b0082
+#define COLOR_DARKOLIVEGREEN 0x556b2f
+#define COLOR_CADETBLUE 0x5f9ea0
+#define COLOR_CORNFLOWERBLUE 0x6495ed
+#define COLOR_MEDIUMAQUAMARINE 0x66cdaa
+#define COLOR_DIMGRAY 0x696969
+#define COLOR_DIMGREY 0x696969
+#define COLOR_SLATEBLUE 0x6a5acd
+#define COLOR_OLIVEDRAB 0x6b8e23
+#define COLOR_SLATEGRAY 0x708090
+#define COLOR_SLATEGREY 0x708090
+#define COLOR_LIGHTSLATEGRAY 0x778899
+#define COLOR_LIGHTSLATEGREY 0x778899
+#define COLOR_MEDIUMSLATEBLUE 0x7b68ee
+#define COLOR_LAWNGREEN 0x7cfc00
+#define COLOR_CHARTREUSE 0x7fff00
+#define COLOR_AQUAMARINE 0x7fffd4
+#define COLOR_MAROON 0x800000
+#define COLOR_PURPLE 0x800080
+#define COLOR_OLIVE 0x808000
+#define COLOR_GRAY 0x808080
+#define COLOR_GREY 0x808080
+#define COLOR_SKYBLUE 0x87ceeb
+#define COLOR_LIGHTSKYBLUE 0x87cefa
+#define COLOR_BLUEVIOLET 0x8a2be2
+#define COLOR_DARKRED 0x8b0000
+#define COLOR_DARKMAGENTA 0x8b008b
+#define COLOR_SADDLEBROWN 0x8b4513
+#define COLOR_DARKSEAGREEN 0x8fbc8f
+#define COLOR_LIGHTGREEN 0x90ee90
+#define COLOR_MEDIUMPURPLE 0x9370db
+#define COLOR_DARKVIOLET 0x9400d3
+#define COLOR_PALEGREEN 0x98fb98
+#define COLOR_DARKORCHID 0x9932cc
+#define COLOR_YELLOWGREEN 0x9acd32
+#define COLOR_SIENNA 0xa0522d
+#define COLOR_BROWN 0xa52a2a
+#define COLOR_DARKGRAY 0xa9a9a9
+#define COLOR_DARKGREY 0xa9a9a9
+#define COLOR_LIGHTBLUE 0xadd8e6
+#define COLOR_GREENYELLOW 0xadff2f
+#define COLOR_PALETURQUOISE 0xafeeee
+#define COLOR_LIGHTSTEELBLUE 0xb0c4de
+#define COLOR_POWDERBLUE 0xb0e0e6
+#define COLOR_FIREBRICK 0xb22222
+#define COLOR_DARKGOLDENROD 0xb8860b
+#define COLOR_MEDIUMORCHID 0xba55d3
+#define COLOR_ROSYBROWN 0xbc8f8f
+#define COLOR_DARKKHAKI 0xbdb76b
+#define COLOR_SILVER 0xc0c0c0
+#define COLOR_MEDIUMVIOLETRED 0xc71585
+#define COLOR_INDIANRED 0xcd5c5c
+#define COLOR_PERU 0xcd853f
+#define COLOR_CHOCOLATE 0xd2691e
+#define COLOR_TAN 0xd2b48c
+#define COLOR_LIGHTGRAY 0xd3d3d3
+#define COLOR_LIGHTGREY 0xd3d3d3
+#define COLOR_THISTLE 0xd8bfd8
+#define COLOR_ORCHID 0xda70d6
+#define COLOR_GOLDENROD 0xdaa520
+#define COLOR_PALEVIOLETRED 0xdb7093
+#define COLOR_CRIMSON 0xdc143c
+#define COLOR_GAINSBORO 0xdcdcdc
+#define COLOR_PLUM 0xdda0dd
+#define COLOR_BURLYWOOD 0xdeb887
+#define COLOR_LIGHTCYAN 0xe0ffff
+#define COLOR_LAVENDER 0xe6e6fa
+#define COLOR_DARKSALMON 0xe9967a
+#define COLOR_VIOLET 0xee82ee
+#define COLOR_PALEGOLDENROD 0xeee8aa
+#define COLOR_LIGHTCORAL 0xf08080
+#define COLOR_KHAKI 0xf0e68c
+#define COLOR_ALICEBLUE 0xf0f8ff
+#define COLOR_HONEYDEW 0xf0fff0
+#define COLOR_AZURE 0xf0ffff
+#define COLOR_SANDYBROWN 0xf4a460
+#define COLOR_WHEAT 0xf5deb3
+#define COLOR_BEIGE 0xf5f5dc
+#define COLOR_WHITESMOKE 0xf5f5f5
+#define COLOR_MINTCREAM 0xf5fffa
+#define COLOR_GHOSTWHITE 0xf8f8ff
+#define COLOR_SALMON 0xfa8072
+#define COLOR_ANTIQUEWHITE 0xfaebd7
+#define COLOR_LINEN 0xfaf0e6
+#define COLOR_LIGHTGOLDENRODYELLOW 0xfafad2
+#define COLOR_OLDLACE 0xfdf5e6
+#define COLOR_RED 0xff0000
+#define COLOR_FUCHSIA 0xff00ff
+#define COLOR_MAGENTA 0xff00ff
+#define COLOR_DEEPPINK 0xff1493
+#define COLOR_ORANGERED 0xff4500
+#define COLOR_TOMATO 0xff6347
+#define COLOR_HOTPINK 0xff69b4
+#define COLOR_CORAL 0xff7f50
+#define COLOR_DARKORANGE 0xff8c00
+#define COLOR_LIGHTSALMON 0xffa07a
+#define COLOR_ORANGE 0xffa500
+#define COLOR_LIGHTPINK 0xffb6c1
+#define COLOR_PINK 0xffc0cb
+#define COLOR_GOLD 0xffd700
+#define COLOR_PEACHPUFF 0xffdab9
+#define COLOR_NAVAJOWHITE 0xffdead
+#define COLOR_MOCCASIN 0xffe4b5
+#define COLOR_BISQUE 0xffe4c4
+#define COLOR_MISTYROSE 0xffe4e1
+#define COLOR_BLANCHEDALMOND 0xffebcd
+#define COLOR_PAPAYAWHIP 0xffefd5
+#define COLOR_LAVENDERBLUSH 0xfff0f5
+#define COLOR_SEASHELL 0xfff5ee
+#define COLOR_CORNSILK 0xfff8dc
+#define COLOR_LEMONCHIFFON 0xfffacd
+#define COLOR_FLORALWHITE 0xfffaf0
+#define COLOR_SNOW 0xfffafa
+#define COLOR_YELLOW 0xffff00
+#define COLOR_LIGHTYELLOW 0xffffe0
+#define COLOR_IVORY 0xfffff0
+#define COLOR_WHITE 0xffffff
+
+#endif // COLORS_H

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp

@@ -12,6 +12,8 @@
 #include "dependencies/dmiinfo.h"
 #include "LogManager.h"
 
+#define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
+
 using namespace std::chrono_literals;
 
 PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_dev_id dev)
@@ -35,25 +37,25 @@ PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_
     switch(major_version)
     {
         case ASROCK_TYPE_ASRLED:
-            LOG_TRACE("%s Device type is ASR RGB LED", ASROCK_CONTROLLER_NAME);
+            LOG_TRACE("[%s] Device type is ASR RGB LED", ASROCK_CONTROLLER_NAME);
             asrock_type = ASROCK_TYPE_ASRLED;
             memset(zone_led_count, 0, sizeof(zone_led_count));
             break;
 
         case ASROCK_TYPE_POLYCHROME_V1:
-            LOG_TRACE("%s Device type is Polychrome v1", ASROCK_CONTROLLER_NAME);
+            LOG_TRACE("[%s] Device type is Polychrome v1", ASROCK_CONTROLLER_NAME);
             asrock_type = ASROCK_TYPE_POLYCHROME_V1;
             ReadLEDConfiguration();
             break;
 
         case ASROCK_TYPE_POLYCHROME_V2:
-            LOG_TRACE("%s Device type is Polychrome v2", ASROCK_CONTROLLER_NAME);
+            LOG_TRACE("[%s] Device type is Polychrome v2", ASROCK_CONTROLLER_NAME);
             asrock_type = ASROCK_TYPE_POLYCHROME_V2;
             ReadLEDConfiguration();
             break;
 
         default:
-            LOG_TRACE("%s Got Unknown version!", ASROCK_CONTROLLER_NAME);
+            LOG_TRACE("[%s] Got Unknown version!", ASROCK_CONTROLLER_NAME);
             asrock_type = ASROCK_TYPE_UNKNOWN;
             break;
     }
@@ -96,7 +98,7 @@ unsigned short PolychromeController::ReadFirmwareVersion()
 {
     // The firmware register holds two bytes, so the first read should return 2
     // If not, report invalid firmware revision FFFF
-    LOG_DEBUG("%s Reading back device firmware version", ASROCK_CONTROLLER_NAME);
+    LOG_DEBUG("[%s] Reading back device firmware version", ASROCK_CONTROLLER_NAME);
     // Version response array needs to be 32 bytes to prevent non ASRock board from stack smashing
     unsigned char asrock_version[I2C_SMBUS_BLOCK_MAX] = { 0x00, 0x00 };
     if (bus->i2c_smbus_read_block_data(dev, ASROCK_REG_FIRMWARE_VER, asrock_version) == 0x02)
@@ -104,12 +106,12 @@ unsigned short PolychromeController::ReadFirmwareVersion()
         unsigned char major = asrock_version[0];
         unsigned char minor = asrock_version[1];
 
-        LOG_DEBUG("%s Device firmware version: v%02d.%02d", ASROCK_CONTROLLER_NAME, major, minor);
+        LOG_DEBUG("[%s] Device firmware version: v%02d.%02d", ASROCK_CONTROLLER_NAME, major, minor);
         return((major << 8) | minor);
     }
     else
     {
-        LOG_WARNING("%s Firmware readback failed; Returning 0xFFFF", ASROCK_CONTROLLER_NAME);
+        LOG_WARNING("[%s] Firmware readback failed; Returning 0xFFFF", ASROCK_CONTROLLER_NAME);
         return(0xFFFF);
     }
 }
@@ -120,7 +122,7 @@ void PolychromeController::ReadLEDConfiguration()
     | The LED configuration register holds 6 bytes, so the first read should return 6   |
     | If not, set all zone sizes to zero                                                |
     \*---------------------------------------------------------------------------------*/
-    LOG_DEBUG("%s Reading LED config from controller", ASROCK_CONTROLLER_NAME);
+    LOG_DEBUG("[%s] Reading LED config from controller", ASROCK_CONTROLLER_NAME);
     unsigned char asrock_zone_count[I2C_SMBUS_BLOCK_MAX] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
     if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_REG_LED_CONFIG, asrock_zone_count) == 0x06)
     {
@@ -130,16 +132,16 @@ void PolychromeController::ReadLEDConfiguration()
         zone_led_count[POLYCHROME_ZONE_4]           = asrock_zone_count[3];
         zone_led_count[POLYCHROME_ZONE_5]           = asrock_zone_count[4];
         zone_led_count[POLYCHROME_ZONE_ADDRESSABLE] = asrock_zone_count[5];
-        LOG_DEBUG("%s Zone 1 LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_1]);
-        LOG_DEBUG("%s Zone 2 LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_2]);
-        LOG_DEBUG("%s Zone 3 LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_3]);
-        LOG_DEBUG("%s Zone 4 LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_4]);
-        LOG_DEBUG("%s Zone 5 LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_5]);
-        LOG_DEBUG("%s Addressable Zone LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_ADDRESSABLE]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_1, zone_led_count[POLYCHROME_ZONE_1]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_2, zone_led_count[POLYCHROME_ZONE_2]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_3, zone_led_count[POLYCHROME_ZONE_3]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_4, zone_led_count[POLYCHROME_ZONE_4]);
+        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_5, zone_led_count[POLYCHROME_ZONE_5]);
+        LOG_DEBUG("[%s] Addressable Zone LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_ADDRESSABLE]);
     }
     else
     {
-        LOG_WARNING("%s LED config read failed", ASROCK_CONTROLLER_NAME);
+        LOG_WARNING("[%s] LED config read failed", ASROCK_CONTROLLER_NAME);
         memset(zone_led_count, 0, sizeof(zone_led_count));
     }
 }

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h

@@ -15,8 +15,10 @@
 
 typedef unsigned char	polychrome_dev_id;
 
-#define ASROCK_CONTROLLER_NAME  "[ASRock Polychrome SMBus Controller]"
-#define ASROCK_DETECTOR_NAME    "[ASRock Polychrome SMBus Detect]"
+#define ASROCK_CONTROLLER_NAME  "ASRock Polychrome SMBus Controller"
+#define ASROCK_DETECTOR_NAME    "ASRock Polychrome SMBus Detect"
+#define VENDOR_NAME             "ASRock"
+#define SMBUS_ADDRESS           0x6A
 
 enum
 {

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusControllerDetect.cpp

@@ -54,33 +54,36 @@ void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
     {
         IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            LOG_TRACE("%s Bus %02d is a motherboard, checking for a device at 0x6A", ASROCK_DETECTOR_NAME, bus);
-            // Check for Polychrome controller at 0x6A
-            if (TestForPolychromeSMBusController(busses[bus], 0x6A))
+            if(busses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
             {
-                LOG_TRACE("%s Detected a device at address 0x6A, testing for a known controller", ASROCK_DETECTOR_NAME);
-                new_polychrome = new PolychromeController(busses[bus], 0x6A);
-
-                if(new_polychrome->GetASRockType() != ASROCK_TYPE_UNKNOWN)
+                LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
+                // Check for Polychrome controller at 0x6A
+                if (TestForPolychromeSMBusController(busses[bus], SMBUS_ADDRESS))
                 {
-                    LOG_TRACE("%s Found a known Polychrome device", ASROCK_DETECTOR_NAME);
-                    new_controller = new RGBController_Polychrome(new_polychrome);
-                    ResourceManager::get()->RegisterRGBController(new_controller);
+                    LOG_DEBUG("[%s] Detected a device at address %02X, testing for a known controller",  ASROCK_DETECTOR_NAME, SMBUS_ADDRESS);
+                    new_polychrome = new PolychromeController(busses[bus], SMBUS_ADDRESS);
+
+                    if(new_polychrome->GetASRockType() != ASROCK_TYPE_UNKNOWN)
+                    {
+                        LOG_DEBUG("[%s] Found a known Polychrome device", ASROCK_DETECTOR_NAME);
+                        new_controller = new RGBController_Polychrome(new_polychrome);
+                        ResourceManager::get()->RegisterRGBController(new_controller);
+                    }
+                    else
+                    {
+                        LOG_DEBUG("[%s] Not a Polychrome device or unknown type", ASROCK_DETECTOR_NAME);
+                        delete new_polychrome;
+                    }
                 }
                 else
                 {
-                    LOG_TRACE("%s Not a Polychrome device or unknown type", ASROCK_DETECTOR_NAME);
-                    delete new_polychrome;
+                    LOG_DEBUG("[%s] Bus %02d no response at %02X", ASROCK_DETECTOR_NAME, bus, SMBUS_ADDRESS);
                 }
             }
             else
             {
-                LOG_TRACE("%s Bus %02d no response at 0x6A", ASROCK_DETECTOR_NAME, bus);
-            }
-        }
-        else
-        {
-            LOG_TRACE("%s Bus %02d not a motherboard", ASROCK_DETECTOR_NAME, bus);
+                LOG_DEBUG(SMBUS_CHECK_DEVICE_FAILURE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME);
+            } 
         }
     }
 

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -8,6 +8,7 @@
 
 #include "Detector.h"
 #include "AsusAuraGPUController.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraGPU.h"
 #include "i2c_smbus.h"
@@ -28,38 +29,45 @@ typedef struct
     const char *    name;
 } gpu_pci_device;
 
+#define ASUSGPU_CONTROLLER_NAME "ASUS Aura GPU"
 #define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
 
 static const gpu_pci_device device_list[] =
 {
-    { NVIDIA_VEN,       NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,       ASUS_GTX1050_STRIX_O2G_GAMING,          0x29,   "ASUS ROG Strix GTX 1050 O2G Gaming"        },
-    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX_6G_GAMING,           0x29,   "ASUS GTX 1060 Strix 6G Gaming"             },
-    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX,                     0x29,   "ASUS GTX 1060 Strix"                       },
-    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_GAMING,              0x29,   "ASUS GTX 1070 Strix Gaming"                },
-    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_OC,                  0x29,   "ASUS GTX 1070 Strix OC"                    },
-    { NVIDIA_VEN,       NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,    0x29,   "ASUS ROG Strix GTX1070 Ti A8G Gaming"      },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_GTX1080_STRIX,                     0x29,   "ASUS GTX 1080 Strix OC"                    },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_A8G_GAMING,      0x29,   "ASUS ROG Strix GTX1080 A8G Gaming"         },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_O8G_GAMING,      0x29,   "ASUS ROG Strix GTX1080 O8G Gaming"         },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_GAMING,        0x29,   "ASUS ROG Strix GTX1080 Ti Gaming"          },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,    0x29,   "ASUS ROG Strix GTX1080 Ti 11G Gaming"      },
-    { NVIDIA_VEN,       NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1650S_OC,             0x2A,   "ASUS ROG Strix GTX 1650S OC 4G"            },
-    { NVIDIA_VEN,       NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,     0x2A,   "ASUS ROG Strix GTX 1660S O6G Gaming"       },
-    { NVIDIA_VEN,       NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_GTX1660TI_OC,                  0x2A,   "ASUS ROG GTX 1660 Ti OC 6G"                },
-    { NVIDIA_VEN,       NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_EVO_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING, 0x2A,   "ASUS ROG STRIX RTX 2060S A8G EVO Gaming 8G"},
-    { NVIDIA_VEN,       NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2060S O8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_A8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2070 A8G Gaming 8G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_O8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2070 O8G Gaming 8G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2070S O8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080_O8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2080 O8G Gaming"        },
-    { NVIDIA_VEN,       NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,   0x2A,   "ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    },
-    { AMD_GPU_VEN,      AMD_VEGA10_DEV,             ASUS_SUB_VEN,       ASUS_VEGA64_STRIX,                      0x29,   "ASUS Vega 64 Strix"                        },
-    { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5700XT_STRIX_GAMING_OC,          0x2A,   "ASUS RX 5700XT Strix Gaming OC"            },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX480_STRIX_GAMING_OC,             0x29,   "ASUS ROG STRIX RX480 Gaming OC"            },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX570_STRIX_O4G_GAMING_OC,         0x29,   "ASUS RX 570 Strix O4G Gaming OC"           },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_OC,             0x29,   "ASUS RX 580 Strix Gaming OC"               }
+    { NVIDIA_VEN,       NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,       ASUS_GTX1050_STRIX_O2G_GAMING,              0x29,   "ASUS ROG Strix GTX 1050 O2G Gaming"        },
+    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX_6G_GAMING,               0x29,   "ASUS GTX 1060 Strix 6G Gaming"             },
+    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX,                         0x29,   "ASUS GTX 1060 Strix"                       },
+    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_GAMING,                  0x29,   "ASUS GTX 1070 Strix Gaming"                },
+    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_OC,                      0x29,   "ASUS GTX 1070 Strix OC"                    },
+    { NVIDIA_VEN,       NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29,   "ASUS ROG Strix GTX1070 Ti A8G Gaming"      },
+    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_GTX1080_STRIX,                         0x29,   "ASUS GTX 1080 Strix OC"                    },
+    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29,   "ASUS ROG Strix GTX1080 A8G Gaming"         },
+    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29,   "ASUS ROG Strix GTX1080 O8G Gaming"         },
+    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29,   "ASUS ROG Strix GTX1080 Ti Gaming"          },
+    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29,   "ASUS ROG Strix GTX1080 Ti 11G Gaming"      },
+    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29,   "ASUS ROG Strix GTX1080 Ti O11G Gaming"     },
+    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29,   "ASUS ROG Strix GTX1080 Ti O11G Gaming"     },
+    { NVIDIA_VEN,       NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A,   "ASUS ROG Strix GTX 1650S OC 4G"            },
+    { NVIDIA_VEN,       NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A,   "ASUS ROG Strix GTX 1660S O6G Gaming"       },
+    { NVIDIA_VEN,       NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_GTX1660TI_OC,                      0x2A,   "ASUS ROG GTX 1660 Ti OC 6G"                },
+    { NVIDIA_VEN,       NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     },
+    { NVIDIA_VEN,       NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2060S A8G EVO Gaming 8G"},
+    { NVIDIA_VEN,       NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2060S O8G Gaming 8G"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2070 A8G Gaming 8G"     },
+    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2070 O8G Gaming 8G"     },
+    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2070S O8G Gaming 8G"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2080 O8G Gaming"        },
+    { NVIDIA_VEN,       NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2080S O8G Gaming"       },
+    { NVIDIA_VEN,       NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A,   "ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    },
+    { AMD_GPU_VEN,      AMD_VEGA10_DEV,             ASUS_SUB_VEN,       ASUS_VEGA64_STRIX,                          0x29,   "ASUS Vega 64 Strix"                        },
+    { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A,   "ASUS RX 5600XT Strix O6G Gaming"           },
+    { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A,   "ASUS RX 5700XT Strix Gaming OC"            },
+    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX480_STRIX_GAMING_OC,                 0x29,   "ASUS ROG STRIX RX480 Gaming OC"            },
+    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29,   "ASUS RX 570 Strix O4G Gaming OC"           },
+    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_OC,                 0x29,   "ASUS RX 580 Strix Gaming OC"               },
+    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_TOP,                0x29,   "ASUS RX 580 Strix Gaming TOP"              },
 };  
 
 /******************************************************************************************\
@@ -77,6 +85,8 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres
     unsigned char aura_gpu_magic_high = bus->i2c_smbus_read_byte_data(address, 0x20);                        // High Byte of magic (0x15)                        
     unsigned char aura_gpu_magic_low = bus->i2c_smbus_read_byte_data(address, 0x21);                         // Low Byte of magic (0x89)
 
+    LOG_DEBUG("[%s] Test GPU expect: 0x1589 received: 0x%02X%02X", ASUSGPU_CONTROLLER_NAME, aura_gpu_magic_high, aura_gpu_magic_low);
+
     if((aura_gpu_magic_high << 8) + aura_gpu_magic_low == AURA_GPU_MAGIC_VAL)
     {
         pass = true;
@@ -120,4 +130,4 @@ void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses)
     }
 } /* DetectAsusAuraGPUControllers() */
 
-REGISTER_I2C_DETECTOR("ASUS Aura GPU", DetectAsusAuraGPUControllers);
+REGISTER_I2C_DETECTOR(ASUSGPU_CONTROLLER_NAME, DetectAsusAuraGPUControllers);

Controllers/AsusAuraSMBusController/AsusAuraSMBusController.cpp

@@ -1,295 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraSMBusController.cpp              |
-|                                           |
-|  Driver for ASUS Aura RGB lighting        |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 8/19/2018   |
-\*-----------------------------------------*/
-
-#include "AsusAuraSMBusController.h"
-#include <cstring>
-
-static const char* aura_channels[] =                /* Aura channel strings                 */
-{
-    "Audio",
-    "Backplate",
-    "Back I/O",
-    "Center",
-    "Center",
-    "DRAM",
-    "PCIe",
-    "RGB Header",
-    "RGB Header 2",
-    "RGB Header",
-    "Unknown",
-};
-
-AuraSMBusController::AuraSMBusController(i2c_smbus_interface* bus, aura_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-
-    AuraUpdateDeviceName();
-
-    // Read the device configuration table
-    for (int i = 0; i < 64; i++)
-    {
-        config_table[i] = AuraRegisterRead(AURA_REG_CONFIG_TABLE + i);
-    }
-
-    // Read LED count from configuration table
-    led_count = config_table[AURA_CONFIG_LED_COUNT];
-
-    // LED-0116 - First generation motherboard controller
-    if (strcmp(device_name, "LED-0116") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT;
-        effect_reg  = AURA_REG_COLORS_EFFECT;
-        channel_cfg = AURA_CONFIG_CHANNEL_V1;
-    }
-    // DIMM_LED-0102 - First generation DRAM controller (Trident Z RGB)
-    else if (strcmp(device_name, "DIMM_LED-0102") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT;
-        effect_reg  = AURA_REG_COLORS_EFFECT;
-        channel_cfg = AURA_CONFIG_CHANNEL_V1;
-    }
-    // AUDA0-E6K5-0101 - Second generation DRAM controller (Geil Super Luce)
-    else if (strcmp(device_name, "AUDA0-E6K5-0101") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT_V2;
-        effect_reg  = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V1;
-    }
-    // AUMA0-E6K5-0106 - Second generation motherboard controller
-    else if (strcmp(device_name, "AUMA0-E6K5-0106") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT_V2;
-        effect_reg  = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V2;
-    }
-    // AUMA0-E6K5-0105 - Second generation motherboard controller
-    else if (strcmp(device_name, "AUMA0-E6K5-0105") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT_V2;
-        effect_reg  = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V2;
-    }
-    // AUMA0-E6K5-0104 - Second generation motherboard controller
-    else if (strcmp(device_name, "AUMA0-E6K5-0104") == 0)
-    {
-        direct_reg = AURA_REG_COLORS_DIRECT_V2;
-        effect_reg = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V2;
-    }
-    // AUMA0-E8K4-0101 - First generation motherboard controller
-    else if (strcmp(device_name, "AUMA0-E8K4-0101") == 0)
-    {
-        direct_reg = AURA_REG_COLORS_DIRECT;
-        effect_reg = AURA_REG_COLORS_EFFECT;
-        channel_cfg = AURA_CONFIG_CHANNEL_V1;
-    }
-    // Assume first generation controller if string does not match
-    else
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT;
-        effect_reg  = AURA_REG_COLORS_EFFECT;
-        channel_cfg = AURA_CONFIG_CHANNEL_V1;
-    }
-}
-
-AuraSMBusController::~AuraSMBusController()
-{
-
-}
-
-std::string AuraSMBusController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string AuraSMBusController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-unsigned char AuraSMBusController::GetChannel(unsigned int led)
-{
-    return(config_table[channel_cfg + led]);
-}
-
-const char * AuraSMBusController::GetChannelName(unsigned int led)
-{
-    switch (config_table[channel_cfg + led])
-    {
-    case (unsigned char)AURA_LED_CHANNEL_AUDIO:
-        return(aura_channels[0]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_BACKPLATE:
-        return(aura_channels[1]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_BACK_IO:
-        return(aura_channels[2]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_CENTER:
-        return(aura_channels[3]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_CENTER_START:
-        return(aura_channels[4]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_DRAM:
-        return(aura_channels[5]);
-        break;
-    
-    case (unsigned char)AURA_LED_CHANNEL_PCIE:
-        return(aura_channels[6]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER:
-        return(aura_channels[7]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER_2:
-        return(aura_channels[8]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER_3:
-        return(aura_channels[9]);
-        break;
-
-    default:
-        return(aura_channels[10]);
-        break;
-    }
-}
-
-unsigned int AuraSMBusController::GetLEDCount()
-{
-    return(led_count);
-}
-
-unsigned char AuraSMBusController::GetLEDRed(unsigned int led)
-{
-    return(AuraRegisterRead(direct_reg + ( 3 * led )));
-}
-
-unsigned char AuraSMBusController::GetLEDGreen(unsigned int led)
-{
-    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 2));
-}
-
-unsigned char AuraSMBusController::GetLEDBlue(unsigned int led)
-{
-    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 1));
-}
-
-void AuraSMBusController::SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char* colors = new unsigned char[led_count * 3];
-
-    for (unsigned int i = 0; i < (led_count * 3); i += 3)
-    {
-        colors[i + 0] = red;
-        colors[i + 1] = blue;
-        colors[i + 2] = green;
-    }
-
-    AuraRegisterWriteBlock(direct_reg, colors, led_count * 3);
-
-    delete[] colors;
-}
-
-void AuraSMBusController::SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char* colors = new unsigned char[led_count * 3];
-
-    for (unsigned int i = 0; i < (led_count * 3); i += 3)
-    {
-        colors[i + 0] = red;
-        colors[i + 1] = blue;
-        colors[i + 2] = green;
-    }
-
-    AuraRegisterWriteBlock(effect_reg, colors, led_count * 3);
-    
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-
-    delete[] colors;
-}
-
-void AuraSMBusController::SetDirect(unsigned char direct)
-{
-    AuraRegisterWrite(AURA_REG_DIRECT, direct);
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-}
-
-void AuraSMBusController::SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char colors[3] = { red, blue, green };
-
-    AuraRegisterWriteBlock(direct_reg + ( 3 * led ), colors, 3);
-}
-
-void AuraSMBusController::SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char colors[3] = { red, blue, green };
-
-    AuraRegisterWriteBlock(effect_reg + (3 * led), colors, 3);
-
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-}
-
-void AuraSMBusController::SetMode(unsigned char mode)
-{
-    AuraRegisterWrite(AURA_REG_MODE, mode);
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-}
-
-void AuraSMBusController::AuraUpdateDeviceName()
-{
-    for (int i = 0; i < 16; i++)
-    {
-        device_name[i] = AuraRegisterRead(AURA_REG_DEVICE_NAME + i);
-    }
-}
-
-unsigned char AuraSMBusController::AuraRegisterRead(aura_register reg)
-{
-    //Write Aura register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Read Aura value
-    return(bus->i2c_smbus_read_byte_data(dev, 0x81));
-
-}
-
-void AuraSMBusController::AuraRegisterWrite(aura_register reg, unsigned char val)
-{
-    //Write Aura register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Write Aura value
-    bus->i2c_smbus_write_byte_data(dev, 0x01, val);
-
-}
-
-void AuraSMBusController::AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz)
-{
-    //Write Aura register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Write Aura block data
-    bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
-
-}

Controllers/AsusAuraSMBusController/AsusAuraSMBusControllerDetect.cpp

@@ -1,226 +0,0 @@
-#include "Detector.h"
-#include "AsusAuraSMBusController.h"
-#include "LogManager.h"
-#include "RGBController.h"
-#include "RGBController_AsusAuraSMBus.h"
-#include "i2c_smbus.h"
-#include "pci_ids.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-#include "dependencies/dmiinfo.h"
-
-using namespace std::chrono_literals;
-
-/*----------------------------------------------------------------------*\
-| This list contains the available SMBus addresses for mapping Aura RAM  |
-\*----------------------------------------------------------------------*/
-#define AURA_RAM_ADDRESS_COUNT  23
-
-static const unsigned char aura_ram_addresses[] =
-{
-    0x70,
-    0x71,
-    0x72,
-    0x73,
-    0x74,
-    0x75,
-    0x76,
-    0x78,
-    0x79,
-    0x7A,
-    0x7B,
-    0x7C,
-    0x7D,
-    0x7E,
-    0x7F,
-    0x4F,
-    0x66,
-    0x67,
-    0x39,
-    0x3A,
-    0x3B,
-    0x3C,
-    0x3D
-};
-
-/*---------------------------------------------------------------------------------*\
-| This list contains the available SMBus addresses for mapping Aura motherboards    |
-\*---------------------------------------------------------------------------------*/
-#define AURA_MOBO_ADDRESS_COUNT 3
-
-static const unsigned char aura_mobo_addresses[] =
-{
-    0x40,
-    0x4E,
-    0x4F
-};
-
-/******************************************************************************************\
-*                                                                                          *
-*   AuraRegisterWrite                                                                      *
-*                                                                                          *
-*       A standalone version of the AuraSMBusController::AuraRegisterWrite function for    *
-*       access to Aura devices without instancing the AuraSMBusController class or reading *
-*       the config table from the device.                                                  *
-*                                                                                          *
-\******************************************************************************************/
-
-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));
-
-    //Write Aura value
-    bus->i2c_smbus_write_byte_data(dev, 0x01, val);
-}
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForAuraSMBusController                                                                  *
-*                                                                                          *
-*       Tests the given address to see if an Aura controller exists there.  First does a   *
-*       quick write to test for a response, and if so does a simple read at 0xA0 to test   *
-*       for incrementing values 0...F which was observed at this location during data dump *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-
-    LOG_DEBUG("[Aura SMBus] looking for devices at 0x%02X...", address);
-
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-
-    if (res >= 0)
-    {
-        pass = true;
-
-        LOG_DEBUG("[Aura SMBus] Detected an I2C device at address %02X, testing register range", address);
-
-        for (int i = 0xA0; i < 0xB0; i++)
-        {
-            res = bus->i2c_smbus_read_byte_data(address, i);
-
-            if (res != (i - 0xA0))
-            {
-                LOG_VERBOSE("[Aura SMBus] Detection failed testing register %02X.  Expected %02X, got %02X.", i, (i - 0xA0), res);
-
-                pass = false;
-            }
-        }
-
-        if(pass)
-        {
-            LOG_VERBOSE("[Aura SMBus] Detection successful, address %02X", address);
-        }
-    }
-
-    return(pass);
-
-}   /* TestForAuraSMBusController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAuraSMBusControllers                                                             *
-*                                                                                          *
-*       Detect Aura controllers on the enumerated I2C busses.  Searches for Aura-enabled   *
-*       RAM at 0x77 and tries to initialize their slot addresses, then searches for them   *
-*       at their correct initialized addresses.  Also looks for motherboard controller at  *
-*       address 0x4E.                                                                      *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           dev - I2C address of Aura device                                               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAsusAuraSMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
-{
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        int address_list_idx = -1;
-
-        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
-        {
-            LOG_DEBUG("[ASUS Aura SMBus DRAM] Remapping Aura SMBus RAM modules on 0x77");
-
-            for (unsigned int slot = 0; slot < 8; slot++)
-            {
-                int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
-
-                if (res < 0)
-                {
-                    LOG_DEBUG("[ASUS Aura SMBus DRAM] No device detected at 0x77, aborting remap");
-
-                    break;
-                }
-
-                do
-                {
-                    address_list_idx++;
-
-                    if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
-                    {
-                        LOG_DEBUG("[ASUS Aura SMBus DRAM] Testing address %02X to see if there is a device there", aura_ram_addresses[address_list_idx]);
-
-                        res = busses[bus]->i2c_smbus_write_quick(aura_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
-                    }
-                    else
-                    {
-                        break;
-                    }
-                } while (res >= 0);
-
-                if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
-                {
-                    LOG_DEBUG("[ASUS Aura SMBus DRAM] Remapping slot %d to address %02X", slot, aura_ram_addresses[address_list_idx]);
-
-                    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 (TestForAsusAuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]))
-                {
-                    AuraSMBusController* controller = new AuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]);
-                    RGBController_AuraSMBus* rgb_controller = new RGBController_AuraSMBus(controller);
-                    ResourceManager::get()->RegisterRGBController(rgb_controller);
-                }
-
-                std::this_thread::sleep_for(1ms);
-            }
-        }
-    }
-}   /* DetectAuraSMBusDRAMControllers() */
-
-void DetectAsusAuraSMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &busses)
-{
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        // Add Aura-enabled motherboard controllers
-        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
-        {
-            for (unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
-            {
-                if (TestForAsusAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
-                {
-                    DMIInfo dmi;
-                    AuraSMBusController* controller = new AuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]);
-                    RGBController_AuraSMBus* rgb_controller = new RGBController_AuraSMBus(controller);
-                    rgb_controller->name = "ASUS " + dmi.getMainboard();
-                    ResourceManager::get()->RegisterRGBController(rgb_controller);
-                }
-
-                std::this_thread::sleep_for(1ms);
-            }
-        }
-    }
-
-}   /* DetectAuraSMBusMotherboardControllers() */
-
-REGISTER_I2C_DETECTOR("ASUS Aura SMBus DRAM", DetectAsusAuraSMBusDRAMControllers);
-REGISTER_I2C_DETECTOR("ASUS Aura SMBus Motherboard", DetectAsusAuraSMBusMotherboardControllers);

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.cpp

@@ -43,6 +43,24 @@ std::string AuraHeadsetStandController::GetSerialString()
     return(return_string);
 }
 
+std::string AuraHeadsetStandController::GetVersion()
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x12;
+    usb_buf[0x02]   = 0x00;
+
+    hid_write(dev, usb_buf, 65);
+
+    unsigned char usb_buf_out[65];
+    hid_read(dev, usb_buf_out, 65);
+
+    char version[5];
+    snprintf(version, 5, "%04X", (usb_buf_out[6] << 8) | usb_buf_out[7]);
+    return std::string(version);
+}
+
 void AuraHeadsetStandController::UpdateLeds
     (
     std::vector<RGBColor>    colors
@@ -96,7 +114,7 @@ void AuraHeadsetStandController::UpdateDevice
     unsigned char   grn,
     unsigned char   blu,
     unsigned char   speed,
-    bool            save
+    unsigned char   brightness
     )
 {
     unsigned char usb_buf[65];
@@ -110,7 +128,7 @@ void AuraHeadsetStandController::UpdateDevice
     usb_buf[0x04]   = 0x00;
     usb_buf[0x05]   = mode;
     usb_buf[0x06]   = speed;
-    usb_buf[0x07]   = 0x04;
+    usb_buf[0x07]   = brightness;
     usb_buf[0x08]   = 0x00;
     usb_buf[0x09]   = 0x00;
     usb_buf[0x0a]   = red;
@@ -118,16 +136,17 @@ void AuraHeadsetStandController::UpdateDevice
     usb_buf[0x0c]   = blu;
     hid_write(dev, usb_buf, 65);
 
-    if(save)
-    {
-        unsigned char usb_save_buf[65];
-
-        memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
-        
-        usb_save_buf[0x00]   = 0x00;
-        usb_save_buf[0x01]   = 0x50;
-        usb_save_buf[0x02]   = 0x55;
-        
-        hid_write(dev, usb_save_buf, 65);
-    }
+}
+
+void AuraHeadsetStandController::SaveMode()
+{
+    unsigned char usb_save_buf[65];
+
+    memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
+
+    usb_save_buf[0x00]   = 0x00;
+    usb_save_buf[0x01]   = 0x50;
+    usb_save_buf[0x02]   = 0x55;
+
+    hid_write(dev, usb_save_buf, 65);
 }

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.h

@@ -37,6 +37,7 @@ public:
 
     std::string GetDeviceLocation();
     std::string GetSerialString();
+    std::string GetVersion();
 
     void UpdateLeds
         (
@@ -50,9 +51,11 @@ public:
         unsigned char   grn,
         unsigned char   blu,
         unsigned char   speed,
-        bool            save
+        unsigned char   brightness
         );
 
+    void SaveMode();
+
 private:
     hid_device*                 dev;
     std::string                 location;

Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp

@@ -44,6 +44,49 @@ std::string AuraMouseController::GetSerialString()
     return(return_string);
 }
 
+std::string AuraMouseController::GetVersion(bool wireless, int protocol)
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x12;
+    hid_write(dev, usb_buf, 65);
+
+    unsigned char usb_buf_out[65];
+    hid_read(dev, usb_buf_out, 65);
+
+    std::string str;
+
+    switch(protocol)
+    {
+        case 0:
+            {
+                unsigned char* offset = usb_buf_out + (wireless ? 13 : 4);
+                str = std::string(offset, offset + 4);
+            }
+            break;
+
+        case 1:
+            {
+                char version[9];
+                int offset = (wireless ? 13 : 4);
+                snprintf(version, 9, "%2X.%02X.%02X", usb_buf_out[offset + 2], usb_buf_out[offset + 1], usb_buf_out[offset]);
+                str = std::string(version);
+            }
+            break;
+
+        case 2:
+            {
+                unsigned char* offset = usb_buf_out + (wireless ? 13 : 4);
+                str = std::string(offset, offset + 4);
+                str = "0." + str.substr(0, 2) + "." + str.substr(2, 2);
+            }
+            break;
+    }
+
+    return str;
+}
+
 void AuraMouseController::SaveMode()
 {
     unsigned char usb_save_buf[ASUS_AURA_MOUSE_PACKET_SIZE] = { 0x00, 0x50, 0x03 };
@@ -60,7 +103,8 @@ void AuraMouseController::SendUpdate
     unsigned char   blu,
     unsigned char   dir,
     bool            random,
-    unsigned char   speed
+    unsigned char   speed,
+    unsigned char   brightness
     )
 {
     unsigned char usb_buf[ASUS_AURA_MOUSE_PACKET_SIZE];
@@ -79,7 +123,7 @@ void AuraMouseController::SendUpdate
     usb_buf[0x03]   = zone;
     usb_buf[0x04]   = 0x00;
     usb_buf[0x05]   = mode;
-    usb_buf[0x06]   = 0x04;
+    usb_buf[0x06]   = brightness;
     usb_buf[0x07]   = red;
     usb_buf[0x08]   = grn;
     usb_buf[0x09]   = blu;

Controllers/AsusAuraUSBController/AsusAuraMouseController.h

@@ -26,6 +26,7 @@ public:
 
     std::string GetDeviceLocation();
     std::string GetSerialString();
+    std::string GetVersion(bool wireless, int protocol);
 
     void SaveMode();
     void SendUpdate
@@ -37,8 +38,9 @@ public:
         unsigned char   blu,
         unsigned char   dir,
         bool            random,
-        unsigned char   speed
-	);
+        unsigned char   speed,
+        unsigned char   brightness
+	    );
 
     uint16_t                    device_pid;
 

Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h

@@ -44,13 +44,16 @@ enum
     AURA_MOUSE_MODE_WAVE        = 3,
     AURA_MOUSE_MODE_REACTIVE    = 4,
     AURA_MOUSE_MODE_COMET       = 5,
-    AURA_MOUSE_MODE_BATTERY     = 6
+    AURA_MOUSE_MODE_BATTERY     = 6,
+    AURA_MOUSE_MODE_NONE        = 255,
 };
 
 typedef struct
 {
     uint8_t                 speed_min;
     uint8_t                 speed_max;
+    bool                    wireless;
+    int                     version_protocol;
     std::vector<uint8_t>    mouse_zones;
     std::vector<uint8_t>    mouse_modes;
 } mouse_type;
@@ -68,8 +71,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_GLADIUS_II_CORE_PID, // ROG Gladius II Core
         {
-            255,    //Speed Min - The Asus Mouse protocol defines larger numbers as slow
-            1,      //Speed Max
+            0,    //Speed Min - The Asus Mouse protocol defines larger numbers as slow
+            0,    //Speed Max
+            false,
+            1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
@@ -79,6 +84,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            false,
+            0,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
@@ -88,6 +95,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            false,
+            0,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
@@ -97,6 +106,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            false,
+            0,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
@@ -106,6 +117,8 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            false,
+            0,
             { AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
@@ -113,25 +126,31 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_GLADIUS_II_WIRELESS_1_PID, // ROG Gladius II Wireless
         {
-            255,
+            0,
+            0,
+            true,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
     },
     {
         AURA_ROG_GLADIUS_II_WIRELESS_2_PID, // ROG Gladius II Wireless
         {
-            255,
+            0,
+            0,
+            true,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_BATTERY }
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
         }
     },
     {
         AURA_ROG_CHAKRAM_WIRELESS_PID, // ROG Chakram Wireless
         {
-            255,
+            15,
+            1,
+            true,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
@@ -140,7 +159,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_CHAKRAM_WIRED_1_PID,  // ROG Chakram Wired 1
         {
-            255,
+            15,
+            1,
+            false,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
@@ -149,7 +170,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_CHAKRAM_WIRED_2_PID, // ROG Chakram Wired 2
         {
-            255,
+            15,
+            1,
+            false,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
@@ -160,14 +183,18 @@ static std::map<int,mouse_type> aura_mouse_devices =
         {
             255,
             1,
+            false,
+            0,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
         }
     },
     {
         AURA_ROG_PUGIO_II_WIRED_PID, // ROG Pugio II Wired
         {
-            255,
+            15,
+            1,
+            false,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
@@ -176,7 +203,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_PUGIO_II_WIRELESS_PID, // ROG Pugio II Wireless
         {
-            255,
+            15,
+            1,
+            true,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
@@ -185,7 +214,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_ROG_STRIX_IMPACT_II_PID, // ROG Strix Impact II
         {
-            255,
+            0,
+            0,
+            false,
             1,
             { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
@@ -194,7 +225,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_TUF_M3_PID, // TUF M3
         {
-            255,
+            0,
+            0,
+            false,
             1,
             { AURA_MOUSE_ZONE_LOGO },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
@@ -203,8 +236,10 @@ static std::map<int,mouse_type> aura_mouse_devices =
     {
         AURA_TUF_M5_PID, // TUF M5
         {
-            255,
-            1,
+            0,
+            0,
+            false,
+            2,
             { AURA_MOUSE_ZONE_LOGO },
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -49,6 +49,7 @@
 |  OTHER                                                            |
 \*-----------------------------------------------------------------*/
 #define AURA_TERMINAL_PID                       0x1889
+#define AURA_ROG_THRONE_PID                     0x18D9
 #define AURA_ROG_THRONE_QI_PID                  0x18C5
 
 
@@ -211,8 +212,8 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",         DetectAsusAuraUS
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,             0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_2_PID,             0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_PID,                       2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,              1,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,           1,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,              0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,           0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PID,             1,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3",                  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M3_PID,                          1,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M5_PID,                          1,  0xFF01);
@@ -221,4 +222,5 @@ REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                  DetectAsusAuraUS
 |  OTHER                                                            |
 \*-----------------------------------------------------------------*/
 REGISTER_HID_DETECTOR   ("ASUS ROG AURA Terminal",              DetectAsusAuraUSBTerminal,      AURA_USB_VID, AURA_TERMINAL_PID);
+REGISTER_HID_DETECTOR_I ("ASUS ROG Throne",         			DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_PID, 					    0);
 REGISTER_HID_DETECTOR_I ("ASUS ROG Throne QI",                  DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID,                   0);

Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp

@@ -17,6 +17,7 @@ RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandC
     vendor      = "ASUS";
     type        = DEVICE_TYPE_HEADSET_STAND;
     description = "ASUS Aura Headset Stand Device";
+    version     = aura->GetVersion();
     location    = aura->GetDeviceLocation();
     serial      = aura->GetSerialString();
 
@@ -28,55 +29,70 @@ RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandC
     modes.push_back(Direct);
 
     mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_HEADSET_STAND_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min = 1;
-    Static.colors_max = 1;
+    Static.name           = "Static";
+    Static.value          = AURA_HEADSET_STAND_MODE_STATIC;
+    Static.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Static.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    Static.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    Static.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
+    Static.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min     = 1;
+    Static.colors_max     = 1;
     Static.colors.resize(1);
     modes.push_back(Static);
 
     mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = AURA_HEADSET_STAND_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.speed_min  = 0;
-    Breathing.speed_max  = 255;
-    Breathing.speed      = 127;
-    Breathing.colors_min = 1;
-    Breathing.colors_max = 1;
+    Breathing.name           = "Breathing";
+    Breathing.value          = AURA_HEADSET_STAND_MODE_BREATHING;
+    Breathing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Breathing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed_min      = AURA_HEADSETSTAND_SPEED_MIN;
+    Breathing.speed_max      = AURA_HEADSETSTAND_SPEED_MAX;
+    Breathing.speed          = AURA_HEADSETSTAND_SPEED_DEFAULT;
+    Breathing.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    Breathing.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    Breathing.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
+    Breathing.colors_min     = 1;
+    Breathing.colors_max     = 1;
     Breathing.colors.resize(1);
     modes.push_back(Breathing);
 
     mode Strobing;
-    Strobing.name       = "Strobing";
-    Strobing.value      = AURA_HEADSET_STAND_MODE_STROBING;
-    Strobing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Strobing.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Strobing.colors_min = 1;
-    Strobing.colors_max = 1;
+    Strobing.name           = "Flashing";
+    Strobing.value          = AURA_HEADSET_STAND_MODE_STROBING;
+    Strobing.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Strobing.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    Strobing.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    Strobing.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
+    Strobing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Strobing.colors_min     = 1;
+    Strobing.colors_max     = 1;
     Strobing.colors.resize(1);
     modes.push_back(Strobing);
 
     mode SpectrumCycle;
-    SpectrumCycle.name       = "Spectrum Cycle";
-    SpectrumCycle.value      = AURA_HEADSET_STAND_MODE_COLOR_CYCLE;
-    SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED;
-    SpectrumCycle.speed_min  = 0;
-    SpectrumCycle.speed_max  = 255;
-    SpectrumCycle.speed      = 127;
-    SpectrumCycle.color_mode = MODE_COLORS_NONE;
+    SpectrumCycle.name           = "Spectrum Cycle";
+    SpectrumCycle.value          = AURA_HEADSET_STAND_MODE_COLOR_CYCLE;
+    SpectrumCycle.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    SpectrumCycle.speed_min      = AURA_HEADSETSTAND_SPEED_MIN;
+    SpectrumCycle.speed_max      = AURA_HEADSETSTAND_SPEED_MAX;
+    SpectrumCycle.speed          = AURA_HEADSETSTAND_SPEED_DEFAULT;
+    SpectrumCycle.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    SpectrumCycle.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    SpectrumCycle.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
+    SpectrumCycle.color_mode     = MODE_COLORS_NONE;
     modes.push_back(SpectrumCycle);
 
     mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = AURA_HEADSET_STAND_MODE_RAINBOW;
-    Rainbow.flags      = MODE_FLAG_HAS_SPEED;
-    Rainbow.speed_min  = 0;
-    Rainbow.speed_max  = 255;
-    Rainbow.speed      = 127;
+    Rainbow.name           = "Rainbow Wave";
+    Rainbow.value          = AURA_HEADSET_STAND_MODE_RAINBOW;
+    Rainbow.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Rainbow.speed_min      = AURA_HEADSETSTAND_SPEED_MIN;
+    Rainbow.speed_max      = AURA_HEADSETSTAND_SPEED_MAX;
+    Rainbow.speed          = AURA_HEADSETSTAND_SPEED_DEFAULT;
+    Rainbow.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
+    Rainbow.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
+    Rainbow.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
     modes.push_back(Rainbow);
     SetupZones();
 }
@@ -172,11 +188,17 @@ void RGBController_AuraHeadsetStand::DeviceUpdateMode()
             red = RGBGetRValue(modes[active_mode].colors[0]);
             grn = RGBGetGValue(modes[active_mode].colors[0]);
             blu = RGBGetBValue(modes[active_mode].colors[0]);
-            aura->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, false);
+            aura->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, modes[active_mode].brightness);
             break;
         case 4:
         case 5:
-            aura->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, false);
+            aura->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, modes[active_mode].brightness);
             break;
     }
 }
+
+void RGBController_AuraHeadsetStand::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    aura->SaveMode();
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.h

@@ -11,6 +11,16 @@
 #include "RGBController.h"
 #include "AsusAuraHeadsetStandController.h"
 
+enum
+{
+    AURA_HEADSETSTAND_BRIGHTNESS_MIN     = 0,
+    AURA_HEADSETSTAND_BRIGHTNESS_MAX     = 4,
+    AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT = 4,
+    AURA_HEADSETSTAND_SPEED_MIN          = 0,
+    AURA_HEADSETSTAND_SPEED_MAX          = 255,
+    AURA_HEADSETSTAND_SPEED_DEFAULT      = 127,
+};
+
 class RGBController_AuraHeadsetStand : public RGBController
 {
 public:
@@ -27,6 +37,7 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
     AuraHeadsetStandController*  aura;

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp

@@ -20,16 +20,20 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
 {
     aura                    = aura_ptr;
 
+    uint16_t pid            = aura->device_pid;
+
     name                    = "ASUS Aura Mouse";
     vendor                  = "ASUS";
     type                    = DEVICE_TYPE_MOUSE;
     description             = "ASUS Aura Mouse Device";
+    version                 = aura->GetVersion(aura_mouse_devices[pid].wireless, aura_mouse_devices[pid].version_protocol);
     location                = aura->GetDeviceLocation();
     serial                  = aura->GetSerialString();
 
-    uint16_t pid            = aura->device_pid;
     std::vector<uint8_t> mm = aura_mouse_devices[pid].mouse_modes;
 
+    int mode_value          = 0;
+
     for(std::vector<uint8_t>::iterator it = mm.begin(); it != mm.end(); it++)
     {
         switch(*it)
@@ -37,10 +41,13 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
             case AURA_MOUSE_MODE_STATIC:
                 {
                     mode Direct;
-                    Direct.name             = "Direct";
-                    Direct.value            = AURA_MOUSE_MODE_STATIC;
-                    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-                    Direct.color_mode       = MODE_COLORS_PER_LED;
+                    Direct.name                 = "Direct";
+                    Direct.value                = mode_value;
+                    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    Direct.brightness_min       = AURA_MOUSE_BRIGHTNESS_MIN;
+                    Direct.brightness_max       = AURA_MOUSE_BRIGHTNESS_MAX;
+                    Direct.brightness           = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Direct.color_mode           = MODE_COLORS_PER_LED;
                     modes.push_back(Direct);
                 }
                 break;
@@ -48,10 +55,13 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
             case AURA_MOUSE_MODE_BREATHING:
                 {
                     mode Breathing;
-                    Breathing.name          = "Breathing";
-                    Breathing.value         = AURA_MOUSE_MODE_BREATHING;
-                    Breathing.flags         = MODE_FLAG_HAS_PER_LED_COLOR;
-                    Breathing.color_mode    = MODE_COLORS_PER_LED;
+                    Breathing.name              = "Breathing";
+                    Breathing.value             = mode_value;
+                    Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    Breathing.brightness_min    = AURA_MOUSE_BRIGHTNESS_MIN;
+                    Breathing.brightness_max    = AURA_MOUSE_BRIGHTNESS_MAX;
+                    Breathing.brightness        = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Breathing.color_mode        = MODE_COLORS_PER_LED;
                     modes.push_back(Breathing);
                 }
                 break;
@@ -59,10 +69,13 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
             case AURA_MOUSE_MODE_SPECTRUM:
                 {
                     mode ColorCycle;
-                    ColorCycle.name         = "Spectrum Cycle";
-                    ColorCycle.value        = AURA_MOUSE_MODE_SPECTRUM;
-                    ColorCycle.flags        = 0;
-                    ColorCycle.color_mode   = MODE_COLORS_NONE;
+                    ColorCycle.name             = "Spectrum Cycle";
+                    ColorCycle.value            = mode_value;
+                    ColorCycle.flags            = MODE_FLAG_HAS_BRIGHTNESS;
+                    ColorCycle.brightness_min   = AURA_MOUSE_BRIGHTNESS_MIN;
+                    ColorCycle.brightness_max   = AURA_MOUSE_BRIGHTNESS_MAX;
+                    ColorCycle.brightness       = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    ColorCycle.color_mode       = MODE_COLORS_NONE;
                     modes.push_back(ColorCycle);
                 }
                 break;
@@ -70,14 +83,17 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
             case AURA_MOUSE_MODE_WAVE:
                 {
                     mode Wave;
-                    Wave.name               = "Wave";
-                    Wave.value              = AURA_MOUSE_MODE_WAVE;
-                    Wave.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-                    Wave.direction          = 0;
-                    Wave.speed_min          = aura_mouse_devices[pid].speed_min;
-                    Wave.speed_max          = aura_mouse_devices[pid].speed_max;
-                    Wave.speed              = 128;
-                    Wave.color_mode         = MODE_COLORS_NONE;
+                    Wave.name                   = "Rainbow Wave";
+                    Wave.value                  = mode_value;
+                    Wave.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    Wave.direction              = 0;
+                    Wave.speed_min              = aura_mouse_devices[pid].speed_min;
+                    Wave.speed_max              = aura_mouse_devices[pid].speed_max;
+                    Wave.speed                  = (aura_mouse_devices[pid].speed_min + aura_mouse_devices[pid].speed_max) / 2;
+                    Wave.brightness_min         = AURA_MOUSE_BRIGHTNESS_MIN;
+                    Wave.brightness_max         = AURA_MOUSE_BRIGHTNESS_MAX;
+                    Wave.brightness             = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Wave.color_mode             = MODE_COLORS_NONE;
                     modes.push_back(Wave);
                 }
                 break;
@@ -85,10 +101,13 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
             case AURA_MOUSE_MODE_REACTIVE:
                 {
                     mode Reactive;
-                    Reactive.name           = "Reactive";
-                    Reactive.value          = AURA_MOUSE_MODE_REACTIVE;
-                    Reactive.flags          = MODE_FLAG_HAS_PER_LED_COLOR;
-                    Reactive.color_mode     = MODE_COLORS_PER_LED;
+                    Reactive.name               = "Reactive";
+                    Reactive.value              = mode_value;
+                    Reactive.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    Reactive.brightness_min     = AURA_MOUSE_BRIGHTNESS_MIN;
+                    Reactive.brightness_max     = AURA_MOUSE_BRIGHTNESS_MAX;
+                    Reactive.brightness         = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Reactive.color_mode         = MODE_COLORS_PER_LED;
                     modes.push_back(Reactive);
                 }
                 break;
@@ -96,13 +115,16 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
             case AURA_MOUSE_MODE_COMET:
                 {
                     mode Comet;
-                    Comet.name              = "Comet";
-                    Comet.value             = AURA_MOUSE_MODE_COMET;
-                    Comet.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
-                    Comet.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-                    Comet.direction         = 0;
-                    Comet.colors_min        = 1;
-                    Comet.colors_max        = 1;
+                    Comet.name                  = "Comet";
+                    Comet.value                 = mode_value;
+                    Comet.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    Comet.brightness_min        = AURA_MOUSE_BRIGHTNESS_MIN;
+                    Comet.brightness_max        = AURA_MOUSE_BRIGHTNESS_MAX;
+                    Comet.brightness            = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    Comet.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+                    Comet.direction             = 0;
+                    Comet.colors_min            = 1;
+                    Comet.colors_max            = 1;
                     Comet.colors.resize(1);
                     modes.push_back(Comet);
                 }
@@ -111,14 +133,18 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
             case AURA_MOUSE_MODE_BATTERY:
                 {
                     mode BatteryMode;
-                    BatteryMode.name       = "Battery";
-                    BatteryMode.value      = AURA_MOUSE_MODE_BATTERY;
-                    BatteryMode.flags      = 0;
-                    BatteryMode.color_mode = MODE_COLORS_NONE;
+                    BatteryMode.name            = "Battery";
+                    BatteryMode.value           = mode_value;
+                    BatteryMode.flags           = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+                    BatteryMode.brightness_min  = AURA_MOUSE_BRIGHTNESS_MIN;
+                    BatteryMode.brightness_max  = AURA_MOUSE_BRIGHTNESS_MAX;
+                    BatteryMode.brightness      = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    BatteryMode.color_mode      = MODE_COLORS_NONE;
                     modes.push_back(BatteryMode);
                 }
                 break;
         }
+        mode_value++;
     }
 
     SetupZones();
@@ -182,7 +208,7 @@ void RGBController_AuraMouse::UpdateSingleLED(int led)
     uint8_t grn = RGBGetGValue(colors[led]);
     uint8_t blu = RGBGetBValue(colors[led]);
 
-    aura->SendUpdate(leds[led].value, active_mode, red, grn, blu, 0, false, 0);
+    aura->SendUpdate(leds[led].value, modes[active_mode].value, red, grn, blu, 0, false, 0, modes[active_mode].brightness);
 }
 
 void RGBController_AuraMouse::SetCustomMode()
@@ -209,7 +235,12 @@ void RGBController_AuraMouse::DeviceUpdateMode()
             blu = RGBGetBValue(modes[active_mode].colors[0]);
         }
 
-        aura->SendUpdate(AURA_MOUSE_ZONE_ALL, active_mode, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed);
-        aura->SaveMode();
+        aura->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
     }
 }
+
+void RGBController_AuraMouse::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    aura->SaveMode();
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.h

@@ -11,6 +11,12 @@
 #include "RGBController.h"
 #include "AsusAuraMouseController.h"
 
+enum {
+	AURA_MOUSE_BRIGHTNESS_MIN     = 0,
+	AURA_MOUSE_BRIGHTNESS_MAX     = 4,
+	AURA_MOUSE_BRIGHTNESS_DEFAULT = 4
+};
+
 class RGBController_AuraMouse : public RGBController
 {
 public:
@@ -27,6 +33,7 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
     AuraMouseController*  aura;

Controllers/AsusTUFLaptopController/AsusTUFLaptopWMIDetect.cpp

@@ -16,7 +16,6 @@ static void DetectAsusTUFLaptopWMIControllers(std::vector<RGBController*>&)
     // For now, checking for "TUF Gaming" should suffice
 
     Wmi wmi;
-    wmi.init();
 
     std::vector<QueryObj> systemProduct;
     if (wmi.query("SELECT * FROM Win32_ComputerSystemProduct", systemProduct))

Controllers/CoolerMasterController/CMARGBcontroller.cpp

@@ -8,17 +8,8 @@
 \*-------------------------------------------------------------------*/
 
 #include "CMARGBcontroller.h"
-#include <cstring>
 
-static unsigned char argb_colour_index_data[2][2][2] =
-{     //B0    B1
-    { { 0x00, 0x03 },    //G0 R0
-      { 0x02, 0x06 }, }, //G1 R0
-    { { 0x01, 0x05 }, 	 //G0 R1
-      { 0x04, 0x07 }, }  //G1 R1
-};
-
-CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx)
+CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx, std::shared_ptr<std::mutex> cm_mutex)
 {
     const int szTemp = 256;
     wchar_t tmpName[szTemp];
@@ -26,6 +17,7 @@ CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned
     dev                     = dev_handle;
     location                = _path;
     zone_index              = _zone_idx;
+    mutex_ptr               = cm_mutex;
 
     hid_get_manufacturer_string(dev, tmpName, szTemp);
     std::wstring wName = std::wstring(tmpName);
@@ -66,6 +58,12 @@ void CMARGBController::GetStatus()
         rgb_offset                              = 1;
     }
 
+    /*---------------------------------------------*\
+    | Guard the writes to the controller until the  |
+    |   for loop has completed to avoid collisons   |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
+
     /*---------------------------------------------------------*\
     | If this is the group then just return the first status    |
     \*---------------------------------------------------------*/
@@ -132,38 +130,6 @@ bool CMARGBController::GetRandomColours()
     return bool_random;
 }
 
-unsigned int CMARGBController::GetLargestColour(unsigned int red, unsigned int green, unsigned int blue)
-{
-    unsigned int largest;
-    if ( red > green )
-    {
-        ( red > blue ) ? largest = red : largest = blue;
-    }
-    else
-    {
-        ( green > blue ) ? largest = green : largest = blue;
-    }
-
-    return (largest == 0) ? 1 : largest;
-}
-
-unsigned char CMARGBController::GetColourIndex(unsigned char red, unsigned char green, unsigned char blue)
-{
-    /*---------------------------------------------------------------------------------------------------------*\
-    | The Cooler Master ARGB controller V0008 uses a limited colour pallette referenced by an index             |
-    | Starting at 0x00 Random, 0x01 Red, 0x02 Green, 0x03 Blue, 0x04 Yellow, 0x05 Purple, 0x06 Cyan, 0x07 White |
-    | The index can be calculated by normalising the input colour, rounding those values                        |
-    | and using them as the indicies of a 3d array containing the correct index                                 |
-    \*---------------------------------------------------------------------------------------------------------*/
-    unsigned int divisor    = GetLargestColour( red, green, blue);
-    unsigned int r          = round( red / divisor );
-    unsigned int g          = round( green / divisor );
-    unsigned int b          = round( blue / divisor );
-    unsigned char idx       = argb_colour_index_data[r][g][b];
-
-    return idx;
-}
-
 void CMARGBController::SetLedCount(int zone, int led_count)
 {
     unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00, 0x80, 0x0D, 0x02 };
@@ -173,18 +139,24 @@ void CMARGBController::SetLedCount(int zone, int led_count)
     buffer[CM_ARGB_MODE_BYTE]                   = led_count;
     buffer[CM_ARGB_COLOUR_INDEX_BYTE]           = (0x0F - led_count > 0) ? 0x0F - led_count : 0x01;
 
+    /*---------------------------------------------*\
+    | Guard the writes to the controller until the  |
+    |   for loop has completed to avoid collisons   |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
+
     hid_write(dev, buffer, buffer_size);
 }
 
-void CMARGBController::SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours)
+void CMARGBController::SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor colour, bool random_colours)
 {
-    bool needs_update   = !( (current_mode == mode) && (current_speed == speed) && (current_brightness == 0xFF) && (ToRGBColor(current_red, current_green, current_blue) == colour));
+    bool needs_update   = !( (current_mode == mode) && (current_speed == speed) && (current_brightness == brightness) && (ToRGBColor(current_red, current_green, current_blue) == colour));
 
     if (needs_update)
     {
         current_mode        = mode;
         current_speed       = speed;
-        current_brightness  = 0xFF;
+        current_brightness  = brightness;
         current_red         = RGBGetRValue(colour);
         current_green       = RGBGetGValue(colour);
         current_blue        = RGBGetBValue(colour);
@@ -197,9 +169,9 @@ void CMARGBController::SetMode(unsigned char mode, unsigned char speed, RGBColor
 void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_count)
 {
     const unsigned char buffer_size     = CM_ARGB_PACKET_SIZE;
-    unsigned char buffer[buffer_size]   = { 0x00, 0x10, 0x02 };
+    unsigned char buffer[buffer_size]   = { 0x00, 0x00, 0x07, 0x02 };
     unsigned char packet_count          = 0;
-    std::vector<unsigned char> colours;
+    std::vector<uint8_t> colours;
 
     /*---------------------------------------------*\
     | Set up the RGB triplets to send               |
@@ -213,11 +185,17 @@ void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_cou
         colours.push_back( RGBGetBValue(colour) );
     }
 
-    buffer[CM_ARGB_ZONE_BYTE]           = argb_header_data[zone_index].header;
-    buffer[CM_ARGB_MODE_BYTE]           = led_count;
-    unsigned char buffer_idx            = CM_ARGB_MODE_BYTE + 1;
+    buffer[CM_ARGB_FUNCTION_BYTE]       = zone_index - 1;
+    buffer[CM_ARGB_ZONE_BYTE]           = led_count;
+    unsigned char buffer_idx            = CM_ARGB_MODE_BYTE;
 
-    for(std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = 0)
+    /*---------------------------------------------*\
+    | Guard the writes to the controller until the  |
+    |   for loop has completed to avoid collisons   |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
+
+    for(std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = CM_ARGB_COMMAND_BYTE)
     {
         /*-----------------------------------------------------------------*\
         | Fill the write buffer till its full or the colour buffer is empty |
@@ -230,8 +208,12 @@ void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_cou
             it++;
         }
 
+        if(it == colours.end())
+        {
+            buffer[CM_ARGB_REPORT_BYTE] += 0x80;
+        }
+
         hid_write(dev, buffer, buffer_size);
-        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
 
         /*-----------------------------------------------------------------*\
         | Reset the write buffer                                            |
@@ -239,21 +221,15 @@ void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_cou
         memset(buffer, 0x00, buffer_size );
         packet_count++;
     }
-
-    buffer[CM_ARGB_REPORT_BYTE]         = 0x82;
-    /*buffer[CM_ARGB_COMMAND_BYTE]        = 0x62;
-    buffer[CM_ARGB_FUNCTION_BYTE]       = 0x00;
-    buffer[CM_ARGB_ZONE_BYTE]           = 0x73;
-    buffer[CM_ARGB_MODE_BYTE]           = 0x00;
-    buffer[CM_ARGB_COLOUR_INDEX_BYTE]   = 0x33;
-    buffer[CM_ARGB_SPEED_BYTE]          = 0x1B;*/
-
-    hid_write(dev, buffer, buffer_size);
-    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
 }
 
 void CMARGBController::SendUpdate()
 {
+    /*---------------------------------------------*\
+    | Guard the writes to the controller            |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
+
     unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00 };
     int  buffer_size                            = (sizeof(buffer) / sizeof(buffer[0]));
     bool boolARGB_header                        = argb_header_data[zone_index].digital;
@@ -262,22 +238,29 @@ void CMARGBController::SendUpdate()
     unsigned char function                      = boolPassthru ? (boolARGB_header ? 0x02 : 0x04) : (boolARGB_header ? 0x01 : 0x03);
     buffer[CM_ARGB_REPORT_BYTE]                 = 0x80;
     buffer[CM_ARGB_COMMAND_BYTE]                = 0x01;
-    buffer[CM_ARGB_FUNCTION_BYTE]               = boolDirect ? 0x01 : function;
+
+    if(boolDirect)
+    {
+        buffer[CM_ARGB_FUNCTION_BYTE]           = 0x01;
+        buffer[CM_ARGB_ZONE_BYTE]               = 0x02;
+
+        hid_write(dev, buffer, buffer_size);
+        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
+
+        /*-----------------------------------------------------------------*\
+        | Direct mode is now set up and no other mode packet is required    |
+        \*-----------------------------------------------------------------*/
+        return;
+    }
+
+    buffer[CM_ARGB_FUNCTION_BYTE]           = function;
 
     hid_write(dev, buffer, buffer_size);
     hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
 
-    /*-----------------------------------------------------------------*\
-    | Direct mode is now set up and no other mode packet is required    |
-    \*-----------------------------------------------------------------*/
-    if(boolDirect)
-    {
-        return;
-    }
-
     if(boolARGB_header)
     {
-        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0b;                                     //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
+        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0B;                                     //ARGB sends 0x0B (1011) RGB sends 0x04 (0100)
         buffer[CM_ARGB_FUNCTION_BYTE]           = (false) ? 0x01 : 0x02;                    //This controls direct mode TODO
         buffer[CM_ARGB_ZONE_BYTE]               = argb_header_data[zone_index].header;
         buffer[CM_ARGB_MODE_BYTE]               = current_mode;
@@ -287,9 +270,6 @@ void CMARGBController::SendUpdate()
         buffer[CM_ARGB_RED_BYTE]                = current_red;
         buffer[CM_ARGB_GREEN_BYTE]              = current_green;
         buffer[CM_ARGB_BLUE_BYTE]               = current_blue;
-
-        hid_write(dev, buffer, buffer_size);
-        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
     }
     else
     {
@@ -301,8 +281,8 @@ void CMARGBController::SendUpdate()
         buffer[CM_ARGB_RED_BYTE + CM_RGB_OFFSET]            = current_red;
         buffer[CM_ARGB_GREEN_BYTE + CM_RGB_OFFSET]          = current_green;
         buffer[CM_ARGB_BLUE_BYTE + CM_RGB_OFFSET]           = current_blue;
-
-        hid_write(dev, buffer, buffer_size);
-        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
     }
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
 }

Controllers/CoolerMasterController/CMARGBcontroller.h

@@ -10,8 +10,9 @@
 \*-------------------------------------------------------------------*/
 
 #include <string>
+#include <cstring>
 #include <array>
-#include <cmath>            //Needed by round()
+#include <memory>
 #include <hidapi/hidapi.h>
 #include "RGBController.h"  //Needed to set the direct mode
 
@@ -25,6 +26,10 @@
 #define CM_RGB_OFFSET -2
 #define HID_MAX_STR 255
 
+#define CM_ARGB_BRIGHTNESS_MAX  255
+#define CM_ARGB_FW0023          std::string("A202011171238")
+#define CM_ARGB_FW0028          std::string("A202105291658")
+
 enum
 {
     CM_ARGB_REPORT_BYTE         = 1,
@@ -48,14 +53,14 @@ struct argb_headers
     unsigned int    count;
 };
 
-static argb_headers argb_header_data[6] =
+static argb_headers argb_header_data[] =
 {
     { "RGB Header",         0xFE, false,  1 },
     { "Digital ARGB1",      0x01, true,  12 },
     { "Digital ARGB2",      0x02, true,  12 },
     { "Digital ARGB3",      0x04, true,  12 },
     { "Digital ARGB4",      0x08, true,  12 },
-    { "All Digital ARGB",   0xFF, true,  12 }
+    //{ "All Digital ARGB",   0xFF, true,  12 }
 };
 
 enum
@@ -96,7 +101,7 @@ enum
 class CMARGBController
 {
 public:
-    CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx);
+    CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx, std::shared_ptr<std::mutex> cm_mutex);
     ~CMARGBController();
 
     std::string GetDeviceName();
@@ -111,27 +116,26 @@ public:
     unsigned char GetLedSpeed();
     bool GetRandomColours();
     void SetLedCount(int zone, int led_count);
-    void SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours);
+    void SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor colour, bool random_colours);
     void SetLedsDirect(RGBColor * led_colours, unsigned int led_count);
 
 private:
-    std::string             device_name;
-    std::string             serial;
-    std::string             location;
-    hid_device*             dev;
+    std::string                 device_name;
+    std::string                 serial;
+    std::string                 location;
+    hid_device*                 dev;
+    std::shared_ptr<std::mutex> mutex_ptr;
 
-    unsigned char           zone_index;
-    unsigned char           current_mode;
-    unsigned char           current_speed;
+    unsigned char               zone_index;
+    unsigned char               current_mode;
+    unsigned char               current_speed;
 
-    unsigned char           current_red;
-    unsigned char           current_green;
-    unsigned char           current_blue;
-    unsigned char           current_brightness;
-    bool                    bool_random;
+    unsigned char               current_red;
+    unsigned char               current_green;
+    unsigned char               current_blue;
+    unsigned char               current_brightness;
+    bool                        bool_random;
 
-    unsigned int GetLargestColour(unsigned int red, unsigned int green, unsigned int blue);
-    unsigned char GetColourIndex(unsigned char red, unsigned char green, unsigned char blue);
     void GetStatus();
     void SendUpdate();
 };

Controllers/CoolerMasterController/CMMM711Controller.cpp

@@ -58,13 +58,20 @@ void CMMM711Controller::GetColourStatus()
 void CMMM711Controller::GetCustomStatus()
 {
     uint8_t buffer[CM_MM711_PACKET_SIZE]    = { 0x00, 0x52, 0xA8 };
-    int buffer_size                         = (sizeof(buffer) / sizeof(buffer[0]));
+    int read_size                           = CM_MM711_PACKET_SIZE - 1;
+    int result                              = 0;
 
-    hid_write(dev, buffer, buffer_size);
-    hid_read_timeout(dev, buffer, buffer_size, CM_MM711_INTERRUPT_TIMEOUT);
+    hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+    do
+    {
+        result = hid_read_timeout(dev, buffer, read_size, CM_MM711_INTERRUPT_TIMEOUT);
+    }while(buffer[1] != 0xA8 && result == read_size);
 
-    wheel_colour            = ToRGBColor(buffer[4], buffer[5], buffer[6]);
-    logo_colour             = ToRGBColor(buffer[7], buffer[8], buffer[9]);
+    if(result == read_size)
+    {
+        wheel_colour            = ToRGBColor(buffer[4], buffer[5], buffer[6]);
+        logo_colour             = ToRGBColor(buffer[7], buffer[8], buffer[9]);
+    }
 }
 
 void CMMM711Controller::GetModeStatus()
@@ -140,8 +147,9 @@ void CMMM711Controller::SetLedsDirect(RGBColor wheel_colour, RGBColor logo_colou
     buffer[CM_MM711_BRIGHTNESS_BYTE]            = RGBGetBValue(logo_colour);
 
     hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM711_PACKET_SIZE, CM_MM711_INTERRUPT_TIMEOUT);
 
-    SendApplyPacket(0xB0);  //Apply custom mode
+    //SendApplyPacket(0xB0);  //Apply custom mode
 }
 
 void CMMM711Controller::SendUpdate(uint8_t mode, uint8_t speed, RGBColor colour, uint8_t brightness)
@@ -159,6 +167,7 @@ void CMMM711Controller::SendUpdate(uint8_t mode, uint8_t speed, RGBColor colour,
     buffer[CM_MM711_BLUE_BYTE]                  = RGBGetBValue(colour);
 
     hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM711_PACKET_SIZE, CM_MM711_INTERRUPT_TIMEOUT);
 
     SendApplyPacket(mode);
 }
@@ -168,6 +177,7 @@ void CMMM711Controller::SendInitPacket()
     unsigned char buffer[CM_MM711_PACKET_SIZE]  = { 0x00, 0x41, 0x80 };
 
     hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM711_PACKET_SIZE, CM_MM711_INTERRUPT_TIMEOUT);
 }
 
 void CMMM711Controller::SendApplyPacket(uint8_t mode)
@@ -177,4 +187,13 @@ void CMMM711Controller::SendApplyPacket(uint8_t mode)
     buffer[CM_MM711_MODE_BYTE]                  = mode;
 
     hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM711_PACKET_SIZE, CM_MM711_INTERRUPT_TIMEOUT);
+}
+
+void CMMM711Controller::SendSavePacket()
+{
+    unsigned char buffer[CM_MM711_PACKET_SIZE]  = { 0x00, 0x50, 0x55 };
+
+    hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM711_PACKET_SIZE, CM_MM711_INTERRUPT_TIMEOUT);
 }

Controllers/CoolerMasterController/CMMM711Controller.h

@@ -76,6 +76,7 @@ public:
 
     void        SendUpdate(uint8_t mode, uint8_t speed, RGBColor colour, uint8_t brightness);
     void        SetLedsDirect(RGBColor wheel_colour, RGBColor logo_colour);
+    void        SendSavePacket();
 private:
     std::string device_name;
     std::string serial;

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -19,6 +19,7 @@
 #define COOLERMASTER_VID                        0x2516
 
 #define COOLERMASTER_MM711_PID                  0x0101
+#define COOLERMASTER_MM720_PID                  0x0141
 #define COOLERMASTER_MP750_XL_PID               0x0109
 #define COOLERMASTER_MP750_MEDIUM_PID           0x0105
 #define COOLERMASTER_ARGB_PID                   0x1011
@@ -45,9 +46,15 @@ void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
     hid_device* dev = hid_open_path(info->path);
     if(dev)
     {
+        /*-------------------------------------------------*\
+        | Create mutex to prevent the controllers sharing a |
+        |   receiver from interfering with each other       |
+        \*-------------------------------------------------*/
+        std::shared_ptr<std::mutex>       cm_mutex = std::make_shared<std::mutex>();
+
         for(std::size_t i = 0; i < CM_ARGB_HEADER_DATA_SIZE; i++)
         {
-            CMARGBController* controller = new CMARGBController(dev, info->path, i);
+            CMARGBController* controller = new CMARGBController(dev, info->path, i, cm_mutex);
             RGBController_CMARGBController* rgb_controller = new RGBController_CMARGBController(controller);
             // Constructor sets the name
             ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -129,6 +136,7 @@ void DetectCoolerMasterSmallARGB(hid_device_info* info, const std::string&)
 }
 
 REGISTER_HID_DETECTOR_IPU("Cooler Master MM711",                    DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM711_PID,                     1,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master MM720",                    DetectCoolerMasterMouse,        COOLERMASTER_VID,   COOLERMASTER_MM720_PID,                     1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 XL",                 DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_XL_PID,                          0xFF00, 1);
 REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 Medium",             DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_MEDIUM_PID,                      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_PID,          1,      0xFF00, 1);

Controllers/CoolerMasterController/RGBController_CMARGBController.cpp

@@ -11,206 +11,245 @@
 
 RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController *cmargb_ptr)
 {
-    cmargb                  = cmargb_ptr;
-    unsigned char speed     = cmargb->GetLedSpeed();
+    cmargb                          = cmargb_ptr;
+    unsigned char speed             = cmargb->GetLedSpeed();
 
-    name                    = argb_header_data[cmargb->GetZoneIndex()].name;
-    vendor                  = "Cooler Master";
-    type                    = DEVICE_TYPE_LEDSTRIP;
-    description             = cmargb->GetDeviceName();
-    version                 = "2.0 for FW0023";
-    serial                  = cmargb->GetSerial();
-    location                = cmargb->GetLocation();
+    name                            = argb_header_data[cmargb->GetZoneIndex()].name;
+    vendor                          = "Cooler Master";
+    type                            = DEVICE_TYPE_LEDSTRIP;
+    description                     = cmargb->GetDeviceName();
+    version                         = "3.0 for FW0028";
+    serial                          = cmargb->GetSerial();
+    location                        = cmargb->GetLocation();
 
     if(argb_header_data[cmargb->GetZoneIndex()].digital)
     {
         mode Off;
-        Off.name                = "Turn Off";
-        Off.value               = CM_ARGB_MODE_OFF;
-        Off.color_mode          = MODE_COLORS_NONE;
+        Off.name                    = "Turn Off";
+        Off.value                   = CM_ARGB_MODE_OFF;
+        Off.color_mode              = MODE_COLORS_NONE;
         modes.push_back(Off);
 
         mode Reload;
-        Reload.name             = "Reload";
-        Reload.value            = CM_ARGB_MODE_RELOAD;
-        Reload.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Reload.colors_min       = 1;
-        Reload.colors_max       = 1;
+        Reload.name                 = "Reload";
+        Reload.value                = CM_ARGB_MODE_RELOAD;
+        Reload.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Reload.colors_min           = 1;
+        Reload.colors_max           = 1;
         Reload.colors.resize(Reload.colors_max);
-        Reload.speed_min        = CM_ARGB_SPEED_SLOWEST;
-        Reload.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Reload.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Reload.speed            = speed;
+        Reload.brightness_min       = 0;
+        Reload.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Reload.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Reload.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Reload.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Reload.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Reload.speed                = speed;
         modes.push_back(Reload);
 
         mode Recoil;
-        Recoil.name             = "Recoil";
-        Recoil.value            = CM_ARGB_MODE_RECOIL;
-        Recoil.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Recoil.colors_min       = 1;
-        Recoil.colors_max       = 1;
+        Recoil.name                 = "Recoil";
+        Recoil.value                = CM_ARGB_MODE_RECOIL;
+        Recoil.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Recoil.colors_min           = 1;
+        Recoil.colors_max           = 1;
         Recoil.colors.resize(Recoil.colors_max);
-        Recoil.speed_min        = CM_ARGB_SPEED_SLOWEST;
-        Recoil.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Recoil.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Recoil.speed            = speed;
+        Recoil.brightness_min       = 0;
+        Recoil.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Recoil.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Recoil.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Recoil.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Recoil.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Recoil.speed                = speed;
         modes.push_back(Recoil);
 
         mode Breathing;
-        Breathing.name          = "Breathing";
-        Breathing.value         = CM_ARGB_MODE_BREATHING;
-        Breathing.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Breathing.colors_min    = 1;
-        Breathing.colors_max    = 1;
+        Breathing.name              = "Breathing";
+        Breathing.value             = CM_ARGB_MODE_BREATHING;
+        Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Breathing.colors_min        = 1;
+        Breathing.colors_max        = 1;
         Breathing.colors.resize(Breathing.colors_max);
-        Breathing.speed_min     = CM_ARGB_SPEED_SLOWEST;
-        Breathing.speed_max     = CM_ARGB_SPEED_FASTEST;
-        Breathing.color_mode    = MODE_COLORS_MODE_SPECIFIC;
-        Breathing.speed         = speed;
+        Breathing.brightness_min    = 0;
+        Breathing.brightness_max    = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.brightness        = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.speed_min         = CM_ARGB_SPEED_SLOWEST;
+        Breathing.speed_max         = CM_ARGB_SPEED_FASTEST;
+        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+        Breathing.speed             = speed;
         modes.push_back(Breathing);
 
         mode Refill;
-        Refill.name             = "Refill";
-        Refill.value            = CM_ARGB_MODE_REFILL;
-        Refill.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Refill.colors_min       = 1;
-        Refill.colors_max       = 1;
+        Refill.name                 = "Refill";
+        Refill.value                = CM_ARGB_MODE_REFILL;
+        Refill.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Refill.colors_min           = 1;
+        Refill.colors_max           = 1;
         Refill.colors.resize(Refill.colors_max);
-        Refill.speed_min        = CM_ARGB_SPEED_SLOWEST;
-        Refill.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Refill.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Refill.speed            = speed;
+        Refill.brightness_min       = 0;
+        Refill.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Refill.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Refill.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Refill.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Refill.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Refill.speed                = speed;
         modes.push_back(Refill);
 
         mode Demo;
-        Demo.name               = "Demo";
-        Demo.value              = CM_ARGB_MODE_DEMO;
-        Demo.flags              = MODE_FLAG_HAS_SPEED;
-        Demo.speed_min          = CM_ARGB_SPEED_SLOWEST;
-        Demo.speed_max          = CM_ARGB_SPEED_FASTEST;
-        Demo.color_mode         = MODE_COLORS_NONE;
-        Demo.speed              = speed;
+        Demo.name                   = "Demo";
+        Demo.value                  = CM_ARGB_MODE_DEMO;
+        Demo.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        Demo.brightness_min         = 0;
+        Demo.brightness_max         = CM_ARGB_BRIGHTNESS_MAX;
+        Demo.brightness             = CM_ARGB_BRIGHTNESS_MAX;
+        Demo.speed_min              = CM_ARGB_SPEED_SLOWEST;
+        Demo.speed_max              = CM_ARGB_SPEED_FASTEST;
+        Demo.color_mode             = MODE_COLORS_NONE;
+        Demo.speed                  = speed;
         modes.push_back(Demo);
 
         mode Spectrum;
-        Spectrum.name           = "Spectrum";
-        Spectrum.value          = CM_ARGB_MODE_SPECTRUM;
-        Spectrum.flags          = MODE_FLAG_HAS_SPEED;
-        Spectrum.speed_min      = CM_ARGB_SPEED_SLOWEST;
-        Spectrum.speed_max      = CM_ARGB_SPEED_FASTEST;
-        Spectrum.color_mode     = MODE_COLORS_NONE;
-        Spectrum.speed          = speed;
+        Spectrum.name               = "Spectrum";
+        Spectrum.value              = CM_ARGB_MODE_SPECTRUM;
+        Spectrum.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        Spectrum.brightness_min     = 0;
+        Spectrum.brightness_max     = CM_ARGB_BRIGHTNESS_MAX;
+        Spectrum.brightness         = CM_ARGB_BRIGHTNESS_MAX;
+        Spectrum.speed_min          = CM_ARGB_SPEED_SLOWEST;
+        Spectrum.speed_max          = CM_ARGB_SPEED_FASTEST;
+        Spectrum.color_mode         = MODE_COLORS_NONE;
+        Spectrum.speed              = speed;
         modes.push_back(Spectrum);
 
         mode FillFlow;
-        FillFlow.name           = "Fill Flow";
-        FillFlow.value          = CM_ARGB_MODE_FILLFLOW;
-        FillFlow.flags          = MODE_FLAG_HAS_SPEED;
-        FillFlow.speed_min      = CM_ARGB_SPEED_SLOWEST;
-        FillFlow.speed_max      = CM_ARGB_SPEED_FASTEST;
-        FillFlow.color_mode     = MODE_COLORS_NONE;
-        FillFlow.speed          = speed;
+        FillFlow.name               = "Fill Flow";
+        FillFlow.value              = CM_ARGB_MODE_FILLFLOW;
+        FillFlow.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        FillFlow.brightness_min     = 0;
+        FillFlow.brightness_max     = CM_ARGB_BRIGHTNESS_MAX;
+        FillFlow.brightness         = CM_ARGB_BRIGHTNESS_MAX;
+        FillFlow.speed_min          = CM_ARGB_SPEED_SLOWEST;
+        FillFlow.speed_max          = CM_ARGB_SPEED_FASTEST;
+        FillFlow.color_mode         = MODE_COLORS_NONE;
+        FillFlow.speed              = speed;
         modes.push_back(FillFlow);
 
         mode Rainbow;
-        Rainbow.name            = "Rainbow";
-        Rainbow.value           = CM_ARGB_MODE_RAINBOW;
-        Rainbow.flags           = MODE_FLAG_HAS_SPEED;
-        Rainbow.speed_min       = CM_ARGB_SPEED_SLOWEST;
-        Rainbow.speed_max       = CM_ARGB_SPEED_FASTEST;
-        Rainbow.color_mode      = MODE_COLORS_NONE;
-        Rainbow.speed           = speed;
+        Rainbow.name                = "Rainbow";
+        Rainbow.value               = CM_ARGB_MODE_RAINBOW;
+        Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        Rainbow.brightness_min      = 0;
+        Rainbow.brightness_max      = CM_ARGB_BRIGHTNESS_MAX;
+        Rainbow.brightness          = CM_ARGB_BRIGHTNESS_MAX;
+        Rainbow.speed_min           = CM_ARGB_SPEED_SLOWEST;
+        Rainbow.speed_max           = CM_ARGB_SPEED_FASTEST;
+        Rainbow.color_mode          = MODE_COLORS_NONE;
+        Rainbow.speed               = speed;
         modes.push_back(Rainbow);
 
         mode Static;
-        Static.name             = "Static";
-        Static.value            = CM_ARGB_MODE_STATIC;
-        Static.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-        Static.colors_min       = 1;
-        Static.colors_max       = 1;
+        Static.name                 = "Static";
+        Static.value                = CM_ARGB_MODE_STATIC;
+        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Static.colors_min           = 1;
+        Static.colors_max           = 1;
         Static.colors.resize(Static.colors_max);
-        Static.speed_min        = CM_ARGB_SPEED_SLOWEST;
-        Static.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Static.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Static.speed            = speed;
+        Static.brightness_min       = 0;
+        Static.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Static.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Static.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Static.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Static.speed                = speed;
         modes.push_back(Static);
 
         mode Direct;
-        Direct.name             = "Direct";
-        Direct.value            = CM_ARGB_MODE_DIRECT;
-        Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-        Direct.color_mode       = MODE_COLORS_PER_LED;
+        Direct.name                 = (serial >= CM_ARGB_FW0028) ? "Direct" : "Custom";
+        Direct.value                = CM_ARGB_MODE_DIRECT;
+        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+        Direct.color_mode           = MODE_COLORS_PER_LED;
         modes.push_back(Direct);
 
         mode PassThru;
-        PassThru.name           = "Pass Thru";
-        PassThru.value          = CM_ARGB_MODE_PASSTHRU;
-        PassThru.flags          = 0;
-        PassThru.color_mode     = MODE_COLORS_NONE;
+        PassThru.name               = "Pass Thru";
+        PassThru.value              = CM_ARGB_MODE_PASSTHRU;
+        PassThru.flags              = 0;
+        PassThru.color_mode         = MODE_COLORS_NONE;
         modes.push_back(PassThru);
     }
     else
     {
         mode Static;
-        Static.name             = "Static";
-        Static.value            = CM_RGB_MODE_STATIC;
-        Static.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-        Static.colors_min       = 1;
-        Static.colors_max       = 1;
+        Static.name                 = "Static";
+        Static.value                = CM_RGB_MODE_STATIC;
+        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Static.colors_min           = 1;
+        Static.colors_max           = 1;
         Static.colors.resize(Static.colors_max);
-        Static.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Static.speed            = 0;
+        Static.brightness_min       = 0;
+        Static.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Static.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Static.speed                = 0;
         modes.push_back(Static);
 
         mode Breathing;
-        Breathing.name          = "Breathing";
-        Breathing.value         = CM_RGB_MODE_BREATHING;
-        Breathing.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Breathing.colors_min    = 1;
-        Breathing.colors_max    = 1;
+        Breathing.name              = "Breathing";
+        Breathing.value             = CM_RGB_MODE_BREATHING;
+        Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Breathing.colors_min        = 1;
+        Breathing.colors_max        = 1;
         Breathing.colors.resize(Breathing.colors_max);
-        Breathing.speed_min     = CM_ARGB_SPEED_SLOWEST;
-        Breathing.speed_max     = CM_ARGB_SPEED_FASTEST;
-        Breathing.color_mode    = MODE_COLORS_MODE_SPECIFIC;
-        Breathing.speed         = CM_ARGB_SPEED_NORMAL;
+        Breathing.brightness_min    = 0;
+        Breathing.brightness_max    = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.brightness        = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.speed_min         = CM_ARGB_SPEED_SLOWEST;
+        Breathing.speed_max         = CM_ARGB_SPEED_FASTEST;
+        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+        Breathing.speed             = CM_ARGB_SPEED_NORMAL;
         modes.push_back(Breathing);
 
         mode Flash;
-        Flash.name              = "Flash";
-        Flash.value             = CM_RGB_MODE_FLASH;
-        Flash.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Flash.colors_min        = 1;
-        Flash.colors_max        = 1;
+        Flash.name                  = "Flash";
+        Flash.value                 = CM_RGB_MODE_FLASH;
+        Flash.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Flash.colors_min            = 1;
+        Flash.colors_max            = 1;
         Flash.colors.resize(Flash.colors_max);
-        Flash.speed_min         = CM_ARGB_SPEED_SLOWEST;
-        Flash.speed_max         = CM_ARGB_SPEED_FASTEST;
-        Flash.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Flash.speed             = CM_ARGB_SPEED_NORMAL;
+        Flash.brightness_min        = 0;
+        Flash.brightness_max        = CM_ARGB_BRIGHTNESS_MAX;
+        Flash.brightness            = CM_ARGB_BRIGHTNESS_MAX;
+        Flash.speed_min             = CM_ARGB_SPEED_SLOWEST;
+        Flash.speed_max             = CM_ARGB_SPEED_FASTEST;
+        Flash.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+        Flash.speed                 = CM_ARGB_SPEED_NORMAL;
         modes.push_back(Flash);
 
         mode Mirage;
-        Mirage.name             = "Mirage";
-        Mirage.value            = CM_RGB_MODE_MIRAGE;
-        Mirage.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Mirage.colors_min       = 1;
-        Mirage.colors_max       = 1;
+        Mirage.name                 = "Mirage";
+        Mirage.value                = CM_RGB_MODE_MIRAGE;
+        Mirage.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Mirage.colors_min           = 1;
+        Mirage.colors_max           = 1;
         Mirage.colors.resize(Mirage.colors_max);
-        Mirage.speed_min        = CM_ARGB_SPEED_SLOWEST;
-        Mirage.speed_max        = CM_ARGB_SPEED_FASTEST;
-        Mirage.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Mirage.speed            = CM_ARGB_SPEED_NORMAL;
+        Mirage.brightness_min       = 0;
+        Mirage.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Mirage.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Mirage.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Mirage.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Mirage.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Mirage.speed                = CM_ARGB_SPEED_NORMAL;
         modes.push_back(Mirage);
 
         mode PassThru;
-        PassThru.name           = "Pass Thru";
-        PassThru.value          = CM_RGB_MODE_PASSTHRU;
-        PassThru.color_mode     = MODE_COLORS_NONE;
+        PassThru.name               = "Pass Thru";
+        PassThru.value              = CM_RGB_MODE_PASSTHRU;
+        PassThru.color_mode         = MODE_COLORS_NONE;
         modes.push_back(PassThru);
 
         mode Off;
-        Off.name                = "Turn Off";
-        Off.value               = CM_RGB_MODE_OFF;
-        Off.color_mode          = MODE_COLORS_NONE;
+        Off.name                    = "Turn Off";
+        Off.value                   = CM_RGB_MODE_OFF;
+        Off.color_mode              = MODE_COLORS_NONE;
         modes.push_back(Off);
     }
 
@@ -229,8 +268,8 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
     if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
     {
         modes[active_mode].colors[0] = ToRGBColor(cmargb->GetLedRed(), cmargb->GetLedGreen(), cmargb->GetLedBlue());
+        modes[active_mode].color_mode = (cmargb->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
     }
-    modes[active_mode].color_mode = (cmargb->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
     if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
     {
         modes[active_mode].speed = cmargb->GetLedSpeed();
@@ -336,9 +375,9 @@ void RGBController_CMARGBController::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_CMARGBController::UpdateZoneLEDs(int /*zone*/)
+void RGBController_CMARGBController::UpdateZoneLEDs(int zone)
 {
-    //cmargb->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
+    cmargb->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
 }
 
 void RGBController_CMARGBController::UpdateSingleLED(int led)
@@ -363,7 +402,7 @@ void RGBController_CMARGBController::DeviceUpdateMode()
     bool random_colours     = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
     RGBColor colour         = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
 
-    cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed, colour, random_colours );
+    cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, colour, random_colours );
 }
 
 int RGBController_CMARGBController::GetLED_Zone(int led_idx)

Controllers/CoolerMasterController/RGBController_CMMM711Controller.cpp

@@ -7,6 +7,8 @@
 |                                                                     |
 \*-------------------------------------------------------------------*/
 
+#define applyBrightness(c, bright) ((RGBColor) ((RGBGetBValue(c) * bright / CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT) << 16 | (RGBGetGValue(c) * bright / CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT) << 8 | (RGBGetRValue(c) * bright / CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT)))
+
 #include "RGBController_CMMM711Controller.h"
 
 RGBController_CMMM711Controller::RGBController_CMMM711Controller(CMMM711Controller *cmmm711_ptr)
@@ -25,7 +27,7 @@ RGBController_CMMM711Controller::RGBController_CMMM711Controller(CMMM711Controll
     mode Custom;
     Custom.name                     = "Direct";
     Custom.value                    = CM_MM711_MODE_CUSTOM;
-    Custom.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Custom.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
     Custom.brightness_min           = CM_MM_ARGB_BRIGHTNESS_MIN;
     Custom.brightness_max           = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
     Custom.brightness               = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
@@ -35,7 +37,7 @@ RGBController_CMMM711Controller::RGBController_CMMM711Controller(CMMM711Controll
     mode Static;
     Static.name                     = "Static";
     Static.value                    = CM_MM711_MODE_STATIC;
-    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
     Static.brightness_min           = CM_MM_ARGB_BRIGHTNESS_MIN;
     Static.brightness_max           = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
     Static.brightness               = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
@@ -51,7 +53,7 @@ RGBController_CMMM711Controller::RGBController_CMMM711Controller(CMMM711Controll
     mode Breathing;
     Breathing.name                  = "Breathing";
     Breathing.value                 = CM_MM711_MODE_BREATHING;
-    Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
     Breathing.brightness_min        = CM_MM_ARGB_BRIGHTNESS_MIN;
     Breathing.brightness_max        = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
     Breathing.brightness            = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
@@ -67,7 +69,7 @@ RGBController_CMMM711Controller::RGBController_CMMM711Controller(CMMM711Controll
     mode Spectrum_Cycle;
     Spectrum_Cycle.name             = "Spectrum Cycle";
     Spectrum_Cycle.value            = CM_MM711_MODE_SPECTRUM_CYCLE;
-    Spectrum_Cycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Spectrum_Cycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
     Spectrum_Cycle.brightness_min   = CM_MM_ARGB_BRIGHTNESS_MIN;
     Spectrum_Cycle.brightness_max   = CM_MM_ARGB_BRIGHTNESS_MAX_SPECTRUM;
     Spectrum_Cycle.brightness       = CM_MM_ARGB_BRIGHTNESS_MAX_SPECTRUM;
@@ -80,12 +82,14 @@ RGBController_CMMM711Controller::RGBController_CMMM711Controller(CMMM711Controll
     mode Indicator;
     Indicator.name                  = "Indicator";
     Indicator.value                 = CM_MM711_MODE_INDICATOR;
+    Indicator.flags                 = MODE_FLAG_MANUAL_SAVE;
     Indicator.color_mode            = MODE_COLORS_NONE;
     modes.push_back(Indicator);
 
     mode Off;
     Off.name                        = "Turn Off";
     Off.value                       = CM_MM711_MODE_OFF;
+    Off.flags                       = MODE_FLAG_MANUAL_SAVE;
     Off.color_mode                  = MODE_COLORS_NONE;
     modes.push_back(Off);
 
@@ -117,7 +121,7 @@ RGBController_CMMM711Controller::~RGBController_CMMM711Controller()
 void RGBController_CMMM711Controller::Init_Controller()
 {
     zone mouse_zone;
-    mouse_zone.name         = "Master Mouse 711";
+    mouse_zone.name         = name;
     mouse_zone.type         = ZONE_TYPE_LINEAR;
     mouse_zone.leds_min     = 2;
     mouse_zone.leds_max     = 2;
@@ -150,7 +154,10 @@ void RGBController_CMMM711Controller::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_CMMM711Controller::DeviceUpdateLEDs()
 {
-    cmmm711->SetLedsDirect( colors[0], colors[1] );
+    RGBColor wheel  = applyBrightness(colors[0], modes[active_mode].brightness);
+    RGBColor logo   = applyBrightness(colors[1], modes[active_mode].brightness);
+
+    cmmm711->SetLedsDirect( wheel, logo);
 }
 
 void RGBController_CMMM711Controller::UpdateZoneLEDs(int /*zone*/)
@@ -189,3 +196,9 @@ void RGBController_CMMM711Controller::DeviceUpdateMode()
         cmmm711->SendUpdate(modes[active_mode].value, modes[active_mode].speed, colour, modes[active_mode].brightness);
     }
 }
+
+void RGBController_CMMM711Controller::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    cmmm711->SendSavePacket();
+}

Controllers/CoolerMasterController/RGBController_CMMM711Controller.h

@@ -31,6 +31,7 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 private:
     void        Init_Controller();
     int         GetDeviceMode();

Controllers/CrucialController/CrucialController.cpp

@@ -16,8 +16,10 @@ 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;
+    for(int i = 0; i < 16; i++)
+    {
+        device_version[i] = CrucialRegisterRead(CRUCIAL_REG_DEVICE_VERSION + i);
+    }
 }
 
 CrucialController::~CrucialController()
@@ -25,9 +27,9 @@ CrucialController::~CrucialController()
 
 }
 
-std::string CrucialController::GetDeviceName()
+std::string CrucialController::GetDeviceVersion()
 {
-    return(device_name);
+    return(device_version);
 }
 
 std::string CrucialController::GetDeviceLocation()
@@ -40,18 +42,9 @@ std::string CrucialController::GetDeviceLocation()
     return("I2C: " + return_string);
 }
 
-unsigned int CrucialController::GetLEDCount()
-{
-    return(led_count);
-}
-
 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)
@@ -87,37 +80,31 @@ void CrucialController::SendEffectMode(unsigned char mode, unsigned char speed)
 
 void CrucialController::SendDirectColors(RGBColor* color_buf)
 {
-    SetMode(CRUCIAL_MODE_STATIC);
+    unsigned char color_blk[8];
+
+    for(unsigned int led = 0; led < 8; led++)
+    {
+        color_blk[led] = RGBGetRValue(color_buf[led]);
+    }
 
     //Red Channels
-    CrucialRegisterWrite(0x8300, RGBGetRValue(color_buf[0]));
-    CrucialRegisterWrite(0x8301, RGBGetRValue(color_buf[1]));
-    CrucialRegisterWrite(0x8302, RGBGetRValue(color_buf[2]));
-    CrucialRegisterWrite(0x8303, RGBGetRValue(color_buf[3]));
-    CrucialRegisterWrite(0x8304, RGBGetRValue(color_buf[4]));
-    CrucialRegisterWrite(0x8305, RGBGetRValue(color_buf[5]));
-    CrucialRegisterWrite(0x8306, RGBGetRValue(color_buf[6]));
-    CrucialRegisterWrite(0x8307, RGBGetRValue(color_buf[7]));
+    CrucialRegisterWriteBlock(0x8300, color_blk, 8);
 
+    for(unsigned int led = 0; led < 8; led++)
+    {
+        color_blk[led] = RGBGetGValue(color_buf[led]);
+    }
+    
     //Green Channels
-    CrucialRegisterWrite(0x8340, RGBGetGValue(color_buf[0]));
-    CrucialRegisterWrite(0x8341, RGBGetGValue(color_buf[1]));
-    CrucialRegisterWrite(0x8342, RGBGetGValue(color_buf[2]));
-    CrucialRegisterWrite(0x8343, RGBGetGValue(color_buf[3]));
-    CrucialRegisterWrite(0x8344, RGBGetGValue(color_buf[4]));
-    CrucialRegisterWrite(0x8345, RGBGetGValue(color_buf[5]));
-    CrucialRegisterWrite(0x8346, RGBGetGValue(color_buf[6]));
-    CrucialRegisterWrite(0x8347, RGBGetGValue(color_buf[7]));
+    CrucialRegisterWriteBlock(0x8340, color_blk, 8);
 
+    for(unsigned int led = 0; led < 8; led++)
+    {
+        color_blk[led] = RGBGetBValue(color_buf[led]);
+    }
+    
     //Blue Channels
-    CrucialRegisterWrite(0x8380, RGBGetBValue(color_buf[0]));
-    CrucialRegisterWrite(0x8381, RGBGetBValue(color_buf[1]));
-    CrucialRegisterWrite(0x8382, RGBGetBValue(color_buf[2]));
-    CrucialRegisterWrite(0x8383, RGBGetBValue(color_buf[3]));
-    CrucialRegisterWrite(0x8384, RGBGetBValue(color_buf[4]));
-    CrucialRegisterWrite(0x8385, RGBGetBValue(color_buf[5]));
-    CrucialRegisterWrite(0x8386, RGBGetBValue(color_buf[6]));
-    CrucialRegisterWrite(0x8387, RGBGetBValue(color_buf[7]));
+    CrucialRegisterWriteBlock(0x8380, color_blk, 8);
 }
 
 unsigned char CrucialController::CrucialRegisterRead(crucial_register reg)
@@ -140,6 +127,15 @@ void CrucialController::CrucialRegisterWrite(crucial_register reg, unsigned char
 
 }
 
+void CrucialController::CrucialRegisterWriteBlock(crucial_register reg, unsigned char * data, unsigned char sz)
+{
+    //Write Crucial register
+    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
+
+    //Write Crucial block data
+    bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
+}
+
 void CrucialController::SendEffectColor
     (
     unsigned int    led_idx,
@@ -156,4 +152,4 @@ void CrucialController::SendEffectColor
     CrucialRegisterWrite(0x82EE, green);
     CrucialRegisterWrite(0x82EF, blue);
     CrucialRegisterWrite(0x82F0, 0x01);
-}
+}

Controllers/CrucialController/CrucialController.h

@@ -16,6 +16,13 @@
 typedef unsigned char	crucial_dev_id;
 typedef unsigned short	crucial_register;
 
+enum
+{
+    CRUCIAL_REG_DEVICE_VERSION      = 0x1000,   /* Version (Date) String 16 bytes   */
+    CRUCIAL_REG_MICRON_CHECK_1      = 0x1025,   /* "Micron" string location 1       */
+    CRUCIAL_REG_MICRON_CHECK_2      = 0x1030    /* "Micron" string location 2       */
+};
+
 enum
 {
     CRUCIAL_MODE_UNKNOWN            = 0x00,     /* We don't know what the mode is   */
@@ -39,22 +46,18 @@ public:
     CrucialController(i2c_smbus_interface* bus, crucial_dev_id dev);
     ~CrucialController();
 
-    std::string   GetDeviceName();
+    std::string   GetDeviceVersion();
     std::string   GetDeviceLocation();
-    unsigned int  GetLEDCount();
     void          SetAllColorsDirect(RGBColor* colors);
     void          SetAllColorsEffect(RGBColor* colors);
     void          SetMode(unsigned char mode);
 
     unsigned char CrucialRegisterRead(crucial_register reg);
     void          CrucialRegisterWrite(crucial_register reg, unsigned char val);
+    void          CrucialRegisterWriteBlock(crucial_register reg, unsigned char * data, unsigned char sz);
 
 private:
-    char                    device_name[16];
-    unsigned char           config_table[64];
-    unsigned int            led_count;
-    unsigned char           channel_cfg;
-    unsigned char           last_mode;
+    char                    device_version[16];
     i2c_smbus_interface *   bus;
     crucial_dev_id          dev;
 

Controllers/CrucialController/CrucialControllerDetect.cpp

@@ -1,5 +1,6 @@
 #include "Detector.h"
 #include "CrucialController.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_Crucial.h"
 #include "i2c_smbus.h"
@@ -13,7 +14,7 @@ using namespace std::chrono_literals;
 /*----------------------------------------------------------------------*\
 | This list contains the available SMBus addresses for Crucial RAM       |
 \*----------------------------------------------------------------------*/
-#define CRUCIAL_ADDRESS_COUNT  4
+#define CRUCIAL_ADDRESS_COUNT  8
 
 static const unsigned char crucial_addresses[] =
 {
@@ -23,16 +24,48 @@ static const unsigned char crucial_addresses[] =
 | the same, Aura RAM will be detected as Crucial.       |
 | We need to improve the Crucial detection scheme.      |
 \*-----------------------------------------------------*/
-//  0x39,
-//  0x3A,
-//  0x3B,
-//  0x3C,
+    0x39,
+    0x3A,
+    0x3B,
+    0x3C,
     0x20,
     0x21,
     0x22,
     0x23
 };
 
+#define CRUCIAL_CONTROLLER_NAME "Crucial DRAM"
+std::string concatHexArray(const unsigned char array[], int count, const char split_char[])
+{
+    std::string addresses = "";
+    for(int i = 0; i < count; i++)
+    {
+        char buffer[6];
+        snprintf(buffer, 6, "0x%02X%s", array[i], (i < count-1)? split_char: "");
+        addresses += buffer;
+    }
+    return addresses;
+}
+#define TESTING_ADDRESSES concatHexArray(crucial_addresses, CRUCIAL_ADDRESS_COUNT, "|").c_str()
+
+/******************************************************************************************\
+*                                                                                          *
+*   CrucialRegisterRead                                                                    *
+*                                                                                          *
+*       A standalone version of the AuraSMBusController::AuraRegisterRead function for     *
+*       access to Aura devices without instancing the AuraSMBusController class or reading *
+*       the config table from the device.                                                  *
+*                                                                                          *
+\******************************************************************************************/
+
+unsigned char CrucialRegisterRead(i2c_smbus_interface* bus, crucial_dev_id dev, crucial_register reg)
+{
+    //Write Aura register
+    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
+
+    //Read Aura value
+    return(bus->i2c_smbus_read_byte_data(dev, 0x81));
+}
 
 /******************************************************************************************\
 *                                                                                          *
@@ -54,15 +87,52 @@ bool TestForCrucialController(i2c_smbus_interface* bus, unsigned char address)
     {
         pass = true;
 
+        LOG_DEBUG("[%s] Detected an I2C device at address %02X", CRUCIAL_CONTROLLER_NAME, address);
+
         for (int i = 0xA0; i < 0xB0; i++)
         {
             res = bus->i2c_smbus_read_byte_data(address, i);
 
             if (res != (i - 0xA0))
             {
+                LOG_VERBOSE("[%s] Detection failed testing register %02X.  Expected %02X, got %02X.", CRUCIAL_CONTROLLER_NAME, i, (i - 0xA0), res);
+
                 pass = false;
             }
         }
+
+        if(pass)
+        {
+            LOG_DEBUG("[%s] Checking for Micron string", CRUCIAL_CONTROLLER_NAME);
+
+            char buf[16];
+            for(int i = 0; i < 16; i++)
+            {
+                buf[i] = CrucialRegisterRead(bus, address, CRUCIAL_REG_MICRON_CHECK_1 + i);
+            }
+
+            if(strcmp(buf, "Micron") == 0)
+            {
+                LOG_DEBUG("[%s] Device %02X is a Micron device, continuing", CRUCIAL_CONTROLLER_NAME, address);
+            }
+            else
+            {
+                for(int i = 0; i < 16; i++)
+                {
+                    buf[i] = CrucialRegisterRead(bus, address, CRUCIAL_REG_MICRON_CHECK_2 + i);
+                }
+                
+                if(strcmp(buf, "Micron") == 0)
+                {
+                    LOG_DEBUG("[%s] Device %02X is a Micron device, continuing", CRUCIAL_CONTROLLER_NAME, address);
+                }
+                else
+                {
+                    LOG_DEBUG("[%s] Device %02X is not a Micron device, skipping", CRUCIAL_CONTROLLER_NAME, address);
+                    pass = false;
+                }
+            }
+        }
     }
 
     return(pass);
@@ -100,7 +170,7 @@ void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses)
 
         IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            // Remap Crucial RAM modules on 0x27
+
             for (unsigned int slot = 0; slot < 4; slot++)
             {
                 int res = busses[bus]->i2c_smbus_write_quick(0x27, I2C_SMBUS_WRITE);
@@ -110,6 +180,7 @@ void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses)
                     break;
                 }
 
+                LOG_DEBUG("[%s] Remapping RAM module on 0x27", CRUCIAL_CONTROLLER_NAME);
                 do
                 {
                     address_list_idx++;
@@ -120,12 +191,14 @@ void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses)
                     }
                     else
                     {
+                        LOG_DEBUG("[%s] Testing address %02X to see if there is a device there", CRUCIAL_CONTROLLER_NAME, crucial_addresses[address_list_idx]);
                         break;
                     }
                 } while (res >= 0);
 
                 if(address_list_idx < CRUCIAL_ADDRESS_COUNT)
                 {
+                    LOG_DEBUG("[%s] Remapping slot %d to address %02X", CRUCIAL_CONTROLLER_NAME, slot, crucial_addresses[address_list_idx]);
                     CrucialRegisterWrite(busses[bus], 0x27, 0x82EE, slot);
                     CrucialRegisterWrite(busses[bus], 0x27, 0x82EF, (crucial_addresses[address_list_idx] << 1));
                     CrucialRegisterWrite(busses[bus], 0x27, 0x82F0, 0xF0);
@@ -134,6 +207,8 @@ void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses)
                 std::this_thread::sleep_for(1ms);
             }
 
+            LOG_DEBUG("[%s] In bus: %02X:%02X looking for devices at [%s]", CRUCIAL_CONTROLLER_NAME, busses[bus]->pci_vendor, busses[bus]->pci_device, TESTING_ADDRESSES);
+
             // Add Crucial controllers
             for (unsigned int address_list_idx = 0; address_list_idx < CRUCIAL_ADDRESS_COUNT; address_list_idx++)
             {
@@ -143,6 +218,8 @@ void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses)
                     new_controller = new RGBController_Crucial(new_crucial);
                     ResourceManager::get()->RegisterRGBController(new_controller);
                 }
+
+                std::this_thread::sleep_for(1ms);
             }
         }
     }

Controllers/CrucialController/RGBController_Crucial.cpp

@@ -17,6 +17,7 @@ RGBController_Crucial::RGBController_Crucial(CrucialController * crucial_ptr)
     vendor      = "Crucial";
     type        = DEVICE_TYPE_DRAM;
     description = "Crucial DRAM Device";
+    version     = crucial->GetDeviceVersion();
     location    = crucial->GetDeviceLocation();
 
     mode Direct;
@@ -29,88 +30,85 @@ RGBController_Crucial::RGBController_Crucial(CrucialController * crucial_ptr)
     mode Shift;
     Shift.name       = "Shift";
     Shift.value      = CRUCIAL_MODE_SHIFT;
-    Shift.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Shift.colors_min = 1;
-    Shift.colors_max = 1;
-    Shift.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Shift.colors.resize(1);
+    Shift.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Shift.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Shift);
     
     mode GradientShift;
     GradientShift.name       = "Gradient Shift";
     GradientShift.value      = CRUCIAL_MODE_GRADIENT_SHIFT;
-    GradientShift.flags      = 0;
-    GradientShift.color_mode = MODE_COLORS_NONE;
+    GradientShift.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    GradientShift.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(GradientShift);
 
     mode Fill;
     Fill.name       = "Fill";
     Fill.value      = CRUCIAL_MODE_FILL;
-    Fill.flags      = 0;
-    Fill.color_mode = MODE_COLORS_NONE;
+    Fill.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Fill.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Fill);
 
     mode Stack;
     Stack.name       = "Stack";
     Stack.value      = CRUCIAL_MODE_STACK;
-    Stack.flags      = 0;
-    Stack.color_mode = MODE_COLORS_NONE;
+    Stack.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Stack.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Stack);
 
     mode DoubleStack;
     DoubleStack.name       = "Double Stack";
     DoubleStack.value      = CRUCIAL_MODE_DOUBLE_STACK;
-    DoubleStack.flags      = 0;
-    DoubleStack.color_mode = MODE_COLORS_NONE;
+    DoubleStack.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    DoubleStack.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(DoubleStack);
 
     mode Breathing;
     Breathing.name       = "Breathing";
     Breathing.value      = CRUCIAL_MODE_BREATHING;
-    Breathing.flags      = 0;
-    Breathing.color_mode = MODE_COLORS_NONE;
+    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Breathing);
 
     mode MotionPoint;
     MotionPoint.name       = "Motion Point";
     MotionPoint.value      = CRUCIAL_MODE_MOTION_POINT;
-    MotionPoint.flags      = 0;
-    MotionPoint.color_mode = MODE_COLORS_NONE;
+    MotionPoint.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    MotionPoint.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(MotionPoint);
 
     mode InsideOut;
     InsideOut.name       = "Inside Out";
     InsideOut.value      = CRUCIAL_MODE_INSIDE_OUT;
-    InsideOut.flags      = 0;
-    InsideOut.color_mode = MODE_COLORS_NONE;
+    InsideOut.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    InsideOut.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(InsideOut);
 
     mode ColorStep;
     ColorStep.name       = "Color Step";
     ColorStep.value      = CRUCIAL_MODE_COLOR_STEP;
-    ColorStep.flags      = 0;
-    ColorStep.color_mode = MODE_COLORS_NONE;
+    ColorStep.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    ColorStep.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(ColorStep);
 
     mode WaterWave;
     WaterWave.name       = "Water Wave (Color Blending)";
     WaterWave.value      = CRUCIAL_MODE_WATER_WAVE;
-    WaterWave.flags      = 0;
-    WaterWave.color_mode = MODE_COLORS_NONE;
+    WaterWave.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    WaterWave.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(WaterWave);
 
     mode Flashing;
     Flashing.name       = "Flashing";
     Flashing.value      = CRUCIAL_MODE_FLASHING;
-    Flashing.flags      = 0;
-    Flashing.color_mode = MODE_COLORS_NONE;
+    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Flashing.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Flashing);
 
     mode Static;
     Static.name       = "Static";
     Static.value      = CRUCIAL_MODE_STATIC;
-    Static.flags      = 0;
-    Static.color_mode = MODE_COLORS_NONE;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     SetupZones();
@@ -185,5 +183,16 @@ void RGBController_Crucial::SetCustomMode()
 
 void RGBController_Crucial::DeviceUpdateMode()
 {
+    if(modes[active_mode].value == 0xFFFF)
+    {
+        crucial->SetMode(CRUCIAL_MODE_STATIC);
+        return;
+    }
+
+    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
+    {
+        crucial->SetAllColorsEffect(&colors[0]);
+    }
+
     crucial->SetMode(modes[active_mode].value);
 }

Controllers/DuckyKeyboardController/DuckyKeyboardController.cpp

@@ -10,10 +10,11 @@
 #include <cstring>
 #include "DuckyKeyboardController.h"
 
-DuckyKeyboardController::DuckyKeyboardController(hid_device* dev_handle, const char* path)
+DuckyKeyboardController::DuckyKeyboardController(hid_device* dev_handle, const char* path, const unsigned short pid)
 {
     dev         = dev_handle;
     location    = path;
+    usb_pid     = pid;
 
     SendInitialize();
 }
@@ -44,6 +45,11 @@ std::string DuckyKeyboardController::GetSerialString()
     return(return_string);
 }
 
+unsigned short DuckyKeyboardController::GetUSBPID()
+{
+    return(usb_pid);
+}
+
 void DuckyKeyboardController::SendColors
     (
     unsigned char*  color_data,

Controllers/DuckyKeyboardController/DuckyKeyboardController.h

@@ -14,15 +14,27 @@
 
 #pragma once
 
+/*-----------------------------------------------------*\
+| Ducky vendor ID                                       |
+\*-----------------------------------------------------*/
+#define DUCKY_VID                       0x04D9
+
+/*-----------------------------------------------------*\
+| Keyboard product IDs                                  |
+\*-----------------------------------------------------*/
+#define DUCKY_SHINE_7_ONE_2_RGB_PID     0x0348
+#define DUCKY_ONE_2_RGB_TKL_PID         0x0356
+
 class DuckyKeyboardController
 {
 public:
-    DuckyKeyboardController(hid_device* dev_handle, const char* path);
+    DuckyKeyboardController(hid_device* dev_handle, const char* path, const unsigned short pid);
     ~DuckyKeyboardController();
 
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
+    std::string     GetDeviceLocation();
+    std::string     GetSerialString();
+    unsigned short  GetUSBPID();
+    
     void SendColors
             (
             unsigned char*  color_data,
@@ -32,6 +44,7 @@ public:
 private:
     hid_device*             dev;
     std::string             location;
+    unsigned short          usb_pid;
 
     void SendInitialize();
     void SendInitializeColorPacket();

Controllers/DuckyKeyboardController/DuckyKeyboardControllerDetect.cpp

@@ -4,17 +4,6 @@
 #include "RGBController_DuckyKeyboard.h"
 #include <hidapi/hidapi.h>
 
-/*-----------------------------------------------------*\
-| Ducky vendor ID                                       |
-\*-----------------------------------------------------*/
-#define DUCKY_VID                       0x04D9
-
-/*-----------------------------------------------------*\
-| Keyboard product IDs                                  |
-\*-----------------------------------------------------*/
-#define DUCKY_SHINE_7_ONE_2_RGB_PID     0x0348
-#define DUCKY_ONE_2_RGB_TKL_PID         0x0356
-
 /******************************************************************************************\
 *                                                                                          *
 *   DetectDuckyKeyboardControllers                                                         *
@@ -28,7 +17,7 @@ void DetectDuckyKeyboardControllers(hid_device_info* info, const std::string& na
     hid_device* dev = hid_open_path(info->path);
     if( dev )
     {
-        DuckyKeyboardController* controller = new DuckyKeyboardController(dev, info->path);
+        DuckyKeyboardController* controller = new DuckyKeyboardController(dev, info->path, info->product_id);
         RGBController_DuckyKeyboard* rgb_controller = new RGBController_DuckyKeyboard(controller);
         rgb_controller->name = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);

Controllers/DuckyKeyboardController/RGBController_DuckyKeyboard.cpp

@@ -20,6 +20,15 @@ static unsigned int matrix_map[6][23] =
       {   4,  10,  16,  22,  28,  34,  NA,  40,  NA,  46,  52,  58,  64,  70,  82,  NA,  NA, 100,  NA, 112, 118, 124, 131 },
       {   5,  11,  17,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  65,  77,  83,  89,  95, 101, 107, 113,  NA, 125,  NA } };
 
+static unsigned int matrix_map_tkl[6][19] =
+    { {   0,  NA,  12,  18,  24,  30,  NA,  42,  48,  54,  60,  NA,  66,  72,  78,  84,  90,  96, 102 },
+      {   1,   7,  13,  19,  25,  31,  37,  43,  49,  55,  61,  NA,  67,  73,  85,  NA,  91,  97, 103 },
+      {   2,  NA,   8,  14,  20,  26,  NA,  32,  38,  44,  50,  56,  62,  68,  74,  86,  92,  98, 104 },
+      {   3,  NA,   9,  15,  21,  27,  NA,  33,  39,  45,  51,  57,  63,  69,  75,  87,  NA,  NA,  NA },
+      {   4,  10,  16,  22,  28,  34,  NA,  40,  NA,  46,  52,  58,  64,  70,  82,  NA,  NA, 100,  NA },
+      {   5,  11,  17,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  65,  77,  83,  89,  95, 101, 107 } };
+
+
 static const char* zone_names[] =
 {
     "Keyboard"
@@ -35,6 +44,11 @@ static const unsigned int zone_sizes[] =
     132
 };
 
+static const unsigned int zone_sizes_tkl[] =
+{
+    108
+};
+
 static const char *led_names[] =
 {
     "Key: Escape",
@@ -216,19 +230,38 @@ void RGBController_DuckyKeyboard::SetupZones()
     unsigned int total_led_count = 0;
     for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
     {
+        unsigned int    zone_size       = 0;
+        unsigned int    matrix_width    = 0;
+        unsigned int*   matrix_map_ptr  = NULL;
+
+        switch(ducky->GetUSBPID())
+        {
+            case DUCKY_SHINE_7_ONE_2_RGB_PID:
+                zone_size               = zone_sizes[zone_idx];
+                matrix_width            = 23;
+                matrix_map_ptr          = (unsigned int *)&matrix_map;
+                break;
+
+            case DUCKY_ONE_2_RGB_TKL_PID:
+                zone_size               = zone_sizes_tkl[zone_idx];
+                matrix_width            = 19;
+                matrix_map_ptr          = (unsigned int *)&matrix_map_tkl;
+                break;
+        }
+
         zone new_zone;
-        new_zone.name               = zone_names[zone_idx];
-        new_zone.type               = zone_types[zone_idx];
-        new_zone.leds_min           = zone_sizes[zone_idx];
-        new_zone.leds_max           = zone_sizes[zone_idx];
-        new_zone.leds_count         = zone_sizes[zone_idx];
-        new_zone.matrix_map         = new matrix_map_type;
-        new_zone.matrix_map->height = 6;
-        new_zone.matrix_map->width  = 23;
-        new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        new_zone.name                   = zone_names[zone_idx];
+        new_zone.type                   = zone_types[zone_idx];
+        new_zone.leds_min               = zone_size;
+        new_zone.leds_max               = zone_size;
+        new_zone.leds_count             = zone_size;
+        new_zone.matrix_map             = new matrix_map_type;
+        new_zone.matrix_map->height     = 6;
+        new_zone.matrix_map->width      = matrix_width;
+        new_zone.matrix_map->map        = matrix_map_ptr;
         zones.push_back(new_zone);
 
-        total_led_count += zone_sizes[zone_idx];
+        total_led_count += zone_size;
     }
 
     for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)

Controllers/ENESMBusController/ENESMBusController.cpp

@@ -0,0 +1,359 @@
+/*-----------------------------------------*\
+|  ENESMBusController.cpp                   |
+|                                           |
+|  Driver for ENE SMBus RGB lighting        |
+|  controller                               |
+|                                           |
+|  Formerly known as ASUS Aura SMBus. ASUS  |
+|  AURA chips are rebranded ENE controllers |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 8/19/2018   |
+\*-----------------------------------------*/
+
+#include "ENESMBusController.h"
+#include "LogManager.h"
+#include <cstring>
+
+static const char* ene_channels[] =                 /* ENE channel strings                  */
+{
+    "Audio",
+    "Backplate",
+    "Back I/O",
+    "Center",
+    "Center",
+    "DRAM",
+    "PCIe",
+    "RGB Header",
+    "RGB Header 2",
+    "RGB Header",
+    "Unknown",
+};
+
+ENESMBusController::ENESMBusController(i2c_smbus_interface* bus, ene_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+
+    UpdateDeviceName();
+
+    // Read the device configuration table
+    for (int i = 0; i < 64; i++)
+    {
+        config_table[i] = ENERegisterRead(ENE_REG_CONFIG_TABLE + i);
+    }
+
+    /*-----------------------------------------------------------------*\
+    | If this is running with TRACE or higher loglevel then             |
+    |   dump the entire Feature list to log                             |
+    \*-----------------------------------------------------------------*/
+    if(LogManager::get()->getLoglevel() >= LL_TRACE)
+    {
+        LOG_TRACE("[ENE SMBus] ENE config table for 0x%02X:", dev);
+        LOG_TRACE("    %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X", config_table[0],  config_table[1],  config_table[2],  config_table[3],
+                                                                                                         config_table[4],  config_table[5],  config_table[6],  config_table[7],
+                                                                                                         config_table[8],  config_table[9],  config_table[10], config_table[11],
+                                                                                                         config_table[12], config_table[13], config_table[14], config_table[15]);
+
+        LOG_TRACE("    %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X", config_table[16], config_table[17], config_table[18], config_table[19],
+                                                                                                         config_table[20], config_table[21], config_table[22], config_table[23],
+                                                                                                         config_table[24], config_table[25], config_table[26], config_table[27],
+                                                                                                         config_table[28], config_table[29], config_table[30], config_table[31]);
+
+        LOG_TRACE("    %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X", config_table[32], config_table[33], config_table[34], config_table[35],
+                                                                                                         config_table[36], config_table[37], config_table[38], config_table[39],
+                                                                                                         config_table[40], config_table[41], config_table[42], config_table[43],
+                                                                                                         config_table[44], config_table[45], config_table[46], config_table[47]);
+
+        LOG_TRACE("    %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X", config_table[48], config_table[49], config_table[50], config_table[51],
+                                                                                                         config_table[52], config_table[53], config_table[54], config_table[55],
+                                                                                                         config_table[56], config_table[57], config_table[58], config_table[59],
+                                                                                                         config_table[60], config_table[61], config_table[62], config_table[63]);
+    }
+
+    // Read LED count from configuration table
+    led_count = config_table[ENE_CONFIG_LED_COUNT];
+
+    // LED-0116 - First generation motherboard controller
+    if (strcmp(device_name, "LED-0116") == 0)
+    {
+        direct_reg  = ENE_REG_COLORS_DIRECT;
+        effect_reg  = ENE_REG_COLORS_EFFECT;
+        channel_cfg = ENE_CONFIG_CHANNEL_V1;
+    }
+    // DIMM_LED-0102 - First generation DRAM controller (Trident Z RGB)
+    else if (strcmp(device_name, "DIMM_LED-0102") == 0)
+    {
+        direct_reg  = ENE_REG_COLORS_DIRECT;
+        effect_reg  = ENE_REG_COLORS_EFFECT;
+        channel_cfg = ENE_CONFIG_CHANNEL_V1;
+    }
+    // AUDA0-E6K5-0101 - Second generation DRAM controller (Geil Super Luce)
+    else if (strcmp(device_name, "AUDA0-E6K5-0101") == 0)
+    {
+        direct_reg  = ENE_REG_COLORS_DIRECT_V2;
+        effect_reg  = ENE_REG_COLORS_EFFECT_V2;
+        channel_cfg = ENE_CONFIG_CHANNEL_V1;
+    }
+    // AUMA0-E6K5-0106 - Second generation motherboard controller
+    else if (strcmp(device_name, "AUMA0-E6K5-0106") == 0)
+    {
+        direct_reg  = ENE_REG_COLORS_DIRECT_V2;
+        effect_reg  = ENE_REG_COLORS_EFFECT_V2;
+        channel_cfg = ENE_CONFIG_CHANNEL_V2;
+    }
+    // AUMA0-E6K5-0105 - Second generation motherboard controller
+    else if (strcmp(device_name, "AUMA0-E6K5-0105") == 0)
+    {
+        direct_reg  = ENE_REG_COLORS_DIRECT_V2;
+        effect_reg  = ENE_REG_COLORS_EFFECT_V2;
+        channel_cfg = ENE_CONFIG_CHANNEL_V2;
+    }
+    // AUMA0-E6K5-0104 - Second generation motherboard controller
+    else if (strcmp(device_name, "AUMA0-E6K5-0104") == 0)
+    {
+        direct_reg  = ENE_REG_COLORS_DIRECT_V2;
+        effect_reg  = ENE_REG_COLORS_EFFECT_V2;
+        channel_cfg = ENE_CONFIG_CHANNEL_V2;
+    }
+    // AUMA0-E8K4-0101 - First generation motherboard controller
+    else if (strcmp(device_name, "AUMA0-E8K4-0101") == 0)
+    {
+        direct_reg  = ENE_REG_COLORS_DIRECT;
+        effect_reg  = ENE_REG_COLORS_EFFECT;
+        channel_cfg = ENE_CONFIG_CHANNEL_V1;
+    }
+    // AUMA0-E6K5-0107 - Second generation GPU controller
+    else if (strcmp(device_name, "AUMA0-E6K5-0107") == 0)
+    {
+        direct_reg  = ENE_REG_COLORS_DIRECT_V2;
+        effect_reg  = ENE_REG_COLORS_EFFECT_V2;
+        channel_cfg = ENE_CONFIG_CHANNEL_V2;
+
+        // Read LED count from configuration table
+        led_count = config_table[ENE_CONFIG_LED_COUNT_0107];
+    }
+    // Assume first generation controller if string does not match
+    else
+    {
+        direct_reg  = ENE_REG_COLORS_DIRECT;
+        effect_reg  = ENE_REG_COLORS_EFFECT;
+        channel_cfg = ENE_CONFIG_CHANNEL_V1;
+    }
+}
+
+ENESMBusController::~ENESMBusController()
+{
+
+}
+
+std::string ENESMBusController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string ENESMBusController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+unsigned char ENESMBusController::GetChannel(unsigned int led)
+{
+    return(config_table[channel_cfg + led]);
+}
+
+const char * ENESMBusController::GetChannelName(unsigned int led)
+{
+    switch (config_table[channel_cfg + led])
+    {
+    case (unsigned char)ENE_LED_CHANNEL_AUDIO:
+        return(ene_channels[0]);
+        break;
+
+    case (unsigned char)ENE_LED_CHANNEL_BACKPLATE:
+        return(ene_channels[1]);
+        break;
+
+    case (unsigned char)ENE_LED_CHANNEL_BACK_IO:
+        return(ene_channels[2]);
+        break;
+
+    case (unsigned char)ENE_LED_CHANNEL_CENTER:
+        return(ene_channels[3]);
+        break;
+
+    case (unsigned char)ENE_LED_CHANNEL_CENTER_START:
+        return(ene_channels[4]);
+        break;
+
+    case (unsigned char)ENE_LED_CHANNEL_DRAM:
+        return(ene_channels[5]);
+        break;
+    
+    case (unsigned char)ENE_LED_CHANNEL_PCIE:
+        return(ene_channels[6]);
+        break;
+
+    case (unsigned char)ENE_LED_CHANNEL_RGB_HEADER:
+        return(ene_channels[7]);
+        break;
+
+    case (unsigned char)ENE_LED_CHANNEL_RGB_HEADER_2:
+        return(ene_channels[8]);
+        break;
+
+    case (unsigned char)ENE_LED_CHANNEL_RGB_HEADER_3:
+        return(ene_channels[9]);
+        break;
+
+    default:
+        return(ene_channels[10]);
+        break;
+    }
+}
+
+unsigned int ENESMBusController::GetLEDCount()
+{
+    return(led_count);
+}
+
+unsigned char ENESMBusController::GetLEDRed(unsigned int led)
+{
+    return(ENERegisterRead(direct_reg + ( 3 * led )));
+}
+
+unsigned char ENESMBusController::GetLEDGreen(unsigned int led)
+{
+    return(ENERegisterRead(direct_reg + ( 3 * led ) + 2));
+}
+
+unsigned char ENESMBusController::GetLEDBlue(unsigned int led)
+{
+    return(ENERegisterRead(direct_reg + ( 3 * led ) + 1));
+}
+
+unsigned char ENESMBusController::GetLEDRedEffect(unsigned int led)
+{
+    return(ENERegisterRead(effect_reg + ( 3 * led )));
+}
+
+unsigned char ENESMBusController::GetLEDGreenEffect(unsigned int led)
+{
+    return(ENERegisterRead(effect_reg + ( 3 * led ) + 2));
+}
+
+unsigned char ENESMBusController::GetLEDBlueEffect(unsigned int led)
+{
+    return(ENERegisterRead(effect_reg + ( 3 * led ) + 1));
+}
+
+void ENESMBusController::SaveMode()
+{
+    ENERegisterWrite(ENE_REG_APPLY, ENE_SAVE_VAL);
+}
+
+void ENESMBusController::SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char* colors = new unsigned char[led_count * 3];
+
+    for (unsigned int i = 0; i < (led_count * 3); i += 3)
+    {
+        colors[i + 0] = red;
+        colors[i + 1] = blue;
+        colors[i + 2] = green;
+    }
+
+    ENERegisterWriteBlock(direct_reg, colors, led_count * 3);
+
+    delete[] colors;
+}
+
+void ENESMBusController::SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char* colors = new unsigned char[led_count * 3];
+
+    for (unsigned int i = 0; i < (led_count * 3); i += 3)
+    {
+        colors[i + 0] = red;
+        colors[i + 1] = blue;
+        colors[i + 2] = green;
+    }
+
+    ENERegisterWriteBlock(effect_reg, colors, led_count * 3);
+    
+    ENERegisterWrite(ENE_REG_APPLY, ENE_APPLY_VAL);
+
+    delete[] colors;
+}
+
+void ENESMBusController::SetDirect(unsigned char direct)
+{
+    ENERegisterWrite(ENE_REG_DIRECT, direct);
+    ENERegisterWrite(ENE_REG_APPLY, ENE_APPLY_VAL);
+}
+
+void ENESMBusController::SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char colors[3] = { red, blue, green };
+
+    ENERegisterWriteBlock(direct_reg + ( 3 * led ), colors, 3);
+}
+
+void ENESMBusController::SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char colors[3] = { red, blue, green };
+
+    ENERegisterWriteBlock(effect_reg + (3 * led), colors, 3);
+
+    ENERegisterWrite(ENE_REG_APPLY, ENE_APPLY_VAL);
+}
+
+void ENESMBusController::SetMode(unsigned char mode, unsigned char speed, unsigned char direction)
+{
+    ENERegisterWrite(ENE_REG_MODE,      mode);
+    ENERegisterWrite(ENE_REG_SPEED,     speed);
+    ENERegisterWrite(ENE_REG_DIRECTION, direction);
+    ENERegisterWrite(ENE_REG_APPLY,     ENE_APPLY_VAL);
+}
+
+void ENESMBusController::UpdateDeviceName()
+{
+    for (int i = 0; i < 16; i++)
+    {
+        device_name[i] = ENERegisterRead(ENE_REG_DEVICE_NAME + i);
+    }
+}
+
+unsigned char ENESMBusController::ENERegisterRead(ene_register reg)
+{
+    //Write ENE register
+    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
+
+    //Read ENE value
+    return(bus->i2c_smbus_read_byte_data(dev, 0x81));
+
+}
+
+void ENESMBusController::ENERegisterWrite(ene_register reg, unsigned char val)
+{
+    //Write ENE register
+    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
+
+    //Write ENE value
+    bus->i2c_smbus_write_byte_data(dev, 0x01, val);
+
+}
+
+void ENESMBusController::ENERegisterWriteBlock(ene_register reg, unsigned char * data, unsigned char sz)
+{
+    //Write ENE register
+    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
+
+    //Write ENE block data
+    bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
+
+}

Controllers/ENESMBusController/ENESMBusController.h

@@ -0,0 +1,140 @@
+/*-----------------------------------------*\
+|  ENESMBusController.h                     |
+|                                           |
+|  Definitions and types for ENE SMBus RGB  |
+|  lighting controller                      |
+|                                           |
+|  Formerly known as ASUS Aura SMBus. ASUS  |
+|  AURA chips are rebranded ENE controllers |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 8/19/2018   |
+\*-----------------------------------------*/
+
+#include <string>
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char	ene_dev_id;
+typedef unsigned short	ene_register;
+
+#define ENE_APPLY_VAL                   0x01        /* Value for Apply Changes Register     */
+#define ENE_SAVE_VAL                    0xAA        /* Value for Save Changes               */
+
+enum
+{
+    ENE_REG_DEVICE_NAME                 = 0x1000,   /* Device String 16 bytes               */
+    ENE_REG_MICRON_CHECK                = 0x1030,   /* If "Micron" appears here, skip       */
+    ENE_REG_CONFIG_TABLE                = 0x1C00,   /* Start of LED configuration bytes     */
+    ENE_REG_COLORS_DIRECT               = 0x8000,   /* Colors for Direct Mode 15 bytes      */
+    ENE_REG_COLORS_EFFECT               = 0x8010,   /* Colors for Internal Effects 15 bytes */
+    ENE_REG_DIRECT                      = 0x8020,   /* "Direct Access" Selection Register   */
+    ENE_REG_MODE                        = 0x8021,   /* Mode Selection Register              */
+    ENE_REG_SPEED                       = 0x8022,   /* Speed Control Register               */
+    ENE_REG_DIRECTION                   = 0x8023,   /* Direction Control Register           */
+    ENE_REG_APPLY                       = 0x80A0,   /* Apply Changes Register               */
+    ENE_REG_SLOT_INDEX                  = 0x80F8,   /* Slot Index Register (RAM only)       */
+    ENE_REG_I2C_ADDRESS                 = 0x80F9,   /* I2C Address Register (RAM only)      */
+    ENE_REG_COLORS_DIRECT_V2            = 0x8100,   /* Direct Colors (v2) 30 bytes          */
+    ENE_REG_COLORS_EFFECT_V2            = 0x8160,   /* Internal Colors (v2) 30 bytes        */
+};
+
+enum
+{
+    ENE_MODE_OFF                        = 0,        /* OFF mode                             */
+    ENE_MODE_STATIC                     = 1,        /* Static color mode                    */
+    ENE_MODE_BREATHING                  = 2,        /* Breathing effect mode                */
+    ENE_MODE_FLASHING                   = 3,        /* Flashing effect mode                 */
+    ENE_MODE_SPECTRUM_CYCLE             = 4,        /* Spectrum Cycle mode                  */
+    ENE_MODE_RAINBOW                    = 5,        /* Rainbow effect mode                  */
+    ENE_MODE_SPECTRUM_CYCLE_BREATHING   = 6,        /* Rainbow Breathing effect mode        */
+    ENE_MODE_CHASE_FADE                 = 7,        /* Chase with Fade effect mode          */
+    ENE_MODE_SPECTRUM_CYCLE_CHASE_FADE  = 8,        /* Chase with Fade, Rainbow effect mode */
+    ENE_MODE_CHASE                      = 9,        /* Chase effect mode                    */
+    ENE_MODE_SPECTRUM_CYCLE_CHASE       = 10,       /* Chase with Rainbow effect mode       */
+    ENE_MODE_SPECTRUM_CYCLE_WAVE        = 11,       /* Wave effect mode                     */
+    ENE_MODE_CHASE_RAINBOW_PULSE        = 12,       /* Chase with  Rainbow Pulse effect mode*/
+    ENE_MODE_RANDOM_FLICKER             = 13,       /* Random flicker effect mode           */
+    ENE_NUMBER_MODES                                /* Number of Aura modes                 */
+};
+
+enum
+{
+    ENE_SPEED_SLOWEST                   = 0x04,     /* Slowest effect speed                 */
+    ENE_SPEED_SLOW                      = 0x03,     /* Slow effect speed                    */
+    ENE_SPEED_NORMAL                    = 0x02,     /* Normal effect speed                  */
+    ENE_SPEED_FAST                      = 0x01,     /* Fast effect speed                    */
+    ENE_SPEED_FASTEST                   = 0x00,     /* Fastest effect speed                 */
+};
+
+enum
+{
+    ENE_DIRECTION_FORWARD               = 0x0,      /* Forward effect direction             */
+    ENE_DIRECTION_REVERSE               = 0x1,      /* Reverse effect direction             */
+};
+
+enum
+{
+    ENE_LED_CHANNEL_DRAM_2              = 0x05,     /* DRAM LED channel                     */
+    ENE_LED_CHANNEL_CENTER_START        = 0x82,     /* Center zone first LED channel        */
+    ENE_LED_CHANNEL_CENTER              = 0x83,     /* Center zone LED channel              */
+    ENE_LED_CHANNEL_AUDIO               = 0x84,     /* Audio zone LED channel               */
+    ENE_LED_CHANNEL_BACK_IO             = 0x85,     /* Back I/O zone LED channel            */
+    ENE_LED_CHANNEL_RGB_HEADER          = 0x86,     /* RGB Header LED channel               */
+    ENE_LED_CHANNEL_RGB_HEADER_2        = 0x87,     /* RGB Header 2 LED channel             */
+    ENE_LED_CHANNEL_BACKPLATE           = 0x88,     /* Backplate zone LED channel           */
+    ENE_LED_CHANNEL_DRAM                = 0x8A,     /* DRAM LED channel                     */
+    ENE_LED_CHANNEL_PCIE                = 0x8B,     /* PCIe zone LED channel                */
+    ENE_LED_CHANNEL_RGB_HEADER_3        = 0x91,     /* RGB Header 3 LED channel             */
+};
+
+enum
+{
+    ENE_CONFIG_LED_COUNT                = 0x02,     /* LED Count configuration offset       */
+    ENE_CONFIG_LED_COUNT_0107           = 0x03,     /* LED Count configuration offset       */
+    ENE_CONFIG_CHANNEL_V1               = 0x13,     /* LED Channel configuration offset     */
+    ENE_CONFIG_CHANNEL_V2               = 0x1B,     /* LED Channel V2 configuration offset  */
+};
+
+class ENESMBusController
+{
+public:
+    ENESMBusController(i2c_smbus_interface* bus, ene_dev_id dev);
+    ~ENESMBusController();
+
+    std::string   GetDeviceName();
+    std::string   GetDeviceLocation();
+    unsigned char GetChannel(unsigned int led);
+    const char*   GetChannelName(unsigned int led);
+    unsigned int  GetLEDCount();
+    unsigned char GetLEDRed(unsigned int led);
+    unsigned char GetLEDGreen(unsigned int led);
+    unsigned char GetLEDBlue(unsigned int led);
+    unsigned char GetLEDRedEffect(unsigned int led);
+    unsigned char GetLEDGreenEffect(unsigned int led);
+    unsigned char GetLEDBlueEffect(unsigned int led);
+    void          SaveMode();
+    void          SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetDirect(unsigned char direct);
+    void          SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void          SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void          SetMode(unsigned char mode, unsigned char speed, unsigned char direction);
+
+    void          UpdateDeviceName();
+
+    unsigned char ENERegisterRead(ene_register reg);
+    void          ENERegisterWrite(ene_register reg, unsigned char val);
+    void          ENERegisterWriteBlock(ene_register reg, unsigned char * data, unsigned char sz);
+
+private:
+    char                    device_name[16];
+    unsigned char           config_table[64];
+    unsigned int            led_count;
+    ene_register            direct_reg;
+    ene_register            effect_reg;
+    unsigned char           channel_cfg;
+    i2c_smbus_interface *   bus;
+    ene_dev_id              dev;
+
+};

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -0,0 +1,359 @@
+#include "Detector.h"
+#include "ENESMBusController.h"
+#include "LogManager.h"
+#include "RGBController.h"
+#include "RGBController_ENESMBus.h"
+#include "i2c_smbus.h"
+#include "pci_ids.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+#include "dependencies/dmiinfo.h"
+
+#define DETECTOR_NAME   "ENE (ASUS Aura) SMBus Controller"
+#define VENDOR_NAME     "ASUS"                                  //This should match the Vendor name from DMI
+
+using namespace std::chrono_literals;
+
+/*----------------------------------------------------------------------*\
+| This list contains the available SMBus addresses for mapping ENE RAM   |
+\*----------------------------------------------------------------------*/
+#define ENE_RAM_ADDRESS_COUNT  23
+
+static const unsigned char ene_ram_addresses[] =
+{
+    0x70,
+    0x71,
+    0x72,
+    0x73,
+    0x74,
+    0x75,
+    0x76,
+    0x78,
+    0x79,
+    0x7A,
+    0x7B,
+    0x7C,
+    0x7D,
+    0x7E,
+    0x7F,
+    0x4F,
+    0x66,
+    0x67,
+    0x39,
+    0x3A,
+    0x3B,
+    0x3C,
+    0x3D
+};
+
+/*---------------------------------------------------------------------------------*\
+| This list contains the available SMBus addresses for mapping Aura motherboards    |
+\*---------------------------------------------------------------------------------*/
+#define AURA_MOBO_ADDRESS_COUNT 3
+
+static const unsigned char aura_mobo_addresses[] =
+{
+    0x40,
+    0x4E,
+    0x4F
+};
+
+/*---------------------------------------------------------------------------------*\
+| This list contains ASUS GPUs which use an ENE RGB controller                      |
+\*---------------------------------------------------------------------------------*/
+
+typedef struct
+{
+    int             pci_vendor;
+    int             pci_device;
+    int             pci_subsystem_vendor;
+    int             pci_subsystem_device;
+    unsigned char   controller_address;
+    const char *    name;
+} gpu_pci_device;
+
+#define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const gpu_pci_device device_list[] =
+{
+    { NVIDIA_VEN,       NVIDIA_RTX3060_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3060_O12G_GAMING,        0x67,   "ASUS ROG STRIX 3060 O12G GAMING"           },
+    { NVIDIA_VEN,       NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3070_OC,                 0x67,   "ASUS ROG STRIX 3070 OC"                    },
+    { NVIDIA_VEN,       NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3070_O8G_WHITE,          0x67,   "ASUS ROG STRIX 3070 O8G White"             },
+    { NVIDIA_VEN,       NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3070_08G_V2_GAMING,      0x67,   "ASUS ROG STRIX 3070 O8G V2 GAMING"         },
+    { NVIDIA_VEN,       NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,       ASUS_TUF_RTX_3070_O8G_GAMING,               0x67,   "ASUS TUF 3070 O8G GAMING"                  },
+    { NVIDIA_VEN,       NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,       ASUS_TUF_RTX_3070_O8G_V2_GAMING,            0x67,   "ASUS TUF 3070 O8G V2 GAMING"               },
+    { NVIDIA_VEN,       NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3080_010G_GAMING,        0x67,   "ASUS ROG STRIX 3080 010G GAMING"           },
+    { NVIDIA_VEN,       NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,       ASUS_TUF_RTX_3080_O10G_OC,                  0x67,   "ASUS TUF 3080 O10G OC"                     },
+    { NVIDIA_VEN,       NVIDIA_RTX3080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3080TI_O12G_GAMING,      0x67,   "ASUS ROG STRIX 3080Ti O12G GAMING"         },
+    { NVIDIA_VEN,       NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3090_O24G_GAMING,        0x67,   "ASUS ROG STRIX 3090 O24G GAMING"           },
+    { NVIDIA_VEN,       NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3090_O24G_GAMING_WHITE,  0x67,   "ASUS ROG STRIX 3090 O24G GAMING White OC"  },
+};
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   ENERegisterRead                                                                        *
+*                                                                                          *
+*       A standalone version of the ENESMBusController::ENERegisterRead function for       *
+*       access to ENE devices without instancing the ENESMBusController class or reading   *
+*       the config table from the device.                                                  *
+*                                                                                          *
+\******************************************************************************************/
+
+unsigned char ENERegisterRead(i2c_smbus_interface* bus, ene_dev_id dev, ene_register reg)
+{
+    //Write ENE register
+    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
+
+    //Read ENE value
+    return(bus->i2c_smbus_read_byte_data(dev, 0x81));
+}
+
+/******************************************************************************************\
+*                                                                                          *
+*   ENERegisterWrite                                                                       *
+*                                                                                          *
+*       A standalone version of the ENESMBusController::ENERegisterWrite function for      *
+*       access to ENE devices without instancing the ENESMBusController class or reading   *
+*       the config table from the device.                                                  *
+*                                                                                          *
+\******************************************************************************************/
+
+void ENERegisterWrite(i2c_smbus_interface* bus, ene_dev_id dev, ene_register reg, unsigned char val)
+{
+    //Write ENE register
+    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
+
+    //Write ENE value
+    bus->i2c_smbus_write_byte_data(dev, 0x01, val);
+}
+
+/******************************************************************************************\
+*                                                                                          *
+*   TestForENESMBusController                                                              *
+*                                                                                          *
+*       Tests the given address to see if an ENE controller exists there.  First does a    *
+*       quick write to test for a response, and if so does a simple read at 0xA0 to test   *
+*       for incrementing values 0...F which was observed at this location during data dump *
+*                                                                                          *
+*       Also tests for the string "Micron" in the ENE register space.  Crucial (Micron)    *
+*       DRAM modules use an ENE controller with custom, incompatible firmware and must     *
+*       be excluded from this controller.                                                  *
+*                                                                                          *
+\******************************************************************************************/
+
+bool TestForENESMBusController(i2c_smbus_interface* bus, unsigned char address)
+{
+    bool pass = false;
+
+    LOG_DEBUG("[ENE SMBus] looking for devices at 0x%02X...", address);
+
+    int res = bus->i2c_smbus_read_byte(address);
+
+    if (res >= 0)
+    {
+        pass = true;
+
+        LOG_DEBUG("[ENE SMBus] Detected an I2C device at address %02X, testing register range", address);
+
+        for (int i = 0xA0; i < 0xB0; i++)
+        {
+            res = bus->i2c_smbus_read_byte_data(address, i);
+
+            if (res != (i - 0xA0))
+            {
+                LOG_VERBOSE("[ENE SMBus] Detection failed testing register %02X.  Expected %02X, got %02X.", i, (i - 0xA0), res);
+
+                pass = false;
+            }
+        }
+
+        if(pass)
+        {
+            LOG_DEBUG("[ENE SMBus] Checking for Micron string");
+
+            char buf[16];
+            for(int i = 0; i < 16; i++)
+            {
+                buf[i] = ENERegisterRead(bus, address, ENE_REG_MICRON_CHECK + i);
+            }
+
+            if(strcmp(buf, "Micron") == 0)
+            {
+                LOG_DEBUG("[ENE SMBus] Device %02X is a Micron device, skipping", address);
+                pass = false;
+            }
+            else
+            {
+                LOG_VERBOSE("[ENE SMBus] Detection successful, address %02X", address);
+            }
+        }
+    }
+
+    return(pass);
+
+}   /* TestForENESMBusController() */
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectENESMBusDRAMControllers                                                          *
+*                                                                                          *
+*           Detects ENE SMBus controllers on DRAM devices                                  *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where device is connected                 *
+*           dev - I2C address of device                                                    *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectENESMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
+{
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        int address_list_idx = -1;
+
+        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        {
+            LOG_DEBUG("[ENE SMBus DRAM] Remapping ENE SMBus RAM modules on 0x77");
+
+            for (unsigned int slot = 0; slot < 8; slot++)
+            {
+                int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
+
+                if (res < 0)
+                {
+                    LOG_DEBUG("[ENE SMBus DRAM] No device detected at 0x77, aborting remap");
+
+                    break;
+                }
+
+                do
+                {
+                    address_list_idx++;
+
+                    if(address_list_idx < ENE_RAM_ADDRESS_COUNT)
+                    {
+                        LOG_DEBUG("[ENE SMBus DRAM] Testing address %02X to see if there is a device there", ene_ram_addresses[address_list_idx]);
+
+                        res = busses[bus]->i2c_smbus_write_quick(ene_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
+                    }
+                    else
+                    {
+                        break;
+                    }
+                } while (res >= 0);
+
+                if(address_list_idx < ENE_RAM_ADDRESS_COUNT)
+                {
+                    LOG_DEBUG("[ENE SMBus DRAM] Remapping slot %d to address %02X", slot, ene_ram_addresses[address_list_idx]);
+
+                    ENERegisterWrite(busses[bus], 0x77, ENE_REG_SLOT_INDEX, slot);
+                    ENERegisterWrite(busses[bus], 0x77, ENE_REG_I2C_ADDRESS, (ene_ram_addresses[address_list_idx] << 1));
+                }
+            }
+
+            // Add ENE controllers at their remapped addresses
+            for (unsigned int address_list_idx = 0; address_list_idx < ENE_RAM_ADDRESS_COUNT; address_list_idx++)
+            {
+                if (TestForENESMBusController(busses[bus], ene_ram_addresses[address_list_idx]))
+                {
+                    ENESMBusController* controller = new ENESMBusController(busses[bus], ene_ram_addresses[address_list_idx]);
+                    RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller);
+                    ResourceManager::get()->RegisterRGBController(rgb_controller);
+                }
+
+                std::this_thread::sleep_for(1ms);
+            }
+        }
+    }
+}   /* DetectENESMBusDRAMControllers() */
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectENESMBusMotherboardControllers                                                   *
+*                                                                                          *
+*           Detects ENE (ASUS Aura) SMBus controllers on ASUS motherboard devices          *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
+*           dev - I2C address of Aura device                                               *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectENESMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &busses)
+{
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        // Add ENE (ASUS Aura) motherboard controllers
+        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        {
+            if(busses[bus]->pci_subsystem_vendor == ASUS_SUB_VEN || busses[bus]->pci_subsystem_vendor == 0)
+            {
+                for (unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
+                {
+                    LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, aura_mobo_addresses[address_list_idx]);
+
+                    if (TestForENESMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
+                    {
+                        DMIInfo dmi;
+                        ENESMBusController* controller = new ENESMBusController(busses[bus], aura_mobo_addresses[address_list_idx]);
+                        RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller);
+                        rgb_controller->name = "ASUS " + dmi.getMainboard();
+                        ResourceManager::get()->RegisterRGBController(rgb_controller);
+                    }
+
+                    std::this_thread::sleep_for(1ms);
+                }
+            }
+            else
+            {
+                LOG_DEBUG(SMBUS_CHECK_DEVICE_FAILURE_EN, DETECTOR_NAME, bus, VENDOR_NAME);
+            }
+        }
+    }
+}   /* DetectENESMBusMotherboardControllers() */
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectENESMBusGPUControllers                                                           *
+*                                                                                          *
+*           Detects ENE (ASUS Aura) SMBus controllers on ASUS GPU devices                  *
+*                                                                                          *
+\******************************************************************************************/
+
+#define GPU_CHECK_DEVICE_MESSAGE_EN     "[%s] Bus %02d is a GPU and the subvendor matches the one for %s, looking for a device at %02X"
+
+void DetectENESMBusGPUControllers(std::vector<i2c_smbus_interface*> &busses)
+{
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        for(unsigned int dev_idx = 0; dev_idx < GPU_NUM_DEVICES; dev_idx++)
+        {
+            if(busses[bus]->pci_vendor           == device_list[dev_idx].pci_vendor           &&
+               busses[bus]->pci_device           == device_list[dev_idx].pci_device           &&
+               busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
+               busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
+            {
+                LOG_DEBUG(GPU_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, device_list[dev_idx].controller_address);
+
+                if(TestForENESMBusController(busses[bus], device_list[dev_idx].controller_address))
+                {
+                    ENESMBusController*     controller     = new ENESMBusController(busses[bus], device_list[dev_idx].controller_address);
+                    RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller);
+
+                    rgb_controller->name = device_list[dev_idx].name;
+                    rgb_controller->type = DEVICE_TYPE_GPU;
+
+                    ResourceManager::get()->RegisterRGBController(rgb_controller);
+                }
+                else
+                {
+                    LOG_DEBUG("[ENE SMBus ASUS GPU] Testing for controller at %d failed", device_list[dev_idx].controller_address);
+                }
+            }
+        }
+    }
+} /* DetectENESMBusGPUControllers() */
+
+REGISTER_I2C_DETECTOR("ENE SMBus DRAM",                 DetectENESMBusDRAMControllers);
+REGISTER_I2C_DETECTOR("ASUS Aura SMBus Motherboard",    DetectENESMBusMotherboardControllers);
+REGISTER_I2C_DETECTOR("ASUS Aura GPU (ENE)",            DetectENESMBusGPUControllers);

Controllers/ENESMBusController/RGBController_ENESMBus.cpp

@@ -0,0 +1,457 @@
+/*-----------------------------------------*\
+|  RGBController_ENESMBus.cpp               |
+|                                           |
+|  Generic RGB Interface for ENE SMBus      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/13/2019   |
+\*-----------------------------------------*/
+
+#include "RGBController_ENESMBus.h"
+
+RGBController_ENESMBus::RGBController_ENESMBus(ENESMBusController * controller_ptr)
+{
+    controller  = controller_ptr;
+
+    /*---------------------------------------------------------*\
+    | Determine name and type (DRAM or Motherboard) by checking |
+    | the ENE controller's version string                       |
+    \*---------------------------------------------------------*/
+    version     = controller->GetDeviceName();
+
+    if((version.find("DIMM_LED") != std::string::npos) || (version.find("AUDA") != std::string::npos) )
+    {
+        type    = DEVICE_TYPE_DRAM;
+        name    = "ENE DRAM";
+        vendor  = "ENE";
+    }
+    else
+    {
+        type    = DEVICE_TYPE_MOTHERBOARD;
+        name    = "ASUS Aura Motherboard";
+        vendor  = "ASUS";
+    }
+
+    location    = controller->GetDeviceLocation();
+    description = "ENE SMBus Device";
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0xFFFF;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Off;
+    Off.name       = "Off";
+    Off.value      = ENE_MODE_OFF;
+    Off.flags      = MODE_FLAG_MANUAL_SAVE;
+    Off.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = ENE_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Static.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Static);
+    
+    mode Breathing;
+    Breathing.name       = "Breathing";
+    Breathing.value      = ENE_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
+    Breathing.speed_min  = ENE_SPEED_SLOWEST;
+    Breathing.speed_max  = ENE_SPEED_FASTEST;
+    Breathing.speed      = ENE_SPEED_NORMAL;
+    modes.push_back(Breathing);
+
+    mode Flashing;
+    Flashing.name       = "Flashing";
+    Flashing.value      = ENE_MODE_FLASHING;
+    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Flashing.color_mode = MODE_COLORS_PER_LED;
+    Flashing.speed_min  = ENE_SPEED_SLOWEST;
+    Flashing.speed_max  = ENE_SPEED_FASTEST;
+    Flashing.speed      = ENE_SPEED_NORMAL;
+    modes.push_back(Flashing);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name       = "Spectrum Cycle";
+    SpectrumCycle.value      = ENE_MODE_SPECTRUM_CYCLE;
+    SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    SpectrumCycle.color_mode = MODE_COLORS_NONE;
+    SpectrumCycle.speed_min  = ENE_SPEED_SLOWEST;
+    SpectrumCycle.speed_max  = ENE_SPEED_FASTEST;
+    SpectrumCycle.speed      = ENE_SPEED_NORMAL;
+    modes.push_back(SpectrumCycle);
+
+    mode Rainbow;
+    Rainbow.name       = "Rainbow";
+    Rainbow.value      = ENE_MODE_RAINBOW;
+    Rainbow.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
+    Rainbow.color_mode = MODE_COLORS_NONE;
+    Rainbow.speed_min  = ENE_SPEED_SLOWEST;
+    Rainbow.speed_max  = ENE_SPEED_FASTEST;
+    Rainbow.speed      = ENE_SPEED_NORMAL;
+    Rainbow.direction  = MODE_DIRECTION_LEFT;
+    modes.push_back(Rainbow);
+
+    mode ChaseFade;
+    ChaseFade.name       = "Chase Fade";
+    ChaseFade.value      = ENE_MODE_CHASE_FADE;
+    ChaseFade.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
+    ChaseFade.color_mode = MODE_COLORS_PER_LED;
+    ChaseFade.speed_min  = ENE_SPEED_SLOWEST;
+    ChaseFade.speed_max  = ENE_SPEED_FASTEST;
+    ChaseFade.speed      = ENE_SPEED_NORMAL;
+    ChaseFade.direction  = MODE_DIRECTION_LEFT;
+    modes.push_back(ChaseFade);
+
+    mode Chase;
+    Chase.name       = "Chase";
+    Chase.value      = ENE_MODE_CHASE;
+    Chase.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
+    Chase.color_mode = MODE_COLORS_PER_LED;
+    Chase.speed_min  = ENE_SPEED_SLOWEST;
+    Chase.speed_max  = ENE_SPEED_FASTEST;
+    Chase.speed      = ENE_SPEED_NORMAL;
+    ChaseFade.direction  = MODE_DIRECTION_LEFT;
+    modes.push_back(Chase);
+
+    mode RandomFlicker;
+    RandomFlicker.name       = "Random Flicker";
+    RandomFlicker.value      = ENE_MODE_RANDOM_FLICKER;
+    RandomFlicker.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    RandomFlicker.color_mode = MODE_COLORS_NONE;
+    RandomFlicker.speed_min  = ENE_SPEED_SLOWEST;
+    RandomFlicker.speed_max  = ENE_SPEED_FASTEST;
+    RandomFlicker.speed      = ENE_SPEED_NORMAL;
+    modes.push_back(RandomFlicker);
+
+    SetupZones();
+
+    /*-------------------------------------------------*\
+    | Initialize active mode                            |
+    \*-------------------------------------------------*/
+    active_mode = GetDeviceMode();
+}
+
+RGBController_ENESMBus::~RGBController_ENESMBus()
+{
+    delete controller;
+}
+
+int RGBController_ENESMBus::GetDeviceMode()
+{
+    /*-----------------------------------------------------------------*\
+    | Determine starting mode by reading the mode and direct registers  |
+    \*-----------------------------------------------------------------*/
+    int dev_mode    = controller->ENERegisterRead(ENE_REG_MODE);
+    int color_mode  = MODE_COLORS_PER_LED;
+    int speed       = controller->ENERegisterRead(ENE_REG_SPEED);
+    int direction   = controller->ENERegisterRead(ENE_REG_DIRECTION);
+
+    if(controller->ENERegisterRead(ENE_REG_DIRECT))
+    {
+        dev_mode = 0xFFFF;
+    }
+
+    switch(dev_mode)
+    {
+        case ENE_MODE_OFF:
+        case ENE_MODE_RAINBOW:
+        case ENE_MODE_SPECTRUM_CYCLE:
+        case ENE_MODE_RANDOM_FLICKER:
+            color_mode = MODE_COLORS_NONE;
+            break;
+
+        case ENE_MODE_SPECTRUM_CYCLE_CHASE:
+            dev_mode   = ENE_MODE_CHASE;
+            color_mode = MODE_COLORS_RANDOM;
+            break;
+
+        case ENE_MODE_SPECTRUM_CYCLE_BREATHING:
+            dev_mode   = ENE_MODE_BREATHING;
+            color_mode = MODE_COLORS_RANDOM;
+            break;
+
+        case ENE_MODE_SPECTRUM_CYCLE_CHASE_FADE:
+            dev_mode   = ENE_MODE_CHASE_FADE;
+            color_mode = MODE_COLORS_RANDOM;
+            break;
+    }
+
+    for(std::size_t mode = 0; mode < modes.size(); mode++)
+    {
+        if(modes[mode].value == dev_mode)
+        {
+            active_mode                 = mode;
+            modes[mode].color_mode      = color_mode;
+
+            if(modes[mode].flags & MODE_FLAG_HAS_SPEED)
+            {
+                modes[mode].speed       = speed;
+            }
+
+            if(modes[mode].flags & MODE_FLAG_HAS_DIRECTION_LR)
+            {
+                modes[mode].direction   = direction;
+            }
+
+            break;
+        }
+    }
+
+    /*---------------------------------------------------------*\
+    | Initialize colors for each LED                            |
+    \*---------------------------------------------------------*/
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        unsigned int  led = leds[led_idx].value;
+        unsigned char red;
+        unsigned char grn;
+        unsigned char blu;
+
+        if(active_mode == 0)
+        {
+            red = controller->GetLEDRed(led);
+            grn = controller->GetLEDGreen(led);
+            blu = controller->GetLEDBlue(led);
+        }
+        else
+        {
+            red = controller->GetLEDRedEffect(led);
+            grn = controller->GetLEDGreenEffect(led);
+            blu = controller->GetLEDBlueEffect(led);
+        }
+
+        colors[led_idx] = ToRGBColor(red, grn, blu);
+    }
+
+    return(active_mode);
+}
+
+void RGBController_ENESMBus::DeviceUpdateLEDs()
+{
+    for(std::size_t led = 0; led < colors.size(); led++)
+    {
+        unsigned char red = RGBGetRValue(colors[led]);
+        unsigned char grn = RGBGetGValue(colors[led]);
+        unsigned char blu = RGBGetBValue(colors[led]);
+
+        if(GetMode() == 0)
+        {
+            controller->SetLEDColorDirect(led, red, grn, blu);
+        }
+        else
+        {
+            controller->SetLEDColorEffect(led, red, grn, blu);
+        }
+    }
+}
+
+void RGBController_ENESMBus::UpdateZoneLEDs(int zone)
+{
+    for(std::size_t led_idx = 0; led_idx < zones[zone].leds_count; led_idx++)
+    {
+        int           led   = zones[zone].leds[led_idx].value;
+        RGBColor      color = colors[led];
+        unsigned char red   = RGBGetRValue(color);
+        unsigned char grn   = RGBGetGValue(color);
+        unsigned char blu   = RGBGetBValue(color);
+
+        if(GetMode() == 0)
+        {
+            controller->SetLEDColorDirect(led, red, grn, blu);
+        }
+        else
+        {
+            controller->SetLEDColorEffect(led, red, grn, blu);
+        }
+    }
+}
+
+void RGBController_ENESMBus::UpdateSingleLED(int led)
+{
+    RGBColor color    = colors[led];
+    unsigned char red = RGBGetRValue(color);
+    unsigned char grn = RGBGetGValue(color);
+    unsigned char blu = RGBGetBValue(color);
+
+    if(GetMode() == 0)
+    {
+        controller->SetLEDColorDirect(led, red, grn, blu);
+    }
+    else
+    {
+        controller->SetLEDColorEffect(led, red, grn, blu);
+    }
+}
+
+void RGBController_ENESMBus::SetupZones()
+{
+    std::vector<int>    led_map;
+
+    /*---------------------------------------------------------*\
+    | Search through all LEDs and create zones for each channel |
+    | type                                                      |
+    \*---------------------------------------------------------*/
+    for(std::size_t led_idx = 0; led_idx < controller->GetLEDCount(); led_idx++)
+    {
+        bool matched = false;
+
+        /*---------------------------------------------------------*\
+        | Search through existing zones to make sure we don't       |
+        | create a duplicate zone                                   |
+        \*---------------------------------------------------------*/
+        for(std::size_t existing_zone_idx = 0; existing_zone_idx < zones.size(); existing_zone_idx++)
+        {
+            if(controller->GetChannelName(led_idx) == zones[existing_zone_idx].name)
+            {
+                matched = true;
+            }
+        }
+
+        /*---------------------------------------------------------*\
+        | If zone does not already exist, create it                 |
+        \*---------------------------------------------------------*/
+        if(matched == false)
+        {
+            zone* new_zone = new zone();
+
+            /*---------------------------------------------------------*\
+            | Set zone name to channel name                             |
+            \*---------------------------------------------------------*/
+            new_zone->name = controller->GetChannelName(led_idx);
+
+            new_zone->leds_count = 0;
+
+            /*---------------------------------------------------------*\
+            | Find all LEDs with this channel type and add them to zone |
+            \*---------------------------------------------------------*/
+            for(std::size_t zone_led_idx = 0; zone_led_idx < controller->GetLEDCount(); zone_led_idx++)
+            {
+                if(controller->GetChannelName(zone_led_idx) == new_zone->name)
+                {
+                    new_zone->leds_count++;
+                    led_map.push_back(zone_led_idx);
+                }
+            }
+
+            /*---------------------------------------------------------*\
+            | Zones have fixed size, so set min and max to count        |
+            \*---------------------------------------------------------*/
+            new_zone->leds_min = new_zone->leds_count;
+            new_zone->leds_max = new_zone->leds_count;
+
+            /*---------------------------------------------------------*\
+            | If this zone has more than one LED, mark it as linear type|
+            \*---------------------------------------------------------*/
+            if(new_zone->leds_count > 1)
+            {
+                new_zone->type = ZONE_TYPE_LINEAR;
+            }
+            else
+            {
+                new_zone->type = ZONE_TYPE_SINGLE;
+            }
+
+            new_zone->matrix_map = NULL;
+            
+            /*---------------------------------------------------------*\
+            | Push new zone to zones vector                             |
+            \*---------------------------------------------------------*/
+            zones.push_back(*new_zone);
+        }
+    }
+
+    /*---------------------------------------------------------*\
+    | Create LED entries for each zone                          |
+    \*---------------------------------------------------------*/
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
+        {
+            led* new_led = new led();
+
+            new_led->name = zones[zone_idx].name + " LED ";
+            new_led->name.append(std::to_string(led_idx + 1));
+
+            new_led->value = led_map[led_idx];
+
+            leds.push_back(*new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_ENESMBus::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_ENESMBus::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_ENESMBus::DeviceUpdateMode()
+{
+    if (modes[active_mode].value == 0xFFFF)
+    {
+        controller->SetDirect(true);
+    }
+    else
+    {
+        int new_mode        = modes[active_mode].value;
+        int new_speed       = 0;
+        int new_direction   = 0;
+
+        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
+        {
+            switch(new_mode)
+            {
+            case ENE_MODE_CHASE:
+                new_mode = ENE_MODE_SPECTRUM_CYCLE_CHASE;
+                break;
+            case ENE_MODE_BREATHING:
+                new_mode = ENE_MODE_SPECTRUM_CYCLE_BREATHING;
+                break;
+            case ENE_MODE_CHASE_FADE:
+                new_mode = ENE_MODE_SPECTRUM_CYCLE_CHASE_FADE;
+                break;
+            }
+        }
+
+        if(modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
+        {
+            new_speed = modes[active_mode].speed;
+        }
+
+        if(modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR)
+        {
+            switch(modes[active_mode].direction)
+            {
+                case MODE_DIRECTION_LEFT:
+                    new_direction = ENE_DIRECTION_FORWARD;
+                    break;
+
+                case MODE_DIRECTION_RIGHT:
+                    new_direction = ENE_DIRECTION_REVERSE;
+                    break;
+            }
+        }
+
+        controller->SetMode(new_mode, new_speed, new_direction);
+        controller->SetDirect(false);
+    }
+}
+
+void RGBController_ENESMBus::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    controller->SaveMode();
+}

Controllers/ENESMBusController/RGBController_ENESMBus.h

@@ -1,8 +1,7 @@
 /*-----------------------------------------*\
-|  RGBController_AsusAuraSMBus.h            |
+|  RGBController_ENESMBus.h                 |
 |                                           |
-|  Generic RGB Interface for OpenAuraSDK    |
-|  Asus Aura SMBus driver                   |
+|  Generic RGB Interface for ENE SMBus      |
 |                                           |
 |  Adam Honse (CalcProgrammer1) 6/13/2019   |
 \*-----------------------------------------*/
@@ -10,13 +9,13 @@
 #pragma once
 
 #include "RGBController.h"
-#include "AsusAuraSMBusController.h"
+#include "ENESMBusController.h"
 
-class RGBController_AuraSMBus : public RGBController
+class RGBController_ENESMBus : public RGBController
 {
 public:
-    RGBController_AuraSMBus(AuraSMBusController* aura_ptr);
-    ~RGBController_AuraSMBus();
+    RGBController_ENESMBus(ENESMBusController* controller_ptr);
+    ~RGBController_ENESMBus();
 
     void        SetupZones();
 
@@ -28,9 +27,10 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
-    AuraSMBusController* aura;
+    ENESMBusController* controller;
 
     int         GetDeviceMode();
 };

Controllers/EVGAGPUController/EVGAGP102Controller.cpp

@@ -0,0 +1,131 @@
+/*-----------------------------------------*\
+|  EVGAGP102Controller.cpp                  |
+|                                           |
+|  Driver for EVGA GP102-based Nvidia GPUs  |
+|  RGB controller for use with GeForce      |
+|  GTX 1080 Ti FTW3 and K|NGP|N.            |
+|                                           |
+|  Fabricio Murta (avengerx) 1/31/2021      |
+\*-----------------------------------------*/
+
+#include "EVGAGP102Controller.h"
+#include "LogManager.h"
+
+EVGAGP102Controller::EVGAGP102Controller(i2c_smbus_interface* bus_ptr, zoneinfo info)
+{
+    bus = bus_ptr;
+    zi = info;
+}
+
+EVGAGP102Controller::~EVGAGP102Controller()
+{
+}
+
+std::string EVGAGP102Controller::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", zi.dev_addr);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+void EVGAGP102Controller::SetColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    SendCommand(EVGA_GP102_CMD_BEGIN);
+    SendCommand(EVGA_GP102_CMD_COLOR);
+
+    if (CommandAcknowledged())
+    {
+        unsigned char rgb[] = { red, green, blue };
+
+        for (int i = 0; i < 3; i++)
+        {
+            bus->i2c_smbus_write_byte_data(zi.dev_addr, zi.color_addrs[i], rgb[i]);
+        }
+
+        SendCommand(EVGA_GP102_CMD_END);
+
+        if (!CommandCompleted())
+        {
+            LOG_WARNING("[%s] Non-clear status report from hardware.", EVGA_GP102_CONTROLLER_NAME);
+        }
+    }
+}
+std::array<unsigned char, 3> EVGAGP102Controller::GetColor()
+{
+    return { GetRed(), GetGreen(), GetBlue() };
+}
+
+bool EVGAGP102Controller::IsValid()
+{
+    for (int i = 0; i < 3; i++)
+    {
+        char res = bus->i2c_smbus_read_byte_data(zi.dev_addr, EVGA_GP102_REG_VALID);
+        if (res == 0x1F)
+        {
+            LOG_TRACE("[%s] Zone discovery successful on address: 0x%02X.", EVGA_GP102_CONTROLLER_NAME, zi.dev_addr);
+            return true;
+        }
+        LOG_DEBUG("[%s] Zone discovery failed on address: 0x%02X expected: 0x1F received: 0x%02X.", EVGA_GP102_CONTROLLER_NAME, zi.dev_addr, res);
+    }
+    return false;
+}
+
+void EVGAGP102Controller::SetMode(unsigned char mode)
+{
+    bus->i2c_smbus_write_byte_data(zi.dev_addr, EVGA_GP102_REG_MODE, mode);
+}
+
+unsigned char EVGAGP102Controller::GetMode()
+{
+    return(bus->i2c_smbus_read_byte_data(zi.dev_addr, EVGA_GP102_REG_MODE));
+}
+
+void EVGAGP102Controller::SendCommand(s32 command)
+{
+    bus->i2c_smbus_write_byte_data(zi.dev_addr, EVGA_GP102_REG_CMD, command);
+}
+
+s32 EVGAGP102Controller::QueryCommand(s32 command)
+{
+    return bus->i2c_smbus_read_byte_data(zi.dev_addr, command);
+}
+
+bool EVGAGP102Controller::CommandAcknowledged()
+{
+    return QueryCommand(EVGA_GP102_REG_CMD) == zi.resp_ready;
+}
+
+bool EVGAGP102Controller::CommandCompleted()
+{
+    return QueryCommand(EVGA_GP102_REG_CMD) == zi.resp_clear;
+}
+
+unsigned char EVGAGP102Controller::GetRed()
+{
+    return(bus->i2c_smbus_read_byte_data(zi.dev_addr, zi.color_addrs[EVGA_GP102_CIDX_RED]));
+}
+
+unsigned char EVGAGP102Controller::GetGreen()
+{
+    return(bus->i2c_smbus_read_byte_data(zi.dev_addr, zi.color_addrs[EVGA_GP102_CIDX_GREEN]));
+}
+
+unsigned char EVGAGP102Controller::GetBlue()
+{
+    return(bus->i2c_smbus_read_byte_data(zi.dev_addr, zi.color_addrs[EVGA_GP102_CIDX_BLUE]));
+}
+
+void EVGAGP102Controller::SaveSettings()
+{
+    //Tested and not worked
+    //bus->i2c_smbus_write_byte_data(zi.dev_addr, 0x21,   0xE5);
+    //bus->i2c_smbus_write_byte_data(zi.dev_addr, 0x22,   0xE7);
+}
+
+std::string EVGAGP102Controller::GetName()
+{
+    return zi.zone_name;
+}

Controllers/EVGAGPUController/EVGAGP102Controller.h

@@ -0,0 +1,102 @@
+/*-----------------------------------------*\
+|  EVGAGP102Controller.h                    |
+|                                           |
+|  Definitions and types for EVGA           |
+|  GP102-based Nvidia GPUs' RGB controller  |
+|  GeForce GTX 1080 Ti K|NGP|N and FTW3.    |
+|                                           |
+|  Fabricio Murta (avengerx) 1/31/2021      |
+\*-----------------------------------------*/
+
+#include <string>
+#include "i2c_smbus.h"
+#include <vector>
+
+#pragma once
+
+#define EVGA_GP102_CONTROLLER_NAME "EVGA GP102 Nvidia GPU"
+
+enum
+{
+    EVGA_GP102_REG_MODE  = 0x0C,
+    EVGA_GP102_REG_CMD   = 0x0E,
+    EVGA_GP102_REG_VALID = 0x04
+};
+
+enum
+{
+    EVGA_GP102_MODE_OFF    = 0x00,
+    EVGA_GP102_MODE_CUSTOM = 0x01
+    // TODO: Other LEDSync modes (rainbow, breath, pulse)
+};
+
+enum
+{
+    EVGA_GP102_CIDX_RED = 0,
+    EVGA_GP102_CIDX_GREEN = 1,
+    EVGA_GP102_CIDX_BLUE = 2
+};
+
+enum
+{
+    EVGA_GP102_CMD_BEGIN = 0xE5,
+    EVGA_GP102_CMD_COLOR = 0xE9,
+    EVGA_GP102_CMD_END = 0xE0
+};
+
+typedef struct
+{
+    std::string zone_name;
+    s32 dev_addr;
+    s32 color_addrs[3];
+    s32 resp_ready;
+    s32 resp_clear;
+} zoneinfo;
+
+const static zoneinfo gpuzoneinfos[]
+{
+    {
+        "Nameplate",
+        0x4A,
+        {0x09, 0x0A, 0x0B},
+        0x03,
+        0x00
+    },
+    {
+        "Backplate",
+        0x2A,
+        {0x30, 0x31, 0x32},
+        0xE9,
+        0xE0
+    }
+};
+
+class EVGAGP102Controller
+{
+public:
+    EVGAGP102Controller(i2c_smbus_interface* bus, zoneinfo info);
+    ~EVGAGP102Controller();
+
+    bool                            IsValid();
+    std::string                     GetDeviceLocation();
+    std::string                     GetName();
+    unsigned char                   GetMode();
+
+    void                            SetColor(unsigned char red, unsigned char green, unsigned char blue);
+    std::array<unsigned char, 3>    GetColor();
+    void                            SetMode(unsigned char mode);
+    void                            SaveSettings();
+
+private:
+    bool                            CommandAcknowledged();
+    bool                            CommandCompleted();
+    s32                             QueryCommand(s32 command);
+    void                            SendCommand(s32 command);
+    unsigned char                   GetRed();
+    unsigned char                   GetGreen();
+    unsigned char                   GetBlue();
+
+    i2c_smbus_interface* bus;
+    zoneinfo zi;
+
+};

Controllers/EVGAGPUController/EVGAGPUCommon.h

@@ -0,0 +1,21 @@
+/*-------------------------------------------------------------------*\
+|  EVGAGPUCommon.h                                                    |
+|                                                                     |
+|  Common classes and functions for EVGA GPUs                         |
+|                                                                     |
+|  Chris M (Dr_No)         11th July 2021                             |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+
+union u16_to_u8
+{
+    uint16_t   u16;
+    struct
+    {
+        uint8_t LSB;
+        uint8_t MSB;
+    };
+};
+
+#define EVGA_DETECT_MESSAGE     "[%s] Found a device match at Bus %02d for Device %04x and SubDevice %04x: %s"

Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp

@@ -1,9 +1,15 @@
 #include "Detector.h"
+#include "EVGAGPUCommon.h"
+#include "EVGAGP102Controller.h"
 #include "EVGAGPUv1Controller.h"
 #include "EVGAGPUv2Controller.h"
+#include "EVGAGPUv3Controller.h"
+#include "LogManager.h"
 #include "RGBController.h"
+#include "RGBController_EVGAGP102.h"
 #include "RGBController_EVGAGPUv1.h"
 #include "RGBController_EVGAGPUv2.h"
+#include "RGBController_EVGAGPUv3.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
 #include <vector>
@@ -12,8 +18,10 @@
 
 enum
 {
+    EVGA_RGB_GP102,
     EVGA_RGB_V1,
     EVGA_RGB_V2,
+    EVGA_RGB_V3,
 };
 
 typedef struct
@@ -30,23 +38,75 @@ 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_GTX1070TI_DEV,     EVGA_SUB_VEN,   EVGA_GTX1070TI_FTW2_SUB_DEV,              EVGA_RGB_V1,    "EVGA GeForce GTX 1070 Ti FTW2"           },
-    { 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_GAMING_SUB_DEV,           EVGA_RGB_V2,    "EVGA GeForce RTX 2070 XC Gaming"         },
-    { 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_RTX2070S_DEV,      EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_PLUS_SUB_DEV,      EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER XC Ultra+"   },
-    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_BLACK_SUB_DEV,            EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Black"          },
-    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_GAMING_SUB_DEV,           EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Gaming"         },
-    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_ULTRA_GAMING_SUB_DEV,     EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Ultra Gaming"   },
-    { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,      EVGA_SUB_VEN,   EVGA_RTX2080S_FTW3_ULTRA_SUB_DEV,         EVGA_RGB_V2,    "EVGA GeForce RTX 2080 SUPER FTW3 Ultra"  },
-    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_XC_ULTRA_GAMING_SUB_DEV,   EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti XC Ultra"        },
-    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_XC_HYBRID_GAMING_SUB_DEV,  EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti XC HYBRID GAMING"},
-    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_FTW3_ULTRA_SUB_DEV,        EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti FTW3 Ultra"      },
-
+    { NVIDIA_VEN,   NVIDIA_GTX1070_DEV,         EVGA_SUB_VEN,   EVGA_GTX1070_FTW_DT_GAMING_SUB_DEV,         EVGA_RGB_V1,    "EVGA GeForce GTX 1070 FTW DT Gaming"                   },
+    { NVIDIA_VEN,   NVIDIA_GTX1070_DEV,         EVGA_SUB_VEN,   EVGA_GTX1070_FTW_SUB_DEV,                   EVGA_RGB_V1,    "EVGA GeForce GTX 1070 FTW"                             },
+    { NVIDIA_VEN,   NVIDIA_GTX1070TI_DEV,       EVGA_SUB_VEN,   EVGA_GTX1070TI_FTW2_SUB_DEV,                EVGA_RGB_V1,    "EVGA GeForce GTX 1070 Ti FTW2"                         },
+    { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,         EVGA_SUB_VEN,   EVGA_GTX1080_FTW_SUB_DEV,                   EVGA_RGB_V1,    "EVGA GeForce GTX 1080 FTW"                             },
+    { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,         EVGA_SUB_VEN,   EVGA_GTX1080_FTW2_SUB_DEV,                  EVGA_RGB_GP102, "EVGA GeForce GTX 1080 FTW2"                            },
+    { NVIDIA_VEN,   NVIDIA_GTX1080TI_DEV,       EVGA_SUB_VEN,   EVGA_GTX1080TI_FTW3_SUB_DEV,                EVGA_RGB_GP102, "EVGA GTX 1080 Ti FTW3"                                 },
+    { NVIDIA_VEN,   NVIDIA_GTX1080TI_DEV,       EVGA_SUB_VEN,   EVGA_GTX1080TI_FTW3_HYBRID_SUB_DEV,         EVGA_RGB_GP102, "EVGA 1080Ti FTW3 Hybrid"                               },
+    { NVIDIA_VEN,   NVIDIA_GTX1080TI_DEV,       EVGA_SUB_VEN,   EVGA_GTX1080TI_KINGPIN_SUB_DEV,             EVGA_RGB_GP102, "EVGA GTX 1080 Ti K|NGP|N"                              },
+    { NVIDIA_VEN,   NVIDIA_RTX2070_OC_DEV,      EVGA_SUB_VEN,   EVGA_RTX2070_XC_GAMING_SUB_DEV,             EVGA_RGB_V2,    "EVGA GeForce RTX 2070 XC Gaming"                       },
+    { 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_BLACK_SUB_DEV,                EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER Black"                     },
+    { 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_RTX2070S_DEV,        EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_PLUS_SUB_DEV,        EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER XC Ultra+"                 },
+    { NVIDIA_VEN,   NVIDIA_RTX2080_DEV,         EVGA_SUB_VEN,   EVGA_RTX2080_BLACK_SUB_DEV,                 EVGA_RGB_V2,    "EVGA GeForce RTX 2080 Black"                           },
+    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,       EVGA_SUB_VEN,   EVGA_RTX2080_XC_BLACK_SUB_DEV,              EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Black"                        },
+    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,       EVGA_SUB_VEN,   EVGA_RTX2080_XC_GAMING_SUB_DEV,             EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Gaming"                       },
+    { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,       EVGA_SUB_VEN,   EVGA_RTX2080_XC_ULTRA_GAMING_SUB_DEV,       EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Ultra Gaming"                 },
+    { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,        EVGA_SUB_VEN,   EVGA_RTX2080S_XC_GAMING_SUB_DEV,            EVGA_RGB_V2,    "EVGA GeForce RTX 2080 SUPER XC Gaming"                 },
+    { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,        EVGA_SUB_VEN,   EVGA_RTX2080S_FTW3_ULTRA_SUB_DEV,           EVGA_RGB_V2,    "EVGA GeForce RTX 2080 SUPER FTW3 Ultra"                },
+    { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,        EVGA_SUB_VEN,   EVGA_RTX2080S_FTW3_ULTRA_HC_SUB_DEV,        EVGA_RGB_V2,    "EVGA GeForce RTX 2080 SUPER FTW3 Ultra Hydro Copper"   },
+    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX2080TI_BLACK_SUB_DEV,               EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti Black"                         },
+    { NVIDIA_VEN,   NVIDIA_RTX2080TI_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_XC_ULTRA_GAMING_SUB_DEV,     EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti XC Ultra"                      },
+    { NVIDIA_VEN,   NVIDIA_RTX2080TI_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_XC_HYBRID_GAMING_SUB_DEV,    EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti XC HYBRID GAMING"              },
+    { NVIDIA_VEN,   NVIDIA_RTX2080TI_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_FTW3_ULTRA_SUB_DEV,          EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti FTW3 Ultra"                    },
+    { NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3060TI_FTW3_GAMING_SUB_DEV,         EVGA_RGB_V3,    "EVGA GeForce RTX 3060TI FTW3 Gaming"                   },
+    { NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3060TI_FTW3_ULTRA_KL_SUB_DEV,       EVGA_RGB_V3,    "EVGA GeForce RTX 3060TI FTW3 Ultra LHR"                },
+    { NVIDIA_VEN,   NVIDIA_RTX3060TI_LHR_DEV,   EVGA_SUB_VEN,   EVGA_RTX3060TI_FTW3_ULTRA_KL_SUB_DEV,       EVGA_RGB_V3,    "EVGA GeForce RTX 3060TI FTW3 Ultra LHR"                },
+    { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         EVGA_SUB_VEN,   EVGA_RTX3070_XC3_BLACK_SUB_DEV,             EVGA_RGB_V3,    "EVGA GeForce RTX 3070 Black Gaming"                    },
+    { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         EVGA_SUB_VEN,   EVGA_RTX3070_XC3_GAMING_SUB_DEV,            EVGA_RGB_V3,    "EVGA GeForce RTX 3070 XC3 Gaming"                      },
+    { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         EVGA_SUB_VEN,   EVGA_RTX3070_XC3_ULTRA_SUB_DEV,             EVGA_RGB_V3,    "EVGA GeForce RTX 3070 XC3 Ultra"                       },
+    { NVIDIA_VEN,   NVIDIA_RTX3070_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3070_XC3_ULTRA_LHR_SUB_DEV,         EVGA_RGB_V3,    "EVGA GeForce RTX 3070 XC3 Ultra LHR"                   },
+    { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         EVGA_SUB_VEN,   EVGA_RTX3070_FTW3_ULTRA_SUB_DEV,            EVGA_RGB_V3,    "EVGA GeForce RTX 3070 FTW3 Ultra"                      },
+    { NVIDIA_VEN,   NVIDIA_RTX3070_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3070_FTW3_ULTRA_LHR_SUB_DEV,        EVGA_RGB_V3,    "EVGA GeForce RTX 3070 FTW3 Ultra LHR"                  },
+    { NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3070TI_XC3_GAMING_SUB_DEV,          EVGA_RGB_V3,    "EVGA GeForce RTX 3070Ti XC3 Gaming"                    },
+    { NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3070TI_XC3_ULTRA_SUB_DEV,           EVGA_RGB_V3,    "EVGA GeForce RTX 3070Ti XC3 Ultra"                     },
+    { NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3070TI_FTW3_ULTRA_SUB_DEV,          EVGA_RGB_V3,    "EVGA GeForce RTX 3070Ti FTW3 Ultra"                    },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_XC3_BLACK_SUB_DEV,             EVGA_RGB_V3,    "EVGA GeForce RTX 3080 XC3 Black"                       },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_XC3_BLACK_LHR_SUB_DEV,         EVGA_RGB_V3,    "EVGA GeForce RTX 3080 XC3 Black LHR"                   },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_XC3_GAMING_SUB_DEV,            EVGA_RGB_V3,    "EVGA GeForce RTX 3080 XC3 Gaming"                      },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_XC3_GAMING_LHR_SUB_DEV,        EVGA_RGB_V3,    "EVGA GeForce RTX 3080 XC3 Gaming LHR"                  },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_XC3_ULTRA_SUB_DEV,             EVGA_RGB_V3,    "EVGA GeForce RTX 3080 XC3 Ultra"                       },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_XC3_ULTRA_LHR_SUB_DEV,         EVGA_RGB_V3,    "EVGA GeForce RTX 3080 XC3 Ultra LHR"                   },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_XC3_ULTRA_HYBRID_SUB_DEV,      EVGA_RGB_V3,    "EVGA GeForce RTX 3080 XC3 Ultra Hybrid"                },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_XC3_ULTRA_HYBRID_LHR_SUB_DEV,  EVGA_RGB_V3,    "EVGA GeForce RTX 3080 XC3 Ultra Hybrid LHR"            },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_XC3_ULTRA_HC_SUB_DEV,          EVGA_RGB_V3,    "EVGA GeForce RTX 3080 XC3 Ultra Hydro Copper"          },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_GAMING_SUB_DEV,           EVGA_RGB_V3,    "EVGA GeForce RTX 3080 FTW3 Gaming"                     },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_SUB_DEV,            EVGA_RGB_V3,    "EVGA GeForce RTX 3080 FTW3 Ultra"                      },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_LHR_SUB_DEV,        EVGA_RGB_V3,    "EVGA GeForce RTX 3080 FTW3 Ultra LHR"                  },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_HYBRID_SUB_DEV,     EVGA_RGB_V3,    "EVGA GeForce RTX 3080 FTW3 Ultra Hybrid"               },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_HYBRID_LHR_SUB_DEV, EVGA_RGB_V3,    "EVGA GeForce RTX 3080 FTW3 Ultra Hybrid LHR"           },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         EVGA_SUB_VEN,   EVGA_RTX3080_FTW3_ULTRA_HC_SUB_DEV,         EVGA_RGB_V3,    "EVGA GeForce RTX 3080 FTW3 Ultra Hydro Copper"         },
+    { NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3080TI_XC3_GAMING_SUB_DEV,          EVGA_RGB_V3,    "EVGA GeForce RTX 3080Ti XC3 Gaming"                    },
+    { NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3080TI_XC3_GAMING_HYBRID_SUB_DEV,   EVGA_RGB_V3,    "EVGA GeForce RTX 3080Ti XC3 Gaming Hybrid"             },
+    { NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3080TI_XC3_GAMING_HC_SUB_DEV,       EVGA_RGB_V3,    "EVGA GeForce RTX 3080Ti XC3 Gaming Hydro Copper"       },
+    { NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3080TI_FTW3_ULTRA_SUB_DEV,          EVGA_RGB_V3,    "EVGA GeForce RTX 3080Ti FTW3 Ultra"                    },
+    { NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3080TI_FTW3_ULTRA_HYBRID_SUB_DEV,   EVGA_RGB_V3,    "EVGA GeForce RTX 3080Ti FTW3 Ultra Hybrid"             },
+    { NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       EVGA_SUB_VEN,   EVGA_RTX3080TI_FTW3_ULTRA_HC_SUB_DEV,       EVGA_RGB_V3,    "EVGA GeForce RTX 3080Ti FTW3 Ultra Hydro Copper"       },
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         EVGA_SUB_VEN,   EVGA_RTX3090_XC3_BLACK_SUB_DEV,             EVGA_RGB_V3,    "EVGA GeForce RTX 3090 XC3 Black"                       },
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         EVGA_SUB_VEN,   EVGA_RTX3090_XC3_GAMING_SUB_DEV,            EVGA_RGB_V3,    "EVGA GeForce RTX 3090 XC3 Gaming"                      },
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         EVGA_SUB_VEN,   EVGA_RTX3090_XC3_ULTRA_SUB_DEV,             EVGA_RGB_V3,    "EVGA GeForce RTX 3090 XC3 Ultra"                       },
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         EVGA_SUB_VEN,   EVGA_RTX3090_XC3_ULTRA_HYBRID_SUB_DEV,      EVGA_RGB_V3,    "EVGA GeForce RTX 3090 XC3 Ultra Hybrid"                },
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         EVGA_SUB_VEN,   EVGA_RTX3090_XC3_ULTRA_HC_SUB_DEV,          EVGA_RGB_V3,    "EVGA GeForce RTX 3090 XC3 Ultra Hydro Copper"          },
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         EVGA_SUB_VEN,   EVGA_RTX3090_FTW3_ULTRA_SUB_DEV,            EVGA_RGB_V3,    "EVGA GeForce RTX 3090 FTW3 Ultra"                      },
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         EVGA_SUB_VEN,   EVGA_RTX3090_FTW3_ULTRA_V2_SUB_DEV,         EVGA_RGB_V3,    "EVGA GeForce RTX 3090 FTW3 Ultra v2"                   },
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         EVGA_SUB_VEN,   EVGA_RTX3090_FTW3_ULTRA_HYBRID_SUB_DEV,     EVGA_RGB_V3,    "EVGA GeForce RTX 3090 FTW3 Ultra Hybrid"               },
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         EVGA_SUB_VEN,   EVGA_RTX3090_FTW3_ULTRA_HC_SUB_DEV,         EVGA_RGB_V3,    "EVGA GeForce RTX 3090 FTW3 Ultra Hydro Copper"         },
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         EVGA_SUB_VEN,   EVGA_RTX3090_KINGPIN_HYBRID_SUB_DEV,        EVGA_RGB_V3,    "EVGA GeForce RTX 3090 K|NGP|N Hybrid"                  },
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         EVGA_SUB_VEN,   EVGA_RTX3090_KINGPIN_HC_SUB_DEV,            EVGA_RGB_V3,    "EVGA GeForce RTX 3090 K|NGP|N Hydro Copper"            },
 };
-
 /******************************************************************************************\
 *                                                                                          *
 *   DetectEVGAGPUControllers                                                               *
@@ -78,6 +138,7 @@ void DetectEVGAGPUControllers(std::vector<i2c_smbus_interface*>& busses)
                 {
                     case EVGA_RGB_V1:
                         {
+                            LOG_DEBUG(EVGA_DETECT_MESSAGE, EVGAGPUV1_CONTROLLER_NAME, bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name );
                             EVGAGPUv1Controller*     new_controller;
                             RGBController_EVGAGPUv1* new_rgbcontroller;
 
@@ -90,6 +151,7 @@ void DetectEVGAGPUControllers(std::vector<i2c_smbus_interface*>& busses)
 
                     case EVGA_RGB_V2:
                         {
+                            LOG_DEBUG(EVGA_DETECT_MESSAGE, EVGAGPUV2_CONTROLLER_NAME, bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name );
                             EVGAGPUv2Controller*     new_controller;
                             RGBController_EVGAGPUv2* new_rgbcontroller;
 
@@ -99,6 +161,55 @@ void DetectEVGAGPUControllers(std::vector<i2c_smbus_interface*>& busses)
                             ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
                         }
                         break;
+
+                    case EVGA_RGB_V3:
+                        {
+                            LOG_DEBUG(EVGA_DETECT_MESSAGE, EVGAGPUV3_CONTROLLER_NAME, bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name );
+                            EVGAGPUv3Controller*     new_controller;
+                            RGBController_EVGAGPUv3* new_rgbcontroller;
+
+                            new_controller = new EVGAGPUv3Controller(busses[bus], 0x2D);
+                            new_controller-> evgaGPUName = device_list[dev_idx].name; // Pass name of the card into the controller for logging.
+                            
+                            if(new_controller-> ReadFWVersion() != "")
+                            {
+                                new_rgbcontroller = new RGBController_EVGAGPUv3(new_controller);
+                                new_rgbcontroller->name = device_list[dev_idx].name;
+                                ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
+                            }
+                            else
+                            {
+                                LOG_INFO("[%s] Failed to get a valid FW version, does the i2c interface support `i2c_smbus_read_i2c_block_data`?", new_controller-> evgaGPUName);
+                                delete new_controller;
+                            }
+                        }
+                        break;
+                    case EVGA_RGB_GP102:
+                        {
+                            LOG_DEBUG(EVGA_DETECT_MESSAGE, EVGA_GP102_CONTROLLER_NAME, bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name );
+                            RGBController_EVGAGP102* new_rgbcontroller;
+                            std::vector<EVGAGP102Controller*>   controllers;
+
+                            for(unsigned int i = 0; i < sizeof(gpuzoneinfos) / sizeof(zoneinfo); i++)
+                            {
+                                EVGAGP102Controller* contr = new EVGAGP102Controller(busses[bus], gpuzoneinfos[i]);
+                                if (contr->IsValid())
+                                {
+                                    controllers.push_back(contr);
+                                }
+                                else
+                                {
+                                    delete contr;
+                                }
+                            }
+                            if(controllers.size() != 0)
+                            {
+                                new_rgbcontroller       = new RGBController_EVGAGP102(controllers);
+                                new_rgbcontroller->name = device_list[dev_idx].name;
+                                ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
+                            }
+                        }
+                        break;
                 }
             }
         }

Controllers/EVGAGPUController/EVGAGPUv1Controller.cpp

@@ -61,3 +61,8 @@ void EVGAGPUv1Controller::SetMode(unsigned char mode)
 {
     bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V1_REG_MODE, mode);
 }
+
+void EVGAGPUv1Controller::SaveSettings()
+{
+    bus->i2c_smbus_write_byte_data(dev, 0x23,   0xE5);
+}

Controllers/EVGAGPUController/EVGAGPUv1Controller.h

@@ -14,6 +14,8 @@
 
 typedef unsigned char	evga_dev_id;
 
+#define EVGAGPUV1_CONTROLLER_NAME   "EVGAv1"
+
 enum
 {
     EVGA_GPU_V1_REG_MODE                = 0x0C,
@@ -45,6 +47,7 @@ public:
 
     void            SetColor(unsigned char red, unsigned char green, unsigned char blue);
     void            SetMode(unsigned char mode);
+    void            SaveSettings();
 
 private:
     i2c_smbus_interface*    bus;

Controllers/EVGAGPUController/EVGAGPUv2Controller.cpp

@@ -71,10 +71,9 @@ unsigned char EVGAGPUv2Controller::GetMode()
             }
             break;
         
-        case EVGA_GPU_V2_MODE_DIRECT:
+        case EVGA_GPU_V2_MODE_STATIC:
             {
-                //No way to detect static so just return direct.
-                return_mode = EVGA_GPU_V2_RGB_MODE_DIRECT;
+                return_mode = EVGA_GPU_V2_RGB_MODE_STATIC;
             }
             break;
 
@@ -121,9 +120,8 @@ unsigned char EVGAGPUv2Controller::GetSpeed()
     return (unsigned char) speed_16.u16;
 }
 
-void EVGAGPUv2Controller::SetMode(unsigned char mode, RGBColor color1, RGBColor color2, unsigned int speed)
+void EVGAGPUv2Controller::SetMode(uint8_t mode, RGBColor color1, RGBColor color2, uint16_t speed, uint8_t brightness)
 {
-    bool boolSave = false;
 
     EnableWrite(true);
     switch (mode)
@@ -131,30 +129,22 @@ void EVGAGPUv2Controller::SetMode(unsigned char mode, RGBColor color1, RGBColor
     case EVGA_GPU_V2_RGB_MODE_OFF:
         {
             SendMode(EVGA_GPU_V2_MODE_OFF);
-            boolSave = true;
         }
         break;
 
-    case EVGA_GPU_V2_RGB_MODE_DIRECT:
     case EVGA_GPU_V2_RGB_MODE_STATIC:
         {
-            SendMode(EVGA_GPU_V2_MODE_DIRECT);
-            //Static is mode 0x01 but with SaveSettings()
-            boolSave = (mode == EVGA_GPU_V2_RGB_MODE_STATIC);
-
-            SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(color1), RGBGetGValue(color1), RGBGetBValue(color1));
+            SendMode(EVGA_GPU_V2_MODE_STATIC);
+            SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(color1), RGBGetGValue(color1), RGBGetBValue(color1), brightness);
         }
         break;
 
     case EVGA_GPU_V2_RGB_MODE_RAINBOW:
         {
             SendMode(EVGA_GPU_V2_MODE_RAINBOW);
-            //OpenRGB does not do brightness yet
-            SendBrightness(0x64); //Default = 0x64
+            SendBrightness(brightness); //Default = 0x64
             // Set Rainbow speed? No control in the GUI but this register is only set in Ranbow mode.
-            bus->i2c_smbus_write_byte_data(dev, 0x19, 0x11);
-
-            boolSave = true;
+            bus->i2c_smbus_write_byte_data(dev, 0x19, 0x11);;
         }
         break;
 
@@ -169,8 +159,8 @@ void EVGAGPUv2Controller::SetMode(unsigned char mode, RGBColor color1, RGBColor
             | inspection is required.                                   |
             \*---------------------------------------------------------*/
 
-            SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(color1), RGBGetGValue(color1), RGBGetBValue(color1));
-            SendColor(EVGA_GPU_V2_REG_COLOR_B_RED, RGBGetRValue(color2), RGBGetGValue(color2), RGBGetBValue(color2));
+            SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(color1), RGBGetGValue(color1), RGBGetBValue(color1), brightness);
+            SendColor(EVGA_GPU_V2_REG_COLOR_B_RED, RGBGetRValue(color2), RGBGetGValue(color2), RGBGetBValue(color2), brightness);
 
             /*-----------------------------------------------------------------*\
             | Breathing mode speeds are consistent for B_TO_A and A_TO_B        |
@@ -185,8 +175,6 @@ void EVGAGPUv2Controller::SetMode(unsigned char mode, RGBColor color1, RGBColor
             // 0x6A and 0x6B = 0x00
             bus->i2c_smbus_write_byte_data(dev, 0x6A,   0x00);
             bus->i2c_smbus_write_byte_data(dev, 0x6B,   0x00);
-
-            boolSave = true;
         }
         break;
 
@@ -194,13 +182,8 @@ void EVGAGPUv2Controller::SetMode(unsigned char mode, RGBColor color1, RGBColor
         break;
     }
 
-    //Disable writes and Save (if applicable)
+    //Disable writes
     EnableWrite(false);
-
-    if(boolSave)
-    {
-        SaveSettings();
-    }
 }
 
 void EVGAGPUv2Controller::EnableWrite(bool boolEnable)
@@ -232,12 +215,12 @@ void EVGAGPUv2Controller::SaveSettings()
     bus->i2c_smbus_write_byte_data(dev, 0x0E,   0xE0);
 }
 
-void EVGAGPUv2Controller::SendBrightness(unsigned char brightness)
+void EVGAGPUv2Controller::SendBrightness(uint8_t brightness)
 {
     bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_BRIGHTNESS, brightness);
 }
 
-void EVGAGPUv2Controller::SendColor(unsigned char start_register, unsigned char red, unsigned char green, unsigned char blue, unsigned char brightness)
+void EVGAGPUv2Controller::SendColor(uint8_t start_register, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness)
 {
     bus->i2c_smbus_write_byte_data(dev, start_register,         red);
     bus->i2c_smbus_write_byte_data(dev, (start_register + 1),   green);
@@ -245,7 +228,7 @@ void EVGAGPUv2Controller::SendColor(unsigned char start_register, unsigned char
     bus->i2c_smbus_write_byte_data(dev, (start_register + 3),   brightness);
 }
 
-void EVGAGPUv2Controller::SendMode(unsigned char mode)
+void EVGAGPUv2Controller::SendMode(uint8_t mode)
 {
     bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_MODE, mode);
 }
@@ -264,15 +247,10 @@ void EVGAGPUv2Controller::SendSpeed(u16_to_u8 aOnTime, u16_to_u8 bOnTime, u16_to
     bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_MSB, (unsigned char) aOnTime.MSB );
 }
 
-void EVGAGPUv2Controller::SetColor(RGBColor colorA, RGBColor colorB, bool boolSave)
+void EVGAGPUv2Controller::SetColor(RGBColor colorA, RGBColor colorB, uint8_t brightness)
 {
     EnableWrite(true);
-    SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(colorA), RGBGetGValue(colorA), RGBGetBValue(colorA), 0x64);
-    SendColor(EVGA_GPU_V2_REG_COLOR_B_RED, RGBGetRValue(colorB), RGBGetGValue(colorB), RGBGetBValue(colorB), 0x64);
+    SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(colorA), RGBGetGValue(colorA), RGBGetBValue(colorA), brightness);
+    SendColor(EVGA_GPU_V2_REG_COLOR_B_RED, RGBGetRValue(colorB), RGBGetGValue(colorB), RGBGetBValue(colorB), brightness);
     EnableWrite(false);
-
-    if(boolSave)
-    {
-        SaveSettings();
-    }
 }

Controllers/EVGAGPUController/EVGAGPUv2Controller.h

@@ -10,12 +10,17 @@
 #include <string>
 #include "i2c_smbus.h"
 #include "RGBController.h"
+#include "EVGAGPUCommon.h"
 
 #pragma once
 
 typedef unsigned char	evga_dev_id;
 
-#define SPEED_MULTIPLIER 10
+#define SPEED_MULTIPLIER                10
+#define EVGA_GPU_V2_BRIGHTNESS_MIN      0x01
+#define EVGA_GPU_V2_BRIGHTNESS_DEFAULT  0x64
+#define EVGA_GPU_V2_BRIGHTNESS_MAX      0x64
+#define EVGAGPUV2_CONTROLLER_NAME   "EVGAv2"
 
 enum
 {
@@ -43,17 +48,16 @@ enum
 enum
 {
     EVGA_GPU_V2_RGB_MODE_OFF                = 0x00,
-    EVGA_GPU_V2_RGB_MODE_DIRECT             = 0x01, 
-    EVGA_GPU_V2_RGB_MODE_STATIC             = 0x02,
-    EVGA_GPU_V2_RGB_MODE_RAINBOW            = 0x03,
-    EVGA_GPU_V2_RGB_MODE_BREATHING          = 0x04,
-    EVGA_GPU_V2_RGB_MODE_PULSE              = 0x05,
+    EVGA_GPU_V2_RGB_MODE_STATIC             = 0x01,
+    EVGA_GPU_V2_RGB_MODE_RAINBOW            = 0x02,
+    EVGA_GPU_V2_RGB_MODE_BREATHING          = 0x03,
+    EVGA_GPU_V2_RGB_MODE_PULSE              = 0x04,
 };
 
 enum
 {
     EVGA_GPU_V2_MODE_OFF                    = 0x00,
-    EVGA_GPU_V2_MODE_DIRECT                 = 0x01, 
+    EVGA_GPU_V2_MODE_STATIC                 = 0x01, 
     EVGA_GPU_V2_MODE_RAINBOW                = 0x0F,
     EVGA_GPU_V2_MODE_BREATHING              = 0x22,
 };
@@ -68,16 +72,6 @@ enum
     EVGA_GPU_V2_SPEED_PULSE_FASTEST         = 0x32,
 };
 
-typedef union
-{
-    uint16_t   u16;
-    struct
-    {
-        uint8_t LSB;
-        uint8_t MSB;
-    };
-} u16_to_u8;
-
 class EVGAGPUv2Controller
 {
 public:
@@ -92,15 +86,15 @@ public:
     unsigned char   GetMode();
     unsigned char   GetSpeed();
 
-    void            SetColor(RGBColor colorA, RGBColor colorB, bool boolSave);
-    void            SetMode(unsigned char mode, RGBColor color1, RGBColor color2, unsigned int speed);
+    void            SetColor(RGBColor colorA, RGBColor colorB, uint8_t brightness);
+    void            SetMode(uint8_t mode, RGBColor color1, RGBColor color2, uint16_t speed, uint8_t brightness);
+    void            SaveSettings();
 
 private:
     void            EnableWrite(bool enable);
-    void            SaveSettings();
-    void            SendBrightness(unsigned char brightness = 0x64);
-    void            SendColor(unsigned char start_register, unsigned char red, unsigned char green, unsigned char blue, unsigned char brightness = 0x64);
-    void            SendMode(unsigned char mode);
+    void            SendBrightness(uint8_t brightness);
+    void            SendColor(uint8_t start_register, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness);
+    void            SendMode(uint8_t mode);
     void            SendSpeed(u16_to_u8 aOnTime, u16_to_u8 bOnTime, u16_to_u8 b2a, u16_to_u8 a2b, u16_to_u8 speed_un);
 
     i2c_smbus_interface*    bus;

Controllers/EVGAGPUController/EVGAGPUv3Controller.cpp

@@ -0,0 +1,515 @@
+/*-----------------------------------------*\
+|  EVGAGPUv3Controller.cpp                  |
+|                                           |
+|  Driver for EVGA GPU RGB V3 (Ampere)      |
+|  lighting controller                      |
+|                                           |
+|  TheRogueZeta                 7/15/2021   |
+\*-----------------------------------------*/
+
+#include "EVGAGPUv3Controller.h"
+#include "LogManager.h"
+
+EVGAGPUv3Controller::EVGAGPUv3Controller(i2c_smbus_interface* bus, evga_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+}
+
+EVGAGPUv3Controller::~EVGAGPUv3Controller()
+{
+
+}
+
+std::string EVGAGPUv3Controller::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char        addr[5];
+
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+void EVGAGPUv3Controller::GetDeviceModes()
+{
+    LOG_DEBUG("[%s] Getting Zone and LED count from HW", evgaGPUName);
+    uint8_t data_pkt[I2C_SMBUS_BLOCK_MAX] = {};
+
+    uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_MODE, 10, data_pkt);
+    if (result == 10)
+    {
+        for(uint8_t zone = 0 ; zone < 4; zone ++)
+        {
+            zone_modes[zone] = data_pkt[zone + 1];
+            zone_led_count[zone] = data_pkt[zone + 5];
+            LOG_DEBUG("[%s] Zone %1d LED count: %02d, mode: %02d", evgaGPUName, zone + 1, zone_led_count[zone], zone_modes[zone]);
+        }
+        zone_sync = data_pkt[9];
+        LOG_DEBUG("[%s] Zone Sync is %1d", evgaGPUName, zone_sync);
+    }
+    else
+    {
+            LOG_DEBUG("[%s] Invalid block read result: %02d", evgaGPUName, result);
+            memset(zone_led_count, 0, sizeof(zone_led_count));
+            memset(zone_modes, 0, sizeof(zone_modes));
+    }
+    initCard();
+}
+
+std::string EVGAGPUv3Controller::GetFWVersion()
+{
+    return(fwVersion);
+}
+
+std::string EVGAGPUv3Controller::ReadFWVersion()
+{
+    LOG_TRACE("[%s] Getting FW from HW", evgaGPUName);
+    uint8_t         data_pkt[I2C_SMBUS_BLOCK_MAX] = {};
+    std::string     return_string = "";
+    char            version[8];
+
+    uint8_t         result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_FIRMWARE, 6, data_pkt);
+    if (result == 6)
+    {
+        uint8_t     major = data_pkt[4];
+        uint8_t     minor = data_pkt[5];
+
+        snprintf(version, 8, "1.%02d.%02d", major, minor);
+        return_string.append(version);
+        LOG_TRACE("[%s] Firmware %s", evgaGPUName, version);
+        fwVersion = return_string;
+        return(return_string);
+    }
+    else
+    {
+        return "";
+    }
+}
+
+uint8_t EVGAGPUv3Controller::GetZoneMode(uint8_t zone)
+{
+    return zone_modes[zone];
+}
+
+EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode)
+{
+    EVGAv3_config               zone_config;
+    u16_to_u8                   speed16;
+    bool                        readFail = false;
+
+    zone_config.brightness      = EVGA_GPU_V3_BRIGHTNESS_DEFAULT;
+    zone_config.direction       = 0;
+    zone_config.numberOfColors  = 0;
+    zone_config.speed           = EVGA_GPU_V3_SPEED_GENERIC_NORMAL;
+
+    LOG_DEBUG("[%s] Retriving Zone %1d config for mode %1d from HW", evgaGPUName, zone, mode);
+    uint8_t data_pkt[I2C_SMBUS_BLOCK_MAX] = {};
+
+    switch (mode)
+    {
+        case EVGA_GPU_V3_MODE_STATIC:
+            {
+                uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + zone, 5, data_pkt);
+                if (result == 5)
+                {
+                    //Load data
+                    zone_config.brightness      = data_pkt[1];
+                    uint8_t red                 = data_pkt[2];
+                    uint8_t green               = data_pkt[3];
+                    uint8_t blue                = data_pkt[4];
+                    zone_config.colors[0]       = ToRGBColor(red, green, blue);
+                    zone_config.numberOfColors  = 1;
+                    zone_config.speed           = 0;
+                    zone_config.direction       = 0;
+                }
+                else
+                {
+                    readFail = true;
+                }
+            }
+            break;
+        
+        case EVGA_GPU_V3_MODE_BREATHING:
+            {
+                uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_BREATHING + zone, 10, data_pkt);
+                if (result == 10)
+                {
+                    //Load data
+                    zone_config.brightness      = data_pkt[1];
+                    uint8_t red1                = data_pkt[2];
+                    uint8_t green1              = data_pkt[3];
+                    uint8_t blue1               = data_pkt[4];
+                    zone_config.colors[0]       = ToRGBColor(red1, green1, blue1);
+                    uint8_t red2                = data_pkt[5];
+                    uint8_t green2              = data_pkt[6];
+                    uint8_t blue2               = data_pkt[7];
+                    zone_config.colors[1]       = ToRGBColor(red2, green2, blue2);
+                    zone_config.numberOfColors= (zone_config.colors[1] != 0 ) ? 2 : 1 ;
+                    speed16.LSB                 = data_pkt[8];
+                    speed16.MSB                 = data_pkt[9];
+                    zone_config.speed           = speed16.u16;
+                    zone_config.direction       = 0;
+                }
+                else
+                {
+                    readFail = true;
+                }
+            }
+            break;
+
+        case EVGA_GPU_V3_MODE_RAINBOW:
+        case EVGA_GPU_V3_MODE_RAINBOW_WAVE:
+        case EVGA_GPU_V3_MODE_STAR:
+            {
+                uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, 4, data_pkt);
+                if (result == 4)
+                {
+                    //Load data
+                    zone_config.brightness      = data_pkt[1];
+                    zone_config.numberOfColors  = 0;
+                    speed16.LSB                 = data_pkt[2];
+                    speed16.MSB                 = data_pkt[3];
+                    zone_config.speed           = speed16.u16;
+                }
+                else
+                {
+                    readFail = true;
+                }
+            }
+            break;
+
+        case EVGA_GPU_V3_MODE_WAVE:
+            {
+                uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, 7, data_pkt);
+                if (result == 7)
+                {
+                    //Load data
+                    zone_config.brightness      = data_pkt[1];
+                    uint8_t red                 = data_pkt[2];
+                    uint8_t green               = data_pkt[3];
+                    uint8_t blue                = data_pkt[4];
+                    zone_config.colors[0]       = ToRGBColor(red, green, blue);
+                    zone_config.numberOfColors  = 1;
+                    speed16.LSB                 = data_pkt[5];
+                    speed16.MSB                 = data_pkt[6];
+                    zone_config.speed           = speed16.u16;
+                }
+                else
+                {
+                    readFail = true;
+                }
+            }
+            break;
+
+        case EVGA_GPU_V3_MODE_COLOR_CYCLE:
+        case EVGA_GPU_V3_MODE_COLOR_STACK:
+            {
+                uint8_t cd_pkt[5];
+
+                if(mode == EVGA_GPU_V3_MODE_COLOR_STACK)
+                {
+                    uint8_t color_count = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_COLOR_STACK_COLOR_COUNT, 5, cd_pkt);
+
+                    if(color_count == 5)
+                    {
+                        zone_config.numberOfColors = cd_pkt[zone + 1];
+                    }
+                    else
+                    {
+                        readFail = true;
+                    }
+
+                    uint8_t direction = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_COLOR_STACK_DIRECTION, 5, cd_pkt);
+                    if(direction == 5)
+                    {
+                        zone_config.direction = cd_pkt[zone + 1];
+                    }
+                    else
+                    {
+                        readFail = true;
+                    }
+                    
+                }
+                else
+                {
+                    uint8_t color_count = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_COLOR_CYCLE_COUNT, 5, cd_pkt);
+
+                    if(color_count == 5)
+                    {
+                        zone_config.numberOfColors = cd_pkt[zone + 1];
+                    }
+                    else
+                    {
+                        readFail = true;
+                    }
+                }
+
+                uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, 31, data_pkt);
+                if (result == 31)
+                {
+                    zone_config.brightness      = data_pkt[1];
+                    for(uint8_t color_index = 0; color_index < zone_config.numberOfColors; color_index++)
+                    {
+                        uint8_t red             = data_pkt[(color_index * 4) + 2];
+                        uint8_t green           = data_pkt[(color_index * 4) + 3];
+                        uint8_t blue            = data_pkt[(color_index * 4) + 4];
+                        zone_config.colors[color_index] = ToRGBColor(red, green, blue);
+                    }
+                    speed16.LSB                 = data_pkt[29];
+                    speed16.MSB                 = data_pkt[30];
+                    zone_config.speed           = speed16.u16;
+                }
+                else 
+                {
+                    readFail = true;
+                }
+            }
+            break;
+
+        default:
+            break;
+    }
+
+    if(readFail == false)
+    {
+        LOG_TRACE("[%s] Zone %1d Brightness: 0x%02X, Colors: %1d, Speed: 0x%04X, Direction %1d.", evgaGPUName, zone, zone_config.brightness, zone_config.numberOfColors, zone_config.speed, zone_config.direction);
+        for(uint8_t color_index = 0; color_index < zone_config.numberOfColors; color_index++)
+        {
+            LOG_TRACE("[%s] Color Index [%2d]: 0x%06X", evgaGPUName, color_index, zone_config.colors[color_index]);
+        }
+        LOG_DEBUG("[%s] Done loading Zone %1d configuration from HW", evgaGPUName, zone);
+    }
+    else
+    {
+        zone_config.direction       = 0;
+        zone_config.numberOfColors  = 0;
+        for(uint8_t i = 0; i < 7; i++)
+        {
+            zone_config.colors[i] = 0;
+        } 
+        LOG_DEBUG("[%s] Failed while loading Zone %1d configuration from HW", evgaGPUName, zone);
+    }
+    return zone_config;
+}
+
+void EVGAGPUv3Controller::initCard()
+{
+    // This command needs to be sent before the card will respond to OpenRGB commands
+    // NvAPI_I2CWriteEx: Dev: 0x2D RegSize: 0x01 Reg: 0xB2 Size: 0x05 Data: 0x04 0xC6 0xEB 0xEA 0x15
+    uint8_t data_pkt[5] = {0x04, 0xC6, 0xEB, 0xEA, 0x15};
+    bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_ENABLE, sizeof(data_pkt), data_pkt);
+    LOG_TRACE("[%s] Sending SW int packet", evgaGPUName);
+    return;
+}
+
+void EVGAGPUv3Controller::SaveConfig()
+{
+    LOG_DEBUG("[%s] Sending save packet", evgaGPUName);
+
+    //NvAPI_I2CWriteEx: Dev: 0x2D RegSize: 0x01 Reg: 0x90 Size: 0x05 Data: 0x04 0x9E 0xEB 0x00 0x90 //Sent on close of PX1
+    uint8_t data_pkt[5] = {0x04, 0x9E, 0xEB, 0x00, 0x90};
+
+    bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_SAVE, sizeof(data_pkt), data_pkt);
+    return;
+}
+
+void EVGAGPUv3Controller::ResizeARGB(uint8_t newSize)
+{
+    if(newSize < EVGAGPUV3_LEDS_MIN)
+    {
+        newSize = EVGAGPUV3_LEDS_MIN;
+    }
+    else if(newSize > EVGAGPUV3_LEDS_MAX)
+    {
+        newSize = EVGAGPUV3_LEDS_MAX;
+    }
+
+    LOG_DEBUG("[%s] Resizing ARGB header with %02d size", evgaGPUName, newSize);
+    uint8_t data_pkt[EVGAGPUV3_MODE_PACKET_SIZE] = { 0x09, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT,
+                                                           EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, newSize, EVGAGPUV3_INIT};
+
+    bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_MODE, sizeof(data_pkt), data_pkt);
+    return;
+}
+
+void EVGAGPUv3Controller::SetAllModes(uint8_t zone_0_mode, uint8_t zone_1_mode,uint8_t zone_2_mode,uint8_t zone_3_mode, bool sync)
+{
+    uint8_t     mode_pkt[EVGAGPUV3_MODE_PACKET_SIZE]    = { EVGAGPUV3_MODE_PACKET_SIZE - 1,
+                                                        EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT,
+                                                        EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, 0x0 };
+
+    // Hack to keep card in sync after power loss (standby) without requireing a rescan.
+    // To be replaced with code that calls this once upon system resume once OpenRGB
+    // knows about system power states.
+    initCard();
+
+    // Keep zone_modes in sync
+    zone_modes[0] = zone_0_mode;
+    zone_modes[1] = zone_1_mode;
+    zone_modes[2] = zone_2_mode;
+    zone_modes[3] = zone_3_mode;
+
+    // Prep packet
+    mode_pkt[1] = zone_0_mode;
+    mode_pkt[2] = zone_1_mode;
+    mode_pkt[3] = zone_2_mode;
+    mode_pkt[4] = zone_3_mode;
+    mode_pkt[9] = sync;
+
+    bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_MODE, EVGAGPUV3_MODE_PACKET_SIZE, mode_pkt);
+    //LOG_TRACE("[%s] Setting all zones to mode: %02d, %2d, %2d, %2d, zone sync %1d.", evgaGPUName, zone_0_mode, zone_1_mode, zone_2_mode, zone_3_mode, sync);
+}
+
+void EVGAGPUv3Controller::SetZoneMode(uint8_t zone, uint8_t mode)
+{
+    uint8_t     mode_pkt[EVGAGPUV3_MODE_PACKET_SIZE]    = { EVGAGPUV3_MODE_PACKET_SIZE - 1,
+                                                        EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT,
+                                                        EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, 0x0 };
+
+    // Hack to keep card in sync after power loss (standby) without requireing a rescan.
+    // To be replaced with code that calls this once upon system resume once OpenRGB
+    // knows about system power states.
+    initCard();
+
+    // Keep zone_modes in sync
+    zone_modes[zone] = mode;
+    // Prep packet
+    mode_pkt[zone + 1] = mode;
+
+    bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_MODE, EVGAGPUV3_MODE_PACKET_SIZE, mode_pkt);
+    //LOG_TRACE("[%s] Setting individual zone %1d to mode %02d", evgaGPUName, zone, mode);
+}
+
+void EVGAGPUv3Controller::SetZone(uint8_t zone, uint8_t mode, EVGAv3_config zone_config)
+{
+    std::string mode_name;
+    u16_to_u8   speed16                                 = { (uint16_t) zone_config.speed };
+
+    switch (mode)
+    {
+    case EVGA_GPU_V3_MODE_OFF:
+        break;
+
+    case EVGA_GPU_V3_MODE_STATIC:
+        {
+            uint8_t zone_pkt[5]     = {EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT};
+
+            zone_pkt[0]             = sizeof(zone_pkt) - 1;
+            zone_pkt[1]             = zone_config.brightness;
+            zone_pkt[2]             = RGBGetRValue(zone_config.colors[0]);
+            zone_pkt[3]             = RGBGetGValue(zone_config.colors[0]);
+            zone_pkt[4]             = RGBGetBValue(zone_config.colors[0]);
+
+            bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + zone, sizeof(zone_pkt), zone_pkt);
+        }
+        break;
+
+    case EVGA_GPU_V3_MODE_BREATHING:
+        {
+            uint8_t zone_pkt[10];
+            memset(zone_pkt, EVGAGPUV3_INIT, sizeof(zone_pkt));
+
+            zone_pkt[0]             = sizeof(zone_pkt) - 1;
+            zone_pkt[1]             = zone_config.brightness;
+            zone_pkt[2]             = RGBGetRValue(zone_config.colors[0]);
+            zone_pkt[3]             = RGBGetGValue(zone_config.colors[0]);
+            zone_pkt[4]             = RGBGetBValue(zone_config.colors[0]);
+            if(zone_config.numberOfColors == 1)
+            {
+                zone_config.colors[1] = 0;
+            }
+            zone_pkt[5]             = RGBGetRValue(zone_config.colors[1]);
+            zone_pkt[6]             = RGBGetGValue(zone_config.colors[1]);
+            zone_pkt[7]             = RGBGetBValue(zone_config.colors[1]);
+            zone_pkt[8]             = speed16.LSB;
+            zone_pkt[9]             = speed16.MSB;
+
+            bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, sizeof(zone_pkt), zone_pkt);
+        }
+        break;
+
+    case EVGA_GPU_V3_MODE_RAINBOW:
+    case EVGA_GPU_V3_MODE_RAINBOW_WAVE:
+    case EVGA_GPU_V3_MODE_STAR:
+        {
+            uint8_t zone_pkt[4];
+            memset(zone_pkt, EVGAGPUV3_INIT, sizeof(zone_pkt));
+
+            zone_pkt[0]             = sizeof(zone_pkt) - 1;
+            zone_pkt[1]             = zone_config.brightness;
+            zone_pkt[2]             = speed16.LSB;
+            zone_pkt[3]             = speed16.MSB;
+
+            bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, sizeof(zone_pkt), zone_pkt);
+        }
+        break;
+
+    case EVGA_GPU_V3_MODE_WAVE:
+        {
+            uint8_t zone_pkt[7];
+            memset(zone_pkt, EVGAGPUV3_INIT, sizeof(zone_pkt));
+
+            zone_pkt[0]             = sizeof(zone_pkt) - 1;
+            zone_pkt[1]             = zone_config.brightness;
+            zone_pkt[2]             = RGBGetRValue(zone_config.colors[0]);
+            zone_pkt[3]             = RGBGetGValue(zone_config.colors[0]);
+            zone_pkt[4]             = RGBGetBValue(zone_config.colors[0]);
+            zone_pkt[5]             = speed16.LSB;
+            zone_pkt[6]             = speed16.MSB;
+
+            bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, sizeof(zone_pkt), zone_pkt);
+        }
+        break;
+
+    case EVGA_GPU_V3_MODE_COLOR_CYCLE:
+    case EVGA_GPU_V3_MODE_COLOR_STACK:
+        {
+            uint8_t zone_pkt[31];;
+            memset(zone_pkt, EVGAGPUV3_INIT, sizeof(zone_pkt));
+            uint8_t color_cnt_pkt[5];
+            memset(color_cnt_pkt, EVGAGPUV3_INIT, sizeof(color_cnt_pkt));
+
+            // Zone packet construction
+            zone_pkt[0] = sizeof(zone_pkt) - 1;
+            for(uint8_t color_index = 0; color_index < zone_config.numberOfColors; color_index++)
+            {
+                zone_pkt[1 + color_index * 4] = zone_config.brightness;
+                zone_pkt[2 + color_index * 4] = RGBGetRValue(zone_config.colors[color_index]);
+                zone_pkt[3 + color_index * 4] = RGBGetGValue(zone_config.colors[color_index]);
+                zone_pkt[4 + color_index * 4] = RGBGetBValue(zone_config.colors[color_index]);
+            }
+            zone_pkt[29] = speed16.LSB;
+            zone_pkt[30] = speed16.MSB;
+
+            // Color Count packet construction
+            color_cnt_pkt[0]                = sizeof(color_cnt_pkt) - 1;
+            color_cnt_pkt[zone+1]           = zone_config.numberOfColors;
+
+            if(mode == EVGA_GPU_V3_MODE_COLOR_STACK)
+            {
+                uint8_t direction_pkt[5];
+                memset(direction_pkt, EVGAGPUV3_INIT, sizeof(direction_pkt));
+                // Direction packet construction
+                direction_pkt[0]            = sizeof(direction_pkt) - 1;
+                direction_pkt[zone+1]       = zone_config.direction;
+
+                bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, sizeof(zone_pkt), zone_pkt);
+                bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_COLOR_STACK_COLOR_COUNT, sizeof(color_cnt_pkt), color_cnt_pkt);
+                bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_COLOR_STACK_DIRECTION, sizeof(direction_pkt), direction_pkt);
+            }
+            else
+            {
+                bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, sizeof(zone_pkt), zone_pkt);
+                bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_COLOR_CYCLE_COUNT, sizeof(color_cnt_pkt), color_cnt_pkt);
+            }
+        }
+        break;
+    default:
+        {
+            LOG_TRACE("[%s] Mode %02d not found", evgaGPUName, mode);
+        }
+        break;
+    }
+}

Controllers/EVGAGPUController/EVGAGPUv3Controller.h

@@ -0,0 +1,117 @@
+/*-----------------------------------------*\
+|  EVGAGPUv3Controller.h                    |
+|                                           |
+|  Definitions and types for EVGA GPU RGB   |
+|  V3 (Ampere) lighting controller          |
+|                                           |
+|  TheRogueZeta                 7/15/2021   |
+\*-----------------------------------------*/
+
+#include <string>
+#include "i2c_smbus.h"
+#include "RGBController.h"
+#include "EVGAGPUCommon.h"
+
+#pragma once
+
+typedef unsigned char	evga_dev_id;
+
+#define SPEED_MULTIPLIER            10
+#define EVGAGPUV3_MODE_PACKET_SIZE  10
+#define EVGAGPUV3_LEDS_MIN          01
+#define EVGAGPUV3_LEDS_MAX          60
+#define EVGAGPUV3_INIT              0xFF
+#define EVGAGPUV3_CONTROLLER_NAME   "EVGAv3"
+
+struct EVGAv3_config
+{
+    uint8_t     brightness;
+    RGBColor    colors[7];
+    uint8_t     numberOfColors;
+    uint16_t    speed;
+    uint8_t     direction;
+};
+
+enum //Control registers and offsets
+{
+    EVGA_GPU_V3_REG_FIRMWARE                = 0xB1,
+    EVGA_GPU_V3_REG_ENABLE                  = 0xB2,
+    EVGA_GPU_V3_REG_MODE                    = 0xC0,
+    EVGA_GPU_V3_OFFSET_ZONE_1               = 0x00,
+    EVGA_GPU_V3_OFFSET_ZONE_2               = 0x01,
+    EVGA_GPU_V3_OFFSET_ZONE_3               = 0x02,
+    EVGA_GPU_V3_OFFSET_ZONE_4               = 0x03,
+    EVGA_GPU_V3_REG_STATIC                  = 0xC1,
+    EVGA_GPU_V3_REG_BREATHING               = 0xC5,
+    EVGA_GPU_V3_REG_RAINBOW                 = 0xC9,
+    EVGA_GPU_V3_REG_COLOR_CYCLE             = 0xCD,
+    EVGA_GPU_V3_REG_RAINBOW_WAVE            = 0xD1,
+    EVGA_GPU_V3_REG_WAVE                    = 0xD5,
+    EVGA_GPU_V3_REG_STAR                    = 0xD9,
+    EVGA_GPU_V3_REG_COLOR_STACK             = 0xDD,
+    EVGA_GPU_V3_REG_COLOR_CYCLE_COUNT       = 0xE5,
+    EVGA_GPU_V3_REG_COLOR_STACK_COLOR_COUNT = 0xE6,
+    EVGA_GPU_V3_REG_COLOR_STACK_DIRECTION   = 0xEB,
+    EVGA_GPU_V3_REG_SAVE                    = 0x90,
+};
+
+enum //Mode values for EVGA_GPU_V3_REG_MODE
+{
+    EVGA_GPU_V3_MODE_OFF                    = 0x00,
+    EVGA_GPU_V3_MODE_STATIC                 = 0x01, 
+    EVGA_GPU_V3_MODE_BREATHING              = 0x02,
+    EVGA_GPU_V3_MODE_RAINBOW                = 0x03,
+    EVGA_GPU_V3_MODE_COLOR_CYCLE            = 0x04,
+    EVGA_GPU_V3_MODE_RAINBOW_WAVE           = 0x05,
+    EVGA_GPU_V3_MODE_WAVE                   = 0x06,
+    EVGA_GPU_V3_MODE_STAR                   = 0x07,
+    EVGA_GPU_V3_MODE_COLOR_STACK            = 0x08,
+};
+
+enum // Value limits for speeds
+{
+    EVGA_GPU_V3_BRIGHTNESS_MIN              = 0x0,
+    EVGA_GPU_V3_BRIGHTNESS_DEFAULT          = 0xFF,
+    EVGA_GPU_V3_BRIGHTNESS_MAX              = 0xFF,
+    EVGA_GPU_V3_SPEED_GENERIC_SLOWEST       = 0x4E20, //20000
+    EVGA_GPU_V3_SPEED_GENERIC_NORMAL        = 0x1388, //5000
+    EVGA_GPU_V3_SPEED_GENERIC_FASTEST       = 0x03E8, //1000
+    EVGA_GPU_V3_SPEED_WAVE_SLOWEST          = 0x0148, //355
+    EVGA_GPU_V3_SPEED_WAVE_NORMAL           = 0x0028, //40
+    EVGA_GPU_V3_SPEED_WAVE_FASTEST          = 0x000A, //10
+    EVGA_GPU_V3_SPEED_STAR_SLOWEST          = 0x2710, //10000
+    EVGA_GPU_V3_SPEED_STAR_NORMAL           = 0x07D0, //2000
+    EVGA_GPU_V3_SPEED_STAR_FASTEST          = 0x01F4, //500
+};
+
+class EVGAGPUv3Controller
+{
+public:
+    EVGAGPUv3Controller(i2c_smbus_interface* bus, evga_dev_id dev);
+    ~EVGAGPUv3Controller();
+
+    uint8_t         zone_led_count[4];
+    uint8_t         zone_modes[4];
+    const char *    evgaGPUName;
+
+    std::string     GetDeviceLocation();
+    std::string     GetFWVersion();
+    std::string     ReadFWVersion();
+
+    void            GetDeviceModes();
+    uint8_t         GetZoneMode(uint8_t zone);
+    EVGAv3_config   GetZoneConfig(uint8_t zone, uint8_t mode);
+    void            SaveConfig();
+
+    void            ResizeARGB(uint8_t newSize);
+    void            SetAllModes(uint8_t zone0, uint8_t zone1, uint8_t zone2, uint8_t zone3, bool sync);
+    void            SetZoneMode(uint8_t zone, uint8_t mode);
+    void            SetZone(uint8_t zone, uint8_t mode, EVGAv3_config zone_config);
+
+private:
+    i2c_smbus_interface*    bus;
+    evga_dev_id             dev;
+    bool                    zone_sync;
+    void                    initCard();
+    std::string             fwVersion;
+};

Controllers/EVGAGPUController/RGBController_EVGAGP102.cpp

@@ -0,0 +1,146 @@
+/*-----------------------------------------*\
+|  RGBController_EVGAGPUv1.cpp              |
+|                                           |
+|  Generic RGB Interface for OpenRGB EVGA   |
+|  GP102-based Nvidia GPUs.                 |
+|                                           |
+|  Fabricio Murta (avengerx) 1/31/2021      |
+\*-----------------------------------------*/
+
+#include "RGBController_EVGAGP102.h"
+#include <array>
+
+RGBController_EVGAGP102::RGBController_EVGAGP102(std::vector<EVGAGP102Controller*> evga_ptr)
+{
+    evga = evga_ptr;
+
+    name        = "EVGA GP102 GPU";
+    vendor      = "EVGA";
+    description = "EVGA GP102-based RGB GPU Device";
+
+    for(unsigned int i = 0; i < zones.size(); i++)
+    {
+        location    += evga[i]->GetDeviceLocation() + " ";
+    }
+
+    type = DEVICE_TYPE_GPU;
+
+    mode Off;
+    Off.name       = "Off";
+    Off.value      = EVGA_GP102_MODE_OFF;
+    Off.flags      = 0;
+    Off.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = EVGA_GP102_MODE_CUSTOM;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+
+    // Initialize active mode and stored color
+
+    unsigned char raw_active_mode = evga[0]->GetMode();
+
+    active_mode = 0;
+    for(unsigned int i = 0; i < modes.size(); i++)
+    {
+        if (modes[i].value == raw_active_mode)
+        {
+            active_mode = i;
+            break;
+        }
+    }
+    for(unsigned int i = 0; i < zones.size(); i++)
+    {
+        std::array<unsigned char, 3> rgb = evga[i]->GetColor();
+
+        colors[i] = ToRGBColor(rgb[0], rgb[1], rgb[2]);
+    }
+}
+
+RGBController_EVGAGP102::~RGBController_EVGAGP102()
+{
+    for(unsigned int i = 0; i < evga.size(); i++)
+    {
+        delete evga[i];
+    }
+}
+
+void RGBController_EVGAGP102::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | This device basically has two controllable zones, one at  |
+    | the top of the board with GeForce 1080 Ti and another for |
+    | the backplate logo (K|NGP|N logo, or EVGA GeForce 1080 Ti |
+    | for the FTW3).
+    \*---------------------------------------------------------*/
+    for(unsigned int i = 0; i < evga.size(); i++)
+    {
+        zone new_zone;
+        led new_led;
+
+        new_zone.name          = evga[i]->GetName();
+        new_zone.type          = ZONE_TYPE_SINGLE;
+        new_zone.leds_min      = 1;
+        new_zone.leds_max      = 1;
+        new_zone.leds_count    = 1;
+        new_zone.matrix_map    = NULL;
+
+        new_led.name           = evga[i]->GetName();
+
+        leds.push_back(new_led);
+        zones.push_back(new_zone);
+    }
+
+    SetupColors();
+}
+
+void RGBController_EVGAGP102::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_EVGAGP102::DeviceUpdateLEDs()
+{
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        UpdateZoneLEDs(zone_idx);
+    }
+}
+
+void RGBController_EVGAGP102::UpdateZoneLEDs(int zone)
+{
+    RGBColor color    = colors[zone];
+    unsigned char red = RGBGetRValue(color);
+    unsigned char grn = RGBGetGValue(color);
+    unsigned char blu = RGBGetBValue(color);
+    evga[zone]->SetColor(red, grn, blu);
+}
+
+void RGBController_EVGAGP102::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_EVGAGP102::SetCustomMode()
+{
+    active_mode = 1;
+}
+
+void RGBController_EVGAGP102::DeviceUpdateMode()
+{
+    for (int i = 0; i < evga.size(); i++)
+    {
+        evga[i]->SetMode((unsigned char)modes[(unsigned int)active_mode].value);
+    }
+}
+
+void RGBController_EVGAGP102::DeviceSaveMode()
+{
+}

Controllers/EVGAGPUController/RGBController_EVGAGP102.h

@@ -0,0 +1,35 @@
+/*-----------------------------------------*\
+|  RGBController_EVGAGP102.h                |
+|                                           |
+|  EVGA Generic RGB Interface for OpenRGB   |
+|  EVGA GP102-based Nvidia GPUs.            |
+|                                           |
+|  Fabricio Murta (avengerx) 1/31/2021      |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "EVGAGP102Controller.h"
+
+class RGBController_EVGAGP102 : public RGBController
+{
+public:
+    RGBController_EVGAGP102(std::vector<EVGAGP102Controller*> evga_ptr);
+    ~RGBController_EVGAGP102();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    std::vector<EVGAGP102Controller*> evga;
+};

Controllers/EVGAGPUController/RGBController_EVGAGPUv1.cpp

@@ -23,28 +23,28 @@ RGBController_EVGAGPUv1::RGBController_EVGAGPUv1(EVGAGPUv1Controller* evga_ptr)
     mode Off;
     Off.name       = "Off";
     Off.value      = EVGA_GPU_V1_MODE_OFF;
-    Off.flags      = 0;
+    Off.flags      = MODE_FLAG_MANUAL_SAVE;
     Off.color_mode = MODE_COLORS_NONE;
     modes.push_back(Off);
 
     mode Direct;
     Direct.name       = "Direct";
     Direct.value      = EVGA_GPU_V1_MODE_CUSTOM;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
     Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Rainbow;
     Rainbow.name       = "Rainbow";
     Rainbow.value      = EVGA_GPU_V1_MODE_RAINBOW;
-    Rainbow.flags      = 0;
+    Rainbow.flags      = MODE_FLAG_MANUAL_SAVE;
     Rainbow.color_mode = MODE_COLORS_NONE;
     modes.push_back(Rainbow);
 
     mode Breathing;
     Breathing.name       = "Breathing";
     Breathing.value      = EVGA_GPU_V1_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
     Breathing.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Breathing);
 
@@ -140,3 +140,8 @@ void RGBController_EVGAGPUv1::DeviceUpdateMode()
 {
     evga->SetMode((unsigned char)modes[(unsigned int)active_mode].value);
 }
+
+void RGBController_EVGAGPUv1::DeviceSaveMode()
+{
+    evga->SaveSettings();
+}

Controllers/EVGAGPUController/RGBController_EVGAGPUv1.h

@@ -28,6 +28,7 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
     EVGAGPUv1Controller* evga;

Controllers/EVGAGPUController/RGBController_EVGAGPUv2.cpp

@@ -21,60 +21,64 @@ RGBController_EVGAGPUv2::RGBController_EVGAGPUv2(EVGAGPUv2Controller* evga_ptr)
     type = DEVICE_TYPE_GPU;
 
     mode Off;
-    Off.name                = "Off";
-    Off.value               = EVGA_GPU_V2_RGB_MODE_OFF;
-    Off.flags               = 0;  //pretty sure not needed
-    Off.color_mode          = MODE_COLORS_NONE;
+    Off.name                    = "Off";
+    Off.value                   = EVGA_GPU_V2_RGB_MODE_OFF;
+    Off.flags                   = 0;  //pretty sure not needed
+    Off.color_mode              = MODE_COLORS_NONE;
     modes.push_back(Off);
 
-    mode Direct;
-    Direct.name             = "Direct";
-    Direct.value            = EVGA_GPU_V2_RGB_MODE_DIRECT;
-    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode       = MODE_COLORS_PER_LED;
-    Direct.colors_min       = 1;
-    Direct.colors_max       = 1;
-    modes.push_back(Direct);
-
     mode Static;
-    Static.name             = "Static";
-    Static.value            = EVGA_GPU_V2_RGB_MODE_STATIC;
-    Static.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode       = MODE_COLORS_PER_LED;
-    Static.colors_min       = 1;
-    Static.colors_max       = 1;
+    Static.name                 = "Direct";
+    Static.value                = EVGA_GPU_V2_RGB_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Static.color_mode           = MODE_COLORS_PER_LED;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.brightness_min       = EVGA_GPU_V2_BRIGHTNESS_MIN;
+    Static.brightness           = EVGA_GPU_V2_BRIGHTNESS_DEFAULT;
+    Static.brightness_max       = EVGA_GPU_V2_BRIGHTNESS_MAX;
+
     modes.push_back(Static);
 
     mode Rainbow;
-    Rainbow.name            = "Spectrum Cycle";
-    Rainbow.value           = EVGA_GPU_V2_RGB_MODE_RAINBOW;
-    Rainbow.flags           = MODE_FLAG_HAS_BRIGHTNESS;
-    Rainbow.color_mode      = MODE_COLORS_NONE;
+    Rainbow.name                = "Spectrum Cycle";
+    Rainbow.value               = EVGA_GPU_V2_RGB_MODE_RAINBOW;
+    Rainbow.flags               = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    Rainbow.brightness_min      = EVGA_GPU_V2_BRIGHTNESS_MIN;
+    Rainbow.brightness          = EVGA_GPU_V2_BRIGHTNESS_DEFAULT;
+    Rainbow.brightness_max      = EVGA_GPU_V2_BRIGHTNESS_MAX;
     modes.push_back(Rainbow);
 
     mode Breathing;
-    Breathing.name          = "Breathing";
-    Breathing.value         = EVGA_GPU_V2_RGB_MODE_BREATHING;
-    Breathing.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Breathing.speed_min     = EVGA_GPU_V2_SPEED_BREATHING_SLOWEST;
-    Breathing.speed         = EVGA_GPU_V2_SPEED_BREATHING_NORMAL;
-    Breathing.speed_max     = EVGA_GPU_V2_SPEED_BREATHING_FASTEST;
-    Breathing.color_mode    = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors_min    = 1;
-    Breathing.colors_max    = 2;
+    Breathing.name              = "Breathing";
+    Breathing.value             = EVGA_GPU_V2_RGB_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Breathing.speed_min         = EVGA_GPU_V2_SPEED_BREATHING_SLOWEST;
+    Breathing.speed             = EVGA_GPU_V2_SPEED_BREATHING_NORMAL;
+    Breathing.speed_max         = EVGA_GPU_V2_SPEED_BREATHING_FASTEST;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.brightness_min    = EVGA_GPU_V2_BRIGHTNESS_MIN;
+    Breathing.brightness        = EVGA_GPU_V2_BRIGHTNESS_DEFAULT;
+    Breathing.brightness_max    = EVGA_GPU_V2_BRIGHTNESS_MAX;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 2;
     Breathing.colors.resize(1);
     modes.push_back(Breathing);
 
     mode Pulse;
-    Pulse.name              = "Flashing";
-    Pulse.value             = EVGA_GPU_V2_RGB_MODE_PULSE;
-    Pulse.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Pulse.speed_min         = EVGA_GPU_V2_SPEED_PULSE_SLOWEST;
-    Pulse.speed             = EVGA_GPU_V2_SPEED_PULSE_NORMAL;
-    Pulse.speed_max         = EVGA_GPU_V2_SPEED_PULSE_FASTEST;
-    Pulse.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Pulse.colors_min        = 1;
-    Pulse.colors_max        = 2;
+    Pulse.name                  = "Flashing";
+    Pulse.value                 = EVGA_GPU_V2_RGB_MODE_PULSE;
+    Pulse.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Pulse.speed_min             = EVGA_GPU_V2_SPEED_PULSE_SLOWEST;
+    Pulse.speed                 = EVGA_GPU_V2_SPEED_PULSE_NORMAL;
+    Pulse.speed_max             = EVGA_GPU_V2_SPEED_PULSE_FASTEST;
+    Pulse.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Pulse.colors_min            = 1;
+    Pulse.colors_max            = 2;
+    Pulse.brightness_min        = EVGA_GPU_V2_BRIGHTNESS_MIN;
+    Pulse.brightness            = EVGA_GPU_V2_BRIGHTNESS_DEFAULT;
+    Pulse.brightness_max        = EVGA_GPU_V2_BRIGHTNESS_MAX;
     Pulse.colors.resize(1);
     modes.push_back(Pulse);
 
@@ -108,6 +112,7 @@ RGBController_EVGAGPUv2::RGBController_EVGAGPUv2(EVGAGPUv2Controller* evga_ptr)
 
     // Load speed settings from the card:
     modes[active_mode].speed = evga->GetSpeed();
+    modes[active_mode].brightness = evga->GetBrightnessA();
 }
 
 RGBController_EVGAGPUv2::~RGBController_EVGAGPUv2()
@@ -169,7 +174,7 @@ void RGBController_EVGAGPUv2::DeviceUpdateLEDs()
     | modes and as such colorB will always be black (0x000000)  |
     \*---------------------------------------------------------*/
 
-    evga->SetColor(colors[0], 0, (modes[active_mode].value != EVGA_GPU_V2_RGB_MODE_DIRECT) );
+    evga->SetColor(colors[0], /* colorB*/ 0, modes[active_mode].brightness);
 }
 
 void RGBController_EVGAGPUv2::UpdateZoneLEDs(int /*zone*/)
@@ -184,7 +189,7 @@ void RGBController_EVGAGPUv2::UpdateSingleLED(int /*led*/)
 
 void RGBController_EVGAGPUv2::SetCustomMode()
 {
-    active_mode = getModeIndex(EVGA_GPU_V2_RGB_MODE_DIRECT);
+    active_mode = getModeIndex(EVGA_GPU_V2_RGB_MODE_STATIC);
 }
 
 void RGBController_EVGAGPUv2::DeviceUpdateMode()
@@ -204,5 +209,10 @@ void RGBController_EVGAGPUv2::DeviceUpdateMode()
         colorB = (modes[active_mode].colors.size() == 2) ? modes[active_mode].colors[1] : 0 ;
     }
     
-    evga->SetMode( modes[active_mode].value, colorA, colorB, modes[active_mode].speed);
+    evga->SetMode( modes[active_mode].value, colorA, colorB, modes[active_mode].speed, modes[active_mode].brightness);
+}
+
+void RGBController_EVGAGPUv2::DeviceSaveMode()
+{
+    evga->SaveSettings();
 }

Controllers/EVGAGPUController/RGBController_EVGAGPUv2.h

@@ -28,6 +28,7 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
     int         getModeIndex(unsigned char mode_value);

Controllers/EVGAGPUController/RGBController_EVGAGPUv3.cpp

@@ -0,0 +1,313 @@
+/*-----------------------------------------*\
+|  RGBController_EVGAGPUv3.cpp              |
+|                                           |
+|  Generic RGB Interface for OpenRGB EVGA   |
+|  GPU V3 (Ampere) Driver                   |
+|                                           |
+|  TheRogueZeta                 7/15/2021   |
+\*-----------------------------------------*/
+
+#include "RGBController_EVGAGPUv3.h"
+#include "LogManager.h"
+
+static const char* evga_v3_zone_names[] =
+{
+    "Front Logo",
+    "End plate Logo",
+    "Back Logo",
+    "Addressable Header"
+};
+
+RGBController_EVGAGPUv3::RGBController_EVGAGPUv3(EVGAGPUv3Controller* evga_ptr)
+{
+    evga = evga_ptr;
+
+    name                        = "EVGA GPU";
+    vendor                      = "EVGA";
+    description                 = "EVGA Ampere RGB GPU Device";
+    location                    = evga->GetDeviceLocation();
+    version                     = evga->GetFWVersion();
+
+    type = DEVICE_TYPE_GPU;
+
+    mode Off;
+    Off.name                    = "Off";
+    Off.value                   = EVGA_GPU_V3_MODE_OFF;
+    Off.flags                   = MODE_FLAG_MANUAL_SAVE;
+    Off.color_mode              = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Static;
+    Static.name                 = "Direct";
+    Static.value                = EVGA_GPU_V3_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Static.color_mode           = MODE_COLORS_PER_LED;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.brightness_min       = EVGA_GPU_V3_BRIGHTNESS_MIN;
+    Static.brightness           = EVGA_GPU_V3_BRIGHTNESS_DEFAULT;
+    Static.brightness_max       = EVGA_GPU_V3_BRIGHTNESS_MAX;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = EVGA_GPU_V3_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Breathing.speed_min         = EVGA_GPU_V3_SPEED_GENERIC_SLOWEST;
+    Breathing.speed             = EVGA_GPU_V3_SPEED_GENERIC_NORMAL;
+    Breathing.speed_max         = EVGA_GPU_V3_SPEED_GENERIC_FASTEST;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 2;
+    Breathing.colors.resize(1);
+    Breathing.brightness_min    = EVGA_GPU_V3_BRIGHTNESS_MIN;
+    Breathing.brightness        = EVGA_GPU_V3_BRIGHTNESS_DEFAULT;
+    Breathing.brightness_max    = EVGA_GPU_V3_BRIGHTNESS_MAX;
+    modes.push_back(Breathing);
+
+    mode Rainbow;
+    Rainbow.name                = "Spectrum Cycle";
+    Rainbow.value               = EVGA_GPU_V3_MODE_RAINBOW;
+    Rainbow.flags               = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Rainbow.speed_min           = EVGA_GPU_V3_SPEED_GENERIC_SLOWEST;
+    Rainbow.speed               = EVGA_GPU_V3_SPEED_GENERIC_NORMAL;
+    Rainbow.speed_max           = EVGA_GPU_V3_SPEED_GENERIC_FASTEST;
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    Rainbow.brightness_min      = EVGA_GPU_V3_BRIGHTNESS_MIN;
+    Rainbow.brightness          = EVGA_GPU_V3_BRIGHTNESS_DEFAULT;
+    Rainbow.brightness_max      = EVGA_GPU_V3_BRIGHTNESS_MAX;
+    modes.push_back(Rainbow);
+
+    mode Color_Cycle;
+    Color_Cycle.name            = "Color Cycle";
+    Color_Cycle.value           = EVGA_GPU_V3_MODE_COLOR_CYCLE;
+    Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Color_Cycle.speed_min       = EVGA_GPU_V3_SPEED_GENERIC_SLOWEST;
+    Color_Cycle.speed           = EVGA_GPU_V3_SPEED_GENERIC_NORMAL;
+    Color_Cycle.speed_max       = EVGA_GPU_V3_SPEED_GENERIC_FASTEST;
+    Color_Cycle.color_mode      = MODE_COLORS_MODE_SPECIFIC;
+    Color_Cycle.colors_min      = 2;
+    Color_Cycle.colors_max      = 7;
+    Color_Cycle.colors.resize(2);
+    Color_Cycle.brightness_min  = EVGA_GPU_V3_BRIGHTNESS_MIN;
+    Color_Cycle.brightness      = EVGA_GPU_V3_BRIGHTNESS_DEFAULT;
+    Color_Cycle.brightness_max  = EVGA_GPU_V3_BRIGHTNESS_MAX;
+    modes.push_back(Color_Cycle);
+
+    mode Rainbow_Wave;
+    Rainbow_Wave.name           = "Rainbow Wave";
+    Rainbow_Wave.value          = EVGA_GPU_V3_MODE_RAINBOW_WAVE;
+    Rainbow_Wave.flags          = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
+    Rainbow_Wave.speed_min      = EVGA_GPU_V3_SPEED_GENERIC_SLOWEST;
+    Rainbow_Wave.speed          = EVGA_GPU_V3_SPEED_GENERIC_NORMAL;
+    Rainbow_Wave.speed_max      = EVGA_GPU_V3_SPEED_GENERIC_FASTEST;
+    Rainbow_Wave.color_mode     = MODE_COLORS_NONE;
+    Rainbow_Wave.brightness_min = EVGA_GPU_V3_BRIGHTNESS_MIN;
+    Rainbow_Wave.brightness     = EVGA_GPU_V3_BRIGHTNESS_DEFAULT;
+    Rainbow_Wave.brightness_max = EVGA_GPU_V3_BRIGHTNESS_MAX;
+    modes.push_back(Rainbow_Wave);
+
+    mode Wave;
+    Wave.name                   = "Wave";
+    Wave.value                  = EVGA_GPU_V3_MODE_WAVE;
+    Wave.flags                  = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Wave.speed_min              = EVGA_GPU_V3_SPEED_WAVE_SLOWEST;
+    Wave.speed                  = EVGA_GPU_V3_SPEED_WAVE_NORMAL;
+    Wave.speed_max              = EVGA_GPU_V3_SPEED_WAVE_FASTEST;
+    Wave.color_mode             = MODE_COLORS_PER_LED;
+    Wave.brightness_min         = EVGA_GPU_V3_BRIGHTNESS_MIN;
+    Wave.brightness             = EVGA_GPU_V3_BRIGHTNESS_DEFAULT;
+    Wave.brightness_max         = EVGA_GPU_V3_BRIGHTNESS_MAX;
+    modes.push_back(Wave);
+
+    mode Star;
+    Star.name                   = "Star";
+    Star.value                  = EVGA_GPU_V3_MODE_STAR;
+    Star.flags                  = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Star.speed_min              = EVGA_GPU_V3_SPEED_STAR_SLOWEST;
+    Star.speed                  = EVGA_GPU_V3_SPEED_STAR_NORMAL;
+    Star.speed_max              = EVGA_GPU_V3_SPEED_STAR_FASTEST;
+    Star.color_mode             = MODE_COLORS_NONE;
+    Star.brightness_min         = EVGA_GPU_V3_BRIGHTNESS_MIN;
+    Star.brightness             = EVGA_GPU_V3_BRIGHTNESS_DEFAULT;
+    Star.brightness_max         = EVGA_GPU_V3_BRIGHTNESS_MAX;
+    modes.push_back(Star);
+
+    mode Color_Stack;
+    Color_Stack.name            = "Color Stack";
+    Color_Stack.value           = EVGA_GPU_V3_MODE_COLOR_STACK;
+    Color_Stack.flags           = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Color_Stack.speed_min       = EVGA_GPU_V3_SPEED_WAVE_SLOWEST;
+    Color_Stack.speed           = EVGA_GPU_V3_SPEED_WAVE_NORMAL;
+    Color_Stack.speed_max       = EVGA_GPU_V3_SPEED_WAVE_FASTEST;
+    Color_Stack.color_mode      = MODE_COLORS_MODE_SPECIFIC;
+    Color_Stack.colors_min      = 2;
+    Color_Stack.colors_max      = 7;
+    Color_Stack.colors.resize(2);
+    Color_Stack.brightness_min  = EVGA_GPU_V3_BRIGHTNESS_MIN;
+    Color_Stack.brightness      = EVGA_GPU_V3_BRIGHTNESS_DEFAULT;
+    Color_Stack.brightness_max  = EVGA_GPU_V3_BRIGHTNESS_MAX;
+    modes.push_back(Color_Stack);
+
+
+    SetupZones();
+
+    // Initialize active mode
+    for( uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
+    {
+        active_mode = evga->GetZoneMode(0); // Hard coding zone 0 until per zone modes are available.
+        
+        if(active_mode != EVGA_GPU_V3_MODE_OFF)
+        {
+            EVGAv3_config hw_config = evga->GetZoneConfig(zoneIndexMap[zone_idx], active_mode);
+
+            /*---------------------------------------------------------*\
+            | The LED color (color[0]) will always be set. Mode colors  |
+            | are only set for the MODE_COLORS_MODE_SPECIFIC modes      |
+            \*---------------------------------------------------------*/
+
+            zones[zone_idx].colors[0]           = hw_config.colors[0];
+
+            if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && zone_idx == 0) // Hard coding zone 0 until per zone modes are available.
+            {
+                for( uint8_t j = 0 ; j < hw_config.numberOfColors; j ++)
+                {
+                    if(modes[active_mode].colors.size() > j)
+                    {
+                        modes[active_mode].colors[j] = hw_config.colors[j];
+                    }
+                    else
+                    {
+                        modes[active_mode].colors.push_back(hw_config.colors[j]);
+                    }
+                }
+            }
+
+            modes[active_mode].speed        = hw_config.speed;
+            modes[active_mode].brightness   = hw_config.brightness;
+            modes[active_mode].direction    = hw_config.direction;
+        }
+    }
+}
+
+RGBController_EVGAGPUv3::~RGBController_EVGAGPUv3()
+{
+    delete evga;
+}
+
+uint8_t RGBController_EVGAGPUv3::getModeIndex(uint8_t mode_value)
+{
+    for(uint8_t mode_index = 0; mode_index < modes.size(); mode_index++)
+    {
+        if (modes[mode_index].value == mode_value)
+        {
+            return mode_index;
+        }
+    }
+    return 0;
+}
+
+void RGBController_EVGAGPUv3::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | This device only allows setting the entire zone for all   |
+    | LED's in the zone and does not allow per LED control.     |
+    | Resizing is only possible on zone 4, addressable header   |
+    \*---------------------------------------------------------*/
+
+    evga->GetDeviceModes();
+
+    for(uint8_t zone_idx = 0; zone_idx < 4; zone_idx++)
+    {
+        if(evga->zone_led_count[zone_idx] > 0)
+        {
+            zone* new_zone = new zone();
+            led*  new_led  = new led();
+
+            new_zone->name          = evga_v3_zone_names[zone_idx];
+            new_zone->type          = ZONE_TYPE_SINGLE;
+            new_zone->leds_min      = 1;
+            new_zone->leds_max      = 1;
+            new_zone->leds_count    = 1;
+            new_zone->matrix_map    = NULL;
+
+            new_led->name           = evga_v3_zone_names[zone_idx];
+            /*---------------------------------------------------------*\
+            | Push the zone and LED on to device vectors                |
+            \*---------------------------------------------------------*/
+            leds.push_back(*new_led);
+            zones.push_back(*new_zone);
+            zoneIndexMap.push_back(zone_idx);
+        }
+    }
+    SetupColors();
+}
+
+void RGBController_EVGAGPUv3::ResizeZone(int /*zone*/, int newSize)
+{
+    evga->ResizeARGB(newSize);
+}
+
+void RGBController_EVGAGPUv3::DeviceUpdateLEDs()
+{
+    /*---------------------------------------------------------*\
+    | DeviceUpdateLEDs() is only used in MODE_COLORS_PER_LED    |
+    | modes and as such colorB will always be black (0x000000)  |
+    \*---------------------------------------------------------*/
+    EVGAv3_config zone_config;
+    
+    zone_config.brightness      = modes[active_mode].brightness;
+    zone_config.speed           = modes[active_mode].speed;
+    zone_config.direction       = modes[active_mode].direction;
+    zone_config.numberOfColors  = (uint8_t) modes[active_mode].colors.size();
+
+    for(uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
+    {
+        zone_config.colors[0] = colors[zone_idx];
+
+        if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+        {
+            for( uint8_t i = 0 ; i < zone_config.numberOfColors; i ++)
+            {
+                zone_config.colors[i] = modes[active_mode].colors[i];
+            }
+        }
+        //LOG_TRACE("[%s] Updating LED %1d", evga->evgaGPUName, zone_idx);
+        evga->SetZone(zoneIndexMap[zone_idx], modes[active_mode].value, zone_config);
+    }
+}
+
+void RGBController_EVGAGPUv3::UpdateZoneLEDs(int /*zone*/ zone)
+{
+    //LOG_TRACE("[%s] Updating zone %1d", evga->evgaGPUName, zone);
+    DeviceUpdateLEDs();
+}
+
+void RGBController_EVGAGPUv3::UpdateSingleLED(int /*led*/ led)
+{
+    //LOG_TRACE("[%s] Updating single LED %1d", evga->evgaGPUName, led);
+    DeviceUpdateLEDs();
+}
+
+void RGBController_EVGAGPUv3::SetCustomMode()
+{
+    active_mode = getModeIndex(EVGA_GPU_V3_MODE_STATIC);
+}
+
+void RGBController_EVGAGPUv3::DeviceUpdateMode()
+{
+    /* Update all zone modes in a loop, each one with a packet to be use with per zone control
+    for(uint8_t zone = 0; zone < 4; zone++)
+    {
+        evga->SetZoneMode(zone, modes[active_mode].value);
+    } 
+    */
+    //LOG_TRACE("[%s] Updating to mode %1d", evga->evgaGPUName, modes[active_mode].value);
+    DeviceUpdateLEDs();
+    evga->SetAllModes(modes[active_mode].value, modes[active_mode].value, modes[active_mode].value,modes[active_mode].value, true); //Set all zones to the same mode
+}
+
+void RGBController_EVGAGPUv3::DeviceSaveMode()
+{
+    evga->SaveConfig();
+}

Controllers/EVGAGPUController/RGBController_EVGAGPUv3.h

@@ -0,0 +1,37 @@
+/*-----------------------------------------*\
+|  RGBController_EVGAGPUv3.h                |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  EVGA GPU RGB V3 (Ampere) Driver          |
+|                                           |
+|  TheRogueZeta                 7/15/2021   |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "EVGAGPUv3Controller.h"
+
+class RGBController_EVGAGPUv3 : public RGBController
+{
+public:
+    RGBController_EVGAGPUv3(EVGAGPUv3Controller* evga_ptr);
+    ~RGBController_EVGAGPUv3();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+    void        DeviceSaveMode();
+
+private:
+    uint8_t     getModeIndex(uint8_t mode_value);
+    EVGAGPUv3Controller* evga;
+    std::vector<uint8_t> zoneIndexMap;
+};

Controllers/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusController.cpp

@@ -99,6 +99,7 @@ void RGBFusion2SMBusController::SetLEDEffect
     (
     unsigned int    led,
     int             mode,
+    unsigned int    brightness,
     unsigned int    speed,
     unsigned char   red,
     unsigned char   green,
@@ -123,59 +124,62 @@ void RGBFusion2SMBusController::SetLEDEffect
         break;
 
         case RGB_FUSION_2_MODE_DIGITAL_WAVE:
-        // Timer 1: On time
-        // Timer 2: Off time
-        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x50 * speed;
-        led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x01;
+        // Timer 1: Wave Speed
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00;
+        led_data[led][RGB_FUSION_2_IDX_BRIGHTNESS]  = brightness;
         break;
 
         case RGB_FUSION_2_MODE_DIGITAL_A:
         // Timer 1: Directly controls speed of LED sections
-        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x39 * speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed;
         led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00;  // Setting this to any number other than 0 slows down the effect
         led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x01;    // Doesn't do anything, but always defaults to 0x01
         break;
 
         case RGB_FUSION_2_MODE_DIGITAL_B:
         // Timer 1: Direct control of section speed and pulsing
-        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x2d * speed; // Main effect speed
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed; // Main effect speed
         led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00;         // Only sets to 0x01 in min speed. Makes light section blink for shorter periods
-        led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04;           // Changes between 0x01 and 0x04 along with speed. Controls light trail length.
+        led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x05 - (speed / 60);           // Changes between 0x01 and 0x04 along with speed. Controls light trail length.
         break;
 
         case RGB_FUSION_2_MODE_DIGITAL_C:
         // Timer 1: Effect Speed
-        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x2d * speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed;
         led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00;  // Like Digital A, slows down the effect, but never sets to another number.
         led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04;    // Fixed at 0x04. Does nothing.
         break;
 
         case RGB_FUSION_2_MODE_DIGITAL_D:
         // Timer 1: Effect Speed
-        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x2d * speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed;
         led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00;  // Like Digital A, slows down the effect, but never sets to another number.
         led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04;    // Fixed at 0x04. Does nothing.
+        led_data[led][RGB_FUSION_2_IDX_BRIGHTNESS]  = brightness;
         break;
 
         case RGB_FUSION_2_MODE_DIGITAL_E:
         // Timer 1: Effect Speed
-        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x25 * speed;
-        led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0;     // Like Digital A, slows down the effect, but never sets to another number.
-        led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04;    // Fixed at 0x04. Does nothing.
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0;  // Like Digital A, slows down the effect, but never sets to another number.
+        led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x05 - (speed / 50); // Changes between 0x02 and 0x04 according to speed, might be similar to Digital B.
         break;
 
         case RGB_FUSION_2_MODE_DIGITAL_F:
         // Timer 1: Effect Speed
-        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x2d * speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed;
         led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00;  // Like Digital A, slows down the effect, but never sets to another number.
         led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04;    // Fixed at 0x04. Does nothing.
+        led_data[led][RGB_FUSION_2_IDX_BRIGHTNESS]  = brightness;
         break;
 
         case RGB_FUSION_2_MODE_DIGITAL_G:
         // Timer 1: Effect Speed
-        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x23 * speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed;
         led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00;  // Like Digital A, slows down the effect, but never sets to another number.
         led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04;    // Fixed at 0x04. Does nothing.
+        led_data[led][RGB_FUSION_2_IDX_BRIGHTNESS]  = brightness;
         break;
 
         case RGB_FUSION_2_MODE_COLOR_CYCLE:
@@ -184,6 +188,7 @@ void RGBFusion2SMBusController::SetLEDEffect
             led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x03 * speed;
             led_data[led][RGB_FUSION_2_IDX_OPT_1]   = 0x07;		// Number of colors to cycle through. Valid range [1-7]
             led_data[led][RGB_FUSION_2_IDX_OPT_2]   = 0x00;		// Color cycle, or color cycle and pulse. [0,1]
+            led_data[led][RGB_FUSION_2_IDX_BRIGHTNESS]  = brightness;
         break;
 
         case RGB_FUSION_2_MODE_FLASHING:

Controllers/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusController.h

@@ -71,6 +71,15 @@ enum
     RGB_FUSION_2_SPEED_FAST         = 0x01,
     RGB_FUSION_2_SPEED_NORMAL       = 0x02,
     RGB_FUSION_2_SPEED_SLOW         = 0x04,
+    RGB_FUSION_2_DIGITAL_SPEED      = 0x91,
+    RGB_FUSION_2_DIGITAL_SPEED_MIN  = 0xe6,
+    RGB_FUSION_2_DIGITAL_SPEED_MAX  = 0x32,
+};
+
+enum
+{
+    RGB_FUSION_2_BRIGHTNESS_MAX     = 0x64,
+    RGB_FUSION_2_BRIGHTNESS_MIN     = 0x0f,
 };
 
 class RGBFusion2SMBusController
@@ -88,6 +97,7 @@ public:
                         (
                         unsigned int    led,
                         int             mode,
+                        unsigned int    brightness,
                         unsigned int    speed,
                         unsigned char   red,
                         unsigned char   green,

Controllers/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusControllerDetect.cpp

@@ -1,5 +1,6 @@
 #include "Detector.h"
 #include "GigabyteRGBFusion2SMBusController.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_GigabyteRGBFusion2SMBus.h"
 #include "i2c_smbus.h"
@@ -9,8 +10,10 @@
 #include <stdlib.h>
 #include <string>
 #include "dependencies/dmiinfo.h"
-#define DETECTOR_NAME "Gigabyte RGB Fusion 2 SMBus"
-#define VENDOR_NAME "Gigabyte Technology Co., Ltd."
+
+#define DETECTOR_NAME   "Gigabyte RGB Fusion 2 SMBus"
+#define VENDOR_NAME     "Gigabyte Technology Co., Ltd."
+#define SMBUS_ADDRESS   0x68
 
 typedef struct
 {
@@ -113,19 +116,27 @@ void DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>&
         {
             IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
             {
-                // TODO - Is this necessary? Or an artifact of my own system?
-                // Skip dmcd devices
-                std::string device_name = std::string(busses[bus]->device_name);
-                if (device_name.find("dmdc") == std::string::npos)
+                if(busses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
                 {
-                    // Check for RGB Fusion 2 controller at 0x68
-                    if (TestForGigabyteRGBFusion2SMBusController(busses[bus], 0x68))
+                    // TODO - Is this necessary? Or an artifact of my own system?
+                    // Skip dmcd devices
+                    std::string device_name = std::string(busses[bus]->device_name);
+                    if (device_name.find("dmdc") == std::string::npos)
                     {
-                        new_rgb_fusion = new RGBFusion2SMBusController(busses[bus], 0x68, dmi.getMainboard() );
-                        new_controller = new RGBController_RGBFusion2SMBus(new_rgb_fusion);
-                        ResourceManager::get()->RegisterRGBController(new_controller);
+                        LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
+                        // Check for RGB Fusion 2 controller at 0x68
+                        if (TestForGigabyteRGBFusion2SMBusController(busses[bus], SMBUS_ADDRESS))
+                        {
+                            new_rgb_fusion = new RGBFusion2SMBusController(busses[bus], SMBUS_ADDRESS, dmi.getMainboard() );
+                            new_controller = new RGBController_RGBFusion2SMBus(new_rgb_fusion);
+                            ResourceManager::get()->RegisterRGBController(new_controller);
+                        }
                     }
                 }
+                else
+                {
+                    LOG_DEBUG(SMBUS_CHECK_DEVICE_FAILURE_EN, DETECTOR_NAME, bus, VENDOR_NAME);
+                }
             }
         }
     }

Controllers/GigabyteRGBFusion2SMBusController/RGBController_GigabyteRGBFusion2SMBus.cpp

@@ -76,32 +76,38 @@ RGBController_RGBFusion2SMBus::RGBController_RGBFusion2SMBus(RGBFusion2SMBusCont
     modes.push_back(Flashing);
 
     mode ColorCycle;
-    ColorCycle.name       = "Color Cycle";
-    ColorCycle.value      = RGB_FUSION_2_MODE_COLOR_CYCLE;
-    ColorCycle.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    ColorCycle.speed_min  = RGB_FUSION_2_SPEED_SLOW;
-    ColorCycle.speed_max  = RGB_FUSION_2_SPEED_FAST;
-    ColorCycle.speed      = RGB_FUSION_2_SPEED_NORMAL;
-    ColorCycle.color_mode = MODE_COLORS_PER_LED;
+    ColorCycle.name           = "Color Cycle";
+    ColorCycle.value          = RGB_FUSION_2_MODE_COLOR_CYCLE;
+    ColorCycle.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    ColorCycle.speed_min      = RGB_FUSION_2_SPEED_SLOW;
+    ColorCycle.speed_max      = RGB_FUSION_2_SPEED_FAST;
+    ColorCycle.speed          = RGB_FUSION_2_SPEED_NORMAL;
+    ColorCycle.brightness_min = RGB_FUSION_2_BRIGHTNESS_MIN;
+    ColorCycle.brightness_max = RGB_FUSION_2_BRIGHTNESS_MAX;
+    ColorCycle.brightness     = RGB_FUSION_2_BRIGHTNESS_MAX;
+    ColorCycle.color_mode     = MODE_COLORS_PER_LED;
     modes.push_back(ColorCycle);
 
     mode DigitalWave;
-    DigitalWave.name       = "Digital Wave";
-    DigitalWave.value      = RGB_FUSION_2_MODE_DIGITAL_WAVE;
-    DigitalWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    DigitalWave.speed_min  = RGB_FUSION_2_SPEED_SLOW;
-    DigitalWave.speed_max  = RGB_FUSION_2_SPEED_FAST;
-    DigitalWave.speed      = RGB_FUSION_2_SPEED_NORMAL;
-    DigitalWave.color_mode = MODE_COLORS_PER_LED;
+    DigitalWave.name           = "Digital Wave";
+    DigitalWave.value          = RGB_FUSION_2_MODE_DIGITAL_WAVE;
+    DigitalWave.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    DigitalWave.speed_min      = 0xff;
+    DigitalWave.speed_max      = 0x49;
+    DigitalWave.speed          = 0xc1;
+    DigitalWave.brightness_min = RGB_FUSION_2_BRIGHTNESS_MIN;
+    DigitalWave.brightness_max = RGB_FUSION_2_BRIGHTNESS_MAX;
+    DigitalWave.brightness     = RGB_FUSION_2_BRIGHTNESS_MAX;
+    DigitalWave.color_mode     = MODE_COLORS_PER_LED;
     modes.push_back(DigitalWave);
 
     mode DigitalA;
     DigitalA.name       = "Digital A";
     DigitalA.value      = RGB_FUSION_2_MODE_DIGITAL_A;
     DigitalA.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    DigitalA.speed_min  = RGB_FUSION_2_SPEED_SLOW;
-    DigitalA.speed_max  = RGB_FUSION_2_SPEED_FAST;
-    DigitalA.speed      = RGB_FUSION_2_SPEED_NORMAL;
+    DigitalA.speed_min  = RGB_FUSION_2_DIGITAL_SPEED_MIN;
+    DigitalA.speed_max  = RGB_FUSION_2_DIGITAL_SPEED_MAX;
+    DigitalA.speed      = RGB_FUSION_2_DIGITAL_SPEED;
     DigitalA.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(DigitalA);
 
@@ -109,9 +115,9 @@ RGBController_RGBFusion2SMBus::RGBController_RGBFusion2SMBus(RGBFusion2SMBusCont
     DigitalB.name       = "Digital B";
     DigitalB.value      = RGB_FUSION_2_MODE_DIGITAL_B;
     DigitalB.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    DigitalB.speed_min  = RGB_FUSION_2_SPEED_SLOW;
-    DigitalB.speed_max  = RGB_FUSION_2_SPEED_FAST;
-    DigitalB.speed      = RGB_FUSION_2_SPEED_NORMAL;
+    DigitalB.speed_min  = 0xf0;
+    DigitalB.speed_max  = 0x3c;
+    DigitalB.speed      = 0xa0;
     DigitalB.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(DigitalB);
 
@@ -119,50 +125,59 @@ RGBController_RGBFusion2SMBus::RGBController_RGBFusion2SMBus(RGBFusion2SMBusCont
     DigitalC.name       = "Digital C";
     DigitalC.value      = RGB_FUSION_2_MODE_DIGITAL_C;
     DigitalC.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    DigitalC.speed_min  = RGB_FUSION_2_SPEED_SLOW;
-    DigitalC.speed_max  = RGB_FUSION_2_SPEED_FAST;
-    DigitalC.speed      = RGB_FUSION_2_SPEED_NORMAL;
+    DigitalC.speed_min  = RGB_FUSION_2_DIGITAL_SPEED_MIN;
+    DigitalC.speed_max  = RGB_FUSION_2_DIGITAL_SPEED_MAX;
+    DigitalC.speed      = RGB_FUSION_2_DIGITAL_SPEED;
     DigitalC.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(DigitalC);
 
     mode DigitalD;
-    DigitalD.name       = "Digital D";
-    DigitalD.value      = RGB_FUSION_2_MODE_DIGITAL_D;
-    DigitalD.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    DigitalD.speed_min  = RGB_FUSION_2_SPEED_SLOW;
-    DigitalD.speed_max  = RGB_FUSION_2_SPEED_FAST;
-    DigitalD.speed      = RGB_FUSION_2_SPEED_NORMAL;
-    DigitalD.color_mode = MODE_COLORS_PER_LED;
+    DigitalD.name           = "Digital D";
+    DigitalD.value          = RGB_FUSION_2_MODE_DIGITAL_D;
+    DigitalD.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    DigitalD.speed_min      = RGB_FUSION_2_DIGITAL_SPEED_MIN;
+    DigitalD.speed_max      = RGB_FUSION_2_DIGITAL_SPEED_MAX;
+    DigitalD.speed          = RGB_FUSION_2_DIGITAL_SPEED;
+    DigitalD.brightness_min = RGB_FUSION_2_BRIGHTNESS_MIN;
+    DigitalD.brightness_max = RGB_FUSION_2_BRIGHTNESS_MAX;
+    DigitalD.brightness     = RGB_FUSION_2_BRIGHTNESS_MAX;
+    DigitalD.color_mode     = MODE_COLORS_PER_LED;
     modes.push_back(DigitalD);
 
     mode DigitalE;
     DigitalE.name       = "Digital E";
     DigitalE.value      = RGB_FUSION_2_MODE_DIGITAL_E;
     DigitalE.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    DigitalE.speed_min  = RGB_FUSION_2_SPEED_SLOW;
-    DigitalE.speed_max  = RGB_FUSION_2_SPEED_FAST;
-    DigitalE.speed      = RGB_FUSION_2_SPEED_NORMAL;
+    DigitalE.speed_min  = 0x96;
+    DigitalE.speed_max  = RGB_FUSION_2_DIGITAL_SPEED_MAX;
+    DigitalE.speed      = 0x6e;
     DigitalE.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(DigitalE);
 
     mode DigitalF;
-    DigitalF.name       = "Digital F";
-    DigitalF.value      = RGB_FUSION_2_MODE_DIGITAL_F;
-    DigitalF.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    DigitalF.speed_min  = RGB_FUSION_2_SPEED_SLOW;
-    DigitalF.speed_max  = RGB_FUSION_2_SPEED_FAST;
-    DigitalF.speed      = RGB_FUSION_2_SPEED_NORMAL;
-    DigitalF.color_mode = MODE_COLORS_PER_LED;
+    DigitalF.name           = "Digital F";
+    DigitalF.value          = RGB_FUSION_2_MODE_DIGITAL_F;
+    DigitalF.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS; // F technically needs brightness when in color cycle mode (no color selected)
+    DigitalF.speed_min      = RGB_FUSION_2_DIGITAL_SPEED_MIN;
+    DigitalF.speed_max      = RGB_FUSION_2_DIGITAL_SPEED_MAX;
+    DigitalF.speed          = RGB_FUSION_2_DIGITAL_SPEED;
+    DigitalF.brightness_min = RGB_FUSION_2_BRIGHTNESS_MIN;
+    DigitalF.brightness_max = RGB_FUSION_2_BRIGHTNESS_MAX;
+    DigitalF.brightness     = RGB_FUSION_2_BRIGHTNESS_MAX;
+    DigitalF.color_mode     = MODE_COLORS_PER_LED;
     modes.push_back(DigitalF);
 
     mode DigitalG;
-    DigitalG.name       = "Digital G";
-    DigitalG.value      = RGB_FUSION_2_MODE_DIGITAL_G;
-    DigitalG.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    DigitalG.speed_min  = RGB_FUSION_2_SPEED_SLOW;
-    DigitalG.speed_max  = RGB_FUSION_2_SPEED_FAST;
-    DigitalG.speed      = RGB_FUSION_2_SPEED_NORMAL;
-    DigitalG.color_mode = MODE_COLORS_PER_LED;
+    DigitalG.name           = "Digital G";
+    DigitalG.value          = RGB_FUSION_2_MODE_DIGITAL_G;
+    DigitalG.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    DigitalG.speed_min      = 0x8c;
+    DigitalG.speed_max      = 0x46;
+    DigitalG.speed          = 0x6e;
+    DigitalG.brightness_min = RGB_FUSION_2_BRIGHTNESS_MIN;
+    DigitalG.brightness_max = RGB_FUSION_2_BRIGHTNESS_MAX;
+    DigitalG.brightness     = RGB_FUSION_2_BRIGHTNESS_MAX;
+    DigitalG.color_mode     = MODE_COLORS_PER_LED;
     modes.push_back(DigitalG);
 
     SetupZones();
@@ -229,8 +244,9 @@ void RGBController_RGBFusion2SMBus::DeviceUpdateLEDs()
 
         int mode = modes[active_mode].value;
         unsigned int speed = modes[active_mode].speed;
+        unsigned int brightness = modes[active_mode].brightness;
 
-        rgb_fusion->SetLEDEffect(led, mode, speed, red, grn, blu);
+        rgb_fusion->SetLEDEffect(led, mode, brightness, speed, red, grn, blu);
     }
 
     rgb_fusion->Apply();
@@ -245,8 +261,9 @@ void RGBController_RGBFusion2SMBus::UpdateZoneLEDs(int zone)
 
     int mode = modes[active_mode].value;
     unsigned int speed = modes[active_mode].speed;
+    unsigned int brightness = modes[active_mode].brightness;
 
-    rgb_fusion->SetLEDEffect(zone, mode, speed, red, grn, blu);
+    rgb_fusion->SetLEDEffect(zone, mode, brightness, speed, red, grn, blu);
     rgb_fusion->Apply();
 }
 

Controllers/GigabyteRGBFusionController/GigabyteRGBFusionControllerDetect.cpp

@@ -1,5 +1,6 @@
 #include "Detector.h"
 #include "GigabyteRGBFusionController.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_GigabyteRGBFusion.h"
 #include "i2c_smbus.h"
@@ -8,6 +9,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#define DETECTOR_NAME   "Gigabyte RGB Fusion SMBus"
+#define VENDOR_NAME     "Gigabyte Technology Co., Ltd."
+#define SMBUS_ADDRESS   0x28
+
 /******************************************************************************************\
 *                                                                                          *
 *   TestForGigabyteRGBFusionController                                                     *
@@ -59,16 +64,23 @@ void DetectGigabyteRGBFusionControllers(std::vector<i2c_smbus_interface*>& busse
     {
         IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            // Check for RGB Fusion controller at 0x28
-            if (TestForGigabyteRGBFusionController(busses[bus], 0x28))
+            if(busses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
             {
-                new_rgb_fusion = new RGBFusionController(busses[bus], 0x28);
-                new_controller = new RGBController_RGBFusion(new_rgb_fusion);
-                ResourceManager::get()->RegisterRGBController(new_controller);
+                LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
+                // Check for RGB Fusion controller at 0x28
+                if (TestForGigabyteRGBFusionController(busses[bus], SMBUS_ADDRESS))
+                {
+                    new_rgb_fusion = new RGBFusionController(busses[bus], SMBUS_ADDRESS);
+                    new_controller = new RGBController_RGBFusion(new_rgb_fusion);
+                    ResourceManager::get()->RegisterRGBController(new_controller);
+                }
+            }
+            else
+            {
+                LOG_DEBUG(SMBUS_CHECK_DEVICE_FAILURE_EN, DETECTOR_NAME, bus, VENDOR_NAME);
             }
         }
     }
-
 }   /* DetectGigabyteRGBFusionControllers() */
 
 REGISTER_I2C_DETECTOR("Gigabyte RGB Fusion", DetectGigabyteRGBFusionControllers);

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUController.cpp

@@ -63,3 +63,20 @@ void RGBFusionGPUController::SetMode(unsigned char mode, unsigned char speed, un
         bus->i2c_smbus_write_byte(dev, 0x00);
     }
 }
+
+void RGBFusionGPUController::Save()
+{
+    bus->i2c_smbus_write_byte(dev, RGB_FUSION_GPU_REG_SAVE);
+    bus->i2c_smbus_write_byte(dev, 0x00);
+    bus->i2c_smbus_write_byte(dev, 0x00);
+    bus->i2c_smbus_write_byte(dev, 0x00);
+
+    // Pad commands with 4 zero-bytes for NVIDIA_RTX3060_DEV
+    if (dev == 0x62)
+    {
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+    }
+}

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUController.h

@@ -17,7 +17,8 @@ typedef unsigned char	rgb_fusion_dev_id;
 enum
 {
     RGB_FUSION_GPU_REG_COLOR            = 0x40,
-    RGB_FUSION_GPU_REG_MODE             = 0x88
+    RGB_FUSION_GPU_REG_MODE             = 0x88,
+    RGB_FUSION_GPU_REG_SAVE             = 0xAA,
 };
 
 enum
@@ -52,6 +53,7 @@ public:
 
     void            SetColor(unsigned char red, unsigned char green, unsigned char blue);
     void            SetMode(unsigned char mode, unsigned char speed, unsigned char brightness);
+    void            Save();
 
 private:
     i2c_smbus_interface*    bus;

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUControllerDetect.cpp

@@ -1,5 +1,6 @@
 #include "Detector.h"
 #include "GigabyteRGBFusionGPUController.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_GigabyteRGBFusionGPU.h"
 #include "i2c_smbus.h"
@@ -18,13 +19,15 @@ typedef struct
     const char *    name;
 } gpu_pci_device;
 
+#define GIGABYTEGPU_CONTROLLER_NAME "Gigabyte RGB Fusion GPU"
 #define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
 
 static const gpu_pci_device device_list[] =
 {
     { NVIDIA_VEN,   NVIDIA_GTX1050TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1050TI_G1_GAMING_SUB_DEV,           0x48,   "Gigabyte GTX1050 Ti G1 Gaming"                 },
     { NVIDIA_VEN,   NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_G1_GAMING_OC_SUB_DEV,          0x47,   "Gigabyte GTX1060 G1 Gaming 6G OC"              },
-    { NVIDIA_VEN,   NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_XTREME_SUB_DEV,                0x47,   "Gigabyte GTX1060 Xtreme Gaming"                },
+    { NVIDIA_VEN,   NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_XTREME_V1_SUB_DEV,             0x47,   "Gigabyte GTX1060 Xtreme Gaming V1"             },
+    { NVIDIA_VEN,   NVIDIA_GTX1060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1060_XTREME_V2_SUB_DEV,             0x47,   "Gigabyte GTX1060 Xtreme Gaming v2"             },
     { NVIDIA_VEN,   NVIDIA_GTX1070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1070_XTREME_SUB_DEV,                0x47,   "Gigabyte GTX1070 Xtreme Gaming"                },
     { NVIDIA_VEN,   NVIDIA_GTX1070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_GTX1070TI_GAMING_SUB_DEV,              0x47,   "Gigabyte GTX1070 Ti 8G Gaming"                 },
     { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1080_G1_GAMING_SUB_DEV,             0x48,   "Gigabyte GTX1080 G1 Gaming"                    },
@@ -37,6 +40,7 @@ static const gpu_pci_device device_list[] =
     { NVIDIA_VEN,   NVIDIA_GTX1660S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_GTX1660S_GAMING_OC_SUB_DEV,            0x47,   "Gigabyte GTX1660 SUPER Gaming OC"              },
     { NVIDIA_VEN,   NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_SUB_DEV,             0x47,   "Gigabyte RTX2060 Gaming OC"                    },
     { NVIDIA_VEN,   NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_PRO_SUB_DEV,         0x47,   "Gigabyte RTX2060 Gaming OC PRO"                },
+    { NVIDIA_VEN,   NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_PRO_WHITE_SUB_DEV,   0x47,   "Gigabyte RTX2060 Gaming OC PRO White"          },
     { NVIDIA_VEN,   NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_SUB_DEV,               0x47,   "Gigabyte RTX2060 SUPER Gaming"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_OC_SUB_DEV,            0x47,   "Gigabyte RTX2060 SUPER Gaming OC"              },
     { NVIDIA_VEN,   NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_OC_WHITE_SUB_DEV,      0x47,   "Gigabyte RTX2060 SUPER Gaming OC 3X White 8G"  },
@@ -44,17 +48,23 @@ static const gpu_pci_device device_list[] =
     { NVIDIA_VEN,   NVIDIA_RTX2070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070_WINDFORCE_SUB_DEV,             0x47,   "Gigabyte RTX2070 Windforce 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_SUB_DEV,            0x47,   "Gigabyte RTX2070S Gaming OC"                   },
     { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_3X_SUB_DEV,         0x55,   "Gigabyte RTX2070S Gaming OC 3X"                },
+    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_3X_WHITE_SUB_DEV,   0x47,   "Gigabyte RTX2070S Gaming OC 3X White"          },
     { NVIDIA_VEN,   NVIDIA_RTX2080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080_GAMING_OC_SUB_DEV,             0x47,   "Gigabyte RTX2080 Gaming OC 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080_A_GAMING_OC_SUB_DEV,           0x47,   "Gigabyte RTX2080 Gaming OC 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080S_GAMING_OC_SUB_DEV,            0x47,   "Gigabyte RTX2080S Gaming OC 8G"                },
     { NVIDIA_VEN,   NVIDIA_RTX3060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_GAMING_OC_12GB_SUB_DEV,        0x62,   "Gigabyte RTX3060 Gaming OC 12G"                },
-    { NVIDIA_VEN,   NVIDIA_RTX3060_V2_DEV,      GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_GAMING_OC_12GB_SUB_DEV,        0x62,   "Gigabyte RTX3060 Gaming OC 12G"                },
+    { NVIDIA_VEN,   NVIDIA_RTX3060_LHR_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_GAMING_OC_12GB_SUB_DEV,        0x62,   "Gigabyte RTX3060 Gaming OC 12G"                },
     { NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_EAGLE_OC_SUB_DEV,            0x63,   "Gigabyte RTX3060 Ti EAGLE OC 8G"               },
     { NVIDIA_VEN,   NVIDIA_RTX3060TI_LHR_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_EAGLE_OC_SUB_DEV,            0x63,   "Gigabyte RTX3060 Ti EAGLE OC 8G V2.0 LHR"      },
     { NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_GAMING_OC_SUB_DEV,           0x62,   "Gigabyte RTX3060 Ti Gaming OC 8G"              },
+    { NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_GAMING_OC_PRO_SUB_DEV,       0x62,   "Gigabyte RTX3060 Ti Gaming OC PRO 8G"          },
+    { NVIDIA_VEN,   NVIDIA_RTX3060TI_LHR_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_GAMING_OC_PRO_SUB_DEV,       0x62,   "Gigabyte RTX3060 Ti Gaming OC PRO 8G LHR"      },
     { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_GAMING_OC_SUB_DEV,             0x62,   "Gigabyte RTX3070 Gaming OC 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_VISION_OC_SUB_DEV,             0x63,   "Gigabyte RTX3070 Vision 8G"                    },
     { NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070TI_GAMING_OC_SUB_DEV,           0x62,   "Gigabyte RTX3070 Ti Gaming OC 8G"              },
+    { NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070TI_EAGLE_SUB_DEV,               0x63,   "Gigabyte RTX3070 Ti EAGLE 8G"                  },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080_GAMING_OC_SUB_DEV,             0x62,   "Gigabyte RTX3080 Gaming OC 10G"                },
+    { NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3080TI_EAGLE_SUB_DEV,               0x63,   "Gigabyte RTX3080 Ti EAGLE 12G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3090_GAMING_OC_24GB_SUB_DEV,        0x62,   "Gigabyte RTX3090 Gaming OC 24G"                },
 };
 
@@ -96,6 +106,7 @@ bool TestForGigabyteRGBFusionGPUController(i2c_smbus_interface* bus, unsigned ch
 
         if (res != 0xAB)
         {
+            LOG_DEBUG("[%s] at 0x%02X address expected 0xAB but recieved: 0x%02X", GIGABYTEGPU_CONTROLLER_NAME, address, res);
             pass = false;
         }
 
@@ -103,6 +114,7 @@ bool TestForGigabyteRGBFusionGPUController(i2c_smbus_interface* bus, unsigned ch
 
         if ((res != 0x14) && (res != 0x10))
         {
+            LOG_DEBUG("[%s] at 0x%02X address expected 0x14|0x10 but recieved: 0x%02X", GIGABYTEGPU_CONTROLLER_NAME, address, res);
             pass = false;
         }
 

Controllers/GigabyteRGBFusionGPUController/RGBController_GigabyteRGBFusionGPU.cpp

@@ -23,7 +23,7 @@ RGBController_RGBFusionGPU::RGBController_RGBFusionGPU(RGBFusionGPUController* r
     mode Direct;
     Direct.name           = "Direct";
     Direct.value          = RGB_FUSION_GPU_MODE_STATIC;
-    Direct.flags          = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.flags          = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
     Direct.color_mode     = MODE_COLORS_PER_LED;
     Direct.brightness_min = RGB_FUSION_GPU_BRIGHTNESS_MIN;
     Direct.brightness_max = RGB_FUSION_GPU_BRIGHTNESS_MAX;
@@ -33,7 +33,7 @@ RGBController_RGBFusionGPU::RGBController_RGBFusionGPU(RGBFusionGPUController* r
     mode Breathing;
     Breathing.name           = "Breathing";
     Breathing.value          = RGB_FUSION_GPU_MODE_BREATHING;
-    Breathing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
     Breathing.speed_min      = RGB_FUSION_GPU_SPEED_SLOWEST;
     Breathing.speed_max      = RGB_FUSION_GPU_SPEED_FASTEST;
     Breathing.speed          = RGB_FUSION_GPU_SPEED_NORMAL;
@@ -46,7 +46,7 @@ RGBController_RGBFusionGPU::RGBController_RGBFusionGPU(RGBFusionGPUController* r
     mode Flashing;
     Flashing.name           = "Flashing";
     Flashing.value          = RGB_FUSION_GPU_MODE_FLASHING;
-    Flashing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Flashing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
     Flashing.speed_min      = RGB_FUSION_GPU_SPEED_SLOWEST;
     Flashing.speed_max      = RGB_FUSION_GPU_SPEED_FASTEST;
     Flashing.speed          = RGB_FUSION_GPU_SPEED_NORMAL;
@@ -59,7 +59,7 @@ RGBController_RGBFusionGPU::RGBController_RGBFusionGPU(RGBFusionGPUController* r
     mode DualFlashing;
     DualFlashing.name           = "Dual Flashing";
     DualFlashing.value          = RGB_FUSION_GPU_MODE_DUAL_FLASHING;
-    DualFlashing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    DualFlashing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
     DualFlashing.speed_min      = RGB_FUSION_GPU_SPEED_SLOWEST;
     DualFlashing.speed_max      = RGB_FUSION_GPU_SPEED_FASTEST;
     DualFlashing.speed          = RGB_FUSION_GPU_SPEED_NORMAL;
@@ -72,7 +72,7 @@ RGBController_RGBFusionGPU::RGBController_RGBFusionGPU(RGBFusionGPUController* r
     mode SpectrumCycle;
     SpectrumCycle.name           = "Spectrum Cycle";
     SpectrumCycle.value          = RGB_FUSION_GPU_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    SpectrumCycle.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
     SpectrumCycle.speed_min      = RGB_FUSION_GPU_SPEED_SLOWEST;
     SpectrumCycle.speed_max      = RGB_FUSION_GPU_SPEED_FASTEST;
     SpectrumCycle.speed          = RGB_FUSION_GPU_SPEED_NORMAL;
@@ -156,3 +156,9 @@ void RGBController_RGBFusionGPU::DeviceUpdateMode()
 {
     rgb_fusion->SetMode((unsigned char)modes[(unsigned int)active_mode].value, (unsigned char)modes[(unsigned int)active_mode].speed, (unsigned char)modes[(unsigned int)active_mode].brightness);
 }
+
+void RGBController_RGBFusionGPU::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    rgb_fusion->Save();
+}

Controllers/GigabyteRGBFusionGPUController/RGBController_GigabyteRGBFusionGPU.h

@@ -28,7 +28,8 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
-
+    void        DeviceSaveMode();
+    
 private:
     RGBFusionGPUController* rgb_fusion;
 };

Controllers/HyperXDRAMController/HyperXDRAMControllerDetect.cpp

@@ -1,5 +1,6 @@
 #include "Detector.h"
 #include "HyperXDRAMController.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_HyperXDRAM.h"
 #include "i2c_smbus.h"
@@ -17,6 +18,7 @@ using namespace std::chrono_literals;
 *       Tests the given address to see if a HyperX controller exists there.                *
 *                                                                                          *
 \******************************************************************************************/
+#define HYPERX_CONTROLLER_NAME "HyperX DRAM"
 
 bool TestForHyperXDRAMController(i2c_smbus_interface* bus, unsigned char address)
 {
@@ -24,6 +26,8 @@ bool TestForHyperXDRAMController(i2c_smbus_interface* bus, unsigned char address
 
     int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
 
+    LOG_DEBUG("[%s] Writing at address %02X, res=%02X", HYPERX_CONTROLLER_NAME, address, res);
+
     if (res >= 0)
     {
         pass = true;
@@ -66,9 +70,12 @@ void DetectHyperXDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
         bool fury_detected = false;
         bool pred_detected = false;
 
+        LOG_DEBUG("[%s] Checking VID/PID on bus %d...", HYPERX_CONTROLLER_NAME, bus);
+
         IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
             // Check for HyperX controller at 0x27
+            LOG_DEBUG("[%s] Testing bus %d at address 0x27", HYPERX_CONTROLLER_NAME, bus);
             if (TestForHyperXDRAMController(busses[bus], 0x27))
             {
                 busses[bus]->i2c_smbus_write_byte_data(0x37, 0x00, 0xFF);
@@ -80,9 +87,16 @@ void DetectHyperXDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
                     // Test for HyperX SPD at slot_addr
                     // This test was copied from NGENUITY software
                     // Tests SPD addresses in order: 0x40, 0x41
-                    if((busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x40) == 0x01)
-                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x41) == 0x98))
+                    int read_0x40 = busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x40);
+                    int read_0x41 = busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x41);
+
+                    LOG_DEBUG("[%s] SPD check: 0x40 => %02X, 0x41 => %02X, ",
+                              HYPERX_CONTROLLER_NAME, read_0x40, read_0x41);
+
+                    if((read_0x40 == 0x01) && (read_0x41 == 0x98))
                     {
+                        LOG_DEBUG("[%s] SPD check success", HYPERX_CONTROLLER_NAME);
+
                         slots_valid |= (1 << (slot_addr - 0x50));
 
                         if(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x67) == 0x01)
@@ -94,10 +108,19 @@ void DetectHyperXDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
                             pred_detected = true;
                         }
                     }
+                    else
+                    {
+                        LOG_DEBUG("[%s] SPD check failed", HYPERX_CONTROLLER_NAME);
+                    }
+
+
 
                     std::this_thread::sleep_for(1ms);
                 }
 
+                LOG_DEBUG("[%s] slots_valid=%d fury_detected=%d pred_detected=%d",
+                          HYPERX_CONTROLLER_NAME, slots_valid, fury_detected, pred_detected);
+
                 if(slots_valid != 0)
                 {
                     new_hyperx = new HyperXDRAMController(busses[bus], 0x27, slots_valid);
@@ -116,6 +139,10 @@ void DetectHyperXDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
                 }
             }
         }
+        else
+        {
+            LOG_DEBUG("[%s] IF_DRAM_SMBUS was false for %04X %04X", HYPERX_CONTROLLER_NAME, busses[bus]->pci_vendor, busses[bus]->pci_device);
+        }
     }
 
 }   /* DetectHyperXDRAMControllers() */

Controllers/HyperXKeyboardController/HyperXAlloyEliteController.cpp

@@ -1,13 +1,13 @@
 /*-----------------------------------------*\
-|  HyperXKeyboardController.cpp             |
+|  HyperXAlloyEliteController.cpp           |
 |                                           |
-|  Driver for HyperX RGB Keyboard lighting  |
-|  controller                               |
+|  Driver for HyperX Alloy Elite Keyboard   |
+|  lighting controller                      |
 |                                           |
 |  Adam Honse (CalcProgrammer1) 1/30/2020   |
 \*-----------------------------------------*/
 
-#include "HyperXKeyboardController.h"
+#include "HyperXAlloyEliteController.h"
 
 #include <cstring>
 
@@ -27,23 +27,23 @@ static unsigned int extended_red[] = {0x08, 0x48, 0x88, 0x09, 0x89, 0x0A, 0x8A,
 static unsigned int extended_grn[] = {0x29, 0x28, 0x78, 0x19, 0x79, 0x1A, 0x7A, 0x1B, 0x7B, 0x1C, 0x7C, 0x1D, 0x7D, 0x1E, 0x6E, 0x7E, 0x1F, 0x6F, 0x82, 0x23, 0x83, 0x22 };
 static unsigned int extended_blu[] = {0x39, 0x38, 0x68, 0x3A, 0x69, 0x2A, 0x6A, 0x2B, 0x6B, 0x2C, 0x6C, 0x2D, 0x6D, 0x2E, 0x5E, 0x5D, 0x2F, 0x5F, 0x72, 0x33, 0x73, 0x32 };
 
-HyperXKeyboardController::HyperXKeyboardController(hid_device* dev_handle, const char* path)
+HyperXAlloyEliteController::HyperXAlloyEliteController(hid_device* dev_handle, const char* path)
 {
     dev         = dev_handle;
     location    = path;
 }
 
-HyperXKeyboardController::~HyperXKeyboardController()
+HyperXAlloyEliteController::~HyperXAlloyEliteController()
 {
     hid_close(dev);
 }
 
-std::string HyperXKeyboardController::GetDeviceLocation()
+std::string HyperXAlloyEliteController::GetDeviceLocation()
 {
     return("HID: " + location);
 }
 
-std::string HyperXKeyboardController::GetSerialString()
+std::string HyperXAlloyEliteController::GetSerialString()
 {
     wchar_t serial_string[128];
     int ret = hid_get_serial_number_string(dev, serial_string, 128);
@@ -59,7 +59,7 @@ std::string HyperXKeyboardController::GetSerialString()
     return(return_string);
 }
 
-void HyperXKeyboardController::SetMode
+void HyperXAlloyEliteController::SetMode
     (
     unsigned char mode,
     unsigned char direction,
@@ -80,18 +80,18 @@ void HyperXKeyboardController::SetMode
     {
         default:
         case 0:
-            color_mode = HYPERX_COLOR_MODE_SPECTRUM;
+            color_mode = HYPERX_ALLOY_ELITE_COLOR_MODE_SPECTRUM;
             break;
 
         case 1:
-            color_mode = HYPERX_COLOR_MODE_SINGLE;
+            color_mode = HYPERX_ALLOY_ELITE_COLOR_MODE_SINGLE;
             mode_colors[0] = RGBGetRValue(colors[0]);
             mode_colors[1] = RGBGetGValue(colors[0]);
             mode_colors[2] = RGBGetBValue(colors[0]);
             break;
 
         case 2:
-            color_mode = HYPERX_COLOR_MODE_DUAL;
+            color_mode = HYPERX_ALLOY_ELITE_COLOR_MODE_DUAL;
             mode_colors[3] = RGBGetRValue(colors[0]);
             mode_colors[4] = RGBGetGValue(colors[0]);
             mode_colors[5] = RGBGetBValue(colors[0]);
@@ -106,7 +106,7 @@ void HyperXKeyboardController::SetMode
         0x01,
         active_mode,
         active_direction,
-        HYPERX_REACTIVE_MODE_NONE,
+        HYPERX_ALLOY_ELITE_REACTIVE_MODE_NONE,
         active_speed,
         color_mode,
         mode_colors[0],
@@ -123,7 +123,7 @@ void HyperXKeyboardController::SetMode
     std::this_thread::sleep_for(100ms);
 }
 
-void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
+void HyperXAlloyEliteController::SetLEDsDirect(std::vector<RGBColor> colors)
 {
     unsigned char red_color_data[106];
     unsigned char grn_color_data[106];
@@ -146,7 +146,7 @@ void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
 
     SendDirect
         (
-        HYPERX_COLOR_CHANNEL_RED,
+        HYPERX_ALLOY_ELITE_COLOR_CHANNEL_RED,
         red_color_data
         );
 
@@ -154,7 +154,7 @@ void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
 
     SendDirect
         (
-        HYPERX_COLOR_CHANNEL_GREEN,
+        HYPERX_ALLOY_ELITE_COLOR_CHANNEL_GREEN,
         grn_color_data
         );
 
@@ -162,7 +162,7 @@ void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
 
     SendDirect
         (
-        HYPERX_COLOR_CHANNEL_BLUE,
+        HYPERX_ALLOY_ELITE_COLOR_CHANNEL_BLUE,
         blu_color_data
         );
 
@@ -174,7 +174,7 @@ void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
         );
 }
 
-void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
+void HyperXAlloyEliteController::SetLEDs(std::vector<RGBColor> colors)
 {
     unsigned char red_color_data[106];
     unsigned char grn_color_data[106];
@@ -198,7 +198,7 @@ void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
     SendColor
         (
         0x01,
-        HYPERX_COLOR_CHANNEL_RED,
+        HYPERX_ALLOY_ELITE_COLOR_CHANNEL_RED,
         red_color_data
         );
 
@@ -207,7 +207,7 @@ void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
     SendColor
         (
         0x01,
-        HYPERX_COLOR_CHANNEL_GREEN,
+        HYPERX_ALLOY_ELITE_COLOR_CHANNEL_GREEN,
         grn_color_data
         );
 
@@ -216,7 +216,7 @@ void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
     SendColor
         (
         0x01,
-        HYPERX_COLOR_CHANNEL_BLUE,
+        HYPERX_ALLOY_ELITE_COLOR_CHANNEL_BLUE,
         blu_color_data
         );
 
@@ -233,7 +233,7 @@ void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
 | Private packet sending functions.                                                                 |
 \*-------------------------------------------------------------------------------------------------*/
 
-void HyperXKeyboardController::SelectProfile
+void HyperXAlloyEliteController::SelectProfile
     (
     unsigned char   profile
     )
@@ -261,7 +261,7 @@ void HyperXKeyboardController::SelectProfile
     hid_send_feature_report(dev, buf, 264);
 }
 
-void HyperXKeyboardController::SendEffect
+void HyperXAlloyEliteController::SendEffect
     (
     unsigned char   profile,
     unsigned char   mode,
@@ -291,7 +291,7 @@ void HyperXKeyboardController::SendEffect
     | Set up Effect packet                                  |
     \*-----------------------------------------------------*/
     buf[0x00]   = 0x07;
-    buf[0x01]   = HYPERX_PACKET_ID_SET_EFFECT;
+    buf[0x01]   = HYPERX_ALLOY_ELITE_PACKET_ID_SET_EFFECT;
     buf[0x02]   = profile;
 
     /*-----------------------------------------------------*\
@@ -363,7 +363,7 @@ void HyperXKeyboardController::SendEffect
     hid_send_feature_report(dev, buf, 264);
 }
 
-void HyperXKeyboardController::SendColor
+void HyperXAlloyEliteController::SendColor
     (
     unsigned char   profile,
     unsigned char   color_channel,
@@ -381,7 +381,7 @@ void HyperXKeyboardController::SendColor
     | Set up Color packet                                   |
     \*-----------------------------------------------------*/
     buf[0x00]   = 0x07;
-    buf[0x01]   = HYPERX_PACKET_ID_SET_COLOR;
+    buf[0x01]   = HYPERX_ALLOY_ELITE_PACKET_ID_SET_COLOR;
     buf[0x02]   = profile;
     buf[0x03]   = color_channel;
 
@@ -399,7 +399,7 @@ void HyperXKeyboardController::SendColor
     hid_send_feature_report(dev, buf, 264);
 }
 
-void HyperXKeyboardController::SendExtendedColor
+void HyperXAlloyEliteController::SendExtendedColor
     (
     unsigned char   profile,
     unsigned char*  color_data
@@ -416,9 +416,9 @@ void HyperXKeyboardController::SendExtendedColor
     | Set up Color packet                                   |
     \*-----------------------------------------------------*/
     buf[0x00]   = 0x07;
-    buf[0x01]   = HYPERX_PACKET_ID_SET_COLOR;
+    buf[0x01]   = HYPERX_ALLOY_ELITE_PACKET_ID_SET_COLOR;
     buf[0x02]   = profile;
-    buf[0x03]   = HYPERX_COLOR_CHANNEL_EXTENDED;
+    buf[0x03]   = HYPERX_ALLOY_ELITE_COLOR_CHANNEL_EXTENDED;
 
     /*-----------------------------------------------------*\
     | Fill in color data                                    |
@@ -434,7 +434,7 @@ void HyperXKeyboardController::SendExtendedColor
     hid_send_feature_report(dev, buf, 264);
 }
 
-void HyperXKeyboardController::SendDirect
+void HyperXAlloyEliteController::SendDirect
     (
     unsigned char   color_channel,
     unsigned char*  color_data
@@ -451,7 +451,7 @@ void HyperXKeyboardController::SendDirect
     | Set up Direct packet                                  |
     \*-----------------------------------------------------*/
     buf[0x00]   = 0x07;
-    buf[0x01]   = HYPERX_PACKET_ID_DIRECT;
+    buf[0x01]   = HYPERX_ALLOY_ELITE_PACKET_ID_DIRECT;
     buf[0x02]   = color_channel;
     buf[0x03]   = 0xA0;
 
@@ -469,7 +469,7 @@ void HyperXKeyboardController::SendDirect
     hid_send_feature_report(dev, buf, 264);
 }
 
-void HyperXKeyboardController::SendDirectExtended
+void HyperXAlloyEliteController::SendDirectExtended
     (
     unsigned char*  color_data
     )
@@ -485,8 +485,8 @@ void HyperXKeyboardController::SendDirectExtended
     | Set up Direct packet                                  |
     \*-----------------------------------------------------*/
     buf[0x00]   = 0x07;
-    buf[0x01]   = HYPERX_PACKET_ID_DIRECT;
-    buf[0x02]   = HYPERX_COLOR_CHANNEL_EXTENDED;
+    buf[0x01]   = HYPERX_ALLOY_ELITE_PACKET_ID_DIRECT;
+    buf[0x02]   = HYPERX_ALLOY_ELITE_COLOR_CHANNEL_EXTENDED;
     buf[0x03]   = 0xA0;
 
     /*-----------------------------------------------------*\

Controllers/HyperXKeyboardController/HyperXAlloyEliteController.h

@@ -1,8 +1,8 @@
 /*-----------------------------------------*\
-|  HyperXKeyboardController.h               |
+|  HyperXAlloyEliteController.h             |
 |                                           |
-|  Definitions and types for HyperX RGB     |
-|  Keyboard lighting controller             |
+|  Definitions and types for HyperX Alloy   |
+|  Elite Keyboard lighting controller       |
 |                                           |
 |  Adam Honse (CalcProgrammer1) 1/30/2020   |
 \*-----------------------------------------*/
@@ -16,57 +16,57 @@
 
 enum
 {
-    HYPERX_PACKET_ID_SET_EFFECT                 = 0x02,     /* Set profile effect packet            */
-    HYPERX_PACKET_ID_SET_COLOR                  = 0x06,     /* Set profile color packet             */
-    HYPERX_PACKET_ID_DIRECT                     = 0x16,     /* Direct control packet                */
+    HYPERX_ALLOY_ELITE_PACKET_ID_SET_EFFECT         = 0x02,     /* Set profile effect packet            */
+    HYPERX_ALLOY_ELITE_PACKET_ID_SET_COLOR          = 0x06,     /* Set profile color packet             */
+    HYPERX_ALLOY_ELITE_PACKET_ID_DIRECT             = 0x16,     /* Direct control packet                */
 };
 
 
 enum
 {
-    HYPERX_DIRECTION_RIGHT  = 0x00,
-    HYPERX_DIRECTION_LEFT   = 0x01,
-    HYPERX_DIRECTION_UP     = 0x02,
-    HYPERX_DIRECTION_DOWN   = 0x03,
-    HYPERX_DIRECTION_IN     = 0x04,
-    HYPERX_DIRECTION_OUT    = 0x05
+    HYPERX_ALLOY_ELITE_DIRECTION_RIGHT              = 0x00,
+    HYPERX_ALLOY_ELITE_DIRECTION_LEFT               = 0x01,
+    HYPERX_ALLOY_ELITE_DIRECTION_UP                 = 0x02,
+    HYPERX_ALLOY_ELITE_DIRECTION_DOWN               = 0x03,
+    HYPERX_ALLOY_ELITE_DIRECTION_IN                 = 0x04,
+    HYPERX_ALLOY_ELITE_DIRECTION_OUT                = 0x05
 };
 
 enum
 {
-    HYPERX_MODE_WAVE                    = 0x00,
-    HYPERX_MODE_STATIC                  = 0x01,
-    HYPERX_MODE_BREATHING               = 0x02,
+    HYPERX_ALLOY_ELITE_MODE_WAVE                    = 0x00,
+    HYPERX_ALLOY_ELITE_MODE_STATIC                  = 0x01,
+    HYPERX_ALLOY_ELITE_MODE_BREATHING               = 0x02,
 };
 
 enum
 {
-    HYPERX_REACTIVE_MODE_TRIGGER        = 0x03,
-    HYPERX_REACTIVE_MODE_EXPLOSION      = 0x04,
-    HYPERX_REACTIVE_MODE_HYPERX_FLAME   = 0x05,
-    HYPERX_REACTIVE_MODE_NONE           = 0xFF
+    HYPERX_ALLOY_ELITE_REACTIVE_MODE_TRIGGER        = 0x03,
+    HYPERX_ALLOY_ELITE_REACTIVE_MODE_EXPLOSION      = 0x04,
+    HYPERX_ALLOY_ELITE_REACTIVE_MODE_HYPERX_FLAME   = 0x05,
+    HYPERX_ALLOY_ELITE_REACTIVE_MODE_NONE           = 0xFF
 };
 
 enum
 {
-    HYPERX_COLOR_MODE_SINGLE            = 0x00,
-    HYPERX_COLOR_MODE_DUAL              = 0x01,
-    HYPERX_COLOR_MODE_SPECTRUM          = 0x02
+    HYPERX_ALLOY_ELITE_COLOR_MODE_SINGLE            = 0x00,
+    HYPERX_ALLOY_ELITE_COLOR_MODE_DUAL              = 0x01,
+    HYPERX_ALLOY_ELITE_COLOR_MODE_SPECTRUM          = 0x02
 };
 
 enum
 {
-    HYPERX_COLOR_CHANNEL_RED                = 0x01,
-    HYPERX_COLOR_CHANNEL_GREEN              = 0x02,
-    HYPERX_COLOR_CHANNEL_BLUE               = 0x03,
-    HYPERX_COLOR_CHANNEL_EXTENDED           = 0x04
+    HYPERX_ALLOY_ELITE_COLOR_CHANNEL_RED            = 0x01,
+    HYPERX_ALLOY_ELITE_COLOR_CHANNEL_GREEN          = 0x02,
+    HYPERX_ALLOY_ELITE_COLOR_CHANNEL_BLUE           = 0x03,
+    HYPERX_ALLOY_ELITE_COLOR_CHANNEL_EXTENDED       = 0x04
 };
 
-class HyperXKeyboardController
+class HyperXAlloyEliteController
 {
 public:
-    HyperXKeyboardController(hid_device* dev_handle, const char* path);
-    ~HyperXKeyboardController();
+    HyperXAlloyEliteController(hid_device* dev_handle, const char* path);
+    ~HyperXAlloyEliteController();
 
     std::string     GetDeviceLocation();
     std::string     GetSerialString();

Controllers/HyperXKeyboardController/HyperXAlloyFPSController.cpp

@@ -0,0 +1,132 @@
+/*-----------------------------------------*\
+|  HyperXAlloyFPSController.cpp             |
+|                                           |
+|  Driver for HyperX Alloy FPS Keyboard     |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/30/2020   |
+\*-----------------------------------------*/
+
+#include "HyperXAlloyFPSController.h"
+
+#include <cstring>
+
+using namespace std::chrono_literals;
+
+static unsigned int keys[] = {0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14,
+                              0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x20, 0x21, 0x22,
+                              0x23, 0x24, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
+                              0x31, 0x32, 0x33, 0x34, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3E, 0x3F, 0x41,
+                              0x44, 0x45, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x51, 0x54, 0x55,
+                              0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5E, 0x5F, 0x61, 0x64, 0x65, 0x68, 0x69, 0x6A,
+                              0x6B, 0x6C, 0x6E, 0x6F, 0x74, 0x75, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
+                              0x7F, 0x81, 0x84, 0x85, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x91,
+                              0x94, 0x95 };
+
+HyperXAlloyFPSController::HyperXAlloyFPSController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+HyperXAlloyFPSController::~HyperXAlloyFPSController()
+{
+    hid_close(dev);
+}
+
+std::string HyperXAlloyFPSController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string HyperXAlloyFPSController::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+void HyperXAlloyFPSController::SetLEDsDirect(std::vector<RGBColor> colors)
+{
+    unsigned char red_color_data[106];
+    unsigned char grn_color_data[106];
+    unsigned char blu_color_data[106];
+    unsigned char ext_color_data[150];
+
+    for(std::size_t i = 0; i < 106; i++)
+    {
+        red_color_data[i] = RGBGetRValue(colors[i]);
+        grn_color_data[i] = RGBGetGValue(colors[i]);
+        blu_color_data[i] = RGBGetBValue(colors[i]);
+    }
+
+    SendDirect
+        (
+        HYPERX_ALLOY_FPS_COLOR_CHANNEL_RED,
+        red_color_data
+        );
+
+    std::this_thread::sleep_for(10ms);
+
+    SendDirect
+        (
+        HYPERX_ALLOY_FPS_COLOR_CHANNEL_GREEN,
+        grn_color_data
+        );
+
+    std::this_thread::sleep_for(10ms);
+
+    SendDirect
+        (
+        HYPERX_ALLOY_FPS_COLOR_CHANNEL_BLUE,
+        blu_color_data
+        );
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void HyperXAlloyFPSController::SendDirect
+    (
+    unsigned char   color_channel,
+    unsigned char*  color_data
+    )
+{
+    unsigned char buf[264];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Direct packet                                  |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x07;
+    buf[0x01]   = HYPERX_ALLOY_FPS_PACKET_ID_DIRECT;
+    buf[0x02]   = color_channel;
+    buf[0x03]   = 0xA0;
+
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for(int i = 0; i < 106; i++)
+    {
+        buf[keys[i]] = color_data[i];
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 264);
+}

Controllers/HyperXKeyboardController/HyperXAlloyFPSController.h

@@ -0,0 +1,49 @@
+/*-----------------------------------------*\
+|  HyperXAlloyFPSController.h               |
+|                                           |
+|  Definitions and types for HyperX Alloy   |
+|  Elite Keyboard lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/30/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    HYPERX_ALLOY_FPS_PACKET_ID_DIRECT               = 0x16,     /* Direct control packet                */
+};
+
+enum
+{
+    HYPERX_ALLOY_FPS_COLOR_CHANNEL_RED              = 0x01,
+    HYPERX_ALLOY_FPS_COLOR_CHANNEL_GREEN            = 0x02,
+    HYPERX_ALLOY_FPS_COLOR_CHANNEL_BLUE             = 0x03
+};
+
+class HyperXAlloyFPSController
+{
+public:
+    HyperXAlloyFPSController(hid_device* dev_handle, const char* path);
+    ~HyperXAlloyFPSController();
+
+    std::string     GetDeviceLocation();
+    std::string     GetSerialString();
+
+    void SetLEDsDirect(std::vector<RGBColor> colors);
+
+private:
+    hid_device*             dev;
+    std::string             location;
+
+    void    SendDirect
+                (
+                unsigned char   color_channel,
+                unsigned char*  color_data
+                );
+};

Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp

@@ -1,13 +1,15 @@
 #include "Detector.h"
+#include "HyperXAlloyEliteController.h"
 #include "HyperXAlloyElite2Controller.h"
+#include "HyperXAlloyFPSController.h"
 #include "HyperXAlloyOriginsController.h"
 #include "HyperXAlloyOriginsCoreController.h"
-#include "HyperXKeyboardController.h"
 #include "RGBController.h"
+#include "RGBController_HyperXAlloyElite.h"
 #include "RGBController_HyperXAlloyElite2.h"
+#include "RGBController_HyperXAlloyFPS.h"
 #include "RGBController_HyperXAlloyOrigins.h"
 #include "RGBController_HyperXAlloyOriginsCore.h"
-#include "RGBController_HyperXKeyboard.h"
 #include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
@@ -20,13 +22,43 @@
 #define HYPERX_ALLOY_ORIGINS_PID        0x16E5
 #define HYPERX_ALLOY_ORIGINS_CORE_PID   0x16E6
 
-void DetectHyperXKeyboards(hid_device_info* info, const std::string& name)
+#define HP_KEYBOARD_VID                 0x03F0
+#define HYPERX_ALLOY_ELITE_2_HP_PID     0x058F
+
+void DetectHyperXAlloyElite(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
-    if( dev )
+
+    if(dev)
     {
-        HyperXKeyboardController* controller = new HyperXKeyboardController(dev, info->path);
-        RGBController_HyperXKeyboard* rgb_controller = new RGBController_HyperXKeyboard(controller);
+        HyperXAlloyEliteController*     controller     = new HyperXAlloyEliteController(dev, info->path);
+        RGBController_HyperXAlloyElite* rgb_controller = new RGBController_HyperXAlloyElite(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectHyperXAlloyElite2(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        HyperXAlloyElite2Controller*     controller     = new HyperXAlloyElite2Controller(dev, info->path);
+        RGBController_HyperXAlloyElite2* rgb_controller = new RGBController_HyperXAlloyElite2(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectHyperXAlloyFPS(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        HyperXAlloyFPSController* controller = new HyperXAlloyFPSController(dev, info->path);
+        RGBController_HyperXAlloyFPS* rgb_controller = new RGBController_HyperXAlloyFPS(controller);
         rgb_controller->name = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
@@ -35,9 +67,10 @@ void DetectHyperXKeyboards(hid_device_info* info, const std::string& name)
 void DetectHyperXAlloyOrigins(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
-    if( dev )
+    
+    if(dev)
     {
-        HyperXAlloyOriginsController* controller = new HyperXAlloyOriginsController(dev, info->path);
+        HyperXAlloyOriginsController*     controller     = new HyperXAlloyOriginsController(dev, info->path);
         RGBController_HyperXAlloyOrigins* rgb_controller = new RGBController_HyperXAlloyOrigins(controller);
         rgb_controller->name = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -47,35 +80,26 @@ void DetectHyperXAlloyOrigins(hid_device_info* info, const std::string& name)
 void DetectHyperXAlloyOriginsCore(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
-    if( dev )
+
+    if(dev)
     {
-        HyperXAlloyOriginsCoreController* controller = new HyperXAlloyOriginsCoreController(dev, info);
+        HyperXAlloyOriginsCoreController*     controller     = new HyperXAlloyOriginsCoreController(dev, info);
         RGBController_HyperXAlloyOriginsCore* rgb_controller = new RGBController_HyperXAlloyOriginsCore(controller);
         rgb_controller->name = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
 
-void DetectHyperXAlloyElite2(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
-    {
-        HyperXAlloyElite2Controller* controller = new HyperXAlloyElite2Controller(dev, info->path);
-        RGBController_HyperXAlloyElite2* rgb_controller = new RGBController_HyperXAlloyElite2(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite RGB",      DetectHyperXKeyboards,        HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID,          2, 0xFF01);
-REGISTER_HID_DETECTOR_IP("HyperX Alloy FPS RGB",        DetectHyperXKeyboards,        HYPERX_KEYBOARD_VID, HYPERX_ALLOY_FPS_RGB_PID,        2, 0xFF01);
+REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite RGB",      DetectHyperXAlloyElite,       HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID,          2, 0xFF01);
+REGISTER_HID_DETECTOR_IP("HyperX Alloy FPS RGB",        DetectHyperXAlloyFPS,         HYPERX_KEYBOARD_VID, HYPERX_ALLOY_FPS_RGB_PID,        2, 0xFF01);
 REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core",    DetectHyperXAlloyOriginsCore, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_CORE_PID,   2);
 
 #ifdef _WIN32
 REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",         DetectHyperXAlloyOrigins,     HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,        3);
 REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2",        DetectHyperXAlloyElite2,      HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,        3, 0xFF90);
+REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite 2 (HP)",   DetectHyperXAlloyElite2,      HP_KEYBOARD_VID,     HYPERX_ALLOY_ELITE_2_HP_PID,     3, 0xFF90);
 #else
 REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",         DetectHyperXAlloyOrigins,     HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,        0);
 REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2",         DetectHyperXAlloyElite2,      HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_2_PID,        0);
+REGISTER_HID_DETECTOR_I("HyperX Alloy Elite 2 (HP)",    DetectHyperXAlloyElite2,      HP_KEYBOARD_VID,     HYPERX_ALLOY_ELITE_2_HP_PID,     0);
 #endif

Controllers/HyperXKeyboardController/RGBController_HyperXAlloyElite.cpp

@@ -1,13 +1,13 @@
 /*-----------------------------------------*\
-|  RGBController_HyperXKeyboard.cpp         |
+|  RGBController_HyperXAlloyElite.cpp       |
 |                                           |
-|  Generic RGB Interface for HyperX RGB     |
-|  Keyboard                                 |
+|  Generic RGB Interface for HyperX Alloy   |
+|  Elite Keyboard                           |
 |                                           |
 |  Adam Honse (CalcProgrammer1) 2/2/2020    |
 \*-----------------------------------------*/
 
-#include "RGBController_HyperXKeyboard.h"
+#include "RGBController_HyperXAlloyElite.h"
 
 using namespace std::chrono_literals;
 
@@ -175,34 +175,34 @@ static const char *led_names[] =
     "Key: Media Mute"
 };
 
-RGBController_HyperXKeyboard::RGBController_HyperXKeyboard(HyperXKeyboardController* hyperx_ptr)
+RGBController_HyperXAlloyElite::RGBController_HyperXAlloyElite(HyperXAlloyEliteController* hyperx_ptr)
 {
-    hyperx = hyperx_ptr;
+    controller  = hyperx_ptr;
 
-    name        = "HyperX RGB Keyboard";
+    name        = "HyperX Alloy Elite";
     vendor      = "HyperX";
     type        = DEVICE_TYPE_KEYBOARD;
-    description = "HyperX RGB Keyboard Device";
-    location    = hyperx->GetDeviceLocation();
-    serial      = hyperx->GetSerialString();
+    description = "HyperX Alloy Elite Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
 
     mode Direct;
     Direct.name       = "Direct";
-    Direct.value      = HYPERX_MODE_STATIC;
+    Direct.value      = HYPERX_ALLOY_ELITE_MODE_STATIC;
     Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
     Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Static;
     Static.name       = "Static";
-    Static.value      = HYPERX_MODE_STATIC;
+    Static.value      = HYPERX_ALLOY_ELITE_MODE_STATIC;
     Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
     Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Wave;
     Wave.name       = "Wave";
-    Wave.value      = HYPERX_MODE_WAVE;
+    Wave.value      = HYPERX_ALLOY_ELITE_MODE_WAVE;
     Wave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
     Wave.speed_min  = 0x00;
     Wave.speed_max  = 0x09;
@@ -213,7 +213,7 @@ RGBController_HyperXKeyboard::RGBController_HyperXKeyboard(HyperXKeyboardControl
 
     mode Breathing;
     Breathing.name       = "Breathing";
-    Breathing.value      = HYPERX_MODE_BREATHING;
+    Breathing.value      = HYPERX_ALLOY_ELITE_MODE_BREATHING;
     Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
     Breathing.speed_min  = 0x00;
     Breathing.speed_max  = 0x09;
@@ -227,16 +227,15 @@ RGBController_HyperXKeyboard::RGBController_HyperXKeyboard(HyperXKeyboardControl
     SetupZones();
 
     /*-----------------------------------------------------*\
-    | The Corsair Lighting Node Pro requires a packet within|
-    | 20 seconds of sending the lighting change in order    |
-    | to not revert back into rainbow mode.  Start a thread |
-    | to continuously send a keepalive packet every 5s      |
+    | The HyperX Alloy Elite requires a steady stream of    |
+    | packets in order to not revert out of direct mode.    |
+    | Start a thread to continuously refresh the device     |
     \*-----------------------------------------------------*/
     keepalive_thread_run = true;
-    keepalive_thread = new std::thread(&RGBController_HyperXKeyboard::KeepaliveThreadFunction, this);
+    keepalive_thread = new std::thread(&RGBController_HyperXAlloyElite::KeepaliveThreadFunction, this);
 }
 
-RGBController_HyperXKeyboard::~RGBController_HyperXKeyboard()
+RGBController_HyperXAlloyElite::~RGBController_HyperXAlloyElite()
 {
     keepalive_thread_run = false;
     keepalive_thread->join();
@@ -253,10 +252,10 @@ RGBController_HyperXKeyboard::~RGBController_HyperXKeyboard()
         }
     }
 
-    delete hyperx;
+    delete controller;
 }
 
-void RGBController_HyperXKeyboard::SetupZones()
+void RGBController_HyperXAlloyElite::SetupZones()
 {
     /*---------------------------------------------------------*\
     | Set up zones                                              |
@@ -298,56 +297,56 @@ void RGBController_HyperXKeyboard::SetupZones()
     SetupColors();
 }
 
-void RGBController_HyperXKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
+void RGBController_HyperXAlloyElite::ResizeZone(int /*zone*/, int /*new_size*/)
 {
     /*---------------------------------------------------------*\
     | This device does not support resizing zones               |
     \*---------------------------------------------------------*/
 }
 
-void RGBController_HyperXKeyboard::DeviceUpdateLEDs()
+void RGBController_HyperXAlloyElite::DeviceUpdateLEDs()
 {
     last_update_time = std::chrono::steady_clock::now();
 
     if(active_mode == 0)
     {
-        hyperx->SetLEDsDirect(colors);
+        controller->SetLEDsDirect(colors);
     }
     else
     {
-        hyperx->SetLEDs(colors);
+        controller->SetLEDs(colors);
     }
 }
 
-void RGBController_HyperXKeyboard::UpdateZoneLEDs(int /*zone*/)
+void RGBController_HyperXAlloyElite::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_HyperXKeyboard::UpdateSingleLED(int /*led*/)
+void RGBController_HyperXAlloyElite::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_HyperXKeyboard::SetCustomMode()
+void RGBController_HyperXAlloyElite::SetCustomMode()
 {
     active_mode = 0;
 }
 
-void RGBController_HyperXKeyboard::DeviceUpdateMode()
+void RGBController_HyperXAlloyElite::DeviceUpdateMode()
 {
     if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
     {
-        hyperx->SetMode(modes[active_mode].value, modes[active_mode].direction, modes[active_mode].speed, modes[active_mode].colors);
+        controller->SetMode(modes[active_mode].value, modes[active_mode].direction, modes[active_mode].speed, modes[active_mode].colors);
     }
     else
     {
         std::vector<RGBColor> temp_colors;
-        hyperx->SetMode(modes[active_mode].value, modes[active_mode].direction, modes[active_mode].speed, temp_colors);
+        controller->SetMode(modes[active_mode].value, modes[active_mode].direction, modes[active_mode].speed, temp_colors);
     }
 }
 
-void RGBController_HyperXKeyboard::KeepaliveThreadFunction()
+void RGBController_HyperXAlloyElite::KeepaliveThreadFunction()
 {
     while(keepalive_thread_run)
     {

Controllers/HyperXKeyboardController/RGBController_HyperXAlloyElite.h

@@ -0,0 +1,42 @@
+/*-----------------------------------------*\
+|  RGBController_HyperXAlloyElite.h         |
+|                                           |
+|  Generic RGB Interface for HyperX Alloy   |
+|  Elite Keyboard                           |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 2/2/2020    |
+\*-----------------------------------------*/
+
+#pragma once
+#include <atomic>
+#include <chrono>
+#include <thread>
+
+#include "RGBController.h"
+#include "HyperXAlloyEliteController.h"
+
+class RGBController_HyperXAlloyElite : public RGBController
+{
+public:
+    RGBController_HyperXAlloyElite(HyperXAlloyEliteController* hyperx_ptr);
+    ~RGBController_HyperXAlloyElite();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+    
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+    void        KeepaliveThreadFunction();
+    
+private:
+    HyperXAlloyEliteController*                         controller;
+    std::atomic<bool>                                   keepalive_thread_run;
+    std::thread*                                        keepalive_thread;
+    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
+};

Controllers/HyperXKeyboardController/RGBController_HyperXAlloyFPS.cpp

@@ -0,0 +1,291 @@
+/*-----------------------------------------*\
+|  RGBController_HyperXAlloyFPS.cpp         |
+|                                           |
+|  Generic RGB Interface for HyperX Alloy   |
+|  FPS Keyboard                             |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 2/2/2020    |
+\*-----------------------------------------*/
+
+#include "RGBController_HyperXAlloyFPS.h"
+
+using namespace std::chrono_literals;
+
+//0xFFFFFFFF indicates an unused entry in matrix
+#define NA  0xFFFFFFFF
+
+static unsigned int matrix_map[6][23] =
+    { {   0,  NA,  16,  30,  44,  54,  NA,  65,  75,  84,  95,  NA,   8,  23 ,  38,   6 ,  22,  36,  49,  NA,  NA,  NA,  NA },
+      {   1,  17,  31,  45,  55,  66,  76,  85,  96,   9,  24,  NA,  39,   7 ,  37,  NA ,  60,  70,  80,  52,  63,  73,  82 },
+      {   2,  NA,  18,  32,  46,  56,  NA,  67,  77,  86,  97,  10,  25,  40 ,  90,  101,  50,  61,  71,  51,  62,  72,  93 },
+      {   3,  NA,  19,  33,  47,  57,  NA,  68,  78,  87,  98,  11,  26,  41 ,  28,  14 ,  NA,  NA,  NA,  92, 103,  53,  NA },
+      {   4,  20,  34,  48,  58,  69,  NA,  79,  NA,  88,  99,  12,  27,  42 ,  81,  NA ,  NA, 102,  NA,  64,  74,  83, 104 },
+      {   5,  21,  35,  NA,  NA,  NA,  NA,  59,  NA,  NA,  NA,  NA,  89,  100,  13,  91 ,  15,  29,  43,  94,  NA, 105,  NA } };
+
+static const char* zone_names[] =
+{
+    "Keyboard"
+};
+
+static zone_type zone_types[] =
+{
+    ZONE_TYPE_MATRIX
+};
+
+static const unsigned int zone_sizes[] =
+{
+    106
+};
+
+static const char *led_names[] =
+{
+    "Key: Escape",
+    "Key: `",
+    "Key: Tab",
+    "Key: Caps Lock",
+    "Key: Left Shift",
+    "Key: Left Control",
+    "Key: F12",
+    "Key: =",
+    "Key: F9",
+    "Key: 9",
+    "Key: O",
+    "Key: L",
+    "Key: ,",
+    "Key: Menu",
+    "Key: Enter (ISO)",
+    "Key: Left Arrow",
+    "Key: F1",
+    "Key: 1",
+    "Key: Q",
+    "Key: A",
+    "Key: \\ (ISO)",
+    "Key: Left Windows",
+    "Key: Print Screen",
+    "Key: F10",
+    "Key: 0",
+    "Key: P",
+    "Key: ;",
+    "Key: .",
+    "Key: Enter",
+    "Key: Down Arrow",
+    "Key: F2",
+    "Key: 2",
+    "Key: W",
+    "Key: S",
+    "Key: Z",
+    "Key: Left Alt",
+    "Key: Scroll Lock",
+    "Key: Backspace",
+    "Key: F11",
+    "Key: -",
+    "Key: [",
+    "Key: '",
+    "Key: /",
+    "Key: Right Arrow",
+    "Key: F3",
+    "Key: 3",
+    "Key: E",
+    "Key: D",
+    "Key: X",
+    "Key: Pause/Break",
+    "Key: Delete",
+    "Key: Number Pad 7",
+    "Key: Num Lock",
+    "Key: Number Pad 6",
+    "Key: F4",
+    "Key: 4",
+    "Key: R",
+    "Key: F",
+    "Key: C",
+    "Key: Space",
+    "Key: Insert",
+    "Key: End",
+    "Key: Number Pad 8",
+    "Key: Number Pad /",
+    "Key: Number Pad 1",
+    "Key: F5",
+    "Key: 5",
+    "Key: T",
+    "Key: G",
+    "Key: V",
+    "Key: Home",
+    "Key: Page Down",
+    "Key: Number Pad 9",
+    "Key: Number Pad *",
+    "Key: Number Pad 2",
+    "Key: F6",
+    "Key: 6",
+    "Key: Y",
+    "Key: H",
+    "Key: B",
+    "Key: Page Up",
+    "Key: Right Shift",
+    "Key: Number Pad -",
+    "Key: Number Pad 3",
+    "Key: F7",
+    "Key: 7",
+    "Key: U",
+    "Key: J",
+    "Key: N",
+    "Key: Right Alt",
+    "Key: ]",
+    "Key: Right Control",
+    "Key: Number Pad 4",
+    "Key: Number Pad +",
+    "Key: Number Pad 0",
+    "Key: F8",
+    "Key: 8",
+    "Key: I",
+    "Key: K",
+    "Key: M",
+    "Key: Right Windows",
+    "Key: \\ (ANSI)",
+    "Key: Up Arrow",
+    "Key: Number Pad 5",
+    "Key: Number Pad Enter",
+    "Key: Number Pad ."
+};
+
+RGBController_HyperXAlloyFPS::RGBController_HyperXAlloyFPS(HyperXAlloyFPSController* hyperx_ptr)
+{
+    controller  = hyperx_ptr;
+
+    name        = "HyperX Alloy FPS";
+    vendor      = "HyperX";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "HyperX Alloy FPS Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+
+    /*-----------------------------------------------------*\
+    | The HyperX Alloy FPS requires a steady stream of      |
+    | packets in order to not revert out of direct mode.    |
+    | Start a thread to continuously refresh the device     |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = true;
+    keepalive_thread = new std::thread(&RGBController_HyperXAlloyFPS::KeepaliveThreadFunction, this);
+}
+
+RGBController_HyperXAlloyFPS::~RGBController_HyperXAlloyFPS()
+{
+    keepalive_thread_run = false;
+    keepalive_thread->join();
+    delete keepalive_thread;
+
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].matrix_map != NULL)
+        {
+            delete zones[zone_index].matrix_map;
+        }
+    }
+
+    delete controller;
+}
+
+void RGBController_HyperXAlloyFPS::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    unsigned int total_led_count = 0;
+    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
+    {
+        zone new_zone;
+        new_zone.name                   = zone_names[zone_idx];
+        new_zone.type                   = zone_types[zone_idx];
+        new_zone.leds_min               = zone_sizes[zone_idx];
+        new_zone.leds_max               = zone_sizes[zone_idx];
+        new_zone.leds_count             = zone_sizes[zone_idx];
+
+        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
+        {
+            new_zone.matrix_map         = new matrix_map_type;
+            new_zone.matrix_map->height = 6;
+            new_zone.matrix_map->width  = 23;
+            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
+        }
+
+        zones.push_back(new_zone);
+
+        total_led_count += zone_sizes[zone_idx];
+    }
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
+    {
+        led new_led;
+        new_led.name = led_names[led_idx];
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_HyperXAlloyFPS::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_HyperXAlloyFPS::DeviceUpdateLEDs()
+{
+    last_update_time = std::chrono::steady_clock::now();
+
+    if(active_mode == 0)
+    {
+        controller->SetLEDsDirect(colors);
+    }
+}
+
+void RGBController_HyperXAlloyFPS::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_HyperXAlloyFPS::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_HyperXAlloyFPS::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_HyperXAlloyFPS::DeviceUpdateMode()
+{
+
+}
+
+void RGBController_HyperXAlloyFPS::KeepaliveThreadFunction()
+{
+    while(keepalive_thread_run)
+    {
+        if(active_mode == 0)
+        {
+            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50))
+            {
+                UpdateLEDs();
+            }
+        }
+        std::this_thread::sleep_for(10ms);;
+    }
+}

Controllers/HyperXKeyboardController/RGBController_HyperXAlloyFPS.h

@@ -1,8 +1,8 @@
 /*-----------------------------------------*\
-|  RGBController_HyperXKeyboard.h           |
+|  RGBController_HyperXAlloyFPS.h           |
 |                                           |
-|  Generic RGB Interface for HyperX RGB     |
-|  Keyboard                                 |
+|  Generic RGB Interface for HyperX Alloy   |
+|  FPS Keyboard                             |
 |                                           |
 |  Adam Honse (CalcProgrammer1) 2/2/2020    |
 \*-----------------------------------------*/
@@ -13,13 +13,13 @@
 #include <thread>
 
 #include "RGBController.h"
-#include "HyperXKeyboardController.h"
+#include "HyperXAlloyFPSController.h"
 
-class RGBController_HyperXKeyboard : public RGBController
+class RGBController_HyperXAlloyFPS : public RGBController
 {
 public:
-    RGBController_HyperXKeyboard(HyperXKeyboardController* hyperx_ptr);
-    ~RGBController_HyperXKeyboard();
+    RGBController_HyperXAlloyFPS(HyperXAlloyFPSController* hyperx_ptr);
+    ~RGBController_HyperXAlloyFPS();
 
     void        SetupZones();
 
@@ -35,8 +35,8 @@ public:
     void        KeepaliveThreadFunction();
     
 private:
-    HyperXKeyboardController*   hyperx;
-    std::atomic<bool>   keepalive_thread_run;
-    std::thread*        keepalive_thread;
+    HyperXAlloyFPSController*                           controller;
+    std::atomic<bool>                                   keepalive_thread_run;
+    std::thread*                                        keepalive_thread;
     std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
 };

Controllers/LogitechController/LogitechControllerDetect.cpp

@@ -36,86 +36,88 @@ using namespace std::chrono_literals;
 /*-----------------------------------------------------*\
 | Logitech vendor ID                                    |
 \*-----------------------------------------------------*/
-#define LOGITECH_VID                            0x046D
-#define LOGITECH_LIGHTSPEED_DETECT_MAX_RETRY    10
+#define LOGITECH_VID                                0x046D
+#define LOGITECH_LIGHTSPEED_DETECT_MAX_RETRY        10
 
 /*-----------------------------------------------------*\
 | Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
-#define LOGITECH_G213_PID                       0xC336
-#define LOGITECH_G512_PID                       0xC342
-#define LOGITECH_G512_RGB_PID                   0xC33C
-#define LOGITECH_G610_1_PID                     0xC333
-#define LOGITECH_G610_2_PID                     0xC338
-#define LOGITECH_G810_1_PID                     0xC331
-#define LOGITECH_G810_2_PID                     0xC337
-#define LOGITECH_G813_PID                       0xC232
-#define LOGITECH_G815_PID                       0xC33F
-#define LOGITECH_G915_WIRED_PID                 0xC33E
-#define LOGITECH_G915_RECEIVER_PID              0xC541
-#define LOGITECH_G910_ORION_SPARK_PID           0xC32B
-#define LOGITECH_G910_PID                       0xC335
+#define LOGITECH_G213_PID                           0xC336
+#define LOGITECH_G512_PID                           0xC342
+#define LOGITECH_G512_RGB_PID                       0xC33C
+#define LOGITECH_G610_1_PID                         0xC333
+#define LOGITECH_G610_2_PID                         0xC338
+#define LOGITECH_G810_1_PID                         0xC331
+#define LOGITECH_G810_2_PID                         0xC337
+#define LOGITECH_G813_PID                           0xC232
+#define LOGITECH_G815_PID                           0xC33F
+#define LOGITECH_G915_WIRED_PID                     0xC33E
+#define LOGITECH_G915_RECEIVER_PID                  0xC541
+#define LOGITECH_G910_ORION_SPARK_PID               0xC32B
+#define LOGITECH_G910_PID                           0xC335
 
 /*-----------------------------------------------------*\
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
-#define LOGITECH_G203_PID                       0xC084
-#define LOGITECH_G203_LIGHTSYNC_PID             0xC092
-#define LOGITECH_G303_PID                       0xC080
-#define LOGITECH_G403_PID                       0xC083
-#define LOGITECH_G403_HERO_PID                  0xC08F
-#define LOGITECH_G403_LIGHTSPEED_PID            0xC082
-#define LOGITECH_G502_PROTEUS_SPECTRUM_PID      0xC332
-#define LOGITECH_G502_HERO_PID                  0xC08B
-#define LOGITECH_G502_LIGHTSPEED_PID            0xC08D
-#define LOGITECH_G703_LIGHTSPEED_PID            0xC087
-#define LOGITECH_G900_LIGHTSPEED_PID            0xC081
-#define LOGITECH_G903_LIGHTSPEED_PID            0xC086
-#define LOGITECH_G_PRO_PID                      0xC085
-#define LOGITECH_G_PRO_HERO_PID                 0xC08C
-#define LOGITECH_G_PRO_WIRELESS_PID             0xC088
+#define LOGITECH_G203_PID                           0xC084
+#define LOGITECH_G203_LIGHTSYNC_PID                 0xC092
+#define LOGITECH_G303_PID                           0xC080
+#define LOGITECH_G403_PID                           0xC083
+#define LOGITECH_G403_HERO_PID                      0xC08F
+#define LOGITECH_G403_LIGHTSPEED_PID                0xC082
+#define LOGITECH_G502_PROTEUS_SPECTRUM_PID          0xC332
+#define LOGITECH_G502_HERO_PID                      0xC08B
+#define LOGITECH_G502_LIGHTSPEED_PID                0xC08D
+#define LOGITECH_G703_LIGHTSPEED_PID                0xC087
+#define LOGITECH_G703_HERO_LIGHTSPEED_PID           0xC090
+#define LOGITECH_G900_LIGHTSPEED_PID                0xC081
+#define LOGITECH_G903_LIGHTSPEED_PID                0xC086
+#define LOGITECH_G_PRO_PID                          0xC085
+#define LOGITECH_G_PRO_HERO_PID                     0xC08C
+#define LOGITECH_G_PRO_WIRELESS_PID                 0xC088
 
 /*-----------------------------------------------------*\
 | Mousemat product IDs                                  |
 \*-----------------------------------------------------*/
-#define LOGITECH_G_LIGHTSPEED_POWERPLAY_PID     0xC53A
+#define LOGITECH_G_LIGHTSPEED_POWERPLAY_PID         0xC53A
 
 /*-----------------------------------------------------*\
 | Speaker product IDs                                   |
 \*-----------------------------------------------------*/
-#define LOGITECH_G560_PID                       0x0A78
+#define LOGITECH_G560_PID                           0x0A78
 
 /*-----------------------------------------------------*\
 | Headset product IDs                                   |
 \*-----------------------------------------------------*/
-#define LOGITECH_G933_PID                       0x0A5B
-#define LOGITECH_G733_PID                       0x0AB5
+#define LOGITECH_G933_PID                           0x0A5B
+#define LOGITECH_G733_PID                           0x0AB5
 
 /*-----------------------------------------------------*\
 | Unifying Device IDs (Including Lightspeed receivers)  |
 |   NB: Not used but preserved for debugging            |
 \*-----------------------------------------------------*/
-#define LOGITECH_G_UNIFYING_RECEIVER_1_PID              0xC52B
-#define LOGITECH_G_NANO_RECEIVER_PID                    0xC52F
-#define LOGITECH_G_G700_RECEIVER_PID                    0xC531
-#define LOGITECH_G_UNIFYING_RECEIVER_2_PID              0xC532
-#define LOGITECH_G_G602_RECEIVER_PID                    0xC537
+#define LOGITECH_G_UNIFYING_RECEIVER_1_PID          0xC52B
+#define LOGITECH_G_NANO_RECEIVER_PID                0xC52F
+#define LOGITECH_G_G700_RECEIVER_PID                0xC531
+#define LOGITECH_G_UNIFYING_RECEIVER_2_PID          0xC532
+#define LOGITECH_G_G602_RECEIVER_PID                0xC537
 
-#define LOGITECH_G_LIGHTSPEED_RECEIVER_PID              0xC539
-#define LOGITECH_G403_LIGHTSPEED_VIRTUAL_PID            0x405D
-#define LOGITECH_G502_LIGHTSPEED_VIRTUAL_PID            0x407F
-#define LOGITECH_G703_LIGHTSPEED_VIRTUAL_PID            0x4070
-#define LOGITECH_G900_LIGHTSPEED_VIRTUAL_PID            0x4053
-#define LOGITECH_G903_LIGHTSPEED_VIRTUAL_PID            0x4067
-#define LOGITECH_G_PRO_WIRELESS_VIRTUAL_PID             0x4079
-#define LOGITECH_POWERPLAY_MAT_VIRTUAL_PID              0x405F
+#define LOGITECH_G_LIGHTSPEED_RECEIVER_PID          0xC539
+#define LOGITECH_G403_LIGHTSPEED_VIRTUAL_PID        0x405D
+#define LOGITECH_G502_LIGHTSPEED_VIRTUAL_PID        0x407F
+#define LOGITECH_G703_LIGHTSPEED_VIRTUAL_PID        0x4070
+#define LOGITECH_G703_HERO_LIGHTSPEED_VIRTUAL_PID   0x4086
+#define LOGITECH_G900_LIGHTSPEED_VIRTUAL_PID        0x4053
+#define LOGITECH_G903_LIGHTSPEED_VIRTUAL_PID        0x4067
+#define LOGITECH_G_PRO_WIRELESS_VIRTUAL_PID         0x4079
+#define LOGITECH_POWERPLAY_MAT_VIRTUAL_PID          0x405F
 
 /*-----------------------------------------------------*\
 | Joystick product IDs                                  |
 \*-----------------------------------------------------*/
-#define LOGITECH_X56_VID                                0x0738
-#define LOGITECH_X56_JOYSTICK_PID                       0x2221
-#define LOGITECH_X56_THROTTLE_PID                       0xA221
+#define LOGITECH_X56_VID                            0x0738
+#define LOGITECH_X56_JOYSTICK_PID                   0x2221
+#define LOGITECH_X56_THROTTLE_PID                   0xA221
 
 /*-----------------------------------------------------*\
 | Logitech Keyboards                                    |
@@ -494,11 +496,6 @@ void DetectLogitechMouseG403(hid_device_info* info, const std::string& name)
     addLogitechLightsyncMouse2zone(info, name, 0xFF, 0x0E, 0x3A);
 }
 
-void DetectLogitechMouseG502PS(hid_device_info* info, const std::string& name)
-{
-    addLogitechLightsyncMouse2zone(info, name, 0xFF, 0x02, 0x3A);
-}
-
 void DetectLogitechMouseGPRO(hid_device_info* info, const std::string& name)
 {
     addLogitechLightsyncMouse1zone(info, name, 0xFF, 0x0E, 0x3C);
@@ -555,46 +552,108 @@ void DetectLogitechX56(hid_device_info* info, const std::string& name)
     }
 }
 
-/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Keyboards                                                                                                                                                                                         |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G213",                                                  DetectLogitechKeyboardG213,      LOGITECH_VID, LOGITECH_G213_PID,                    1, 0xFF43, 0x0602);
-REGISTER_HID_DETECTOR_IP ("Logitech G512",                                                  DetectLogitechKeyboardG810,      LOGITECH_VID, LOGITECH_G512_PID,                    1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G512 RGB",                                              DetectLogitechKeyboardG810,      LOGITECH_VID, LOGITECH_G512_RGB_PID,                1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G610 Orion",                                            DetectLogitechKeyboardG810,      LOGITECH_VID, LOGITECH_G610_1_PID,                  1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G610 Orion",                                            DetectLogitechKeyboardG810,      LOGITECH_VID, LOGITECH_G610_2_PID,                  1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G810 Orion Spectrum",                                   DetectLogitechKeyboardG810,      LOGITECH_VID, LOGITECH_G810_1_PID,                  1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G810 Orion Spectrum",                                   DetectLogitechKeyboardG810,      LOGITECH_VID, LOGITECH_G810_2_PID,                  1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G813 RGB Mechanical Gaming Keyboard",                   DetectLogitechKeyboardG815,      LOGITECH_VID, LOGITECH_G813_PID,                    1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G815 RGB Mechanical Gaming Keyboard",                   DetectLogitechKeyboardG815,      LOGITECH_VID, LOGITECH_G815_PID,                    1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G910 Orion Spark",                                      DetectLogitechKeyboardG910,      LOGITECH_VID, LOGITECH_G910_ORION_SPARK_PID,        1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G910 Orion Spectrum",                                   DetectLogitechKeyboardG910,      LOGITECH_VID, LOGITECH_G910_PID,                    1, 0xFF43);
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Keyboards                                                                                                                                         |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Logitech G213",                                  DetectLogitechKeyboardG213, LOGITECH_VID, LOGITECH_G213_PID,                    1, 0xFF43, 0x0602);
+REGISTER_HID_DETECTOR_IP ("Logitech G512",                                  DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G512_PID,                    1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G512 RGB",                              DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G512_RGB_PID,                1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G610 Orion",                            DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G610_1_PID,                  1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G610 Orion",                            DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G610_2_PID,                  1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G810 Orion Spectrum",                   DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G810_1_PID,                  1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G810 Orion Spectrum",                   DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G810_2_PID,                  1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G813 RGB Mechanical Gaming Keyboard",   DetectLogitechKeyboardG815, LOGITECH_VID, LOGITECH_G813_PID,                    1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G815 RGB Mechanical Gaming Keyboard",   DetectLogitechKeyboardG815, LOGITECH_VID, LOGITECH_G815_PID,                    1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G910 Orion Spark",                      DetectLogitechKeyboardG910, LOGITECH_VID, LOGITECH_G910_ORION_SPARK_PID,        1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G910 Orion Spectrum",                   DetectLogitechKeyboardG910, LOGITECH_VID, LOGITECH_G910_PID,                    1, 0xFF43);
 REGISTER_HID_DETECTOR_IPU("Logitech G915 Wireless RGB Mechanical Gaming Keyboard",          DetectLogitechKeyboardG915,      LOGITECH_VID, LOGITECH_G915_RECEIVER_PID,           2, 0xFF00, 2);
 REGISTER_HID_DETECTOR_IPU("Logitech G915 Wireless RGB Mechanical Gaming Keyboard (Wired)",  DetectLogitechKeyboardG915Wired, LOGITECH_VID, LOGITECH_G915_WIRED_PID,              2, 0xFF00, 2);
-/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Mice                                                                                                                                                                                              |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP ("Logitech G203 Prodigy",                                          DetectLogitechMouseG203,         LOGITECH_VID, LOGITECH_G203_PID,                    1, 0xFF00);
-REGISTER_HID_DETECTOR_IPU("Logitech G203 Lightsync",                                        DetectLogitechMouseG203L,        LOGITECH_VID, LOGITECH_G203_LIGHTSYNC_PID,          1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IP ("Logitech G303 Daedalus Apex",                                    DetectLogitechMouseG303,         LOGITECH_VID, LOGITECH_G303_PID,                    1, 0xFF00);
-REGISTER_HID_DETECTOR_IP ("Logitech G403 Hero",                                             DetectLogitechMouseG403,         LOGITECH_VID, LOGITECH_G403_HERO_PID,               1, 0xFF00);
-REGISTER_HID_DETECTOR_IP ("Logitech G502 Proteus Spectrum Gaming Mouse",                    DetectLogitechMouseG502PS,       LOGITECH_VID, LOGITECH_G502_PROTEUS_SPECTRUM_PID,   1, 0xFF00);
-REGISTER_HID_DETECTOR_IP ("Logitech G502 Hero Gaming Mouse",                                DetectLogitechMouseG502PS,       LOGITECH_VID, LOGITECH_G502_HERO_PID,               1, 0xFF00);
-REGISTER_HID_DETECTOR_IP ("Logitech G Pro Gaming Mouse",                                    DetectLogitechMouseGPRO,         LOGITECH_VID, LOGITECH_G_PRO_PID,                   1, 0xFF00);
-REGISTER_HID_DETECTOR_IP ("Logitech G Pro (HERO) Gaming Mouse",                             DetectLogitechMouseGPRO,         LOGITECH_VID, LOGITECH_G_PRO_HERO_PID,              1, 0xFF00);
-/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Speakers                                                                                                                                                                                          |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G560 Lightsync Speaker",                                DetectLogitechG560,              LOGITECH_VID, LOGITECH_G560_PID,                    2, 0xFF43, 514);
-/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Headsets                                                                                                                                                                                          |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G933 Lightsync Headset",                                DetectLogitechG933,              LOGITECH_VID, LOGITECH_G933_PID,                    3, 0xFF43, 514);
-/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Joysticks                                                                                                                                                                                         |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Logitech X56 Rhino Hotas Joystick",                               DetectLogitechX56,               LOGITECH_X56_VID, LOGITECH_X56_JOYSTICK_PID,        2, 0xFF00);
-REGISTER_HID_DETECTOR_IP("Logitech X56 Rhino Hotas Throttle",                               DetectLogitechX56,               LOGITECH_X56_VID, LOGITECH_X56_THROTTLE_PID,        2, 0xFF00);
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Mice                                                                                                                                              |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP ("Logitech G203 Prodigy",                          DetectLogitechMouseG203,    LOGITECH_VID, LOGITECH_G203_PID,                    1, 0xFF00);
+REGISTER_HID_DETECTOR_IPU("Logitech G203 Lightsync",                        DetectLogitechMouseG203L,   LOGITECH_VID, LOGITECH_G203_LIGHTSYNC_PID,          1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IP ("Logitech G303 Daedalus Apex",                    DetectLogitechMouseG303,    LOGITECH_VID, LOGITECH_G303_PID,                    1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G403 Hero",                             DetectLogitechMouseG403,    LOGITECH_VID, LOGITECH_G403_HERO_PID,               1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G Pro Gaming Mouse",                    DetectLogitechMouseGPRO,    LOGITECH_VID, LOGITECH_G_PRO_PID,                   1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G Pro (HERO) Gaming Mouse",             DetectLogitechMouseGPRO,    LOGITECH_VID, LOGITECH_G_PRO_HERO_PID,              1, 0xFF00);
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Speakers                                                                                                                                         |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Logitech G560 Lightsync Speaker",                DetectLogitechG560,         LOGITECH_VID, LOGITECH_G560_PID,                    2, 0xFF43, 514);
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Headsets                                                                                                                                         |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Logitech G933 Lightsync Headset",                DetectLogitechG933,         LOGITECH_VID, LOGITECH_G933_PID,                    3, 0xFF43, 514);
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Joysticks                                                                                                                                         |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("Logitech X56 Rhino Hotas Joystick",               DetectLogitechX56,          LOGITECH_X56_VID, LOGITECH_X56_JOYSTICK_PID,        2, 0xFF00);
+REGISTER_HID_DETECTOR_IP("Logitech X56 Rhino Hotas Throttle",               DetectLogitechX56,          LOGITECH_X56_VID, LOGITECH_X56_THROTTLE_PID,        2, 0xFF00);
+
+
+
+
+
+/*---------------------------------------------------------------------------------------------------------*\
+| Common Lightspeed Detection                                                                               |
+|                                                                                                           |
+\*---------------------------------------------------------------------------------------------------------*/
+
+void CreateLogitechLightspeedDevice(char *path, usages device_usages, uint8_t device_index, uint16_t pid, bool wireless, std::shared_ptr<std::mutex> mutex_ptr)
+{
+    LogitechLightspeedController* controller                = new LogitechLightspeedController(device_usages.find(2)->second, path);
+    bool lightspeedDeviceIsValid                            = false;
+    int retryCount                                          = 0;
+
+    while (!lightspeedDeviceIsValid && retryCount < LOGITECH_LIGHTSPEED_DETECT_MAX_RETRY)
+    {
+        std::this_thread::sleep_for(50ms);
+        controller->lightspeed                              = new logitech_device(path, device_usages, device_index, wireless, mutex_ptr);
+        lightspeedDeviceIsValid                             = controller->lightspeed->is_valid();
+        retryCount++;
+    }
+
+    if (retryCount < LOGITECH_LIGHTSPEED_DETECT_MAX_RETRY)
+    {
+        RGBController_LogitechLightspeed* rgb_controller    = new RGBController_LogitechLightspeed(controller);
+        rgb_controller->pid                                 = pid;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        LOG_DEBUG("Added controller in %i retries", retryCount);
+    }
+    else
+    {
+        delete controller;
+        LOG_DEBUG("Failed to set up device - exceeded retries");
+    }
+}
+
+void DetectLogitechWired(hid_device_info* info, const std::string& /*name*/)
+{
+    /*-----------------------------------------------------------------*\
+    | Wired lightspeed devices don't use the FAP short message          |
+    |   Be sure to specify a Page AND Usage when using this detector    |
+    |   i.e. REGISTER_HID_DETECTOR_IPU                                  |
+    \*-----------------------------------------------------------------*/
+    //char        *path           = info->path;
+    usages      device_usages;
+    hid_device* dev             = hid_open_path(info->path);
+
+    if(dev)
+    {
+        LOG_DEBUG("Adding Usage %i for device @ path %s", info->usage, info->path);
+        device_usages.emplace((uint8_t)info->usage, dev);
+    }
+    else
+    {
+        LOG_DEBUG("Error opening Usage %i for device @ path %s", info->usage, info->path);
+    }
+
+    if(device_usages.size() > 0)
+    {
+        CreateLogitechLightspeedDevice(info->path, device_usages, LOGITECH_DEFAULT_DEVICE_INDEX, info->product_id, false, nullptr);
+    }
+}
 
 /*---------------------------------------------------------------------------------------------------------*\
 | Windows and MacOS Lightspeed Detection                                                                    |
@@ -646,33 +705,6 @@ usages BundleLogitechUsages(hid_device_info* info)
     return temp_usages;
 }
 
-void CreateLogitechLightspeedDevice(char *path, usages device_usages, uint8_t device_index, bool wireless, std::shared_ptr<std::mutex> mutex_ptr)
-{
-    LogitechLightspeedController* controller                = new LogitechLightspeedController(device_usages.find(2)->second, path);
-    bool lightspeedDeviceIsValid                            = false;
-    int retryCount                                          = 0;
-
-    while (!lightspeedDeviceIsValid && retryCount < LOGITECH_LIGHTSPEED_DETECT_MAX_RETRY)
-    {
-        std::this_thread::sleep_for(50ms);
-        controller->lightspeed                              = new logitech_device(path, device_usages, device_index, wireless, mutex_ptr);
-        lightspeedDeviceIsValid                             = controller->lightspeed->is_valid();
-        retryCount++;
-    }
-
-    if (retryCount < LOGITECH_LIGHTSPEED_DETECT_MAX_RETRY)
-    {
-        RGBController_LogitechLightspeed* rgb_controller    = new RGBController_LogitechLightspeed(controller);
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-        LOG_DEBUG("Added controller in %i retries", retryCount);
-    }
-    else
-    {
-        delete controller;
-        LOG_DEBUG("Failed to set up device - exceeded retries");
-    }
-}
-
 void DetectLogitechLightspeedReceiver(hid_device_info* info, const std::string& /*name*/)
 {
     /*-----------------------------------------------------------------*\
@@ -700,17 +732,32 @@ void DetectLogitechLightspeedReceiver(hid_device_info* info, const std::string&
 
         for(wireless_map::iterator wd = wireless_devices.begin(); wd != wireless_devices.end(); wd++)
         {
-            CreateLogitechLightspeedDevice(path, device_usages, wd->second, true, logitech_mutex);
+            CreateLogitechLightspeedDevice(path, device_usages, wd->second, dev_pid, true, logitech_mutex);
         }
     }
 }
 
-void DetectLogitechWired(hid_device_info* info, const std::string& /*name*/)
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Lightspeed Receivers (Windows Wireless)                                                                                                           |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("Logitech Lightspeed Receiver",                        DetectLogitechLightspeedReceiver,   LOGITECH_VID, LOGITECH_G_LIGHTSPEED_RECEIVER_PID,   2, 0xFF00);
+REGISTER_HID_DETECTOR_IP("Logitech G Powerplay Mousepad",                       DetectLogitechLightspeedReceiver,   LOGITECH_VID, LOGITECH_G_LIGHTSPEED_POWERPLAY_PID,  2, 0xFF00);
+
+#endif
+
+/*---------------------------------------------------------------------------------------------------------*\
+| Linux Lightspeed Detection                                                                                |
+|                                                                                                           |
+| The Linux kernel handles detecting wireless devices connected to a Unifying Receiver.                     |
+\*---------------------------------------------------------------------------------------------------------*/
+#ifdef __linux__
+
+void DetectLogitechWireless(hid_device_info* info, const std::string& /*name*/)
 {
     /*-----------------------------------------------------------------*\
-    | Wired lightspeed devices don't use the FAP short message          |
-    |   Be sure to specify a Page AND Usage when using this detector    |
-    |   i.e. REGISTER_HID_DETECTOR_IPU                                  |
+    | Wireless lightspeed devices on Linux are handled by the Kernel    |
+    |   and as such can largely be treated as Wired with the caveat     |
+    |   that they may not be connected                                  |
     \*-----------------------------------------------------------------*/
     //char        *path           = info->path;
     usages      device_usages;
@@ -728,105 +775,42 @@ void DetectLogitechWired(hid_device_info* info, const std::string& /*name*/)
 
     if(device_usages.size() > 0)
     {
-        CreateLogitechLightspeedDevice(info->path, device_usages, 0xFF, false, nullptr);
+        /*-------------------------------------------------*\
+        | Create mutex to prevent the controllers sharing a |
+        |   receiver from interfering with each other       |
+        \*-------------------------------------------------*/
+        std::shared_ptr<std::mutex>       logitech_mutex = std::make_shared<std::mutex>();
+
+        CreateLogitechLightspeedDevice(info->path, device_usages, LOGITECH_DEFAULT_DEVICE_INDEX, info->product_id, true, logitech_mutex);
     }
 }
 
-/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Lightspeed Receivers (Windows Wireless)                                                                                                           |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Logitech Lightspeed Receiver",                        DetectLogitechLightspeedReceiver,   LOGITECH_VID, LOGITECH_G_LIGHTSPEED_RECEIVER_PID,   2, 0xFF00);
-REGISTER_HID_DETECTOR_IP("Logitech G Powerplay Mousepad",                       DetectLogitechLightspeedReceiver,   LOGITECH_VID, LOGITECH_G_LIGHTSPEED_POWERPLAY_PID,  2, 0xFF00);
-
-/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Lightspeed Wireless Devices (Windows Wired)                                                                                                       |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G403 Wireless Gaming Mouse (wired)",        DetectLogitechWired,                LOGITECH_VID, LOGITECH_G403_LIGHTSPEED_PID,         1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G502 Wireless Gaming Mouse (wired)",        DetectLogitechWired,                LOGITECH_VID, LOGITECH_G502_LIGHTSPEED_PID,         1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G703 Wireless Gaming Mouse (wired)",        DetectLogitechWired,                LOGITECH_VID, LOGITECH_G703_LIGHTSPEED_PID,         1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G900 Wireless Gaming Mouse (wired)",        DetectLogitechWired,                LOGITECH_VID, LOGITECH_G900_LIGHTSPEED_PID,         1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G903 Wireless Gaming Mouse (wired)",        DetectLogitechWired,                LOGITECH_VID, LOGITECH_G903_LIGHTSPEED_PID,         1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G Pro Wireless Gaming Mouse (wired)",       DetectLogitechWired,                LOGITECH_VID, LOGITECH_G_PRO_WIRELESS_PID,          2, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G733 Gaming Headset",                       DetectLogitechWired,                LOGITECH_VID, LOGITECH_G733_PID,                    2, 0xFF43, 514);
-
-#endif
-
-/*---------------------------------------------------------------------------------------------------------*\
-| Linux Lightspeed Detection                                                                                |
-|                                                                                                           |
-| The Linux kernel handles detecting wireless devices connected to a Unifying Receiver.                     |
-\*---------------------------------------------------------------------------------------------------------*/
-#ifdef __linux__
-
-void CreateLogitechLightspeedDevice(hid_device_info* info, bool wireless)
-{
-    usages      device_usages;
-
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        device_usages.emplace((uint8_t)info->usage, dev);
-    }
-
-    if(device_usages.size() > 0)
-    {
-        LogitechLightspeedController* controller                = new LogitechLightspeedController(device_usages.find(0)->second, info->path);
-        bool lightspeedDeviceIsValid                            = false;
-        int retryCount                                          = 0;
-
-        while (!lightspeedDeviceIsValid && retryCount < LOGITECH_LIGHTSPEED_DETECT_MAX_RETRY)
-        {
-            std::this_thread::sleep_for(50ms);
-            controller->lightspeed                              = new logitech_device(info->path, device_usages, 0xFF, wireless);
-            lightspeedDeviceIsValid                             = controller->lightspeed->is_valid();
-            retryCount++;
-        }
-
-        if (retryCount < LOGITECH_LIGHTSPEED_DETECT_MAX_RETRY)
-        {
-            RGBController_LogitechLightspeed* rgb_controller    = new RGBController_LogitechLightspeed(controller);
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
-            LOG_DEBUG("Added controller in %i retries", retryCount);
-        }
-        else
-        {
-            delete controller;
-            LOG_DEBUG("Failed to set up device - exceeded retries");
-        }
-    }
-}
-
-void DetectLogitechWireless(hid_device_info* info, const std::string& /*name*/)
-{
-    CreateLogitechLightspeedDevice(info, true);
-}
-
-void DetectLogitechWired(hid_device_info* info, const std::string& /*name*/)
-{
-    CreateLogitechLightspeedDevice(info, false);
-}
-
 /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
 | Lightspeed Devices (Linux Wireless)                                                                                                               |
 \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G403 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G403_LIGHTSPEED_VIRTUAL_PID, 2, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G502 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G502_LIGHTSPEED_VIRTUAL_PID, 2, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G703 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G703_LIGHTSPEED_VIRTUAL_PID, 2, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G900 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G900_LIGHTSPEED_VIRTUAL_PID, 2, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G903 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G903_LIGHTSPEED_VIRTUAL_PID, 2, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G Pro Wireless Gaming Mouse",               DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G_PRO_WIRELESS_VIRTUAL_PID,  2, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech Powerplay Mat",                             DetectLogitechWireless,     LOGITECH_VID, LOGITECH_POWERPLAY_MAT_VIRTUAL_PID,   2, 0xFF00, 2);
-
-/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Lightspeed Wireless Devices (Linux Wired)                                                                                                          |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G403 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G403_LIGHTSPEED_PID,         1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G502 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G502_LIGHTSPEED_PID,         1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G703 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G703_LIGHTSPEED_PID,         1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G900 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G900_LIGHTSPEED_PID,         1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G903 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G903_LIGHTSPEED_PID,         1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G Pro Wireless Gaming Mouse (wired)",       DetectLogitechWired,        LOGITECH_VID, LOGITECH_G_PRO_WIRELESS_PID,          2, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G733 Gaming Headset",                       DetectLogitechWired,        LOGITECH_VID, LOGITECH_G733_PID,                    2, 0xFF43, 514);
+REGISTER_HID_DETECTOR_IPU("Logitech G403 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G403_LIGHTSPEED_VIRTUAL_PID,         2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G502 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G502_LIGHTSPEED_VIRTUAL_PID,         2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G703 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G703_LIGHTSPEED_VIRTUAL_PID,         2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G703 Hero Wireless Gaming Mouse",           DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G703_HERO_LIGHTSPEED_VIRTUAL_PID,    2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G900 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G900_LIGHTSPEED_VIRTUAL_PID,         2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G903 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G903_LIGHTSPEED_VIRTUAL_PID,         2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G Pro Wireless Gaming Mouse",               DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G_PRO_WIRELESS_VIRTUAL_PID,          2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech Powerplay Mat",                             DetectLogitechWireless,     LOGITECH_VID, LOGITECH_POWERPLAY_MAT_VIRTUAL_PID,           2, 0xFF00, 2);
 
 #endif
+
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Lightspeed Wireless Devices (Common Wired)                                                                                                          |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Logitech G502 Proteus Spectrum Gaming Mouse",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G502_PROTEUS_SPECTRUM_PID,           1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G502 Hero Gaming Mouse",                    DetectLogitechWired,        LOGITECH_VID, LOGITECH_G502_HERO_PID,                       1, 0xFF00, 2);
+
+REGISTER_HID_DETECTOR_IPU("Logitech G403 Prodigy Gaming Mouse",                 DetectLogitechWired,        LOGITECH_VID, LOGITECH_G403_PID,                            1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G403 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G403_LIGHTSPEED_PID,                 1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G502 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G502_LIGHTSPEED_PID,                 1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G703 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G703_LIGHTSPEED_PID,                 1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G703 Hero Wireless Gaming Mouse (wired)",   DetectLogitechWired,        LOGITECH_VID, LOGITECH_G703_HERO_LIGHTSPEED_PID,            1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G900 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G900_LIGHTSPEED_PID,                 1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G903 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G903_LIGHTSPEED_PID,                 1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G Pro Wireless Gaming Mouse (wired)",       DetectLogitechWired,        LOGITECH_VID, LOGITECH_G_PRO_WIRELESS_PID,                  2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G733 Gaming Headset",                       DetectLogitechWired,        LOGITECH_VID, LOGITECH_G733_PID,                            2, 0xFF43, 514);

Controllers/LogitechController/LogitechLightspeedController.cpp

@@ -37,10 +37,10 @@ std::string LogitechLightspeedController::GetSerialString()
     else
     {
         wchar_t serial_string[128];
-        int ret = hid_get_serial_number_string(dev, serial_string, 128);
-        LOG_DEBUG("[%s] hid_get_serial_number_string Returned status - %i : %s", lightspeed->device_name.c_str(), ret, ((ret == 0) ? "SUCCESS" : "FAILED"));
+        //int ret = hid_get_serial_number_string(dev, serial_string, 128);
+        //LOG_DEBUG("[%s] hid_get_serial_number_string Returned status - %i : %s", lightspeed->device_name.c_str(), ret, ((ret == 0) ? "SUCCESS" : "FAILED"));
 
-        if(ret != 0)
+        //if(ret != 0)
         {
             return("");
         }
@@ -55,13 +55,14 @@ std::string LogitechLightspeedController::GetSerialString()
 void LogitechLightspeedController::SendMouseMode
     (
     unsigned char       mode,
-    std::uint16_t       speed,
+    uint16_t            speed,
     unsigned char       zone,
     unsigned char       red,
     unsigned char       green,
-    unsigned char       blue
-  //  unsigned char       brightness
+    unsigned char       blue,
+    unsigned char       brightness,
+    bool                bright_cycle_swap
     )
 {
-    lightspeed->setMode(mode, speed, zone, red, green, blue, 0x64);
+    lightspeed->setMode(mode, speed, zone, red, green, blue, brightness, bright_cycle_swap);
 }

Controllers/LogitechController/LogitechLightspeedController.h

@@ -16,6 +16,8 @@
 #include <hidapi/hidapi.h>
 
 #pragma once
+#define LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MIN      0x01
+#define LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX      0x64
 
 enum
 {
@@ -50,12 +52,13 @@ public:
     void        SendMouseMode
                    (
                     unsigned char       mode,
-                    unsigned short      speed,
+                    uint16_t            speed,
                     unsigned char       zone,
                     unsigned char       red,
                     unsigned char       green,
-                    unsigned char       blue
-//                    unsigned char       brightness
+                    unsigned char       blue,
+                    unsigned char       brightness,
+                    bool                bright_cycle_swap
                    );
 
 private:

Controllers/LogitechController/LogitechProtocolCommon.cpp

@@ -11,8 +11,8 @@
 
 static std::vector<uint16_t> logitech_RGB_pages =
 {
-    0x8070,
-    0x8071
+    LOGITECH_HIDPP_PAGE_RGB_EFFECTS1,
+    LOGITECH_HIDPP_PAGE_RGB_EFFECTS2
 };
 
 int getWirelessDevice(usages device_usages, uint16_t pid, wireless_map *wireless_devices)
@@ -39,7 +39,7 @@ int getWirelessDevice(usages device_usages, uint16_t pid, wireless_map *wireless
         response.init();
 
         shortFAPrequest get_connected_devices;
-        get_connected_devices.init(LOGITECH_RECEIVER_ADDRESS, LOGITECH_GET_REGISTER_REQUEST);
+        get_connected_devices.init(LOGITECH_RECEIVER_DEVICE_INDEX, LOGITECH_GET_REGISTER_REQUEST);
 
         result = hid_write(dev_use1, get_connected_devices.buffer, get_connected_devices.size());
         result = hid_read_timeout(dev_use1, response.buffer, response.size(), LOGITECH_PROTOCOL_TIMEOUT);
@@ -48,7 +48,7 @@ int getWirelessDevice(usages device_usages, uint16_t pid, wireless_map *wireless
         if (!wireless_notifications)
         {
             response.init(); //zero out the response
-            get_connected_devices.init(LOGITECH_RECEIVER_ADDRESS, LOGITECH_SET_REGISTER_REQUEST);
+            get_connected_devices.init(LOGITECH_RECEIVER_DEVICE_INDEX, LOGITECH_SET_REGISTER_REQUEST);
             get_connected_devices.data[1] = 1;
             result = hid_write(dev_use1, get_connected_devices.buffer, get_connected_devices.size());
             result = hid_read_timeout(dev_use1, response.buffer, response.size(), LOGITECH_PROTOCOL_TIMEOUT);
@@ -60,7 +60,7 @@ int getWirelessDevice(usages device_usages, uint16_t pid, wireless_map *wireless
         }
 
         response.init(); //zero out the response
-        get_connected_devices.init(LOGITECH_RECEIVER_ADDRESS, LOGITECH_GET_REGISTER_REQUEST);
+        get_connected_devices.init(LOGITECH_RECEIVER_DEVICE_INDEX, LOGITECH_GET_REGISTER_REQUEST);
         get_connected_devices.feature_command       = 0x02;    //0x02 Connection State register. Essentially asking for count of paired devices
         result = hid_write(dev_use1, get_connected_devices.buffer, get_connected_devices.size());
         result = hid_read_timeout(dev_use1, response.buffer, response.size(), LOGITECH_PROTOCOL_TIMEOUT);
@@ -74,7 +74,7 @@ int getWirelessDevice(usages device_usages, uint16_t pid, wireless_map *wireless
             device_count++;     //Add 1 to the device_count to include the receiver
 
             response.init();
-            get_connected_devices.init(LOGITECH_RECEIVER_ADDRESS, LOGITECH_SET_REGISTER_REQUEST);
+            get_connected_devices.init(LOGITECH_RECEIVER_DEVICE_INDEX, LOGITECH_SET_REGISTER_REQUEST);
             get_connected_devices.feature_index     = LOGITECH_SET_REGISTER_REQUEST;
             get_connected_devices.feature_command   = 0x02;    //0x02 Connection State register
             get_connected_devices.data[0]           = 0x02;    //Writting 0x02 to the connection state register will ask the receiver to fake a reconnect of paired devices
@@ -93,7 +93,7 @@ int getWirelessDevice(usages device_usages, uint16_t pid, wireless_map *wireless
                 | We need to read the receiver from the HID device queue but        |
                 |    there is no need to add it as it's own device                  |
                 \*-----------------------------------------------------------------*/
-                if(devices.device_index != 0xFF)
+                if(devices.device_index != LOGITECH_RECEIVER_DEVICE_INDEX)
                 {
                     wireless_devices->emplace(wireless_PID, devices.device_index);
                 }
@@ -147,12 +147,20 @@ void logitech_device::initialiseDevice()
 
     if(is_connected)
     {
-        getDeviceName();            //This will get the name of the device if it exists
+        getDeviceName();
+
+        /*-----------------------------------------------------------------*\
+        | If this is running with DEBUG or higher loglevel then             |
+        |   dump the entire Feature list to log                             |
+        \*-----------------------------------------------------------------*/
         if(LogManager::get()->getLoglevel() > 4)
         {
             getDeviceFeatureList();     //This will populate the feature list
         }
 
+        /*-----------------------------------------------------------------*\
+        | Check device for known RGB Effects Feature pages & save the index |
+        \*-----------------------------------------------------------------*/
         for(std::vector<uint16_t>::iterator page = logitech_RGB_pages.begin(); page != logitech_RGB_pages.end(); page++)
         {
             int feature_index = getFeatureIndex(*page);
@@ -163,17 +171,13 @@ void logitech_device::initialiseDevice()
             }
         }
 
+        /*-----------------------------------------------------------------*\
+        | If there was no RGB Effect Feature  page found                    |
+        |   dump the entire Feature list to log                             |
+        \*-----------------------------------------------------------------*/
         if (RGB_feature_index == 0)
         {
-            /*-----------------------------------------------------------------*\
-            | If there was no RGB Effect Feature  page found                    |
-            |   dump the entire Feature list to log                             |
-            \*-----------------------------------------------------------------*/
             LOG_INFO("[%s] Unable add this device due to missing RGB Effects Feature", device_name.c_str());
-            /*for(features::iterator feature = feature_list.begin(); feature != feature_list.end(); feature++)
-            {
-                LOG_INFO("Feature Index: %02X\tFeature Page: %04X", feature->second, feature->first);
-            }*/
         }
         else
         {
@@ -332,13 +336,12 @@ int logitech_device::getDeviceFeatureList()
     int result = 0;
 
     /*-----------------------------------------------------------------*\
-    | Check the usage map for usage1 (0x10 Short FAP Message) & usage2  |
-    |   (0x11 Long FAP Message) then list all features for device       |
+    | Check the usage map for usage2 (0x11 Long FAP Message)            |
+    |   then list all features for device                               |
     \*-----------------------------------------------------------------*/
-    //hid_device* dev_use1 = getDevice(1);
     hid_device* dev_use2 = getDevice(2);
 
-    if(/*dev_use1 &&*/ dev_use2)
+    if(dev_use2)
     {
         /*-----------------------------------------------------------------*\
         | Create a buffer for reads                                         |
@@ -355,26 +358,18 @@ int logitech_device::getDeviceFeatureList()
         /*-----------------------------------------------------------------*\
         | Get the count of Features                                         |
         \*-----------------------------------------------------------------*/
-        //shortFAPrequest get_count;
         longFAPrequest get_count;
-        //get_count.init(device_index, feature_index);
-        //get_count.feature_command = LOGITECH_CMD_FEATURE_SET_GET_COUNT;
         get_count.init(device_index, feature_index, LOGITECH_CMD_FEATURE_SET_GET_COUNT);
 
-        //result = hid_write(dev_use1, get_count.buffer, get_count.size());
         result = hid_write(dev_use2, get_count.buffer, get_count.size());
         result = hid_read_timeout(dev_use2, response.buffer, response.size(), LOGITECH_PROTOCOL_TIMEOUT);
         unsigned int feature_count = response.data[0];
 
-        //shortFAPrequest get_features;
         longFAPrequest get_features;
-        //get_features.init(device_index, feature_index);
-        //get_features.feature_command = LOGITECH_CMD_FEATURE_SET_GET_ID;
         get_features.init(device_index, feature_index, LOGITECH_CMD_FEATURE_SET_GET_ID);
         for(std::size_t i = 1; feature_list.size() < feature_count; i++ )
         {
             get_features.data[0] = i;
-            //result = hid_write(dev_use1, get_features.buffer, get_features.size());
             result = hid_write(dev_use2, get_features.buffer, get_features.size());
             result = hid_read_timeout(dev_use2, response.buffer, response.size(), LOGITECH_PROTOCOL_TIMEOUT);
             LOG_DEBUG("[%s] Feature %04X @ index: %02X", device_name.c_str(), (response.data[0] << 8) | response.data[1], i);
@@ -383,14 +378,7 @@ int logitech_device::getDeviceFeatureList()
     }
     else
     {
-        /*if(!dev_use1)
-        {
-            LOG_INFO("[%s] Unable get the feature index list - missing Short Message (0x10) usage", device_name.c_str());
-        }*/
-        if(!dev_use2)
-        {
-            LOG_INFO("[%s] Unable get the feature index list - missing FAP Long Message (0x11) usage", device_name.c_str());
-        }
+        LOG_INFO("[%s] Unable get the feature index list - missing FAP Long Message (0x11) usage", device_name.c_str());
     }
 
     return feature_list.size();
@@ -418,28 +406,6 @@ int logitech_device::getDeviceName()
         \*-----------------------------------------------------------------*/
         int feature_index = getFeatureIndex(LOGITECH_HIDPP_PAGE_DEVICE_NAME_TYPE);
 
-        /*-----------------------------------------------------------------*\
-        | Check if the feature_list contains an index for the Device_name   |
-        |    feature otherwise query the root index. If not found return 0  |
-        \*-----------------------------------------------------------------*/
-        /*uint8_t name_feature_index;
-        features::iterator find_feature = feature_list.find(LOGITECH_HIDPP_PAGE_DEVICE_NAME_TYPE);
-        if (find_feature == feature_list.end())
-        {
-            longFAPrequest get_index;
-            get_index.init(device_index, LOGITECH_HIDPP_PAGE_ROOT_IDX, LOGITECH_CMD_ROOT_GET_FEATURE);
-            get_index.data[0] = LOGITECH_HIDPP_PAGE_DEVICE_NAME_TYPE >> 8;            //Get feature index of the Feature Set 0x0001
-            get_index.data[1] = LOGITECH_HIDPP_PAGE_DEVICE_NAME_TYPE & 0xFF;
-
-            result = hid_write(dev_use2, get_index.buffer, get_index.size());
-            result = hid_read_timeout(dev_use2, response.buffer, response.size(), LOGITECH_PROTOCOL_TIMEOUT);
-            name_feature_index = response.data[0];
-        }
-        else
-        {
-            name_feature_index = find_feature->second;
-        }*/
-
         /*-----------------------------------------------------------------*\
         | Get the device name length                                        |
         \*-----------------------------------------------------------------*/
@@ -563,14 +529,12 @@ uint8_t logitech_device::setDirectMode(bool direct)
     int result = 0;
 
     /*-----------------------------------------------------------------*\
-    | Check the usage map for usage1 (0x10 Short FAP Message) & usage2  |
-    |   (0x11 Long FAP Message) then set the device into direct mode    |
-    |   via register 0x8A                                               |
+    | Check the usage map for usage2 (0x11 Long FAP Message)            |
+    |   then set the device into direct mode via register 0x80          |
     \*-----------------------------------------------------------------*/
-    //hid_device* dev_use1 = getDevice(1);
     hid_device* dev_use2 = getDevice(2);
 
-    if(/*dev_use1 &&*/ dev_use2)
+    if(dev_use2)
     {
         /*-----------------------------------------------------------------*\
         | Create a buffer for reads                                         |
@@ -581,10 +545,7 @@ uint8_t logitech_device::setDirectMode(bool direct)
         /*-----------------------------------------------------------------*\
         | Turn the direct mode on or off via the RGB_feature_index          |
         \*-----------------------------------------------------------------*/
-        //shortFAPrequest set_direct;
         longFAPrequest set_direct;
-        //set_direct.init(device_index, RGB_feature_index);
-        //set_direct.feature_command = LOGITECH_CMD_RGB_EFFECTS_UNKNOWN;
         set_direct.init(device_index, RGB_feature_index, LOGITECH_CMD_RGB_EFFECTS_UNKNOWN);
         set_direct.data[0] = (direct) ? 1 : 0;
         set_direct.data[1] = set_direct.data[0];
@@ -600,13 +561,11 @@ uint8_t logitech_device::setDirectMode(bool direct)
         {
             std::lock_guard<std::mutex> guard(*mutex);
 
-            //result = hid_write(dev_use1, set_direct.buffer, set_direct.size());
             result = hid_write(dev_use2, set_direct.buffer, set_direct.size());
             result = hid_read_timeout(dev_use2, response.buffer, response.size(), LOGITECH_PROTOCOL_TIMEOUT);
         }
         else
         {
-            //result = hid_write(dev_use1, set_direct.buffer, set_direct.size());
             result = hid_write(dev_use2, set_direct.buffer, set_direct.size());
             result = hid_read_timeout(dev_use2, response.buffer, response.size(), LOGITECH_PROTOCOL_TIMEOUT);
         }
@@ -614,7 +573,7 @@ uint8_t logitech_device::setDirectMode(bool direct)
     return result;
 }
 
-uint8_t logitech_device::setMode(uint8_t mode, uint16_t speed, uint8_t zone, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness)
+uint8_t logitech_device::setMode(uint8_t mode, uint16_t speed, uint8_t zone, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness, bool bright_cycle_swap)
 {
     int result = 0;
 
@@ -651,12 +610,20 @@ uint8_t logitech_device::setMode(uint8_t mode, uint16_t speed, uint8_t zone, uin
         }
         else if(mode == 2)  //Spectrum Cycle
         {
+            if(bright_cycle_swap)
+            {
+                set_mode.data[1] = 3;
+            }
             set_mode.data[7]    = speed >> 8;
             set_mode.data[8]    = speed & 0xFF;
             set_mode.data[9]    = brightness;
         }
         else if(mode == 3)  //Breathing
         {
+            if(bright_cycle_swap)
+            {
+                set_mode.data[1] = 2;
+            }
             set_mode.data[5]    = speed >> 8;
             set_mode.data[6]    = speed & 0xFF;
             set_mode.data[8]    = brightness;

Controllers/LogitechController/LogitechProtocolCommon.h

@@ -14,21 +14,22 @@
 
 #pragma once
 
-#define LOGITECH_PROTOCOL_TIMEOUT       300     //Timeout in ms
-#define LOGITECH_HEADER_SIZE            3
-#define LOGITECH_SHORT_MESSAGE          0x10
-#define LOGITECH_SHORT_MESSAGE_LEN      7
-#define LOGITECH_LONG_MESSAGE           0x11
-#define LOGITECH_LONG_MESSAGE_LEN       20
-#define LOGITECH_FAP_RESPONSE_LEN       64      //Define a universal response buffer and allow the hidapi to determine the size
+#define LOGITECH_PROTOCOL_TIMEOUT                       300     //Timeout in ms
+#define LOGITECH_HEADER_SIZE                            3
+#define LOGITECH_SHORT_MESSAGE                          0x10
+#define LOGITECH_SHORT_MESSAGE_LEN                      7
+#define LOGITECH_LONG_MESSAGE                           0x11
+#define LOGITECH_LONG_MESSAGE_LEN                       20
+#define LOGITECH_FAP_RESPONSE_LEN                       64      //Define a universal response buffer and allow the hidapi to determine the size
 
-#define LOGITECH_RECEIVER_ADDRESS       0xFF    //The Unifying receiver uses RAP or register access protocol
-#define LOGITECH_SET_REGISTER_REQUEST   0x80
-#define LOGITECH_GET_REGISTER_REQUEST   0x81
+#define LOGITECH_DEFAULT_DEVICE_INDEX                   0xFF
+#define LOGITECH_RECEIVER_DEVICE_INDEX                  0xFF    //The Unifying receiver uses RAP or register access protocol
+#define LOGITECH_SET_REGISTER_REQUEST                   0x80
+#define LOGITECH_GET_REGISTER_REQUEST                   0x81
 
-#define LOGITECH_HIDPP_PAGE_ROOT_IDX    0x00    //Used for querying the feature index
-#define LOGITECH_CMD_ROOT_GET_FEATURE   0x01
-#define LOGITECH_CMD_ROOT_GET_PROTOCOL  0x11
+#define LOGITECH_HIDPP_PAGE_ROOT_IDX                    0x00    //Used for querying the feature index
+#define LOGITECH_CMD_ROOT_GET_FEATURE                   0x01
+#define LOGITECH_CMD_ROOT_GET_PROTOCOL                  0x11
 
 #define LOGITECH_HIDPP_PAGE_FEATURE_SET                 0x0001
 #define LOGITECH_CMD_FEATURE_SET_GET_COUNT              0x01
@@ -216,7 +217,7 @@ public:
     uint8_t                     getFeatureIndex(uint16_t feature_page);
     uint8_t                     getLEDinfo();
     uint8_t                     setDirectMode(bool direct);
-    uint8_t                     setMode(uint8_t mode, uint16_t speed, uint8_t zone, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness);
+    uint8_t                     setMode(uint8_t mode, uint16_t speed, uint8_t zone, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness, bool bright_cycle_swap);
     int                         getDeviceName();
 private:
     std::vector<logitech_led>   leds;

Controllers/LogitechController/RGBController_LogitechG915.cpp

@@ -22,7 +22,7 @@ static unsigned int matrix_map[7][27] =
       { 112, NA,  49,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  NA,  41,  42,  38,  NA,  NA,  69,  70,  71,  NA,  79,  80,  81,  82  },
       { 113, NA,  39,  NA,  16,  22,  4,   17,  NA,  19,  24,  20,  8,   14,  15,  43,  44,  45,  NA,  72,  73,  74,  NA,  91,  92,  93,  83  },
       { 114, NA,  53,  NA,  0,   18,  3,   5,   NA,  6,   7,   9,   10,  11,  47,  48,  46,  36,  NA,  NA,  NA,  NA,  NA,  88,  89,  90,  NA  },
-      { 115, NA,  99,  NA,  25,  23,  2,   21,  NA,  1,   NA,  13,  12,  50,  51,  52,  103, NA,  NA,  NA,  78,  NA,  NA,  85,  86,  87,  84  },
+      { 115, NA,  99,  96,  25,  23,  2,   21,  NA,  1,   NA,  13,  12,  50,  51,  52,  103, NA,  NA,  NA,  78,  NA,  NA,  85,  86,  87,  84  },
       { 116, NA,  98,  101, 100, NA,  NA,  NA,  NA,  40,  NA,  NA,  NA,  NA,  104, 105, 97,  102, NA,  76,  77,  75,  NA,  94,  NA,  95,  NA  }  };
 
 static const char* zone_names[] =

Controllers/LogitechController/RGBController_LogitechLightspeed.cpp

@@ -62,8 +62,11 @@ RGBController_LogitechLightspeed::RGBController_LogitechLightspeed(LogitechLight
         mode Static;
         Static.name                 = "Static";
         Static.value                = LOGITECH_G_PRO_WIRELESS_MODE_STATIC;
-        Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+        Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
         Static.color_mode           = MODE_COLORS_PER_LED;
+        Static.brightness_min       = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MIN;
+        Static.brightness_max       = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
+        Static.brightness           = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
         modes.push_back(Static);
 
         mode Cycle;
@@ -71,6 +74,9 @@ RGBController_LogitechLightspeed::RGBController_LogitechLightspeed(LogitechLight
         Cycle.value                 = LOGITECH_G_PRO_WIRELESS_MODE_CYCLE;
         Cycle.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
         Cycle.color_mode            = MODE_COLORS_NONE;
+        Cycle.brightness_min        = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MIN;
+        Cycle.brightness_max        = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
+        Cycle.brightness            = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
         Cycle.speed_min             = LOGITECH_G_PRO_WIRELESS_SPEED_SLOWEST;
         Cycle.speed_max             = LOGITECH_G_PRO_WIRELESS_SPEED_FASTEST;
         Cycle.speed                 = LOGITECH_G_PRO_WIRELESS_SPEED_NORMAL;
@@ -81,6 +87,9 @@ RGBController_LogitechLightspeed::RGBController_LogitechLightspeed(LogitechLight
         Breathing.value             = LOGITECH_G_PRO_WIRELESS_MODE_BREATHING;
         Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
         Breathing.color_mode        = MODE_COLORS_PER_LED;
+        Breathing.brightness_min    = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MIN;
+        Breathing.brightness_max    = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
+        Breathing.brightness        = LOGITECH_G_PRO_WIRELESS_BRIGHTNESS_MAX;
         Breathing.speed_min         = LOGITECH_G_PRO_WIRELESS_SPEED_SLOWEST;
         Breathing.speed_max         = LOGITECH_G_PRO_WIRELESS_SPEED_FASTEST;
         Breathing.speed             = LOGITECH_G_PRO_WIRELESS_SPEED_NORMAL;
@@ -148,16 +157,21 @@ void RGBController_LogitechLightspeed::DeviceUpdateLEDs()
 
 void RGBController_LogitechLightspeed::UpdateZoneLEDs(int zone)
 {
-    unsigned char red = RGBGetRValue(colors[zone]);
-    unsigned char grn = RGBGetGValue(colors[zone]);
-    unsigned char blu = RGBGetBValue(colors[zone]);
+    unsigned char red       = RGBGetRValue(colors[zone]);
+    unsigned char grn       = RGBGetGValue(colors[zone]);
+    unsigned char blu       = RGBGetBValue(colors[zone]);
+
+    /*---------------------------------------------------------*\
+    | Workaround for G502 mode breathing / spectrum cycle swap  |
+    \*---------------------------------------------------------*/
+    bool bright_cycle_swap  = (pid == 0xC08B || pid == 0xC332);
 
     /*---------------------------------------------------------*\
     | Replace direct mode with static when sending to controller|
     \*---------------------------------------------------------*/
     unsigned char temp_mode = (modes[active_mode].value == 0xFF) ? LOGITECH_G_PRO_WIRELESS_MODE_STATIC : modes[active_mode].value;
 
-    logitech->SendMouseMode(temp_mode, modes[active_mode].speed, zone, red, grn, blu);
+    logitech->SendMouseMode(temp_mode, modes[active_mode].speed, zone, red, grn, blu, modes[active_mode].brightness, bright_cycle_swap);
 }
 
 void RGBController_LogitechLightspeed::UpdateSingleLED(int led)

Controllers/LogitechController/RGBController_LogitechLightspeed.h

@@ -28,6 +28,7 @@ public:
     void        SetCustomMode();
     void        DeviceUpdateMode();
 
+    uint16_t    pid;        //This is a workaround fix for G502 mode breathing / spectrum cycle swap
 private:
     LogitechLightspeedController*   logitech;
 };

Controllers/MSIGPUController/MSIGPUControllerDetect.cpp

@@ -51,14 +51,20 @@ static const msi_gpu_pci_device device_list[] =
     { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,       MSI_SUB_VEN,    MSI_RTX2080_SEA_HAWK_EK_X_SUB_DEV,      "MSI GeForce RTX 2080 Sea Hawk EK X"            },  
     { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,       MSI_SUB_VEN,    MSI_RTX2080_DUKE_OC_SUB_DEV,            "MSI GeForce RTX 2080 Duke 8G OC"               },
     { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,        MSI_SUB_VEN,    MSI_RTX2080S_GAMING_X_TRIO_SUB_DEV,     "MSI GeForce RTX 2080 Super Gaming X Trio"      },
-    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,       MSI_SUB_VEN,    MSI_RTX2080TI_GAMING_X_TRIO_SUB_DEV,    "MSI GeForce RTX 2080Ti Gaming X Trio"          },
-    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,       MSI_SUB_VEN,    MSI_RTX2080TI_SEA_HAWK_EK_X_SUB_DEV,    "MSI GeForce RTX 2080Ti Sea Hawk EK X"          },
+    { NVIDIA_VEN,   NVIDIA_RTX2080TI_A_DEV,     MSI_SUB_VEN,    MSI_RTX2080TI_GAMING_X_TRIO_SUB_DEV,    "MSI GeForce RTX 2080Ti Gaming X Trio"          },
+    { NVIDIA_VEN,   NVIDIA_RTX2080TI_A_DEV,     MSI_SUB_VEN,    MSI_RTX2080TI_SEA_HAWK_EK_X_SUB_DEV,    "MSI GeForce RTX 2080Ti Sea Hawk EK X"          },
     { NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       MSI_SUB_VEN,    MSI_RTX3070_GAMING_X_TRIO_SUB_DEV,      "MSI GeForce RTX 3060 Ti 8GB Gaming X Trio"     },
     { NVIDIA_VEN,   NVIDIA_RTX3060TI_LHR_DEV,   MSI_SUB_VEN,    MSI_RTX3070_GAMING_X_TRIO_SUB_DEV,      "MSI GeForce RTX 3060 Ti 8GB Gaming X Trio LHR" },
+    { NVIDIA_VEN,   NVIDIA_RTX3070_LHR_DEV,     MSI_SUB_VEN,    MSI_RTX3070_GAMING_TRIO_SUB_DEV,        "MSI GeForce RTX 3070 8GB Gaming Trio"          },
     { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         MSI_SUB_VEN,    MSI_RTX3070_GAMING_X_TRIO_SUB_DEV,      "MSI GeForce RTX 3070 8GB Gaming X Trio"        },
+    { NVIDIA_VEN,   NVIDIA_RTX3070_LHR_DEV,     MSI_SUB_VEN,    MSI_RTX3070_SUPRIM_X_LHR_SUB_DEV,       "MSI GeForce RTX 3070 8GB Suprim X LHR"         },
+    { NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       MSI_SUB_VEN,    MSI_RTX3070TI_GAMING_X_TRIO_SUB_DEV,    "MSI GeForce RTX 3070 Ti 8GB Gaming X Trio"     },
+    { NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,       MSI_SUB_VEN,    MSI_RTX3070TI_SUPRIM_X_SUB_DEV,         "MSI GeForce RTX 3070 Ti Suprim X 8G"           },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,     MSI_SUB_VEN,    MSI_RTX3080_GAMING_Z_TRIO_SUB_DEV,      "MSI GeForce RTX 3080 10GB Gaming Z Trio LHR"   },
     { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         MSI_SUB_VEN,    MSI_RTX3080_GAMING_X_TRIO_SUB_DEV,      "MSI GeForce RTX 3080 10GB Gaming X Trio"       },
     { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         MSI_SUB_VEN,    MSI_RTX3080_SUPRIM_X_SUB_DEV,           "MSI GeForce RTX 3080 Suprim X 10G"             },
     { NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       MSI_SUB_VEN,    MSI_RTX3080TI_GAMING_X_TRIO_SUB_DEV,    "MSI GeForce RTX 3080 Ti Gaming X Trio 12G"     },
+    { NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,       MSI_SUB_VEN,    MSI_RTX3080TI_SUPRIM_X_SUB_DEV,         "MSI GeForce RTX 3080 Ti Suprim X 12G"          },
     { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         MSI_SUB_VEN,    MSI_RTX3090_GAMING_X_TRIO_SUB_DEV,      "MSI GeForce RTX 3090 24GB Gaming X Trio"       },
     { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         MSI_SUB_VEN,    MSI_RTX3090_SUPRIM_X_SUB_DEV,           "MSI GeForce RTX 3090 Suprim X 24G"             }, 
 };

Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp

@@ -76,6 +76,7 @@ REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C35",    DetectMSIMysticLight185C
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C37",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C37,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C56",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C56,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C59",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C59,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C71",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C71,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C75",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C75,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C76",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C76,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C79",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C79,   0x0001, 0x00);
@@ -90,8 +91,11 @@ REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C92",    DetectMSIMysticLight185C
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C94",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C94,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C95",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C95,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D06",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7D06,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D07",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7D07,   0x0001, 0x00); // MPG Z590 GAMING EDGE WIFI
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D09",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7D09,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D13",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7D13,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D15",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7D15,   0x0001, 0x00);
+REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7D54",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7D54,   0x0001, 0x00);
 
 #ifdef ENABLE_UNTESTED_MYSTIC_LIGHT
 /*-------------------------------------------------------------*\
@@ -107,7 +111,6 @@ REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C42",    DetectMSIMysticLight185C
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C60",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C60,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C67",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C67,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C70",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C70,   0x0001, 0x00);
-REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C71",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C71,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C73",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C73,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C77",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C77,   0x0001, 0x00);
 REGISTER_HID_DETECTOR_PU("MSI Mystic Light MS_7C82",    DetectMSIMysticLight185Controllers,   MSI_USB_VID,    0x7C82,   0x0001, 0x00);

Controllers/NZXTHue2Controller/NZXTHue2ControllerDetect.cpp

@@ -12,7 +12,9 @@
 #define NZXT_KRAKEN_X3_PID           0x2007
 #define NZXT_RGB_FAN_CONTROLLER_PID  0x2009
 #define NZXT_RGB_FAN_CONTROLLER2_PID 0x2010
+#define NZXT_RGB_FAN_CONTROLLER3_PID 0x200E
 #define NZXT_SMART_DEVICE_V2_1_PID   0x200D
+#define NZXT_SMART_DEVICE_V2_2_PID   0x200F
 
 static void spawn_hue(hid_device_info* info, const std::string& name, int rgb_channels, int fan_channels)
 {
@@ -63,4 +65,6 @@ REGISTER_HID_DETECTOR("NZXT Smart Device V2",      DetectNZXTSmartDeviceV2,   NZ
 REGISTER_HID_DETECTOR("NZXT Kraken X3",            DetectNZXTKrakenX3,        NZXT_VID, NZXT_KRAKEN_X3_PID);
 REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController,   NZXT_VID, NZXT_RGB_FAN_CONTROLLER_PID);
 REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController,   NZXT_VID, NZXT_RGB_FAN_CONTROLLER2_PID);
+REGISTER_HID_DETECTOR("NZXT RGB & Fan Controller", DetectNZXTFanController,   NZXT_VID, NZXT_RGB_FAN_CONTROLLER3_PID);
 REGISTER_HID_DETECTOR("NZXT Smart Device V2",      DetectNZXTSmartDeviceV2,   NZXT_VID, NZXT_SMART_DEVICE_V2_1_PID);
+REGISTER_HID_DETECTOR("NZXT Smart Device V2",      DetectNZXTSmartDeviceV2,   NZXT_VID, NZXT_SMART_DEVICE_V2_2_PID);

Controllers/NZXTHuePlusController/NZXTHuePlusController.cpp

@@ -20,6 +20,7 @@ HuePlusController::HuePlusController()
 
 HuePlusController::~HuePlusController()
 {
+    delete serialport;
 }
 
 void HuePlusController::Initialize(char* port)

Controllers/NZXTHuePlusController/NZXTHuePlusController.h

@@ -96,7 +96,7 @@ public:
 
 private:
     std::string     port_name;
-    serial_port     *serialport;
+    serial_port     *serialport = nullptr;
 
     void            SendPacket
                         (

Controllers/OpenRazerController/OpenRazerDevices.h

@@ -1685,7 +1685,7 @@ static const razer_zone cynosa_v2_zone =
 
 static const razer_device cynosa_v2_device =
 {
-    "Razer Cynosa v2",
+    "Razer Cynosa V2",
     DEVICE_TYPE_KEYBOARD,
     true,
     6,

Controllers/PNYGPUController/PNYGPUController.cpp

@@ -0,0 +1,104 @@
+/*-----------------------------------------*\
+|  PNYGPUController.cpp                     |
+|                                           |
+|  Driver for PNY GPU RGB (Turing)          |
+|  lighting controller                      |
+|                                           |
+|  KendallMorgan   10/17/2021               |
+\*-----------------------------------------*/
+
+#include "PNYGPUController.h"
+
+PNYGPUController::PNYGPUController(i2c_smbus_interface* bus, pny_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+}
+
+PNYGPUController::~PNYGPUController()
+{
+
+}
+
+std::string PNYGPUController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+void PNYGPUController::WriteI2CData(u8 command, u8 length, u8* data)
+{
+    //Simulating i2c_smbus_write_i2c_block_data(command, length, data);
+    for (u8 i = 0; i < length; i++)
+    {
+        bus->i2c_smbus_write_byte_data(dev, command+i, data[i]);
+    }
+}
+
+unsigned char PNYGPUController::GetMode()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, PNY_GPU_MODE_OFF));
+}
+
+unsigned char PNYGPUController::GetRed()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, PNY_GPU_REG_COLOR_RED));
+}
+
+unsigned char PNYGPUController::GetGreen()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, PNY_GPU_REG_COLOR_GREEN));
+}
+
+unsigned char PNYGPUController::GetBlue()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, PNY_GPU_REG_COLOR_BLUE));
+}
+
+void PNYGPUController::SetOff()
+{
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_CONTROL,                0);
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_MODE,                   0x00);
+}
+
+void PNYGPUController::SetCycle(unsigned char speed)
+{
+    u8 loop[] = {
+        0x01,  // Direction
+        0x00,  // ??
+        speed, // Speed
+        0x1F   // Somehow related to speed
+    };
+    loop[2] = speed;
+    WriteI2CData(PNY_GPU_REG_CONTROL, sizeof(loop), loop);
+}
+
+void PNYGPUController::SetStrobe(unsigned char r, unsigned char g, unsigned char b, unsigned char speed, unsigned char brightness)
+{
+    u8 strobe[] = {
+        0x02,       // Strobe
+        0x00,       // Rise speed
+        speed,      // Cycle length/2
+        0x00,       // Off delay
+        r,          // R
+        g,          // G
+        b,          // B
+        brightness, // Peak brightness
+        0x05        // Fade speed
+    };
+    WriteI2CData(PNY_GPU_REG_CONTROL, sizeof(strobe), strobe);
+}
+
+void PNYGPUController::SetDirect(unsigned char red, unsigned char green, unsigned char blue, unsigned char brightness)
+{
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_CONTROL,                0);
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_MODE,                   0x01);
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_COLOR_RED,              red);
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_COLOR_BLUE,             blue);
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_COLOR_GREEN,            green);
+    bus->i2c_smbus_write_byte_data(dev, PNY_GPU_REG_COLOR_BRIGHTNESS,       brightness);
+}

Controllers/PNYGPUController/PNYGPUController.h

@@ -0,0 +1,58 @@
+/*-----------------------------------------*\
+|  PNYGPUController.h                       |
+|                                           |
+|  Definitions and types for PNY GPU RGB    |
+|  (Turing) lighting controller             |
+|                                           |
+|  KendallMorgan   10/17/2021               |
+\*-----------------------------------------*/
+
+#include <string>
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char   pny_dev_id;
+
+enum
+{
+    PNY_GPU_REG_CONTROL                 = 0xE0,
+    PNY_GPU_REG_MODE                    = 0x60,
+    PNY_GPU_REG_COLOR_RED               = 0x6C,
+    PNY_GPU_REG_COLOR_GREEN             = 0x6D,
+    PNY_GPU_REG_COLOR_BLUE              = 0x6E,
+    PNY_GPU_REG_COLOR_BRIGHTNESS        = 0x6F,
+};
+
+enum
+{
+    PNY_GPU_MODE_OFF                    = 0x00,
+    PNY_GPU_MODE_DIRECT                 = 0x01,
+    PNY_GPU_MODE_CYCLE                  = 0x02,
+    PNY_GPU_MODE_STROBE                 = 0x03,
+};
+
+class PNYGPUController
+{
+public:
+	PNYGPUController(i2c_smbus_interface* bus, pny_dev_id dev);
+	~PNYGPUController();
+
+	std::string     GetDeviceLocation();
+
+    void SetOff();
+    void SetCycle(unsigned char speed);
+    void SetStrobe(unsigned char r, unsigned char g, unsigned char b, unsigned char speed, unsigned char brightness);
+    void SetDirect(unsigned char red, unsigned char green, unsigned char blue, unsigned char brightness);
+
+private:
+	i2c_smbus_interface*    bus;
+	pny_dev_id              dev;
+
+    void            WriteI2CData(u8 command, u8 length, u8* data);
+    unsigned char   GetMode();
+    unsigned char   GetRed();
+    unsigned char   GetGreen();
+    unsigned char   GetBlue();
+
+};

Controllers/PNYGPUController/PNYGPUControllerDetect.cpp

@@ -0,0 +1,111 @@
+#include "Detector.h"
+#include "PNYGPUController.h"
+#include "RGBController.h"
+#include "RGBController_PNYGPU.h"
+#include "i2c_smbus.h"
+#include "pci_ids.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+enum
+{
+    PNY_RGB,
+};
+
+typedef struct
+{
+    int             pci_vendor;
+    int             pci_device;
+    int             pci_subsystem_vendor;
+    int             pci_subsystem_device;
+    int             gpu_rgb_version;
+    const char *    name;
+} gpu_pci_device;
+
+#define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+#define PNY_SUB_VEN_STR     "PNY"
+#define PALIT_SUB_VEN_STR   "Palit"
+#define GENERIC_SUB_VEN_STR "Generic"
+
+static const gpu_pci_device device_list[] =
+{
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,       PNY_SUB_VEN,     PNY_RTX_3090_XLR8_REVEL_EPIC_X_SUB_DEV,  PNY_RGB,    "PNY XLR8 Revel EPIC-X RTX 3090" },
+    { NVIDIA_VEN,   NVIDIA_RTX3060_DEV,       PALIT_SUB_VEN,   PALIT_RTX3060_SUB_DEV,                   PNY_RGB,    "Palit 3060" },
+    { NVIDIA_VEN,   NVIDIA_RTX3060_LHR_DEV,   PALIT_SUB_VEN,   PALIT_RTX3060_LHR_SUB_DEV,               PNY_RGB,    "Palit 3060 LHR" },
+
+    { NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,     PALIT_SUB_VEN,   PALIT_RTX3060TI_SUB_DEV,                 PNY_RGB,    "Palit 3060Ti" },
+    { NVIDIA_VEN,   NVIDIA_RTX3060TI_LHR_DEV, PALIT_SUB_VEN,   PALIT_RTX3060TI_LHR_SUB_DEV,             PNY_RGB,    "Palit 3060Ti" },
+
+    { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,       PALIT_SUB_VEN,   PALIT_RTX3070_SUB_DEV,                   PNY_RGB,    "Palit 3070" },
+    { NVIDIA_VEN,   NVIDIA_RTX3070_LHR_DEV,   PALIT_SUB_VEN,   PALIT_RTX3070_LHR_SUB_DEV,               PNY_RGB,    "Palit 3070 LHR" },
+    { NVIDIA_VEN,   NVIDIA_RTX3070TI_DEV,     PALIT_SUB_VEN,   PALIT_RTX3070TI_SUB_DEV,                 PNY_RGB,    "Palit 3070Ti" },
+
+    { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,       PALIT_SUB_VEN,   PALIT_RTX3080_SUB_DEV,                   PNY_RGB,    "Palit 3080" },
+    { NVIDIA_VEN,   NVIDIA_RTX3080_LHR_DEV,   PALIT_SUB_VEN,   PALIT_RTX3080_LHR_SUB_DEV,               PNY_RGB,    "Palit 3080 LHR" },
+    { NVIDIA_VEN,   NVIDIA_RTX3080TI_DEV,     PALIT_SUB_VEN,   PALIT_RTX3080TI_SUB_DEV,                 PNY_RGB,    "Palit 3080Ti" },
+
+    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,       PALIT_SUB_VEN,   PALIT_RTX3090_SUB_DEV,                   PNY_RGB,    "Palit 3090" }
+};
+
+/******************************************************************************************\
+ *                                                                                        *
+ *   DetectPNYGPUControllers                                                              *
+ *                                                                                        *
+ *       Detect PNY GPU controllers on the enumerated I2C busses at address 0x49.         *
+ *                                                                                        *
+ *       bus - pointer to i2c_smbus_interface where PNY GPU device is connected           *
+ *       dev - I2C address of PNY GPU device                                              *
+ *                                                                                        *
+\******************************************************************************************/
+
+void DetectPNYGPUControllers(std::vector<i2c_smbus_interface*>& busses)
+{
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        for(unsigned int dev_idx = 0; dev_idx < GPU_NUM_DEVICES; dev_idx++)
+        {
+            if(busses[bus]->port_id != 1)
+            {
+                break;
+            }
+
+            if(busses[bus]->pci_vendor           == device_list[dev_idx].pci_vendor           &&
+               busses[bus]->pci_device           == device_list[dev_idx].pci_device           &&
+               busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
+               busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
+            {
+                switch(device_list[dev_idx].gpu_rgb_version)
+                {
+                    case PNY_RGB:
+                        {
+                            PNYGPUController*     new_controller;
+                            RGBController_PNYGPU* new_rgbcontroller;
+
+                            new_controller            = new PNYGPUController(busses[bus], 0x49);
+                            new_rgbcontroller         = new RGBController_PNYGPU(new_controller);
+                            new_rgbcontroller->name   = device_list[dev_idx].name;
+                            switch(device_list[dev_idx].pci_subsystem_vendor)
+                            {
+                            case PNY_SUB_VEN:
+                                new_rgbcontroller->vendor = PNY_SUB_VEN_STR;
+                                break;
+
+                            case PALIT_SUB_VEN:
+                                new_rgbcontroller->vendor = PALIT_SUB_VEN_STR;
+                                break;
+                            default:
+                                new_rgbcontroller->vendor = GENERIC_SUB_VEN_STR;
+                                break;
+                            }
+                            ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
+                        }
+                        break;
+                }
+            }
+        }
+    }
+}
+/* DetectPNYGPUControllers() */
+REGISTER_I2C_DETECTOR("PNY GPU", DetectPNYGPUControllers);

Controllers/PNYGPUController/RGBController_PNYGPU.cpp

@@ -0,0 +1,154 @@
+/*-----------------------------------------*\
+|  RGBController_PNYGPU.cpp                 |
+|                                           |
+|  Generic RGB Interface for OpenRGB PNY    |
+|  GPU (Turing) Driver                      |
+|                                           |
+|  KendallMorgan   10/17/2021               |
+\*-----------------------------------------*/
+
+#include "RGBController_PNYGPU.h"
+
+RGBController_PNYGPU::RGBController_PNYGPU(PNYGPUController* pny_ptr)
+{
+    pny = pny_ptr;
+
+    name                    = "PNY/Palit GPU";
+    vendor                  = "PNY/Palit";
+    description             = "PNY/Palit RGB GPU Device";
+    location                = pny->GetDeviceLocation();
+
+    type = DEVICE_TYPE_GPU;
+
+    mode Off;
+    Off.name                = "Off";
+    Off.value               = PNY_GPU_MODE_OFF;
+    Off.flags               = 0;
+    Off.color_mode          = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Direct;
+    Direct.name             = "Direct";
+    Direct.value            = PNY_GPU_MODE_DIRECT;
+    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR| MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.brightness       = 255;
+    Direct.brightness_min   = 0;
+    Direct.brightness_max   = 100;
+    Direct.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Cycle;
+    Cycle.name             = "Cycle";
+    Cycle.value            = PNY_GPU_MODE_CYCLE;
+    Cycle.flags            = MODE_FLAG_HAS_SPEED;
+    Cycle.speed            = 3;
+    Cycle.speed_max        = 0;
+    Cycle.speed_max        = 100;
+    Cycle.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Cycle);
+
+    mode Strobe;
+    Strobe.name             = "Strobe";
+    Strobe.value            = PNY_GPU_MODE_STROBE;
+    Strobe.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Strobe.speed            = 2;
+    Strobe.speed_max        = 0;
+    Strobe.speed_max        = 255;
+    Strobe.brightness       = 255;
+    Strobe.brightness_min   = 0;
+    Strobe.brightness_max   = 100;
+    Strobe.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Strobe);
+
+
+    SetupZones();
+
+    // Initialize active mode
+    active_mode = 0;
+}
+
+void RGBController_PNYGPU::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | This device only has one LED, so create a single zone and |
+    | LED for it                                                |
+    \*---------------------------------------------------------*/
+    zone* new_zone = new zone();
+    led*  new_led  = new led();
+
+    new_zone->name          = "GPU Zone";
+    new_zone->type          = ZONE_TYPE_SINGLE;
+    new_zone->leds_min      = 1;
+    new_zone->leds_max      = 1;
+    new_zone->leds_count    = 1;
+    new_zone->matrix_map    = NULL;
+
+    new_led->name           = "GPU LED";
+
+    /*---------------------------------------------------------*\
+    | Push the zone and LED on to device vectors                |
+    \*---------------------------------------------------------*/
+    leds.push_back(*new_led);
+    zones.push_back(*new_zone);
+    SetupColors();
+}
+
+void RGBController_PNYGPU::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_PNYGPU::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_PNYGPU::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_PNYGPU::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_PNYGPU::SetCustomMode()
+{
+    active_mode = 1;
+}
+
+void RGBController_PNYGPU::DeviceUpdateMode()
+{
+    RGBColor      color = colors[0];
+    unsigned char r   = RGBGetRValue(color);
+    unsigned char g   = RGBGetGValue(color);
+    unsigned char b   = RGBGetBValue(color);
+    unsigned char speed, brightness;
+    switch(modes[active_mode].value)
+    {
+        case PNY_GPU_MODE_OFF:
+            pny->SetOff();
+            break;
+
+        case PNY_GPU_MODE_DIRECT:
+            brightness = modes[active_mode].brightness;
+            pny->SetDirect(r, g, b, brightness);
+            break;
+
+        case PNY_GPU_MODE_CYCLE:
+            speed = modes[active_mode].speed;
+            pny->SetCycle(speed);
+            break;
+
+        case PNY_GPU_MODE_STROBE:
+            speed      = modes[active_mode].speed;
+            brightness = modes[active_mode].brightness;
+            pny->SetStrobe(r, g, b, speed, brightness);
+            break;
+        default:
+        break;
+    }
+}

Controllers/PNYGPUController/RGBController_PNYGPU.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_PNYGPU.h                   |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  PNY GPU RGB  (Turing) Driver             |
+|                                           |
+|  KendallMorgan   10/17/2021               |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "PNYGPUController.h"
+
+class RGBController_PNYGPU : public RGBController
+{
+public:
+    RGBController_PNYGPU(PNYGPUController* pny_ptr);
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    PNYGPUController* pny;
+};

Controllers/PatriotViperController/PatriotViperControllerDetect.cpp

@@ -1,5 +1,6 @@
 #include "Detector.h"
 #include "PatriotViperController.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_PatriotViper.h"
 #include "i2c_smbus.h"
@@ -9,6 +10,7 @@
 #include <stdlib.h>
 
 using namespace std::chrono_literals;
+#define PATRIOT_CONTROLLER_NAME "Patriot Viper"
 
 /******************************************************************************************\
 *                                                                                          *
@@ -32,49 +34,50 @@ void DetectPatriotViperControllers(std::vector<i2c_smbus_interface*> &busses)
 
         IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
+            int res = busses[bus]->i2c_smbus_read_byte_data(0x36, 0x00);
+
+            if(res < 0)
+            {
+                continue;
+            }
+            std::this_thread::sleep_for(1ms);
+
             for(int slot_addr = 0x50; slot_addr <= 0x57; slot_addr++)
             {
                 // Test for Patriot Viper RGB SPD at slot_addr
                 // This test was copied from Viper RGB software
                 // Tests SPD addresses in order: 0x00, 0x40, 0x41, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68
-                bool pass = false;
 
-                int res = busses[bus]->i2c_smbus_read_byte(slot_addr);
+                busses[bus]->i2c_smbus_write_byte_data(0x36, 0x00, 0xFF);
 
-                if (res >= 0)
+                std::this_thread::sleep_for(1ms);
+
+                int res = busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x00);
+
+                LOG_DEBUG("[%s] Trying to read 0x%02X RAM module data at 0x00 expect: 0x23 res: %02X", PATRIOT_CONTROLLER_NAME, slot_addr, res);
+                if(res == 0x23)
                 {
-                    pass = true;
-                }
-
-                if(pass)
-                {
-                    busses[bus]->i2c_smbus_write_byte_data(0x36, 0x00, 0xFF);
+                    busses[bus]->i2c_smbus_write_byte_data(0x37, 0x00, 0xFF);
 
                     std::this_thread::sleep_for(1ms);
 
-                    if(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x00) == 0x23)
+                    if((busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x40) == 0x85)
+                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x41) == 0x02)
+                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x61) == 0x4D)
+                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x62) == 0x49)
+                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x63) == 0x43)
+                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x64) == 0x53)
+                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x65) == 0x59)
+                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x66) == 0x53)
+                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x67) == 0x5f)
+                    &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x68) == 0x44))
                     {
-                        busses[bus]->i2c_smbus_write_byte_data(0x37, 0x00, 0xFF);
-
-                        std::this_thread::sleep_for(1ms);
-
-                        if((busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x40) == 0x85)
-                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x41) == 0x02)
-                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x61) == 0x4D)
-                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x62) == 0x49)
-                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x63) == 0x43)
-                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x64) == 0x53)
-                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x65) == 0x59)
-                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x66) == 0x53)
-                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x67) == 0x5f)
-                        &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x68) == 0x44))
-                        {
-                            slots_valid |= (1 << (slot_addr - 0x50));
-                        }
+                        LOG_DEBUG("[%s] The 0x%02X RAM module detected", PATRIOT_CONTROLLER_NAME, slot_addr);
+                        slots_valid |= (1 << (slot_addr - 0x50));
                     }
-
-                    std::this_thread::sleep_for(1ms);
                 }
+
+                std::this_thread::sleep_for(1ms);
             }
 
             if(slots_valid != 0)
@@ -88,4 +91,4 @@ void DetectPatriotViperControllers(std::vector<i2c_smbus_interface*> &busses)
 
 }   /* DetectPatriotViperControllers() */
 
-REGISTER_I2C_DETECTOR("Patriot Viper", DetectPatriotViperControllers);
+REGISTER_I2C_DETECTOR(PATRIOT_CONTROLLER_NAME, DetectPatriotViperControllers);