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,17 +114,22 @@ ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /s
 #       Masterkeys SK630                                        #
 #       Masterkeys SK650                                        #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0101", TAG+="uaccess"          #MM711
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0109", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0105", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="1011", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="1000", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="014d", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0047", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="003c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0067", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0089", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="008d", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0101", TAG+="uaccess", TAG+="MM711"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0141", TAG+="uaccess", TAG+="MM720"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0109", TAG+="uaccess", TAG+="MP750_XL"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="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"
+
 
 #---------------------------------------------------------------#
 #  Corsair Hydro Series Devices                                 #
@@ -189,6 +195,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c23", TAG+="uacces
 #       Corsair K70 RGB MK2 LP                                  #
 #       Corsair K95 RGB                                         #
 #       Corsair K95 Platinum                                    #
+#       Corsair K100                                            #
 #       Corsair Strafe                                          #
 #       Corsair Strafe MK2                                      #
 #                                                               #
@@ -223,11 +230,14 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b11", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b2d", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b20", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b48", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b7c", TAG+="uaccess"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b34", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b74", TAG+="uaccess"
 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"
@@ -343,6 +353,8 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0cf2", ATTR{idProduct}=="7750", TAG+="uacces
 #       Logitech G810 #2                                        #
 #       Logitech G813                                           #
 #       Logitech G815                                           #
+#       Logitech G915                                           #
+#       Logitech G Pro                                          #
 #                                                               #
 #  Mice:                                                        #
 #       Logitech G203 Prodigy                                   #
@@ -354,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             #
@@ -373,16 +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}=="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"
@@ -394,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                                 #
@@ -426,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                                           #
@@ -499,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                                                  #
@@ -510,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                                  #
@@ -718,14 +751,16 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="0ba0", TAG+="uacces
 #       SteelSeries Rival 300 Blackops Edition                  #
 #       SteelSeries Rival 310                                   #
 #       SteelSeries Rival 310 CS:GO Howl Edition                #
-#       SteelSeries Rival 310 PubG Edition			#
-#	SteelSeries Rival 650 Wireless		                #
+#       SteelSeries Rival 310 PubG Edition                      #
+#       SteelSeries Rival 650 Wireless                          #
+#       SteelSeries Rival 3                                     #
 #       SteelSeries Rival Sensei Ten                            #
 #       SteelSeries Rival Sensei Ten CS:GO Neon Rider           #
 #       SteelSeries Rival Sensei 310                            #
 #  Headsets:                                                    #
 #       SteelSeries Siberia 350                                 #
 #  Keyboards:                                                   #
+#       SteelSeries Apex 3                                      #
 #       SteelSeries Apex 5                                      #
 #       SteelSeries Apex 7                                      #
 #       SteelSeries Apex 7 TKL                                  #
@@ -735,7 +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"
@@ -755,7 +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}=="172b", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1824", TAG+="uaccess", TAG+="Rival3_Old"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="184c", TAG+="uaccess", TAG+="Rival3"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1229", TAG+="uaccess"
 
@@ -764,12 +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                                              #
@@ -784,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/AMDWraithPrismController/AMDWraithPrismController.cpp

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

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

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

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

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

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp

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

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h

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

Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusControllerDetect.cpp

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

Controllers/AlienwareController/RGBController_Alienware.cpp

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

Controllers/AlienwareKeyboardController/AlienwareAW510KController.cpp

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

Controllers/AlienwareKeyboardController/AlienwareAW510KController.h

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

Controllers/AlienwareKeyboardController/AlienwareKeyboardControllerDetect.cpp

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

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.cpp

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

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.h

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

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -8,6 +8,7 @@
 
 #include "Detector.h"
 #include "AsusAuraGPUController.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraGPU.h"
 #include "i2c_smbus.h"
@@ -28,34 +29,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_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX,                     0x29,   "ASUS GTX 1060 Strix"                       },
-    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_GAMING,              0x29,   "ASUS GTX 1070 Strix Gaming"                },
-    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_OC,                  0x29,   "ASUS GTX 1070 Strix OC"                    },
-    { NVIDIA_VEN,       NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,    0x29,   "ASUS ROG Strix GTX1070 Ti A8G Gaming"      },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_GTX1080_STRIX,                     0x29,   "ASUS GTX 1080 Strix OC"                    },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_A8G_GAMING,      0x29,   "ASUS ROG Strix GTX1080 A8G Gaming"         },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_O8G_GAMING,      0x29,   "ASUS ROG Strix GTX1080 O8G Gaming"         },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_GAMING,        0x29,   "ASUS ROG Strix GTX1080 Ti Gaming"          },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,    0x29,   "ASUS ROG Strix GTX1080 Ti 11G Gaming"      },
-    { NVIDIA_VEN,       NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1650S_OC,             0x2A,   "ASUS ROG Strix GTX 1650S OC 4G"            },
-    { NVIDIA_VEN,       NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_GTX1660TI_OC,                  0x2A,   "ASUS ROG GTX 1660 Ti OC 6G"                },
-    { NVIDIA_VEN,       NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_EVO_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING, 0x2A,   "ASUS ROG STRIX RTX 2060S A8G EVO Gaming 6G"},
-    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_A8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2070 A8G Gaming 8G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_O8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2070 O8G Gaming 8G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2070S O8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080_O8G_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2080 O8G Gaming"        },
-    { NVIDIA_VEN,       NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,   0x2A,   "ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    },
-    { AMD_GPU_VEN,      AMD_VEGA10_DEV,             ASUS_SUB_VEN,       ASUS_VEGA64_STRIX,                      0x29,   "ASUS Vega 64 Strix"                        },
-    { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5700XT_STRIX_GAMING_OC,          0x2A,   "ASUS RX 5700XT Strix Gaming OC"            },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX480_STRIX_GAMING_OC,             0x29,   "ASUS ROG STRIX RX480 Gaming OC"            },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX570_STRIX_O4G_GAMING_OC,         0x29,   "ASUS RX 570 Strix O4G Gaming OC"           },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_OC,             0x29,   "ASUS RX 580 Strix Gaming OC"               }
+    { NVIDIA_VEN,       NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,       ASUS_GTX1050_STRIX_O2G_GAMING,              0x29,   "ASUS ROG Strix GTX 1050 O2G Gaming"        },
+    { NVIDIA_VEN,       NVIDIA_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"              },
 };  
 
 /******************************************************************************************\
@@ -73,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;
@@ -104,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);
@@ -116,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 - Second generation motherboard controller
-    else if (strcmp(device_name, "AUMA0-E8K4-0101") == 0)
-    {
-        direct_reg = AURA_REG_COLORS_DIRECT_V2;
-        effect_reg = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V2;
-    }
-    // Assume first generation controller if string does not match
-    else
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT;
-        effect_reg  = AURA_REG_COLORS_EFFECT;
-        channel_cfg = AURA_CONFIG_CHANNEL_V1;
-    }
-}
-
-AuraSMBusController::~AuraSMBusController()
-{
-
-}
-
-std::string AuraSMBusController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string AuraSMBusController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-unsigned char AuraSMBusController::GetChannel(unsigned int led)
-{
-    return(config_table[channel_cfg + led]);
-}
-
-const char * AuraSMBusController::GetChannelName(unsigned int led)
-{
-    switch (config_table[channel_cfg + led])
-    {
-    case (unsigned char)AURA_LED_CHANNEL_AUDIO:
-        return(aura_channels[0]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_BACKPLATE:
-        return(aura_channels[1]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_BACK_IO:
-        return(aura_channels[2]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_CENTER:
-        return(aura_channels[3]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_CENTER_START:
-        return(aura_channels[4]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_DRAM:
-        return(aura_channels[5]);
-        break;
-    
-    case (unsigned char)AURA_LED_CHANNEL_PCIE:
-        return(aura_channels[6]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER:
-        return(aura_channels[7]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER_2:
-        return(aura_channels[8]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER_3:
-        return(aura_channels[9]);
-        break;
-
-    default:
-        return(aura_channels[10]);
-        break;
-    }
-}
-
-unsigned int AuraSMBusController::GetLEDCount()
-{
-    return(led_count);
-}
-
-unsigned char AuraSMBusController::GetLEDRed(unsigned int led)
-{
-    return(AuraRegisterRead(direct_reg + ( 3 * led )));
-}
-
-unsigned char AuraSMBusController::GetLEDGreen(unsigned int led)
-{
-    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 2));
-}
-
-unsigned char AuraSMBusController::GetLEDBlue(unsigned int led)
-{
-    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 1));
-}
-
-void AuraSMBusController::SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char* colors = new unsigned char[led_count * 3];
-
-    for (unsigned int i = 0; i < (led_count * 3); i += 3)
-    {
-        colors[i + 0] = red;
-        colors[i + 1] = blue;
-        colors[i + 2] = green;
-    }
-
-    AuraRegisterWriteBlock(direct_reg, colors, led_count * 3);
-
-    delete[] colors;
-}
-
-void AuraSMBusController::SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char* colors = new unsigned char[led_count * 3];
-
-    for (unsigned int i = 0; i < (led_count * 3); i += 3)
-    {
-        colors[i + 0] = red;
-        colors[i + 1] = blue;
-        colors[i + 2] = green;
-    }
-
-    AuraRegisterWriteBlock(effect_reg, colors, led_count * 3);
-    
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-
-    delete[] colors;
-}
-
-void AuraSMBusController::SetDirect(unsigned char direct)
-{
-    AuraRegisterWrite(AURA_REG_DIRECT, direct);
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-}
-
-void AuraSMBusController::SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char colors[3] = { red, blue, green };
-
-    AuraRegisterWriteBlock(direct_reg + ( 3 * led ), colors, 3);
-}
-
-void AuraSMBusController::SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char colors[3] = { red, blue, green };
-
-    AuraRegisterWriteBlock(effect_reg + (3 * led), colors, 3);
-
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-}
-
-void AuraSMBusController::SetMode(unsigned char mode)
-{
-    AuraRegisterWrite(AURA_REG_MODE, mode);
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-}
-
-void AuraSMBusController::AuraUpdateDeviceName()
-{
-    for (int i = 0; i < 16; i++)
-    {
-        device_name[i] = AuraRegisterRead(AURA_REG_DEVICE_NAME + i);
-    }
-}
-
-unsigned char AuraSMBusController::AuraRegisterRead(aura_register reg)
-{
-    //Write Aura register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Read Aura value
-    return(bus->i2c_smbus_read_byte_data(dev, 0x81));
-
-}
-
-void AuraSMBusController::AuraRegisterWrite(aura_register reg, unsigned char val)
-{
-    //Write Aura register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Write Aura value
-    bus->i2c_smbus_write_byte_data(dev, 0x01, val);
-
-}
-
-void AuraSMBusController::AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz)
-{
-    //Write Aura register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Write Aura block data
-    bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
-
-}

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

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

Controllers/CoolerMasterController/CMMKController.h

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

Controllers/CoolerMasterController/CMMM711Controller.cpp

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

Controllers/CoolerMasterController/CMMM711Controller.h

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

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

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

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

Controllers/CoolerMasterController/RGBController_CMMM711Controller.cpp

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

Controllers/CoolerMasterController/RGBController_CMMM711Controller.h

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

Controllers/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

@@ -0,0 +1,172 @@
+/*-----------------------------------------*\
+|  CorsairK100Controller.cpp                |
+|                                           |
+|  Driver for Corsair K100 Keyboard         |
+\*-----------------------------------------*/
+
+#include "CorsairK100Controller.h"
+#include "LogManager.h"
+
+static unsigned int keys_k100[] = {0x25, 0x31, 0x27, 0x35, 0x66, 0x65, 0x41, 0x2A, 0x6E, 0x5B, 0x36, 0x1A, 0x10, 0x00, 0x68, 0x42,
+                                   0x62, 0x5C, 0x37, 0x1B, 0x16, 0x12, 0x19, 0x67, 0x43, 0x26, 0x77, 0x5D, 0x38, 0x1C, 0x04, 0x03,
+                                   0x17, 0x44, 0x48, 0x7A, 0x39, 0x1D, 0x11, 0x05, 0x02, 0x28, 0x45, 0x49, 0x78, 0x58, 0x3A, 0x1E,
+                                   0x13, 0x06, 0x15, 0x46, 0x4A, 0x79, 0x59, 0x3B, 0x1F, 0x18, 0x07, 0x01, 0x47, 0x6A, 0x4F, 0x5A,
+                                   0x3C, 0x20, 0x14, 0x09, 0x0D, 0x6B, 0x2C, 0x69, 0x50, 0x55, 0x3D, 0x21, 0x08, 0x0A, 0x0C, 0x76,
+                                   0x2D, 0x4E, 0x51, 0x56, 0x3E, 0x22, 0x0E, 0x0B, 0x32, 0x61, 0x4C, 0x52, 0x57, 0x3F, 0x23, 0x0F,
+                                   0x2F, 0x33, 0x24, 0x4D, 0x53, 0x5E, 0x40, 0x29, 0x2B, 0x30, 0x34, /*Brightness,*/
+                                   0x4B, 0x54, 0x5F, 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,
+                                   0x9B, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,0xB0, 0xB1, //Light Bar
+                                   0x85, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9,//Nameplate
+                                   0xBA, 0xBB, 0xBC/*Logo*/};
+
+CorsairK100Controller::CorsairK100Controller(hid_device* dev_handle, const char* path)
+{
+    dev             = dev_handle;
+    location        = path;
+    keyboard_type   = CORSAIR_TYPE_K100;
+
+    LightingControl();
+}
+CorsairK100Controller::~CorsairK100Controller()
+{
+    hid_close(dev);
+}
+
+std::string CorsairK100Controller::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string CorsairK100Controller::GetFirmwareString()
+{
+    return "";
+}
+
+std::string CorsairK100Controller::GetName()
+{
+    return name;
+}
+
+void CorsairK100Controller::SetName(std::string device_name)
+{
+    name = device_name;
+}
+
+CorsairKeyboardType CorsairK100Controller::GetKeyboardType()
+{
+    return keyboard_type;
+}
+
+std::string CorsairK100Controller::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+void CorsairK100Controller::LightingControl()
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    //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, 65);
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    int res = hid_read_timeout(dev, usb_buf, 50, 1000);
+
+    if (res == 0 || usb_buf[1] != 0x01)
+    {
+        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)
+{
+    switch(keyboard_type)
+    {
+        case CORSAIR_TYPE_K100:
+            SetLEDsKeyboardFull(colors);
+            break;
+
+        case CORSAIR_TYPE_UNKNOWN:
+            break;
+    }
+}
+
+void CorsairK100Controller::SetLEDsKeyboardFull(std::vector<RGBColor> colors)
+{
+    unsigned char usb_buf[600];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x01] = 0x08;
+    usb_buf[0x02] = 0x06;
+    usb_buf[0x03] = 0x01;
+    usb_buf[0x04] = 0x45;
+    usb_buf[0x05] = 0x02;
+    usb_buf[0x08] = 0x12;
+
+    for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        RGBColor color = colors[color_idx];
+        usb_buf[0x16 + keys_k100[color_idx]*3] = RGBGetRValue(color);
+        usb_buf[0x17 + keys_k100[color_idx]*3] = RGBGetGValue(color);
+        usb_buf[0x18 + keys_k100[color_idx]*3] = RGBGetBValue(color);
+    }
+
+    hid_write(dev, (unsigned char *)usb_buf, 600);
+}

Controllers/CorsairPeripheralController/CorsairK100Controller.h

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

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

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

Controllers/CorsairPeripheralController/CorsairPeripheralController.h

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

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

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

Controllers/CorsairPeripheralController/RGBController_CorsairK100.cpp

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

@@ -0,0 +1,40 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairK100.cpp            |
+|                                           |
+|  Driver for Corsair K100 Keyboard         |
+\*-----------------------------------------*/
+
+#ifndef RGBCONTROLLER_CORSAIRK100_H
+#define RGBCONTROLLER_CORSAIRK100_H
+
+#include "RGBController.h"
+#include "CorsairK100Controller.h"
+
+class RGBController_CorsairK100 : public RGBController
+{
+public:
+    RGBController_CorsairK100(CorsairK100Controller* corsair_ptr);
+    ~RGBController_CorsairK100();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
+
+    void DeviceUpdateMode();
+    void SetCustomMode();
+    void        KeepaliveThread();
+
+private:
+    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

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