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,17 +114,21 @@ 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"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0105", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="1011", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="1000", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="014d", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0047", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="003c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0067", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0089", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="008d", TAG+="uaccess"
+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"
+
 
 #---------------------------------------------------------------#
 #  Corsair Hydro Series Devices                                 #
@@ -189,6 +194,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c23", TAG+="uacces
 #       Corsair K70 RGB MK2 LP                                  #
 #       Corsair K95 RGB                                         #
 #       Corsair K95 Platinum                                    #
+#       Corsair K100                                            #
 #       Corsair Strafe                                          #
 #       Corsair Strafe MK2                                      #
 #                                                               #
@@ -223,6 +229,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b11", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b2d", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b20", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b48", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b7c", TAG+="uaccess"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b34", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b74", TAG+="uaccess"
@@ -343,6 +350,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0cf2", ATTR{idProduct}=="7750", TAG+="uacces
 #       Logitech G810 #2                                        #
 #       Logitech G813                                           #
 #       Logitech G815                                           #
+#       Logitech G915                                           #
 #                                                               #
 #  Mice:                                                        #
 #       Logitech G203 Prodigy                                   #
@@ -354,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             #
@@ -382,7 +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}=="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"
@@ -394,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"
@@ -406,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                                 #
@@ -426,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                                           #
@@ -499,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                                                  #
@@ -510,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"
@@ -616,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                                               #
@@ -718,14 +737,16 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="0ba0", TAG+="uacces
 #       SteelSeries Rival 300 Blackops Edition                  #
 #       SteelSeries Rival 310                                   #
 #       SteelSeries Rival 310 CS:GO Howl Edition                #
-#       SteelSeries Rival 310 PubG Edition			#
-#	SteelSeries Rival 650 Wireless		                #
+#       SteelSeries Rival 310 PubG Edition                      #
+#       SteelSeries Rival 650 Wireless                          #
+#       SteelSeries Rival 3                                     #
 #       SteelSeries Rival Sensei Ten                            #
 #       SteelSeries Rival Sensei Ten CS:GO Neon Rider           #
 #       SteelSeries Rival Sensei 310                            #
 #  Headsets:                                                    #
 #       SteelSeries Siberia 350                                 #
 #  Keyboards:                                                   #
+#       SteelSeries Apex 3                                      #
 #       SteelSeries Apex 5                                      #
 #       SteelSeries Apex 7                                      #
 #       SteelSeries Apex 7 TKL                                  #
@@ -735,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"
@@ -755,7 +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}=="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"
 
@@ -764,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                                              #
@@ -784,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/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -19,17 +19,20 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
 
     strcpy(device_name, "AMD Wraith Prism");
 
-    current_fan_mode = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
-    current_fan_speed = 0xFF;
-    current_fan_random_color = false;
+    current_fan_mode            = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
+    current_fan_speed           = 0xFF;
+    current_fan_random_color    = false;
+    current_fan_brightness      = 0xFF;
 
-    current_logo_mode = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
-    current_logo_speed = 0xFF;
-    current_logo_random_color = false;
+    current_logo_mode           = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
+    current_logo_speed          = 0xFF;
+    current_logo_random_color   = false;
+    current_logo_brightness     = 0xFF;
 
-    current_ring_mode = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
-    current_ring_speed = 0xFF;
-    current_ring_direction = false;
+    current_ring_mode           = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
+    current_ring_speed          = 0xFF;
+    current_ring_direction      = false;
+    current_ring_brightness     = 0xFF;
 
     SendEnableCommand();
 }
@@ -147,10 +150,11 @@ std::string AMDWraithPrismController::GetFirmwareVersionString()
     return(ret_string);
 }
 
-void AMDWraithPrismController::SetFanMode(unsigned char mode, unsigned char speed, bool random_color)
+void AMDWraithPrismController::SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color)
 {
     current_fan_mode            = mode;
     current_fan_speed           = speed_values_fan_logo[mode][speed];
+    current_fan_brightness      = brightness;
     current_fan_random_color    = random_color;
 }
 
@@ -163,17 +167,18 @@ void AMDWraithPrismController::SetFanColor(unsigned char red, unsigned char gree
         false,
         current_fan_random_color,
         current_fan_mode,
-        max_brightness_fan_logo[current_fan_mode],
+        current_fan_brightness,
         red,
         green,
         blue
     );
 }
 
-void AMDWraithPrismController::SetLogoMode(unsigned char mode, unsigned char speed, bool random_color)
+void AMDWraithPrismController::SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color)
 {
     current_logo_mode           = mode;
     current_logo_speed          = speed_values_fan_logo[mode][speed];
+    current_logo_brightness     = brightness;
     current_logo_random_color   = random_color;
 }
 
@@ -186,18 +191,19 @@ void AMDWraithPrismController::SetLogoColor(unsigned char red, unsigned char gre
         false,
         current_logo_random_color,
         current_logo_mode,
-        max_brightness_fan_logo[current_logo_mode],
+        current_logo_brightness,
         red,
         green,
         blue
     );
 }
 
-void AMDWraithPrismController::SetRingMode(unsigned char mode, unsigned char speed, bool direction, bool random_color)
+void AMDWraithPrismController::SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color)
 {
     current_ring_mode           = mode;
     current_ring_speed          = speed_values_ring[mode][speed];
     current_ring_direction      = direction;
+    current_ring_brightness     = brightness;
     current_ring_random_color   = random_color;
 }
 
@@ -212,7 +218,7 @@ void AMDWraithPrismController::SetRingColor(unsigned char red, unsigned char gre
         current_ring_direction,
         current_ring_random_color,
         mode_value_ring[current_ring_mode],
-        max_brightness_ring[current_ring_mode],
+        current_ring_brightness,
         red,
         green,
         blue

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

@@ -12,13 +12,8 @@
 
 #pragma once
 
-static const unsigned char max_brightness_fan_logo[] =
-{
-    0x00,
-    0xFF,
-    0x7F,
-    0xFF
-};
+#define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX     0xFF
+#define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_CYCLE_MAX       0x7F
 
 static const unsigned char speed_values_fan_logo[][5] =
 {
@@ -28,22 +23,6 @@ static const unsigned char speed_values_fan_logo[][5] =
     { 0x3C, 0x37, 0x31, 0x2C, 0x26 },                  /* Breathing                    */
 };
 
-static const unsigned char max_brightness_ring[] =
-{
-    0xFF,
-    0xFF,
-    0x7F,
-    0x00,
-    0x00,
-    0x00,
-    0x00,
-    0xFF,
-    0xFF,
-    0xFF,
-    0xFF,
-    0xFF
-};
-
 static const unsigned char mode_value_ring[] =
 {
     0xFF,
@@ -121,13 +100,13 @@ public:
 
     void SetRingEffectChannel(unsigned char channel);
 
-    void SetFanMode(unsigned char mode, unsigned char speed, bool random_color);
+    void SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
     void SetFanColor(unsigned char red, unsigned char green, unsigned char blue);
 
-    void SetLogoMode(unsigned char mode, unsigned char speed, bool random_color);
+    void SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
     void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);
 
-    void SetRingMode(unsigned char mode, unsigned char speed, bool direction, bool random_color);
+    void SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color);
     void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);
 
 private:
@@ -137,14 +116,17 @@ private:
 
     unsigned char           current_fan_mode;
     unsigned char           current_fan_speed;
+    unsigned char           current_fan_brightness;
     bool                    current_fan_random_color;
 
     unsigned char           current_logo_mode;
     unsigned char           current_logo_speed;
+    unsigned char           current_logo_brightness;
     bool                    current_logo_random_color;
 
     unsigned char           current_ring_mode;
     unsigned char           current_ring_speed;
+    unsigned char           current_ring_brightness;
     bool                    current_ring_direction;
     bool                    current_ring_random_color;
 

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -26,70 +26,91 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
     serial      = "";//wraith->GetSerialString();
 
     mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name                 = "Direct";
+    Direct.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.brightness_min       = 0;
+    Direct.brightness_max       = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Direct.brightness           = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Breathing.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Breathing.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    Breathing.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Breathing.name              = "Breathing";
+    Breathing.value             = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.speed_min         = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Breathing.speed_max         = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Breathing.brightness_min    = 0;
+    Breathing.brightness_max    = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Breathing.brightness        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Breathing.color_mode        = MODE_COLORS_PER_LED;
+    Breathing.speed             = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Breathing);
 
     mode ColorCycle;
-    ColorCycle.name       = "Color Cycle";
-    ColorCycle.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE;
-    ColorCycle.flags      = MODE_FLAG_HAS_SPEED;
-    ColorCycle.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    ColorCycle.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    ColorCycle.color_mode = MODE_COLORS_NONE;
-    ColorCycle.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    ColorCycle.name             = "Color Cycle";
+    ColorCycle.value            = AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE;
+    ColorCycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    ColorCycle.speed_min        = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    ColorCycle.speed_max        = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    ColorCycle.brightness_min   = 0;
+    ColorCycle.brightness_max   = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_CYCLE_MAX;
+    ColorCycle.brightness       = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_CYCLE_MAX;
+    ColorCycle.color_mode       = MODE_COLORS_NONE;
+    ColorCycle.speed            = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(ColorCycle);
 
     mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW;
-    Rainbow.flags      = MODE_FLAG_HAS_SPEED;
-    Rainbow.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Rainbow.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Rainbow.color_mode = MODE_COLORS_NONE;
-    Rainbow.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Rainbow.name                = "Rainbow";
+    Rainbow.value               = AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW;
+    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Rainbow.speed_min           = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Rainbow.speed_max           = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Rainbow.brightness_min      = 0;
+    Rainbow.brightness_max      = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Rainbow.brightness          = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;    //The Ring zone can not get brighter but Logo / Fan can
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    Rainbow.speed               = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Rainbow);
 
     mode Bounce;
-    Bounce.name       = "Bounce";
-    Bounce.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE;
-    Bounce.flags      = MODE_FLAG_HAS_SPEED;
-    Bounce.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Bounce.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Bounce.color_mode = MODE_COLORS_NONE;
-    Bounce.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Bounce.name                 = "Bounce";
+    Bounce.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE;
+    Bounce.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Bounce.speed_min            = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Bounce.speed_max            = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Bounce.brightness_min       = 0;
+    Bounce.brightness_max       = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Bounce.brightness           = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;    //The Ring zone can not get brighter but Logo / Fan can
+    Bounce.color_mode           = MODE_COLORS_NONE;
+    Bounce.speed                = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Bounce);
 
     mode Chase;
-    Chase.name       = "Chase";
-    Chase.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE;
-    Chase.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Chase.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Chase.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Chase.color_mode = MODE_COLORS_PER_LED;
-    Chase.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Chase.name                  = "Chase";
+    Chase.value                 = AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE;
+    Chase.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Chase.speed_min             = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Chase.speed_max             = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Chase.brightness_min        = 0;
+    Chase.brightness_max        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Chase.brightness            = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Chase.color_mode            = MODE_COLORS_PER_LED;
+    Chase.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Chase);
 
     mode Swirl;
-    Swirl.name       = "Swirl";
-    Swirl.value      = AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL;
-    Swirl.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Swirl.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Swirl.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Swirl.color_mode = MODE_COLORS_PER_LED;
-    Swirl.speed      = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    Swirl.name                  = "Swirl";
+    Swirl.value                 = AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL;
+    Swirl.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Swirl.speed_min             = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Swirl.speed_max             = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Swirl.brightness_min        = 0;
+    Swirl.brightness_max        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Swirl.brightness            = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Swirl.color_mode            = MODE_COLORS_PER_LED;
+    Swirl.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
     modes.push_back(Swirl);
 
     SetupZones();
@@ -210,32 +231,36 @@ void RGBController_AMDWraithPrism::DeviceUpdateMode()
 {
     bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
 
-    wraith->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, random);
+    wraith->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
 
     switch(modes[active_mode].value)
     {
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE:
+            wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
+            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
+            break;
+
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW:
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE:
-            wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
-            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
+            wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
+            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
             break;
         
         case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
-            wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, random);
-            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, random);
+            wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
+            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
             break;
 
         default:
             if(random)
             {
-                wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
-                wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
+                wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
+                wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
             }
             else
             {
-                wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, random);
-                wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, random);
+                wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
+                wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
             }
             break;
     }

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 an Motherboard, checking for 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/AlienwareController/RGBController_Alienware.cpp

@@ -17,7 +17,7 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* alienware_
     alienware                   = alienware_ptr;
 
     name                        = alienware->GetDeviceName();
-    vendor                      = "Alienware Corporation";
+    vendor                      = "Alienware";
     type                        = DEVICE_TYPE_KEYBOARD;
     description                 = "Alienware USB Device";
     location                    = alienware->GetDeviceLocation();

Controllers/AlienwareKeyboardController/AlienwareAW510KController.cpp

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

Controllers/AlienwareKeyboardController/AlienwareAW510KController.h

@@ -0,0 +1,156 @@
+/*-----------------------------------------*\
+|  AlienwareAW510KController.h              |
+|                                           |
+|  Definitions and types for alienware      |
+|  AW510K Keyboard                          |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    ALIENWARE_AW510K_ZONE_MODE_KEYBOARD         = 0x01,
+    ALIENWARE_AW510K_ZONE_MODE_LOGO             = 0x07,     /* logo is only need key value, which equal 07  */
+};
+
+enum
+{
+    ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD       = 0x01,
+    ALIENWARE_AW510K_ZONE_DIRECT_MEDIA          = 0x02,
+    ALIENWARE_AW510K_ZONE_DIRECT_LOGO           = 0x07,
+    ALIENWARE_AW510K_ZONE_DIRECT_INDICATORS     = 0x40,
+};
+
+enum
+{
+    ALIENWARE_AW510K_MODE_OFF                   = 0x00,
+    ALIENWARE_AW510K_MODE_DIRECT_PER_LED        = 0x01,
+    ALIENWARE_AW510K_MODE_DIRECT                = 0x01,
+    ALIENWARE_AW510K_MODE_PULSE                 = 0x02,
+    ALIENWARE_AW510K_MODE_MORPH                 = 0x03,
+    ALIENWARE_AW510K_MODE_BREATHING             = 0x07,
+    ALIENWARE_AW510K_MODE_SPECTRUM              = 0x08,
+    ALIENWARE_AW510K_MODE_SINGLE_WAVE           = 0x0F,
+    ALIENWARE_AW510K_MODE_RAINBOW_WAVE          = 0x10,
+    ALIENWARE_AW510K_MODE_SCANNER               = 0x11,
+    ALIENWARE_AW510K_MODE_STATIC                = 0x13,
+};
+
+enum
+{
+    ALIENWARE_AW510K_SPEED_SLOWEST              = 0x2D,     /* Slowest speed                                */
+    ALIENWARE_AW510K_SPEED_NORMAL               = 0x19,     /* Normal speed                                 */
+    ALIENWARE_AW510K_SPEED_FASTEST              = 0x0A,     /* Fastest speed                                */
+};
+
+enum
+{
+    ALIENWARE_AW510K_DIRECTION_LEFT_TO_RIGHT    = 0x01,
+    ALIENWARE_AW510K_DIRECTION_RIGHT_TO_LEFT    = 0x02,
+    ALIENWARE_AW510K_DIRECTION_TOP_TO_BOTTOM    = 0x03,
+    ALIENWARE_AW510K_DIRECTION_BOTTOM_TO_TOP    = 0x04,
+};
+
+enum
+{
+    ALIENWARE_AW510K_SINGLE_COLOR_MODE          = 0x01,
+    ALIENWARE_AW510K_TWO_USER_DEFINED_COLOR_MODE= 0x02,
+    ALIENWARE_AW510K_RANBOW_COLOR_MODE          = 0x03,
+};
+
+struct SelectedKeys
+{
+    unsigned char idx;
+    unsigned char red;
+    unsigned char green;
+    unsigned char blue;
+};
+
+class AlienwareAW510KController
+{
+public:
+    AlienwareAW510KController(hid_device* dev_handle, const char* path);
+    ~AlienwareAW510KController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void        SendInitialize();
+    void        SendCommit();
+    void        SendfeatureReport
+                    (
+                    unsigned char   first_byte,
+                    unsigned char   second_byte,
+                    unsigned char   third_byte,
+                    unsigned char   forth_byte
+                    );
+
+    void        SendEdit();
+
+    void        SetDirect
+                    (
+                    unsigned char   zone,
+                    unsigned char   r,
+                    unsigned char   g,
+                    unsigned char   b
+                    );
+
+    void    SendDirectOn
+                    (
+                    std::vector<SelectedKeys>     &frame_data
+                    );
+
+    void        SetMode
+                    (
+                    unsigned char   mode,
+                    unsigned short  speed,
+                    unsigned char   direction,
+                    unsigned char   colorMode,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+
+    void        SetMorphMode
+                    (
+                    unsigned char   mode,
+                    unsigned short  speed,
+                    unsigned char   red1,
+                    unsigned char   green1,
+                    unsigned char   blue1,
+                    unsigned char   red2,
+                    unsigned char   green2,
+                    unsigned char   blue2
+                    );
+
+    void        UpdateSingleLED
+                    (
+                    unsigned char   led,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+
+private:
+    hid_device*             dev;
+    std::string             location;
+
+    void        SendMode
+                    (
+                    unsigned char   zone,
+                    unsigned char   mode,
+                    unsigned short  speed,
+                    unsigned char   direction,
+                    unsigned char   colorMode,
+                    unsigned char   red,
+                    unsigned char   green,
+                    unsigned char   blue
+                    );
+};

Controllers/AlienwareKeyboardController/AlienwareKeyboardControllerDetect.cpp

@@ -0,0 +1,38 @@
+#include "Detector.h"
+#include "AlienwareAW510KController.h"
+#include "RGBController.h"
+#include "RGBController_AlienwareAW510K.h"
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Alienware vendor ID                                   |
+\*-----------------------------------------------------*/
+#define ALIENWARE_VID           0x04F2
+
+/*-----------------------------------------------------*\
+| Keyboard product IDs                                  |
+\*-----------------------------------------------------*/
+#define ALIENWARE_AW510K_PID    0x1830
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAlienwareKeyboardControllers                                                     *
+*                                                                                          *
+*       Tests the USB address to see if a Alienware RGB Keyboard controller exists there.  *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
+    {
+        AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path);
+        RGBController_AlienwareAW510K* rgb_controller = new RGBController_AlienwareAW510K(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}   /* DetectAlienwareKeyboardControllers() */
+
+
+REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.cpp

@@ -0,0 +1,488 @@
+/*-----------------------------------------*\
+|  RGBController_AlienwareAW510K.cpp        |
+|                                           |
+|  Generic RGB Interface for alienware      |
+|  AW510K Keyboard                          |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/
+
+#include "RGBController_AlienwareAW510K.h"
+#include <iterator>
+
+//0xFFFFFFFF indicates an unused entry in matrix
+#define NA  0xFFFFFFFF
+
+int GetAW520K_WaveDirection(int input);
+
+static unsigned int matrix_map[7][24] =
+{ {  0,   NA,   1,   2,   3,   4,  NA,   5,   6,   7,   8,   9,  10,  11,  12,  NA,  13,  14,  15,  NA,  16,  NA,  NA,  NA },
+  {  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  NA,  NA,  31,  32,  33,  NA,  34,  35,  36,  37 },
+  {  38,  NA,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  NA,  52,  53,  54,  NA,  55,  56,  57,  74 },
+  {  58,  NA,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,  NA,  70,  NA,  NA,  NA,  NA,  NA,  71,  72,  73,  NA },
+  {  75,  NA,  NA,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  NA,  NA,  NA,  87,  NA,  NA,  88,  89,  90, 104 },
+  {  91,  NA,  92,  93,  NA,  94,  NA,  NA,  NA,  NA,  NA,  95,  96,  97,  98,  NA,  99, 100, 101,  NA, 102,  NA, 103,  NA },
+  {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  105, NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA }};
+
+static const char* zone_names[] =
+{
+    "AW510K",
+};
+
+static zone_type zone_types[] =
+{
+    ZONE_TYPE_MATRIX,
+};
+
+static const unsigned int zone_sizes[] =
+{
+    106,
+};
+
+typedef struct
+{
+    const char *        name;
+    const unsigned char zone;
+    const unsigned char idx;
+} led_type;
+
+static const led_type led_names[] =
+{
+    /* Key Label                Zone,                                      Index  */
+    { "Key: Escape",            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB0    },
+    { "Key: F1",                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x98    },
+    { "Key: F2",                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x90    },
+    { "Key: F3",                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x88    },
+    { "Key: F4",                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x80    },
+    { "Key: F5",                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x70    },
+    { "Key: F6",                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x68    },
+    { "Key: F7",                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x60    },
+    { "Key: F8",                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x58    },
+    { "Key: F9",                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x50    },
+    { "Key: F10",               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x48    },
+    { "Key: F11",               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x40    },
+    { "Key: F12",               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x38    },
+    { "Key: Print Screen",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x30    },
+    { "Key: Scroll Lock",       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x28    },
+    { "Key: Pause/Break",       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x20    },
+    { "Key: Media Mute",        ALIENWARE_AW510K_ZONE_DIRECT_MEDIA,        0x18    },
+    { "Key: `",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB1    },
+    { "Key: 1",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA1    },
+    { "Key: 2",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x99    },
+    { "Key: 3",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x91    },
+    { "Key: 4",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x89    },
+    { "Key: 5",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x81    },
+    { "Key: 6",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x79    },
+    { "Key: 7",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x71    },
+    { "Key: 8",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x69    },
+    { "Key: 9",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x61    },
+    { "Key: 0",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x59    },
+    { "Key: -",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x51    },
+    { "Key: =",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x49    },
+    { "Key: Backspace",         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x39    },
+    { "Key: Insert",            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x31    },
+    { "Key: Home",              ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x29    },
+    { "Key: Page Up",           ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x21    },
+    { "Key: Num Lock",          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x19    },
+    { "Key: Number Pad /",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x11    },
+    { "Key: Number Pad *",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x09    },
+    { "Key: Number Pad -",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x01    },
+    { "Key: Tab",               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB2    },
+    { "Key: Q",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA2    },
+    { "Key: W",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x9A    },
+    { "Key: E",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x92    },
+    { "Key: R",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x8A    },
+    { "Key: T",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x82    },
+    { "Key: Y",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x7A    },
+    { "Key: U",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x72    },
+    { "Key: I",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x6A    },
+    { "Key: O",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x62    },
+    { "Key: P",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x5A    },
+    { "Key: [",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x52    },
+    { "Key: ]",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x4A    },
+    { "Key: \\ (ANSI)",         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x42    },//ANSI only
+    { "Key: Delete",            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x32    },
+    { "Key: End",               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x2A    },
+    { "Key: Page Down",         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x22    },
+    { "Key: Number Pad 7",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x1A    },
+    { "Key: Number Pad 8",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x12    },
+    { "Key: Number Pad 9",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x0A    },
+    { "Key: Caps Lock",         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB3    },
+    { "Key: A",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA3    },
+    { "Key: S",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x9B    },
+    { "Key: D",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x93    },
+    { "Key: F",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x8B    },
+    { "Key: G",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x83    },
+    { "Key: H",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x7B    },
+    { "Key: J",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x73    },
+    { "Key: K",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x6B    },
+    { "Key: L",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x63    },
+    { "Key: ;",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x5B    },
+    { "Key: '",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x53    },
+    { "Key: Enter",             ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x43    },
+    { "Key: Number Pad 4",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x1B    },
+    { "Key: Number Pad 5",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x13    },
+    { "Key: Number Pad 6",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x0B    },
+    { "Key: Number Pad +",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x03    },
+    { "Key: Left Shift",        ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB4    },
+    { "Key: Z",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA4    },
+    { "Key: X",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x9C    },
+    { "Key: C",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x94    },
+    { "Key: V",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x8C    },
+    { "Key: B",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x84    },
+    { "Key: N",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x7C    },
+    { "Key: M",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x74    },
+    { "Key: ,",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x6C    },
+    { "Key: .",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x64    },
+    { "Key: /",                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x5C    },
+    { "Key: Right Shift",       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x4C    },
+    { "Key: Up Arrow",          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x2C    },
+    { "Key: Number Pad 1",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x1C    },
+    { "Key: Number Pad 2",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x14    },
+    { "Key: Number Pad 3",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x0C    },
+    { "Key: Left Control",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB5    },
+    { "Key: Left Windows",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xAD    },
+    { "Key: Left Alt",          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA5    },
+    { "Key: Space",             ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x85    },
+    { "Key: Right Alt",         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x65    },
+    { "Key: Right Fn",          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x5D    },
+    { "Key: Menu",              ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x55    },
+    { "Key: Right Control",     ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x4D    },
+    { "Key: Left Arrow",        ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x35    },
+    { "Key: Down Arrow",        ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x2D    },
+    { "Key: Right Arrow",       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x25    },
+    { "Key: Number Pad 0",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x1D    },
+    { "Key: Number Pad .",      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x0D    },
+    { "Key: Number Pad Enter",  ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x05    },
+    { "Logo",                   ALIENWARE_AW510K_ZONE_DIRECT_LOGO,         0x07    }
+};
+
+RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KController* alienware_ptr)
+{
+    alienware   = alienware_ptr;
+
+    name        = "Alienware AW510K Keyboard Device";
+    vendor      = "Alienware";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "Alienware AW510K Keyboard Device";
+    location    = alienware->GetDeviceLocation();
+    serial      = alienware->GetSerialString();
+
+    mode Direct_Per_LED;
+    Direct_Per_LED.name             = "Direct";
+    Direct_Per_LED.value            = ALIENWARE_AW510K_MODE_DIRECT_PER_LED;
+    Direct_Per_LED.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct_Per_LED.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Direct_Per_LED);
+
+    mode Static;
+    Static.name                     = "Static";
+    Static.value                    = ALIENWARE_AW510K_MODE_STATIC;
+    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min               = 1;
+    Static.colors_max               = 1;
+    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Pulse;
+    Pulse.name                      = "Pulse";
+    Pulse.value                     = ALIENWARE_AW510K_MODE_PULSE;
+    Pulse.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Pulse.color_mode                = MODE_COLORS_MODE_SPECIFIC;
+    Pulse.speed_min                 = ALIENWARE_AW510K_SPEED_SLOWEST;
+    Pulse.speed_max                 = ALIENWARE_AW510K_SPEED_NORMAL;
+    Pulse.speed                     = ALIENWARE_AW510K_SPEED_NORMAL;
+    Pulse.colors_min                = 1;
+    Pulse.colors_max                = 1;
+    Pulse.colors.resize(1);
+    modes.push_back(Pulse);
+
+    mode Morph;
+    Morph.name                      = "Morph";
+    Morph.value                     = ALIENWARE_AW510K_MODE_MORPH;
+    Morph.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Morph.color_mode                = MODE_COLORS_MODE_SPECIFIC;
+    Morph.speed_min                 = ALIENWARE_AW510K_SPEED_SLOWEST;
+    Morph.speed_max                 = ALIENWARE_AW510K_SPEED_NORMAL;
+    Morph.speed                     = ALIENWARE_AW510K_SPEED_NORMAL;
+    Morph.colors_min                = 2;
+    Morph.colors_max                = 2;
+    Morph.colors.resize(2);
+    modes.push_back(Morph);
+
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = ALIENWARE_AW510K_MODE_BREATHING;
+    Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.colors_min            = 1;
+    Breathing.colors_max            = 1;
+    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors.resize(1);
+    Breathing.speed_min             = ALIENWARE_AW510K_SPEED_SLOWEST;
+    Breathing.speed_max             = ALIENWARE_AW510K_SPEED_FASTEST;
+    Breathing.speed                 = ALIENWARE_AW510K_SPEED_NORMAL;
+    modes.push_back(Breathing);
+
+    mode SingleWave;
+    SingleWave.name                  = "Single Wave";
+    SingleWave.value                 = ALIENWARE_AW510K_MODE_SINGLE_WAVE;
+    SingleWave.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    SingleWave.speed_min             = ALIENWARE_AW510K_SPEED_SLOWEST;
+    SingleWave.speed_max             = ALIENWARE_AW510K_SPEED_FASTEST;
+    SingleWave.speed                 = ALIENWARE_AW510K_SPEED_NORMAL;
+    SingleWave.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    SingleWave.colors_min            = 1;
+    SingleWave.colors_max            = 1;
+    SingleWave.colors.resize(1);
+    modes.push_back(SingleWave);
+
+    mode RainbowWave;
+    RainbowWave.name                  = "Rainbow Wave";
+    RainbowWave.value                 = ALIENWARE_AW510K_MODE_RAINBOW_WAVE;
+    RainbowWave.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    RainbowWave.speed_min             = ALIENWARE_AW510K_SPEED_SLOWEST;
+    RainbowWave.speed_max             = ALIENWARE_AW510K_SPEED_FASTEST;
+    RainbowWave.speed                 = ALIENWARE_AW510K_SPEED_NORMAL;
+    RainbowWave.colors_min            = 1;
+    RainbowWave.colors_max            = 1;
+    RainbowWave.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    RainbowWave.colors.resize(1);
+    modes.push_back(RainbowWave);
+
+    mode Off;
+    Off.name                          = "Off";
+    Off.value                         = ALIENWARE_AW510K_MODE_OFF;
+    Off.flags                         = 0;
+    Off.color_mode                    = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    SetupZones();
+    std::copy(colors.begin(), colors.end(),std::back_inserter(current_colors));
+}
+
+RGBController_AlienwareAW510K::~RGBController_AlienwareAW510K()
+{
+    /*---------------------------------------------------------*\
+    | 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 alienware;
+}
+
+void RGBController_AlienwareAW510K::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 = 7;
+            new_zone.matrix_map->width  = 24;
+            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
+        }
+
+        zones.push_back(new_zone);
+
+        total_led_count += zone_sizes[zone_idx];
+    }
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
+    {
+        led new_led;
+        new_led.name  = led_names[led_idx].name;
+        new_led.value = led_names[led_idx].idx;
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AlienwareAW510K::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
+{
+    std::vector<SelectedKeys>   frame_buf_keys;
+    std::vector<RGBColor>       new_colors;
+
+    std::copy(colors.begin(), colors.end(),std::back_inserter(new_colors));
+
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        if (current_colors[led_idx]==new_colors[led_idx])
+        {
+            /*-------------------------------------------------*\
+            | Don't send if key color is not changed            |
+            \*-------------------------------------------------*/
+            continue;
+        }
+
+        if(RGBGetRValue(colors[led_idx]) != 0x00 || RGBGetBValue(colors[led_idx]) != 0x00 || RGBGetBValue(colors[led_idx]) != 0x00)
+        {
+            SelectedKeys key;
+
+            key.idx = (unsigned char)leds[led_idx].value;
+            key.red = RGBGetRValue(colors[led_idx]);
+            key.green = RGBGetGValue(colors[led_idx]);
+            key.blue = RGBGetBValue(colors[led_idx]);
+
+            frame_buf_keys.push_back(key);
+        }
+        else
+        {
+            SelectedKeys key;
+
+            key.idx = (unsigned char)leds[led_idx].value;
+            key.red = RGBGetRValue(colors[led_idx]);
+            key.green = RGBGetGValue(colors[led_idx]);
+            key.blue = RGBGetBValue(colors[led_idx]);
+
+            frame_buf_keys.push_back(key);
+        }
+    }
+
+    alienware->SendInitialize();
+    alienware->SendfeatureReport(0x05, 0x01, 0x51, 0x00);
+    alienware->SendCommit();
+
+    if(frame_buf_keys.size() > 0)
+    {
+        alienware->SendDirectOn(frame_buf_keys);
+    }
+
+    std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
+}
+
+void RGBController_AlienwareAW510K::UpdateZoneLEDs(int zone)
+{
+    alienware->SetDirect((unsigned char) zone, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
+}
+
+void RGBController_AlienwareAW510K::UpdateSingleLED(int led)
+{
+    alienware->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+}
+
+void RGBController_AlienwareAW510K::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_AlienwareAW510K::DeviceUpdateMode()
+{
+    if(active_mode == 0xFFFF)
+    {
+        UpdateLEDs();
+        return;
+    }
+
+    alienware->SendfeatureReport(0x05, 0x01, 0x51, 0x00);
+    unsigned char red = 0;
+    unsigned char grn = 0;
+    unsigned char blu = 0;
+
+    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        red = RGBGetRValue(modes[active_mode].colors[0]);
+        grn = RGBGetGValue(modes[active_mode].colors[0]);
+        blu = RGBGetBValue(modes[active_mode].colors[0]);
+    }
+
+    switch(modes[active_mode].value)
+    {
+        case ALIENWARE_AW510K_MODE_MORPH:
+            /*-------------------------------------------------------------*\
+            | In case of morph it requires two colors (color1 and color2)   |
+            \*-------------------------------------------------------------*/
+            {
+                unsigned char red2 = RGBGetRValue(modes[active_mode].colors[1]);
+                unsigned char grn2 = RGBGetGValue(modes[active_mode].colors[1]);
+                unsigned char blu2 = RGBGetBValue(modes[active_mode].colors[1]);
+
+                alienware->SetMorphMode(modes[active_mode].value, modes[active_mode].speed, red, grn, blu, red2, grn2, blu2);
+            }
+            break;
+
+        case ALIENWARE_AW510K_MODE_SPECTRUM:
+            /*-------------------------------------------------------------*\
+            | Spectrum only set mode, speed and colorMode                   |
+            \*-------------------------------------------------------------*/
+            alienware->SetMode(modes[active_mode].value, modes[active_mode].speed, 0x00, ALIENWARE_AW510K_RANBOW_COLOR_MODE, 0x00, 0x00, 0x00);
+            break;
+
+        case ALIENWARE_AW510K_MODE_SINGLE_WAVE:
+            /*-------------------------------------------------------------*\
+            | Wave only set mode, speed, direction and colorMode            |
+            \*-------------------------------------------------------------*/
+            {
+                int waveDirection = GetAW520K_WaveDirection(modes[active_mode].direction);
+                alienware->SetMode(modes[active_mode].value, modes[active_mode].speed, waveDirection, ALIENWARE_AW510K_SINGLE_COLOR_MODE, red, grn, blu);
+            }
+            break;
+
+        case ALIENWARE_AW510K_MODE_RAINBOW_WAVE:
+            /*-------------------------------------------------------------*\
+            | Wave only set mode, speed, direction and colorMode            |
+            \*-------------------------------------------------------------*/
+            {
+            int waveDirection = GetAW520K_WaveDirection(modes[active_mode].direction);
+            alienware->SetMode(modes[active_mode].value, modes[active_mode].speed, waveDirection, ALIENWARE_AW510K_RANBOW_COLOR_MODE, 0x00, 0x00, 0x00);
+            }
+            break;
+
+
+        default:
+            alienware->SetMode(modes[active_mode].value, modes[active_mode].speed, 0x00, ALIENWARE_AW510K_SINGLE_COLOR_MODE, red, grn, blu);
+            break;
+    }
+}
+
+int GetAW520K_WaveDirection(int input)
+{
+    switch(input)
+    {
+        case MODE_DIRECTION_LEFT:
+            return(ALIENWARE_AW510K_DIRECTION_RIGHT_TO_LEFT);
+
+        case MODE_DIRECTION_RIGHT:
+            return(ALIENWARE_AW510K_DIRECTION_LEFT_TO_RIGHT);
+
+        case MODE_DIRECTION_UP:
+            return(ALIENWARE_AW510K_DIRECTION_BOTTOM_TO_TOP);
+
+        case MODE_DIRECTION_DOWN:
+            return(ALIENWARE_AW510K_DIRECTION_TOP_TO_BOTTOM);
+
+        default:
+            return(ALIENWARE_AW510K_DIRECTION_RIGHT_TO_LEFT);
+    }
+}
+

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.h

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

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,34 +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_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_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 6G"},
-    { 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"              },
 };  
 
 /******************************************************************************************\
@@ -73,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;
@@ -116,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 - Second generation motherboard controller
-    else if (strcmp(device_name, "AUMA0-E8K4-0101") == 0)
-    {
-        direct_reg = AURA_REG_COLORS_DIRECT_V2;
-        effect_reg = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V2;
-    }
-    // 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/CMMKController.cpp

@@ -12,24 +12,44 @@
 
 CMMKController::CMMKController(hid_device* dev, hid_device_info* dev_info)
 {
-    location        =  dev_info->path;
+    location            =  dev_info->path;
 
-    const int szTemp = 256;
+    const int szTemp    = 256;
     wchar_t tmpName[szTemp];
 
     hid_get_manufacturer_string(dev, tmpName, szTemp);
-    std::wstring wName = std::wstring(tmpName);
-    device_name        = std::string(wName.begin(), wName.end());
+    std::wstring wName  = std::wstring(tmpName);
+    vendor_name         = std::string(wName.begin(), wName.end());
 
     hid_get_product_string(dev, tmpName, szTemp);
     wName  = std::wstring(tmpName);
-    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
+    device_name         = std::string(wName.begin(), wName.end());
 
     cmmk_attach_path(&cmmk_handle, dev_info->path, dev_info->product_id, -1);
 
     char buf[32] = {0};
     cmmk_get_firmware_version(&cmmk_handle, buf, 32);
 
+    /*--------------------------------------------------------------*\
+    | Adjust the row count for keyboards without the front light bar |
+    | Adjust the column count for TKL keyboards (i.e. x30 vs x50)    |
+    \*--------------------------------------------------------------*/
+    enum cmmk_product_type kb_type = cmmk_get_device_model(&cmmk_handle);
+    row_count = (kb_type == CMMK_PRODUCT_MASTERKEYS_MK750) ? CMMK_ROWS_MAX : CMMK_ROWS_MAX - 1;
+    switch(kb_type)
+    {
+        case CMMK_PRODUCT_MASTERKEYS_PRO_S:
+        case CMMK_PRODUCT_MASTERKEYS_SK630:
+            column_count = CMMK_COLS_MAX - 4;
+            break;
+
+        case CMMK_PRODUCT_MASTERKEYS_PRO_L:
+        case CMMK_PRODUCT_MASTERKEYS_MK750:
+        case CMMK_PRODUCT_MASTERKEYS_SK650:
+        default:
+            column_count = CMMK_COLS_MAX;
+    }
+
     firmware_version = buf;
 }
 
@@ -43,6 +63,11 @@ std::string CMMKController::GetDeviceName()
     return device_name;
 }
 
+std::string CMMKController::GetDeviceVendor()
+{
+    return vendor_name;
+}
+
 std::string CMMKController::GetLocation()
 {
     return location;
@@ -53,6 +78,16 @@ std::string CMMKController::GetFirmwareVersion()
     return firmware_version;
 }
 
+uint8_t CMMKController::GetRowCount()
+{
+    return row_count;
+}
+
+uint8_t CMMKController::GetColumnCount()
+{
+    return column_count;
+}
+
 void CMMKController::SetFirmwareControl()
 {
     ActivateMode(CMMK_FIRMWARE);

Controllers/CoolerMasterController/CMMKController.h

@@ -20,8 +20,11 @@ public:
     ~CMMKController();
 
     std::string GetDeviceName();
+    std::string GetDeviceVendor();
     std::string GetLocation();
     std::string GetFirmwareVersion();
+    uint8_t     GetRowCount();
+    uint8_t     GetColumnCount();
 
     void SetFirmwareControl();
     void SetManualControl();
@@ -51,8 +54,11 @@ private:
     int         current_effect  = -1;
 
     std::string device_name;
+    std::string vendor_name;
     std::string location;
     std::string firmware_version;
+    uint8_t     row_count;
+    uint8_t     column_count;
 
     mutable struct cmmk cmmk_handle;
 };

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,13 +19,14 @@
 #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
 #define COOLERMASTER_SMALL_ARGB_PID             0x1000
 #define COOLERMASTER_RGB_PID                    0x004F
 #define COOLERMASTER_RADEON_6000_PID            0x014D
-#define COOLERMASTER_MASTERKEYS_PRO_L_PID       CMMK_USB_MASTERKEYS_MK750
+#define COOLERMASTER_MASTERKEYS_PRO_L_PID       CMMK_USB_MASTERKEYS_PRO_L
 #define COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID CMMK_USB_MASTERKEYS_PRO_L_WHITE
 #define COOLERMASTER_MASTERKEYS_PRO_S_PID       CMMK_USB_MASTERKEYS_PRO_S 
 #define COOLERMASTER_MASTERKEYS_MK750_PID       CMMK_USB_MASTERKEYS_MK750
@@ -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_CMMKController.cpp

@@ -14,141 +14,158 @@
 
 using namespace std::chrono_literals;
 
-#define CMMK_SPEED_MIN      CMMK_SPEED0
-#define CMMK_SPEED_MID      CMMK_SPEED2 
-#define CMMK_SPEED_MAX      CMMK_SPEED4
-#define CMMK_MODE_FIRMWARE  0xFF
-#define CMMK_MODE_MANUAL    0x7F
+#define CMMK_SPEED_MIN          CMMK_SPEED0
+#define CMMK_SPEED_MID          CMMK_SPEED2
+#define CMMK_SPEED_MAX          CMMK_SPEED4
+#define CMMK_MODE_FIRMWARE      0xFF
+#define CMMK_MODE_MANUAL        0x7F
 
 RGBController_CMMKController::RGBController_CMMKController(CMMKController* cmmk_ctrl)
 {
-    cmmk        = cmmk_ctrl;
+    cmmk                        = cmmk_ctrl;
 
-    name        = cmmk->GetDeviceName();
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "Cooler Master MasterKeys Device";
-    version     = cmmk->GetFirmwareVersion();
-    serial      = "";
-    location    = cmmk->GetLocation();
+    name                        = cmmk->GetDeviceName();
+    vendor                      = cmmk->GetDeviceVendor();
+    type                        = DEVICE_TYPE_KEYBOARD;
+    description                 = "Cooler Master MasterKeys Device";
+    version                     = cmmk->GetFirmwareVersion();
+    serial                      = "";
+    location                    = cmmk->GetLocation();
     
     mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = CMMK_MODE_MANUAL;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name                 = "Direct";
+    Direct.value                = CMMK_MODE_MANUAL;
+    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      = CMMK_EFFECT_FULLY_LIT;
-    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                = CMMK_EFFECT_FULLY_LIT;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    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      = CMMK_EFFECT_BREATHE;
-    Breathing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathing.speed_min  = 0x20;
-    Breathing.speed_max  = 0x20;
-    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors_min = 1;
-    Breathing.colors_max = 1;
+    Breathing.name              = "Breathing";
+    Breathing.value             = CMMK_EFFECT_BREATHE;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed_min         = CMMK_SPEED_MIN;
+    Breathing.speed_max         = CMMK_SPEED_MAX;
+    Breathing.speed             = CMMK_SPEED_MID;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
     Breathing.colors.resize(1);
     modes.push_back(Breathing);
 
     mode Cycle;
-    Cycle.name       = "Spectrum Cycle";
-    Cycle.value      = CMMK_EFFECT_CYCLE;
-    Cycle.flags      = MODE_FLAG_HAS_SPEED;
-    Cycle.speed_min  = CMMK_SPEED_MIN;
-    Cycle.speed_max  = CMMK_SPEED_MAX;
-    Cycle.color_mode = MODE_COLORS_NONE;
+    Cycle.name                  = "Spectrum Cycle";
+    Cycle.value                 = CMMK_EFFECT_CYCLE;
+    Cycle.flags                 = MODE_FLAG_HAS_SPEED;
+    Cycle.color_mode            = MODE_COLORS_NONE;
+    Cycle.speed_min             = 2 * CMMK_SPEED_MIN; //Spectrum Cycle uses a unique speed range
+    Cycle.speed_max             = 2 * CMMK_SPEED_MAX;
+    Cycle.speed                 = 2 * CMMK_SPEED_MID;
     modes.push_back(Cycle);
 
     mode Reactive;
-    Reactive.name       = "Reactive";
-    Reactive.value      = CMMK_EFFECT_SINGLE;
-    Reactive.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Reactive.speed_min  = CMMK_SPEED_MIN;
-    Reactive.speed_max  = CMMK_SPEED_MAX;
-    Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Reactive.colors_min = 2;
-    Reactive.colors_max = 2;
+    Reactive.name               = "Reactive";
+    Reactive.value              = CMMK_EFFECT_SINGLE;
+    Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Reactive.speed_min          = CMMK_SPEED_MIN;
+    Reactive.speed_max          = CMMK_SPEED_MAX;
+    Reactive.speed              = CMMK_SPEED_MID;
+    Reactive.colors_min         = 2;
+    Reactive.colors_max         = 2;
     Reactive.colors.resize(2);
     modes.push_back(Reactive);
 
     mode Wave;
-    Wave.name       = "Rainbow Wave";
-    Wave.value      = CMMK_EFFECT_WAVE;
-    Wave.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
-    Wave.speed_min  = CMMK_SPEED_MIN;
-    Wave.speed_max  = CMMK_SPEED_MAX;
-    Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Wave.colors_min = 1;
-    Wave.colors_max = 1;
+    Wave.name                   = "Rainbow Wave";
+    Wave.value                  = CMMK_EFFECT_WAVE;
+    Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Wave.speed_min              = CMMK_SPEED_MIN;
+    Wave.speed_max              = CMMK_SPEED_MAX;
+    Wave.speed                  = CMMK_SPEED_MID;
+    Wave.direction              = MODE_DIRECTION_LEFT;
+    Wave.colors_min             = 1;
+    Wave.colors_max             = 1;
     Wave.colors.resize(1);
     modes.push_back(Wave);
     
     mode Ripple;
-    Ripple.name       = "Ripple Effect";
-    Ripple.value      = CMMK_EFFECT_RIPPLE;
-    Ripple.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
-    Ripple.speed_min  = CMMK_SPEED_MIN;
-    Ripple.speed_max  = CMMK_SPEED_MAX;
-    Ripple.colors_min = 2;
-    Ripple.colors_max = 2;
+    Ripple.name                 = "Ripple Effect";
+    Ripple.value                = CMMK_EFFECT_RIPPLE;
+    Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
+    Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Ripple.speed_min            = CMMK_SPEED_MIN;
+    Ripple.speed_max            = CMMK_SPEED_MAX;
+    Ripple.speed                = CMMK_SPEED_MID;
+    Ripple.colors_min           = 2;
+    Ripple.colors_max           = 2;
     Ripple.colors.resize(2);
     modes.push_back(Ripple);
     
     mode Cross;
-    Cross.name       = "Cross";
-    Cross.value      = CMMK_EFFECT_CROSS;
-    Cross.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Cross.speed_min  = CMMK_SPEED_MIN;
-    Cross.speed_max  = CMMK_SPEED_MAX;
-    Cross.colors_min = 2;
-    Cross.colors_max = 2;
+    Cross.name                  = "Cross";
+    Cross.value                 = CMMK_EFFECT_CROSS;
+    Cross.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Cross.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Cross.speed_min             = CMMK_SPEED_MIN;
+    Cross.speed_max             = CMMK_SPEED_MAX;
+    Cross.speed                 = CMMK_SPEED_MID;
+    Cross.colors_min            = 2;
+    Cross.colors_max            = 2;
     Cross.colors.resize(2);
     modes.push_back(Cross);
 
     mode Raindrops;
-    Raindrops.name       = "Raindrops";
-    Raindrops.value      = CMMK_EFFECT_RAINDROPS;
-    Raindrops.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Raindrops.speed_min  = CMMK_SPEED_MIN;
-    Raindrops.speed_max  = CMMK_SPEED_MAX;
-    Raindrops.colors_min = 2;
-    Raindrops.colors_max = 2;
+    Raindrops.name              = "Raindrops";
+    Raindrops.value             = CMMK_EFFECT_RAINDROPS;
+    Raindrops.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Raindrops.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Raindrops.speed_min         = CMMK_SPEED_MIN;
+    Raindrops.speed_max         = CMMK_SPEED_MAX;
+    Raindrops.speed             = CMMK_SPEED_MID;
+    Raindrops.colors_min        = 2;
+    Raindrops.colors_max        = 2;
     Raindrops.colors.resize(2);
     modes.push_back(Raindrops);
     
     mode Stars;
-    Stars.name       = "Starfield";
-    Stars.value      = CMMK_EFFECT_STARS;
-    Stars.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Stars.speed_min  = CMMK_SPEED_MIN;
-    Stars.speed_max  = CMMK_SPEED_MAX;
-    Stars.colors_min = 2;
+    Stars.name                  = "Starfield";
+    Stars.value                 = CMMK_EFFECT_STARS;
+    Stars.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
+    Stars.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Stars.speed_min             = CMMK_SPEED_MIN;
+    Stars.speed_max             = CMMK_SPEED_MAX;
+    Stars.speed                 = CMMK_SPEED_MID;
+    Stars.colors_min            = 2;
     Stars.colors_max = 2;
     Stars.colors.resize(2);
     modes.push_back(Stars);
 
     mode Snake;
-    Snake.name      = "Snake";
-    Snake.value     = CMMK_EFFECT_SNAKE;
-    Snake.flags     = MODE_FLAG_HAS_SPEED;
-    Snake.speed_min = CMMK_SPEED_MIN;
-    Snake.speed_max = CMMK_SPEED_MAX;
+    Snake.name                  = "Snake";
+    Snake.value                 = CMMK_EFFECT_SNAKE;
+    Snake.flags                 = MODE_FLAG_HAS_SPEED;
+    Snake.color_mode            = MODE_COLORS_NONE;
+    Snake.speed_min             = CMMK_SPEED_MIN;
+    Snake.speed_max             = CMMK_SPEED_MAX;
+    Snake.speed                 = CMMK_SPEED_MID;
     modes.push_back(Snake);
 
     mode FirmwareControl;
-    FirmwareControl.name  = "Firmware Controlled";
-    FirmwareControl.value = 0xFF;
-    FirmwareControl.flags = 0;
+    FirmwareControl.name        = "Firmware Controlled";
+    FirmwareControl.value       = 0xFF;
+    FirmwareControl.flags       = 0;
+    FirmwareControl.color_mode  = MODE_COLORS_NONE;
     modes.push_back(FirmwareControl);
 
     SetupZones();
@@ -182,9 +199,12 @@ void RGBController_CMMKController::SetupMatrixMap()
 
 void RGBController_CMMKController::SetupZones()
 {
-    for(int y = 0; y < CMMK_ROWS_MAX; y++)
+    uint8_t row_count       = cmmk->GetRowCount();
+    uint8_t column_count    = cmmk->GetColumnCount();
+
+    for(int y = 0; y < row_count; y++)
     {
-        for(int x = 0; x < CMMK_COLS_MAX; x++)
+        for(int x = 0; x < column_count; x++)
         {
             if(!cmmk->PositionValid(y, x))
             {
@@ -211,8 +231,8 @@ void RGBController_CMMKController::SetupZones()
     KeyboardZone.leds_max           = leds.size();
     KeyboardZone.leds_count         = leds.size();
     KeyboardZone.matrix_map         = new matrix_map_type;
-    KeyboardZone.matrix_map->height = CMMK_ROWS_MAX;
-    KeyboardZone.matrix_map->width  = CMMK_COLS_MAX;
+    KeyboardZone.matrix_map->height = row_count;
+    KeyboardZone.matrix_map->width  = column_count;
     KeyboardZone.matrix_map->map    = (unsigned int *)&matrix_map;
 
     zones.push_back(KeyboardZone);

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/CorsairPeripheralController/CorsairK100Controller.cpp

@@ -0,0 +1,136 @@
+/*-----------------------------------------*\
+|  CorsairK100Controller.cpp                |
+|                                           |
+|  Driver for Corsair K100 Keyboard         |
+\*-----------------------------------------*/
+
+#include "CorsairK100Controller.h"
+#include "LogManager.h"
+
+static unsigned int keys_k100[] = {0x25, 0x31, 0x27, 0x35, 0x66, 0x65, 0x41, 0x2A, 0x6E, 0x5B, 0x36, 0x1A, 0x10, 0x00, 0x68, 0x42,
+                                   0x62, 0x5C, 0x37, 0x1B, 0x16, 0x12, 0x19, 0x67, 0x43, 0x26, 0x77, 0x5D, 0x38, 0x1C, 0x04, 0x03,
+                                   0x17, 0x44, 0x48, 0x7A, 0x39, 0x1D, 0x11, 0x05, 0x02, 0x28, 0x45, 0x49, 0x78, 0x58, 0x3A, 0x1E,
+                                   0x13, 0x06, 0x15, 0x46, 0x4A, 0x79, 0x59, 0x3B, 0x1F, 0x18, 0x07, 0x01, 0x47, 0x6A, 0x4F, 0x5A,
+                                   0x3C, 0x20, 0x14, 0x09, 0x0D, 0x6B, 0x2C, 0x69, 0x50, 0x55, 0x3D, 0x21, 0x08, 0x0A, 0x0C, 0x76,
+                                   0x2D, 0x4E, 0x51, 0x56, 0x3E, 0x22, 0x0E, 0x0B, 0x32, 0x61, 0x4C, 0x52, 0x57, 0x3F, 0x23, 0x0F,
+                                   0x2F, 0x33, 0x24, 0x4D, 0x53, 0x5E, 0x40, 0x29, 0x2B, 0x30, 0x34, /*Brightness,*/
+                                   0x4B, 0x54, 0x5F, 114 , 99, 0x7C, //114 and 99 is not conformed it just a guess
+                                   0x7F, 0x80, 0x81, 0x82, 0x83, 0x84,//Macro
+                                   0xA6, 0xA5, 0xA4, 0xA3, 0xA2, 0xA1, 0xA0, 0x9F, 0x9E, 0x9D, 0x9C, 0x86, 0x87, 0x88, 0x89, 0x8A,
+                                   0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A,
+                                   0x9B, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,0xB0, 0xB1, //Light Bar
+                                   0x85, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9,//Nameplate
+                                   0xBA, 0xBB, 0xBC/*Logo*/};
+
+CorsairK100Controller::CorsairK100Controller(hid_device* dev_handle, const char* path)
+{
+    dev             = dev_handle;
+    location        = path;
+    keyboard_type   = CORSAIR_TYPE_K100;
+
+    LightingControl();
+}
+CorsairK100Controller::~CorsairK100Controller()
+{
+    hid_close(dev);
+}
+
+std::string CorsairK100Controller::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string CorsairK100Controller::GetFirmwareString()
+{
+    return "";
+}
+
+std::string CorsairK100Controller::GetName()
+{
+    return name;
+}
+
+void CorsairK100Controller::SetName(std::string device_name)
+{
+    name = device_name;
+}
+
+CorsairKeyboardType CorsairK100Controller::GetKeyboardType()
+{
+    return keyboard_type;
+}
+
+std::string CorsairK100Controller::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 CorsairK100Controller::LightingControl()
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x05;
+    usb_buf[0x03] = 0x01;
+
+    hid_write(dev, (unsigned char *)usb_buf, 5);
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    int res = hid_read_timeout(dev, usb_buf, 50, 1000);
+
+    if (res == 0 || usb_buf[1] != 0x05)
+    {
+        LOG_INFO("[Corsair-K100] This device did not allow to take control over it.");
+        keyboard_type = CORSAIR_TYPE_UNKNOWN;
+    }
+}
+
+void CorsairK100Controller::SetLEDs(std::vector<RGBColor>colors)
+{
+    switch(keyboard_type)
+    {
+        case CORSAIR_TYPE_K100:
+            SetLEDsKeyboardFull(colors);
+            break;
+
+        case CORSAIR_TYPE_UNKNOWN:
+            break;
+    }
+}
+
+void CorsairK100Controller::SetLEDsKeyboardFull(std::vector<RGBColor> colors)
+{
+    unsigned char usb_buf[600];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00] = 0x00;
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x06;
+    usb_buf[0x03] = 0x01;
+    usb_buf[0x04] = 0x45;
+    usb_buf[0x05] = 0x02;
+    usb_buf[0x08] = 0x12;
+
+    for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        RGBColor color = colors[color_idx];
+        usb_buf[0x16 + keys_k100[color_idx]*3] = RGBGetRValue(color);
+        usb_buf[0x17 + keys_k100[color_idx]*3] = RGBGetGValue(color);
+        usb_buf[0x18 + keys_k100[color_idx]*3] = RGBGetBValue(color);
+    }
+
+    hid_write(dev, (unsigned char *)usb_buf, 600);
+}

Controllers/CorsairPeripheralController/CorsairK100Controller.h

@@ -0,0 +1,49 @@
+/*-----------------------------------------*\
+|  CorsairK100Controller.h                  |
+|                                           |
+|  Driver for Corsair K100 Keyboard         |
+\*-----------------------------------------*/
+
+#ifndef CORSAIRK100CONTROLLER_H
+#define CORSAIRK100CONTROLLER_H
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+typedef enum
+{
+    CORSAIR_TYPE_UNKNOWN            = 0,
+    CORSAIR_TYPE_K100               = 1
+} CorsairKeyboardType;
+
+class CorsairK100Controller
+{
+public:
+    CorsairK100Controller(hid_device* dev_handle, const char* path);
+    ~CorsairK100Controller();
+    CorsairKeyboardType             GetKeyboardType();
+    std::string                     GetDeviceLocation();
+    std::string                     GetFirmwareString();
+    std::string                     GetName();
+    std::string                     GetSerialString();
+
+    void                            SetLEDs(std::vector<RGBColor> colors);
+    void                            SetLEDsKeyboardLimited(std::vector<RGBColor> colors);
+    void                            SetName(std::string device_name);
+
+private:
+    hid_device*             dev;
+
+    std::string             firmware_version;
+    std::string             location;
+    std::string             name;
+    device_type             type;
+    CorsairKeyboardType     keyboard_type;
+
+    void                    LightingControl();
+    void                    SetLEDsKeyboardFull(std::vector<RGBColor> colors);
+};
+
+#endif // CORSAIRK100CONTROLLER_H

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -22,6 +22,15 @@ static unsigned int keys[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x
                               116,  117,  120,  121,  122,  123,  124,  126,  127,  128,  129,  132,  133,  134,  135,
                               136,  137,  139,  140,  141, 0x10, 114};
 
+static unsigned int keys_k70_mk2[] =   {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0C, 0x0D, 0x0E, 0x0F, 0x11, 0x12,
+                                        0x14, 0x15, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x24, 0x25, 0x26,
+                                        0x27, 0x28, 0x2A, 0x2B, 0x2C, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+                                        0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x42, 0x43, 0x44, 0x45, 0x48, 73,   74,   75,   76,   78,
+                                        79,   80,   81,   84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   96,   97,
+                                        98,   99,   100,  101,  102,  103,  104,  105,  108,  109,  110,  111,  112,  113,  115,
+                                        116,  117,  120,  121,  122,  123,  124,  126,  127,  128,  129,  132,  133,  134,  135,
+                                        136,  137,  139,  140,  141,  16,   114,  47,   59,   125 };
+
 
 static unsigned int keys_k95_plat[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0C, 0x0D, 0x0E, 0x0F, 0x11, 0x12,
                                        0x14, 0x15, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x24, 0x25, 0x26,
@@ -61,14 +70,14 @@ CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle,
     /*-----------------------------------------------------*\
     | K55 and K95 Platinum require additional steps         |
     \*-----------------------------------------------------*/
-    if (logical_layout == CORSAIR_TYPE_K55 || logical_layout == CORSAIR_TYPE_K95_PLAT)
+    if (logical_layout == CORSAIR_TYPE_K55 || logical_layout == CORSAIR_TYPE_K95_PLAT || logical_layout == CORSAIR_TYPE_K70_MK2 || logical_layout == CORSAIR_TYPE_K68)
     {
         SpecialFunctionControl();
     }
 
     LightingControl();
 
-    if (logical_layout == CORSAIR_TYPE_K55 || logical_layout == CORSAIR_TYPE_K95_PLAT)
+    if (logical_layout == CORSAIR_TYPE_K55 || logical_layout == CORSAIR_TYPE_K95_PLAT || logical_layout == CORSAIR_TYPE_K70_MK2 || logical_layout == CORSAIR_TYPE_K68)
     {
         SetupK55AndK95LightingControl();
     }
@@ -204,6 +213,12 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
             blu_val[keys_k95[color_idx]] = RGBGetBValue(color);
             data_sz = 48; //untested
         }
+        else if (logical_layout = CORSAIR_TYPE_K70_MK2)
+        {
+            red_val[keys_k70_mk2[color_idx]] = RGBGetRValue(color);
+            grn_val[keys_k70_mk2[color_idx]] = RGBGetGValue(color);
+            blu_val[keys_k70_mk2[color_idx]] = RGBGetBValue(color);
+        }
         else
         {
             red_val[keys[color_idx]] = RGBGetRValue(color);
@@ -541,6 +556,17 @@ void CorsairPeripheralController::ReadFirmwareInfo()
                     logical_layout = CORSAIR_TYPE_K55;
                     break;
 
+                    case 0x1B38:
+                    case 0x1B49:
+                    case 0x1B6B:
+                    case 0x1B55:
+                    logical_layout = CORSAIR_TYPE_K70_MK2;
+                    break;
+
+                    case 0x1B4F:
+                    logical_layout = CORSAIR_TYPE_K68;
+                    break;
+
                     default:
                     logical_layout = CORSAIR_TYPE_NORMAL;
                 }

Controllers/CorsairPeripheralController/CorsairPeripheralController.h

@@ -62,7 +62,9 @@ enum
     CORSAIR_TYPE_NORMAL             = 0,
     CORSAIR_TYPE_K95_PLAT           = 1,
     CORSAIR_TYPE_K95                = 2,
-    CORSAIR_TYPE_K55                = 3
+    CORSAIR_TYPE_K55                = 3,
+    CORSAIR_TYPE_K70_MK2            = 4,
+    CORSAIR_TYPE_K68                = 5
 };
 
 class CorsairPeripheralController

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -1,7 +1,9 @@
 #include "Detector.h"
 #include "CorsairPeripheralController.h"
+#include "CorsairK100Controller.h"
 #include "RGBController.h"
 #include "RGBController_CorsairPeripheral.h"
+#include "RGBController_CorsairK100.h"
 #include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
@@ -60,6 +62,33 @@
 \*-----------------------------------------------------*/
 #define CORSAIR_ST100_PID               0x0A34
 
+/*-----------------------------------------------------*\
+| Corsair K100 Keyboard product ID                      |
+| This keyboard uses a separate driver                  |
+\*-----------------------------------------------------*/
+#define CORSAIR_K100_PID                0x1B7C
+
+void DetectCorsairK100Controllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        CorsairK100Controller* controller = new CorsairK100Controller(dev, info->path);
+        controller->SetName(name);
+
+        if(controller->GetKeyboardType() != CORSAIR_TYPE_UNKNOWN)
+        {
+            RGBController_CorsairK100* rgb_controller = new RGBController_CorsairK100(controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+        else
+        {
+            delete controller;
+        }
+    }
+}   /* DetectCorsairPeripheralControllers() */
+
 /******************************************************************************************\
 *                                                                                          *
 *   DetectCorsairPeripheralControllers                                                     *
@@ -67,11 +96,11 @@
 *       Tests the USB address to see if a Corsair RGB Keyboard controller exists there.    *
 *                                                                                          *
 \******************************************************************************************/
-
 void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
-    if( dev )
+
+    if(dev)
     {
         CorsairPeripheralController* controller = new CorsairPeripheralController(dev, info->path);
         controller->SetName(name);
@@ -134,3 +163,8 @@ REGISTER_HID_DETECTOR_P("Corsair ST100 RGB",                DetectCorsairPeriphe
 #else
 REGISTER_HID_DETECTOR_I("Corsair ST100 RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID,             0);
 #endif
+
+/*-----------------------------------------------------------------------------------------------------*\
+| Corsair K100 Keyboard                                                                                 |
+\*-----------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("Corsair K100",                    DetectCorsairK100Controllers,       CORSAIR_VID, CORSAIR_K100_PID,              1, 0xFF42);

Controllers/CorsairPeripheralController/RGBController_CorsairK100.cpp

@@ -0,0 +1,338 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairK100.cpp            |
+|                                           |
+|  Driver for Corsair K100 Keyboard         |
+\*-----------------------------------------*/
+
+#include "RGBController_CorsairK100.h"
+#include "LogManager.h"
+
+#define NA  0xFFFFFFFF
+
+static unsigned int matrix_map_k100[7][24] =
+    { {  NA, 112,  NA,   8,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  16,  NA,  NA,  NA,},
+      { 113,   0,  NA,  10,  18,  28,  36,  NA,  46,  55,  64,  74,  NA,  84,  93, 102,   6,  15,  24,  33,  26,  35,  44,  53 },
+      { 114,   1,  11,  19,  29,  37,  47,  56,  65,  75,  85,  94,  NA, 103,   7,  25,  NA,  42,  51,  60,  62,  72,  82,  91 },
+      { 115,   2,  NA,  12,  20,  30,  38,  NA,  48,  57,  66,  76,  86,  95, 104,  70,  80,  34,  43,  52,  9,   17,  27, 100 },
+      { 116,   3,  NA,  13,  21,  31,  39,  NA,  49,  58,  67,  77,  87,  96, 105,  98, 111,  NA,  NA,  NA,  45,  54,  63,  NA },
+      { 117,   4, 110,  22,  32,  40,  50,  NA,  59,  NA,  68,  78,  88,  97, 106,  61,  NA,  NA,  81,  NA,  73,  83,  92, 108 },
+      { 118,   5,  14,  23,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  69,  79,  89,  71,  90,  99, 107, 101,  NA, 109,  NA } };
+
+static const char* led_names_k100[] =
+{
+    "Key: Escape",          //0
+    "Key: `",               //1
+    "Key: Tab",             //2
+    "Key: Caps Lock",       //3
+    "Key: Left Shift",      //4
+    "Key: Left Control",    //5
+    "Key: F12",             //6
+    "Key: =",               //7
+    "Key: Lock",            //8
+    "Key: Number Pad 7",    //9
+    "Key: F1",              //12
+    "Key: 1",               //13
+    "Key: Q",               //14
+    "Key: A",               //15
+    "Key: Left Windows",    //17
+    "Key: Print Screen",    //18
+    "Key: Media Mute",      //20
+    "Key: Number Pad 8",    //21
+    "Key: F2",              //24
+    "Key: 2",               //25
+    "Key: W",               //26
+    "Key: S",               //27
+    "Key: Z",               //28
+    "Key: Left Alt",        //29
+    "Key: Scroll Lock",     //30
+    "Key: Backspace",       //31
+    "Key: Media Stop",      //32
+    "Key: Number Pad 9",    //33
+    "Key: F3",              //36
+    "Key: 3",               //37
+    "Key: E",               //38
+    "Key: D",               //39
+    "Key: X",               //40
+    "Key: Pause/Break",     //42
+    "Key: Delete",          //43
+    "Key: Media Previous",  //44
+    "Key: F4",              //48
+    "Key: 4",               //49
+    "Key: R",               //50
+    "Key: F",               //51
+    "Key: C",               //52
+    "Key: Space",           //53
+    "Key: Insert",          //54
+    "Key: End",             //55
+    "Key: Media Play/Pause",//56
+    "Key: Number Pad 4",    //57
+    "Key: F5",              //60
+    "Key: 5",               //61
+    "Key: T",               //62
+    "Key: G",               //63
+    "Key: V",               //64
+    "Key: Home",            //66
+    "Key: Page Down",       //67
+    "Key: Media Next",      //68
+    "Key: Number Pad 5",    //69
+    "Key: F6",              //72
+    "Key: 6",               //73
+    "Key: Y",               //74
+    "Key: H",               //75
+    "Key: B",               //76
+    "Key: Page Up",         //78
+    "Key: Right Shift",     //79
+    "Key: Num Lock",        //80
+    "Key: Number Pad 6",    //81
+    "Key: F7",              //84
+    "Key: 7",               //85
+    "Key: U",               //86
+    "Key: J",               //87
+    "Key: N",               //88
+    "Key: Right Alt",       //89
+    "Key: ]",               //90
+    "Key: Right Control",   //91
+    "Key: Number Pad /",    //92
+    "Key: Number Pad 1",    //93
+    "Key: F8",              //96
+    "Key: 8",               //97
+    "Key: I",               //98
+    "Key: K",               //99
+    "Key: M",               //100
+    "Key: Right Windows",   //101
+    "Key: \\ (ANSI)",       //102
+    "Key: Up Arrow",        //103
+    "Key: Number Pad *",    //104
+    "Key: Number Pad 2",    //105
+    "Key: F9",              //108
+    "Key: 9",               //109
+    "Key: O",               //110
+    "Key: L",               //111
+    "Key: ,",               //112
+    "Key: Menu",            //113
+    "Key: Left Arrow",      //115
+    "Key: Number Pad -",    //116
+    "Key: Number Pad 3",    //117
+    "Key: F10",             //120
+    "Key: 0",               //121
+    "Key: P",               //122
+    "Key: ;",               //123
+    "Key: .",               //124
+    "Key: Enter",           //126
+    "Key: Down Arrow",      //127
+    "Key: Number Pad +",    //128
+    "Key: Number Pad 0",    //129
+    "Key: F11",             //132
+    "Key: -",               //133
+    "Key: [",               //134
+    "Key: '",               //135
+    "Key: /",               //136
+//    "Key: Brightness",      //137
+    "Key: Right Arrow",     //139
+    "Key: Number Pad Enter",//140
+    "Key: Number Pad .",    //141
+    "Key: / (ISO)",
+    "Key: \\ (ISO)",
+    "Key: Preset",
+    "Key: G1",
+    "Key: G2",
+    "Key: G3",
+    "Key: G4",
+    "Key: G5",
+    "Key: G6",
+};
+static const char* led_names_lightbar[] =
+{
+    "Underglow 1",
+    "Underglow 2",
+    "Underglow 3",
+    "Underglow 4",
+    "Underglow 5",
+    "Underglow 6",
+    "Underglow 7",
+    "Underglow 8",
+    "Underglow 9",
+    "Underglow 10",
+    "Underglow 11",
+    "Underglow 12",
+    "Underglow 13",
+    "Underglow 14",
+    "Underglow 15",
+    "Underglow 16",
+    "Underglow 17",
+    "Underglow 18",
+    "Underglow 19",
+    "Underglow 20",
+    "Underglow 21",
+    "Underglow 22",
+    "Underglow 23",
+    "Underglow 24",
+    "Underglow 25",
+    "Underglow 26",
+    "Underglow 27",
+    "Underglow 28",
+    "Underglow 29",
+    "Underglow 30",
+    "Underglow 31",
+    "Underglow 32",
+    "Underglow 33",
+    "Underglow 34",
+    "Underglow 35",
+    "Underglow 36",
+    "Underglow 37",
+    "Underglow 38",
+    "Underglow 39",
+    "Underglow 40",
+    "Underglow 41",
+    "Underglow 42",
+    "Underglow 43",
+    "Underglow 44",
+};
+static const char* led_names_nameplate[] =
+{
+    "Nameplate 1",
+    "Nameplate 2",
+    "Nameplate 3",
+    "Nameplate 4",
+    "Nameplate 5",
+    "Nameplate 6",
+    "Nameplate 7",
+    "Nameplate 8",
+    "Nameplate 9",
+};
+static const char* led_names_logo[] =
+{
+    "Logo",
+    "Logo",
+    "Logo",
+};
+
+typedef struct
+{
+    const char* name;
+    const unsigned int size;
+    const zone_type type;
+    const char** led_names;
+    matrix_map_type* matrix;
+} led_zone_layout;
+
+RGBController_CorsairK100::RGBController_CorsairK100(CorsairK100Controller* corsair_ptr)
+{
+    corsair         = corsair_ptr;
+
+    name            = corsair->GetName();
+    vendor          = "Corsair";
+    description     = "Corsair K100 Keyboard Device";
+    type            = DEVICE_TYPE_KEYBOARD;
+    version         = corsair->GetFirmwareString();
+    location        = corsair->GetDeviceLocation();
+    serial          = corsair->GetSerialString();
+
+    logical_layout  = corsair->GetKeyboardType();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_CorsairK100::~RGBController_CorsairK100()
+{
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].type == ZONE_TYPE_MATRIX)
+        {
+            delete zones[zone_index].matrix_map;
+        }
+    }
+
+    delete corsair;
+}
+
+void RGBController_CorsairK100::SetupZones()
+{
+    std::vector<led_zone_layout> selected_zone;
+
+    switch(logical_layout)
+    {
+        case CORSAIR_TYPE_K100:
+            selected_zone.push_back({"Keyboard",    119,    ZONE_TYPE_MATRIX, led_names_k100, new matrix_map_type{7, 24, (unsigned int *)&matrix_map_k100}});
+            selected_zone.push_back({"Underglow",   44,     ZONE_TYPE_LINEAR, led_names_lightbar});
+            selected_zone.push_back({"Nameplate",   9,      ZONE_TYPE_LINEAR, led_names_nameplate});
+            selected_zone.push_back({"Logo",        3,      ZONE_TYPE_LINEAR, led_names_logo});
+            break;
+    }
+
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_idx = 0; zone_idx < selected_zone.size(); zone_idx++)
+    {
+        zone new_zone;
+
+        new_zone.name                   = selected_zone[zone_idx].name;
+        new_zone.type                   = selected_zone[zone_idx].type;
+        new_zone.leds_min               = selected_zone[zone_idx].size;
+        new_zone.leds_max               = selected_zone[zone_idx].size;
+        new_zone.leds_count             = selected_zone[zone_idx].size;
+
+        if (new_zone.type == ZONE_TYPE_MATRIX)
+        {
+            new_zone.matrix_map         = selected_zone[zone_idx].matrix;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
+        }
+
+        zones.push_back(new_zone);
+
+        for(unsigned int led_idx = 0; led_idx < selected_zone[zone_idx].size; led_idx++)
+        {
+            led new_led;
+            new_led.name = selected_zone[zone_idx].led_names[led_idx];
+            leds.push_back(new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_CorsairK100::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_CorsairK100::DeviceUpdateLEDs()
+{
+    corsair->SetLEDs(colors);
+}
+
+void RGBController_CorsairK100::UpdateZoneLEDs(int /*zone*/)
+{
+    corsair->SetLEDs(colors);
+}
+
+void RGBController_CorsairK100::UpdateSingleLED(int /*led*/)
+{
+    corsair->SetLEDs(colors);
+}
+
+void RGBController_CorsairK100::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_CorsairK100::DeviceUpdateMode()
+{
+
+}

Controllers/CorsairPeripheralController/RGBController_CorsairK100.h

@@ -0,0 +1,34 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairK100.cpp            |
+|                                           |
+|  Driver for Corsair K100 Keyboard         |
+\*-----------------------------------------*/
+
+#ifndef RGBCONTROLLER_CORSAIRK100_H
+#define RGBCONTROLLER_CORSAIRK100_H
+
+#include "RGBController.h"
+#include "CorsairK100Controller.h"
+
+class RGBController_CorsairK100 : public RGBController
+{
+public:
+    RGBController_CorsairK100(CorsairK100Controller* corsair_ptr);
+    ~RGBController_CorsairK100();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
+
+    void DeviceUpdateMode();
+    void SetCustomMode();
+
+private:
+    CorsairK100Controller*  corsair;
+    CorsairKeyboardType     logical_layout;
+};
+
+#endif // RGBCONTROLLER_CORSAIRK100_H

Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.cpp

@@ -20,6 +20,15 @@ static unsigned int matrix_map[6][23] =
       {   4, 111,  22,  32,  40,  50,  NA,  59,  NA,  68,  78,  88,  97, 106,  61,  NA,  NA,  81,  NA,  73,  83,  92, 109 },
       {   5,  14,  23,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  69,  79,  89,  71,  90,  99, 108, 101,  NA, 110,  NA } };
 
+static unsigned int matrix_map_k70_mk2[7][23] =
+    { {  NA,  NA,  NA, 115, 107,   8,  NA,  NA,  NA,  NA,  NA, 113, 114,  NA,  NA,  NA,  NA,  NA,  NA,  16,  NA,  NA,  NA,},
+      {   0,  NA,  10,  18,  28,  36,  NA,  46,  55,  64,  74,  NA,  84,  93, 102,   6,  15,  24,  33,  26,  35,  44,  53 },
+      {   1,  11,  19,  29,  37,  47,  56,  65,  75,  85,  94,  NA, 103,   7,  25,  NA,  42,  51,  60,  62,  72,  82,  91 },
+      {   2,  NA,  12,  20,  30,  38,  NA,  48,  57,  66,  76,  86,  95, 104,  70,  80,  34,  43,  52,  9,   17,  27, 100 },
+      {   3,  NA,  13,  21,  31,  39,  NA,  49,  58,  67,  77,  87,  96, 105,  98, 112,  NA,  NA,  NA,  45,  54,  63,  NA },
+      {   4, 111,  22,  32,  40,  50,  NA,  59,  NA,  68,  78,  88,  97, 106,  61,  NA,  NA,  81,  NA,  73,  83,  92, 109 },
+      {   5,  14,  23,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  69,  79,  89,  71,  90,  99, 108, 101,  NA, 110,  NA } };
+
 static unsigned int matrix_map_k95_platinum[7][24] =
     { {  NA,  NA,  NA, 119, 107,   8,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  16,  NA,  NA,  NA,},
       { 113,   0,  NA,  10,  18,  28,  36,  NA,  46,  55,  64,  74,  NA,  84,  93, 102,   6,  15,  24,  33,  26,  35,  44,  53 },
@@ -56,6 +65,24 @@ static const zone_type zone_types[] =
     ZONE_TYPE_MATRIX,
 };
 
+/*---------------------------------------------------------*\
+| K70 MK2 Corsair Layout                                    |
+\*---------------------------------------------------------*/
+static const char* zone_names_k70_mk2[] =
+{
+    "Keyboard",
+};
+
+static const unsigned int zone_sizes_k70_mk2[] =
+{
+    116
+};
+
+static const zone_type zone_types_k70_mk2[] =
+{
+    ZONE_TYPE_MATRIX,
+};
+
 /*---------------------------------------------------------*\
 | K95 Platinum                                              |
 \*---------------------------------------------------------*/
@@ -236,6 +263,131 @@ static const char* led_names[] =
     "Key: \\ (ISO)",
 };
 
+static const char* led_names_k70_mk2[] =
+{
+    "Key: Escape",          //0
+    "Key: `",               //1
+    "Key: Tab",             //2
+    "Key: Caps Lock",       //3
+    "Key: Left Shift",      //4
+    "Key: Left Control",    //5
+    "Key: F12",             //6
+    "Key: =",               //7
+    "Key: Lock",            //8
+    "Key: Number Pad 7",    //9
+    "Key: F1",              //12
+    "Key: 1",               //13
+    "Key: Q",               //14
+    "Key: A",               //15
+    //"Key: / (ISO)",         //16
+    "Key: Left Windows",    //17
+    "Key: Print Screen",    //18
+    "Key: Media Mute",      //20
+    "Key: Number Pad 8",    //21
+    "Key: F2",              //24
+    "Key: 2",               //25
+    "Key: W",               //26
+    "Key: S",               //27
+    "Key: Z",               //28
+    "Key: Left Alt",        //29
+    "Key: Scroll Lock",     //30
+    "Key: Backspace",       //31
+    "Key: Media Stop",      //32
+    "Key: Number Pad 9",    //33
+    "Key: F3",              //36
+    "Key: 3",               //37
+    "Key: E",               //38
+    "Key: D",               //39
+    "Key: X",               //40
+    "Key: Pause/Break",     //42
+    "Key: Delete",          //43
+    "Key: Media Previous",  //44
+    //"Key: Logo Left",       //047
+    "Key: F4",              //48
+    "Key: 4",               //49
+    "Key: R",               //50
+    "Key: F",               //51
+    "Key: C",               //52
+    "Key: Space",           //53
+    "Key: Insert",          //54
+    "Key: End",             //55
+    "Key: Media Play/Pause",//56
+    "Key: Number Pad 4",    //57
+    //"Key: Logo Right",      //059
+    "Key: F5",              //60
+    "Key: 5",               //61
+    "Key: T",               //62
+    "Key: G",               //63
+    "Key: V",               //64
+    "Key: Home",            //66
+    "Key: Page Down",       //67
+    "Key: Media Next",      //68
+    "Key: Number Pad 5",    //69
+    "Key: F6",              //72
+    "Key: 6",               //73
+    "Key: Y",               //74
+    "Key: H",               //75
+    "Key: B",               //76
+    "Key: Page Up",         //78
+    "Key: Right Shift",     //79
+    "Key: Num Lock",        //80
+    "Key: Number Pad 6",    //81
+    "Key: F7",              //84
+    "Key: 7",               //85
+    "Key: U",               //86
+    "Key: J",               //87
+    "Key: N",               //88
+    "Key: Right Alt",       //89
+    "Key: ]",               //90
+    "Key: Right Control",   //91
+    "Key: Number Pad /",    //92
+    "Key: Number Pad 1",    //93
+    "Key: F8",              //96
+    "Key: 8",               //97
+    "Key: I",               //98
+    "Key: K",               //99
+    "Key: M",               //100
+    "Key: Right Windows",   //101
+    "Key: \\ (ANSI)",       //102
+    "Key: Up Arrow",        //103
+    "Key: Number Pad *",    //104
+    "Key: Number Pad 2",    //105
+    "Key: F9",              //108
+    "Key: 9",               //109
+    "Key: O",               //110
+    "Key: L",               //111
+    "Key: ,",               //112
+    "Key: Menu",            //113
+    //"Key: \\ (ISO)",        //114
+    "Key: Left Arrow",      //115
+    "Key: Number Pad -",    //116
+    "Key: Number Pad 3",    //117
+    "Key: F10",             //120
+    "Key: 0",               //121
+    "Key: P",               //122
+    "Key: ;",               //123
+    //"Key: Profile",         //125
+    "Key: .",               //124
+    "Key: Enter",           //126
+    "Key: Down Arrow",      //127
+    "Key: Number Pad +",    //128
+    "Key: Number Pad 0",    //129
+    "Key: F11",             //132
+    "Key: -",               //133
+    "Key: [",               //134
+    "Key: '",               //135
+    "Key: /",               //136
+    "Key: Brightness",      //137
+    "Key: Right Arrow",     //139
+    "Key: Number Pad Enter",//140
+    "Key: Number Pad .",    //141
+    "Key: / (ISO)",         //16
+    "Key: \\ (ISO)",        //114
+    "Key: Logo Left",       //047
+    "Key: Logo Right",      //059
+    "Key: Profile",         //125
+};
+
 static const char* led_names_k95_plat[] =
 {
     "Key: Escape",          //0
@@ -735,6 +887,26 @@ void RGBController_CorsairPeripheral::SetupZones()
                     new_zone.leds_count             = zone_sizes_k55[zone_idx];
                     new_zone.matrix_map             = NULL;
                 }
+                else if (logical_layout == CORSAIR_TYPE_K70_MK2)
+                {
+                    new_zone.name                   = zone_names_k70_mk2[zone_idx];
+                    new_zone.type                   = zone_types_k70_mk2[zone_idx];
+                    new_zone.leds_min               = zone_sizes_k70_mk2[zone_idx];
+                    new_zone.leds_max               = zone_sizes_k70_mk2[zone_idx];
+                    new_zone.leds_count             = zone_sizes_k70_mk2[zone_idx];
+
+                    if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
+                    {
+                        new_zone.matrix_map         = new matrix_map_type;
+                        new_zone.matrix_map->height = 7;
+                        new_zone.matrix_map->width  = 23;
+                        new_zone.matrix_map->map    = (unsigned int *)&matrix_map_k70_mk2;
+                    }
+                    else
+                    {
+                        new_zone.matrix_map         = NULL;
+                    }
+                }
                 else //default layout
                 {
                     new_zone.name                   = zone_names[zone_idx];
@@ -822,6 +994,10 @@ void RGBController_CorsairPeripheral::SetupZones()
                 {
                     new_led.name = led_names_k55[led_idx];
                 }
+                else if(logical_layout == CORSAIR_TYPE_K70_MK2)
+                {
+                    new_led.name = led_names_k70_mk2[led_idx];
+                }
                 else
                 {
                     new_led.name = led_names[led_idx];

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/GigabyteRGBFusion2USBController/GigabyteRGBFusion2USBController.cpp

@@ -362,42 +362,32 @@ void RGBFusion2USBController::SetLEDEffect(unsigned int led, int mode, unsigned
     pkt.e.effect_type   = mode;
     pkt.e.color0        = r << 16 | g << 8 | b;
 
-    if(speed < speeds.size())
-    {
-        const std::array<int, 3>& s = speeds[speed];
-
-        pkt.e.period0 = s[0];
-        pkt.e.period1 = s[1];
-        pkt.e.period2 = s[2];
-    }
-
     pkt.e.max_brightness = brightness;
 
     switch(mode)
     {
-        case 0:
+        case 0: // Direct
+        case 1: // Static
             break;
 
-        // Static
-        case 1:
-            break;
+        case 2: //Breathing
+        case 3: //Blink
+        case 4: // Color Cycle
+            if(speed < speeds.size())
+            {
+                const std::array<int, 3>& s = speeds[speed];
 
-        // Breathing
-        case 2:
+                pkt.e.period0 = s[0];
+                pkt.e.period1 = s[1];
+                pkt.e.period2 = s[2];
+            }
 
-        // Blink
-        case 3:
             if(random)
             {
                 pkt.e.effect_param0 = 7; // cycle through up to 7 (max?) colors
             }
             break;
 
-        // Color Cycle
-        case 4:
-            pkt.e.effect_param0 = 7; // cycle through up to 7 (max?) colors
-            break;
-
         // "Fake" effects
         case 10: // flashing, flashing color cycle
             pkt.e.period0       = 200;

Controllers/GigabyteRGBFusion2USBController/GigabyteRGBFusion2USBController.h

@@ -175,7 +175,7 @@ union PktEffect
         e.max_brightness    = 100;
         e.min_brightness    = 0;
         e.color0            = 0x00FF2100;   //orange
-        e.period0           = 1200;
+        e.period0           = 0;            //Rising Timer - Needs to be 0 for "Direct"
         e.period1           = 1200;
         e.period2           = 200;
         e.period3           = 200;

Controllers/GigabyteRGBFusion2USBController/RGBController_GigabyteRGBFusion2USB.cpp

@@ -533,8 +533,8 @@ void RGBController_RGBFusion2USB::UpdateZoneLEDs(int zone)
     /*---------------------------------------------------------*\
     | Get mode parameters                                       |
     \*---------------------------------------------------------*/
-    bool    random      = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
     int     mode_value  = (modes[active_mode].value);
+    bool    random      = (modes[active_mode].color_mode == MODE_COLORS_RANDOM || mode_value == EFFECT_COLORCYCLE);
 
     /*---------------------------------------------------------*\
     | Set motherboard LEDs                                      |

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,16 +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"                },
 };
 
@@ -95,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;
         }
 
@@ -102,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)
     {