OpenRGB version 0.7

Wording adjusted by Adam Honse <[email protected]>

.gitlab-ci.yml

@@ -32,7 +32,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 32 AppImage":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
   stage: build
   script:
   - export $(dpkg-architecture)
@@ -51,7 +51,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 64 AppImage":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
   stage: build
   script:
   - export $(dpkg-architecture)
@@ -66,9 +66,9 @@ before_script:
     expire_in: 30 days
 
 #-----------------------------------------------------------------------#
-# Linux (.deb) 32-bit Build Target                                      #
+# Linux (.deb) Debian Buster (Legacy) 32-bit Build Target               #
 #-----------------------------------------------------------------------#
-"Linux 32 deb":
+"Linux 32 .deb (Debian Buster)":
   <<: *ccache_init
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
   stage: build
@@ -87,9 +87,9 @@ before_script:
     expire_in: 30 days
 
 #-----------------------------------------------------------------------#
-# Linux (.deb) 64-bit Build Target                                      #
+# Linux (.deb) Debian Buster (Legacy) 64-bit Build Target               #
 #-----------------------------------------------------------------------#
-"Linux 64 deb":
+"Linux 64 .deb (Debian Buster)":
   <<: *ccache_init
   image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
   stage: build
@@ -107,6 +107,48 @@ before_script:
     - openrgb-dbgsym*.deb
     expire_in: 30 days
 
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Bullseye 32-bit Build Target                      #
+#-----------------------------------------------------------------------#
+"Linux 32 .deb (Debian Bullseye)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
+  stage: build
+  script:
+  - dpkg-architecture -l
+  - dpkg-buildpackage --target-arch i386 -us -B
+  - rm -v ../openrgb-dbgsym*.deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.deb
+    expire_in: 30 days
+    
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Bullseye 64-bit Build Target                      #
+#-----------------------------------------------------------------------#
+"Linux 64 .deb (Debian Bullseye)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
+  stage: build
+  script:
+  - dpkg-architecture -l
+  - dpkg-buildpackage -us -B
+  - rm -v ../openrgb-dbgsym*.deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.deb
+    expire_in: 30 days
+
 #-----------------------------------------------------------------------#
 # Linux (.rpm) 64-bit Build Target                                      #
 #-----------------------------------------------------------------------#
@@ -133,52 +175,6 @@ before_script:
     paths:
     - openrgb*.rpm
     expire_in: 30 days
-  
-#-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bullseye 32-bit Build Target                      #
-#-----------------------------------------------------------------------#
-"Linux 32 deb Bullseye":
-  <<: *ccache_init
-  image: i386/debian:bullseye
-  stage: build
-  script:
-  - apt update
-  - apt install -y build-essential qtcreator qtbase5-dev libusb-1.0-0-dev libhidapi-dev libmbedtls-dev pkgconf wget git file debhelper
-  - dpkg-architecture -l
-  - dpkg-buildpackage --target-arch i386 -us -B
-  - rm -v ../openrgb-dbgsym*.deb
-  - mv -v ../openrgb*.deb ./
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.deb
-    expire_in: 30 days
-
-#-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bullseye 64-bit Build Target                      #
-#-----------------------------------------------------------------------#
-"Linux 64 deb Bullseye":
-  <<: *ccache_init
-  image: debian:bullseye
-  stage: build
-  script:
-  - apt update
-  - apt install -y build-essential qtcreator qtbase5-dev libusb-1.0-0-dev libhidapi-dev libmbedtls-dev pkgconf wget git file debhelper
-  - dpkg-architecture -l
-  - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.deb
-  - mv -v ../openrgb*.deb ./
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.deb
-    expire_in: 30 days
 
 #-----------------------------------------------------------------------#
 # Debian 32 Buster test                                                 #
@@ -193,9 +189,26 @@ before_script:
   - openrgb -l
   - apt remove -y openrgb
   dependencies:
-  - "Linux 32 deb"
+  - "Linux 32 .deb (Debian Buster)"
   needs:
-  - "Linux 32 deb"
+  - "Linux 32 .deb (Debian Buster)"
+
+#-----------------------------------------------------------------------#
+# Debian 64 Buster test                                                 #
+#-----------------------------------------------------------------------#
+"Debian 64 Buster":
+  image: amd64/debian:buster
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
+  - openrgb --version
+  - openrgb -l
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 64 .deb (Debian Buster)"
+  needs:
+  - "Linux 64 .deb (Debian Buster)"
 
 #-----------------------------------------------------------------------#
 # Debian 32 Bullseye test                                               #
@@ -210,66 +223,15 @@ before_script:
   - openrgb -l
   - apt remove -y openrgb
   dependencies:
-  - "Linux 32 deb"
+  - "Linux 32 .deb (Debian Bullseye)"
   needs:
-  - "Linux 32 deb"
-
-# #-----------------------------------------------------------------------#
-# # Ubuntu 32 18.04LTS test                                               #
-# #-----------------------------------------------------------------------#
-# "Ubuntu 32 18.04LTS":
-#   image: i386/ubuntu:bionic
-#   stage: test
-#   script:
-#   - apt update
-#   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
-#   - openrgb --version
-#   - openrgb -l
-#   - apt remove -y openrgb
-#   dependencies:
-#   - "Linux 32 deb"
-#   needs:
-#   - "Linux 32 deb"
-
-# #-----------------------------------------------------------------------#
-# # Mint 32 19.3 test                                                     #
-# #-----------------------------------------------------------------------#
-# "Mint 32 20.1":
-#   image: linuxmintd/mint19.3-i386
-#   stage: test
-#   script:
-#   - apt update
-#   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
-#   - openrgb --version
-#   - openrgb -l
-#   - apt remove -y openrgb
-#   dependencies:
-#   - "Linux 32 deb"
-#   needs:
-#   - "Linux 32 deb"
-
-#-----------------------------------------------------------------------#
-# Debian 64 Buster test                                                 #
-#-----------------------------------------------------------------------#
-"Debian 64 Buster":
-  image: debian:buster
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-  - openrgb --version
-  - openrgb -l
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 64 deb"
-  needs:
-  - "Linux 64 deb"
+  - "Linux 32 .deb (Debian Bullseye)"
 
 #-----------------------------------------------------------------------#
 # Debian 64 Bullseye test                                               #
 #-----------------------------------------------------------------------#
 "Debian 64 Bullseye":
-  image: debian:bullseye
+  image: amd64/debian:bullseye
   stage: test
   script:
   - apt update
@@ -278,9 +240,43 @@ before_script:
   - openrgb -l
   - apt remove -y openrgb
   dependencies:
-  - "Linux 64 deb"
+  - "Linux 64 .deb (Debian Bullseye)"
   needs:
-  - "Linux 64 deb"
+  - "Linux 64 .deb (Debian Bullseye)"
+
+#-----------------------------------------------------------------------#
+# Ubuntu 64 20.04LTS test                                               #
+#-----------------------------------------------------------------------#
+"Ubuntu 64 20.04LTS":
+  image: ubuntu:focal
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
+  - openrgb --version
+  - openrgb -l
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 64 .deb (Debian Buster)"
+  needs:
+  - "Linux 64 .deb (Debian Buster)"
+
+#-----------------------------------------------------------------------#
+# Ubuntu 64 21.10 test                                                  #
+#-----------------------------------------------------------------------#
+"Ubuntu 64 21.10":
+  image: ubuntu:impish
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
+  - openrgb --version
+  - openrgb -l
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 64 .deb (Debian Bullseye)"
+  needs:
+  - "Linux 64 .deb (Debian Bullseye)"
 
 #-----------------------------------------------------------------------#
 # Fedora 64 v34 test                                                    #
@@ -298,74 +294,6 @@ before_script:
   needs:
   - "Linux 64 rpm"
 
-# #-----------------------------------------------------------------------#
-# # Ubuntu 64 18.04LTS test                                               #
-# #-----------------------------------------------------------------------#
-# "Ubuntu 64 18.04LTS":
-#   image: ubuntu:bionic
-#   stage: test
-#   script:
-#   - apt update
-#   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-#   - openrgb --version
-#   - openrgb -l
-#   - apt remove -y openrgb
-#   dependencies:
-#   - "Linux 64 deb"
-#   needs:
-#   - "Linux 64 deb"
-
-#-----------------------------------------------------------------------#
-# Ubuntu 64 20.04LTS test                                               #
-#-----------------------------------------------------------------------#
-"Ubuntu 64 20.04LTS":
-  image: ubuntu:focal
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-  - openrgb --version
-  - openrgb -l
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 64 deb"
-  needs:
-  - "Linux 64 deb"
-
-#-----------------------------------------------------------------------#
-# Ubuntu 64 20.10 test                                                  #
-#-----------------------------------------------------------------------#
-"Ubuntu 64 20.10":
-  image: ubuntu:groovy
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-  - openrgb --version
-  - openrgb -l
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 64 deb"
-  needs:
-  - "Linux 64 deb"
-
-#-----------------------------------------------------------------------#
-# Mint 64 20.1 test                                                     #
-#-----------------------------------------------------------------------#
-"Mint 64 20.1":
-  image: linuxmintd/mint20.1-amd64
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-  - openrgb --version
-  - openrgb -l
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 64 deb"
-  needs:
-  - "Linux 64 deb"
-
 #-----------------------------------------------------------------------#
 # Windows (32-bit) Build Target                                         #
 #-----------------------------------------------------------------------#

.gitmodules

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

60-openrgb.rules

@@ -35,8 +35,8 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1044", ATTR{idProduct}=="7a42", TAG+="uacces
 #   ASRock Polychrome USB                                       #
 #   ASRock Deskmini Addressable LED Strip                       #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="26CE", ATTR{idProduct}=="01A2", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="26CE", ATTR{idProduct}=="01A6", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="26ce", ATTR{idProduct}=="01a2", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="26ce", ATTR{idProduct}=="01a6", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  ASUS Aura Core Devices                                       #
@@ -57,30 +57,30 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a5", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1939", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18af", TAG+="uaccess"
 
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="193c", TAG+="uaccess"          #ROG Falchion Wired
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="193e", TAG+="uaccess"          #ROG Falchion Wireless
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1875", TAG+="uaccess"          #ROG Strix Flare
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cf", TAG+="uaccess"          #ROG Strix Flare Pink
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18f8", TAG+="uaccess"          #ROG Strix Scope
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1951", TAG+="uaccess"          #ROG Strix Scope RX
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="190c", TAG+="uaccess"          #ROG Strix Scope TKL
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a0", TAG+="uaccess"          #TUF K7 Gaming
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="193c", TAG+="uaccess", TAG+="ROG_Falchion_Wired"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="193e", TAG+="uaccess", TAG+="ROG_Falchion_Wireless"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1875", TAG+="uaccess", TAG+="ROG_Strix_Flare"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cf", TAG+="uaccess", TAG+="ROG_Strix_Flare_Pink"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18f8", TAG+="uaccess", TAG+="ROG_Strix_Scope"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1951", TAG+="uaccess", TAG+="ROG_Strix_Scope_RX"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="190c", TAG+="uaccess", TAG+="ROG_Strix_Scope_TKL"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a0", TAG+="uaccess", TAG+="TUF_K7_Gaming"
 
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18dd", TAG+="uaccess"          #ROG Gladius II Core
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1845", TAG+="uaccess"          #ROG Gladius II
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1877", TAG+="uaccess"          #ROG Gladius II Origin
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cd", TAG+="uaccess"          #ROG Gladius II Origin Pink
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18b1", TAG+="uaccess"          #ROG Gladius II Origin COD
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="189e", TAG+="uaccess"          #ROG Gladius II Wireless1
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a0", TAG+="uaccess"          #ROG Gladius II Wireless2
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e5", TAG+="uaccess"          #ROG Chakram Wireless
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e3", TAG+="uaccess"          #ROG Chakram Wired1
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1958", TAG+="uaccess"          #ROG Chakram Wired2
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1846", TAG+="uaccess"          #ROG Pugio
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1906", TAG+="uaccess"          #ROG Pugio II Wired
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1908", TAG+="uaccess"          #ROG Pugio II Wireless
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e1", TAG+="uaccess"          #ROG Strix Impact II
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1910", TAG+="uaccess"          #TUF M3 & M7
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18dd", TAG+="uaccess", TAG+="ROG_Gladius_II_Core"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1845", TAG+="uaccess", TAG+="ROG_Gladius_II"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1877", TAG+="uaccess", TAG+="ROG_Gladius_II_Origin"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cd", TAG+="uaccess", TAG+="ROG_Gladius_II_Origin_Pink"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18b1", TAG+="uaccess", TAG+="ROG_Gladius_II_Origin_COD"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="189e", TAG+="uaccess", TAG+="ROG_Gladius_II_Wireless1"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a0", TAG+="uaccess", TAG+="ROG_Gladius_II_Wireless2"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e5", TAG+="uaccess", TAG+="ROG_Chakram_Wireless"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e3", TAG+="uaccess", TAG+="ROG_Chakram_Wired1"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1958", TAG+="uaccess", TAG+="ROG_Chakram_Wired2"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1846", TAG+="uaccess", TAG+="ROG_Pugio"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1906", TAG+="uaccess", TAG+="ROG_Pugio_II_Wired"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1908", TAG+="uaccess", TAG+="ROG_Pugio_II_Wireless"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e1", TAG+="uaccess", TAG+="ROG_Strix_Impact_II"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1910", TAG+="uaccess", TAG+="TUF_M3_&_M7"
 
 #---------------------------------------------------------------#
 #  ASUS TUF Laptops (faustus)                                   #
@@ -98,6 +98,7 @@ ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /s
 #                                                               #
 #  Mice:                                                        #
 #       Cooler Master MM711                                     #
+#       Cooler Master MM720                                     #
 #  Mousemats:                                                   #
 #       Cooler Master MP750                                     #
 #  Controllers:                                                 #
@@ -113,19 +114,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"          #MP750 XL
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0105", TAG+="uaccess"          #MP750 M
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="1011", TAG+="uaccess"          #ARGB
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="1000", TAG+="uaccess"          #Small ARGB
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="004f", TAG+="uaccess"          #RGB
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="014d", TAG+="uaccess"          #Radeon 6000
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="003b", TAG+="uaccess"          #Masterkeys Pro L
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0047", TAG+="uaccess"          #Masterkeys Pro L White
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="003c", TAG+="uaccess"          #Masterkeys Pro S
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0067", TAG+="uaccess"          #Masterkeys MK750
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0089", TAG+="uaccess"          #Masterkeys SK630
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="008d", TAG+="uaccess"          #Masterkeys SK650
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0101", TAG+="uaccess", TAG+="MM711"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0141", TAG+="uaccess", TAG+="MM720"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0109", TAG+="uaccess", TAG+="MP750_XL"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0107", TAG+="uaccess", TAG+="MP750_L"
+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"
 
 
 #---------------------------------------------------------------#
@@ -233,6 +236,8 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b34", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b74", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b3c", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b75", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b5d", TAG+="uaccess", TAG+="Ironclaw"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b12", TAG+="uaccess", TAG+="M65"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b2e", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b5a", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b3e", TAG+="uaccess"
@@ -349,6 +354,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0cf2", ATTR{idProduct}=="7750", TAG+="uacces
 #       Logitech G813                                           #
 #       Logitech G815                                           #
 #       Logitech G915                                           #
+#       Logitech G Pro                                          #
 #                                                               #
 #  Mice:                                                        #
 #       Logitech G203 Prodigy                                   #
@@ -360,6 +366,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             #
@@ -379,18 +386,19 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0cf2", ATTR{idProduct}=="7750", TAG+="uacces
 #       Logitech Rhino X56 Hotas (Throttle and Stick)           #
 #                                                               #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c336", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c342", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c333", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c338", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c331", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c337", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c232", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33f", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c335", TAG+="uaccess"          #G910
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c541", TAG+="uaccess"          #G915 Receiver
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33e", TAG+="uaccess"          #G915 Wired
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c336", TAG+="uaccess", TAG+="G213"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c342", TAG+="uaccess", TAG+="G512"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33c", TAG+="uaccess", TAG+="G512_RGB"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c333", TAG+="uaccess", TAG+="G610"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c338", TAG+="uaccess", TAG+="G610"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c331", TAG+="uaccess", TAG+="G810"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c337", TAG+="uaccess", TAG+="G810"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c339", TAG+="uaccess", TAG+="G_Pro"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c232", TAG+="uaccess", TAG+="G813"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33f", TAG+="uaccess", TAG+="G815"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c335", TAG+="uaccess", TAG+="G910"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c541", TAG+="uaccess", TAG+="G915_Receiver"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33e", TAG+="uaccess", TAG+="G915_Wired"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c084", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c092", TAG+="uaccess"
@@ -402,28 +410,32 @@ 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}=="c081", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4053", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c086", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4067", TAG+="uaccess"
+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", TAG+="G900_wired"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4053", TAG+="uaccess", TAG+="G900_wireless"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c086", TAG+="uaccess", TAG+="G903_wired"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c091", TAG+="uaccess", TAG+="G903_V2_wired"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4067", TAG+="uaccess", TAG+="G903_wireless"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4087", TAG+="uaccess", TAG+="G903_V2_wireless"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c539", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c085", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08c", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c088", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4079", TAG+="uaccess"
 
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uaccess"          #Powerplay Mat Reciever
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="405F", TAG+="uaccess"          #Powerplay Mat Virtual PID
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uaccess", TAG+="Powerplay_Mat_Reciever"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="405f", TAG+="uaccess", TAG+="Powerplay_Mat_Virtual"
 
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a78", TAG+="uaccess"          #G560
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a78", TAG+="uaccess", TAG+="G560"
 
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a5b", TAG+="uaccess"          #G933
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0ab5", TAG+="uaccess"          #G733
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a5b", TAG+="uaccess", TAG+="G933"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0ab5", TAG+="uaccess", TAG+="G733"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0738", ATTR{idProduct}=="2221", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0738", ATTR{idProduct}=="A221", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0738", ATTR{idProduct}=="a221", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  Metadot Das Keyboard 4Q + 5Q                                 #
@@ -434,62 +446,64 @@ 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}=="1720", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7b10", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7b12", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7b17", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7b85", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7b93", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7b94", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7b96", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c34", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c35", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c36", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c37", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c42", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c56", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c59", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c60", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c67", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c70", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c71", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c73", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c75", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c76", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c77", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c79", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c80", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c81", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c82", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c83", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c84", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c85", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c86", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c87", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c88", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c89", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c90", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c91", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c92", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c94", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c95", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c96", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c98", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7c99", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7d06", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7d07", TAG+="uaccess", TAG+="MPG_Z590_GAMING_EDGE_WIFI"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7d09", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="905d", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  MSI/SteelSeries 3-Zone Laptop Keyboard                       #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1770", ATTR{idProduct}=="FF00", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1770", ATTR{idProduct}=="ff00", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  NZXT Hue+                                                    #
 #---------------------------------------------------------------#
-KERNEL=="ttyACM[0-9]*", ATTR{idVendor}=="04D8", ATTR{idProduct}=="00DF", TAG+="uaccess"
+KERNEL=="ttyACM[0-9]*", ATTR{idVendor}=="04d8", ATTR{idProduct}=="00df", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  NZXT Hue 2 Devices                                           #
@@ -507,7 +521,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2005", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2006", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2007", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2009", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="200D", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="200d", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  NZXT Kraken                                                  #
@@ -518,148 +532,159 @@ 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}=="0258", TAG+="uaccess", TAG+="Blackwidow_V3_Mini-Wired"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0271", TAG+="uaccess", TAG+="Blackwidow_V3_Mini-Wireless"
+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}=="026B", TAG+="uaccess", TAG+="Huntsman_V2_TKL"
 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}=="0266", TAG+="uaccess", TAG+="Huntsman V2 Analog"
+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"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0067", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0050", TAG+="uaccess", TAG+="Naga_Hex_V2"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="008d", TAG+="uaccess", TAG+="Naga_Left_Handed"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0067", TAG+="uaccess", TAG+="Naga_Trinity"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0013", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0039", TAG+="uaccess"
 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                                               #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e7d", ATTR{idProduct}=="2e2c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1e7d", ATTR{idProduct}=="2e27", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1e7d", ATTR{idProduct}=="2e27", TAG+="uaccess", TAG+="Roccat_Kone_Aimo"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1e7d", ATTR{idProduct}=="2e2c", TAG+="uaccess", TAG+="Roccat_Kone_Aimo_16K"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1e7d", ATTR{idProduct}=="3098", TAG+="uaccess", TAG+="Roccat_Vulcan_120_Aimo"
 
 #---------------------------------------------------------------#
 #  Redragon Peripheral Devices                                  #
@@ -735,6 +760,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="0ba0", TAG+="uacces
 #  Headsets:                                                    #
 #       SteelSeries Siberia 350                                 #
 #  Keyboards:                                                   #
+#       SteelSeries Apex 3                                      #
 #       SteelSeries Apex 5                                      #
 #       SteelSeries Apex 7                                      #
 #       SteelSeries Apex 7 TKL                                  #
@@ -744,7 +770,10 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="0ba0", TAG+="uacces
 #       SteelSeries Apex OG                                     #
 #       SteelSeries Apex 350                                    #
 #  Mousemats:                                                   #
-#       SteelSeries QCK Prism Cloth                             #
+#       SteelSeries QCK Prism Cloth Medium                      #
+#       SteelSeries QCK Prism Cloth XL                          #
+#       SteelSeries QCK Prism Cloth 3XL                         #
+#       SteelSeries QCK Prism Cloth 4XL                         #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1702", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="170c", TAG+="uaccess"
@@ -764,9 +793,9 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1832", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1834", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1722", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1726", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="172B", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1824", TAG+="uaccess"          #Rival3_Old
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="184c", TAG+="uaccess"          #Rival3
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="172b", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1824", TAG+="uaccess", TAG+="Rival3_Old"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="184c", TAG+="uaccess", TAG+="Rival3"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1229", TAG+="uaccess"
 
@@ -775,12 +804,15 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1612", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1618", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1610", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1614", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="161a", TAG+="uaccess", TAG+="Apex3"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="0616", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1202", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1206", TAG+="uaccess"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="150a", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="150d", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1516", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1518", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  Tecknet Devices                                              #
@@ -795,18 +827,23 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="3006", TAG+="uacces
 #---------------------------------------------------------------#
 #  Thermaltake Riing Controllers                                #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FA[5-9]", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FA[A-F]", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FB[0-5]", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1fa[5-9]", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1fa[a-f]", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1fb[0-5]", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="226[0-3]", TAG+="uaccess"
 
+#---------------------------------------------------------------#
+#  ThingM Controllers                                           #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="27b8", ATTR{idProduct}=="01ed", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  Wooting Devices                                              #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff01", TAG+="uaccess"          #WootingOne
-SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff02", TAG+="uaccess"          #WootingTwo
-SUBSYSTEMS=="usb", ATTR{idVendor}=="31e3", ATTR{idProduct}=="1210", TAG+="uaccess"          #WootingTwo LE
-SUBSYSTEMS=="usb", ATTR{idVendor}=="31e3", ATTR{idProduct}=="1220", TAG+="uaccess"          #WootingTwo HE
+SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff01", TAG+="uaccess", TAG+="WootingOne"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff02", TAG+="uaccess", TAG+="WootingTwo"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="31e3", ATTR{idProduct}=="1210", TAG+="uaccess", TAG+="WootingTwo_LE"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="31e3", ATTR{idProduct}=="1220", TAG+="uaccess", TAG+="WootingTwo_HE"
 
 #---------------------------------------------------------------#
 #  Zalman ZSync Devices                                         #

AutoStart/AutoStart-Windows.cpp

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

Colors.h

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

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp

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

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h

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

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusControllerDetect.cpp

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

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -8,6 +8,7 @@
 
 #include "Detector.h"
 #include "AsusAuraGPUController.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraGPU.h"
 #include "i2c_smbus.h"
@@ -28,37 +29,48 @@ typedef struct
     const char *    name;
 } gpu_pci_device;
 
+#define ASUSGPU_CONTROLLER_NAME "ASUS Aura GPU"
 #define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
 
 static const gpu_pci_device device_list[] =
 {
-    { NVIDIA_VEN,       NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,       ASUS_GTX1050_STRIX_O2G_GAMING,          0x29,   "ASUS ROG Strix GTX 1050 O2G Gaming"        },
-    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX_6G_GAMING,           0x29,   "ASUS GTX 1060 Strix 6G Gaming"             },
-    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX,                     0x29,   "ASUS GTX 1060 Strix"                       },
-    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_GAMING,              0x29,   "ASUS GTX 1070 Strix Gaming"                },
-    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_OC,                  0x29,   "ASUS GTX 1070 Strix OC"                    },
-    { NVIDIA_VEN,       NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,    0x29,   "ASUS ROG Strix GTX1070 Ti A8G Gaming"      },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_GTX1080_STRIX,                     0x29,   "ASUS GTX 1080 Strix OC"                    },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_A8G_GAMING,      0x29,   "ASUS ROG Strix GTX1080 A8G Gaming"         },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_O8G_GAMING,      0x29,   "ASUS ROG Strix GTX1080 O8G Gaming"         },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_GAMING,        0x29,   "ASUS ROG Strix GTX1080 Ti Gaming"          },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,    0x29,   "ASUS ROG Strix GTX1080 Ti 11G Gaming"      },
-    { NVIDIA_VEN,       NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1650S_OC,             0x2A,   "ASUS ROG Strix GTX 1650S OC 4G"            },
-    { NVIDIA_VEN,       NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_GTX1660TI_OC,                  0x2A,   "ASUS ROG GTX 1660 Ti OC 6G"                },
-    { NVIDIA_VEN,       NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_EVO_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING, 0x2A,   "ASUS ROG STRIX RTX 2060S A8G EVO Gaming 8G"},
-    { NVIDIA_VEN,       NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2060S O8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_A8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2070 A8G Gaming 8G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_O8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2070 O8G Gaming 8G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2070S O8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080_O8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2080 O8G Gaming"        },
-    { NVIDIA_VEN,       NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,   0x2A,   "ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    },
-    { AMD_GPU_VEN,      AMD_VEGA10_DEV,             ASUS_SUB_VEN,       ASUS_VEGA64_STRIX,                      0x29,   "ASUS Vega 64 Strix"                        },
-    { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5700XT_STRIX_GAMING_OC,          0x2A,   "ASUS RX 5700XT Strix Gaming OC"            },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX480_STRIX_GAMING_OC,             0x29,   "ASUS ROG STRIX RX480 Gaming OC"            },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX570_STRIX_O4G_GAMING_OC,         0x29,   "ASUS RX 570 Strix O4G Gaming OC"           },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_OC,             0x29,   "ASUS RX 580 Strix Gaming OC"               }
+    { NVIDIA_VEN,       NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,       ASUS_GTX1050_STRIX_O2G_GAMING,              0x29,   "ASUS ROG Strix GTX 1050 O2G Gaming"        },
+    { NVIDIA_VEN,       NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29,   "ASUS ROG Strix GTX 1050 TI O4G Gaming"     },
+    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX_6G_GAMING,               0x29,   "ASUS GTX 1060 Strix 6G Gaming"             },
+    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX,                         0x29,   "ASUS GTX 1060 Strix"                       },
+    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_GAMING,                  0x29,   "ASUS GTX 1070 Strix Gaming"                },
+    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_OC,                      0x29,   "ASUS GTX 1070 Strix OC"                    },
+    { NVIDIA_VEN,       NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1070TI_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_86FF,    0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
+    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         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_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A,   "ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     },
+    { NVIDIA_VEN,       NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A,   "ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    },
+    { 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"              },
 };  
 
 /******************************************************************************************\
@@ -76,6 +88,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;
@@ -107,6 +121,7 @@ void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses)
                busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
                busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
             {
+                LOG_DEBUG(GPU_DETECT_MESSAGE, ASUSGPU_CONTROLLER_NAME, bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name );
                 if (TestForAsusAuraGPUController(busses[bus], device_list[dev_idx].controller_address))
                 {
                     new_aura_gpu         = new AuraGPUController(busses[bus], device_list[dev_idx].controller_address);
@@ -119,4 +134,4 @@ void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses)
     }
 } /* DetectAsusAuraGPUControllers() */
 
-REGISTER_I2C_DETECTOR("ASUS Aura GPU", DetectAsusAuraGPUControllers);
+REGISTER_I2C_DETECTOR(ASUSGPU_CONTROLLER_NAME, DetectAsusAuraGPUControllers);

Controllers/AsusAuraSMBusController/AsusAuraSMBusController.cpp

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

Controllers/AsusAuraSMBusController/AsusAuraSMBusController.h

@@ -1,113 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraSMBusController.h                |
-|                                           |
-|  Definitions and types for ASUS Aura RGB  |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 8/19/2018   |
-\*-----------------------------------------*/
-
-#include <string>
-#include "i2c_smbus.h"
-
-#pragma once
-
-typedef unsigned char	aura_dev_id;
-typedef unsigned short	aura_register;
-
-#define AURA_APPLY_VAL  0x01                /* Value for Apply Changes Register     */
-
-enum
-{
-    AURA_REG_DEVICE_NAME                = 0x1000,   /* Device String 16 bytes               */
-    AURA_REG_CONFIG_TABLE               = 0x1C00,   /* Start of LED configuration bytes     */
-    AURA_REG_COLORS_DIRECT              = 0x8000,   /* Colors for Direct Mode 15 bytes      */
-    AURA_REG_COLORS_EFFECT              = 0x8010,   /* Colors for Internal Effects 15 bytes */
-    AURA_REG_DIRECT                     = 0x8020,   /* "Direct Access" Selection Register   */
-    AURA_REG_MODE                       = 0x8021,   /* AURA Mode Selection Register         */
-    AURA_REG_APPLY                      = 0x80A0,   /* AURA Apply Changes Register          */
-    AURA_REG_SLOT_INDEX                 = 0x80F8,   /* AURA Slot Index Register (RAM only)  */
-    AURA_REG_I2C_ADDRESS                = 0x80F9,   /* AURA I2C Address Register (RAM only) */
-    AURA_REG_COLORS_DIRECT_V2           = 0x8100,   /* Direct Colors (v2) 30 bytes          */
-    AURA_REG_COLORS_EFFECT_V2           = 0x8160,   /* Internal Colors (v2) 30 bytes        */
-};
-
-enum
-{
-    AURA_MODE_OFF                       = 0,        /* OFF mode                             */
-    AURA_MODE_STATIC                    = 1,        /* Static color mode                    */
-    AURA_MODE_BREATHING                 = 2,        /* Breathing effect mode                */
-    AURA_MODE_FLASHING                  = 3,        /* Flashing effect mode                 */
-    AURA_MODE_SPECTRUM_CYCLE            = 4,        /* Spectrum Cycle mode                  */
-    AURA_MODE_RAINBOW                   = 5,        /* Rainbow effect mode                  */
-    AURA_MODE_SPECTRUM_CYCLE_BREATHING  = 6,        /* Rainbow Breathing effect mode        */
-    AURA_MODE_CHASE_FADE                = 7,        /* Chase with Fade effect mode          */
-    AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE = 8,        /* Chase with Fade, Rainbow effect mode */
-    AURA_MODE_CHASE                     = 9,        /* Chase effect mode                    */
-    AURA_MODE_SPECTRUM_CYCLE_CHASE      = 10,       /* Chase with Rainbow effect mode       */
-    AURA_MODE_SPECTRUM_CYCLE_WAVE       = 11,       /* Wave effect mode                     */
-    AURA_MODE_CHASE_RAINBOW_PULSE       = 12,       /* Chase with  Rainbow Pulse effect mode*/
-    AURA_MODE_RANDOM_FLICKER            = 13,       /* Random flicker effect mode           */
-    AURA_NUMBER_MODES                               /* Number of Aura modes                 */
-};
-
-enum
-{
-    AURA_LED_CHANNEL_DRAM_2             = 0x05,     /* DRAM LED channel                     */
-    AURA_LED_CHANNEL_CENTER_START       = 0x82,     /* Center zone first LED channel        */
-    AURA_LED_CHANNEL_CENTER             = 0x83,     /* Center zone LED channel              */
-    AURA_LED_CHANNEL_AUDIO              = 0x84,     /* Audio zone LED channel               */
-    AURA_LED_CHANNEL_BACK_IO            = 0x85,     /* Back I/O zone LED channel            */
-    AURA_LED_CHANNEL_RGB_HEADER         = 0x86,     /* RGB Header LED channel               */
-    AURA_LED_CHANNEL_RGB_HEADER_2       = 0x87,     /* RGB Header 2 LED channel             */
-    AURA_LED_CHANNEL_BACKPLATE          = 0x88,     /* Backplate zone LED channel           */
-    AURA_LED_CHANNEL_DRAM               = 0x8A,     /* DRAM LED channel                     */
-    AURA_LED_CHANNEL_PCIE               = 0x8B,     /* PCIe zone LED channel                */
-    AURA_LED_CHANNEL_RGB_HEADER_3       = 0x91,     /* RGB Header 3 LED channel             */
-};
-
-enum
-{
-    AURA_CONFIG_LED_COUNT               = 0x02,     /* LED Count configuration offset       */
-    AURA_CONFIG_CHANNEL_V1              = 0x13,     /* LED Channel configuration offset     */
-    AURA_CONFIG_CHANNEL_V2              = 0x1B,     /* LED Channel V2 configuration offset  */
-};
-
-class AuraSMBusController
-{
-public:
-    AuraSMBusController(i2c_smbus_interface* bus, aura_dev_id dev);
-    ~AuraSMBusController();
-
-    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);
-    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);
-
-    void          AuraUpdateDeviceName();
-
-    unsigned char AuraRegisterRead(aura_register reg);
-    void          AuraRegisterWrite(aura_register reg, unsigned char val);
-    void          AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz);
-
-private:
-    char                    device_name[16];
-    unsigned char           config_table[64];
-    unsigned int            led_count;
-    aura_register           direct_reg;
-    aura_register           effect_reg;
-    unsigned char           channel_cfg;
-    i2c_smbus_interface *   bus;
-    aura_dev_id             dev;
-
-};

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/AsusAuraSMBusController/RGBController_AsusAuraSMBus.cpp

@@ -1,368 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraSMBus.cpp          |
-|                                           |
-|  Generic RGB Interface for OpenAuraSDK    |
-|  Asus Aura SMBus driver                   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/13/2019   |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraSMBus.h"
-
-int RGBController_AuraSMBus::GetDeviceMode()
-{
-    int  dev_mode  = aura->AuraRegisterRead(AURA_REG_MODE);
-    int color_mode = MODE_COLORS_PER_LED;
-
-    if (aura->AuraRegisterRead(AURA_REG_DIRECT))
-    {
-        dev_mode = 0xFFFF;
-    }
-
-    switch(dev_mode)
-    {
-    case AURA_MODE_OFF:
-    case AURA_MODE_RAINBOW:
-    case AURA_MODE_SPECTRUM_CYCLE:
-    case AURA_MODE_RANDOM_FLICKER:
-        color_mode = MODE_COLORS_NONE;
-        break;
-
-    case AURA_MODE_SPECTRUM_CYCLE_CHASE:
-        dev_mode   = AURA_MODE_CHASE;
-        color_mode = MODE_COLORS_RANDOM;
-        break;
-
-    case AURA_MODE_SPECTRUM_CYCLE_BREATHING:
-        dev_mode   = AURA_MODE_BREATHING;
-        color_mode = MODE_COLORS_RANDOM;
-        break;
-
-    case AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE:
-        dev_mode   = AURA_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;
-        }
-    }
-
-    return(active_mode);
-}
-
-void RGBController_AuraSMBus::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)
-        {
-            aura->SetLEDColorDirect(led, red, grn, blu);
-        }
-        else
-        {
-            aura->SetLEDColorEffect(led, red, grn, blu);
-        }
-    }
-}
-
-void RGBController_AuraSMBus::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)
-        {
-            aura->SetLEDColorDirect(led, red, grn, blu);
-        }
-        else
-        {
-            aura->SetLEDColorEffect(led, red, grn, blu);
-        }
-    }
-}
-
-void RGBController_AuraSMBus::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)
-    {
-        aura->SetLEDColorDirect(led, red, grn, blu);
-    }
-    else
-    {
-        aura->SetLEDColorEffect(led, red, grn, blu);
-    }
-}
-
-RGBController_AuraSMBus::RGBController_AuraSMBus(AuraSMBusController * aura_ptr)
-{
-    aura = aura_ptr;
-
-    version = aura->GetDeviceName();
-    location = aura->GetDeviceLocation();
-    if((version.find("DIMM_LED") != std::string::npos) || (version.find("AUDA") != std::string::npos) )
-    {
-        type = DEVICE_TYPE_DRAM;
-        name = "ASUS Aura DRAM";
-    }
-    else
-    {
-        type = DEVICE_TYPE_MOTHERBOARD;
-        name = "ASUS Aura Motherboard";
-    }
-    vendor      = "ASUS";
-    description = "ASUS Aura 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      = AURA_MODE_OFF;
-    Off.flags      = 0;
-    Off.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Static);
-    
-    mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = AURA_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Breathing);
-
-    mode Flashing;
-    Flashing.name       = "Flashing";
-    Flashing.value      = AURA_MODE_FLASHING;
-    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Flashing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Flashing);
-
-    mode SpectrumCycle;
-    SpectrumCycle.name       = "Spectrum Cycle";
-    SpectrumCycle.value      = AURA_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags      = 0;
-    SpectrumCycle.color_mode = MODE_COLORS_NONE;
-    modes.push_back(SpectrumCycle);
-
-    mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = AURA_MODE_RAINBOW;
-    Rainbow.flags      = 0;
-    Rainbow.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Rainbow);
-
-    mode ChaseFade;
-    ChaseFade.name       = "Chase Fade";
-    ChaseFade.value      = AURA_MODE_CHASE_FADE;
-    ChaseFade.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
-    ChaseFade.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(ChaseFade);
-
-    mode Chase;
-    Chase.name       = "Chase";
-    Chase.value      = AURA_MODE_CHASE;
-    Chase.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
-    Chase.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Chase);
-
-    mode RandomFlicker;
-    RandomFlicker.name       = "Random Flicker";
-    RandomFlicker.value      = AURA_MODE_RANDOM_FLICKER;
-    RandomFlicker.flags      = 0;
-    RandomFlicker.color_mode = MODE_COLORS_NONE;
-    modes.push_back(RandomFlicker);
-
-    SetupZones();
-
-    // Initialize active mode
-    active_mode = GetDeviceMode();
-}
-
-RGBController_AuraSMBus::~RGBController_AuraSMBus()
-{
-    delete aura;
-}
-
-void RGBController_AuraSMBus::SetupZones()
-{
-    std::vector<int>    aura_led_map;
-
-    /*---------------------------------------------------------*\
-    | Search through all LEDs and create zones for each channel |
-    | type                                                      |
-    \*---------------------------------------------------------*/
-    for (std::size_t led_idx = 0; led_idx < aura->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 (aura->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 = aura->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 < aura->GetLEDCount(); zone_led_idx++)
-            {
-                if (aura->GetChannelName(zone_led_idx) == new_zone->name)
-                {
-                    new_zone->leds_count++;
-                    aura_led_map.push_back(zone_led_idx);
-                }
-            }
-
-            /*---------------------------------------------------------*\
-            | Aura 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 = aura_led_map[led_idx];
-
-            leds.push_back(*new_led);
-        }
-    }
-
-    SetupColors();
-
-    /*---------------------------------------------------------*\
-    | 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 = aura->GetLEDRed(led);
-        unsigned char grn = aura->GetLEDGreen(led);
-        unsigned char blu = aura->GetLEDBlue(led);
-
-        colors[led_idx] = ToRGBColor(red, grn, blu);
-    }
-}
-
-void RGBController_AuraSMBus::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AuraSMBus::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AuraSMBus::DeviceUpdateMode()
-{
-    if (modes[active_mode].value == 0xFFFF)
-    {
-        aura->SetDirect(true);
-    }
-    else
-    {
-        int new_mode = modes[active_mode].value;
-
-        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
-        {
-            switch(new_mode)
-            {
-            case AURA_MODE_CHASE:
-                new_mode = AURA_MODE_SPECTRUM_CYCLE_CHASE;
-                break;
-            case AURA_MODE_BREATHING:
-                new_mode = AURA_MODE_SPECTRUM_CYCLE_BREATHING;
-                break;
-            case AURA_MODE_CHASE_FADE:
-                new_mode = AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE;
-                break;
-            }
-        }
-
-        aura->SetMode(new_mode);
-        aura->SetDirect(false);
-    }
-}

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[ASUS_AURA_MOUSE_PACKET_SIZE];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x12;
+    hid_write(dev, usb_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
+
+    unsigned char usb_buf_out[ASUS_AURA_MOUSE_PACKET_SIZE];
+    hid_read(dev, usb_buf_out, ASUS_AURA_MOUSE_PACKET_SIZE);
+
+    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,9 +103,18 @@ void AuraMouseController::SendUpdate
     unsigned char   blu,
     unsigned char   dir,
     bool            random,
-    unsigned char   speed
+    unsigned char   speed,
+    unsigned char   brightness
     )
 {
+    int bytes_read = 1;
+    unsigned char usb_buf_flush[ASUS_AURA_MOUSE_PACKET_SIZE];
+
+    while(bytes_read > 0)
+    {
+      bytes_read = hid_read_timeout(dev, usb_buf_flush, ASUS_AURA_MOUSE_PACKET_SIZE, 0);
+    }
+
     unsigned char usb_buf[ASUS_AURA_MOUSE_PACKET_SIZE];
 
     /*-----------------------------------------------------*\
@@ -79,10 +131,11 @@ 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;
+
     if (device_pid == AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID)
     {
         usb_buf[0x0A]   = 0;
@@ -103,4 +156,7 @@ void AuraMouseController::SendUpdate
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
+
+    unsigned char usb_buf_out[ASUS_AURA_MOUSE_PACKET_SIZE];
+    hid_read(dev, usb_buf_out, ASUS_AURA_MOUSE_PACKET_SIZE);
 }

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

@@ -20,13 +20,13 @@
 #define AURA_ROG_GLADIUS_II_WIRELESS_2_PID      0x18A0
 #define AURA_ROG_CHAKRAM_WIRELESS_PID           0x18E5
 #define AURA_ROG_CHAKRAM_WIRED_1_PID            0x18E3
-#define AURA_ROG_CHAKRAM_WIRED_2_PID            0x1958
+#define AURA_ROG_CHAKRAM_CORE_PID               0x1958
 #define AURA_ROG_PUGIO_PID                      0x1846
 #define AURA_ROG_PUGIO_II_WIRED_PID             0x1906
 #define AURA_ROG_PUGIO_II_WIRELESS_PID          0x1908
 #define AURA_ROG_STRIX_IMPACT_II_PID            0x18E1
 #define AURA_TUF_M3_PID                         0x1910
-#define AURA_TUF_M5_PID                         0x1910
+#define AURA_TUF_M5_PID                         0x1898
 
 enum
 {
@@ -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,19 +159,23 @@ 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 }
         }
     },
     {
-        AURA_ROG_CHAKRAM_WIRED_2_PID, // ROG Chakram Wired 2
+        AURA_ROG_CHAKRAM_CORE_PID, // ROG Chakram Core
         {
-            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_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
+            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
         }
     },
     {
@@ -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/AsusAuraStrixEvolveController.cpp

@@ -0,0 +1,146 @@
+/*-----------------------------------------*\
+|  AsusAuraStrixEvolveController.cpp        |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Mola19 11/30/2021                        |
+\*-----------------------------------------*/
+
+#include "AsusAuraStrixEvolveController.h"
+
+#include <cstring>
+#include <chrono>
+#include <thread>
+
+AuraStrixEvolveController::AuraStrixEvolveController(hid_device* dev_handle, const char* path, uint16_t pid)
+{
+    dev         = dev_handle;
+    location    = path;
+    device_pid  = pid;
+}
+
+AuraStrixEvolveController::~AuraStrixEvolveController()
+{
+    hid_close(dev);
+}
+
+std::string AuraStrixEvolveController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AuraStrixEvolveController::GetSerialString()
+{
+    wchar_t serial_string[HID_MAX_STR];
+    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+std::string AuraStrixEvolveController::GetVersion()
+{
+    unsigned char usb_buf[9] = { 0x0c, 0xc4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+    hid_send_feature_report(dev, usb_buf, 9);
+
+    unsigned char usb_buf_out[9] = { 0x0c };
+    hid_get_feature_report(dev, usb_buf_out, 9);
+
+    return std::string("1." +  std::to_string(usb_buf_out[3]));
+}
+
+int AuraStrixEvolveController::GetActiveProfile()
+{
+    int profile;
+
+    do
+    {
+        unsigned char usb_buf[9] = { 0x0c, 0xdf, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+        hid_send_feature_report(dev, usb_buf, 9);
+
+        unsigned char usb_buf_out[9] = { 0x0c };
+        hid_get_feature_report(dev, usb_buf_out, 9);
+
+        profile = usb_buf_out[4] % 16;
+    } while (profile > 2);
+
+    return profile + 1;
+}
+
+void AuraStrixEvolveController::SendUpdate
+    (
+    unsigned char   key,
+    unsigned char   value
+    )
+{
+    unsigned char usb_buf[9];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, 9);
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x0c;
+    usb_buf[0x01]   = 0xc4;
+    usb_buf[0x02]   = 0x0f;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = key;
+    usb_buf[0x05]   = value;
+    hid_send_feature_report(dev, usb_buf, 9);
+}
+
+
+void AuraStrixEvolveController::UpdateProfile
+    (
+    unsigned char   key,
+    unsigned char   profile,
+    unsigned char   value
+    )
+{
+    unsigned char usb_buf[9];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, 9);
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x0c;
+    usb_buf[0x01]   = 0xde;
+    usb_buf[0x02]   = key;
+    usb_buf[0x03]   = profile;
+    usb_buf[0x04]   = value;
+    hid_send_feature_report(dev, usb_buf, 9);
+    std::this_thread::sleep_for(std::chrono::milliseconds(5));
+}
+
+void AuraStrixEvolveController::SendSavePacket()
+{
+    unsigned char usb_buf[9];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, 9);
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x0c;
+    usb_buf[0x01]   = 0xc4;
+
+    hid_send_feature_report(dev, usb_buf, 9);
+}

Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.h

@@ -0,0 +1,50 @@
+/*-----------------------------------------*\
+|  AsusAuraStrixEvolveController.h          |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 11/30/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+#define HID_MAX_STR 255
+
+class AuraStrixEvolveController
+{
+public:
+    AuraStrixEvolveController(hid_device* dev_handle, const char* path, uint16_t pid);
+    virtual ~AuraStrixEvolveController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+    std::string GetVersion();
+    int GetActiveProfile();
+
+    void SendUpdate
+        (
+        unsigned char   key,
+        unsigned char   value
+	    );
+
+    void UpdateProfile
+        (
+        unsigned char   key,
+        unsigned char   profile,
+        unsigned char   value
+        );
+
+    void SendSavePacket();
+
+    uint16_t                    device_pid;
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp

@@ -15,7 +15,7 @@
 #include <math.h>
 #include <stdio.h>
 #include <string.h>
-#include <iostream>
+#include <cmath>
 
 AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path)
 {
@@ -36,7 +36,12 @@ std::string AuraTUFKeyboardController::GetDeviceLocation()
 std::string AuraTUFKeyboardController::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, 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());
@@ -44,6 +49,53 @@ std::string AuraTUFKeyboardController::GetSerialString()
     return(return_string);
 }
 
+std::string AuraTUFKeyboardController::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[9];
+    snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
+    return std::string(version);
+}
+
+int AuraTUFKeyboardController::GetLayout()
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x12;
+    usb_buf[0x02]   = 0x12;
+
+    hid_write(dev, usb_buf, 65);
+
+    unsigned char usb_buf_out[65];
+    hid_read(dev, usb_buf_out, 65);
+
+    return(usb_buf_out[4] * 100 + usb_buf_out[5]);
+}
+
+void AuraTUFKeyboardController::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);
+}
+
 void AuraTUFKeyboardController::UpdateSingleLed
     (
     int             led,
@@ -141,7 +193,8 @@ void AuraTUFKeyboardController::UpdateDevice
     std::vector<RGBColor>   colors,
     unsigned char           dir,
     unsigned char           color_mode,
-    unsigned char           speed
+    unsigned char           speed,
+    unsigned char           brightness
     )
 {
     unsigned char usb_buf[65];
@@ -154,21 +207,21 @@ void AuraTUFKeyboardController::UpdateDevice
     usb_buf[0x03]   = mode;
     usb_buf[0x04]   = 0x00;
     usb_buf[0x05]   = speed;
-    usb_buf[0x06]   = 0x64;
+    usb_buf[0x06]   = brightness;
     usb_buf[0x07]   = color_mode;
     usb_buf[0x08]   = dir;
     usb_buf[0x09]   = 0x02;
 
-	if(mode == 4 || mode == 5)
-	{
-	    /*-----------------------------------------------------*\
+    if(mode == 4 || mode == 5)
+    {
+        /*-----------------------------------------------------*\
         | If mode is Rainbow or Ripple                          |
-	    \*-----------------------------------------------------*/
-	    usb_buf[0x0A]   = colors.size();
+        \*-----------------------------------------------------*/
+        usb_buf[0x0A]   = colors.size();
 
-	    /*-----------------------------------------------------*\
-	    | Loop over every color given                           |
-	    \*-----------------------------------------------------*/
+        /*-----------------------------------------------------*\
+        | Loop over every color given                           |
+        \*-----------------------------------------------------*/
         for(unsigned int i = 0; i / 4 < colors.size(); i += 4)
         {
             if(colors[i / 4])
@@ -179,13 +232,13 @@ void AuraTUFKeyboardController::UpdateDevice
                 usb_buf[14 + i] = RGBGetBValue(colors[i/4]);
             }
         }
-	}
+    }
     else
     {
-	    /*-----------------------------------------------------*\
-	    | Loop over Color1, Color2 and Background if there      |
-	    \*-----------------------------------------------------*/
-	    for(unsigned int i = 0; i / 3 != colors.size(); i += 3)
+        /*-----------------------------------------------------*\
+        | Loop over Color1, Color2 and Background if there      |
+        \*-----------------------------------------------------*/
+        for(unsigned int i = 0; i / 3 != colors.size(); i += 3)
         {
             if(colors[i / 3])
             {
@@ -194,25 +247,28 @@ void AuraTUFKeyboardController::UpdateDevice
                 usb_buf[12 + i] = RGBGetBValue(colors[i/3]);
             }
         }
-			
-	}
+            
+    }
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
+}
 
-    /*-----------------------------------------------------*\
-    | Set up and send packet save Packet                    |
-    \*-----------------------------------------------------*/
-    unsigned char usb_save_buf[65];
+void AuraTUFKeyboardController::AwaitResponse()
+{
+    unsigned char usb_buf_out[65];
+    hid_read(dev, usb_buf_out, 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 AuraTUFKeyboardController::ClearResponses()
+{
+    int result = 1;
+    unsigned char usb_buf_flush[65];
+    while(result > 0)
+    {
+      result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
+    }
 }
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h

@@ -8,6 +8,7 @@
 \*-----------------------------------------*/
 
 #include "RGBController.h"
+#include "AsusAuraTUFKeyboardLayouts.h"
 
 #include <string>
 #include <vector>
@@ -46,6 +47,9 @@ public:
 
     std::string GetDeviceLocation();
     std::string GetSerialString();
+    std::string GetVersion();
+    int         GetLayout();
+    void        SaveMode();
 
     void UpdateSingleLed
         (
@@ -55,7 +59,7 @@ public:
         unsigned char   blue
         );
 
-	void UpdateLeds
+    void UpdateLeds
         (
         std::vector<RGBColor>    colors
         );
@@ -66,8 +70,11 @@ public:
         std::vector<RGBColor>   colors,
         unsigned char           dir,
         unsigned char           color_mode,
-        unsigned char           speed
+        unsigned char           speed,
+        unsigned char           brightness
         );
+    void AwaitResponse();
+    void ClearResponses();
 
 private:
     hid_device*                 dev;

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardLayouts.h

@@ -0,0 +1,411 @@
+/*-----------------------------------------*\
+|  AsusAuraTUFKeyboardController.h          |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 10/02/2021                        |
+\*-----------------------------------------*/
+
+#include <vector>
+#include <map>
+#include "RGBController.h"
+
+#pragma once
+
+enum
+{
+    ASUS_TUF_K7_LAYOUT_CA    = 1,
+    ASUS_TUF_K7_LAYOUT_AR    = 2,
+    ASUS_TUF_K7_LAYOUT_DE    = 3,
+    ASUS_TUF_K7_LAYOUT_UK    = 4,
+    ASUS_TUF_K7_LAYOUT_FR    = 5,
+    ASUS_TUF_K7_LAYOUT_CN    = 6,
+    ASUS_TUF_K7_LAYOUT_HU    = 7,
+    ASUS_TUF_K7_LAYOUT_IT    = 8,
+    ASUS_TUF_K7_LAYOUT_TH    = 9,
+    ASUS_TUF_K7_LAYOUT_UA    = 10,
+    ASUS_TUF_K7_LAYOUT_NO    = 11,
+    ASUS_TUF_K7_LAYOUT_PT    = 12,
+    ASUS_TUF_K7_LAYOUT_HE    = 13,
+    ASUS_TUF_K7_LAYOUT_RU    = 14,
+    ASUS_TUF_K7_LAYOUT_ES    = 15,
+    ASUS_TUF_K7_LAYOUT_TW    = 16,
+    ASUS_TUF_K7_LAYOUT_US    = 17,
+    ASUS_TUF_K7_LAYOUT_TR    = 18,
+    ASUS_TUF_K7_LAYOUT_CZ    = 19,
+    ASUS_TUF_K7_LAYOUT_BE    = 20,
+    ASUS_TUF_K7_LAYOUT_JP    = 21,
+    ASUS_TUF_K7_LAYOUT_KR    = 22,
+    ASUS_TUF_K7_LAYOUT_IS    = 23,
+    ASUS_TUF_K7_LAYOUT_WB    = 24,
+    ASUS_TUF_K7_LAYOUT_SW_CH = 25
+};
+
+#define NA  0xFFFFFFFF
+
+typedef struct
+{
+    unsigned int *                matrix_map;
+    std::vector<std::string>      led_names;
+} layout_type;
+
+
+static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_104[6][23] = {
+    {   0,  NA,  18,  24,  30,  36,  NA,  48,  54,  60,  66,  72,  78,  84,  90,  NA,  96, 102, 108,  NA,  NA,  NA,  NA },
+    {   1,  13,  19,  25,  31,  37,  43,  49,  55,  61,  67,  73,  79,  91,  NA,  NA,  97, 103, 109, 115, 121, 127, 133 },
+    {   2,  NA,  14,  20,  26,  32,  38,  44,  50,  56,  62,  68,  74,  80,  92,  NA,  98, 104, 110, 116, 122, 128, 134 },
+    {   3,  NA,  15,  21,  27,  33,  39,  45,  51,  57,  63,  69,  75,  NA,  93,  NA,  NA,  NA,  NA, 117, 123, 129,  NA },
+    {   4,  NA,  16,  22,  28,  34,  40,  46,  52,  58,  64,  70,  NA,  94,  NA,  NA,  NA, 106,  NA, 118, 124, 130, 136 },
+    {   5,  11,  17,  NA,  NA,  NA,  41,  NA,  NA,  NA,  59,  71,  77,  NA,  95,  NA, 101, 107, 113, 119,  NA, 131,  NA }
+};
+
+static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_105[6][23] = {
+    {   0,  NA,  18,  24,  30,  36,  NA,  48,  54,  60,  66,  72,  78,  84,  90,  NA,  96, 102, 108,  NA,  NA,  NA,  NA },
+    {   1,  13,  19,  25,  31,  37,  43,  49,  55,  61,  67,  73,  79,  91,  NA,  NA,  97, 103, 109, 115, 121, 127, 133 },
+    {   2,  NA,  14,  20,  26,  32,  38,  44,  50,  56,  62,  68,  74,  80,  NA,  NA,  98, 104, 110, 116, 122, 128, 134 },
+    {   3,  NA,  15,  21,  27,  33,  39,  45,  51,  57,  63,  69,  75,  81,  93,  NA,  NA,  NA,  NA, 117, 123, 129,  NA },
+    {   4,  10,  16,  22,  28,  34,  40,  46,  52,  58,  64,  70,  NA,  94,  NA,  NA,  NA, 106,  NA, 118, 124, 130, 136 },
+    {   5,  11,  17,  NA,  NA,  NA,  41,  NA,  NA,  NA,  59,  71,  77,  NA,  95,  NA, 101, 107, 113, 119,  NA, 131,  NA }
+};
+
+
+static std::map<int,layout_type> AsusTUFK7Layouts =
+{
+    {
+        ASUS_TUF_K7_LAYOUT_UK,
+        {
+            (unsigned int *) ASUS_TUF_K7_LAYOUT_KEYS_105,
+            {
+                "Key: Escape",
+                "Key: `",
+                "Key: Tab",
+                "Key: Caps Lock",
+                "Key: Left Shift",
+                "Key: Left Control",
+
+                "Unused",
+                "Unused",
+                "Unused",
+                "Unused",
+                "Key: \\",
+                "Key: Left Windows",
+
+                "Unused",
+                "Key: 1",
+                "Key: Q",
+                "Key: A",
+                "Key: Z",
+                "Key: Left Alt",
+
+                "Key: F1",
+                "Key: 2",
+                "Key: W",
+                "Key: S",
+                "Key: X",
+                "Unused",
+
+                "Key: F2",
+                "Key: 3",
+                "Key: E",
+                "Key: D",
+                "Key: C",
+                "Unused",
+
+                "Key: F3",
+                "Key: 4",
+                "Key: R",
+                "Key: F",
+                "Key: V",
+                "Unused",
+
+                "Key: F4",
+                "Key: 5",
+                "Key: T",
+                "Key: G",
+                "Key: B",
+                "Key: Space",
+
+                "Unused",
+                "Key: 6",
+                "Key: Y",
+                "Key: H",
+                "Key: N",
+                "Unused",
+
+                "Key: F5",
+                "Key: 7",
+                "Key: U",
+                "Key: J",
+                "Key: M",
+                "Unused",
+
+                "Key: F6",
+                "Key: 8",
+                "Key: I",
+                "Key: K",
+                "Key: ,",
+                "Key: Right Alt",
+
+                "Key: F7",
+                "Key: 9",
+                "Key: O",
+                "Key: L",
+                "Key: .",
+                "Unused",
+
+                "Key: F8",
+                "Key: 0",
+                "Key: P",
+                "Key: ;",
+                "Key: /",
+                "Key: Right Fn",
+
+                "Key: F9",
+                "Key: -",
+                "Key: [",
+                "Key: '",
+                "Unused",
+                "Key: Menu",
+
+                "Key: F10",
+                "Key: =",
+                "Key: ]",
+                "Key: #",
+                "Unused",
+                "Unused",
+
+                "Key: F11",
+                "Unused",
+                "Unused",
+                "Unused",
+                "Unused",
+                "Unused",
+
+                "Key: F12",
+                "Key: Backspace",
+                "Unused",
+                "Key: Enter",
+                "Key: Right Shift",
+                "Key: Right Control",
+
+                "Key: Print Screen",
+                "Key: Insert",
+                "Key: Delete",
+                "Unused",
+                "Unused",
+                "Key: Left Arrow",
+
+                "Key: Scroll Lock",
+                "Key: Home",
+                "Key: End",
+                "Unused",
+                "Key: Up Arrow",
+                "Key: Down Arrow",
+
+                "Key: Pause/Break",
+                "Key: Page Up",
+                "Key: Page Down",
+                "Unused",
+                "Unused",
+                "Key: Right Arrow",
+
+                "Unused",
+                "Key: Num Lock",
+                "Key: Number Pad 7",
+                "Key: Number Pad 4",
+                "Key: Number Pad 1",
+                "Key: Number Pad 0",
+
+                "Unused",
+                "Key: Number Pad /",
+                "Key: Number Pad 8",
+                "Key: Number Pad 5",
+                "Key: Number Pad 2",
+                "Unused",
+
+                "Unused",
+                "Key: Number Pad *",
+                "Key: Number Pad 9",
+                "Key: Number Pad 6",
+                "Key: Number Pad 3",
+                "Key: Number Pad ,",
+
+                "Unused",
+                "Key: Number Pad -",
+                "Key: Number Pad +",
+                "Unused",
+                "Key: Number Pad Enter",
+                "Unused",
+            }
+        }
+    },
+    {
+        ASUS_TUF_K7_LAYOUT_US,
+        {
+            (unsigned int *) ASUS_TUF_K7_LAYOUT_KEYS_104,
+            {
+                "Key: Escape",
+                "Key: `",
+                "Key: Tab",
+                "Key: Caps Lock",
+                "Key: Left Shift",
+                "Key: Left Control",
+
+                "Unused",
+                "Unused",
+                "Unused",
+                "Unused",
+                "Unused",
+                "Key: Left Windows",
+
+                "Unused",
+                "Key: 1",
+                "Key: Q",
+                "Key: A",
+                "Key: Z",
+                "Key: Left Alt",
+
+                "Key: F1",
+                "Key: 2",
+                "Key: W",
+                "Key: S",
+                "Key: X",
+                "Unused",
+
+                "Key: F2",
+                "Key: 3",
+                "Key: E",
+                "Key: D",
+                "Key: C",
+                "Unused",
+
+                "Key: F3",
+                "Key: 4",
+                "Key: R",
+                "Key: F",
+                "Key: V",
+                "Unused",
+
+                "Key: F4",
+                "Key: 5",
+                "Key: T",
+                "Key: G",
+                "Key: B",
+                "Key: Space",
+
+                "Unused",
+                "Key: 6",
+                "Key: Y",
+                "Key: H",
+                "Key: N",
+                "Unused",
+
+                "Key: F5",
+                "Key: 7",
+                "Key: U",
+                "Key: J",
+                "Key: M",
+                "Unused",
+
+                "Key: F6",
+                "Key: 8",
+                "Key: I",
+                "Key: K",
+                "Key: ,",
+                "Key: Right Alt",
+
+                "Key: F7",
+                "Key: 9",
+                "Key: O",
+                "Key: L",
+                "Key: .",
+                "Unused",
+
+                "Key: F8",
+                "Key: 0",
+                "Key: P",
+                "Key: ;",
+                "Key: /",
+                "Key: Right Fn",
+
+                "Key: F9",
+                "Key: -",
+                "Key: [",
+                "Key: '",
+                "Unused",
+                "Key: Menu",
+
+                "Key: F10",
+                "Key: =",
+                "Key: ]",
+                "Unused",
+                "Unused",
+                "Unused",
+
+                "Key: F11",
+                "Unused",
+                "Unused",
+                "Unused",
+                "Unused",
+                "Unused",
+
+                "Key: F12",
+                "Key: Backspace",
+                "Key: \\",
+                "Key: Enter",
+                "Key: Right Shift",
+                "Key: Right Control",
+
+                "Key: Print Screen",
+                "Key: Insert",
+                "Key: Delete",
+                "Unused",
+                "Unused",
+                "Key: Left Arrow",
+
+                "Key: Scroll Lock",
+                "Key: Home",
+                "Key: End",
+                "Unused",
+                "Key: Up Arrow",
+                "Key: Down Arrow",
+
+                "Key: Pause/Break",
+                "Key: Page Up",
+                "Key: Page Down",
+                "Unused",
+                "Unused",
+                "Key: Right Arrow",
+
+                "Unused",
+                "Key: Num Lock",
+                "Key: Number Pad 7",
+                "Key: Number Pad 4",
+                "Key: Number Pad 1",
+                "Key: Number Pad 0",
+
+                "Unused",
+                "Key: Number Pad /",
+                "Key: Number Pad 8",
+                "Key: Number Pad 5",
+                "Key: Number Pad 2",
+                "Unused",
+
+                "Unused",
+                "Key: Number Pad *",
+                "Key: Number Pad 9",
+                "Key: Number Pad 6",
+                "Key: Number Pad 3",
+                "Key: Number Pad ,",
+
+                "Unused",
+                "Key: Number Pad -",
+                "Key: Number Pad +",
+                "Unused",
+                "Key: Number Pad Enter",
+                "Unused",
+            }
+        }
+    },
+};

Controllers/AsusAuraUSBController/AsusAuraUSBController.cpp

@@ -100,9 +100,8 @@ void AuraUSBController::GetConfigTable()
     }
     else
     {       
-        hid_close(dev);
-
-        throw std::runtime_error("Could not read config table");
+        LOG_INFO("[%s] Could not read config table, can not add device", device_name);
+        delete this;
     }
 }
 

Controllers/AsusAuraUSBController/AsusAuraUSBController.h

@@ -8,6 +8,7 @@
 \*-----------------------------------------*/
 
 #include "RGBController.h"
+#include "LogManager.h"
 
 #include <string>
 #include <vector>

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -5,12 +5,14 @@
 #include "AsusAuraTUFKeyboardController.h"
 #include "AsusAuraMainboardController.h"
 #include "AsusAuraMouseController.h"
+#include "AsusAuraStrixEvolveController.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraUSB.h"
 #include "RGBController_AsusAuraHeadsetStand.h"
 #include "RGBController_AsusAuraKeyboard.h"
 #include "RGBController_AsusAuraTUFKeyboard.h"
 #include "RGBController_AsusAuraMouse.h"
+#include "RGBController_AsusAuraStrixEvolve.h"
 #include <stdexcept>
 #include <hidapi/hidapi.h>
 #include "dependencies/dmiinfo.h"
@@ -44,11 +46,13 @@
 |  MICE - defined in AsusAuraMouseDevices.h                         |
 \*-----------------------------------------------------------------*/
 
+#define AURA_ROG_STRIX_EVOLVE_PID               0x185B
 
 /*-----------------------------------------------------------------*\
 |  OTHER                                                            |
 \*-----------------------------------------------------------------*/
 #define AURA_TERMINAL_PID                       0x1889
+#define AURA_ROG_THRONE_PID                     0x18D9
 #define AURA_ROG_THRONE_QI_PID                  0x18C5
 
 
@@ -150,6 +154,18 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
     }
 }
 
+void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        AuraStrixEvolveController* controller = new AuraStrixEvolveController(dev, info->path, info->product_id);
+        RGBController_AuraStrixEvolve* rgb_controller = new RGBController_AuraStrixEvolve(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 void DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -209,16 +225,19 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",        DetectAsusAuraUS
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,       2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",         DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,            0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,             0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_2_PID,             0,  0xFF01);
+REGISTER_HID_DETECTOR_IP("Asus ROG Chakram Core",               DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID,                0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_PID,                       2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,              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);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M5_PID,                          2,  0xFF01);
+
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Evolve",               DetectAsusAuraUSBStrixEvolve,   AURA_USB_VID, AURA_ROG_STRIX_EVOLVE_PID,                1,  0x0008);
 
 /*-----------------------------------------------------------------*\
 |  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 | MODE_FLAG_MANUAL_SAVE ;
+                    ColorCycle.brightness_min   = AURA_MOUSE_BRIGHTNESS_MIN;
+                    ColorCycle.brightness_max   = AURA_MOUSE_BRIGHTNESS_MAX;
+                    ColorCycle.brightness       = AURA_MOUSE_BRIGHTNESS_DEFAULT;
+                    ColorCycle.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();
@@ -165,9 +191,9 @@ void RGBController_AuraMouse::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AuraMouse::DeviceUpdateLEDs()
 {
-    for(std::vector<led>::iterator led_it = leds.begin(); led_it != leds.end(); led_it++)
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
     {
-        UpdateSingleLED(led_it->value);
+        UpdateSingleLED(zone_index);
     }
 }
 
@@ -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/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp

@@ -0,0 +1,154 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraStrixEvolve.cpp    |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 11/30/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraStrixEvolve.h"
+
+RGBController_AuraStrixEvolve::RGBController_AuraStrixEvolve(AuraStrixEvolveController* controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    name                        = "ASUS ROG Strix Evolve";
+    vendor                      = "ASUS";
+    type                        = DEVICE_TYPE_MOUSE;
+    description                 = "ASUS Aura Mouse Device";
+    version                     = controller->GetVersion();
+    location                    = controller->GetDeviceLocation();
+    serial                      = controller->GetSerialString();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = 1;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.brightness_min       = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Direct.brightness_max       = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Direct.brightness           = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = 2;
+    Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.brightness_min    = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Breathing.brightness        = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Breathing.color_mode        = MODE_COLORS_PER_LED;
+    modes.push_back(Breathing);
+
+    mode ColorCycle;
+    ColorCycle.name             = "Spectrum Cycle";
+    ColorCycle.value            = 3;
+    ColorCycle.flags            = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    ColorCycle.brightness_min   = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    ColorCycle.brightness_max   = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    ColorCycle.brightness       = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    ColorCycle.color_mode       = MODE_COLORS_NONE;
+    modes.push_back(ColorCycle);
+
+    mode Reactive;
+    Reactive.name               = "Reactive";
+    Reactive.value              = 4;
+    Reactive.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Reactive.brightness_min     = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
+    Reactive.brightness_max     = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
+    Reactive.brightness         = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
+    Reactive.color_mode         = MODE_COLORS_PER_LED;
+    modes.push_back(Reactive);
+
+    SetupZones();
+}
+
+RGBController_AuraStrixEvolve::~RGBController_AuraStrixEvolve()
+{
+    delete controller;
+}
+
+void RGBController_AuraStrixEvolve::SetupZones()
+{
+    zone mouse_zone;
+
+    mouse_zone.name         = "Underglow";
+    mouse_zone.type         = ZONE_TYPE_SINGLE;
+    mouse_zone.leds_min     = 1;
+    mouse_zone.leds_max     = 1;
+    mouse_zone.leds_count   = 1;
+    mouse_zone.matrix_map   = NULL;
+
+    zones.push_back(mouse_zone);
+
+    led mouse_led;
+
+    mouse_led.name          = "Underglow";
+    mouse_led.value         = 1;
+
+    leds.push_back(mouse_led);
+
+    SetupColors();
+}
+
+void RGBController_AuraStrixEvolve::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_AuraStrixEvolve::DeviceUpdateLEDs()
+{
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+
+    controller->SendUpdate(0x1C, red);
+    controller->SendUpdate(0x1D, grn);
+    controller->SendUpdate(0x1E, blu);
+}
+
+void RGBController_AuraStrixEvolve::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraStrixEvolve::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraStrixEvolve::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_AuraStrixEvolve::DeviceUpdateMode()
+{
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+
+    controller->SendUpdate(0x19, modes[active_mode].value);
+    controller->SendUpdate(0x1A, modes[active_mode].brightness);
+    controller->SendUpdate(0x1C, red);
+    controller->SendUpdate(0x1D, grn);
+    controller->SendUpdate(0x1E, blu);
+}
+
+void RGBController_AuraStrixEvolve::DeviceSaveMode()
+{
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+
+    unsigned int profile = controller->GetActiveProfile();
+
+    controller->UpdateProfile(0x19, profile, modes[active_mode].value);
+    controller->UpdateProfile(0x1A, profile, modes[active_mode].brightness);
+    controller->UpdateProfile(0x1C, profile, red);
+    controller->UpdateProfile(0x1D, profile, grn);
+    controller->UpdateProfile(0x1E, profile, blu);
+
+    controller->SendSavePacket();
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h

@@ -0,0 +1,41 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraStrixEvolve.h      |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 11/30/2021                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraStrixEvolveController.h"
+
+enum
+{
+    AURA_STRIX_EVOLVE_BRIGHTNESS_MIN     = 0,
+    AURA_STRIX_EVOLVE_BRIGHTNESS_MAX     = 255,
+    AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT = 255
+};
+
+class RGBController_AuraStrixEvolve : public RGBController
+{
+public:
+    RGBController_AuraStrixEvolve(AuraStrixEvolveController* controller_ptr);
+    ~RGBController_AuraStrixEvolve();
+
+    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:
+    AuraStrixEvolveController*  controller;
+};

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -9,195 +9,7 @@
 
 #include "RGBController_AsusAuraTUFKeyboard.h"
 #include <vector>
-
-#define NA  0xFFFFFFFF
-
-static unsigned int matrix_map[6][23] =
-    { {   0,  NA,  18,  24,  30,  36,  NA,  48,  54,  60,  66,  72,  78,  84,  90,  NA,  96, 102, 108,  NA,  NA,  NA,  NA },
-      {   1,  13,  19,  25,  31,  37,  43,  49,  55,  61,  67,  73,  79,  91,  NA,  NA,  97, 103, 109, 115, 121, 127, 133 },
-      {   2,  NA,  14,  20,  26,  32,  38,  44,  50,  56,  62,  68,  74,  80,  NA,  NA,  98, 104, 110, 116, 122, 128, 134 },
-      {   3,  NA,  15,  21,  27,  33,  39,  45,  51,  57,  63,  69,  75,  81,  93,  NA,  NA,  NA,  NA, 117, 123, 129,  NA },
-      {   4,  10,  16,  22,  28,  34,  40,  46,  52,  58,  64,  70,  NA,  94,  NA,  NA,  NA, 106,  NA, 118, 124, 130, 136 },
-      {   5,  11,  17,  NA,  NA,  NA,  41,  NA,  NA,  NA,  59,  71,  77,  NA,  95,  NA, 101, 107, 113, 119,  NA, 131,  NA } };
-
-static const char* zone_names[] =
-{
-    "Keyboard"
-};
-
-static zone_type zone_types[] =
-{
-    ZONE_TYPE_MATRIX,
-};
-
-static const unsigned int zone_sizes[] =
-{
-    138
-};
-
-static const char *led_names[] =
-{
-    "Key: Escape",
-    "Key: ^",
-    "Key: Tab",
-    "Key: Caps Lock",
-    "Key: Left Shift",
-    "Key: Left Control",
-
-    "Unused",
-    "Unused",
-    "Unused",
-    "Unused",
-    "Key: <",
-    "Key: Left Windows",
-
-    "Unused",
-    "Key: 1",
-    "Key: Q",
-    "Key: A",
-    "Key: Y",
-    "Key: Left Alt",
-
-    "Key: F1",
-    "Key: 2",
-    "Key: W",
-    "Key: S",
-    "Key: X",
-    "Unused",
-
-    "Key: F2",
-    "Key: 3",
-    "Key: E",
-    "Key: D",
-    "Key: C",
-    "Unused",
-
-    "Key: F3",
-    "Key: 4",
-    "Key: R",
-    "Key: F",
-    "Key: V",
-    "Unused",
-
-    "Key: F4",
-    "Key: 5",
-    "Key: T",
-    "Key: G",
-    "Key: B",
-    "Key: Space",
-
-    "Unused",
-    "Key: 6",
-    "Key: Z",
-    "Key: H",
-    "Key: N",
-    "Unused",
-
-    "Key: F5",
-    "Key: 7",
-    "Key: U",
-    "Key: J",
-    "Key: M",
-    "Unused",
-
-    "Key: F6",
-    "Key: 8",
-    "Key: I",
-    "Key: K",
-    "Key: ,",
-    "Key: Right Alt",
-
-    "Key: F7",
-    "Key: 9",
-    "Key: O",
-    "Key: L",
-    "Key: .",
-    "Unused",
-
-    "Key: F8",
-    "Key: 0",
-    "Key: P",
-    "Key: Ö",
-    "Key: -",
-    "Key: Right Fn",
-
-    "Key: F9",
-    "Key: ß",
-    "Key: Ü",
-    "Key: Ä",
-    "Unused",
-    "Key: Menu",
-
-    "Key: F10",
-    "Key: ´",
-    "Key: +",
-    "Key: #",
-    "Unused",
-    "Unused",
-
-    "Key: F11",
-    "Unused",
-    "Unused",
-    "Unused",
-    "Unused",
-    "Unused",
-
-    "Key: F12",
-    "Key: Backspace",
-    "Unused",
-    "Key: Enter",
-    "Key: Right Shift",
-    "Key: Right Control",
-
-    "Key: Print Screen",
-    "Key: Insert",
-    "Key: Delete",
-    "Unused",
-    "Unused",
-    "Key: Left Arrow",
-
-    "Key: Scroll Lock",
-    "Key: Home",
-    "Key: End",
-    "Unused",
-    "Key: Up Arrow",
-    "Key: Down Arrow",
-
-    "Key: Pause/Break",
-    "Key: Page Up",
-    "Key: Page Down",
-    "Unused",
-    "Unused",
-    "Key: Right Arrow",
-
-    "Unused",
-    "Key: Num Lock",
-    "Key: Number Pad 7",
-    "Key: Number Pad 4",
-    "Key: Number Pad 1",
-    "Key: Number Pad 0",
-
-    "Unused",
-    "Key: Number Pad /",
-    "Key: Number Pad 8",
-    "Key: Number Pad 5",
-    "Key: Number Pad 2",
-    "Unused",
-
-    "Unused",
-    "Key: Number Pad *",
-    "Key: Number Pad 9",
-    "Key: Number Pad 6",
-    "Key: Number Pad 3",
-    "Key: Number Pad ,",
-
-    "Unused",
-    "Key: Number Pad -",
-    "Key: Number Pad +",
-    "Unused",
-    "Key: Number Pad Enter",
-    "Unused",
-};
+#include <cmath>
 
 RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* aura_ptr)
 {
@@ -207,139 +19,170 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
     vendor      = "ASUS";
     type        = DEVICE_TYPE_KEYBOARD;
     description = "ASUS Aura Keyboard Device";
+    version     = aura->GetVersion();
     location    = aura->GetDeviceLocation();
     serial      = aura->GetSerialString();
 
     mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = AURA_KEYBOARD_MODE_DIRECT;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    Direct.name                 = "Direct";
+    Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_KEYBOARD_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_KEYBOARD_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Static.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Static.brightness           = AURA_KEYBOARD_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_KEYBOARD_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.speed_min  = 0;
-    Breathing.speed_max  = 15;
-    Breathing.speed      = 8;
-    Breathing.colors_min = 1;
-    Breathing.colors_max = 2;
+    Breathing.name              = "Breathing";
+    Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+    Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+    Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+    Breathing.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Breathing.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 2;
     Breathing.colors.resize(1);
     modes.push_back(Breathing);
 
     mode Color_Cycle;
-    Color_Cycle.name       = "Color Cycle";
-    Color_Cycle.value      = AURA_KEYBOARD_MODE_COLOR_CYCLE;
-    Color_Cycle.flags      = MODE_FLAG_HAS_SPEED;
-    Color_Cycle.color_mode = MODE_COLORS_NONE;
-    Color_Cycle.speed_min  = 0;
-    Color_Cycle.speed_max  = 15;
-    Color_Cycle.speed      = 8;
+    Color_Cycle.name            = "Spectrum Cycle";
+    Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
+    Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Color_Cycle.speed_min       = AURA_KEYBOARD_SPEED_MIN;
+    Color_Cycle.speed_max       = AURA_KEYBOARD_SPEED_MAX;
+    Color_Cycle.speed           = AURA_KEYBOARD_SPEED_DEFAULT;
+    Color_Cycle.brightness_min  = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Color_Cycle.brightness_max  = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Color_Cycle.brightness      = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Color_Cycle.color_mode      = MODE_COLORS_NONE;
     modes.push_back(Color_Cycle);
 
     mode Wave;
-    Wave.name       = "Wave";
-    Wave.value      = AURA_KEYBOARD_MODE_WAVE;
-    Wave.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_HV;
-    Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Wave.speed_min  = 0;
-    Wave.speed_max  = 15;
-    Wave.speed      = 8;
-    Wave.direction  = MODE_DIRECTION_LEFT;
-    Wave.colors_min = 1;
-    Wave.colors_max = 7;
+    Wave.name                   = "Rainbow Wave";
+    Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
+    Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Wave.speed_min              = AURA_KEYBOARD_SPEED_MIN;
+    Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
+    Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
+    Wave.brightness_min         = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Wave.brightness_max         = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Wave.brightness             = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Wave.direction              = MODE_DIRECTION_LEFT;
+    Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Wave.colors_min             = 1;
+    Wave.colors_max             = 7;
     Wave.colors.resize(7);
     modes.push_back(Wave);
 
     mode Ripple;
-    Ripple.name       = "Ripple";
-    Ripple.value      = AURA_KEYBOARD_MODE_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  = 0;
-    Ripple.speed_max  = 15;
-    Ripple.speed      = 8;
-    Ripple.colors_min = 1;
-    Ripple.colors_max = 8;
+    Ripple.name                 = "Ripple";
+    Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
+    Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Ripple.speed_min            = AURA_KEYBOARD_SPEED_MIN;
+    Ripple.speed_max            = AURA_KEYBOARD_SPEED_MAX;
+    Ripple.speed                = AURA_KEYBOARD_SPEED_DEFAULT;
+    Ripple.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Ripple.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Ripple.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Ripple.colors_min           = 1;
+    Ripple.colors_max           = 8;
     Ripple.colors.resize(7);
     modes.push_back(Ripple);
 
     mode Reactive;
-    Reactive.name       = "Reactive";
-    Reactive.value      = AURA_KEYBOARD_MODE_REACTIVE;
-    Reactive.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
-    Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Reactive.speed_min  = 0;
-    Reactive.speed_max  = 15;
-    Reactive.speed      = 8;
-    Reactive.colors_min = 1;
-    Reactive.colors_max = 2;
+    Reactive.name               = "Reactive";
+    Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
+    Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Reactive.speed_min          = AURA_KEYBOARD_SPEED_MIN;
+    Reactive.speed_max          = AURA_KEYBOARD_SPEED_MAX;
+    Reactive.speed              = AURA_KEYBOARD_SPEED_DEFAULT;
+    Reactive.brightness_min     = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Reactive.brightness_max     = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Reactive.brightness         = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Reactive.colors_min         = 1;
+    Reactive.colors_max         = 2;
     Reactive.colors.resize(1);
     modes.push_back(Reactive);
 
     mode Starry_Night;
-    Starry_Night.name       = "Starry Night";
-    Starry_Night.value      = AURA_KEYBOARD_MODE_STARRY_NIGHT;
-    Starry_Night.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
-    Starry_Night.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Starry_Night.speed_min  = 0;
-    Starry_Night.speed_max  = 15;
-    Starry_Night.speed      = 8;
-    Starry_Night.colors_min = 1;
-    Starry_Night.colors_max = 3;
+    Starry_Night.name           = "Starry Night";
+    Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
+    Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Starry_Night.speed_min      = AURA_KEYBOARD_SPEED_MIN;
+    Starry_Night.speed_max      = AURA_KEYBOARD_SPEED_MAX;
+    Starry_Night.speed          = AURA_KEYBOARD_SPEED_DEFAULT;
+    Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Starry_Night.brightness     = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Starry_Night.colors_min     = 1;
+    Starry_Night.colors_max     = 3;
     Starry_Night.colors.resize(1);
     modes.push_back(Starry_Night);
 
     mode Quicksand;
-    Quicksand.name       = "Quicksand";
-    Quicksand.value      = AURA_KEYBOARD_MODE_QUICKSAND;
-    Quicksand.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD;
-    Quicksand.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Quicksand.direction  = MODE_DIRECTION_DOWN;
-    Quicksand.speed_min  = 0;
-    Quicksand.speed_max  = 15;
-    Quicksand.speed      = 8;
-    Quicksand.colors_min = 6;
-    Quicksand.colors_max = 6;
+    Quicksand.name              = "Quicksand";
+    Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
+    Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Quicksand.direction         = MODE_DIRECTION_DOWN;
+    Quicksand.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+    Quicksand.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+    Quicksand.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+    Quicksand.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Quicksand.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Quicksand.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Quicksand.colors_min        = 6;
+    Quicksand.colors_max        = 6;
     Quicksand.colors.resize(6);
     modes.push_back(Quicksand);
 
     mode Current;
-    Current.name       = "Current";
-    Current.value      = AURA_KEYBOARD_MODE_CURRENT;
-    Current.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
-    Current.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Current.speed_min  = 0;
-    Current.speed_max  = 15;
-    Current.speed      = 8;
-    Current.colors_min = 1;
-    Current.colors_max = 3;
+    Current.name                = "Current";
+    Current.value               = AURA_KEYBOARD_MODE_CURRENT;
+    Current.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Current.speed_min           = AURA_KEYBOARD_SPEED_MIN;
+    Current.speed_max           = AURA_KEYBOARD_SPEED_MAX;
+    Current.speed               = AURA_KEYBOARD_SPEED_DEFAULT;
+    Current.brightness_min      = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Current.brightness_max      = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Current.brightness          = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Current.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+    Current.colors_min          = 1;
+    Current.colors_max          = 3;
     Current.colors.resize(1);
     modes.push_back(Current);
 
     mode Rain_Drop;
-    Rain_Drop.name       = "Rain Drop";
-    Rain_Drop.value      = AURA_KEYBOARD_MODE_RAIN_DROP;
-    Rain_Drop.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
-    Rain_Drop.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Rain_Drop.speed_min  = 0;
-    Rain_Drop.speed_max  = 15;
-    Rain_Drop.speed      = 8;
-    Rain_Drop.colors_min = 1;
-    Rain_Drop.colors_max = 3;
+    Rain_Drop.name              = "Rain Drop";
+    Rain_Drop.value             = AURA_KEYBOARD_MODE_RAIN_DROP;
+    Rain_Drop.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Rain_Drop.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+    Rain_Drop.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+    Rain_Drop.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+    Rain_Drop.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Rain_Drop.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Rain_Drop.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Rain_Drop.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Rain_Drop.colors_min        = 1;
+    Rain_Drop.colors_max        = 3;
     Rain_Drop.colors.resize(1);
     modes.push_back(Rain_Drop);
 
@@ -353,29 +196,40 @@ RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
 
 void RGBController_AuraTUFKeyboard::SetupZones()
 {
+    int layout = aura->GetLayout();
+
+    if(AsusTUFK7Layouts.find(layout % 100) == AsusTUFK7Layouts.end())
+    {
+        layout = std::floor(layout/100) == 2 ? ASUS_TUF_K7_LAYOUT_UK : ASUS_TUF_K7_LAYOUT_US;
+    }
+    else
+    {
+        layout = layout % 100;
+    }
+
     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];
-        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;
-        zones.push_back(new_zone);
+    int zone_size = 138;
+
+    zone keyboard;
+    keyboard.name               = "Keyboard";
+    keyboard.type               = ZONE_TYPE_MATRIX;
+    keyboard.leds_min           = zone_size;
+    keyboard.leds_max           = zone_size;
+    keyboard.leds_count         = zone_size;
+    keyboard.matrix_map         = new matrix_map_type;
+    keyboard.matrix_map->height = 6;
+    keyboard.matrix_map->width  = 23;
+    keyboard.matrix_map->map    = AsusTUFK7Layouts[layout].matrix_map;
+    zones.push_back(keyboard);
+
+    total_led_count += zone_size;
 
-        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];
+        new_led.name = AsusTUFK7Layouts[layout].led_names[led_idx];
         leds.push_back(new_led);
     }
 
@@ -465,6 +319,14 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
 
         mode_colors = modes[active_mode].color_mode == MODE_COLORS_PER_LED ? std::vector<RGBColor>(colors) : std::vector<RGBColor>(modes[active_mode].colors);
 
-        aura->UpdateDevice(modes[active_mode].value, mode_colors, direction, color_mode, (15 - modes[active_mode].speed));
+        aura->UpdateDevice(modes[active_mode].value, mode_colors, direction, color_mode, (15 - modes[active_mode].speed), modes[active_mode].brightness * 25);
     }
 }
+
+void RGBController_AuraTUFKeyboard::DeviceSaveMode()
+{
+    aura->ClearResponses();
+    DeviceUpdateMode();
+    aura->AwaitResponse();
+    aura->SaveMode();
+}

Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h

@@ -11,6 +11,16 @@
 #include "RGBController.h"
 #include "AsusAuraTUFKeyboardController.h"
 
+enum
+{
+	AURA_KEYBOARD_SPEED_MIN          = 0,
+	AURA_KEYBOARD_SPEED_MAX          = 15,
+	AURA_KEYBOARD_SPEED_DEFAULT      = 8,
+	AURA_KEYBOARD_BRIGHTNESS_MIN     = 0,
+	AURA_KEYBOARD_BRIGHTNESS_MAX     = 4,
+	AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4
+};
+
 class RGBController_AuraTUFKeyboard : public RGBController
 {
 public:
@@ -27,6 +37,7 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
     AuraTUFKeyboardController*  aura;

Controllers/AsusTUFLaptopController/AsusTUFLaptopWMIDetect.cpp

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

Controllers/CoolerMasterController/CMARGBcontroller.cpp

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

Controllers/CoolerMasterController/CMARGBcontroller.h

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

Controllers/CoolerMasterController/CMMM711Controller.cpp

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

Controllers/CoolerMasterController/CMMM711Controller.h

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

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -19,7 +19,9 @@
 #define COOLERMASTER_VID                        0x2516
 
 #define COOLERMASTER_MM711_PID                  0x0101
+#define COOLERMASTER_MM720_PID                  0x0141
 #define COOLERMASTER_MP750_XL_PID               0x0109
+#define COOLERMASTER_MP750_L_PID                0x0107
 #define COOLERMASTER_MP750_MEDIUM_PID           0x0105
 #define COOLERMASTER_ARGB_PID                   0x1011
 #define COOLERMASTER_SMALL_ARGB_PID             0x1000
@@ -45,9 +47,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,7 +137,9 @@ 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 Large",              DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_L_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);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L White",   DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID,    1,      0xFF00, 1);

Controllers/CoolerMasterController/RGBController_CMARGBController.cpp

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

Controllers/CoolerMasterController/RGBController_CMMM711Controller.cpp

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

Controllers/CoolerMasterController/RGBController_CMMM711Controller.h

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

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -265,7 +265,7 @@ void CorsairLightingNodeController::SendDirect
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
+    hid_read_timeout(dev, usb_buf, 17, 1);
 }
 
 void CorsairLightingNodeController::SendCommit()
@@ -293,7 +293,7 @@ void CorsairLightingNodeController::SendCommit()
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
+    hid_read_timeout(dev, usb_buf, 17, 1);
 }
 
 void CorsairLightingNodeController::SendBegin
@@ -456,7 +456,7 @@ void CorsairLightingNodeController::SendPortState
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
+    hid_read_timeout(dev, usb_buf, 17, 1);
 }
 
 void CorsairLightingNodeController::SendBrightness

Controllers/CorsairPeripheralController/CorsairK100Controller.cpp

@@ -14,7 +14,7 @@ static unsigned int keys_k100[] = {0x25, 0x31, 0x27, 0x35, 0x66, 0x65, 0x41, 0x2
                                    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
+                                   0x4B, 0x54, 0x5F, 0x60, 0x2E, 0x7C,
                                    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,
@@ -80,22 +80,59 @@ void CorsairK100Controller::LightingControl()
 {
     unsigned char usb_buf[65];
     memset(usb_buf, 0x00, sizeof(usb_buf));
+    //This is requered
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x01;
+    usb_buf[0x03] = 0x03;
+    usb_buf[0x05] = 0x02;
+
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x01;
+    usb_buf[0x03] = 0x4A;
+    usb_buf[0x05] = 0x01;
+
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x01;
+    usb_buf[0x03] = 0x45;
+    usb_buf[0x05] = 0x00;
+
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    //This is requered
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x0D;
+    usb_buf[0x03] = 0x01;
+    usb_buf[0x04] = 0x22;
+
+    hid_write(dev, (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);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 
     memset(usb_buf, 0x00, sizeof(usb_buf));
 
     int res = hid_read_timeout(dev, usb_buf, 50, 1000);
 
-    if (res == 0 || usb_buf[1] != 0x05)
+    if (res == 0 || usb_buf[1] != 0x01)
     {
-        LOG_INFO("[Corsair-K100] This device did not allow to take control over it.");
+        LOG_INFO("[Corsair-K100] This device did not allow to take control over it. recieved response: %02X", usb_buf[1]);
         keyboard_type = CORSAIR_TYPE_UNKNOWN;
-    }
+    }*/
+
 }
 
 void CorsairK100Controller::SetLEDs(std::vector<RGBColor>colors)
@@ -116,7 +153,6 @@ 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;

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -8,6 +8,7 @@
 \*-----------------------------------------*/
 
 #include "CorsairPeripheralController.h"
+#include "LogManager.h"
 
 #include <cstring>
 
@@ -60,6 +61,8 @@ static unsigned int st100[] = { 0x00, 0x01, 0x02, 0x03, 0x05, 0x06, 0x07, 0x08,
 static unsigned int key_mapping_k95_plat_ansi[] = { 0x31, 0x3f, 0x41, 0x42, 0x51, 0x53, 0x55, 0x6f, 0x7e, 0x7f, 0x80, 0x81 };
 static unsigned int key_mapping_k95_plat_iso[] = { 0x3f, 0x41, 0x42, 0x48, 0x50, 0x53, 0x55, 0x6f, 0x7e, 0x7f, 0x80, 0x81 };
 
+#define CORSAIR_PERIPHERAL_CONTROLLER_NAME "Corsair peripheral"
+
 CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle, const char* path)
 {
     dev         = dev_handle;
@@ -213,7 +216,7 @@ 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)
+        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);
@@ -532,7 +535,9 @@ void CorsairPeripheralController::ReadFirmwareInfo()
     |   0xC0    Device is a keyboard                        |
     |   0xC1    Device is a mouse                           |
     |   0xC2    Device is a mousepad or headset stand       |
-    \*-----------------------------------------------------*/
+    \*-----------------------------------------------------*/    
+    LOG_DEBUG("[%s] Device type %02X", CORSAIR_PERIPHERAL_CONTROLLER_NAME, (unsigned char)usb_buf[0x14 + offset]);
+
     switch((unsigned char)usb_buf[0x14 + offset])
     {
         case 0xC0:

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -1,11 +1,14 @@
 #include "Detector.h"
 #include "CorsairPeripheralController.h"
 #include "CorsairK100Controller.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_CorsairPeripheral.h"
 #include "RGBController_CorsairK100.h"
 #include <hidapi/hidapi.h>
 
+#define CORSAIR_PERIPHERAL_CONTROLLER_NAME "Corsair peripheral"
+
 /*-----------------------------------------------------*\
 | Corsair vendor ID                                     |
 \*-----------------------------------------------------*/
@@ -35,6 +38,7 @@
 #define CORSAIR_K95_PLATINUM_PID        0x1B2D
 
 #define CORSAIR_STRAFE_PID              0x1B20
+#define CORSAIR_STRAFE_RED_PID          0x1B44
 #define CORSAIR_STRAFE_MK2_PID          0x1B48
 
 /*-----------------------------------------------------*\
@@ -45,6 +49,8 @@
 #define CORSAIR_GLAIVE_RGB_PRO_PID      0x1B74
 #define CORSAIR_HARPOON_RGB_PID         0x1B3C
 #define CORSAIR_HARPOON_RGB_PRO_PID     0x1B75
+#define CORSAIR_IRONCLAW_RGB_PID        0x1B5D
+#define CORSAIR_M65_PID                 0x1B12
 #define CORSAIR_M65_PRO_PID             0x1B2E
 #define CORSAIR_M65_RGB_ELITE_PID       0x1B5A
 #define CORSAIR_SCIMITAR_PRO_RGB_PID    0x1B3E
@@ -102,6 +108,8 @@ void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string
 
     if(dev)
     {
+        LOG_DEBUG("[%s] Device opened. VID/PID %02X:%02X", CORSAIR_PERIPHERAL_CONTROLLER_NAME, info->vendor_id , info->product_id);
+
         CorsairPeripheralController* controller = new CorsairPeripheralController(dev, info->path);
         controller->SetName(name);
 
@@ -112,6 +120,7 @@ void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string
         }
         else
         {
+            LOG_DEBUG("[%s] Device type is unknown", CORSAIR_PERIPHERAL_CONTROLLER_NAME);
             delete controller;
         }
     }
@@ -134,6 +143,7 @@ REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2 Low Profile", DetectCorsairPeriph
 REGISTER_HID_DETECTOR_IP("Corsair K95 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_RGB_PID,           1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K95 RGB PLATINUM",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_PLATINUM_PID,      1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Strafe",                   DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_PID,            1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Strafe Red",               DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_RED_PID,        1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Strafe MK.2",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_MK2_PID,        1, 0xFFC2);
 /*-----------------------------------------------------------------------------------------------------*\
 | Mice                                                                                                  |
@@ -142,6 +152,8 @@ REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB",               DetectCorsairPeriph
 REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB PRO",           DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PRO_PID,    1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PID,       1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB PRO",          DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PRO_PID,   1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair Ironclaw RGB",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_IRONCLAW_RGB_PID,      1, 0xFFC2);
+REGISTER_HID_DETECTOR_IP("Corsair M65",                      DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_PID,               1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair M65 PRO",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_PRO_PID,           1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair M65 RGB Elite" ,           DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_RGB_ELITE_PID,     1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair Scimitar PRO RGB",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_PRO_RGB_PID,  1, 0xFFC2);
@@ -167,4 +179,4 @@ REGISTER_HID_DETECTOR_I("Corsair ST100 RGB",                DetectCorsairPeriphe
 /*-----------------------------------------------------------------------------------------------------*\
 | Corsair K100 Keyboard                                                                                 |
 \*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair K100",                    DetectCorsairK100Controllers,       CORSAIR_VID, CORSAIR_K100_PID,              1, 0xFF42);
+REGISTER_HID_DETECTOR_IP("Corsair K100",                    DetectCorsairK100Controllers,       CORSAIR_VID, CORSAIR_K100_PID,              1, 0xFF42);

Controllers/CorsairPeripheralController/RGBController_CorsairK100.cpp

@@ -7,6 +7,8 @@
 #include "RGBController_CorsairK100.h"
 #include "LogManager.h"
 
+using namespace std::chrono_literals;
+
 #define NA  0xFFFFFFFF
 
 static unsigned int matrix_map_k100[7][24] =
@@ -238,10 +240,25 @@ RGBController_CorsairK100::RGBController_CorsairK100(CorsairK100Controller* cors
     modes.push_back(Direct);
 
     SetupZones();
+    /*-----------------------------------------------------*\
+    | The Corsair K100 requires a packet within             |
+    | 1 minutes of sending the lighting change in order     |
+    | to not revert back into rainbow mode.  Start a thread |
+    | to continuously send a keepalive packet every 50 sec  |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = true;
+    keepalive_thread = new std::thread(&RGBController_CorsairK100::KeepaliveThread, this);
 }
 
 RGBController_CorsairK100::~RGBController_CorsairK100()
 {
+    /*-----------------------------------------------------*\
+    | Close keepalive thread                                |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = false;
+    keepalive_thread->join();
+    delete keepalive_thread;
+
     /*---------------------------------------------------------*\
     | Delete the matrix map                                     |
     \*---------------------------------------------------------*/
@@ -314,6 +331,8 @@ void RGBController_CorsairK100::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_CorsairK100::DeviceUpdateLEDs()
 {
+    last_update_time = std::chrono::steady_clock::now();
+
     corsair->SetLEDs(colors);
 }
 
@@ -336,3 +355,18 @@ void RGBController_CorsairK100::DeviceUpdateMode()
 {
 
 }
+
+void RGBController_CorsairK100::KeepaliveThread()
+{
+    while(keepalive_thread_run.load())
+    {
+        if(active_mode == 0)
+        {
+            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50000))
+            {
+                DeviceUpdateLEDs();
+            }
+        }
+        std::this_thread::sleep_for(3000ms);
+    }
+}

Controllers/CorsairPeripheralController/RGBController_CorsairK100.h

@@ -25,10 +25,16 @@ public:
 
     void DeviceUpdateMode();
     void SetCustomMode();
+    void        KeepaliveThread();
 
 private:
-    CorsairK100Controller*  corsair;
-    CorsairKeyboardType     logical_layout;
+    CorsairK100Controller*          corsair;
+    CorsairKeyboardType             logical_layout;
+
+    std::thread*                    keepalive_thread;
+    std::atomic<bool>               keepalive_thread_run;
+    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
+
 };
 
 #endif // RGBCONTROLLER_CORSAIRK100_H

Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.cpp

@@ -1013,6 +1013,10 @@ void RGBController_CorsairPeripheral::SetupZones()
                 {
                     new_led.name = corsair_harpoon_pro_leds[led_idx];
                 }
+                if(name == "Corsair Ironclaw RGB")
+                {
+                    new_led.name = corsair_m65_elite_leds[led_idx];
+                }
                 else if(name == "Corsair Sabre RGB")
                 {
                     new_led.name = corsair_sabre_rgb_leds[led_idx];

Controllers/CorsairWirelessController/RGBController_CorsairWireless.cpp

@@ -206,12 +206,18 @@ RGBController_CorsairWireless::RGBController_CorsairWireless(CorsairWirelessCont
     | to not revert back into rainbow mode.  Start a thread |
     | to continuously send a keepalive packet every 5s      |
     \*-----------------------------------------------------*/
-    keepalive_thread_run = 1;
+    keepalive_thread_run = true;
     keepalive_thread = new std::thread(&RGBController_CorsairWireless::KeepaliveThread, this);
 }
 
 RGBController_CorsairWireless::~RGBController_CorsairWireless()
 {
+    /*-----------------------------------------------------*\
+    | Close keepalive thread                                |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = false;
+    keepalive_thread->join();
+    delete keepalive_thread;
     /*---------------------------------------------------------*\
     | Delete the matrix map                                     |
     \*---------------------------------------------------------*/

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

@@ -0,0 +1,97 @@
+/*-----------------------------------------*\
+|  DygmaRaiseController.cpp                 |
+|                                           |
+|  Driver for Dygma Raise keyboard          |
+|                                           |
+|  Timo Schlegel (@eispalast) 12/12/2021    |
+\*-----------------------------------------*/
+
+#include "DygmaRaiseController.h"
+
+using namespace std::chrono_literals;
+
+static int val_char_len(int number)
+{
+    if(number < 10)
+    {
+        return 1;
+    }
+    else if
+    (number < 100)
+    {
+        return 2;
+    }
+    else
+    {
+        return 3;
+    }
+}
+
+DygmaRaiseController::DygmaRaiseController() 
+{
+   
+}
+
+DygmaRaiseController::~DygmaRaiseController() 
+{   
+    serialport->serial_close();
+    delete serialport;
+}
+
+void DygmaRaiseController::Initialize(char* port)
+{
+    port_name = port;
+    
+    serialport = new serial_port(port_name.c_str(), DYGMA_RAISE_BAUD);
+}
+
+std::string DygmaRaiseController::GetDeviceLocation() 
+{
+    return("COM: " + port_name);
+}
+
+void DygmaRaiseController::SendDirect(std::vector<RGBColor>colors, size_t led_num)
+{    
+    char serial_buf[MAX_LEN];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(serial_buf,0x00,sizeof(serial_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up led theme packet                               |
+    \*-----------------------------------------------------*/
+    sprintf(serial_buf,"led.theme");
+    int actual_length=9;
+
+    /*-----------------------------------------------------*\
+    | Fill packet with color values                         |
+    \*-----------------------------------------------------*/
+    for(std::size_t led_idx = 0; led_idx < led_num; led_idx++)
+    {
+        int r = RGBGetRValue(colors[led_idx]);
+        int g = RGBGetGValue(colors[led_idx]);
+        int b = RGBGetBValue(colors[led_idx]);
+
+        sprintf(serial_buf+actual_length," %d",r);
+        actual_length += val_char_len(r) + 1;
+        
+        sprintf(serial_buf+actual_length," %d",g);
+        actual_length += val_char_len(g) + 1;
+
+        sprintf(serial_buf+actual_length," %d",b);
+        actual_length += val_char_len(b) + 1;
+    }
+
+    /*-----------------------------------------------------*\
+    | Add the final newline                                 |
+    \*-----------------------------------------------------*/
+    sprintf(serial_buf+actual_length,"\n");
+    actual_length++;    
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    serialport->serial_write(serial_buf, actual_length);
+}

Controllers/DygmaRaiseController/DygmaRaiseController.h

@@ -0,0 +1,36 @@
+/*-----------------------------------------*\
+|  DygmaRaiseController.h                   |
+|                                           |
+|  Driver for Dygma Raise keyboard          |
+|                                           |
+|   Timo Schlegel (@eispalast) 12/12/2021   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include <string>
+#include <vector>
+#include "serial_port.h"
+
+#pragma once
+
+#define DYGMA_RAISE_VID 0x1209
+#define DYGMA_RAISE_PID 0x2201
+
+#define DYGMA_RAISE_BAUD 115200
+#define MAX_LEN (4*3*132+9) //max. 4 Bytes per led channel * 3 channels * 132 leds + codeword led.theme
+
+class DygmaRaiseController
+{
+public:
+    DygmaRaiseController();
+    ~DygmaRaiseController();
+
+    void Initialize(char* port);
+    std::string GetDeviceLocation();
+    void SendDirect(std::vector<RGBColor>colors, size_t led_num);
+private:
+    std::string                 location;
+    std::string                 port_name;
+    serial_port *               serialport = nullptr;
+};

Controllers/DygmaRaiseController/DygmaRaiseControllerDetect.cpp

@@ -0,0 +1,39 @@
+#include "Detector.h"
+#include "DygmaRaiseController.h"
+#include "RGBController.h"
+#include "RGBController_DygmaRaise.h"
+#include "find_usb_serial_port.h"
+#include <vector>
+#include <stdio.h>
+
+
+#define DYGMA_RAISE_VID 0x1209
+#define DYGMA_RAISE_PID 0x2201
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectDygmaRaiseControllers                                                            *
+*                                                                                          *
+*       Tests the USB address to see if a DygmaRaise keyboard exists there.                *
+*       Then opens a serial port to communicate with the KB                                *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectDygmaRaiseControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    std::vector<std::string *> ports = find_usb_serial_port(DYGMA_RAISE_VID, DYGMA_RAISE_PID);
+
+    for(std::size_t i = 0; i < ports.size(); i++)
+    {
+        if(*ports[i] != "")
+        {
+            DygmaRaiseController*     controller     = new DygmaRaiseController();
+            controller->Initialize((char *)ports[i]->c_str());
+
+            RGBController_DygmaRaise* rgb_controller = new RGBController_DygmaRaise(controller);
+            rgb_controllers.push_back(rgb_controller);
+        }
+    }
+}
+
+REGISTER_DETECTOR("Dygma Raise", DetectDygmaRaiseControllers);

Controllers/DygmaRaiseController/RGBController_DygmaRaise.cpp

@@ -0,0 +1,249 @@
+/*-----------------------------------------*\
+|  RGBController_DygmaRaise.cpp             |
+|                                           |
+|  RGB Interface DygmaRaise keyboard        |
+|                                           |
+|  Timo Schlegel (@eispalast) 12/12/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController_DygmaRaise.h"
+
+#define NA              0xFFFFFFFF
+#define LED_REAL_COUNT  ((6*14)+(12*14))
+#define LED_COUNT       (LED_REAL_COUNT - 121)
+
+static unsigned int kb_matrix_map_ISO[6][14] =
+    { {  0,  1,  2,  3,  4,  5,  6, 39, 38, 37, 36, 35, 34, 33 },
+      {  7,  8,  9, 10, 11, 12, 47, 46, 45, 44, 43, 42, 41, 40 },
+      { 13, 14, 15, 16, 17, 18, 54, 53, 52, 51, 50, 49, 48, NA },
+      { 19, 20, 21, 22, 23, 24, 25, 60, 59, 58, 57, 56, 55, NA }, 
+      { 26, 27, 28, NA, 29, 30, NA, 66, 65, NA, 64, 63, 62, 61 }, 
+      { NA, NA, NA, NA, 31, 32, NA, 68, 67, NA, NA, NA, NA, NA } };
+
+static unsigned int underglow_matrix[11][14] =
+    { { 2, 3 , 4, 5  , 6 , 7,  NA, 38, 37, 36, 35, 34, 33, 32}, 
+      { 1, NA, NA, NA, NA, 8,  NA, 39, NA, NA, NA, NA, NA, 31  }, 
+      { 0, NA, NA, NA, NA, 9,  NA, 40, NA, NA, NA, NA, NA, 30  }, 
+      { 29, NA, NA, NA, NA, 10,NA, 41, NA, NA, NA, NA, NA, 61  }, 
+      { 28, NA, NA, NA, NA, 11,NA, 42, NA, NA, NA, NA, NA, 60  }, 
+      { 27, NA, NA, NA, NA, 12,NA, 43, NA, NA, NA, NA, NA, 59  }, 
+      { 26, NA, NA, NA, NA, 13,NA, 44, NA, NA, NA, NA, NA, 58  }, 
+      { 25, NA, NA, NA, NA, 14,NA, 45, NA, NA, NA, NA, NA, 57  }, 
+      { 24, NA, NA, NA, NA, 15,NA, 46, NA, NA, NA, NA, NA, 56  }, 
+      { 23, NA, NA, NA, NA, 16,NA, 47, NA, NA, NA, NA, NA, 55  }, 
+      { 22, 21, 20, 19, 18, 17,NA, 48,49,50,51,52,53, 54, }};
+
+
+static const char* zone_names[] =
+{
+    "Keyboard",
+    "Underglow",
+    "Neuron",
+};
+
+static zone_type zone_types[] =
+{
+    ZONE_TYPE_MATRIX,
+    ZONE_TYPE_MATRIX,
+    ZONE_TYPE_SINGLE,
+};
+
+static const unsigned int zone_sizes[] =
+{
+    69,
+    62,
+    1,
+};
+
+static const char* led_names[] =
+{
+    "Key: Escape",
+    "Key: 1",                           
+    "Key: 2",                      
+    "Key: 3",                      
+    "Key: 4",                      
+    "Key: 5",                      
+    "Key: 6",                      
+    "Key: Tab",                    
+    "Key: Q",                      
+    "Key: W",                      
+    "Key: E",                      
+    "Key: R",                      
+    "Key: T",                      
+    "Key: Caps Lock",              
+    "Key: A",                      
+    "Key: S",                      
+    "Key: D",                      
+    "Key: F",                      
+    "Key: G",                      
+    "Key: Left Shift",             
+    "Key: \\ (ISO)",               
+    "Key: Z",                      
+    "Key: X",                      
+    "Key: C",                      
+    "Key: V",                      
+    "Key: B",                      
+    "Key: Left Control",           
+    "Key: Left Windows",           
+    "Key: Left Alt",               
+    "Key: T1",                     
+    "Key: T2",                     
+    "Key: T3",                     
+    "Key: T4",                     
+    "Key: Backspace",              
+    "Key: =",                      
+    "Key: -",                      
+    "Key: 0",                      
+    "Key: 9",                      
+    "Key: 8",                      
+    "Key: 7",                      
+    "Key: Enter",                  
+    "Key: ]",                      
+    "Key: [",                      
+    "Key: P",                      
+    "Key: O",                      
+    "Key: I",                      
+    "Key: U",                      
+    "Key: Y",                      
+    "Key: #",                      
+    "Key: '",                      
+    "Key: ;",                      
+    "Key: L",                      
+    "Key: K",                      
+    "Key: J",                      
+    "Key: H",                      
+    "Key: Right Shift",            
+    "Key: /",                      
+    "Key: .",                      
+    "Key: ,",                      
+    "Key: M",                      
+    "Key: N",                      
+    "Key: Right Control",          
+    "Key: Right Windows",          
+    "Key: Right Fn",               
+    "Key: Right Alt",              
+    "Key: T6",                     
+    "Key: T5",                     
+    "Key: T8",                     
+    "Key: T7",             
+};
+
+RGBController_DygmaRaise::RGBController_DygmaRaise(DygmaRaiseController* controller_ptr) 
+{
+    controller      = controller_ptr;
+
+    name            = "Raise";
+    vendor          = "Dygma";
+    type            = DEVICE_TYPE_KEYBOARD;
+    description     = "Dygma Raise Split Mech KB";
+    location        = controller->GetDeviceLocation();
+
+    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_DygmaRaise::~RGBController_DygmaRaise() 
+{
+    delete controller;
+}
+
+void RGBController_DygmaRaise::SetupZones() 
+{
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    for(size_t i=0; i<3; i++)
+    {
+        zone new_zone;
+        new_zone.name                   = zone_names[i];
+        new_zone.type                   = zone_types[i];
+        new_zone.leds_min               = zone_sizes[i];
+        new_zone.leds_max               = zone_sizes[i];
+        new_zone.leds_count             = zone_sizes[i];
+
+        if(i==0)
+        {
+            new_zone.matrix_map             = new matrix_map_type;
+            new_zone.matrix_map->height     = 6;
+            new_zone.matrix_map->width      = 14;
+            new_zone.matrix_map->map        = (unsigned int *)&kb_matrix_map_ISO;
+        }
+        else if(i==1)
+        {
+            new_zone.matrix_map             = new matrix_map_type;
+            new_zone.matrix_map->height     = 11;
+            new_zone.matrix_map->width      = 14;
+            new_zone.matrix_map->map        = (unsigned int *)&underglow_matrix;
+        }
+        
+        zones.push_back(new_zone);
+    }
+    
+    /*---------------------------------------------------------*\
+    | Set up keyboard LEDs                                      |
+    \*---------------------------------------------------------*/
+    for(unsigned int led_idx = 0; led_idx < zone_sizes[0]; led_idx++)
+    {
+        led new_led;
+        new_led.name  = led_names[led_idx];
+        leds.push_back(new_led);
+    }
+
+    /*---------------------------------------------------------*\
+    | Set up underglow LEDs                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int led_idx = 0; led_idx < zone_sizes[1]; led_idx++)
+    {
+        led new_led;
+        new_led.name  = "Underglow";
+        leds.push_back(new_led);
+    }
+
+    /*---------------------------------------------------------*\
+    | Set up Neuron LED                                         |
+    \*---------------------------------------------------------*/
+    led new_led;
+    new_led.name = "Neuron";
+    leds.push_back(new_led);
+
+    SetupColors();
+}
+
+void RGBController_DygmaRaise::ResizeZone(int /*zone*/, int /*new_size*/) 
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+
+void RGBController_DygmaRaise::DeviceUpdateLEDs() 
+{
+    controller->SendDirect(colors,leds.size());
+}
+
+void RGBController_DygmaRaise::UpdateZoneLEDs(int /*zone*/) 
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_DygmaRaise::UpdateSingleLED(int /*led*/) 
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_DygmaRaise::SetCustomMode() 
+{
+    active_mode = 0;
+}
+
+void RGBController_DygmaRaise::DeviceUpdateMode() 
+{
+    
+}

Controllers/DygmaRaiseController/RGBController_DygmaRaise.h

@@ -0,0 +1,31 @@
+/*-----------------------------------------*\
+|  RGBController_DygmaRaise.h               |
+|                                           |
+|  RGB Interface for  DygmaRaise keyboard   |
+|                                           |
+|   Timo Schlegel (@eispalast) 12/12/2021   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "DygmaRaiseController.h"
+
+class RGBController_DygmaRaise : public RGBController
+{
+public:
+    RGBController_DygmaRaise(DygmaRaiseController* controller_ptr);
+    ~RGBController_DygmaRaise();
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    DygmaRaiseController*   controller;
+};

Controllers/E131Controller/E131ControllerDetect.cpp

@@ -154,7 +154,7 @@ void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers)
                     }
                     else if(rgb_order_val == "BRG")
                     {
-                        dev.rgb_order = E131_RGB_ORDER_BGR;
+                        dev.rgb_order = E131_RGB_ORDER_BRG;
                     }
                     else if(rgb_order_val == "BGR")
                     {

Controllers/ENESMBusController/ENESMBusController.cpp

@@ -0,0 +1,374 @@
+/*-----------------------------------------*\
+|  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(ENESMBusInterface* interface, ene_dev_id dev)
+{
+    this->interface = interface;
+    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()
+{
+    delete interface;
+}
+
+std::string ENESMBusController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string ENESMBusController::GetDeviceLocation()
+{
+    std::string return_string = interface->GetLocation();
+
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+
+    return(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:
+    case (unsigned char)ENE_LED_CHANNEL_DRAM_2:
+        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(RGBColor* colors)
+{
+    unsigned char* color_buf   = new unsigned char[led_count * 3];
+    unsigned int   bytes_sent  = 0;
+
+    for(unsigned int i = 0; i < (led_count * 3); i += 3)
+    {
+        color_buf[i + 0] = RGBGetRValue(colors[i / 3]);
+        color_buf[i + 1] = RGBGetBValue(colors[i / 3]);
+        color_buf[i + 2] = RGBGetGValue(colors[i / 3]);
+    }
+
+    while(bytes_sent < (led_count * 3))
+    {
+        unsigned int bytes_to_send = (led_count * 3) - bytes_sent;
+
+        if(bytes_to_send > interface->GetMaxBlock())
+        {
+            bytes_to_send = interface->GetMaxBlock();
+        }
+
+        ENERegisterWriteBlock(direct_reg + bytes_sent, &color_buf[bytes_sent], bytes_to_send);
+
+        bytes_sent += bytes_to_send;
+    }
+
+    delete color_buf;
+}
+
+void ENESMBusController::SetAllColorsEffect(RGBColor* colors)
+{
+    unsigned char* color_buf   = new unsigned char[led_count * 3];
+    unsigned int   bytes_sent  = 0;
+
+    for(unsigned int i = 0; i < (led_count * 3); i += 3)
+    {
+        color_buf[i + 0] = RGBGetRValue(colors[i / 3]);
+        color_buf[i + 1] = RGBGetBValue(colors[i / 3]);
+        color_buf[i + 2] = RGBGetGValue(colors[i / 3]);
+    }
+
+    while(bytes_sent < (led_count * 3))
+    {
+        unsigned int bytes_to_send = (led_count * 3) - bytes_sent;
+
+        if(bytes_to_send > interface->GetMaxBlock())
+        {
+            bytes_to_send = interface->GetMaxBlock();
+        }
+
+        ENERegisterWriteBlock(effect_reg + bytes_sent, &color_buf[bytes_sent], bytes_to_send);
+
+        bytes_sent += bytes_to_send;
+    }
+
+    ENERegisterWrite(ENE_REG_APPLY, ENE_APPLY_VAL);
+    
+    delete color_buf;
+}
+
+
+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)
+{
+    return(interface->ENERegisterRead(dev, reg));
+}
+
+void ENESMBusController::ENERegisterWrite(ene_register reg, unsigned char val)
+{
+    interface->ENERegisterWrite(dev, reg, val);
+}
+
+void ENESMBusController::ENERegisterWriteBlock(ene_register reg, unsigned char * data, unsigned char sz)
+{
+    interface->ENERegisterWriteBlock(dev, reg, data, sz);
+}

Controllers/ENESMBusController/ENESMBusController.h

@@ -0,0 +1,138 @@
+/*-----------------------------------------*\
+|  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 "ENESMBusInterface.h"
+#include "RGBController.h"
+
+#pragma once
+
+#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(ENESMBusInterface* interface, 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(RGBColor* colors);
+    void          SetAllColorsEffect(RGBColor* colors);
+    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;
+    ENESMBusInterface*      interface;
+    ene_dev_id              dev;
+
+};

Controllers/ENESMBusController/ENESMBusControllerDetect.cpp

@@ -0,0 +1,384 @@
+#include "Detector.h"
+#include "ENESMBusController.h"
+#include "ENESMBusInterface_i2c_smbus.h"
+#include "ENESMBusInterface_SpectrixS40G.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;
+
+/*----------------------------------------------------------------------*\
+| Windows defines "interface" for some reason.  Work around this         |
+\*----------------------------------------------------------------------*/
+#ifdef interface
+#undef interface
+#endif
+
+/*----------------------------------------------------------------------*\
+| 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_RTX3060TI_DEV,       ASUS_SUB_VEN,       ASUS_TUF_RTX_3060_TI_O8G_OC,                0x67,   "ASUS TUF RTX 3060Ti O8G OC"                },
+    { NVIDIA_VEN,       NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3070_OC,                 0x67,   "ASUS ROG STRIX 3070 OC"                    },
+    { NVIDIA_VEN,       NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3070_O8G_WHITE,          0x67,   "ASUS ROG STRIX 3070 O8G White"             },
+    { NVIDIA_VEN,       NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3070_08G_V2_GAMING,      0x67,   "ASUS ROG STRIX 3070 O8G V2 GAMING"         },
+    { NVIDIA_VEN,       NVIDIA_RTX3070_DEV,         ASUS_SUB_VEN,       ASUS_TUF_RTX_3070_O8G_GAMING,               0x67,   "ASUS TUF RTX 3070 O8G GAMING"              },
+    { NVIDIA_VEN,       NVIDIA_RTX3070_LHR_DEV,     ASUS_SUB_VEN,       ASUS_TUF_RTX_3070_O8G_V2_GAMING,            0x67,   "ASUS TUF RTX 3070 O8G V2 GAMING"           },
+    { NVIDIA_VEN,       NVIDIA_RTX3070TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3070TI_O8G_GAMING,       0x67,   "ASUS ROG STRIX 3070Ti O8G GAMING"          },
+    { NVIDIA_VEN,       NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3080_O10G_GAMING,        0x67,   "ASUS ROG STRIX 3080 O10G GAMING"           },
+    { NVIDIA_VEN,       NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3080_O10G_WHITE,         0x67,   "ASUS ROG STRIX 3080 O10G WHITE"            },
+    { NVIDIA_VEN,       NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX_3080_O10G_V2_WHITE,      0x67,   "ASUS ROG STRIX 3080 O10G V2 WHITE"         },
+    { NVIDIA_VEN,       NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,       ASUS_TUF_RTX_3080_10G_GAMING_PD,            0x67,   "ASUS TUF RTX 3080 10G GAMING"              },
+    { NVIDIA_VEN,       NVIDIA_RTX3080_DEV,         ASUS_SUB_VEN,       ASUS_TUF_RTX_3080_O10G_OC,                  0x67,   "ASUS TUF RTX 3080 O10G OC"                 },
+    { NVIDIA_VEN,       NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,       ASUS_TUF_RTX_3080_O10G_V2_GAMING_8822,      0x67,   "ASUS TUF RTX 3080 O10G V2 GAMING"          },
+    { NVIDIA_VEN,       NVIDIA_RTX3080_LHR_DEV,     ASUS_SUB_VEN,       ASUS_TUF_RTX_3080_O10G_V2_GAMING,           0x67,   "ASUS TUF RTX 3080 O10G V2 GAMING"          },
+    { NVIDIA_VEN,       NVIDIA_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"  },
+    { NVIDIA_VEN,       NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,       ASUS_TUF_RTX_3090_O24G,                     0x67,   "ASUS TUF RTX 3090 O24G"                    },
+    { NVIDIA_VEN,       NVIDIA_RTX3090_DEV,         ASUS_SUB_VEN,       ASUS_TUF_RTX_3090_O24G_OC,                  0x67,   "ASUS TUF RTX 3090 O24G OC"                 },
+};
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   ENERegisterRead                                                                        *
+*                                                                                          *
+*       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]))
+                {
+                    ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(busses[bus]);
+                    ENESMBusController*          controller     = new ENESMBusController(interface, 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;
+
+                        ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(busses[bus]);
+                        ENESMBusController*          controller     = new ENESMBusController(interface, 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))
+                {
+                    ENESMBusInterface_i2c_smbus* interface      = new ENESMBusInterface_i2c_smbus(busses[bus]);
+                    ENESMBusController*          controller     = new ENESMBusController(interface, device_list[dev_idx].controller_address);
+                    RGBController_ENESMBus*      rgb_controller = new RGBController_ENESMBus(controller);
+
+                    rgb_controller->name = 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/ENESMBusInterface/ENESMBusInterface.h

@@ -0,0 +1,24 @@
+/*-----------------------------------------*\
+|  ENESMBusInterface.h                      |
+|                                           |
+|  Definitions and types for ENE interface  |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 11/21/2021  |
+\*-----------------------------------------*/
+
+#include <string>
+
+#pragma once
+
+typedef unsigned short	ene_register;
+typedef unsigned char	ene_dev_id;
+
+class ENESMBusInterface
+{
+public:
+    virtual std::string   GetLocation() = 0;
+    virtual int           GetMaxBlock() = 0;
+    virtual unsigned char ENERegisterRead(ene_dev_id dev, ene_register reg) = 0;
+    virtual void          ENERegisterWrite(ene_dev_id dev, ene_register reg, unsigned char val) = 0;
+    virtual void          ENERegisterWriteBlock(ene_dev_id dev, ene_register reg, unsigned char * data, unsigned char sz) = 0;
+};

Controllers/ENESMBusController/ENESMBusInterface/ENESMBusInterface_SpectrixS40G.cpp

@@ -0,0 +1,201 @@
+/*-----------------------------------------*\
+|  ENESMBusInterface_SpectrixS40G.cpp       |
+|                                           |
+|  Code for ENE XPG Spectrix S40G NVMe      |
+|  interface                                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 11/21/2021  |
+\*-----------------------------------------*/
+
+#include "ENESMBusInterface_SpectrixS40G.h"
+#include <sys/ioctl.h>
+#include <cstring>
+
+/*---------------------------------------------------------------------*\
+| Functions for submitting NVME admin passthrough command taken from    |
+| libnvme: https://github.com/linux-nvme/libnvme                        |
+\*---------------------------------------------------------------------*/
+
+#define NVME_IOCTL_ADMIN_CMD	_IOWR('N', 0x41, struct nvme_passthru_cmd)
+
+struct nvme_passthru_cmd
+{
+    uint8_t     opcode;
+    uint8_t     flags;
+	uint16_t    rsvd1;
+	uint32_t    nsid;
+	uint32_t    cdw2;
+	uint32_t    cdw3;
+	uint64_t    metadata;
+	uint64_t    addr;
+	uint32_t    metadata_len;
+	uint32_t    data_len;
+	uint32_t    cdw10;
+	uint32_t    cdw11;
+	uint32_t    cdw12;
+	uint32_t    cdw13;
+	uint32_t    cdw14;
+	uint32_t    cdw15;
+	uint32_t    timeout_ms;
+	uint32_t    result;
+};
+
+static int nvme_submit_passthru(int fd, unsigned long ioctl_cmd,
+				struct nvme_passthru_cmd *cmd, uint32_t *result)
+{
+	int err = ioctl(fd, ioctl_cmd, cmd);
+
+	if (err >= 0 && result)
+		*result = cmd->result;
+	return err;
+}
+
+static int nvme_passthru(int fd, unsigned long ioctl_cmd, uint8_t opcode,
+			 uint8_t flags, uint16_t rsvd, uint32_t nsid, uint32_t cdw2,
+			 uint32_t cdw3, uint32_t cdw10, uint32_t cdw11, uint32_t cdw12,
+			 uint32_t cdw13, uint32_t cdw14, uint32_t cdw15, uint32_t data_len,
+			 void *data, uint32_t metadata_len, void *metadata,
+			 uint32_t timeout_ms, uint32_t *result)
+{
+	struct nvme_passthru_cmd cmd = {
+		.opcode		= opcode,
+		.flags		= flags,
+		.rsvd1		= rsvd,
+		.nsid		= nsid,
+		.cdw2		= cdw2,
+		.cdw3		= cdw3,
+		.metadata	= (uint64_t)(uintptr_t)metadata,
+		.addr		= (uint64_t)(uintptr_t)data,
+		.metadata_len	= metadata_len,
+		.data_len	= data_len,
+		.cdw10		= cdw10,
+		.cdw11		= cdw11,
+		.cdw12		= cdw12,
+		.cdw13		= cdw13,
+		.cdw14		= cdw14,
+		.cdw15		= cdw15,
+		.timeout_ms	= timeout_ms,
+	};
+
+	return nvme_submit_passthru(fd, ioctl_cmd, &cmd, result);
+}
+
+int nvme_admin_passthru(int fd, uint8_t opcode, uint8_t flags, uint16_t rsvd,
+			uint32_t nsid, uint32_t cdw2, uint32_t cdw3, uint32_t cdw10,
+			uint32_t cdw11, uint32_t cdw12, uint32_t cdw13, uint32_t cdw14,
+			uint32_t cdw15, uint32_t data_len, void *data,
+			uint32_t metadata_len, void *metadata, uint32_t timeout_ms,
+			uint32_t *result)
+{
+	return nvme_passthru(fd, NVME_IOCTL_ADMIN_CMD, opcode, flags, rsvd,
+			     nsid, cdw2, cdw3, cdw10, cdw11, cdw12, cdw13,
+			     cdw14, cdw15, data_len, data, metadata_len,
+			     metadata, timeout_ms, result);
+}
+
+/*---------------------------------------------------------------------*\
+| ENESMBusInterface_SpectrixS40G implementation                         |
+\*---------------------------------------------------------------------*/
+
+ENESMBusInterface_SpectrixS40G::ENESMBusInterface_SpectrixS40G(int fd, char* path)
+{
+    this->nvme_fd = fd;
+	this->path    = path;
+}
+
+std::string ENESMBusInterface_SpectrixS40G::GetLocation()
+{
+    return("NVMe: " + path);
+}
+
+int ENESMBusInterface_SpectrixS40G::GetMaxBlock()
+{
+    return(24);
+}
+
+unsigned char ENESMBusInterface_SpectrixS40G::ENERegisterRead(ene_dev_id dev, ene_register reg)
+{
+  	struct nvme_passthru_cmd cfg;
+
+    memset(&cfg, 0, sizeof(nvme_passthru_cmd));
+
+    unsigned short corrected_reg    = ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF);
+
+    cfg.opcode                      = 0xFA;
+    cfg.cdw12                       = (corrected_reg << 16) | (dev << 1);
+    cfg.cdw13                       = 0x81100001;
+    cfg.data_len                    = 1;
+
+    unsigned char   data[1];
+    unsigned char   metadata[1];
+    unsigned int    result;
+
+    /*-----------------------------------------------------------------------------*\
+    | Send the command to the device                                                |
+    \*-----------------------------------------------------------------------------*/
+    nvme_admin_passthru(nvme_fd, cfg.opcode, cfg.flags, cfg.rsvd1,
+				cfg.nsid, cfg.cdw2, cfg.cdw3, cfg.cdw10,
+				cfg.cdw11, cfg.cdw12, cfg.cdw13, cfg.cdw14,
+				cfg.cdw15, cfg.data_len, data, cfg.metadata_len,
+				metadata, cfg.timeout_ms, &result);
+
+    return(data[0]);
+}
+
+void ENESMBusInterface_SpectrixS40G::ENERegisterWrite(ene_dev_id dev, ene_register reg, unsigned char val)
+{
+  	struct nvme_passthru_cmd cfg;
+
+    memset(&cfg, 0, sizeof(nvme_passthru_cmd));
+
+    unsigned short corrected_reg    = ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF);
+
+    cfg.opcode                      = 0xFB;
+    cfg.cdw12                       = (corrected_reg << 16) | (dev << 1);
+    cfg.cdw13                       = 0x01100001;
+    cfg.data_len                    = 1;
+
+    unsigned char data[1];
+
+    data[0]                         = val;
+
+    unsigned char   metadata[1];
+    unsigned int    result;
+
+    /*-----------------------------------------------------------------------------*\
+    | Send the command to the device                                                |
+    \*-----------------------------------------------------------------------------*/
+    nvme_admin_passthru(nvme_fd, cfg.opcode, cfg.flags, cfg.rsvd1,
+				cfg.nsid, cfg.cdw2, cfg.cdw3, cfg.cdw10,
+				cfg.cdw11, cfg.cdw12, cfg.cdw13, cfg.cdw14,
+				cfg.cdw15, cfg.data_len, data, cfg.metadata_len,
+				metadata, cfg.timeout_ms, &result);
+
+}
+
+void ENESMBusInterface_SpectrixS40G::ENERegisterWriteBlock(ene_dev_id dev, ene_register reg, unsigned char * data, unsigned char sz)
+{
+  	struct nvme_passthru_cmd cfg;
+
+    memset(&cfg, 0, sizeof(nvme_passthru_cmd));
+
+    unsigned short corrected_reg    = ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF);
+
+    cfg.opcode                      = 0xFB;
+    cfg.cdw12                       = (corrected_reg << 16) | (dev << 1);
+    cfg.cdw13                       = 0x03100000 | sz;
+    cfg.data_len                    = sz;
+
+    unsigned char   metadata[1];
+    unsigned int    result;
+
+    /*-----------------------------------------------------------------------------*\
+    | Send the command to the device                                                |
+    \*-----------------------------------------------------------------------------*/
+    nvme_admin_passthru(nvme_fd, cfg.opcode, cfg.flags, cfg.rsvd1,
+				cfg.nsid, cfg.cdw2, cfg.cdw3, cfg.cdw10,
+				cfg.cdw11, cfg.cdw12, cfg.cdw13, cfg.cdw14,
+				cfg.cdw15, cfg.data_len, data, cfg.metadata_len,
+				metadata, cfg.timeout_ms, &result);
+
+}

Controllers/ENESMBusController/ENESMBusInterface/ENESMBusInterface_SpectrixS40G.h

@@ -0,0 +1,28 @@
+/*-----------------------------------------*\
+|  ENESMBusInterface_SpectrixS40G.h         |
+|                                           |
+|  Definitions and types for ENE XPG        |
+|  Spectrix S40G NVMe interface             |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 11/21/2021  |
+\*-----------------------------------------*/
+
+#include "ENESMBusInterface.h"
+
+#pragma once
+
+class ENESMBusInterface_SpectrixS40G : public ENESMBusInterface
+{
+public:
+    ENESMBusInterface_SpectrixS40G(int fd, char* path);
+
+    std::string   GetLocation();
+    int           GetMaxBlock();
+    unsigned char ENERegisterRead(ene_dev_id dev, ene_register reg);
+    void          ENERegisterWrite(ene_dev_id dev, ene_register reg, unsigned char val);
+    void          ENERegisterWriteBlock(ene_dev_id dev, ene_register reg, unsigned char * data, unsigned char sz);
+
+private:
+    int         nvme_fd;
+    std::string path;
+};

Controllers/ENESMBusController/ENESMBusInterface/ENESMBusInterface_SpectrixS40G_Windows.cpp

@@ -0,0 +1,251 @@
+/*-----------------------------------------*\
+|  ENESMBusInterface_SpectrixS40G_Windows   |
+|                                           |
+|  Code for ENE XPG Spectrix S40G NVMe      |
+|  interface                                |
+|  Windows implementation					|
+|                                           |
+|  Adam Honse (CalcProgrammer1) 11/21/2021  |
+\*-----------------------------------------*/
+
+#include "ENESMBusInterface_SpectrixS40G_Windows.h"
+
+#include <fileapi.h>
+#include <winioctl.h>
+#include <nvme.h>
+
+ENESMBusInterface_SpectrixS40G::ENESMBusInterface_SpectrixS40G(HANDLE fd, wchar_t* path)
+{
+    this->nvme_fd = fd;
+	this->path    = path;
+}
+
+std::string ENESMBusInterface_SpectrixS40G::GetLocation()
+{
+	std::string str(path.begin(), path.end());
+    return("NVMe: " + str);
+}
+
+int ENESMBusInterface_SpectrixS40G::GetMaxBlock()
+{
+    return(24);
+}
+
+unsigned char ENESMBusInterface_SpectrixS40G::ENERegisterRead(ene_dev_id dev, ene_register reg)
+{
+    if(nvme_fd != INVALID_HANDLE_VALUE)
+    {
+        /*-----------------------------------------------------------------------------*\
+        | Create buffer to hold STORAGE_PROTOCOL_COMMAND                                |
+        | Size must be enough for the STORAGE_PROTOCOL_COMMAND struct plus the command  |
+        | data.  Subtract sizeof(DWORD) as the Command field in the structure overlaps  |
+        | the actual command data.                                                      |
+        \*-----------------------------------------------------------------------------*/
+        unsigned char buffer[sizeof(STORAGE_PROTOCOL_COMMAND) + (sizeof(DWORD) * 34) - sizeof(DWORD)] = {0};
+
+        /*-----------------------------------------------------------------------------*\
+        | Create STORAGE_PROTOCOL_COMMAND pointer and point it to the buffer            |
+        \*-----------------------------------------------------------------------------*/
+        PSTORAGE_PROTOCOL_COMMAND command       = (PSTORAGE_PROTOCOL_COMMAND)buffer;
+
+        /*-----------------------------------------------------------------------------*\
+        | Fill in STORAGE_PROTOCOL_COMMAND structure                                    |
+        \*-----------------------------------------------------------------------------*/
+        command->Version                        = STORAGE_PROTOCOL_STRUCTURE_VERSION;
+        command->Length                         = sizeof(STORAGE_PROTOCOL_COMMAND);
+        command->ProtocolType                   = ProtocolTypeNvme;
+        command->Flags                          = STORAGE_PROTOCOL_COMMAND_FLAG_ADAPTER_REQUEST;
+        command->ReturnStatus                   = 0x00000000;
+        command->ErrorCode                      = 0x00000000;
+        command->CommandLength                  = STORAGE_PROTOCOL_COMMAND_LENGTH_NVME;
+        command->ErrorInfoLength                = 0x00000040;
+        command->DataToDeviceTransferLength     = 0x00000000;
+        command->DataFromDeviceTransferLength   = 0x00000001;
+        command->TimeOutValue                   = 0x00000001;
+        command->ErrorInfoOffset                = 0x00000090;
+        command->DataToDeviceBufferOffset       = 0x00000000;
+        command->DataFromDeviceBufferOffset     = 0x000000D0;
+        command->CommandSpecific                = STORAGE_PROTOCOL_SPECIFIC_NVME_ADMIN_COMMAND;
+        command->Reserved0                      = 0x00000000;
+        command->FixedProtocolReturnData        = 0x00000000;
+        command->Reserved1[0]                   = 0x00000000;
+        command->Reserved1[1]                   = 0x00000000;
+        command->Reserved1[2]                   = 0x00000000;
+
+        /*-----------------------------------------------------------------------------*\
+        | Create ENE Register Write command, filling in the appropriate register and    |
+        | value                                                                         |
+        \*-----------------------------------------------------------------------------*/
+        PNVME_COMMAND CommandValue              = (PNVME_COMMAND)command->Command;
+
+        unsigned short corrected_reg            = ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF);
+
+        CommandValue->CDW0.OPC                  = 0xFA;
+        CommandValue->u.GENERAL.CDW12           = (corrected_reg << 16) | (dev << 1);
+        CommandValue->u.GENERAL.CDW13           = 0x81100001;
+
+        DWORD ExtraValue[18] = { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+                                 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 };
+
+        /*-----------------------------------------------------------------------------*\
+        | Send the STORAGE_PROTOCOL_COMMAND to the device                               |
+        \*-----------------------------------------------------------------------------*/
+        DWORD bytesreturned = 0;
+        while(bytesreturned != sizeof(buffer))
+        {        
+            bool result = DeviceIoControl(nvme_fd, IOCTL_STORAGE_PROTOCOL_COMMAND, buffer, sizeof(buffer), buffer, sizeof(buffer), &bytesreturned, (LPOVERLAPPED)0x0);
+        }
+
+        /*-----------------------------------------------------------------------------*\
+        | Copy the ENE Register Write extra data into the STORAGE_PROTOCOL_COMMAND      |
+        | buffer                                                                        |
+        \*-----------------------------------------------------------------------------*/
+        memcpy(ExtraValue, &command->Command + sizeof(NVME_COMMAND), sizeof(ExtraValue));
+
+        return(ExtraValue[16]);
+    }
+
+}
+
+void ENESMBusInterface_SpectrixS40G::ENERegisterWrite(ene_dev_id dev, ene_register reg, unsigned char val)
+{
+    if(nvme_fd != INVALID_HANDLE_VALUE)
+    {
+        /*-----------------------------------------------------------------------------*\
+        | Create buffer to hold STORAGE_PROTOCOL_COMMAND                                |
+        | Size must be enough for the STORAGE_PROTOCOL_COMMAND struct plus the command  |
+        | data.  Subtract sizeof(DWORD) as the Command field in the structure overlaps  |
+        | the actual command data.                                                      |
+        \*-----------------------------------------------------------------------------*/
+        unsigned char buffer[sizeof(STORAGE_PROTOCOL_COMMAND) + (sizeof(DWORD) * 34) - sizeof(DWORD)];
+
+        /*-----------------------------------------------------------------------------*\
+        | Create STORAGE_PROTOCOL_COMMAND pointer and point it to the buffer            |
+        \*-----------------------------------------------------------------------------*/
+        PSTORAGE_PROTOCOL_COMMAND command       = (PSTORAGE_PROTOCOL_COMMAND)buffer;
+
+        /*-----------------------------------------------------------------------------*\
+        | Fill in STORAGE_PROTOCOL_COMMAND structure                                    |
+        \*-----------------------------------------------------------------------------*/
+        command->Version                        = STORAGE_PROTOCOL_STRUCTURE_VERSION;
+        command->Length                         = sizeof(STORAGE_PROTOCOL_COMMAND);
+        command->ProtocolType                   = ProtocolTypeNvme;
+        command->Flags                          = STORAGE_PROTOCOL_COMMAND_FLAG_ADAPTER_REQUEST;
+        command->ReturnStatus                   = 0x00000000;
+        command->ErrorCode                      = 0x00000000;
+        command->CommandLength                  = STORAGE_PROTOCOL_COMMAND_LENGTH_NVME;
+        command->ErrorInfoLength                = 0x00000040;
+        command->DataToDeviceTransferLength     = 0x00000001;
+        command->DataFromDeviceTransferLength   = 0x00000000;
+        command->TimeOutValue                   = 0x00000001;
+        command->ErrorInfoOffset                = 0x00000090;
+        command->DataToDeviceBufferOffset       = 0x000000D0;
+        command->DataFromDeviceBufferOffset     = 0x00000000;
+        command->CommandSpecific                = STORAGE_PROTOCOL_SPECIFIC_NVME_ADMIN_COMMAND;
+        command->Reserved0                      = 0x00000000;
+        command->FixedProtocolReturnData        = 0x00000000;
+        command->Reserved1[0]                   = 0x00000000;
+        command->Reserved1[1]                   = 0x00000000;
+        command->Reserved1[2]                   = 0x00000000;
+
+        /*-----------------------------------------------------------------------------*\
+        | Create ENE Register Write command, filling in the appropriate register and    |
+        | value                                                                         |
+        \*-----------------------------------------------------------------------------*/
+        PNVME_COMMAND CommandValue              = (PNVME_COMMAND)command->Command;
+
+        unsigned short corrected_reg            = ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF);
+
+        CommandValue->CDW0.OPC                  = 0xFB;
+        CommandValue->u.GENERAL.CDW12           = (corrected_reg << 16) | (dev << 1);
+        CommandValue->u.GENERAL.CDW13           = 0x01100001;
+
+        DWORD ExtraValue[18] = { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+                                 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 };
+
+        ExtraValue[16]                          = val;
+
+        /*-----------------------------------------------------------------------------*\
+        | Copy the ENE Register Write extra data into the STORAGE_PROTOCOL_COMMAND      |
+        | buffer                                                                        |
+        \*-----------------------------------------------------------------------------*/
+        memcpy(&command->Command + sizeof(NVME_COMMAND), ExtraValue, sizeof(ExtraValue));
+
+        /*-----------------------------------------------------------------------------*\
+        | Send the STORAGE_PROTOCOL_COMMAND to the device                               |
+        \*-----------------------------------------------------------------------------*/
+        DeviceIoControl(nvme_fd, IOCTL_STORAGE_PROTOCOL_COMMAND, buffer, sizeof(buffer), buffer, sizeof(buffer), 0x0, (LPOVERLAPPED)0x0);
+    }
+}
+
+void ENESMBusInterface_SpectrixS40G::ENERegisterWriteBlock(ene_dev_id dev, ene_register reg, unsigned char * data, unsigned char sz)
+{
+    if(nvme_fd != INVALID_HANDLE_VALUE)
+    {
+        /*-----------------------------------------------------------------------------*\
+        | Create buffer to hold STORAGE_PROTOCOL_COMMAND                                |
+        | Size must be enough for the STORAGE_PROTOCOL_COMMAND struct plus the command  |
+        | data.  Subtract sizeof(DWORD) as the Command field in the structure overlaps  |
+        | the actual command data.                                                      |
+        \*-----------------------------------------------------------------------------*/
+        unsigned char buffer[sizeof(STORAGE_PROTOCOL_COMMAND) + (sizeof(DWORD) * 39) - sizeof(DWORD)];
+
+        /*-----------------------------------------------------------------------------*\
+        | Create STORAGE_PROTOCOL_COMMAND pointer and point it to the buffer            |
+        \*-----------------------------------------------------------------------------*/
+        PSTORAGE_PROTOCOL_COMMAND command       = (PSTORAGE_PROTOCOL_COMMAND)buffer;
+
+        /*-----------------------------------------------------------------------------*\
+        | Fill in STORAGE_PROTOCOL_COMMAND structure                                    |
+        \*-----------------------------------------------------------------------------*/
+        command->Version                        = STORAGE_PROTOCOL_STRUCTURE_VERSION;
+        command->Length                         = sizeof(STORAGE_PROTOCOL_COMMAND);
+        command->ProtocolType                   = ProtocolTypeNvme;
+        command->Flags                          = STORAGE_PROTOCOL_COMMAND_FLAG_ADAPTER_REQUEST;
+        command->ReturnStatus                   = 0x00000000;
+        command->ErrorCode                      = 0x00000000;
+        command->CommandLength                  = STORAGE_PROTOCOL_COMMAND_LENGTH_NVME;
+        command->ErrorInfoLength                = 0x00000040;
+        command->DataToDeviceTransferLength     = sz;
+        command->DataFromDeviceTransferLength   = 0x00000000;
+        command->TimeOutValue                   = 0x00000001;
+        command->ErrorInfoOffset                = 0x00000090;
+        command->DataToDeviceBufferOffset       = 0x000000D0;
+        command->DataFromDeviceBufferOffset     = 0x00000000;
+        command->CommandSpecific                = STORAGE_PROTOCOL_SPECIFIC_NVME_ADMIN_COMMAND;
+        command->Reserved0                      = 0x00000000;
+        command->FixedProtocolReturnData        = 0x00000000;
+        command->Reserved1[0]                   = 0x00000000;
+        command->Reserved1[1]                   = 0x00000000;
+        command->Reserved1[2]                   = 0x00000000;
+
+        /*-----------------------------------------------------------------------------*\
+        | Create ENE Register Write Block command, filling in the appropriate register  |
+        | and value                                                                     |
+        \*-----------------------------------------------------------------------------*/
+        PNVME_COMMAND CommandValue              = (PNVME_COMMAND)command->Command;
+
+        unsigned short corrected_reg            = ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF);
+
+        CommandValue->CDW0.OPC                  = 0xFB;
+        CommandValue->u.GENERAL.CDW12           = (corrected_reg << 16) | (dev << 1);
+        CommandValue->u.GENERAL.CDW13           = 0x03100000 | sz;
+
+        DWORD ExtraValue[23] = { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+                                 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+                                 0x00000000, 0x00000000, 0x00000000 };
+
+        memcpy(&ExtraValue[16], data, sz);
+
+        /*-----------------------------------------------------------------------------*\
+        | Copy the ENE Register Write Block extra data into the                         |
+        | STORAGE_PROTOCOL_COMMAND buffer                                               |
+        \*-----------------------------------------------------------------------------*/
+        memcpy(&command->Command + sizeof(NVME_COMMAND), ExtraValue, sizeof(ExtraValue));
+
+        /*-----------------------------------------------------------------------------*\
+        | Send the STORAGE_PROTOCOL_COMMAND to the device                               |
+        \*-----------------------------------------------------------------------------*/
+        DeviceIoControl(nvme_fd, IOCTL_STORAGE_PROTOCOL_COMMAND, buffer, sizeof(buffer), buffer, sizeof(buffer), 0x0, (LPOVERLAPPED)0x0);
+    }
+}

Controllers/ENESMBusController/ENESMBusInterface/ENESMBusInterface_SpectrixS40G_Windows.h

@@ -0,0 +1,30 @@
+/*-----------------------------------------*\
+|  ENESMBusInterface_SpectrixS40G_Windows.h |
+|                                           |
+|  Definitions and types for ENE XPG        |
+|  Spectrix S40G NVMe interface             |
+|  Windows implementation                   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 11/21/2021  |
+\*-----------------------------------------*/
+
+#include "ENESMBusInterface.h"
+#include <windows.h>
+
+#pragma once
+
+class ENESMBusInterface_SpectrixS40G : public ENESMBusInterface
+{
+public:
+    ENESMBusInterface_SpectrixS40G(HANDLE fd, wchar_t* path);
+
+    std::string   GetLocation();
+    int           GetMaxBlock();
+    unsigned char ENERegisterRead(ene_dev_id dev, ene_register reg);
+    void          ENERegisterWrite(ene_dev_id dev, ene_register reg, unsigned char val);
+    void          ENERegisterWriteBlock(ene_dev_id dev, ene_register reg, unsigned char * data, unsigned char sz);
+
+private:
+    HANDLE       nvme_fd;
+    std::wstring path;
+};

Controllers/ENESMBusController/ENESMBusInterface/ENESMBusInterface_i2c_smbus.cpp

@@ -0,0 +1,52 @@
+/*-----------------------------------------*\
+|  ENESMBusInterface_i2c_smbus.cpp          |
+|                                           |
+|  Code for ENE I2C/SMBus interface         |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 11/21/2021  |
+\*-----------------------------------------*/
+
+#include "ENESMBusInterface_i2c_smbus.h"
+
+ENESMBusInterface_i2c_smbus::ENESMBusInterface_i2c_smbus(i2c_smbus_interface* bus)
+{
+    this->bus = bus;
+}
+
+std::string ENESMBusInterface_i2c_smbus::GetLocation()
+{
+    std::string return_string(bus->device_name);
+    return("I2C: " + return_string);
+}
+
+int ENESMBusInterface_i2c_smbus::GetMaxBlock()
+{
+    return(3);
+}
+
+unsigned char ENESMBusInterface_i2c_smbus::ENERegisterRead(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));
+}
+
+void ENESMBusInterface_i2c_smbus::ENERegisterWrite(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);
+}
+
+void ENESMBusInterface_i2c_smbus::ENERegisterWriteBlock(ene_dev_id dev, 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/ENESMBusInterface/ENESMBusInterface_i2c_smbus.h

@@ -0,0 +1,28 @@
+/*-----------------------------------------*\
+|  ENESMBusInterface_i2c_smbus.h            |
+|                                           |
+|  Definitions and types for ENE I2C/SMBus  |
+|  interface                                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 11/21/2021  |
+\*-----------------------------------------*/
+
+#include "ENESMBusInterface.h"
+#include "i2c_smbus.h"
+
+#pragma once
+
+class ENESMBusInterface_i2c_smbus : public ENESMBusInterface
+{
+public:
+    ENESMBusInterface_i2c_smbus(i2c_smbus_interface* bus);
+
+    std::string   GetLocation();
+    int           GetMaxBlock();
+    unsigned char ENERegisterRead(ene_dev_id dev, ene_register reg);
+    void          ENERegisterWrite(ene_dev_id dev, ene_register reg, unsigned char val);
+    void          ENERegisterWriteBlock(ene_dev_id dev, ene_register reg, unsigned char * data, unsigned char sz);
+
+private:
+    i2c_smbus_interface *   bus;
+};

Controllers/ENESMBusController/RGBController_ENESMBus.cpp

@@ -0,0 +1,451 @@
+/*-----------------------------------------*\
+|  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()
+{
+    if(GetMode() == 0)
+    {
+        controller->SetAllColorsDirect(&colors[0]);
+    }
+    else
+    {
+        controller->SetAllColorsEffect(&colors[0]);
+    }
+
+}
+
+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/ENESMBusController/XPGSpectrixS40GDetect.cpp

@@ -0,0 +1,82 @@
+#include "Detector.h"
+#include "ENESMBusController.h"
+#include "ENESMBusInterface_SpectrixS40G.h"
+#include "LogManager.h"
+#include "RGBController.h"
+#include "RGBController_ENESMBus.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <dirent.h>
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectSpectrixS40GControllers                                                          *
+*                                                                                          *
+*           Detects ENE SMBus controllers on XPG Spectrix S40G NVMe devices                *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectSpectrixS40GControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    /*---------------------------------------------------------------------*\
+    | Search for /dev/nvmeX nodes with model matching "XPG SPECTRIX S40G"   |
+    \*---------------------------------------------------------------------*/
+    unsigned int nvme_idx = 0;
+
+    while(1)
+    {
+        /*-------------------------------------------------*\
+        | Create the nvme class model path                  |
+        \*-------------------------------------------------*/
+        char nvme_dev_buf[1024];
+
+        snprintf(nvme_dev_buf, 1024, "/sys/class/nvme/nvme%d/model", nvme_idx);
+
+        /*-------------------------------------------------*\
+        | Open the input event path to get the name         |
+        \*-------------------------------------------------*/
+        int nvme_model_fd = open(nvme_dev_buf, O_RDONLY|O_NONBLOCK);
+
+        if(nvme_model_fd < 0)
+        {
+            break;
+        }
+
+        memset(nvme_dev_buf, 0, 1024);
+        read(nvme_model_fd, nvme_dev_buf, 1024);
+        close(nvme_model_fd);
+
+        LOG_DEBUG("[XPG Spectrix S40G] Probing %d, model: %s", nvme_idx, nvme_dev_buf);
+
+        /*-------------------------------------------------*\
+        | Check if this NVMe device is a SPECTRIX S40G      |
+        \*-------------------------------------------------*/
+        if(strncmp(nvme_dev_buf, "XPG SPECTRIX S40G", 17) == 0)
+        {
+            snprintf(nvme_dev_buf, 1024, "/dev/nvme%d", nvme_idx);
+
+            int nvme_fd = open(nvme_dev_buf, O_RDWR);
+
+            if(nvme_fd > 0)
+            {
+                ENESMBusInterface_SpectrixS40G* interface = new ENESMBusInterface_SpectrixS40G(nvme_fd, nvme_dev_buf);
+                ENESMBusController*             controller     = new ENESMBusController(interface, 0x67);
+                RGBController_ENESMBus*         rgb_controller = new RGBController_ENESMBus(controller);
+                
+                rgb_controller->name   = "XPG Spectrix S40G";
+                rgb_controller->type   = DEVICE_TYPE_STORAGE;
+                rgb_controller->vendor = "XPG";
+
+                rgb_controllers.push_back(rgb_controller);
+            }
+        }
+
+        nvme_idx++;
+    }
+}   /* DetectSpectrixS40GControllers() */
+
+REGISTER_DETECTOR(    "XPG Spectrix S40G",              DetectSpectrixS40GControllers);

Controllers/ENESMBusController/XPGSpectrixS40GDetect_Windows.cpp

@@ -0,0 +1,122 @@
+#include "Detector.h"
+#include "ENESMBusController.h"
+#include "ENESMBusInterface_SpectrixS40G_Windows.h"
+#include "LogManager.h"
+#include "RGBController.h"
+#include "RGBController_ENESMBus.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define DEVBUFSIZE (128 * 1024)
+#include <windows.h>
+#include <fileapi.h>
+
+/*----------------------------------------------------------------------*\
+| Windows defines "interface" for some reason.  Work around this         |
+\*----------------------------------------------------------------------*/
+#ifdef interface
+#undef interface
+#endif
+
+/******************************************************************************************\
+*                                                                                          *
+*   Search                                                                                 *
+*                                                                                          *
+*           Search for an NVMe device matching "XPG SPECTRIX S40G"                         *
+*                                                                                          *
+\******************************************************************************************/
+
+int Search(wchar_t *dev_name)
+{
+    wchar_t buff[DEVBUFSIZE]  = L"";
+    int wchar_count;
+
+    wchar_count = QueryDosDeviceW(NULL, buff, DEVBUFSIZE);
+
+    if(wchar_count == 0)
+    {
+        return 0;
+    }
+
+    for(int i = 0; i < wchar_count; i++)
+    {
+        if(wcsstr(buff + i, L"SCSI#Disk&Ven_NVMe&Prod_XPG_SPECTRIX_S40#"))
+        {
+            wcsncpy(dev_name, buff + i, MAX_PATH);
+            (dev_name)[MAX_PATH - 1] = '\0';
+            return 1;
+        }
+
+        i += wcslen(buff + i);
+    }
+
+    return 0;
+}
+
+/******************************************************************************************\
+*                                                                                          *
+*   OpenDevice                                                                             *
+*                                                                                          *
+*           Open a handle to the given device path                                         *
+*                                                                                          *
+\******************************************************************************************/
+
+HANDLE OpenDevice(wchar_t buff[MAX_PATH])
+{
+    wchar_t path[MAX_PATH];
+
+    wcscpy(path, L"\\\\?\\");
+    wcsncat(path, buff, MAX_PATH - 4);
+
+    for(size_t i = 0; i < MAX_PATH && path[i] != '\0'; i++)
+    {
+        path[i] = tolower(path[i]);
+    }
+
+    wprintf(L"%s\n", path);
+
+    HANDLE hDevice = CreateFileW(path, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, (LPSECURITY_ATTRIBUTES)0x0, OPEN_EXISTING, 0x0, (HANDLE)0x0);
+
+    return(hDevice);
+}
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectSpectrixS40GControllers                                                          *
+*                                                                                          *
+*           Detects ENE SMBus controllers on XPG Spectrix S40G NVMe devices                *
+*                                                                                          *
+*           Tests for the existance of a file descriptor matching                          *
+*           SCSI#Disk&Ven_NVMe&Prod_XPG_SPECTRIX_S40# on Windows machines                  *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectSpectrixS40GControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    /*-------------------------------------------------------------------------------------------------*\
+    | https://docs.microsoft.com/en-us/windows-hardware/drivers/install/identifiers-for-scsi-devices    |
+    \*-------------------------------------------------------------------------------------------------*/
+    wchar_t dev_name[MAX_PATH];
+    
+    if(Search(dev_name))
+    {
+        HANDLE nvme_fd = OpenDevice(dev_name);
+
+        if(nvme_fd != INVALID_HANDLE_VALUE)
+        {
+            ENESMBusInterface_SpectrixS40G* interface      = new ENESMBusInterface_SpectrixS40G(nvme_fd, dev_name);
+            ENESMBusController*             controller     = new ENESMBusController(interface, 0x67);
+            RGBController_ENESMBus*         rgb_controller = new RGBController_ENESMBus(controller);
+            
+            rgb_controller->name   = "XPG Spectrix S40G";
+            rgb_controller->type   = DEVICE_TYPE_STORAGE;
+            rgb_controller->vendor = "XPG";
+
+            rgb_controllers.push_back(rgb_controller);
+        }
+    }
+}   /* DetectSpectrixS40GControllers() */
+
+
+REGISTER_DETECTOR(    "XPG Spectrix S40G",              DetectSpectrixS40GControllers);

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,19 @@
+/*-------------------------------------------------------------------*\
+|  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;
+    };
+};

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,76 @@ 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_GTX1070_DEV,         EVGA_SUB_VEN,   EVGA_GTX1070_FTW_HYBRID_SUB_DEV,            EVGA_RGB_V1,    "EVGA GeForce GTX 1070 FTW HYBRID"                      },
+    { 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_OC_DEV,     EVGA_SUB_VEN,   EVGA_RTX2070S_BLACK_SUB_DEV,                EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER Black"                     },
+    { NVIDIA_VEN,   NVIDIA_RTX2070S_OC_DEV,     EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_SUB_DEV,             EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER XC Ultra"                  },
+    { NVIDIA_VEN,   NVIDIA_RTX2070S_OC_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 +139,7 @@ void DetectEVGAGPUControllers(std::vector<i2c_smbus_interface*>& busses)
                 {
                     case EVGA_RGB_V1:
                         {
+                            LOG_DEBUG(GPU_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 +152,7 @@ void DetectEVGAGPUControllers(std::vector<i2c_smbus_interface*>& busses)
 
                     case EVGA_RGB_V2:
                         {
+                            LOG_DEBUG(GPU_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 +162,55 @@ void DetectEVGAGPUControllers(std::vector<i2c_smbus_interface*>& busses)
                             ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
                         }
                         break;
+
+                    case EVGA_RGB_V3:
+                        {
+                            LOG_DEBUG(GPU_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(GPU_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/GainwardGPUController/GainwardGPUControllerDetect.cpp

@@ -9,6 +9,7 @@
 #include "Detector.h"
 #include "GainwardGPUv1Controller.h"
 #include "GainwardGPUv2Controller.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_GainwardGPUv1.h"
 #include "RGBController_GainwardGPUv2.h"
@@ -41,7 +42,7 @@ typedef struct
 static const gpu_pci_device device_list[] =
 {
     { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,     GAINWARD_SUB_VEN,       GAINWARD_GTX_1080_PHOENIX,     RGB_V1,     "Gainward GTX 1080 Phoenix"             },
-    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,    GAINWARD_SUB_VEN,       NVIDIA_RTX2070S_DEV,           RGB_V2,     "Gainward RTX 2070 Super Phantom"       },
+    { NVIDIA_VEN,   NVIDIA_RTX2070S_OC_DEV, GAINWARD_SUB_VEN,       NVIDIA_RTX2070S_OC_DEV,        RGB_V2,     "Gainward RTX 2070 Super Phantom"       },
     { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,     GAINWARD_SUB_VEN,       NVIDIA_RTX3070_DEV,            RGB_V2,     "Gainward RTX 3070 Phoenix"             },
 };
 
@@ -109,6 +110,7 @@ void DetectGainwardGPUControllers(std::vector<i2c_smbus_interface*> &busses)
                     {
                         case RGB_V1:
                             {
+                                LOG_DEBUG(GPU_DETECT_MESSAGE, "Gainward v1", bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name );
                                 GainwardGPUv1Controller*     new_GainwardGPU;
                                 RGBController_GainwardGPUv1* new_controller;
 
@@ -121,6 +123,7 @@ void DetectGainwardGPUControllers(std::vector<i2c_smbus_interface*> &busses)
 
                         case RGB_V2:
                             {
+                                LOG_DEBUG(GPU_DETECT_MESSAGE, "Gainward v2", bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name );
                                 GainwardGPUv2Controller*     new_GainwardGPU;
                                 RGBController_GainwardGPUv2* new_controller;
 

Controllers/GalaxGPUController/GalaxGPUControllerDetect.cpp

@@ -8,6 +8,7 @@
 
 #include "Detector.h"
 #include "GalaxGPUController.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_GalaxGPU.h"
 #include "i2c_smbus.h"
@@ -32,7 +33,7 @@ typedef struct
 static const gpu_pci_device device_list[] =
 {
     { NVIDIA_VEN,   NVIDIA_RTX2070_DEV,     NVIDIA_SUB_VEN,     KFA2_RTX_2070_EX_SUB_DEV,               "KFA2 RTX 2070 EX"                      },
-    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,    NVIDIA_SUB_VEN,     GALAX_RTX_2070S_EX_GAMER_BLACK_SUB_DEV, "GALAX RTX 2070 Super EX Gamer Black"   },
+    { NVIDIA_VEN,   NVIDIA_RTX2070S_OC_DEV, NVIDIA_SUB_VEN,     GALAX_RTX_2070S_EX_GAMER_BLACK_SUB_DEV, "GALAX RTX 2070 Super EX Gamer Black"   },
     { NVIDIA_VEN,   NVIDIA_RTX2080_DEV,     NVIDIA_SUB_VEN,     KFA2_RTX_2080_EX_OC_SUB_DEV,            "KFA2 RTX 2080 EX OC"                   },
 };
 /******************************************************************************************\
@@ -82,6 +83,7 @@ void DetectGalaxGPUControllers(std::vector<i2c_smbus_interface*> &busses)
                busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
                busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
             {
+                LOG_DEBUG(GPU_DETECT_MESSAGE, "Galax GPU", bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name );
                 if (TestForGalaxGPUController(busses[bus], 0x23))
                 {
                     new_GalaxGPU         = new GalaxGPUController(busses[bus], 0x23);

Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.cpp

@@ -0,0 +1,147 @@
+/*-----------------------------------------*\
+|  GigabyteRGBFusion2GPUController.cpp      |
+|                                           |
+|  Driver for Gigabyte Aorus RGB Fusion2 GPU|
+|  lighting controller                      |
+|                                           |
+|  based on original by                     |
+|  Adam Honse (CalcProgrammer1)             |
+\*-----------------------------------------*/
+
+#include <chrono>
+#include <thread>
+#include "GigabyteRGBFusion2GPUController.h"
+#include "LogManager.h"
+
+using namespace std::chrono_literals;
+
+RGBFusion2GPUController::RGBFusion2GPUController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+}
+
+RGBFusion2GPUController::~RGBFusion2GPUController()
+{
+
+}
+
+std::string RGBFusion2GPUController::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 RGBFusion2GPUController::SaveConfig()
+{
+    uint8_t data_pkt[8] = { 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+    bus->i2c_write_block(dev, sizeof(data_pkt), data_pkt);
+}
+
+void RGBFusion2GPUController::SetMode(uint8_t zone, uint8_t mode, fusion2_config zone_config, uint8_t mystery_flag)
+{
+    uint8_t zone_pkt[8] = { RGB_FUSION2_GPU_REG_MODE, mode, zone_config.speed, zone_config.brightness, mystery_flag, (zone + 1), 0x00, 0x00 };
+    bus->i2c_write_block(dev, sizeof(zone_pkt), zone_pkt);
+
+    uint8_t zone_pkt2[8] = { RGB_FUSION2_GPU_REG_COLOR, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]), (zone + 1), 0x00, 0x00, 0x00 };
+    bus->i2c_write_block(dev, sizeof(zone_pkt2), zone_pkt2);
+}
+
+void RGBFusion2GPUController::SetZone(uint8_t zone, uint8_t mode, fusion2_config zone_config)
+{
+    std::string mode_name;
+    uint8_t mystery_flag = 0x00;
+
+    switch(mode)
+    {
+        case RGB_FUSION2_GPU_MODE_STATIC:
+            {
+                SetMode(zone, mode, zone_config, mystery_flag);
+            }
+            break;
+
+        case RGB_FUSION2_GPU_MODE_BREATHING:
+            {
+                SetMode(zone, mode, zone_config, mystery_flag);
+            }
+            break;
+
+        case RGB_FUSION2_GPU_MODE_COLOR_CYCLE:
+            {
+                uint8_t zone_pkt[8] = { RGB_FUSION2_GPU_REG_MODE, mode, zone_config.speed, zone_config.brightness, mystery_flag, (zone + 1), 0x00, 0x00 };
+                bus->i2c_write_block(dev, sizeof(zone_pkt), zone_pkt);
+            } 
+            break;
+
+        case RGB_FUSION2_GPU_MODE_GRADIENT:
+            {
+                mystery_flag = 0x08;
+                SetMode(zone, mode, zone_config, mystery_flag);
+            }
+            break;
+
+        case RGB_FUSION2_GPU_MODE_FLASHING:
+            {
+                SetMode(zone, mode, zone_config, mystery_flag);
+            }
+            break;
+
+        case RGB_FUSION2_GPU_MODE_DUAL_FLASHING:
+            {
+                SetMode(zone, mode, zone_config, mystery_flag);
+            }
+            break;
+
+        case RGB_FUSION2_GPU_MODE_WAVE:
+            {
+                SetMode(zone, mode, zone_config, mystery_flag);
+            }
+            break;
+
+        case RGB_FUSION2_GPU_MODE_COLOR_SHIFT: 
+            {
+                mystery_flag = zone_config.numberOfColors;
+                uint8_t zone_pkt[8] = { RGB_FUSION2_GPU_REG_MODE, mode, zone_config.speed, zone_config.brightness, mystery_flag, (zone + 1), 0x00, 0x00 };
+                bus->i2c_write_block(dev, sizeof(zone_pkt), zone_pkt);
+
+                uint8_t bank = (0xB0 + (zone * 4));
+                uint8_t zone_pktA[8] = { bank, mode, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]), RGBGetRValue(zone_config.colors[1]), RGBGetGValue(zone_config.colors[1]), RGBGetBValue(zone_config.colors[1]) };
+                bus->i2c_write_block(dev, sizeof(zone_pktA), zone_pktA);
+                uint8_t zone_pktB[8] = { (bank + 1), mode, RGBGetRValue(zone_config.colors[2]), RGBGetGValue(zone_config.colors[2]), RGBGetBValue(zone_config.colors[2]), RGBGetRValue(zone_config.colors[3]), RGBGetGValue(zone_config.colors[3]), RGBGetBValue(zone_config.colors[3]) };
+                bus->i2c_write_block(dev, sizeof(zone_pktB), zone_pktB);
+                uint8_t zone_pktC[8] = { (bank + 2), mode, RGBGetRValue(zone_config.colors[4]), RGBGetGValue(zone_config.colors[4]), RGBGetBValue(zone_config.colors[4]), RGBGetRValue(zone_config.colors[5]), RGBGetGValue(zone_config.colors[5]), RGBGetBValue(zone_config.colors[5]) };
+                bus->i2c_write_block(dev, sizeof(zone_pktC), zone_pktC);
+                uint8_t zone_pktD[8] = { (bank + 3), mode, RGBGetRValue(zone_config.colors[6]), RGBGetGValue(zone_config.colors[6]), RGBGetBValue(zone_config.colors[6]), RGBGetRValue(zone_config.colors[7]), RGBGetGValue(zone_config.colors[7]), RGBGetBValue(zone_config.colors[7]) };
+                bus->i2c_write_block(dev, sizeof(zone_pktD), zone_pktD);
+            }
+            break;
+
+        case RGB_FUSION2_GPU_MODE_TRICOLOR:
+            {
+                mystery_flag = 0x08;
+                uint8_t zone_pkt[8] = { RGB_FUSION2_GPU_REG_MODE, mode, zone_config.speed, zone_config.brightness, mystery_flag, (zone + 1), 0x00, 0x00 };
+                bus->i2c_write_block(dev, sizeof(zone_pkt), zone_pkt);
+
+                uint8_t bank = (0xB0 + (zone * 4));
+                uint8_t zone_pktA[8] = { bank, mode, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]), RGBGetRValue(zone_config.colors[1]), RGBGetGValue(zone_config.colors[1]), RGBGetBValue(zone_config.colors[1]) };
+                bus->i2c_write_block(dev, sizeof(zone_pktA), zone_pktA);
+                uint8_t zone_pktB[8] = { (bank + 1), mode, RGBGetRValue(zone_config.colors[2]), RGBGetGValue(zone_config.colors[2]), RGBGetBValue(zone_config.colors[2]), RGBGetRValue(zone_config.colors[3]), RGBGetGValue(zone_config.colors[3]), RGBGetBValue(zone_config.colors[3]) };
+                bus->i2c_write_block(dev, sizeof(zone_pktB), zone_pktB);
+                uint8_t zone_pktC[8] = { (bank + 2), mode, RGBGetRValue(zone_config.colors[4]), RGBGetGValue(zone_config.colors[4]), RGBGetBValue(zone_config.colors[4]), RGBGetRValue(zone_config.colors[5]), RGBGetGValue(zone_config.colors[5]), RGBGetBValue(zone_config.colors[5]) };
+                bus->i2c_write_block(dev, sizeof(zone_pktC), zone_pktC);
+                uint8_t zone_pktD[8] = { (bank + 3), mode, RGBGetRValue(zone_config.colors[6]), RGBGetGValue(zone_config.colors[6]), RGBGetBValue(zone_config.colors[6]), RGBGetRValue(zone_config.colors[7]), RGBGetGValue(zone_config.colors[7]), RGBGetBValue(zone_config.colors[7]) };
+                bus->i2c_write_block(dev, sizeof(zone_pktD), zone_pktD);
+            }
+            break;
+        
+        default:
+            {
+                LOG_TRACE("[%s] Mode %02d not found", "fusion2 gpu", mode);
+            }
+            break;
+    }
+}