Add Alpine Linux CI

Adding ROG Strix 2060S 8G Gaming GPU
* Added card ID * Registered detector in AsusAuraGPUControllerDetect.cpp * Link to [webpage](https://rog.asus.com/graphics-cards/graphics-cards/rog-strix/rog-strix-rtx2060s-8g-gaming-model/)
2021-12-30 18:13:54 -06:00 · 2021-12-30 18:10:45 +00:00 · 2021-12-30 18:10:13 +00:00 · 2021-12-30 08:13:12 +00:00 · 2021-12-30 00:46:13 -06:00 · 2021-12-30 00:45:07 -06:00
446 changed files with 37270 additions and 6052 deletions
@@ -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,18 @@ before_script:
    paths:
    - openrgb*.rpm
    expire_in: 30 days
-  
+
 #-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bullseye 32-bit Build Target                      #
+# Alpine Linux 64-bit Build Target                                      #
 #-----------------------------------------------------------------------#
-"Linux 32 deb Bullseye":
-  <<: *ccache_init
-  image: i386/debian:bullseye
+"Alpine Linux 64":
+  image: alpinelinux/alpine-gitlab-ci:latest
  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
+  - doas apk update
+  - doas apk add hidapi-dev libusb-dev mbedtls-dev qt5-qtbase-dev
+  - qmake .
+  - make

 #-----------------------------------------------------------------------#
 # Debian 32 Buster test                                                 #
@@ -193,9 +201,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 +235,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 +252,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 +306,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                                         #
 #-----------------------------------------------------------------------#
@@ -1,3 +0,0 @@
-[submodule "razer-drivers-win32"]
-	path = razer-drivers-win32
-	url = https://github.com/rsandoz/razer-drivers-win32
@@ -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                                       #
@@ -56,16 +56,31 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18f3", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a5", TAG+="uaccess"
 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}=="18dd", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1845", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1875", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1877", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cd", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cf", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e5", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e3", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1958", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a0", TAG+="uaccess"
+
+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", 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)                                   #
@@ -81,6 +96,9 @@ ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /s
 #---------------------------------------------------------------#
 #  Cooler Master Peripheral Devices                             #
 #                                                               #
+#  Mice:                                                        #
+#       Cooler Master MM711                                     #
+#       Cooler Master MM720                                     #
 #  Mousemats:                                                   #
 #       Cooler Master MP750                                     #
 #  Controllers:                                                 #
@@ -96,16 +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}=="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                                 #
@@ -171,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                                      #
 #                                                               #
@@ -205,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"
@@ -237,6 +265,15 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b62", TAG+="uacces
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="041e", ATTR{idProduct}=="3256", TAG+="uaccess"

+#---------------------------------------------------------------#
+#  Dell G Series Devices                                        #
+#                                                               #
+#                                                               #
+#  Controllers:                                                 #
+#       Dell G Series LED Controller                            #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="187c", ATTR{idProduct}=="0550", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  Ducky Keyboard Devices                                       #
 #                                                               #
@@ -316,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                                   #
@@ -327,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             #
@@ -346,15 +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}=="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"
@@ -366,26 +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"
-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"
+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"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a78", TAG+="uaccess", TAG+="G560"

-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a5b", TAG+="uaccess"
+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                                 #
@@ -396,61 +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}=="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                                           #
@@ -468,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                                                  #
@@ -479,141 +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}=="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", 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", 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}=="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}=="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                                  #
@@ -680,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                                  #
@@ -697,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"
@@ -717,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"

@@ -726,11 +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                                              #
@@ -745,16 +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"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff02", TAG+="uaccess"
+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                                         #
@@ -0,0 +1,42 @@
+# Contributor: Bart Ribbers <[email protected]>
+# Maintainer: Bart Ribbers <[email protected]>
+pkgname=openrgb
+pkgver=0.7
+pkgrel=0
+pkgdesc="Open source RGB lighting control that doesn't depend on manufacturer software"
+url="https://gitlab.com/CalcProgrammer1/OpenRGB"
+arch="all !ppc64le" # Build fails and not supported on ppc64le
+license="GPL-2.0-only"
+makedepends="
+	hidapi-dev
+	libusb-dev
+	mbedtls-dev
+	qt5-qtbase-dev
+	"
+source="https://gitlab.com/CalcProgrammer1/OpenRGB/-/archive/release_$pkgver/OpenRGB-release_$pkgver.tar.gz
+	0001-fix-build.patch
+	modules-load.conf
+	"
+install="$pkgname.post-install"
+builddir="$srcdir/OpenRGB-release_$pkgver"
+
+build() {
+	qmake-qt5 PREFIX=/usr
+	make
+}
+
+check() {
+	make check
+}
+
+package() {
+	INSTALL_ROOT="$pkgdir" make install
+
+	install -Dm644 "$srcdir"/modules-load.conf "$pkgdir"/usr/lib/modules-load.d/openrgb.conf
+}
+
+sha512sums="
+d08ef4f1b1d890858b37a0b76145da13031b35fca0b09bc243121323f4f7fc2760319981da6071acfe0ad020fdacf8663038f7fa0f4e596283a278905f1a010b  OpenRGB-release_0.7.tar.gz
+9070b8520b7ead8796c45ff90c9775ce235ae4fd818092998600cfe31c7c0b4393e10731fc727f0f29bee1aa093be5236779c38a164bf10bc1f218f53243c0a4  0001-fix-build.patch
+6fc01a649fcdecd2168292ae383a5af61be8c3d3fb8b98026a779f09dc9c9e1643e3c55290abd3b262bfea55e9a6cacab902f0fae5c9396dc20028a37f566555  modules-load.conf
+"
@@ -0,0 +1,212 @@
+#include "AutoStart-Linux.h"
+#include "LogManager.h"
+#include "filesystem.h"
+
+#include <fstream>
+#include <iostream>
+#include <unistd.h>
+#include <linux/limits.h>
+
+/*-----------------------------------------------------*\
+| Linux AutoStart Implementation                        |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
+
+AutoStart::AutoStart(std::string name)
+{
+    InitAutoStart(name);
+}
+
+bool AutoStart::DisableAutoStart()
+{
+    std::error_code autostart_file_remove_errcode;
+    bool            success                         = false;
+
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_file != "")
+    {
+        /*---------------------------------------------*\
+        | If file doesn't exist, disable is successful  |
+        \*---------------------------------------------*/
+        if(!filesystem::exists(autostart_file))
+        {
+            success = true;
+        }
+        /*---------------------------------------------*\
+        | Otherwise, delete the file                    |
+        \*---------------------------------------------*/
+        else
+        {
+            success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
+
+            if(!success)
+            {
+                LOG_ERROR("[AutoStart] An error occurred removing the auto start file.");
+            }
+        }
+    }
+    else
+    {
+        LOG_ERROR("Could not establish correct autostart file path.");
+    }
+
+    return(success);
+}
+
+bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
+{
+    bool        success                             = false;
+
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_file != "")
+    {
+        std::string     desktop_file                = GenerateDesktopFile(autostart_info);
+        std::ofstream   autostart_file_stream(autostart_file, std::ios::out | std::ios::trunc);
+
+        /*---------------------------------------------*\
+        | Error out if the file could not be opened     |
+        \*---------------------------------------------*/
+        if(!autostart_file_stream)
+        {
+            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
+            success = false;
+        }
+        /*---------------------------------------------*\
+        | Otherwise, write the file                     |
+        \*---------------------------------------------*/
+        else
+        {
+            autostart_file_stream << desktop_file;
+            autostart_file_stream.close();
+            success = !autostart_file_stream.fail();
+
+            if (!success)
+            {
+                LOG_ERROR("An error occurred writing the auto start file.");
+            }
+        }
+    }
+    else
+    {
+        LOG_ERROR("Could not establish correct autostart file path.");
+    }
+
+    return(success);
+}
+
+bool AutoStart::IsAutoStartEnabled()
+{
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_file != "")
+    {
+        return(filesystem::exists(autostart_file));
+    }
+    else
+    {
+        return(false);
+    }
+}
+
+std::string AutoStart::GetExePath()
+{
+    /*-------------------------------------------------*\
+    | Create the OpenRGB executable path                |
+    \*-------------------------------------------------*/
+    char exepath[ PATH_MAX ];
+
+    ssize_t count = readlink("/proc/self/exe", exepath, PATH_MAX);
+    
+    return(std::string(exepath, (count > 0) ? count : 0));
+}
+
+/*-----------------------------------------------------*\
+| Linux AutoStart Implementation                        |
+| Private Methods                                       |
+\*-----------------------------------------------------*/
+
+std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
+{
+    /*-------------------------------------------------*\
+    | Generate a .desktop file from the AutoStart       |
+    | parameters                                        |
+    \*-------------------------------------------------*/
+    std::stringstream fileContents;
+
+    fileContents << "[Desktop Entry]"                               << std::endl;
+    fileContents << "Categories="        << autostart_info.category << std::endl;
+    fileContents << "Comment="           << autostart_info.desc     << std::endl;
+    fileContents << "Icon="              << autostart_info.icon     << std::endl;
+    fileContents << "Name="              << GetAutoStartName()      << std::endl;
+    fileContents << "StartupNotify=true"                            << std::endl;
+    fileContents << "Terminal=false"                                << std::endl;
+    fileContents << "Type=Application"                              << std::endl;
+
+    /*-------------------------------------------------*\
+    | Add the executable path and arguments             |
+    \*-------------------------------------------------*/
+    fileContents << "Exec="              << autostart_info.path;
+
+    if (autostart_info.args != "")
+    {
+        fileContents << " " << autostart_info.args;
+    }
+
+    fileContents << std::endl;
+    
+    return(fileContents.str());
+}
+
+void AutoStart::InitAutoStart(std::string name)
+{
+    std::string autostart_dir;
+
+    autostart_name = name;
+
+    /*-------------------------------------------------*\
+    | Get home and config paths                         |
+    \*-------------------------------------------------*/
+    const char *xdg_config_home = getenv("XDG_CONFIG_HOME");
+    const char *home = getenv("HOME");
+
+    /*-------------------------------------------------*\
+    | Determine where the autostart .desktop files are  |
+    | kept                                              |
+    \*-------------------------------------------------*/
+    if(xdg_config_home != NULL)
+    {
+        autostart_dir = xdg_config_home;
+        autostart_dir = autostart_dir + "/autostart/";
+    }
+    else if(home != NULL)
+    {
+        autostart_dir = home;
+        autostart_dir = autostart_dir + "/.config/autostart/";
+    }
+
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_dir != "")
+    {
+        std::error_code ec;
+
+        bool success = true;
+        
+        if(!filesystem::exists(autostart_dir))
+        {
+            success = filesystem::create_directories(autostart_dir, ec);
+        }
+
+        if(success)
+        {
+            autostart_file = autostart_dir + autostart_name + ".desktop";
+        }
+    }
+}
+
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+#include "AutoStart.h"
+
+class AutoStart: public AutoStartInterface
+{
+public:
+    AutoStart(std::string name);
+
+    bool        DisableAutoStart();
+    bool        EnableAutoStart(AutoStartInfo autostart_info);
+    bool        IsAutoStartEnabled();
+    std::string GetExePath();
+
+private:
+    void        InitAutoStart(std::string name);
+    std::string GenerateDesktopFile(AutoStartInfo autostart_info);
+};
@@ -0,0 +1,208 @@
+#include "AutoStart-MacOS.h"
+#include "LogManager.h"
+#include "filesystem.h"
+
+#include <fstream>
+#include <sstream>
+#include <iostream>
+#include <unistd.h>
+
+#include <mach-o/dyld.h>
+
+/*-----------------------------------------------------*\
+| MacOS AutoStart Implementation                        |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
+
+AutoStart::AutoStart(std::string name)
+{
+    InitAutoStart(name);
+}
+
+bool AutoStart::DisableAutoStart()
+{
+    std::error_code autostart_file_remove_errcode;
+    bool            success                         = false;
+
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_file != "")
+    {
+        /*---------------------------------------------*\
+        | If file doesn't exist, disable is successful  |
+        \*---------------------------------------------*/
+        if(!filesystem::exists(autostart_file))
+        {
+            success = true;
+        }
+        /*---------------------------------------------*\
+        | Otherwise, delete the file                    |
+        \*---------------------------------------------*/
+        else
+        {
+            success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
+
+            if(!success)
+            {
+                LOG_ERROR("[AutoStart] An error occurred removing the auto start file.");
+            }
+        }
+    }
+    else
+    {
+        LOG_ERROR("Could not establish correct autostart file path.");
+    }
+
+    return(success);
+}
+
+bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
+{
+    bool        success                             = false;
+
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_file != "")
+    {
+        std::string     desktop_file                = GenerateLaunchAgentFile(autostart_info);
+        std::ofstream   autostart_file_stream(autostart_file, std::ios::out | std::ios::trunc);
+
+        /*---------------------------------------------*\
+        | Error out if the file could not be opened     |
+        \*---------------------------------------------*/
+        if(!autostart_file_stream)
+        {
+            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
+            success = false;
+        }
+        /*---------------------------------------------*\
+        | Otherwise, write the file                     |
+        \*---------------------------------------------*/
+        else
+        {
+            autostart_file_stream << desktop_file;
+            autostart_file_stream.close();
+            success = !autostart_file_stream.fail();
+
+            if (!success)
+            {
+                LOG_ERROR("An error occurred writing the auto start file.");
+            }
+        }
+    }
+    else
+    {
+        LOG_ERROR("Could not establish correct autostart file path.");
+    }
+
+    return(success);
+}
+
+bool AutoStart::IsAutoStartEnabled()
+{
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_file != "")
+    {
+        return(filesystem::exists(autostart_file));
+    }
+    else
+    {
+        return(false);
+    }
+}
+
+std::string AutoStart::GetExePath()
+{
+    /*-------------------------------------------------*\
+    | Create the OpenRGB executable path                |
+    \*-------------------------------------------------*/
+    char     exepath[ PATH_MAX ];
+    uint32_t exesize = PATH_MAX;
+
+    int ret_val = _NSGetExecutablePath(exepath, &exesize);
+
+    return(std::string(exepath, (ret_val == 0) ? strlen(exepath) : 0));
+
+    return("");
+}
+
+/*-----------------------------------------------------*\
+| MacOS AutoStart Implementation                        |
+| Private Methods                                       |
+\*-----------------------------------------------------*/
+
+std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
+{
+    /*-------------------------------------------------*\
+    | Generate a .plist file from the AutoStart         |
+    | parameters                                        |
+    \*-------------------------------------------------*/
+    std::stringstream fileContents;
+
+    fileContents << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"                                                                    << std::endl;
+    fileContents << "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">"    << std::endl;
+    fileContents << "<plist version=\"1.0\">"                                                                                       << std::endl;
+    fileContents << "<dict>"                                                                                                        << std::endl;
+    fileContents << "    <key>Label</key>"                                                                                          << std::endl;
+    fileContents << "    <string>org.openrgb</string>"                                                                              << std::endl;
+    fileContents << "    <key>ProgramArguments</key>"                                                                               << std::endl;
+    fileContents << "    <array>"                                                                                                   << std::endl;
+    fileContents << "        <string>" << autostart_info.path << "</string>"                                                        << std::endl;
+    
+    if(autostart_info.args != "")
+    {
+        std::istringstream arg_parser(autostart_info.args);
+        std::string arg;
+
+        while(arg_parser >> arg)
+        {
+            fileContents << "        <string>" << arg << "</string>"                                                                << std::endl;
+        }
+    }
+    
+    fileContents << "    </array>"                                                                                                  << std::endl;
+    fileContents << "    <key>RunAtLoad</key><true/>"                                                                               << std::endl;
+    fileContents << "</dict>"                                                                                                       << std::endl;
+    fileContents << "</plist>"                                                                                                      << std::endl;
+    
+    return(fileContents.str());
+}
+
+void AutoStart::InitAutoStart(std::string name)
+{
+    std::string autostart_dir;
+
+    autostart_name = name;
+
+    /*-------------------------------------------------*\
+    | Determine where the autostart .desktop files are  |
+    | kept                                              |
+    \*-------------------------------------------------*/
+    autostart_dir = getenv("HOME");
+    autostart_dir = autostart_dir + "/Library/LaunchAgents/";
+
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_dir != "")
+    {
+        std::error_code ec;
+
+        bool success = true;
+        
+        if(!filesystem::exists(autostart_dir))
+        {
+            success = filesystem::create_directories(autostart_dir, ec);
+        }
+
+        if(success)
+        {
+            autostart_file = autostart_dir + autostart_name + ".plist";
+        }
+    }
+}
+
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+#include "AutoStart.h"
+
+class AutoStart: public AutoStartInterface
+{
+public:
+    AutoStart(std::string name);
+
+    bool            DisableAutoStart();
+    bool            EnableAutoStart(AutoStartInfo autostart_info);
+    bool            IsAutoStartEnabled();
+    std::string     GetExePath();
+
+private:
+    void            InitAutoStart(std::string name);
+    std::string     GenerateLaunchAgentFile(AutoStartInfo autostart_info);
+};
@@ -0,0 +1,204 @@
+#include "AutoStart-Windows.h"
+#include "LogManager.h"
+#include "filesystem.h"
+
+#include <fstream>
+#include <iostream>
+
+#include "windows.h"
+#include <shlobj.h>
+
+/*-----------------------------------------------------*\
+| Windows AutoStart Implementation                      |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
+
+AutoStart::AutoStart(std::string name)
+{
+    InitAutoStart(name);
+}
+
+bool AutoStart::DisableAutoStart()
+{
+    std::error_code autostart_file_remove_errcode;
+    bool success                                    = false;
+
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_file != "")
+    {
+        /*---------------------------------------------*\
+        | If file doesn't exist, disable is successful  |
+        \*---------------------------------------------*/
+        if(!filesystem::exists(autostart_file))
+        {
+            success = true;
+        }
+        /*---------------------------------------------*\
+        | Otherwise, delete the file                    |
+        \*---------------------------------------------*/
+        else
+        {
+            success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
+            
+            if(!success)
+            {
+                LOG_ERROR("An error occurred removing the auto start file.");
+            }
+        }
+    }
+    else
+    {
+        LOG_ERROR("Could not establish correct autostart file path.");
+    }
+
+    return(success);
+}
+
+bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
+{
+    bool success                                    = false;
+
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_file != "")
+    {
+        bool            weInitialised               = false;
+        HRESULT         result;
+        IShellLinkW*    shellLink                   = NULL;
+
+        std::wstring    exepathw                    = utf8_decode(autostart_info.path);
+        std::wstring    argumentsw                  = utf8_decode(autostart_info.args);
+        std::wstring    startupfilepathw            = utf8_decode(autostart_file);
+        std::wstring    descriptionw                = utf8_decode(autostart_info.desc);
+        std::wstring    iconw                       = utf8_decode(autostart_info.path);
+
+        result                                      = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);
+
+        /*---------------------------------------------*\
+        | If not initialized, initialize                |
+        \*---------------------------------------------*/
+        if(result == CO_E_NOTINITIALIZED)
+        {
+            weInitialised                           = true;
+            CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
+            result                                  = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);
+        }
+
+        /*---------------------------------------------*\
+        | If successfully initialized, save a shortcut  |
+        | from the AutoStart parameters                 |
+        \*---------------------------------------------*/
+        if(SUCCEEDED(result))
+        {
+            shellLink->SetPath(exepathw.c_str());
+            shellLink->SetArguments(argumentsw.c_str());
+            shellLink->SetDescription(descriptionw.c_str());
+            shellLink->SetIconLocation(iconw.c_str(), 0);
+            
+            IPersistFile* persistFile;
+            
+            result                                  = shellLink->QueryInterface(IID_IPersistFile, (void**)&persistFile);
+            
+            if(SUCCEEDED(result))
+            {
+                result                              = persistFile->Save(startupfilepathw.c_str(), TRUE);
+                success                             = SUCCEEDED(result);
+                persistFile->Release();
+            }
+
+            shellLink->Release();
+        }
+
+        /*---------------------------------------------*\
+        | Uninitialize when done                        |
+        \*---------------------------------------------*/
+        if(weInitialised)
+        {
+            CoUninitialize();
+        }
+    }
+    else
+    {
+        LOG_ERROR("Could not establish correct autostart file path.");
+    }
+
+    return success;
+}
+
+bool AutoStart::IsAutoStartEnabled()
+{
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
+    if(autostart_file != "")
+    {
+        return(filesystem::exists(autostart_file));
+    }
+    else
+    {
+        return(false);
+    }
+}
+
+std::string AutoStart::GetExePath()
+{
+    /*-------------------------------------------------*\
+    | Create the OpenRGB executable path                |
+    \*-------------------------------------------------*/
+    char exepath[MAX_PATH] = "";
+
+    DWORD count = GetModuleFileNameA(NULL, exepath, MAX_PATH);
+    
+    return(std::string(exepath, (count > 0) ? count : 0));
+}
+
+/*-----------------------------------------------------*\
+| Windows AutoStart Implementation                      |
+| Private Methods                                       |
+\*-----------------------------------------------------*/
+
+void AutoStart::InitAutoStart(std::string name)
+{
+    char startMenuPath[MAX_PATH];
+
+    autostart_name = name;
+
+    /*-------------------------------------------------*\
+    | Get startup applications path                     |
+    \*-------------------------------------------------*/
+    HRESULT result = SHGetFolderPathA(NULL, CSIDL_PROGRAMS, NULL, 0, startMenuPath);
+
+    if(SUCCEEDED(result))
+    {
+        autostart_file = std::string(startMenuPath);
+
+        autostart_file += "\\Startup\\" + autostart_name + ".lnk";
+    }
+    else
+    {
+        autostart_file.clear();
+    }
+}
+
+/*-----------------------------------------------------*\
+| Convert an UTF8 string to a wide Unicode String       |
+| (from wmi.cpp)                                        |
+\*-----------------------------------------------------*/
+std::wstring AutoStart::utf8_decode(const std::string& str)
+{
+    if(str.empty())
+    {
+        return std::wstring();
+    }
+
+    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), nullptr, 0);
+
+    std::wstring wstrTo(size_needed, 0);
+    
+    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), &wstrTo[0], size_needed);
+    
+    return(wstrTo);
+}
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+#include "AutoStart.h"
+
+class AutoStart: public AutoStartInterface
+{
+public:
+    AutoStart(std::string name);
+
+    bool            DisableAutoStart();
+    bool            EnableAutoStart(AutoStartInfo autostart_info);
+    bool            IsAutoStartEnabled();
+    std::string     GetExePath();
+
+private:
+    void            InitAutoStart(std::string name);
+    std::wstring    utf8_decode(const std::string& str);
+};
@@ -0,0 +1,16 @@
+#include "AutoStart.h"
+
+/*-----------------------------------------------------*\
+| Common AutoStart Implementation                       |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
+
+std::string AutoStartInterface::GetAutoStartFile()
+{
+    return(autostart_file);
+}
+
+std::string AutoStartInterface::GetAutoStartName()
+{
+    return(autostart_name);
+}
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <string>
+
+struct AutoStartInfo
+{
+    std::string path;
+    std::string args;
+    std::string desc;
+    std::string icon;
+    std::string category;
+};
+
+class AutoStartInterface
+{
+public:
+    virtual bool        DisableAutoStart()                              = 0;
+    virtual bool        EnableAutoStart(AutoStartInfo autostart_info)   = 0;
+    virtual bool        IsAutoStartEnabled()                            = 0;
+    virtual std::string GetExePath()                                    = 0;
+
+    std::string         GetAutoStartFile();
+    std::string         GetAutoStartName();
+
+protected:
+    std::string         autostart_file;
+    std::string         autostart_name;
+};
+
+#ifdef _WIN32
+#include "AutoStart-Windows.h"
+#endif
+
+#ifdef __linux__
+#include "AutoStart-Linux.h"
+#endif
+
+#ifdef __APPLE__
+#include "AutoStart-MacOS.h"
+#endif
@@ -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
@@ -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
@@ -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;

@@ -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;
    }
@@ -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_DEBUG("Device type is ASR RGB LED");
+            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_DEBUG("Device type is Polychrome v1");
+            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_DEBUG("Device type is Polychrome v2");
+            LOG_TRACE("[%s] Device type is Polychrome v2", ASROCK_CONTROLLER_NAME);
            asrock_type = ASROCK_TYPE_POLYCHROME_V2;
            ReadLEDConfiguration();
            break;

        default:
-            LOG_DEBUG("Got Unknown version!");
+            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("Reading back device firmware version");
+    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("Device firmware version: v%02d.%02d", major, minor);
+        LOG_DEBUG("[%s] Device firmware version: v%02d.%02d", ASROCK_CONTROLLER_NAME, major, minor);
        return((major << 8) | minor);
    }
    else
    {
-        LOG_WARNING("Firmware readback failed; Returning 0xFFFF");
+        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("Reading back LED config");
+    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("Zone 1 LED count: %02d", zone_led_count[POLYCHROME_ZONE_1]);
-        LOG_DEBUG("Zone 2 LED count: %02d", zone_led_count[POLYCHROME_ZONE_2]);
-        LOG_DEBUG("Zone 3 LED count: %02d", zone_led_count[POLYCHROME_ZONE_3]);
-        LOG_DEBUG("Zone 4 LED count: %02d", zone_led_count[POLYCHROME_ZONE_4]);
-        LOG_DEBUG("Zone 5 LED count: %02d", zone_led_count[POLYCHROME_ZONE_5]);
-        LOG_DEBUG("Addressable Zone LED count: %02d", 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("LED config read failed");
+        LOG_WARNING("[%s] LED config read failed", ASROCK_CONTROLLER_NAME);
        memset(zone_led_count, 0, sizeof(zone_led_count));
    }
 }
@@ -15,6 +15,11 @@

 typedef unsigned char	polychrome_dev_id;

+#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
 {
    ASROCK_TYPE_UNKNOWN                     = 0x00,     /* Unknown Type or Not ASRock Device    */
@@ -54,24 +54,36 @@ void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
    {
        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
        {
-            // Check for Polychrome controller at 0x6A
-            if (TestForPolychromeSMBusController(busses[bus], 0x6A))
+            if(busses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
            {
-                LOG_DEBUG("Detected a device at address 0x6A, Testing for a known controller");
-                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_DEBUG("Found a known Polychrome device");
-                    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_DEBUG("Not a Polychrome device or unknown type");
-                    delete new_polychrome;
+                    LOG_DEBUG("[%s] Bus %02d no response at %02X", ASROCK_DETECTOR_NAME, bus, SMBUS_ADDRESS);
                }
            }
+            else
+            {
+                LOG_DEBUG(SMBUS_CHECK_DEVICE_FAILURE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME);
+            } 
        }
    }

@@ -0,0 +1,826 @@
+/*-----------------------------------------*\
+|  AlienwareController.cpp                  |
+|                                           |
+|  Driver for Alienware lighting controller |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/21/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include "AlienwareController.h"
+#include <cstring>
+#include <cstdint>
+#include <map>
+#include <thread>
+#include <chrono>
+#include <algorithm>
+#include <sstream>
+
+typedef uint32_t alienware_platform_id;
+
+/*---------------------------------------------------------*\
+| Some devices appear to report the wrong number of zones.  |
+| Record that here.                                         |
+\*---------------------------------------------------------*/
+static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
+{
+    { 0x0C01,   4 }, // Dell G5 SE 5505
+    { 0x0A01,  16 }  // Dell G7 15 7500
+};
+
+/*---------------------------------------------------------*\
+| Add zones for devices here, mapping the platform ID to    |
+| the zone names                                            |
+\*---------------------------------------------------------*/
+static const std::map<alienware_platform_id, std::vector<const char*>> zone_names_table =
+{
+    { 0x0C01,   { "Left",           "Middle",       "Right",        "Numpad"    } },
+    { 0x0A01,   { "Left",           "Center Left",  "Center Right", "Right",
+                  "Light Bar 1",    "Light Bar 2",  "Light Bar 3",
+                  "Light Bar 4",    "Light Bar 5",  "Light Bar 6",
+                  "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
+                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } }
+};
+
+static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
+{
+    using namespace std::chrono_literals;
+
+    hid_send_feature_report(dev, usb_buf, usb_buf_size);
+
+    /*-----------------------------------------------------*\
+    | The controller really doesn't like really spammed by  |
+    | too many commands at once... the delay may be command |
+    | dependent also.  Delay for longer if the command is   |
+    | changing animation state                              |
+    \*-----------------------------------------------------*/
+    unsigned char command       = usb_buf[2];
+    unsigned char subcommand    = usb_buf[3];
+
+    if( ( command == ALIENWARE_COMMAND_USER_ANIM                    )
+     && ( ( subcommand == ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY )
+       || ( subcommand == ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE ) ) )
+    {
+        std::this_thread::sleep_for(1s);
+    }
+    else
+    {
+        std::this_thread::sleep_for(60ms);
+    }
+}
+
+AlienwareController::AlienwareController(hid_device* dev_handle, const hid_device_info& info, std::string name)
+{
+    HidapiAlienwareReport report;
+
+    dev                 = dev_handle;
+    device_name         = name;
+    location            = info.path;
+
+    /*-----------------------------------------------------*\
+    | Get serial number                                     |
+    \*-----------------------------------------------------*/
+    std::wstring tmp_serial_number;
+    tmp_serial_number   = info.serial_number;
+    serial_number       = std::string(tmp_serial_number.begin(), tmp_serial_number.end());
+
+    /*-----------------------------------------------------*\
+    | Get zone information by checking firmware             |
+    | configuration                                         |
+    \*-----------------------------------------------------*/
+    report              = Report(ALIENWARE_COMMAND_REPORT_CONFIG);
+    alienware_platform_id platform_id = report.data[4] << 8 | report.data[5];
+
+    /*-----------------------------------------------------*\
+    | Get firmware version                                  |
+    \*-----------------------------------------------------*/
+    report              = Report(ALIENWARE_COMMAND_REPORT_FIRMWARE);
+
+    std::stringstream fw_string;
+
+    fw_string << static_cast<unsigned>(report.data[4]) << '.' << static_cast<unsigned>(report.data[5]) << '.' << static_cast<unsigned>(report.data[6]);
+    version             = fw_string.str();
+
+    /*-----------------------------------------------------*\
+    | Check if the device reports the wrong number of zones |
+    \*-----------------------------------------------------*/
+    unsigned number_of_zones = zone_quirks_table.count(platform_id) ? zone_quirks_table.at(platform_id) : report.data[6];
+
+    /*-----------------------------------------------------*\
+    | Initialize Alienware zones                            |
+    \*-----------------------------------------------------*/
+    zones.resize(number_of_zones);
+
+    if(zone_names_table.count(platform_id))
+    {
+        zone_names = zone_names_table.at(platform_id);
+    }
+    else
+    {
+        /*-------------------------------------------------*\
+        | If this is an unknown controller, set the name of |
+        | all regions to "Unknown"                          |
+        \*-------------------------------------------------*/
+        for(size_t i = 0; i < number_of_zones; i++)
+        {
+            zone_names.emplace_back("Unknown");
+        }
+    }
+
+    /*-----------------------------------------------------*\
+    | Set defaults for all zones                            |
+    | It doesn't seem possible to read the controller's     |
+    | current state, hence the default value being set here.|
+    \*-----------------------------------------------------*/
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        zones[zone_idx].color[0]    = 0x000000;
+        zones[zone_idx].color[1]    = 0x000000;
+        zones[zone_idx].mode        = ALIENWARE_MODE_COLOR;
+
+        /*-------------------------------------------------*\
+        | Default period value from ACC                     |
+        \*-------------------------------------------------*/
+        zones[zone_idx].period      = 2000;
+        zones[zone_idx].tempo       = ALIENWARE_TEMPO_MAX;
+        zones[zone_idx].dim         = 0;
+    }
+
+    /*-----------------------------------------------------*\
+    | Initialize dirty flags                                |
+    \*-----------------------------------------------------*/
+    dirty               = true;
+    dirty_dim           = true;
+}
+
+AlienwareController::~AlienwareController()
+{
+
+}
+
+unsigned int AlienwareController::GetZoneCount()
+{
+    return(zones.size());
+}
+
+std::vector<const char*> AlienwareController::GetZoneNames()
+{
+    return(zone_names);
+}
+
+std::string AlienwareController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AlienwareController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string AlienwareController::GetSerialString()
+{
+    return(serial_number);
+}
+
+std::string AlienwareController::GetFirmwareVersion()
+{
+    return(version);
+}
+
+AlienwareController::HidapiAlienwareReport AlienwareController::GetResponse()
+{
+    /*-----------------------------------------------------*\
+    | Zero init. This is not updated if there's a problem.  |
+    \*-----------------------------------------------------*/
+    HidapiAlienwareReport result;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(result.data, 0x00, sizeof(result.data));
+
+
+    hid_get_feature_report(dev, result.data, HIDAPI_ALIENWARE_REPORT_SIZE);
+
+    return(result);
+}
+
+AlienwareController::HidapiAlienwareReport AlienwareController::Report(uint8_t subcommand)
+{
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00] = 0x00;
+    usb_buf[0x01] = 0x03;
+    usb_buf[0x02] = ALIENWARE_COMMAND_REPORT;
+    usb_buf[0x03] = subcommand;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    return(GetResponse());
+}
+
+AlienwareReport AlienwareController::GetStatus(uint8_t subcommand)
+{
+    HidapiAlienwareReport   data    = Report(subcommand);
+    AlienwareReport         result  = AlienwareReport{};
+
+    /*-----------------------------------------------------*\
+    | Skip first byte, as that's the report number, which   |
+    | should be 0                                           |
+    \*-----------------------------------------------------*/
+    memcpy(result.data, &data.data[1], sizeof(result.data));
+
+    return(result);
+}
+
+bool AlienwareController::Dim(std::vector<uint8_t> zones, double percent)
+{
+    /*-----------------------------------------------------*\
+    | Bail out if there are no zones to update              |
+    \*-----------------------------------------------------*/
+    if(!zones.size())
+    {
+        return(true);
+    }
+
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    uint16_t num_zones  = zones.size();
+
+    usb_buf[0x00]       = 0x00;
+    usb_buf[0x01]       = 0x03;
+    usb_buf[0x02]       = ALIENWARE_COMMAND_DIM;
+    usb_buf[0x03]       = static_cast<uint8_t>(percent);
+    usb_buf[0x04]       = num_zones >> 8;
+    usb_buf[0x05]       = num_zones & 0xFF;
+
+    for(size_t i = 0; i < num_zones; i++)
+    {
+        usb_buf[0x06+i] = zones[i];
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | For this command, error is if the output equals the   |
+    | input                                                 |
+    \*-----------------------------------------------------*/
+    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
+}
+
+bool AlienwareController::UserAnimation(uint16_t subcommand, uint16_t animation, uint16_t duration)
+{
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00 per hidapi      |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]       = 0x00;
+    usb_buf[0x01]       = 0x03;
+    usb_buf[0x02]       = ALIENWARE_COMMAND_USER_ANIM;
+    usb_buf[0x03]       = subcommand >> 8;
+    usb_buf[0x04]       = subcommand & 0xFF;
+    usb_buf[0x05]       = animation >> 8;
+    usb_buf[0x06]       = animation & 0xFF;
+    usb_buf[0x07]       = duration >> 8;
+    usb_buf[0x08]       = duration & 0xFF;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Every subcommand appears to report its result on a    |
+    | different byte                                        |
+    \*-----------------------------------------------------*/
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | The only time the 0x03 byte is zero is if the         |
+    | controller has crashed                                |
+    \*-----------------------------------------------------*/
+    if(response.data[1] == 0)
+    {
+        return(false);
+    }
+
+    switch(subcommand)
+    {
+        case ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE:
+            return(!response.data[7]);
+        case ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY:
+            return(!response.data[5]);
+        case ALIENWARE_COMMAND_USER_ANIM_PLAY:
+            return(!response.data[7]);
+        default:
+            return(true);
+    }
+}
+
+bool AlienwareController::SelectZones(const std::vector<uint8_t>& zones)
+{
+    /*-----------------------------------------------------*\
+    | Bail if zones is empty, and return false to indicate  |
+    | nothing has changed                                   |
+    \*-----------------------------------------------------*/
+    if(!zones.size())
+    {
+        return(false);
+    }
+
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    uint16_t num_zones  = zones.size();
+
+    usb_buf[0x00]       = 0x00;
+    usb_buf[0x01]       = 0x03;
+    usb_buf[0x02]       = ALIENWARE_COMMAND_SELECT_ZONES;
+    usb_buf[0x03]       = 1; // loop?
+    usb_buf[0x04]       = num_zones >> 8;
+    usb_buf[0x05]       = num_zones & 0xFF;
+
+    for(size_t i = 0; i < num_zones; i++)
+    {
+        usb_buf[0x06+i] = zones[i];
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | For this command, error is if the output equals the   |
+    | input                                                 |
+    \*-----------------------------------------------------*/
+    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
+}
+
+bool AlienwareController::ModeAction(uint8_t mode, uint16_t duration, uint16_t tempo, RGBColor color)
+{
+    return(ModeAction(&mode, &duration, &tempo, &color, 1));
+}
+
+bool AlienwareController::ModeAction
+    (
+    const uint8_t*  mode,
+    const uint16_t* duration,
+    const uint16_t* tempo,
+    const RGBColor* color,
+    unsigned        amount
+    )
+{
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Amount must be 3 or less, as that's how many          |
+    | subcommands can fit into one report                   |
+    \*-----------------------------------------------------*/
+    if(amount > 3)
+    {
+        return(false);
+    }
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]               = 0x00;
+    usb_buf[0x01]               = 0x03;
+    usb_buf[0x02]               = ALIENWARE_COMMAND_ADD_ACTION;
+
+    for(unsigned int i = 0; i < amount; i++)
+    {
+        usb_buf[0x03 + (8 * i)] = mode[i];
+        usb_buf[0x04 + (8 * i)] = duration[i] >> 8;
+        usb_buf[0x05 + (8 * i)] = duration[i] & 0xFF;
+        usb_buf[0x06 + (8 * i)] = tempo[i] >> 8;
+        usb_buf[0x07 + (8 * i)] = tempo[i] & 0xFF;
+        usb_buf[0x08 + (8 * i)] = RGBGetRValue(color[i]);
+        usb_buf[0x09 + (8 * i)] = RGBGetGValue(color[i]);
+        usb_buf[0x0A + (8 * i)] = RGBGetBValue(color[i]);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | For this command, error is if the output equals the   |
+    | input                                                 |
+    \*-----------------------------------------------------*/
+    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
+}
+
+bool AlienwareController::MultiModeAction
+    (
+    const uint8_t*  mode,
+    const uint16_t* duration,
+    const uint16_t* tempo,
+    const RGBColor* color,
+    unsigned        amount
+    )
+{
+    bool         result = true;
+    unsigned int left   = amount;
+
+    while(left && result)
+    {
+        unsigned int tmp_amount;
+
+        tmp_amount          = std::min(left, 3u);
+        result             &= ModeAction(mode, duration, tempo, color, tmp_amount);
+        mode               += tmp_amount;
+        duration           += tmp_amount;
+        tempo              += tmp_amount;
+        color              += tmp_amount;
+        left               -= tmp_amount;
+    }
+
+    return(result);
+}
+
+bool AlienwareController::SetColorDirect(RGBColor color, std::vector<uint8_t> zones)
+{
+    /*-----------------------------------------------------*\
+    | Bail if zones is empty                                |
+    \*-----------------------------------------------------*/
+    if(zones.empty())
+    {
+        return(true);
+    }
+
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    uint16_t num_zones      = zones.size();
+
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x03;
+    usb_buf[0x02]           = ALIENWARE_COMMAND_SET_COLOR;
+    usb_buf[0x03]           = RGBGetRValue(color);
+    usb_buf[0x04]           = RGBGetGValue(color);
+    usb_buf[0x05]           = RGBGetBValue(color);
+    usb_buf[0x06]           = num_zones >> 8;
+    usb_buf[0x07]           = num_zones & 0xFF;
+
+    for(size_t i = 0; i < num_zones; i++)
+    {
+        usb_buf[0x08 + i]   = zones[i];
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | For this command, error is if the output equals the   |
+    | input                                                 |
+    \*-----------------------------------------------------*/
+    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
+}
+
+bool AlienwareController::Reset()
+{
+    /*-----------------------------------------------------*\
+    | Bail if zones is empty                                |
+    \*-----------------------------------------------------*/
+    if(zones.empty())
+    {
+        return(true);
+    }
+
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]       = 0x00;
+    usb_buf[0x01]       = 0x03;
+    usb_buf[0x02]       = ALIENWARE_COMMAND_RESET;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | For this command, error is if the output equals the   |
+    | input                                                 |
+    \*-----------------------------------------------------*/
+    return(response.data[1] == 0x03);
+}
+
+void AlienwareController::SetMode(uint8_t zone, uint8_t mode)
+{
+    if(mode != zones[zone].mode)
+    {
+        zones[zone].mode        = mode;
+        dirty                   = true;
+    }
+}
+
+void AlienwareController::SetColor(uint8_t zone, RGBColor color)
+{
+    SetColor(zone, color, zones[zone].color[1]);
+}
+
+void AlienwareController::SetColor(uint8_t zone, RGBColor color1, RGBColor color2)
+{
+    dirty = ((color1 != zones[zone].color[0]) || (color2 != zones[zone].color[1]));
+
+	if(dirty)
+	{
+		zones[zone].color[0] = color1;
+        zones[zone].color[1] = color2;
+	}
+}
+
+void AlienwareController::SetPeriod(uint8_t zone, uint16_t period)
+{
+    if(period != zones[zone].period)
+    {
+        zones[zone].period      = period;
+        dirty                   = true;
+    }
+}
+
+void AlienwareController::SetTempo(uint8_t zone, uint16_t tempo)
+{
+    if(tempo != zones[zone].tempo)
+    {
+        zones[zone].tempo       = tempo;
+        dirty                   = true;
+    }
+}
+
+void AlienwareController::SetDim(uint8_t zone, uint8_t dim)
+{
+    if(dim != zones[zone].dim)
+    {
+        zones[zone].dim         = dim;
+        dirty_dim               = true;
+    }
+}
+
+void AlienwareController::UpdateDim()
+{
+    if(!dirty_dim)
+    {
+        return;
+    }
+
+    /*-----------------------------------------------------*\
+    | Collect all zones that share dim settings, and update |
+    | them together                                         |
+    \*-----------------------------------------------------*/
+    std::map<uint8_t, std::vector<uint8_t>> dim_zone_map;
+
+    for(size_t i = 0; i < zones.size(); i++)
+    {
+        dim_zone_map[zones[i].dim].emplace_back(i);
+    }
+
+    for(std::pair<const uint8_t, std::vector<uint8_t>> &pair : dim_zone_map)
+    {
+        /*-------------------------------------------------*\
+        | Bail on an error...                               |
+        \*-------------------------------------------------*/
+        if(!Dim(pair.second, pair.first))
+        {
+            return;
+        }
+    }
+
+    dirty_dim = false;
+}
+
+bool AlienwareController::UpdateDirect()
+{
+    /*-----------------------------------------------------*\
+    | Collect all zones that share dim settings, and update |
+    | them together                                         |
+    \*-----------------------------------------------------*/
+    std::map<RGBColor, std::vector<uint8_t>> color_zone_map;
+
+    for(size_t i = 0; i < zones.size(); i++)
+    {
+        color_zone_map[zones[i].color[0]].emplace_back(i);
+    }
+
+    for(std::pair<const RGBColor, std::vector<uint8_t>> &pair : color_zone_map)
+    {
+        /*-------------------------------------------------*\
+        | Bail on an error...                               |
+        \*-------------------------------------------------*/
+        if(!SetColorDirect(pair.first, pair.second))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+static const RGBColor rainbow_colors[4][7] =
+{
+    { 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000, 0x00BFFF, 0x0000FF, 0x800080 },
+    { 0x800080, 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000, 0x00BFFF, 0x0000FF },
+    { 0x0000FF, 0x800080, 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000, 0x00BFFF },
+    { 0x00BFFF, 0x0000FF, 0x800080, 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000 }
+};
+
+void AlienwareController::UpdateMode()
+{
+    /*-----------------------------------------------------*\
+    | If there are no updates, don't bother running this    |
+    \*-----------------------------------------------------*/
+    if(!dirty)
+    {
+        return;
+    }
+
+    bool result = UserAnimation(ALIENWARE_COMMAND_USER_ANIM_NEW, ALIENWARE_COMMAND_USER_ANIM_KEYBOARD, 0);
+
+    if(!result)
+    {
+        return;
+    }
+
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        alienware_zone zone = zones[zone_idx];
+
+        result = SelectZones({static_cast<uint8_t>(zone_idx)});
+
+        if(!result)
+        {
+            return;
+        }
+
+        /*-------------------------------------------------*\
+        | Some modes use 0x07D0 for their duration as sent  |
+        | by AWCC traces, maybe 2000ms?                     |
+        \*-------------------------------------------------*/
+        switch (zone.mode)
+        {
+            case ALIENWARE_MODE_COLOR:
+                result = ModeAction(zone.mode, 2000, ALIENWARE_TEMPO_MAX, zone.color[0]);
+                break;
+
+            case ALIENWARE_MODE_PULSE:
+                result = ModeAction(zone.mode, zone.period, zone.tempo, zone.color[0]);
+                break;
+
+            case ALIENWARE_MODE_MORPH:
+                {
+                    uint8_t  zones[2]   = { zone.mode,              zone.mode     };
+                    uint16_t periods[2] = { zone.period,            zone.period   };
+                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo    };
+                    RGBColor colors[2]  = { zone.color[0],          zone.color[1] };
+
+                    result = MultiModeAction(zones, periods, tempos, colors, 2);
+                }
+                break;
+
+            case ALIENWARE_MODE_SPECTRUM:
+                {
+                    uint8_t  zones[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH };
+                    uint16_t periods[7] = { zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period };
+                    uint16_t tempos[7] = {  zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo };
+
+                    result = MultiModeAction(zones, periods, tempos, rainbow_colors[0], 7);
+                }
+                break;
+
+            case ALIENWARE_MODE_RAINBOW:
+                {
+                    uint8_t  zones[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH };
+                    uint16_t periods[7] = { zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period };
+                    uint16_t tempos[7]  = { zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo };
+
+                    result = MultiModeAction(zones, periods, tempos, rainbow_colors[zone_idx], 7);
+                }
+                break;
+
+            case ALIENWARE_MODE_BREATHING:
+                {
+                    uint8_t  zones[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
+                    uint16_t periods[2] = { zone.period,            zone.period          };
+                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo           };
+                    RGBColor colors[2]  = { zone.color[0],          0x0                  };
+
+                    result = MultiModeAction(zones, periods, tempos, colors, 2);
+                }
+                break;
+
+            default:
+                result = false;
+        }
+
+        if(!result)
+        {
+            return;
+        }
+    }
+
+    result = UserAnimation(ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY, ALIENWARE_COMMAND_USER_ANIM_KEYBOARD, 0);
+
+    /*-------------------------------------------------*\
+    | Don't update dirty flag if there's an error       |
+    \*-------------------------------------------------*/
+    if(!result)
+    {
+        return;
+    }
+
+    dirty = false;
+}
+
+void AlienwareController::UpdateController()
+{
+    UpdateMode();
+    UpdateDim();
+}
@@ -0,0 +1,161 @@
+/*-----------------------------------------*\
+|  AlienwareController.h                    |
+|                                           |
+|  Driver for Dell Alienware RGB USB        |
+|  controller                               |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
+
+#pragma once
+
+/*----------------------------------------------------------------------------------------------*\
+| Definitions for Alienware Controller                                                           |
+\*----------------------------------------------------------------------------------------------*/
+
+#define ALIENWARE_REPORT_SIZE               33
+#define HIDAPI_ALIENWARE_REPORT_SIZE        (ALIENWARE_REPORT_SIZE + 1)
+
+enum
+{
+    ALIENWARE_COMMAND_REPORT                = 0x20,     /* Set report type to get               */
+    ALIENWARE_COMMAND_USER_ANIM             = 0x21,     /* Set user animation settings          */
+    ALIENWARE_COMMAND_POWER_ANIM            = 0x22,     /* Set power animation settings         */
+    ALIENWARE_COMMAND_SELECT_ZONES          = 0x23,     /* Select zones to apply actions to     */
+    ALIENWARE_COMMAND_ADD_ACTION            = 0x24,     /* Set actions to apply                 */
+    ALIENWARE_COMMAND_UNKNOWN1              = 0x25,     /* Supposedly set event?                */
+    ALIENWARE_COMMAND_DIM                   = 0x26,     /* Set dim percentage                   */
+    ALIENWARE_COMMAND_SET_COLOR             = 0x27,     /* Unclear (causes color flash)         */
+    ALIENWARE_COMMAND_RESET                 = 0x28,     /* Reset                                */
+    ALIENWARE_COMMAND_ERASE_FLASH           = 0xFF,     /* Erases flash memory on controller    */
+};
+
+enum
+{
+    ALIENWARE_COMMAND_REPORT_FIRMWARE       = 0x00,     /* Get firmware verion                  */
+    ALIENWARE_COMMAND_REPORT_STATUS         = 0x01,     /* Get status                           */
+    ALIENWARE_COMMAND_REPORT_CONFIG         = 0x02,     /* Get firmware config                  */
+    ALIENWARE_COMMAND_REPORT_ANIMATION      = 0x03,     /* Get animation count and last id      */
+    ALIENWARE_COMMAND_REPORT_UNKNOWN1       = 0x04,     /* Get ELC animation by ID              */
+    ALIENWARE_COMMAND_REPORT_UNKNOWN2       = 0x05,     /* Read series???                       */
+    ALIENWARE_COMMAND_REPORT_UNKNOWN3       = 0x06,     /* Get action???                        */
+    ALIENWARE_COMMAND_REPORT_UNKNOWN4       = 0x07,     /* Get Caldera status???                */
+};
+
+enum
+{
+    ALIENWARE_COMMAND_USER_ANIM_NEW         = 0x0001,   /* Start new animation                  */
+    ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE = 0x0002,   /* Finish and save animation            */
+    ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY = 0x0003,   /* Finish and play animation            */
+    ALIENWARE_COMMAND_USER_ANIM_REMOVE      = 0x0004,   /* Remove/erase animation               */
+    ALIENWARE_COMMAND_USER_ANIM_PLAY        = 0x0005,   /* Play animation                       */
+    ALIENWARE_COMMAND_USER_ANIM_DEFAULT     = 0x0006,   /* Set default animation                */
+    ALIENWARE_COMMAND_USER_ANIM_STARTUP     = 0x0007,   /* Set startup animation                */
+};
+
+enum
+{
+    ALIENWARE_ANIM_DEFAULT_STARTUP          = 0x0008,   /* Default slot for startup             */
+    ALIENWARE_ANIM_DEFAULT                  = 0x0061,   /* Default slot                         */
+    ALIENWARE_COMMAND_USER_ANIM_KEYBOARD    = 0xFFFF,   /* Non-saved animation slot             */
+};
+
+enum
+{
+    ALIENWARE_MODE_COLOR                    = 0x00,     /* Action to set color mode             */
+    ALIENWARE_MODE_PULSE                    = 0x01,     /* Action to set pulse mode             */
+    ALIENWARE_MODE_MORPH                    = 0x02,     /* Action to set morph mode             */
+    ALIENWARE_MODE_SPECTRUM,                            /* Abitrary code for spectrum mode      */
+    ALIENWARE_MODE_RAINBOW,                             /* Arbitrary code for rainbow wave mode */
+    ALIENWARE_MODE_BREATHING,                           /* Arbitrary code for rainbow wave mode */
+};
+
+enum
+{
+    ALIENWARE_TEMPO_MIN                     = 0x0064,   /* Min tempo (as used by AWCC)          */
+    ALIENWARE_TEMPO_MAX                     = 0x00FA,   /* Max tempo (as used by AWCC)          */
+    ALIENWARE_TEMPO_SPECTRUM                = 0x000F,   /* Used by Spectrum mode                */
+};
+
+enum
+{
+    ALIENWARE_DURATION_LONG                 = 0x09C4,   /* Min tempo (as used by AWCC)          */
+    ALIENWARE_DURATION_MED                  = 0x05DC,   /* Max tempo (as used by AWCC)          */
+    ALIENWARE_DURATION_SHORT                = 0x01F3,   /* Max tempo (as used by AWCC)          */
+    ALIENWARE_DURATION_SPECTRUM             = 0x01AC,   /* Used by Spectrum mode                */
+};
+
+typedef struct
+{
+    unsigned char           data[ALIENWARE_REPORT_SIZE];
+} AlienwareReport;
+
+class AlienwareController
+{
+public:
+    AlienwareController(hid_device* dev_handle, const hid_device_info& info, std::string name);
+    ~AlienwareController();
+
+    std::string                 GetSerialString();
+    std::string                 GetDeviceLocation();
+    std::string                 GetDeviceName();
+    std::string                 GetFirmwareVersion();
+    unsigned                    GetZoneCount();
+    std::vector<const char*>    GetZoneNames();
+
+    void                        SetColor(uint8_t zone, RGBColor color);
+    void                        SetColor(uint8_t zone, RGBColor color1, RGBColor color2);
+    void                        SetMode(uint8_t zone, uint8_t mode);
+    void                        SetPeriod(uint8_t zone, uint16_t period);
+    void                        SetTempo(uint8_t zone, uint16_t tempo);
+    void                        SetDim(uint8_t zone, uint8_t dim);
+    AlienwareReport             GetStatus(uint8_t subcommand);
+
+    void                        UpdateDim();
+    void                        UpdateMode();
+    void                        UpdateController();
+
+protected:
+    hid_device* dev;
+
+private:
+    typedef struct
+    {
+        RGBColor                color[2];
+        uint8_t                 mode;
+        uint16_t                period;
+        uint16_t                tempo;
+        uint8_t                 dim;
+    } alienware_zone;
+
+    typedef struct
+    {
+        unsigned char           data[HIDAPI_ALIENWARE_REPORT_SIZE];
+    } HidapiAlienwareReport;
+
+    std::string                 device_name;
+    std::string                 location;
+    std::vector<alienware_zone> zones;
+    std::string                 serial_number;
+    std::string                 version;
+    std::vector<const char*>    zone_names;
+    bool                        dirty;
+    bool                        dirty_dim;
+
+    HidapiAlienwareReport       GetResponse();
+    HidapiAlienwareReport       Report(uint8_t subcommand);
+
+    bool                        Dim(std::vector<uint8_t> zones, double percent);
+    bool                        UserAnimation(uint16_t subcommand, uint16_t animation, uint16_t duration);
+    bool                        SelectZones(const std::vector<uint8_t>& zones);
+    bool                        ModeAction(uint8_t mode, uint16_t duration, uint16_t tempo, RGBColor color);
+    bool                        ModeAction(const uint8_t *mode, const uint16_t *duration, const uint16_t *tempo, const RGBColor *color, unsigned amount);
+    bool                        MultiModeAction(const uint8_t *mode, const uint16_t *duration, const uint16_t *tempo, const RGBColor *color, unsigned amount);
+    bool                        SetColorDirect(RGBColor color, std::vector<uint8_t> zones);
+    bool                        UpdateDirect();
+    bool                        Reset();
+};
@@ -0,0 +1,29 @@
+#include "Detector.h"
+#include "AlienwareController.h"
+#include "RGBController.h"
+#include "RGBController_Alienware.h"
+
+/*---------------------------------------------------------*\
+| Alienware vendor ID                                       |
+\*---------------------------------------------------------*/
+#define ALIENWARE_VID                               0x187C
+
+/*---------------------------------------------------------*\
+| Alienware product ID                                      |
+\*---------------------------------------------------------*/
+#define ALIENWARE_G_SERIES_PID                         0x0550
+
+void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AlienwareController*     controller     = new AlienwareController(dev, *info, name);
+        RGBController_Alienware* rgb_controller = new RGBController_Alienware(controller);
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID);
@@ -0,0 +1,278 @@
+/*-----------------------------------------*\
+|  RGBController_Alienware.cpp              |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Alienware USB Driver                     |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController_Alienware.h"
+
+#include <thread>
+#include <chrono>
+
+RGBController_Alienware::RGBController_Alienware(AlienwareController* alienware_ptr)
+{
+    alienware                   = alienware_ptr;
+
+    name                        = alienware->GetDeviceName();
+    vendor                      = "Alienware";
+    type                        = DEVICE_TYPE_KEYBOARD;
+    description                 = "Alienware USB Device";
+    location                    = alienware->GetDeviceLocation();
+    serial                      = alienware->GetSerialString();
+    version                     = alienware->GetFirmwareVersion();
+
+    mode Color;
+    Color.name                 = "Static";
+    Color.value                = ALIENWARE_MODE_COLOR;
+    Color.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Color.color_mode           = MODE_COLORS_PER_LED;
+    Color.colors_min           = 1;
+    Color.colors_max           = 1;
+    Color.brightness_min       = 100;
+    Color.brightness_max       = 0;
+    Color.brightness           = 0;
+    modes.push_back(Color);
+
+    mode Pulse;
+    Pulse.name                 = "Flashing";
+    Pulse.value                = ALIENWARE_MODE_PULSE;
+    Pulse.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Pulse.color_mode           = MODE_COLORS_PER_LED;
+    Pulse.colors_min           = 1;
+    Pulse.colors_max           = 1;
+    Pulse.speed_min            = ALIENWARE_TEMPO_MIN;
+    Pulse.speed_max            = ALIENWARE_TEMPO_MAX;
+    Pulse.speed                = ALIENWARE_TEMPO_MIN;
+    Pulse.brightness_min       = 100;
+    Pulse.brightness_max       = 0;
+    Pulse.brightness           = 0;
+    modes.push_back(Pulse);
+
+    mode Morph;
+    Morph.name                 = "Morph";
+    Morph.value                = ALIENWARE_MODE_MORPH;
+    Morph.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Morph.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Morph.colors_min           = 2 * alienware->GetZoneCount();
+    Morph.colors_max           = Morph.colors_min;
+    Morph.colors.resize(Morph.colors_max);
+    Morph.speed_min            = ALIENWARE_TEMPO_MIN;
+    Morph.speed_max            = ALIENWARE_TEMPO_MAX;
+    Morph.speed                = ALIENWARE_TEMPO_MIN;
+    Morph.brightness_min       = 100;
+    Morph.brightness_max       = 0;
+    Morph.brightness           = 0;
+    modes.push_back(Morph);
+
+    mode Spectrum;
+    Spectrum.name              = "Spectrum Cycle";
+    Spectrum.value             = ALIENWARE_MODE_SPECTRUM;
+    Spectrum.flags             = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Spectrum.color_mode        = MODE_COLORS_NONE;
+    Spectrum.speed_min         = ALIENWARE_TEMPO_SPECTRUM;
+    Spectrum.speed_max         = ALIENWARE_TEMPO_MAX;
+    Spectrum.speed             = ALIENWARE_TEMPO_SPECTRUM;
+    Spectrum.brightness_min    = 100;
+    Spectrum.brightness_max    = 0;
+    Spectrum.brightness        = 0;
+    modes.push_back(Spectrum);
+
+    mode Rainbow;
+    Rainbow.name               = "Rainbow Wave";
+    Rainbow.value              = ALIENWARE_MODE_RAINBOW;
+    Rainbow.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Rainbow.color_mode         = MODE_COLORS_NONE;
+    Rainbow.speed_min          = ALIENWARE_TEMPO_SPECTRUM;
+    Rainbow.speed_max          = ALIENWARE_TEMPO_MAX;
+    Rainbow.speed              = ALIENWARE_TEMPO_SPECTRUM;
+    Rainbow.brightness_min     = 100;
+    Rainbow.brightness_max     = 0;
+    Rainbow.brightness         = 0;
+    modes.push_back(Rainbow);
+
+    mode Breathing;
+    Breathing.name             = "Breathing";
+    Breathing.value            = ALIENWARE_MODE_BREATHING;
+    Breathing.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode       = MODE_COLORS_PER_LED;
+    Breathing.colors_min       = 1;
+    Breathing.colors_max       = 1;
+    Breathing.speed_min        = ALIENWARE_TEMPO_MIN;
+    Breathing.speed_max        = ALIENWARE_TEMPO_MAX;
+    Breathing.speed            = ALIENWARE_TEMPO_MIN;
+    Breathing.brightness_min   = 100;
+    Breathing.brightness_max   = 0;
+    Breathing.brightness       = 0;
+    modes.push_back(Breathing);
+
+    SetupZones();
+
+    alienware->UpdateDim();
+}
+
+void RGBController_Alienware::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    std::vector<const char*> zone_names = alienware->GetZoneNames();
+
+    for(unsigned int zone_idx = 0; zone_idx < alienware->GetZoneCount(); zone_idx++)
+    {
+        zone new_zone;
+
+        new_zone.name       = zone_names[zone_idx];
+        new_zone.type       = ZONE_TYPE_SINGLE;
+        new_zone.leds_min   = 1;
+        new_zone.leds_max   = 1;
+        new_zone.leds_count = 1;
+        new_zone.matrix_map = nullptr;
+
+        zones.emplace_back(new_zone);
+    }
+
+    for(unsigned int led_idx = 0; led_idx < zones.size(); led_idx++)
+    {
+        led new_led;
+        
+        new_led.name        = zones[led_idx].name + std::string(" LED");
+
+        leds.emplace_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_Alienware::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_Alienware::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_Alienware::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_Alienware::UpdateSingleLED(int led)
+{
+    UpdateZoneLEDs(led);
+}
+
+void RGBController_Alienware::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+static bool modes_eq(const mode& mode1, const mode& mode2)
+{
+    return( ( mode1.name           == mode2.name       )
+         && ( mode1.value          == mode2.value      )
+         && ( mode1.flags          == mode2.flags      )
+         && ( mode1.speed_min      == mode2.speed_min  )
+         && ( mode1.speed_max      == mode2.speed_max  )
+         && ( mode1.colors_min     == mode2.colors_min )
+         && ( mode1.colors_max     == mode2.colors_max )
+         && ( mode1.speed          == mode2.speed      )
+         && ( mode1.direction      == mode2.direction  )
+         && ( mode1.color_mode     == mode2.color_mode )
+         && ( mode1.colors         == mode2.colors     )
+         && ( mode1.brightness     == mode2.brightness )
+         && ( mode1.brightness_min == mode2.brightness_min )
+         && ( mode1.brightness_max == mode2.brightness_max ) );
+}
+
+void RGBController_Alienware::DeviceUpdateMode()
+{
+    /*---------------------------------------------------------*\
+    | Copy mode to get the current state-- this is racy, as the |
+    | UI thread can be actively modifying this variable         |
+    \*---------------------------------------------------------*/
+    int  current_mode_idx = active_mode;
+    mode current_mode     = modes[current_mode_idx];
+
+    bool done             = false;
+
+    while(!done)
+    {
+        /*-----------------------------------------------------*\
+        | Setup state per zone                                  |
+        \*-----------------------------------------------------*/
+        for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+        {
+            zone current_zone = zones[zone_idx];
+
+            /*-------------------------------------------------*\
+            | Some modes use 2000ms (0x07D0) for their duration,|
+            | per traces                                        |
+            \*-------------------------------------------------*/
+            uint16_t period = 0x07d0;
+
+            alienware->SetMode(zone_idx, current_mode.value);
+            
+            switch(current_mode_idx)
+            {
+                case ALIENWARE_MODE_COLOR:
+                    alienware->SetPeriod(zone_idx, period);
+                    alienware->SetColor( zone_idx, colors[current_zone.start_idx]);
+                    alienware->SetTempo( zone_idx, ALIENWARE_TEMPO_MAX);
+                    alienware->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    break;
+
+                case ALIENWARE_MODE_PULSE:
+                    alienware->SetPeriod(zone_idx, period);
+                    alienware->SetColor( zone_idx, colors[current_zone.start_idx]);
+                    alienware->SetTempo( zone_idx, current_mode.speed);
+                    alienware->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    break;
+
+                case ALIENWARE_MODE_MORPH:
+                    alienware->SetPeriod(zone_idx, period);
+                    alienware->SetColor( zone_idx, current_mode.colors[zone_idx * 2], current_mode.colors[(zone_idx * 2) + 1]);
+                    alienware->SetTempo( zone_idx, current_mode.speed);
+                    alienware->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    break;
+
+                case ALIENWARE_MODE_SPECTRUM:
+                case ALIENWARE_MODE_RAINBOW:
+                    alienware->SetPeriod(zone_idx, ALIENWARE_DURATION_SPECTRUM);
+                    alienware->SetTempo( zone_idx, current_mode.speed);
+                    alienware->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    break;
+
+                case ALIENWARE_MODE_BREATHING:
+                    alienware->SetPeriod(zone_idx, period);
+                    alienware->SetColor( zone_idx, colors[current_zone.start_idx], 0x0);
+                    alienware->SetTempo( zone_idx, current_mode.speed);
+                    alienware->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    break;
+            }
+        }
+
+        /*-----------------------------------------------------*\
+        | Due to rate-limiting, this can take more than one     |
+        | second to execute                                     |
+        \*-----------------------------------------------------*/
+        alienware->UpdateController();
+
+        /*-----------------------------------------------------*\
+        | Re-run update if there's anything that's changed from |
+        | under us...                                           |
+        \*-----------------------------------------------------*/
+        int  new_current_mode_idx = active_mode;
+        mode new_current_mode     = modes[current_mode_idx];
+
+        done                      = (current_mode_idx == new_current_mode_idx && modes_eq(new_current_mode, current_mode));
+        current_mode_idx          = new_current_mode_idx;
+        current_mode              = new_current_mode;
+    }
+}
@@ -0,0 +1,37 @@
+/*-----------------------------------------*\
+|  RGBController_Alienware.h                |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Alienware RGB USB Driver                 |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AlienwareController.h"
+
+#include <chrono>
+
+class RGBController_Alienware : public RGBController
+{
+public:
+    RGBController_Alienware(AlienwareController* alienware_ptr);
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+    void        SetCustomMode();
+
+private:
+    AlienwareController*                    alienware;
+    std::chrono::steady_clock::time_point   last_packet_ts;
+};
@@ -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);
+}
@@ -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
+                    );
+};
@@ -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);
@@ -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);
+    }
+}
+
@@ -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;
+};
@@ -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,30 +29,50 @@ 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_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_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_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_RTX2060_TU104_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2060 O6G EVO Gaming"    },
+    { 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_8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2060S 8G 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"              },
 };  

 /******************************************************************************************\
@@ -69,6 +90,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;
@@ -100,6 +123,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);
@@ -112,4 +136,4 @@ void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses)
    }
 } /* DetectAsusAuraGPUControllers() */

-REGISTER_I2C_DETECTOR("ASUS Aura GPU", DetectAsusAuraGPUControllers);
+REGISTER_I2C_DETECTOR(ASUSGPU_CONTROLLER_NAME, DetectAsusAuraGPUControllers);
@@ -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(RGBColor* colors)
-{
-    unsigned char* color_buf = new unsigned char[led_count * 3];
-
-    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]);
-    }
-
-    AuraRegisterWriteBlock(direct_reg, color_buf, led_count * 3);
-
-    delete[] color_buf;
-}
-
-void AuraSMBusController::SetAllColorsEffect(RGBColor* colors)
-{
-    unsigned char* color_buf = new unsigned char[led_count * 3];
-
-    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]);
-    }
-
-    AuraRegisterWriteBlock(effect_reg, color_buf, led_count * 3);
-
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-
-    delete[] color_buf;
-}
-
-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);
-
-}
@@ -1,115 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraSMBusController.h                |
-|                                           |
-|  Definitions and types for ASUS Aura RGB  |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 8/19/2018   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#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(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);
-
-    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;
-
-};
@@ -1,231 +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("Testing address %02X for Aura SMBus controller", address);
-
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-
-    if (res >= 0)
-    {
-        pass = true;
-
-        LOG_DEBUG("Detected an I2C device at address %02X, testing register range for Aura SMBus", address);
-
-        for (int i = 0xA0; i < 0xB0; i++)
-        {
-            res = bus->i2c_smbus_read_byte_data(address, i);
-
-            if (res != (i - 0xA0))
-            {
-                LOG_DEBUG("Detection failed testing register %02X.  Expected %02X, got %02X.", i, (i - 0xA0), res);
-
-                pass = false;
-            }
-        }
-
-        if(pass)
-        {
-            LOG_DEBUG("Detection successful, address %02X appears to be an Aura SMBus controller", 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("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("No device detected at address 0x77, aborting remap");
-
-                    break;
-                }
-
-                do
-                {
-                    address_list_idx++;
-
-                    if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
-                    {
-                        LOG_DEBUG("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("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)
-{
-    AuraSMBusController* new_aura;
-    RGBController_AuraSMBus* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        int address_list_idx = -1;
-
-        // 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);
@@ -1,361 +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()
-{
-    if(GetMode() == 0)
-    {
-        aura->SetAllColorsDirect(&colors[0]);
-    }
-    else
-    {
-        aura->SetAllColorsEffect(&colors[0]);
-    }
-}
-
-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);
-    }
-}
@@ -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);
 }
@@ -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;
@@ -11,10 +11,11 @@

 #include <cstring>

-AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path)
+AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid)
 {
    dev         = dev_handle;
    location    = path;
+    device_pid  = pid;
 }

 AuraMouseController::~AuraMouseController()
@@ -29,8 +30,8 @@ std::string AuraMouseController::GetDeviceLocation()

 std::string AuraMouseController::GetSerialString()
 {
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+    wchar_t serial_string[HID_MAX_STR];
+    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);

    if(ret != 0)
    {
@@ -43,21 +44,83 @@ 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 };
+
+    hid_write(dev, usb_save_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
+}
+
 void AuraMouseController::SendUpdate
    (
    unsigned char   zone,
    unsigned char   mode,
    unsigned char   red,
    unsigned char   grn,
-    unsigned char   blu
+    unsigned char   blu,
+    unsigned char   dir,
+    bool            random,
+    unsigned char   speed,
+    unsigned char   brightness
    )
 {
-    unsigned char usb_buf[65];
+    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];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
+    memset(usb_buf, 0x00, ASUS_AURA_MOUSE_PACKET_SIZE);

    /*-----------------------------------------------------*\
    | Set up message packet                                 |
@@ -68,13 +131,32 @@ 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;
+        usb_buf[0x0B]   = 0;
+        usb_buf[0x0C]   = 0;
+        usb_buf[0x0D]   = dir;
+        usb_buf[0x0E]   = random;
+        usb_buf[0x0F]   = speed;
+    }
+    else
+    {
+        usb_buf[0x0A]   = dir;
+        usb_buf[0x0B]   = random;
+        usb_buf[0x0C]   = speed;
+    }
+
    /*-----------------------------------------------------*\
    | Send packet                                           |
    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    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);
 }
@@ -8,46 +8,41 @@
 \*-----------------------------------------*/

 #include "RGBController.h"
+#include "AsusAuraMouseDevices.h"

 #include <string>
-#include <vector>
 #include <hidapi/hidapi.h>

 #pragma once

-enum
-{
-    AURA_MOUSE_ZONE_LOGO        = 0,
-    AURA_MOUSE_ZONE_SCROLL      = 1,
-    AURA_MOUSE_ZONE_UNDERGLOW   = 2,
-    AURA_MOUSE_ZONE_ALL         = 3,
-};
-
-enum
-{
-    AURA_MOUSE_MODE_STATIC      = 0,
-    AURA_MOUSE_MODE_BREATHING   = 1,
-    AURA_MOUSE_MODE_COLOR_CYCLE = 2,
-    AURA_MOUSE_MODE_REACTIVE    = 3,
-};
+#define ASUS_AURA_MOUSE_PACKET_SIZE 65
+#define HID_MAX_STR 255

 class AuraMouseController
 {
 public:
-    AuraMouseController(hid_device* dev_handle, const char* path);
+    AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid);
    virtual ~AuraMouseController();

    std::string GetDeviceLocation();
    std::string GetSerialString();
+    std::string GetVersion(bool wireless, int protocol);

+    void SaveMode();
    void SendUpdate
        (
        unsigned char   zone,
        unsigned char   mode,
        unsigned char   red,
        unsigned char   grn,
-        unsigned char   blu
-        );
+        unsigned char   blu,
+        unsigned char   dir,
+        bool            random,
+        unsigned char   speed,
+        unsigned char   brightness
+	    );
+
+    uint16_t                    device_pid;

 private:
    hid_device*                 dev;
@@ -0,0 +1,247 @@
+/*-------------------------------------------------------------------*\
+|  AsusAuraMouseDevices.h                                             |
+|                                                                     |
+|  Asus Aura Mouse definitions and mapping                            |
+|                                                                     |
+|  Chris M (Dr_No)         11th July 2021                             |
+\*-------------------------------------------------------------------*/
+
+#include <vector>
+#include <map>
+
+#pragma once
+
+#define AURA_ROG_GLADIUS_II_CORE_PID            0x18DD
+#define AURA_ROG_GLADIUS_II_PID                 0x1845
+#define AURA_ROG_GLADIUS_II_ORIGIN_PID          0x1877
+#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID  0x18CD
+#define AURA_ROG_GLADIUS_II_ORIGIN_COD_PID      0x18B1
+#define AURA_ROG_GLADIUS_II_WIRELESS_1_PID      0x189E
+#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_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                         0x1898
+
+enum
+{
+    AURA_MOUSE_ZONE_LOGO        = 0,
+    AURA_MOUSE_ZONE_SCROLL      = 1,
+    AURA_MOUSE_ZONE_UNDERGLOW   = 2,
+    AURA_MOUSE_ZONE_ALL         = 3,
+};
+
+enum
+{
+    AURA_MOUSE_MODE_STATIC      = 0,
+    AURA_MOUSE_MODE_BREATHING   = 1,
+    AURA_MOUSE_MODE_SPECTRUM    = 2,
+    AURA_MOUSE_MODE_WAVE        = 3,
+    AURA_MOUSE_MODE_REACTIVE    = 4,
+    AURA_MOUSE_MODE_COMET       = 5,
+    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;
+
+/*-----------------------------------------------------------------*\
+|  DEVICE MAP                                                       |
+|                                                                   |
+|    This structure maps the OpenRGB modes to the mode values       |
+|    sent to each mouse. As not all modes are present on each       |
+|    mouse the "mode index" is different. Eg. "Reactive" is mode    |
+|    4 on the Gladius II and mode 3 on the Gladius II wireless      |
+\*-----------------------------------------------------------------*/
+static std::map<int,mouse_type> aura_mouse_devices =
+{
+    {
+        AURA_ROG_GLADIUS_II_CORE_PID, // ROG Gladius II Core
+        {
+            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 }
+        }
+    },
+    {
+        AURA_ROG_GLADIUS_II_PID, // ROG Gladius II
+        {
+            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_ROG_GLADIUS_II_ORIGIN_PID, // ROG Gladius II Origin
+        {
+            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_ROG_GLADIUS_II_ORIGIN_COD_PID, // ROG Gladius II COD
+        {
+            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_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID, // ROG Gladius II PNK LTD
+        {
+            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 }
+        }
+    },
+    {
+        AURA_ROG_GLADIUS_II_WIRELESS_1_PID, // ROG Gladius II Wireless
+        {
+            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_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
+    {
+        AURA_ROG_GLADIUS_II_WIRELESS_2_PID, // ROG Gladius II Wireless
+        {
+            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_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
+        }
+    },
+    {
+        AURA_ROG_CHAKRAM_WIRELESS_PID, // ROG Chakram Wireless
+        {
+            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 }
+        }
+    },
+    {
+        AURA_ROG_CHAKRAM_WIRED_1_PID,  // ROG Chakram Wired 1
+        {
+            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_CORE_PID, // ROG Chakram Core
+        {
+            0,
+            0,
+            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 }
+        }
+    },
+    {
+        AURA_ROG_PUGIO_PID, // ROG Pugio
+        {
+            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_ROG_PUGIO_II_WIRED_PID, // ROG Pugio II Wired
+        {
+            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_PUGIO_II_WIRELESS_PID, // ROG Pugio II Wireless
+        {
+            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 }
+        }
+    },
+    {
+        AURA_ROG_STRIX_IMPACT_II_PID, // ROG Strix Impact II
+        {
+            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 }
+        }
+    },
+    {
+        AURA_TUF_M3_PID, // TUF M3
+        {
+            0,
+            0,
+            false,
+            1,
+            { AURA_MOUSE_ZONE_LOGO },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
+        }
+    },
+    {
+        AURA_TUF_M5_PID, // TUF M5
+        {
+            0,
+            0,
+            false,
+            2,
+            { AURA_MOUSE_ZONE_LOGO },
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
+        }
+    },
+};
@@ -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);
+}
@@ -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;
+};
@@ -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);
+    }
 }

@@ -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;
@@ -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",
+            }
+        }
+    },
+};
@@ -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;
    }
 }

@@ -8,6 +8,7 @@
 \*-----------------------------------------*/

 #include "RGBController.h"
+#include "LogManager.h"

 #include <string>
 #include <vector>
@@ -5,18 +5,23 @@
 #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"

 #define AURA_USB_VID                            0x0B05
-#define AURA_TERMINAL_PID                       0x1889
+
+/*-----------------------------------------------------------------*\
+|  MOTHERBOARDS                                                     |
+\*-----------------------------------------------------------------*/
 #define AURA_ADDRESSABLE_1_PID                  0x1867
 #define AURA_ADDRESSABLE_2_PID                  0x1872
 #define AURA_ADDRESSABLE_3_PID                  0x18A3
@@ -24,18 +29,58 @@
 #define AURA_MOTHERBOARD_1_PID                  0x18F3
 #define AURA_MOTHERBOARD_2_PID                  0x1939
 #define AURA_MOTHERBOARD_3_PID                  0x19AF
-#define AURA_ROG_GLADIUS_II_CORE_PID            0x18DD
-#define AURA_ROG_GLADIUS_II_PID                 0x1845
+
+/*-----------------------------------------------------------------*\
+|  KEYBOARDS                                                        |
+\*-----------------------------------------------------------------*/
+#define AURA_ROG_FALCHION_WIRED_PID             0x193C
+#define AURA_ROG_FALCHION_WIRELESS_PID          0x193E
 #define AURA_ROG_STRIX_FLARE_PID                0x1875
-#define AURA_ROG_GLADIUS_II_ORIGIN_PID          0x1877
-#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID  0x18CD
-#define AURA_ROG_GLADIUS_II_WIRELESS_PID        0x18A0
 #define AURA_ROG_STRIX_FLARE_PNK_LTD_PID        0x18CF
-#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_STRIX_SCOPE_PID                0x18F8
+#define AURA_ROG_STRIX_SCOPE_RX_PID             0x1951
+#define AURA_ROG_STRIX_SCOPE_TKL_PID            0x190C
+#define AURA_TUF_K7_GAMING_PID                  0x18AA
+
+/*-----------------------------------------------------------------*\
+|  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
-#define AURA_TUF_K7_GAMING_PID				    0x18AA
+
+
+AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
+{
+    switch(pid)
+    {
+        case AURA_ROG_STRIX_FLARE_PID:
+        case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
+            return FLARE_LAYOUT;
+
+        case AURA_ROG_STRIX_SCOPE_PID:
+            return SCOPE_LAYOUT;
+
+        case AURA_ROG_STRIX_SCOPE_RX_PID:
+            return SCOPE_RX_LAYOUT;
+
+        case AURA_ROG_STRIX_SCOPE_TKL_PID:
+            return SCOPE_TKL_LAYOUT;
+
+        case AURA_ROG_FALCHION_WIRED_PID:
+        case AURA_ROG_FALCHION_WIRELESS_PID:
+            return FALCHION_LAYOUT;
+
+        default:
+            return FLARE_LAYOUT;
+    }
+}

 void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
 {
@@ -50,7 +95,7 @@ void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
    }
 }

-void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*name*/)
 {
    hid_device* dev = hid_open_path(info->path);

@@ -64,7 +109,7 @@ void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& name
    }
 }

-void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*name*/)
 {
    hid_device* dev = hid_open_path(info->path);
    if(dev)
@@ -89,8 +134,9 @@ void DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
    hid_device* dev = hid_open_path(info->path);
    if(dev)
    {
-        AuraKeyboardController* controller = new AuraKeyboardController(dev, info->path);
-        RGBController_AuraKeyboard* rgb_controller = new RGBController_AuraKeyboard(controller);
+        AuraKeyboardController* controller         = new AuraKeyboardController(dev, info->path);
+        AuraKeyboardMappingLayoutType layout       = GetKeyboardMappingLayoutType(info->product_id);
+        RGBController_AuraKeyboard* rgb_controller = new RGBController_AuraKeyboard(controller, layout);
        rgb_controller->name = name;
        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
@@ -101,13 +147,25 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
    hid_device* dev = hid_open_path(info->path);
    if(dev)
    {
-        AuraMouseController* controller = new AuraMouseController(dev, info->path);
+        AuraMouseController* controller = new AuraMouseController(dev, info->path, info->product_id);
        RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller);
        rgb_controller->name = name;
        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
 }

+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);
@@ -132,7 +190,9 @@ void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name
    }
 }

-REGISTER_HID_DETECTOR   ("ASUS ROG AURA Terminal",              DetectAsusAuraUSBTerminal,      AURA_USB_VID, AURA_TERMINAL_PID);
+/*-----------------------------------------------------------------*\
+|  MOTHERBOARDS                                                     |
+\*-----------------------------------------------------------------*/
 REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_1_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_2_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_3_PID);
@@ -140,15 +200,44 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUS
 REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",               DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_1_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",               DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_2_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",               DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_3_PID);
+
+/*-----------------------------------------------------------------*\
+|  KEYBOARDS                                                        |
+\*-----------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",           DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,              1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,           1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                 1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,         1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                 1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",             DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,              1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL",            DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID,             1,  0xFF00);
+REGISTER_HID_DETECTOR_I ("ASUS TUF Gaming K7",                  DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                   1);
+
+/*-----------------------------------------------------------------*\
+|  MICE                                                             |
+\*-----------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,             0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,                  2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin",          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID,           2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID,   2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_PID,         2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID,       1,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,       1,  0xFF13);
+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 Strix Flare",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                 1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,         1,  0xFF00);
-REGISTER_HID_DETECTOR_I ("ASUS ROG Throne QI",         			DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID, 					0);
-REGISTER_HID_DETECTOR_I ("ASUS TUF Gaming K7",         			DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID, 					1);
+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,              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,                          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);
@@ -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();
+}
@@ -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;
@@ -12,42 +12,38 @@
 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF

-static unsigned int matrix_map[6][22] =
+static unsigned int flare_matrix_map[6][22] =
    { {   0,  NA,  13,  18,  23,  28,  38,  43,  49,  54,  60,  65,  69,  70,  NA,  76,  80,  85,  NA,  NA,  NA,  NA },
      {   1,   8,  14,  19,  24,  29,  34,  39,  44,  50,  55,  61,  66,  71,  NA,  77,  81,  86,  89,  94,  98, 103 },
      {   2,  NA,   9,  15,  20,  25,  30,  35,  40,  45,  51,  56,  62,  67,  72,  78,  82,  87,  90,  95,  99, 104 },
      {   3,  NA,  10,  16,  21,  26,  31,  36,  41,  46,  52,  57,  63,  68,  73,  NA,  NA,  NA,  91,  96, 100,  NA },
-      {   4,   6,  11,  17,  22,  27,  32,  37,  42,  47,  53,  58,  NA,  NA,  74,  NA,  83,  NA,  92,  97, 101, 105 },
+      {   4,   6,  11,  17,  22,  27,  32,  37,  42,  47,  53,  58,  74,  NA,  NA,  NA,  83,  NA,  92,  97, 101, 105 },
      {   5,   7,  12,  NA,  NA,  NA,  NA,  33,  NA,  48,  NA,  59,  64,  75,  NA,  79,  84,  88,  93,  NA, 102,  NA } };

-static const char* zone_names[] =
-{
-    "Keyboard",
-    "Logo",
-    "Underglow"
-};
+static unsigned int scope_matrix_map[6][22] =
+    { {   0,  NA,  13,  18,  23,  28,  38,  43,  49,  54,  60,  65,  69,  70,  NA,  76,  80,  85,  NA,  NA,  NA,  NA },
+      {   1,   8,  14,  19,  24,  29,  34,  39,  44,  50,  55,  61,  66,  71,  NA,  77,  81,  86,  89,  94,  98, 103 },
+      {   2,  NA,   9,  15,  20,  25,  30,  35,  40,  45,  51,  56,  62,  67,  72,  78,  82,  87,  90,  95,  99, 104 },
+      {   3,  NA,  10,  16,  21,  26,  31,  36,  41,  46,  52,  57,  63,  68,  73,  NA,  NA,  NA,  91,  96, 100,  NA },
+      {   4,   6,  11,  17,  22,  27,  32,  37,  42,  47,  53,  58,  74,  NA,  NA,  NA,  83,  NA,  92,  97, 101, 105 },
+      {   5,   NA,  7,  12,  NA,  NA,  NA,  33,  NA,  48,  NA,  59,  64,  75,  NA,  79,  84,  88,  93,  NA, 102,  NA } };

-static zone_type zone_types[] =
-{
-    ZONE_TYPE_MATRIX,
-    ZONE_TYPE_SINGLE,
-    ZONE_TYPE_SINGLE
-};
+static unsigned int scope_tkl_matrix_map[6][18] =
+    { {   0,  NA,  13,  18,  23,  28,  38,  43,  49,  54,  60,  65,  69,  70,  NA,  NA,  NA,  NA },
+      {   1,   8,  14,  19,  24,  29,  34,  39,  44,  50,  55,  61,  66,  71,  NA,  76,  79,  83 },
+      {   2,  NA,   9,  15,  20,  25,  30,  35,  40,  45,  51,  56,  62,  67,  72,  77,  80,  84 },
+      {   3,  NA,  10,  16,  21,  26,  31,  36,  41,  46,  52,  57,  63,  68,  73,  NA,  NA,  NA },
+      {   4,   6,  11,  17,  22,  27,  32,  37,  42,  47,  53,  58,  74,  NA,  NA,  NA,  81,  NA },
+      {   5,   NA,  7,  12,  NA,  NA,  NA,  33,  NA,  48,  NA,  59,  64,  75,  NA,  78,  82,  85 } };

-static const unsigned int zone_sizes[] =
-{
-    106,
-    1,
-    2,
-};
+static unsigned int falchion_matrix_map[5][16] =
+    { {   0,   5,   9,  14,  18,  22,  26,  31,  35,  39,  44,  49,  54,  58,  NA,  63 },
+      {   1,  NA,   6,  10,  15,  19,  23,  27,  32,  36,  40,  45,  50,  55,  59,  64 },
+      {   2,  NA,   7,  11,  16,  20,  24,  28,  33,  37,  41,  46,  51,  60,  NA,  65 }, 
+      {   3,  NA,  12,  17,  21,  25,  29,  34,  38,  42,  47,  52,  56,  NA,  61,  66 },
+      {   4,   8,  13,  NA,  NA,  NA,  30,  NA,  NA,  NA,  43,  48,  53,  57,  62,  67 } };

-typedef struct
-{
-    const char *        name;
-    const unsigned char idx;
-} led_type;
-
-static const led_type led_names[] =
+static const std::vector<led_type> default_led_names =
 {
    /* Key Label                Index  */
    { "Key: Escape",            0x00    },
@@ -57,12 +53,10 @@ static const led_type led_names[] =
    { "Key: Left Shift",        0x04    },
    { "Key: Left Control",      0x05    },
    { "Key: \\ (ISO)",          0x0C    },
-    { "Key: Left Windows",      0x0D    },
    { "Key: 1",                 0x11    },
    { "Key: Q",                 0x12    },
    { "Key: A",                 0x13    },
    { "Key: Z",                 0x14    },
-    { "Key: Left Alt",          0x15    },
    { "Key: F1",                0x18    },
    { "Key: 2",                 0x19    },
    { "Key: W",                 0x1A    },
@@ -156,14 +150,202 @@ static const led_type led_names[] =
    { "Key: Number Pad -",      0xB1    },
    { "Key: Number Pad +",      0xB2    },
    { "Key: Number Pad Enter",  0xB4    },
-    { "Logo",                   0xB8    },
-    { "Left Underglow",         0xB9    },
-    { "Right Underglow",        0xBA    },
 };

-RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* aura_ptr)
+static const std::vector<led_type> default_tkl_led_names =
 {
-    aura = aura_ptr;
+    /* Key Label                Index  */
+    { "Key: Escape",            0x00    },
+    { "Key: `",                 0x01    },
+    { "Key: Tab",               0x02    },
+    { "Key: Caps Lock",         0x03    },
+    { "Key: Left Shift",        0x04    },
+    { "Key: Left Control",      0x05    },
+    { "Key: \\ (ISO)",          0x0C    },
+    { "Key: 1",                 0x11    },
+    { "Key: Q",                 0x12    },
+    { "Key: A",                 0x13    },
+    { "Key: Z",                 0x14    },
+    { "Key: F1",                0x18    },
+    { "Key: 2",                 0x19    },
+    { "Key: W",                 0x1A    },
+    { "Key: S",                 0x1B    },
+    { "Key: X",                 0x1C    },
+    { "Key: F2",                0x20    },
+    { "Key: 3",                 0x21    },
+    { "Key: E",                 0x22    },
+    { "Key: D",                 0x23    },
+    { "Key: C",                 0x24    },
+    { "Key: F3",                0x28    },
+    { "Key: 4",                 0x29    },
+    { "Key: R",                 0x2A    },
+    { "Key: F",                 0x2B    },
+    { "Key: V",                 0x2C    },
+    { "Key: F4",                0x30    },
+    { "Key: 5",                 0x31    },
+    { "Key: T",                 0x32    },
+    { "Key: G",                 0x33    },
+    { "Key: B",                 0x34    },
+    { "Key: Space",             0x35    },
+    { "Key: 6",                 0x39    },
+    { "Key: Y",                 0x3A    },
+    { "Key: H",                 0x3B    },
+    { "Key: N",                 0x3C    },
+    { "Key: F5",                0x40    },
+    { "Key: 7",                 0x41    },
+    { "Key: U",                 0x42    },
+    { "Key: J",                 0x43    },
+    { "Key: M",                 0x44    },
+    { "Key: F6",                0x48    },
+    { "Key: 8",                 0x49    },
+    { "Key: I",                 0x4A    },
+    { "Key: K",                 0x4B    },
+    { "Key: ,",                 0x4C    },
+    { "Key: Right Alt",         0x4D    },
+    { "Key: F7",                0x50    },
+    { "Key: 9",                 0x51    },
+    { "Key: O",                 0x52    },
+    { "Key: L",                 0x53    },
+    { "Key: .",                 0x54    },
+    { "Key: F8",                0x58    },
+    { "Key: 0",                 0x59    },
+    { "Key: P",                 0x5A    },
+    { "Key: ;",                 0x5B    },
+    { "Key: /",                 0x5C    },
+    { "Key: Right Fn",          0x5D    },
+    { "Key: F9",                0x60    },
+    { "Key: -",                 0x61    },
+    { "Key: [",                 0x62    },
+    { "Key: '",                 0x63    },
+    { "Key: Menu",              0x65    },
+    { "Key: F10",               0x68    },
+    { "Key: =",                 0x69    },
+    { "Key: ]",                 0x6A    },
+    { "Key: #",                 0x6B    },
+    { "Key: F11",               0x70    },
+    { "Key: F12",               0x78    },
+    { "Key: Backspace",         0x79    },
+    { "Key: \\ (ANSI)",         0x7A    },
+    { "Key: Enter",             0x7B    },
+    { "Key: Right Shift",       0x7C    },
+    { "Key: Right Control",     0x7D    },
+    { "Key: Insert",            0x81    },
+    { "Key: Delete",            0x82    },
+    { "Key: Left Arrow",        0x85    },
+    { "Key: Home",              0x89    },
+    { "Key: End",               0x8A    },
+    { "Key: Up Arrow",          0x8C    },
+    { "Key: Down Arrow",        0x8D    },
+    { "Key: Page Up",           0x91    },
+    { "Key: Page Down",         0x92    },
+    { "Key: Right Arrow",       0x95    },
+    { "Logo 1",                 0x80    },
+    { "Logo 2",                 0x90    },
+    { "Underglow 1",            0x06    },
+    { "Underglow 2",            0x0E    },
+    { "Underglow 3",            0x16    },
+    { "Underglow 4",            0x1E    },
+    { "Underglow 5",            0x26    },
+    { "Underglow 6",            0x2E    },
+    { "Underglow 7",            0x36    },
+    { "Underglow 8",            0x3E    },
+    { "Underglow 9",            0x46    },
+    { "Underglow 10",           0x4E    },
+    { "Underglow 11",           0x56    },
+    { "Underglow 12",           0x5E    },
+    { "Underglow 13",           0x66    },
+    { "Underglow 14",           0x6E    },
+    { "Underglow 15",           0x76    },
+    { "Underglow 16",           0x7E    },
+    { "Underglow 17",           0x86    },
+    { "Underglow 18",           0x8E    },
+    { "Underglow 19",           0x96    },
+    { "Underglow 20",           0x9E    },
+    { "Underglow 21",           0xA6    },
+    { "Underglow 22",           0xAE    },
+    { "Underglow 23",           0xB6    },
+    { "Underglow 24",           0xBE    },
+    { "Underglow 25",           0xC6    },
+    { "Underglow 26",           0xCE    },
+};
+
+static const std::vector<led_type> default_65pct_led_names =
+{
+    /* Key Label                Index  */
+    { "Key: Escape",            0x00    },
+    { "Key: Tab",               0x01    },
+    { "Key: Caps Lock",         0x02    },
+    { "Key: Left Shift",        0x03    },
+    { "Key: Left Control",      0x04    },
+    { "Key: 1",                 0x08    },
+    { "Key: Q",                 0x09    },
+    { "Key: A",                 0x0A    },
+    { "Key: Left Windows",      0x0C    },
+    { "Key: 2",                 0x10    },
+    { "Key: W",                 0x11    },
+    { "Key: S",                 0x12    },
+    { "Key: Z",                 0x13    },
+    { "Key: Left Alt",          0x14    },
+    { "Key: 3",                 0x18    },
+    { "Key: E",                 0x19    },
+    { "Key: D",                 0x1A    },
+    { "Key: X",                 0x1B    },
+    { "Key: 4",                 0x20    },
+    { "Key: R",                 0x21    },
+    { "Key: F",                 0x22    },
+    { "Key: C",                 0x23    },
+    { "Key: 5",                 0x28    },
+    { "Key: T",                 0x29    },
+    { "Key: G",                 0x2A    },
+    { "Key: V",                 0x2B    },
+    { "Key: 6",                 0x30    },
+    { "Key: Y",                 0x31    },
+    { "Key: H",                 0x32    },
+    { "Key: B",                 0x33    },
+    { "Key: Space",             0x34    },
+    { "Key: 7",                 0x38    },
+    { "Key: U",                 0x39    },
+    { "Key: J",                 0x3A    },
+    { "Key: N",                 0x3B    },
+    { "Key: 8",                 0x40    },
+    { "Key: I",                 0x41    },
+    { "Key: K",                 0x42    },
+    { "Key: M",                 0x43    },
+    { "Key: 9",                 0x48    },
+    { "Key: O",                 0x49    },
+    { "Key: L",                 0x4A    },
+    { "Key: ,",                 0x4B    },
+    { "Key: Right Alt",         0x4C    },
+    { "Key: 0",                 0x50    },
+    { "Key: P",                 0x51    },
+    { "Key: ;",                 0x52    },
+    { "Key: .",                 0x53    },
+    { "Key: Right Fn",          0x54    },
+    { "Key: -",                 0x58    },
+    { "Key: [",                 0x59    },
+    { "Key: '",                 0x5A    },
+    { "Key: /",                 0x5B    },
+    { "Key: Right Control",     0x5C    },
+    { "Key: =",                 0x60    },
+    { "Key: ]",                 0x61    },
+    { "Key: Right Shift",       0x63    },
+    { "Key: Left Arrow",        0x64    },
+    { "Key: Backspace",         0x68    },
+    { "Key: \\ (ANSI)",         0x69    },
+    { "Key: Enter",             0x6A    },
+    { "Key: Up Arrow",          0x6B    },
+    { "Key: Down Arrow",        0x6C    },
+    { "Key: Insert",            0x70    },
+    { "Key: Delete",            0x71    },
+    { "Key: Page Up",           0x72    },
+    { "Key: Page Down",         0x73    },
+    { "Key: Right Arrow",       0x74    },
+};
+
+RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* aura_ptr, AuraKeyboardMappingLayoutType keyboard_layout)
+{
+    aura        = aura_ptr;
+    layout      = keyboard_layout;

    name        = "ASUS Aura Keyboard";
    vendor      = "ASUS";
@@ -184,6 +366,13 @@ RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* a

 RGBController_AuraKeyboard::~RGBController_AuraKeyboard()
 {
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        if(zones[zone_idx].type == ZONE_TYPE_MATRIX)
+        {
+            delete zones[zone_idx].matrix_map;
+        }
+    }
    delete aura;
 }

@@ -192,22 +381,76 @@ void RGBController_AuraKeyboard::SetupZones()
    /*---------------------------------------------------------*\
    | Set up zones                                              |
    \*---------------------------------------------------------*/
+    std::vector<led_zone> led_zones;
+    std::vector<led_type> led_names;
+
+    switch(layout)
+    {
+        /*-----------------------------------------------------*\
+        | On the ROG Scope keyboards Ctrl key is double sized,  |
+        | so there is a layout shift                            |
+        \*-----------------------------------------------------*/
+        case SCOPE_LAYOUT:
+            led_names = default_led_names;
+            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
+
+            led_names.insert(led_names.begin() + 7,     {"Key: Left Windows", 0x15});
+            led_names.insert(led_names.begin() + 12,    {"Key: Left Alt", 0x1D});
+            break;
+
+        case SCOPE_RX_LAYOUT:
+            led_names = default_led_names;
+            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
+            led_zones.push_back({"Logo",        ZONE_TYPE_SINGLE, 1});
+
+            led_names.insert(led_names.begin() + 7,     {"Key: Left Windows", 0x15});
+            led_names.insert(led_names.begin() + 12,    {"Key: Left Alt", 0x1D});
+            led_names.push_back({ "Logo", 0xB0});
+            break;
+
+        case SCOPE_TKL_LAYOUT:
+            led_names = default_tkl_led_names;
+            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 86, new matrix_map_type{6, 18, (unsigned int *)&scope_tkl_matrix_map}});
+            led_zones.push_back({"Logo",        ZONE_TYPE_LINEAR, 2});
+            led_zones.push_back({"Underglow",   ZONE_TYPE_LINEAR, 26});
+
+            led_names.insert(led_names.begin() + 7,     {"Key: Left Windows", 0x15});
+            led_names.insert(led_names.begin() + 12,    {"Key: Left Alt", 0x1D});
+            break;
+
+        case FLARE_LAYOUT:
+            led_names = default_led_names;
+            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&flare_matrix_map}});
+            led_zones.push_back({"Logo",        ZONE_TYPE_SINGLE, 1});
+            led_zones.push_back({"Underglow",   ZONE_TYPE_SINGLE, 2});
+
+            led_names.insert(led_names.begin() + 7,     {"Key: Left Windows", 0x0D});
+            led_names.insert(led_names.begin() + 12,    {"Key: Left Alt", 0x15});
+
+            led_names.push_back({ "Logo", 0xB8});
+            led_names.push_back({ "Left Underglow",     0xB9});
+            led_names.push_back({ "Right Underglow",    0xBA});
+            break;
+
+        case FALCHION_LAYOUT:
+            led_names = default_65pct_led_names;
+            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 68, new matrix_map_type{5, 16, (unsigned int *)&falchion_matrix_map}});
+            break;
+    }
+
    unsigned int total_led_count = 0;
-    for(unsigned int zone_idx = 0; zone_idx < 3; zone_idx++)
+    for(unsigned int zone_idx = 0; zone_idx < led_zones.size(); 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.name                   = led_zones[zone_idx].name;
+        new_zone.type                   = led_zones[zone_idx].type;
+        new_zone.leds_min               = led_zones[zone_idx].size;
+        new_zone.leds_max               = led_zones[zone_idx].size;
+        new_zone.leds_count             = led_zones[zone_idx].size;

-        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
+        if(led_zones[zone_idx].type == ZONE_TYPE_MATRIX)
        {
-            new_zone.matrix_map         = new matrix_map_type;
-            new_zone.matrix_map->height = 6;
-            new_zone.matrix_map->width  = 22;
-            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+            new_zone.matrix_map         = led_zones[zone_idx].matrix;
        }
        else
        {
@@ -216,7 +459,7 @@ void RGBController_AuraKeyboard::SetupZones()

        zones.push_back(new_zone);

-        total_led_count += zone_sizes[zone_idx];
+        total_led_count += led_zones[zone_idx].size;
    }

    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
@@ -224,6 +467,7 @@ void RGBController_AuraKeyboard::SetupZones()
        led new_led;
        new_led.name  = led_names[led_idx].name;
        new_led.value = led_names[led_idx].idx;
+
        leds.push_back(new_led);
    }

@@ -239,20 +483,25 @@ void RGBController_AuraKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)

 void RGBController_AuraKeyboard::DeviceUpdateLEDs()
 {
-unsigned char frame_buf[109 * 4];
+    std::vector<unsigned char> frame_buf;

-/*---------------------------------------------------------*\
-| TODO: Send packets with multiple LED frames               |
-\*---------------------------------------------------------*/
-for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
-{
-    frame_buf[(led_idx * 4) + 0] = leds[led_idx].value;
-    frame_buf[(led_idx * 4) + 1] = RGBGetRValue(colors[led_idx]);
-    frame_buf[(led_idx * 4) + 2] = RGBGetGValue(colors[led_idx]);
-    frame_buf[(led_idx * 4) + 3] = RGBGetBValue(colors[led_idx]);
-}
+    /*---------------------------------------------------------*\
+    | Resize the frame buffer, 4 bytes per LED                  |
+    \*---------------------------------------------------------*/
+    frame_buf.resize(leds.size() * 4);

-aura->SendDirect(109, frame_buf);
+    /*---------------------------------------------------------*\
+    | TODO: Send packets with multiple LED frames               |
+    \*---------------------------------------------------------*/
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        frame_buf[(led_idx * 4) + 0] = leds[led_idx].value;
+        frame_buf[(led_idx * 4) + 1] = RGBGetRValue(colors[led_idx]);
+        frame_buf[(led_idx * 4) + 2] = RGBGetGValue(colors[led_idx]);
+        frame_buf[(led_idx * 4) + 3] = RGBGetBValue(colors[led_idx]);
+    }
+
+    aura->SendDirect(leds.size(), frame_buf.data());
 }

 void RGBController_AuraKeyboard::UpdateZoneLEDs(int /*zone*/)
@@ -11,10 +11,33 @@
 #include "RGBController.h"
 #include "AsusAuraKeyboardController.h"

+enum AuraKeyboardMappingLayoutType
+{
+    FLARE_LAYOUT,
+    SCOPE_LAYOUT,
+    SCOPE_RX_LAYOUT,
+    SCOPE_TKL_LAYOUT,
+    FALCHION_LAYOUT,
+};
+
+typedef struct
+{
+    const char*         name;
+    unsigned char       idx;
+} led_type;
+
+typedef struct
+{
+    const char*         name;
+    const zone_type     type;
+    const unsigned int  size;
+    matrix_map_type*    matrix;
+} led_zone;
+
 class RGBController_AuraKeyboard : public RGBController
 {
 public:
-    RGBController_AuraKeyboard(AuraKeyboardController* aura_ptr);
+    RGBController_AuraKeyboard(AuraKeyboardController* aura_ptr, AuraKeyboardMappingLayoutType keyboard_layout);
    ~RGBController_AuraKeyboard();

    void        SetupZones();
@@ -29,5 +52,6 @@ public:
    void        DeviceUpdateMode();

 private:
-    AuraKeyboardController* aura;
+    AuraKeyboardController*         aura;
+    AuraKeyboardMappingLayoutType   layout;
 };
@@ -9,44 +9,143 @@

 #include "RGBController_AsusAuraMouse.h"

+static std::string aura_mouse_zone_names[3]
+{
+    "Logo",
+    "Scroll Wheel",
+    "Underglow"
+};
+
 RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
 {
-    aura = aura_ptr;
+    aura                    = aura_ptr;

-    name        = "ASUS Aura Mouse";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_MOUSE;
-    description = "ASUS Aura Mouse Device";
-    location    = aura->GetDeviceLocation();
-    serial      = aura->GetSerialString();
+    uint16_t pid            = aura->device_pid;

-    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;
-    modes.push_back(Direct);
+    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();

-    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;
-    modes.push_back(Breathing);
+    std::vector<uint8_t> mm = aura_mouse_devices[pid].mouse_modes;

-    mode SpectrumCycle;
-    SpectrumCycle.name       = "Spectrum Cycle";
-    SpectrumCycle.value      = AURA_MOUSE_MODE_COLOR_CYCLE;
-    SpectrumCycle.flags      = 0;
-    SpectrumCycle.color_mode = MODE_COLORS_NONE;
-    modes.push_back(SpectrumCycle);
+    int mode_value          = 0;

-    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;
-    modes.push_back(Reactive);
+    for(std::vector<uint8_t>::iterator it = mm.begin(); it != mm.end(); it++)
+    {
+        switch(*it)
+        {
+            case AURA_MOUSE_MODE_STATIC:
+                {
+                    mode Direct;
+                    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;
+
+            case AURA_MOUSE_MODE_BREATHING:
+                {
+                    mode Breathing;
+                    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;
+
+            case AURA_MOUSE_MODE_SPECTRUM:
+                {
+                    mode ColorCycle;
+                    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;
+
+            case AURA_MOUSE_MODE_WAVE:
+                {
+                    mode Wave;
+                    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;
+
+            case AURA_MOUSE_MODE_REACTIVE:
+                {
+                    mode Reactive;
+                    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;
+
+            case AURA_MOUSE_MODE_COMET:
+                {
+                    mode Comet;
+                    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);
+                }
+                break;
+
+            case AURA_MOUSE_MODE_BATTERY:
+                {
+                    mode BatteryMode;
+                    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();
 }
@@ -58,56 +157,29 @@ RGBController_AuraMouse::~RGBController_AuraMouse()

 void RGBController_AuraMouse::SetupZones()
 {
-    zone logo_zone;

-    logo_zone.name          = "Logo";
-    logo_zone.type          = ZONE_TYPE_SINGLE;
-    logo_zone.leds_min      = 1;
-    logo_zone.leds_max      = 1;
-    logo_zone.leds_count    = 1;
-    logo_zone.matrix_map    = NULL;
+    uint16_t pid                = aura->device_pid;

-    zones.push_back(logo_zone);
+    for(std::vector<uint8_t>::iterator zone_it = aura_mouse_devices[pid].mouse_zones.begin(); zone_it != aura_mouse_devices[pid].mouse_zones.end(); zone_it++)
+    {
+        zone mouse_zone;

-    led logo_led;
+        mouse_zone.name         = aura_mouse_zone_names[*zone_it];
+        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;

-    logo_led.name           = "Logo";
+        zones.push_back(mouse_zone);

-    leds.push_back(logo_led);
+        led mouse_led;

-    zone scroll_zone;
+        mouse_led.name          = mouse_zone.name + " LED";
+        mouse_led.value         = *zone_it;

-    scroll_zone.name        = "Scroll Wheel";
-    scroll_zone.type        = ZONE_TYPE_SINGLE;
-    scroll_zone.leds_min    = 1;
-    scroll_zone.leds_max    = 1;
-    scroll_zone.leds_count  = 1;
-    scroll_zone.matrix_map  = NULL;
-
-    zones.push_back(scroll_zone);
-
-    led scroll_led;
-
-    scroll_led.name         = "Scroll Wheel";
-
-    leds.push_back(scroll_led);
-
-    zone underglow_zone;
-
-    underglow_zone.name       = "Underglow";
-    underglow_zone.type       = ZONE_TYPE_SINGLE;
-    underglow_zone.leds_min   = 1;
-    underglow_zone.leds_max   = 1;
-    underglow_zone.leds_count = 1;
-    underglow_zone.matrix_map = NULL;
-
-    zones.push_back(underglow_zone);
-
-    led underglow_led;
-
-    underglow_led.name        = "Underglow";
-
-    leds.push_back(underglow_led);
+        leds.push_back(mouse_led);
+    }

    SetupColors();
 }
@@ -119,7 +191,10 @@ void RGBController_AuraMouse::ResizeZone(int /*zone*/, int /*new_size*/)

 void RGBController_AuraMouse::DeviceUpdateLEDs()
 {
-    DeviceUpdateMode();
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        UpdateSingleLED(zone_index);
+    }
 }

 void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
@@ -129,41 +204,11 @@ void RGBController_AuraMouse::UpdateZoneLEDs(int zone)

 void RGBController_AuraMouse::UpdateSingleLED(int led)
 {
-    unsigned char red = 0;
-    unsigned char grn = 0;
-    unsigned char blu = 0;
+    uint8_t red = RGBGetRValue(colors[led]);
+    uint8_t grn = RGBGetGValue(colors[led]);
+    uint8_t blu = RGBGetBValue(colors[led]);

-    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
-    {
-        if(led == 0)
-        {
-            red = RGBGetRValue(colors[led]);
-            grn = RGBGetGValue(colors[led]);
-            blu = RGBGetBValue(colors[led]);
-
-            aura->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu);
-        }
-        else if(led == 1)
-        {
-            red = RGBGetRValue(colors[led]);
-            grn = RGBGetGValue(colors[led]);
-            blu = RGBGetBValue(colors[led]);
-
-            aura->SendUpdate(AURA_MOUSE_ZONE_SCROLL, modes[active_mode].value, red, grn, blu);
-        }
-        else
-        {
-            red = RGBGetRValue(colors[led]);
-            grn = RGBGetGValue(colors[led]);
-            blu = RGBGetBValue(colors[led]);
-
-            aura->SendUpdate(AURA_MOUSE_ZONE_UNDERGLOW, modes[active_mode].value, red, grn, blu);
-        }
-    }
-    else
-    {
-        aura->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu);
-    }
+    aura->SendUpdate(leds[led].value, modes[active_mode].value, red, grn, blu, 0, false, 0, modes[active_mode].brightness);
 }

 void RGBController_AuraMouse::SetCustomMode()
@@ -173,32 +218,29 @@ void RGBController_AuraMouse::SetCustomMode()

 void RGBController_AuraMouse::DeviceUpdateMode()
 {
-    unsigned char red = 0;
-    unsigned char grn = 0;
-    unsigned char blu = 0;
-
    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
    {
-        red = RGBGetRValue(colors[0]);
-        grn = RGBGetGValue(colors[0]);
-        blu = RGBGetBValue(colors[0]);
-
-        aura->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu);
-
-        red = RGBGetRValue(colors[1]);
-        grn = RGBGetGValue(colors[1]);
-        blu = RGBGetBValue(colors[1]);
-
-        aura->SendUpdate(AURA_MOUSE_ZONE_SCROLL, modes[active_mode].value, red, grn, blu);
-
-        red = RGBGetRValue(colors[2]);
-        grn = RGBGetGValue(colors[2]);
-        blu = RGBGetBValue(colors[2]);
-
-        aura->SendUpdate(AURA_MOUSE_ZONE_UNDERGLOW, modes[active_mode].value, red, grn, blu);
+        DeviceUpdateLEDs();
    }
    else
    {
-        aura->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu);
+        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]);
+        }
+
+        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();
+}
@@ -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;
@@ -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();
+}
@@ -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;
+};
@@ -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();
+}
@@ -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;
@@ -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))
@@ -0,0 +1,104 @@
+/*---------------------------------------------------------*\
+|  BlinkyTapeController.cpp                                 |
+|                                                           |
+|  BlinkyTape controller interface                          |
+|                                                           |
+|  Matt Mets (matt@blinkinlabs.com), 07/01/2021             |
+\*---------------------------------------------------------*/
+
+#include "BlinkyTapeController.h"
+
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <string>
+
+#ifndef WIN32
+#define LPSTR           char *
+#define strtok_s        strtok_r
+#endif
+
+BlinkyTapeController::BlinkyTapeController()
+{
+}
+
+BlinkyTapeController::~BlinkyTapeController()
+{
+    if(serialport != nullptr)
+    {
+        serialport->serial_close();
+        delete serialport;
+    }
+}
+
+void BlinkyTapeController::Initialize(const std::string &portname)
+{
+    port_name   = portname;
+
+    serialport  = new serial_port();
+
+    if(!serialport->serial_open(port_name.c_str(), 115200))
+    {
+        delete serialport;
+        serialport = nullptr;
+    }
+}
+
+std::string BlinkyTapeController::GetLocation()
+{
+    if(serialport == nullptr)
+    {
+        return("");
+    }
+
+    return("COM: " + port_name);
+}
+
+char* BlinkyTapeController::GetLEDString()
+{
+    return(led_string);
+}
+
+void BlinkyTapeController::SetLEDs(std::vector<RGBColor> colors)
+{
+    if(serialport == nullptr)
+    {
+        return;
+    }
+
+    /*-------------------------------------------------------------*\
+    | BlinkyTape Protocol                                           |
+    |                                                               |
+    |   Packet size: Number of data bytes + 1                       |
+    |                                                               |
+    |   0-n: Data Byte (0-254)                                      |
+    |   n+1: Packet End Byte (0xFF)                                 |
+    \*-------------------------------------------------------------*/
+    const unsigned int payload_size     = (colors.size() * 3);
+    const unsigned int packet_size      = payload_size + 1;
+
+    std::vector<unsigned char> serial_buf(packet_size);
+
+    /*-------------------------------------------------------------*\
+    | Set up end byte                                               |
+    \*-------------------------------------------------------------*/
+    serial_buf[packet_size - 1] = 0xFF;
+
+    /*-------------------------------------------------------------*\
+    | Copy in color data in RGB order                               |
+    \*-------------------------------------------------------------*/
+    for(unsigned int color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        const unsigned int color_offset = color_idx * 3;
+
+        serial_buf[0x00 + color_offset] = std::min((unsigned int)254, RGBGetRValue(colors[color_idx]));
+        serial_buf[0x01 + color_offset] = std::min((unsigned int)254, RGBGetGValue(colors[color_idx]));
+        serial_buf[0x02 + color_offset] = std::min((unsigned int)254, RGBGetBValue(colors[color_idx]));
+    }
+
+    /*-------------------------------------------------------------*\
+    | Send the packet                                               |
+    \*-------------------------------------------------------------*/
+    serialport->serial_write((char *)serial_buf.data(), packet_size);
+}
+
@@ -0,0 +1,38 @@
+/*---------------------------------------------------------*\
+|  Definitions for BlinkyTape Interface                     |
+|                                                           |
+|  Matt Mets (matt@blinkinlabs.com), 07/01/2021             |
+\*---------------------------------------------------------*/
+
+#ifndef BLINKYTAPE_H
+#define BLINKYTAPE_H
+
+#include "RGBController.h"
+#include "serial_port.h"
+
+struct BlinkyTapeDevice
+{
+    std::string     port;
+    unsigned int    num_leds;
+};
+
+class BlinkyTapeController
+{
+public:
+    BlinkyTapeController();
+    ~BlinkyTapeController();
+
+    void        Initialize(const std::string &portname);
+
+    char*       GetLEDString();
+    std::string GetLocation();
+
+    void        SetLEDs(std::vector<RGBColor> colors);
+
+private:
+    char led_string[1024];
+    std::string port_name;
+    serial_port *serialport = nullptr;
+};
+
+#endif
@@ -0,0 +1,36 @@
+#include "Detector.h"
+#include "BlinkyTapeController.h"
+#include "RGBController.h"
+#include "RGBController_BlinkyTape.h"
+#include "SettingsManager.h"
+#include "find_usb_serial_port.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define BLINKINLABS_VID     0x1D50
+#define BLINKYTAPE_PID      0x605E
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectBlinkyTapeControllers                                                            *
+*                                                                                          *
+*       Detect BlinkyTape devices                                                          *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectBlinkyTapeControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    std::vector<std::string *> device_locations = find_usb_serial_port(BLINKINLABS_VID, BLINKYTAPE_PID);
+
+    for(unsigned int device_idx = 0; device_idx < device_locations.size(); device_idx++)
+    {
+        BlinkyTapeController*     controller     = new BlinkyTapeController();
+        controller->Initialize(*device_locations[device_idx]);
+
+        RGBController_BlinkyTape* rgb_controller = new RGBController_BlinkyTape(controller);
+        rgb_controllers.push_back(rgb_controller);
+    }
+}
+
+REGISTER_DETECTOR("BlinkyTape", DetectBlinkyTapeControllers);
@@ -0,0 +1,137 @@
+/*---------------------------------------------------------*\
+|  RGBController_BlinkyTape.cpp                             |
+|                                                           |
+|  Generic RGB Interface for BlinkyTape Led controller      |
+|                                                           |
+|  Matt Mets (matt@blinkinlabs.com), 07/01/2021             |
+\*---------------------------------------------------------*/
+
+#include "RGBController_BlinkyTape.h"
+
+RGBController_BlinkyTape::RGBController_BlinkyTape(BlinkyTapeController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "BlinkyTape";
+    vendor      = "Blinkinlabs";
+    type        = DEVICE_TYPE_LEDSTRIP;
+    description = "BlinkyTape Controller Device";
+    location    = controller->GetLocation();
+
+    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_BlinkyTape::~RGBController_BlinkyTape()
+{
+    delete controller;
+}
+
+void RGBController_BlinkyTape::SetupZones()
+{
+    zones.clear();
+    leds.clear();
+
+    zone led_zone;
+    led_zone.name       = "LED Strip";
+    led_zone.type       = ZONE_TYPE_LINEAR;
+    led_zone.leds_min   = 0;
+    led_zone.leds_max   = 512;
+    led_zone.leds_count = 0;
+    led_zone.matrix_map = NULL;
+    zones.push_back(led_zone);
+
+    ResizeZone(0, led_zone.leds_count);
+}
+
+void RGBController_BlinkyTape::ResizeZone(int zone, int new_size)
+{
+    /*-------------------------------------------------*\
+    | Explicitly cast these to avoid compiler warnings  |
+    \*-------------------------------------------------*/
+    const unsigned int zone_u       = static_cast<unsigned int>(zone);
+    const unsigned int new_size_u   = static_cast<unsigned int>(new_size);
+
+    /*-------------------------------------------------*\
+    | Check that the zone is in bounds                  |
+    \*-------------------------------------------------*/
+    if((zone_u > zones.size()) || (zone < 0))
+    {
+        return;
+    }
+
+    /*-------------------------------------------------*\
+    | And that the new size is in bounds                |
+    \*-------------------------------------------------*/
+    if((new_size_u > zones.at(zone).leds_max) || (new_size_u < zones.at(zone).leds_min))
+    {
+        return;
+    }
+
+    /*-------------------------------------------------*\
+    | And that there's actually a change                |
+    \*-------------------------------------------------*/
+    if(zones.at(zone).leds_count == new_size_u)
+    {
+        return;
+    }
+
+    /*-------------------------------------------------*\
+    | If the new size is less than the current size,    |
+    | just chop off the end                             |
+    \*-------------------------------------------------*/
+    if(leds.size() > new_size_u)
+    {
+        leds.resize(new_size);
+    }
+
+    /*-------------------------------------------------*\
+    | Otherwise, add new LEDs to the end                |
+    \*-------------------------------------------------*/
+    if(leds.size() < new_size_u)
+    {
+        for(size_t led_idx = leds.size(); led_idx < new_size_u; led_idx++)
+        {
+            led new_led;
+            new_led.name = "LED ";
+            new_led.name.append(std::to_string(led_idx));
+
+            leds.push_back(new_led);
+        }
+    }
+
+    zones.at(zone).leds_count = new_size;
+
+    SetupColors();
+}
+
+void RGBController_BlinkyTape::DeviceUpdateLEDs()
+{
+    controller->SetLEDs(colors);
+}
+
+void RGBController_BlinkyTape::UpdateZoneLEDs(int /*zone*/)
+{
+    controller->SetLEDs(colors);
+}
+
+void RGBController_BlinkyTape::UpdateSingleLED(int /*led*/)
+{
+    controller->SetLEDs(colors);
+}
+
+void RGBController_BlinkyTape::SetCustomMode()
+{
+
+}
+
+void RGBController_BlinkyTape::DeviceUpdateMode()
+{
+
+}
@@ -0,0 +1,33 @@
+/*---------------------------------------------------------*\
+|  RGBController_BlinkyTape.h                               |
+|                                                           |
+|  Generic RGB Interface for BlinkyTape Led controller      |
+|                                                           |
+|  Matt Mets (matt@blinkinlabs.com), 07/01/2021             |
+\*---------------------------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "serial_port.h"
+#include "BlinkyTapeController.h"
+
+class RGBController_BlinkyTape : public RGBController
+{
+public:
+    RGBController_BlinkyTape(BlinkyTapeController* controller_ptr);
+    ~RGBController_BlinkyTape();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    BlinkyTapeController*   controller;
+};
@@ -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);
 }
@@ -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();
 };
@@ -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);
@@ -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;
 };
@@ -0,0 +1,199 @@
+/*-------------------------------------------------------------------*\
+|  CMMM711Controller.cpp                                              |
+|                                                                     |
+|  Driver for Coolermaster Master Mouse 711                           |
+|                                                                     |
+|  Chris M (Dr_No)          14th Feb 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "CMMM711Controller.h"
+#include <cstring>
+
+CMMM711Controller::CMMM711Controller(hid_device* dev_handle, char *_path)
+{
+    const int szTemp = HID_MAX_STR;
+    wchar_t tmpName[szTemp];
+
+    dev                     = dev_handle;
+    location                = _path;
+    current_speed           = CM_MM711_SPEED_NORMAL;
+
+    hid_get_manufacturer_string(dev, tmpName, szTemp);
+    std::wstring wName = std::wstring(tmpName);
+    device_name = std::string(wName.begin(), wName.end());
+
+    hid_get_product_string(dev, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
+
+    hid_get_indexed_string(dev, 2, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    serial = std::string(wName.begin(), wName.end());
+
+    SendInitPacket();
+    GetColourStatus();
+    GetCustomStatus();
+    GetModeStatus();
+}
+
+CMMM711Controller::~CMMM711Controller()
+{
+    hid_close(dev);
+}
+
+void CMMM711Controller::GetColourStatus()
+{
+    uint8_t buffer[CM_MM711_PACKET_SIZE]    = { 0x00, 0x52, 0x2B };
+
+    hid_write(dev, buffer, CM_MM711_PACKET_SIZE);
+    hid_read_timeout(dev, buffer, CM_MM711_PACKET_SIZE, CM_MM711_INTERRUPT_TIMEOUT);
+
+    current_brightness      = buffer[CM_MM711_BRIGHTNESS_BYTE - 1];
+    current_red             = buffer[CM_MM711_RED_BYTE - 1];
+    current_green           = buffer[CM_MM711_GREEN_BYTE - 1];
+    current_blue            = buffer[CM_MM711_BLUE_BYTE - 1];
+}
+
+void CMMM711Controller::GetCustomStatus()
+{
+    uint8_t buffer[CM_MM711_PACKET_SIZE]    = { 0x00, 0x52, 0xA8 };
+    int read_size                           = CM_MM711_PACKET_SIZE - 1;
+    int result                              = 0;
+
+    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);
+
+    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()
+{
+    uint8_t buffer[CM_MM711_PACKET_SIZE]    = { 0x00, 0x52, 0x28 };
+    int buffer_size                         = (sizeof(buffer) / sizeof(buffer[0]));
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_MM711_INTERRUPT_TIMEOUT);
+
+    current_mode            = buffer[CM_MM711_MODE_BYTE - 1];
+}
+
+std::string CMMM711Controller::GetDeviceName()
+{
+    return device_name;
+}
+
+std::string CMMM711Controller::GetSerial()
+{
+    return serial;
+}
+
+std::string CMMM711Controller::GetLocation()
+{
+    return("HID: " + location);
+}
+
+unsigned char CMMM711Controller::GetMode()
+{
+    return current_mode;
+}
+
+unsigned char CMMM711Controller::GetLedRed()
+{
+    return current_red;
+}
+
+unsigned char CMMM711Controller::GetLedGreen()
+{
+    return current_green;
+}
+
+unsigned char CMMM711Controller::GetLedBlue()
+{
+    return current_blue;
+}
+
+unsigned char CMMM711Controller::GetLedSpeed()
+{
+    return current_speed;
+}
+
+RGBColor CMMM711Controller::GetWheelColour()
+{
+    return wheel_colour;
+}
+
+RGBColor CMMM711Controller::GetLogoColour()
+{
+    return logo_colour;
+}
+
+void CMMM711Controller::SetLedsDirect(RGBColor wheel_colour, RGBColor logo_colour)
+{
+    unsigned char buffer[CM_MM711_PACKET_SIZE]  = { 0x00, 0x51, 0xA8, 0x00, 0x00 };
+
+    buffer[CM_MM711_MODE_BYTE]                  = RGBGetRValue(wheel_colour);
+    buffer[CM_MM711_SPEED_BYTE]                 = RGBGetGValue(wheel_colour);
+    buffer[CM_MM711_NFI_1]                      = RGBGetBValue(wheel_colour);
+    buffer[CM_MM711_NFI_2]                      = RGBGetRValue(logo_colour);
+    buffer[CM_MM711_NFI_3]                      = RGBGetGValue(logo_colour);
+    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
+}
+
+void CMMM711Controller::SendUpdate(uint8_t mode, uint8_t speed, RGBColor colour, uint8_t brightness)
+{
+    unsigned char buffer[CM_MM711_PACKET_SIZE]  = { 0x00, 0x51, 0x2B, 0x00, 0x00 };
+
+    buffer[CM_MM711_MODE_BYTE]                  = mode;
+    buffer[CM_MM711_SPEED_BYTE]                 = speed;
+    buffer[CM_MM711_NFI_1]                      = 0x20;
+    buffer[CM_MM711_NFI_2]                      = 0xFF;
+    buffer[CM_MM711_NFI_3]                      = 0xFF;
+    buffer[CM_MM711_BRIGHTNESS_BYTE]            = brightness;
+    buffer[CM_MM711_RED_BYTE]                   = RGBGetRValue(colour);
+    buffer[CM_MM711_GREEN_BYTE]                 = RGBGetGValue(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);
+}
+
+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)
+{
+    unsigned char buffer[CM_MM711_PACKET_SIZE]  = { 0x00, 0x51, 0x28, 0x00, 0x00 };
+
+    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);
+}
@@ -0,0 +1,101 @@
+/*-------------------------------------------------------------------*\
+|  CMMM711Controller.h                                                |
+|                                                                     |
+|  Driver for Coolermaster Master Mouse 711                           |
+|                                                                     |
+|  Chris M (Dr_No)          14th Feb 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <array>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
+#pragma once
+
+#define CM_MM711_PACKET_SIZE 65
+#define CM_MM711_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
+#define CM_MM711_HEADER_DATA_SIZE (sizeof(argb_header_data) / sizeof(argb_headers) )
+#define CM_MM711_INTERRUPT_TIMEOUT 250
+#define CM_MM711_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
+#define HID_MAX_STR 255
+
+enum
+{
+    CM_MM711_REPORT_BYTE            = 1,
+    CM_MM711_COMMAND_BYTE           = 2,
+    CM_MM711_FUNCTION_BYTE          = 3,
+    CM_MM711_ZONE_BYTE              = 4,
+    CM_MM711_MODE_BYTE              = 5,
+    CM_MM711_SPEED_BYTE             = 6,
+    CM_MM711_NFI_1                  = 7,
+    CM_MM711_NFI_2                  = 8,
+    CM_MM711_NFI_3                  = 9,
+    CM_MM711_BRIGHTNESS_BYTE        = 10,
+    CM_MM711_RED_BYTE               = 11,
+    CM_MM711_GREEN_BYTE             = 12,
+    CM_MM711_BLUE_BYTE              = 13,
+};
+
+enum
+{
+    CM_MM711_MODE_STATIC            = 0,    //Static Mode
+    CM_MM711_MODE_BREATHING         = 1,    //Breathing Mode
+    CM_MM711_MODE_SPECTRUM_CYCLE    = 2,    //Spectrum Cycle Mode
+    CM_MM711_MODE_INDICATOR         = 4,    //Indicator Mode
+    CM_MM711_MODE_CUSTOM            = 176,  //Custom LED Control
+    CM_MM711_MODE_OFF               = 254   //Turn Off
+};
+
+enum
+{
+    CM_MM711_SPEED_SLOWEST          = 0x5F, // Slowest speed
+    CM_MM711_SPEED_NORMAL           = 0x38, // Normal speed
+    CM_MM711_SPEED_FASTEST          = 0x20, // Fastest speed
+};
+
+class CMMM711Controller
+{
+public:
+    CMMM711Controller(hid_device* dev_handle, char *_path);
+    ~CMMM711Controller();
+
+    std::string GetDeviceName();
+    std::string GetSerial();
+    std::string GetLocation();
+
+    uint8_t     GetZoneIndex();
+    uint8_t     GetMode();
+    uint8_t     GetLedRed();
+    uint8_t     GetLedGreen();
+    uint8_t     GetLedBlue();
+    uint8_t     GetLedSpeed();
+    RGBColor    GetWheelColour();
+    RGBColor    GetLogoColour();
+
+    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;
+    std::string location;
+    hid_device* dev;
+
+    uint8_t     current_mode;
+    uint8_t     current_speed;
+
+    uint8_t     current_brightness;
+    uint8_t     current_red;
+    uint8_t     current_green;
+    uint8_t     current_blue;
+    RGBColor    wheel_colour;
+    RGBColor    logo_colour;
+
+    void        GetColourStatus();
+    void        GetCustomStatus();
+    void        GetModeStatus();
+    void        SendInitPacket();
+    void        SendApplyPacket(uint8_t mode);
+};
@@ -29,7 +29,6 @@ CMR6000Controller::CMR6000Controller(hid_device* dev_handle, char *_path)
    wName  = std::wstring(tmpName);
    serial = std::string(wName.begin(), wName.end());

-    GetStatus();        //When setting up device get current status
 }

 CMR6000Controller::~CMR6000Controller()
@@ -40,30 +39,6 @@ CMR6000Controller::~CMR6000Controller()
    }
 }

-void CMR6000Controller::GetStatus()
-{
-    unsigned char buffer[CM_6K_PACKET_SIZE]     = { 0x00, 0x52, 0xA0, 0x01, 0x00, 0x00, 0x03 };
-    int buffer_size                             = (sizeof(buffer) / sizeof(buffer[0]));
-
-    // Request mode
-    hid_write(dev, buffer, buffer_size);
-    hid_read(dev, buffer, buffer_size);
-
-    unsigned char cmdbuffer[CM_6K_PACKET_SIZE]  = { 0x00, 0x52, 0x2C, 0x01, 0x00 };
-    int cmdbuffer_size                          = (sizeof(cmdbuffer) / sizeof(cmdbuffer[0]));
-
-    current_mode    = buffer[0x0A];
-    cmdbuffer[0x05] = current_mode;
-    hid_write(dev, cmdbuffer, cmdbuffer_size);
-    hid_read(dev, cmdbuffer, cmdbuffer_size);
-
-    current_speed       = cmdbuffer[0x05];
-    current_brightness  = cmdbuffer[0x09];
-    current_red         = cmdbuffer[0x0A];
-    current_green       = cmdbuffer[0x0B];
-    current_blue        = cmdbuffer[0x0C];
-}
-
 std::string CMR6000Controller::GetDeviceName()
 {
    return device_name;
@@ -104,12 +79,17 @@ unsigned char CMR6000Controller::GetLedSpeed()
    return current_speed;
 }

+unsigned char CMR6000Controller::GetBrightness()
+{
+    return current_brightness;
+}
+
 bool CMR6000Controller::GetRandomColours()
 {
    return current_random;
 }

-void CMR6000Controller::SetMode(unsigned char mode, unsigned char speed, unsigned char red, unsigned char green, unsigned char blue, unsigned char random)
+void CMR6000Controller::SetMode(unsigned char mode, unsigned char speed, unsigned char red, unsigned char green, unsigned char blue, unsigned char random, unsigned char brightness)
 {
    current_mode        = mode;
    current_speed       = speed;
@@ -117,7 +97,7 @@ void CMR6000Controller::SetMode(unsigned char mode, unsigned char speed, unsigne
    current_green       = green;
    current_blue        = blue;
    current_random      = random;
-    current_brightness  = (current_mode == CM_MR6000_MODE_COLOR_CYCLE) ? 0x7F : 0xFF;    //Color_Cycle brightness needs to be clamped to 0x7F to avoid wash out
+    current_brightness  = brightness;

    SendUpdate();
 }
@@ -144,7 +124,7 @@ void CMR6000Controller::SendUpdate()
        buffer[0x03] = 0x01;
        buffer[0x04] = 0x00;
        buffer[0x05] = current_mode;
-        buffer[0x06] = (current_mode == CM_MR6000_MODE_STATIC) ? 0xFF: current_speed;
+        buffer[0x06] = (current_mode == CM_MR6000_MODE_DIRECT) ? 0xFF: current_speed;
        buffer[0x07] = (current_mode == CM_MR6000_MODE_BREATHE)? current_random : 0x00; //random (A0)
        buffer[0x08] = (current_mode == CM_MR6000_MODE_BREATHE)? 0x03 : 0xFF;
        //buffer[0x09] = 0xFF;
@@ -20,7 +20,7 @@

 enum
 {
-    CM_MR6000_MODE_STATIC        = 0x00, //Static Mode
+    CM_MR6000_MODE_DIRECT        = 0x00, //Direct Mode
    CM_MR6000_MODE_BREATHE       = 0x01, //Breathe Mode
    CM_MR6000_MODE_COLOR_CYCLE   = 0x02, //Color cycle
    CM_MR6000_MODE_OFF           = 0xFF, //Off
@@ -56,8 +56,9 @@ public:
    unsigned char GetLedGreen();
    unsigned char GetLedBlue();
    unsigned char GetLedSpeed();
+    unsigned char GetBrightness();
    bool          GetRandomColours();
-    void          SetMode(unsigned char mode, unsigned char speed, unsigned char red, unsigned char green, unsigned char blue, unsigned char random);
+    void          SetMode(unsigned char mode, unsigned char speed, unsigned char red, unsigned char green, unsigned char blue, unsigned char random, unsigned char brightness);

 private:
    std::string             device_name;
@@ -74,7 +75,6 @@ private:
    unsigned char           current_blue;
    unsigned char           current_brightness;

-    void GetStatus();
    void SendUpdate();
    void SendEnableCommand();
    void SendApplyCommand();
@@ -0,0 +1,367 @@
+/*-------------------------------------------------------------------*\
+|  CMRGBController.cpp                                                |
+|                                                                     |
+|  Driver for Coolermaster RGB USB Controller                         |
+|                                                                     |
+|  Nic W (midgetspy)        13th Apr 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBController_CMRGBController.h"
+#include "CMRGBController.h"
+#include <cstring>
+
+CMRGBController::CMRGBController(hid_device* dev_handle, char* path)
+{
+    const int szTemp = 256;
+    wchar_t tmpName[szTemp];
+
+    dev         = dev_handle;
+    location    = path;
+
+    hid_get_manufacturer_string(dev, tmpName, szTemp);
+    std::wstring wName = std::wstring(tmpName);
+    device_name = std::string(wName.begin(), wName.end());
+
+    hid_get_product_string(dev, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
+
+    hid_get_serial_number_string(dev, tmpName, szTemp);
+    wName = std::wstring(tmpName);
+    serial = std::string(wName.begin(), wName.end());
+
+    ReadCurrentMode();
+}
+
+void CMRGBController::SendFlowControl(unsigned char byte_flag)
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { 0x00, CM_RGBC_OPCODE_OP_FLOW_CONTROL }; //Packets on Windows need a 0x00 if they don't use ReportIDs
+
+    buffer[0x02] = byte_flag;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+}
+
+void CMRGBController::SendApply()
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { 0x00, CM_RGBC_OPCODE_OP_UNKNOWN_50, CM_RGBC_OPCODE_TYPE_UNKNOWN_55 }; //Packets on Windows need a 0x00 if they don't use ReportIDs
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+}
+
+void CMRGBController::SendReadMode()
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { };
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_OP]     = CM_RGBC_OPCODE_OP_READ;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_TYPE]   = CM_RGBC_OPCODE_TYPE_MODE;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+
+    current_mode = buffer[CM_RGBC_PACKET_OFFSET_MODE];
+}
+
+void CMRGBController::SendSetMode(unsigned char mode)
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { };
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_OP]     = CM_RGBC_OPCODE_OP_WRITE;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_TYPE]   = CM_RGBC_OPCODE_TYPE_MODE;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MODE]   = mode;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+}
+
+void CMRGBController::SendSetCustomColors(RGBColor color_1, RGBColor color_2, RGBColor color_3, RGBColor color_4)
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { };
+
+    current_port1_color = color_1;
+    current_port2_color = color_2;
+    current_port3_color = color_3;
+    current_port4_color = color_4;
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_OP]                     = CM_RGBC_OPCODE_OP_WRITE;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_TYPE]                   = CM_RGBC_OPCODE_TYPE_LED_INFO;
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_1]       = RGBGetRValue(color_1);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_1 + 1]   = RGBGetGValue(color_1);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_1 + 2]   = RGBGetBValue(color_1);
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_2]       = RGBGetRValue(color_2);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_2 + 1]   = RGBGetGValue(color_2);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_2 + 2]   = RGBGetBValue(color_2);
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_3]       = RGBGetRValue(color_3);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_3 + 1]   = RGBGetGValue(color_3);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_3 + 2]   = RGBGetBValue(color_3);
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_4]       = RGBGetRValue(color_4);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_4 + 1]   = RGBGetGValue(color_4);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_4 + 2]   = RGBGetBValue(color_4);
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+}
+
+void CMRGBController::SendReadCustomColors()
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { };
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_OP]     = CM_RGBC_OPCODE_OP_READ;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_TYPE]   = CM_RGBC_OPCODE_TYPE_LED_INFO;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+
+    current_port1_color = ToRGBColor(
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_1],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_1 + 1],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_1 + 2]);
+    current_port2_color = ToRGBColor(
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_2],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_2 + 1],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_2 + 2]);
+    current_port3_color = ToRGBColor(
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_3],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_3 + 1],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_3 + 2]);
+    current_port4_color = ToRGBColor(
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_4],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_4 + 1],
+        buffer[CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_4 + 2]);
+}
+
+void CMRGBController::SendSetConfig(unsigned char mode, unsigned char speed, unsigned char brightness, RGBColor color_1, RGBColor color_2, bool simplified=false, bool multilayer=false)
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { };
+
+    current_mode            = mode;
+    current_speed           = speed;
+    current_brightness      = brightness;
+    current_mode_color_1    = color_1;
+    current_mode_color_2    = color_2;
+
+    /*---------------------------------------------*\
+    | Handle special cases                          |
+    \*---------------------------------------------*/
+    switch(mode)
+    {
+        case CM_RGBC_MODE_COLOR_CYCLE:
+            brightness  = 0xDF;
+            color_1     = 0xFFFFFF;
+            color_2     = 0x000000;
+            break;
+
+        case CM_RGBC_MODE_OFF:
+            brightness  = 0x03;
+            break;
+    }
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_OP]                 = CM_RGBC_OPCODE_OP_WRITE;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_TYPE]               = simplified ? CM_RGBC_OPCODE_TYPE_CONFIG_SIMPLIFIED : CM_RGBC_OPCODE_TYPE_CONFIG_FULL;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MODE]               = mode;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_SPEED]              = speed;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_BRIGHTNESS]         = brightness;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_COLOR_1]            = RGBGetRValue(color_1);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_COLOR_1 + 1]        = RGBGetGValue(color_1);
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_COLOR_1 + 2]        = RGBGetBValue(color_1);
+
+    /*---------------------------------------------*\
+    | Magic values, meaning unknown                 |
+    \*---------------------------------------------*/
+    buffer[REPORT_ID_OFFSET + 0x06] = (mode == CM_RGBC_MODE_BREATHING)  ? 0x20 : 0x00;
+    buffer[REPORT_ID_OFFSET + 0x07] = (mode == CM_RGBC_MODE_STAR)       ? 0x19 : 0xFF;
+    buffer[REPORT_ID_OFFSET + 0x08]                                     = 0xFF;
+
+    if(!simplified)
+    {
+        buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MULTILAYER]     = multilayer ? 0x01 : 0x00;
+        buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_COLOR_2]        = RGBGetRValue(color_2);
+        buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_COLOR_2 + 1]    = RGBGetGValue(color_2);
+        buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_COLOR_2 + 2]    = RGBGetBValue(color_2);
+
+        for(int i = REPORT_ID_OFFSET + 16; i < CM_RGBC_PACKET_SIZE; i++)
+        {
+            buffer[i] = 0xFF;
+        }
+    }
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+}
+
+void CMRGBController::SendReadConfig(unsigned char mode)
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { };
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_OP]             = CM_RGBC_OPCODE_OP_READ;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_TYPE]           = CM_RGBC_OPCODE_TYPE_CONFIG_FULL;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_MODE]           = mode;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+
+    current_mode            = mode;
+    current_speed           = buffer[CM_RGBC_PACKET_OFFSET_SPEED];
+    current_brightness      = buffer[CM_RGBC_PACKET_OFFSET_BRIGHTNESS];
+
+    current_mode_color_1    = ToRGBColor(
+        buffer[CM_RGBC_PACKET_OFFSET_COLOR_1],
+        buffer[CM_RGBC_PACKET_OFFSET_COLOR_1 + 1],
+        buffer[CM_RGBC_PACKET_OFFSET_COLOR_1 + 2]);
+    current_mode_color_2    = ToRGBColor(
+        buffer[CM_RGBC_PACKET_OFFSET_COLOR_2],
+        buffer[CM_RGBC_PACKET_OFFSET_COLOR_2 + 1],
+        buffer[CM_RGBC_PACKET_OFFSET_COLOR_2 + 2]);
+}
+
+void CMRGBController::SendCustomColorStart()
+{
+    const unsigned char buffer_size     = CM_RGBC_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { };
+
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_OP]     = CM_RGBC_OPCODE_OP_WRITE;
+    buffer[REPORT_ID_OFFSET + CM_RGBC_PACKET_OFFSET_TYPE]   = CM_RGBC_OPCODE_TYPE_UNKNOWN_30;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_RGBC_INTERRUPT_TIMEOUT);
+}
+
+void CMRGBController::ReadCurrentMode()
+{
+    SendFlowControl(CM_RGBC_OPCODE_FLOW_01);
+
+    SendReadMode();
+}
+
+void CMRGBController::ReadModeConfig(unsigned char mode)
+{
+    SendFlowControl(CM_RGBC_OPCODE_FLOW_00);
+
+    SendReadConfig(mode);
+
+    if(mode == CM_RGBC_MODE_MULTIPLE)
+    {
+        SendReadCustomColors();
+    }
+}
+
+void CMRGBController::SetMode(unsigned char mode, unsigned char speed, unsigned char brightness, RGBColor color_1, RGBColor color_2)
+{
+    SendFlowControl(CM_RGBC_OPCODE_FLOW_01);
+
+    SendSetConfig(mode, speed, brightness, color_1, color_2, false);
+
+    SendSetMode(mode);
+
+    SendApply();
+
+    SendFlowControl(CM_RGBC_OPCODE_FLOW_00);
+}
+
+void CMRGBController::SetLedsDirect(RGBColor color_1, RGBColor color_2, RGBColor color_3, RGBColor color_4)
+{
+    SendFlowControl(CM_RGBC_OPCODE_FLOW_80);
+
+    SendCustomColorStart();
+
+    SendSetCustomColors(color_1, color_2, color_3, color_4);
+
+    SendSetMode(CM_RGBC_MODE_MULTIPLE);
+
+    SendCustomColorStart();
+
+    SendSetConfig(CM_RGBC_MODE_MULTIPLE, 0x00, 0xFF, color_1, 0x000000, false);
+
+    SendApply();
+
+    SendFlowControl(CM_RGBC_OPCODE_FLOW_00);
+}
+
+std::string CMRGBController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string CMRGBController::GetSerial()
+{
+    return(serial);
+}
+
+std::string CMRGBController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+unsigned char CMRGBController::GetMode()
+{
+    return(current_mode);
+}
+
+unsigned char CMRGBController::GetSpeed()
+{
+    return(current_speed);
+}
+
+unsigned char CMRGBController::GetBrightness()
+{
+    return(current_brightness);
+}
+
+RGBColor CMRGBController::GetModeColor(int color_number)
+{
+    switch(color_number)
+    {
+        case 0:
+            return(current_mode_color_1);
+        
+        case 1:
+            return(current_mode_color_2);
+        
+        default:
+            return(ToRGBColor(0, 0, 0));
+    }
+}
+
+RGBColor CMRGBController::GetPortColor(int port_number)
+{
+    switch(port_number)
+    {
+        case 0:
+            return(current_port1_color);
+        
+        case 1:
+            return(current_port2_color);
+        
+        case 2:
+            return(current_port3_color);
+        
+        case 3:
+            return(current_port4_color);
+        
+        default:
+            return(ToRGBColor(0, 0, 0));
+    }
+}
+
+CMRGBController::~CMRGBController()
+{
+    if(dev)
+    {
+        hid_close(dev);
+    }
+}
@@ -0,0 +1,149 @@
+/*-------------------------------------------------------------------*\
+|  CMRGBController.h                                                  |
+|                                                                     |
+|  Driver for Coolermaster RGB USB Controller                         |
+|                                                                     |
+|  Nic W (midgetspy)        13th Apr 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
+#pragma once
+#define CM_RGBC_NUM_LEDS 4
+
+#define REPORT_ID_OFFSET                        1
+#define CM_RGBC_PACKET_SIZE                     64 + REPORT_ID_OFFSET //This needs to have one byte extra for the report ID thing
+#define CM_RGBC_PACKET_OFFSET_OP                0x00
+#define CM_RGBC_PACKET_OFFSET_TYPE              0x01
+#define CM_RGBC_PACKET_OFFSET_MULTILAYER        0x02
+#define CM_RGBC_PACKET_OFFSET_MODE              0x04
+#define CM_RGBC_PACKET_OFFSET_SPEED             0x05
+#define CM_RGBC_PACKET_OFFSET_BRIGHTNESS        0x09
+#define CM_RGBC_PACKET_OFFSET_COLOR_1           0x0A
+#define CM_RGBC_PACKET_OFFSET_COLOR_2           0x0D
+
+#define CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_1  0x04
+#define CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_2  0x07
+#define CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_3  0x0A
+#define CM_RGBC_PACKET_OFFSET_MULTIPLE_COLOR_4  0x0D
+
+#define CM_RGBC_INTERRUPT_TIMEOUT               250
+
+#define CM_RGBC_SPEED_NONE                      0x05
+#define CM_RGBC_BRIGHTNESS_OFF                  0x03
+
+/*-------------------------------------------------*\
+| OP OPCODES                                        |
+\*-------------------------------------------------*/
+enum
+{
+    CM_RGBC_OPCODE_OP_FLOW_CONTROL          = 0x41,
+    CM_RGBC_OPCODE_OP_UNKNOWN_50            = 0x50,
+    CM_RGBC_OPCODE_OP_WRITE                 = 0x51,
+    CM_RGBC_OPCODE_OP_READ                  = 0x52,
+};
+
+/*-------------------------------------------------*\
+| CONTROL FLOW OPCODES                              |
+\*-------------------------------------------------*/
+enum
+{
+    CM_RGBC_OPCODE_FLOW_00                  = 0x00,
+    CM_RGBC_OPCODE_FLOW_01                  = 0x01,
+    CM_RGBC_OPCODE_FLOW_80                  = 0x80,
+};
+
+/*-------------------------------------------------*\
+| OP TYPE OPCODES                                   |
+\*-------------------------------------------------*/
+enum
+{
+    CM_RGBC_OPCODE_TYPE_MODE                = 0x28,
+    CM_RGBC_OPCODE_TYPE_CONFIG_SIMPLIFIED   = 0x2B,
+    CM_RGBC_OPCODE_TYPE_CONFIG_FULL         = 0x2C,
+    CM_RGBC_OPCODE_TYPE_UNKNOWN_30          = 0x30,
+    CM_RGBC_OPCODE_TYPE_UNKNOWN_55          = 0x55,
+    CM_RGBC_OPCODE_TYPE_LED_INFO            = 0xA8,
+};
+
+/*-------------------------------------------------*\
+| MODES                                             |
+\*-------------------------------------------------*/
+enum
+{
+    CM_RGBC_MODE_STATIC                     = 0x00,
+    CM_RGBC_MODE_BREATHING                  = 0x01,
+    CM_RGBC_MODE_COLOR_CYCLE                = 0x02,
+    CM_RGBC_MODE_STAR                       = 0x03,
+    CM_RGBC_MODE_MULTIPLE                   = 0x04,
+    CM_RGBC_MODE_MULTILAYER                 = 0xE0,
+    CM_RGBC_MODE_OFF                        = 0xFE,
+};
+
+/*-------------------------------------------------*\
+| SPEED                                             |
+\*-------------------------------------------------*/
+enum
+{
+    CM_RGBC_SPEED_BREATHING_SLOWEST         = 0x3C,
+    CM_RGBC_SPEED_BREATHING_FASTEST         = 0x26,
+    CM_RGBC_SPEED_COLOR_CYCLE_SLOWEST       = 0x96,
+    CM_RGBC_SPEED_COLOR_CYCLE_FASTEST       = 0x68,
+    CM_RGBC_SPEED_STAR_SLOWEST              = 0x46,
+    CM_RGBC_SPEED_STAR_FASTEST              = 0x32,
+};
+
+class CMRGBController
+{
+public:
+    CMRGBController(hid_device* dev_handle, char* path);
+    ~CMRGBController();
+
+    std::string         GetDeviceName();
+    std::string         GetSerial();
+    std::string         GetLocation();
+
+    unsigned char       GetMode();
+    unsigned char       GetSpeed();
+    unsigned char       GetBrightness();
+    RGBColor            GetModeColor(int color_number);
+    RGBColor            GetPortColor(int port_number);
+
+    void                SetMode(unsigned char mode, unsigned char speed, unsigned char brightness, RGBColor color_1, RGBColor color_2);
+    void                SetLedsDirect(RGBColor color_1, RGBColor color_2, RGBColor color_3, RGBColor color_4);
+
+    void                ReadCurrentMode();
+    void                ReadModeConfig(unsigned char mode);
+
+private:
+    std::string         device_name;
+    std::string         serial;
+    std::string         location;
+    hid_device*         dev;
+
+    unsigned char       current_mode;
+    unsigned char       current_speed;
+    unsigned char       current_brightness;
+    RGBColor            current_mode_color_1;
+    RGBColor            current_mode_color_2;
+    RGBColor            current_port1_color;
+    RGBColor            current_port2_color;
+    RGBColor            current_port3_color;
+    RGBColor            current_port4_color;
+
+    void                SendFlowControl(unsigned char byte_flag);
+    void                SendApply();
+    void                SendCustomColorStart();
+
+    void                SendReadMode();
+    void                SendSetMode(unsigned char mode);
+
+    void                SendReadCustomColors();
+    void                SendSetCustomColors(RGBColor color_1, RGBColor color_2, RGBColor color_3, RGBColor color_4);
+
+    void                SendReadConfig(unsigned char mode);
+    void                SendSetConfig(unsigned char mode, unsigned char speed, unsigned char brightness, RGBColor color_1, RGBColor color_2, bool simplified, bool multilayer);
+};
@@ -135,50 +135,47 @@ void CMSmallARGBController::SetLedCount(int zone, int led_count)
    hid_write(dev, buffer, buffer_size);
 }

-void CMSmallARGBController::SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours)
+void CMSmallARGBController::SetMode(unsigned char mode, unsigned char speed, unsigned char brightness, RGBColor colour, bool random_colours)
 {
-    current_mode    = mode;
-    current_speed   = speed;
-    current_red     = RGBGetRValue(colour);
-    current_green   = RGBGetGValue(colour);
-    current_blue    = RGBGetBValue(colour);
-    bool_random     = random_colours;
+    current_mode        = mode;
+    current_speed       = speed;
+    current_brightness  = brightness;
+    current_red         = RGBGetRValue(colour);
+    current_green       = RGBGetGValue(colour);
+    current_blue        = RGBGetBValue(colour);
+    bool_random         = random_colours;

    SendUpdate();
 }

-void CMSmallARGBController::SetLedsDirect(RGBColor* /*led_colours*/, unsigned int /*led_count*/)
+void CMSmallARGBController::SetLedsDirect(RGBColor* led_colours, unsigned int led_count)
 {
-    // Mode not yet Tested
-    /*
-    const unsigned char buffer_size     = 0x41;
-    unsigned char buffer[buffer_size]   = { 0x00 };
-    unsigned char packet_count          = 0x00;
-    std::vector<unsigned char> colours;
+    const unsigned char buffer_size     = CM_SMALL_ARGB_PACKET_SIZE;
+    unsigned char buffer[buffer_size]   = { 0x00, 0x00, 0x10, 0x02 };
+    unsigned char packet_count          = 0;
+    std::vector<uint8_t> colours;

-    //Set up the RGB triplets to send
-    for(int i = 0; i < led_count; i++)
+    /*---------------------------------------------*\
+    | Set up the RGB triplets to send               |
+    \*---------------------------------------------*/
+    for(unsigned int i = 0; i < led_count; i++)
    {
        RGBColor      colour            = led_colours[i];
-        unsigned char r                 = RGBGetRValue(colour);
-        unsigned char g                 = RGBGetGValue(colour);
-        unsigned char b                 = RGBGetBValue(colour);

-        colours.push_back(r);
-        colours.push_back(g);
-        colours.push_back(b);
+        colours.push_back( RGBGetRValue(colour) );
+        colours.push_back( RGBGetGValue(colour) );
+        colours.push_back( RGBGetBValue(colour) );
    }

-    //buffer[CM_ARGB_REPORT_BYTE]       = packet_count;
-    buffer[CM_SMALL_ARGB_COMMAND_BYTE]  = 0x10;
-    buffer[CM_SMALL_ARGB_FUNCTION_BYTE] = 0x02;
-    buffer[CM_SMALL_ARGB_ZONE_BYTE]     = small_argb_header_data[zone_index].header;
-    buffer[CM_SMALL_ARGB_MODE_BYTE]     = 0x30; //30 might be the LED count??
-    unsigned char buffer_idx            = CM_SMALL_ARGB_MODE_BYTE + 1;    //Start colour info from
+    buffer[CM_SMALL_ARGB_ZONE_BYTE]     = zone_index - 1; //argb_header_data[zone_index].header;
+    buffer[CM_SMALL_ARGB_MODE_BYTE]     = led_count;
+    unsigned char buffer_idx            = CM_SMALL_ARGB_MODE_BYTE + 1;

-    for (std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = 0)
+    for(std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = CM_SMALL_ARGB_COMMAND_BYTE)
    {
-        //Fill the write buffer till its full or the colour buffer is empty
+        /*-----------------------------------------------------------------*\
+        | Fill the write buffer till its full or the colour buffer is empty |
+        \*-----------------------------------------------------------------*/
        buffer[CM_SMALL_ARGB_REPORT_BYTE] = packet_count;
        while (( buffer_idx < buffer_size) && ( it != colours.end() ))
        {
@@ -187,24 +184,19 @@ void CMSmallARGBController::SetLedsDirect(RGBColor* /*led_colours*/, unsigned in
            it++;
        }

-        hid_write(dev, buffer, buffer_size);
-        hid_read_timeout(dev, buffer, buffer_size, CM_SMALL_ARGB_INTERRUPT_TIMEOUT);
+        if(it == colours.end())
+        {
+            buffer[CM_SMALL_ARGB_REPORT_BYTE] += 0x80;
+        }

-        //reset the write buffer
-        memset(buffer, 0x00, sizeof(buffer) );
+        hid_write(dev, buffer, buffer_size);
+
+        /*-----------------------------------------------------------------*\
+        | Reset the write buffer                                            |
+        \*-----------------------------------------------------------------*/
+        memset(buffer, 0x00, buffer_size );
        packet_count++;
    }
-    buffer[CM_SMALL_ARGB_REPORT_BYTE]         = 0x82;
-    buffer[CM_SMALL_ARGB_COMMAND_BYTE]        = 0x62;
-    buffer[CM_SMALL_ARGB_FUNCTION_BYTE]       = 0x00;
-    buffer[CM_SMALL_ARGB_ZONE_BYTE]           = 0x73;
-    buffer[CM_SMALL_ARGB_MODE_BYTE]           = 0x00;
-    buffer[CM_SMALL_ARGB_SPEED_BYTE]          = 0x33;
-    buffer[CM_SMALL_ARGB_COLOUR_INDEX_BYTE]   = 0x18;
-
-    hid_write(dev, buffer, buffer_size);
-    hid_read_timeout(dev, buffer, buffer_size, CM_SMALL_ARGB_INTERRUPT_TIMEOUT);
-    */
 }

 void CMSmallARGBController::SendUpdate()
@@ -227,7 +219,7 @@ void CMSmallARGBController::SendUpdate()
    buffer[CM_SMALL_ARGB_MODE_BYTE]                     = current_mode;
    buffer[CM_SMALL_ARGB_SPEED_BYTE]                    = current_speed;
    buffer[CM_SMALL_ARGB_COLOUR_INDEX_BYTE]             = (bool_random) ? 0x00 : 0x10; //This looks to still be the colour index and controls random colours
-    buffer[CM_SMALL_ARGB_BRIGHTNESS_BYTE]               = 0xFF;
+    buffer[CM_SMALL_ARGB_BRIGHTNESS_BYTE]               = current_brightness;
    buffer[CM_SMALL_ARGB_RED_BYTE]                      = current_red;
    buffer[CM_SMALL_ARGB_GREEN_BYTE]                    = current_green;
    buffer[CM_SMALL_ARGB_BLUE_BYTE]                     = current_blue;
@@ -16,7 +16,7 @@

 #pragma once

-#define CM_SMALL_ARGB_PACKET_SIZE 65
+#define CM_SMALL_ARGB_PACKET_SIZE       65
 #define CM_SMALL_ARGB_INTERRUPT_TIMEOUT 250

 enum
@@ -88,7 +88,7 @@ public:
    bool                GetRandomColours();

    void                SetLedCount(int zone, int led_count);
-    void                SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours);
+    void                SetMode(unsigned char mode, unsigned char speed, unsigned char brightness, RGBColor colour, bool random_colours);
    void                SetLedsDirect(RGBColor * led_colours, unsigned int led_count);
 private:
    std::string         device_name;
@@ -1,25 +1,33 @@
 #include "Detector.h"
+#include "CMMM711Controller.h"
 #include "CMMP750Controller.h"
 #include "CMARGBcontroller.h"
 #include "CMSmallARGBController.h"
+#include "CMRGBController.h"
 #include "CMR6000Controller.h"
 #include "CMMKController.h"
 #include "RGBController.h"
+#include "RGBController_CMMM711Controller.h"
 #include "RGBController_CMMP750Controller.h"
 #include "RGBController_CMARGBController.h"
 #include "RGBController_CMSmallARGBController.h"
+#include "RGBController_CMRGBController.h"
 #include "RGBController_CMR6000Controller.h"
 #include "RGBController_CMMKController.h"
 #include <hidapi/hidapi.h>

 #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
@@ -34,26 +42,20 @@
 *                                                                                          *
 \******************************************************************************************/

-void DetectCoolerMasterMousemats(hid_device_info* info, const std::string&)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        CMMP750Controller* controller                   = new CMMP750Controller(dev, info->path);
-        RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
 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);
@@ -61,18 +63,6 @@ void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
    }
 }

-void DetectCoolerMasterSmallARGB(hid_device_info* info, const std::string&)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        CMSmallARGBController* controller = new CMSmallARGBController(dev, info->path, 0);
-        RGBController_CMSmallARGBController* rgb_controller = new RGBController_CMSmallARGBController(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
 void DetectCoolerMasterGPU(hid_device_info* info, const std::string&)
 {
    hid_device* dev = hid_open_path(info->path);
@@ -98,14 +88,66 @@ void DetectCoolerMasterKeyboards(hid_device_info* info, const std::string&)
    }
 }

-REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 XL",                 DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_XL_PID,                  0xFF00, 1        );
-REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 Medium",             DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_MEDIUM_PID,              0xFF00, 1        );
+void DetectCoolerMasterMouse(hid_device_info* info, const std::string&)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        CMMM711Controller* controller                   = new CMMM711Controller(dev, info->path);
+        RGBController_CMMM711Controller* rgb_controller = new RGBController_CMMM711Controller(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectCoolerMasterMousemats(hid_device_info* info, const std::string&)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        CMMP750Controller* controller                   = new CMMP750Controller(dev, info->path);
+        RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectCoolerMasterRGB(hid_device_info* info, const std::string&)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        CMRGBController* controller = new CMRGBController(dev, info->path);
+        RGBController_CMRGBController* rgb_controller = new RGBController_CMRGBController(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectCoolerMasterSmallARGB(hid_device_info* info, const std::string&)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        CMSmallARGBController* controller = new CMSmallARGBController(dev, info->path, 0);
+        RGBController_CMSmallARGBController* rgb_controller = new RGBController_CMSmallARGBController(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+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);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro S",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_S_PID,          1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master MK570",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_MK750_PID,          1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master SK630",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_SK630_PID,          1,      0xFF00, 1);
 REGISTER_HID_DETECTOR_IPU("Cooler Master SK650",                    DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_SK650_PID,          1,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB",                     DetectCoolerMasterARGB,         COOLERMASTER_VID,   COOLERMASTER_ARGB_PID,         	            0,      0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master Smalll ARGB",              DetectCoolerMasterSmallARGB,    COOLERMASTER_VID,   COOLERMASTER_SMALL_ARGB_PID,   	            0,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB",                     DetectCoolerMasterARGB,         COOLERMASTER_VID,   COOLERMASTER_ARGB_PID,         	        0,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master Small ARGB",               DetectCoolerMasterSmallARGB,    COOLERMASTER_VID,   COOLERMASTER_SMALL_ARGB_PID,   	        0,      0xFF00, 1);
+REGISTER_HID_DETECTOR_IPU("Cooler Master RGB",                      DetectCoolerMasterRGB,          COOLERMASTER_VID,   COOLERMASTER_RGB_PID,                       0,      0xFF00, 1);
 REGISTER_HID_DETECTOR_I  ("Cooler Master Radeon 6000 GPU",          DetectCoolerMasterGPU,          COOLERMASTER_VID,   COOLERMASTER_RADEON_6000_PID,               1                );
@@ -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)
@@ -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);
@@ -0,0 +1,204 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMMM711Controller.cpp                                |
+|                                                                     |
+|  Driver for Coolermaster MM711 Controller                           |
+|                                                                     |
+|  Chris M (Dr_No)          14th Feb 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#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)
+{
+    cmmm711                         = cmmm711_ptr;
+    uint8_t speed                   = cmmm711->GetLedSpeed();
+
+    name                            = cmmm711->GetDeviceName();
+    vendor                          = "Cooler Master";
+    type                            = DEVICE_TYPE_MOUSE;
+    description                     = cmmm711->GetDeviceName();
+    version                         = "1.0";
+    serial                          = cmmm711->GetSerial();
+    location                        = cmmm711->GetLocation();
+
+    mode Custom;
+    Custom.name                     = "Direct";
+    Custom.value                    = CM_MM711_MODE_CUSTOM;
+    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;
+    Custom.color_mode               = MODE_COLORS_PER_LED;
+    modes.push_back(Custom);
+
+    mode Static;
+    Static.name                     = "Static";
+    Static.value                    = CM_MM711_MODE_STATIC;
+    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;
+    Static.colors_min               = 1;
+    Static.colors_max               = 1;
+    Static.colors.resize(Static.colors_max);
+    Static.speed_min                = CM_MM711_SPEED_SLOWEST;
+    Static.speed_max                = CM_MM711_SPEED_FASTEST;
+    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    Static.speed                    = CM_MM711_SPEED_NORMAL;
+    modes.push_back(Static);
+
+    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 | 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;
+    Breathing.colors_min            = 1;
+    Breathing.colors_max            = 1;
+    Breathing.colors.resize(Breathing.colors_max);
+    Breathing.speed_min             = CM_MM711_SPEED_SLOWEST;
+    Breathing.speed_max             = CM_MM711_SPEED_FASTEST;
+    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed                 = CM_MM711_SPEED_NORMAL;
+    modes.push_back(Breathing);
+
+    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 | 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;
+    Spectrum_Cycle.speed_min        = CM_MM711_SPEED_SLOWEST;
+    Spectrum_Cycle.speed_max        = CM_MM711_SPEED_FASTEST;
+    Spectrum_Cycle.color_mode       = MODE_COLORS_NONE;
+    Spectrum_Cycle.speed            = CM_MM711_SPEED_NORMAL;
+    modes.push_back(Spectrum_Cycle);
+
+    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);
+
+    Init_Controller();         //Only processed on first run
+    SetupZones();
+
+    uint8_t temp_mode           = cmmm711->GetMode();
+    for(std::size_t mode_index = 0; mode_index < modes.size(); mode_index++)
+    {
+        if (modes[mode_index].value == temp_mode)
+        {
+            active_mode = mode_index;
+            break;
+        }
+    }
+    if (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        modes[active_mode].colors[0] = ToRGBColor(cmmm711->GetLedRed(),cmmm711->GetLedGreen(),cmmm711->GetLedBlue());
+    }
+    colors[0] = cmmm711->GetWheelColour();
+    colors[1] = cmmm711->GetLogoColour();
+}
+
+RGBController_CMMM711Controller::~RGBController_CMMM711Controller()
+{
+    delete cmmm711;
+}
+
+void RGBController_CMMM711Controller::Init_Controller()
+{
+    zone mouse_zone;
+    mouse_zone.name         = name;
+    mouse_zone.type         = ZONE_TYPE_LINEAR;
+    mouse_zone.leds_min     = 2;
+    mouse_zone.leds_max     = 2;
+    mouse_zone.leds_count   = 2;
+    mouse_zone.matrix_map   = NULL;
+    zones.push_back(mouse_zone);
+
+    led wheel_led;
+    wheel_led.name          = "Scroll Wheel LED";
+    wheel_led.value         = 0;
+    leds.push_back(wheel_led);
+
+    led logo_led;
+    logo_led.name           = "Logo LED";
+    logo_led.value          = 1;
+    leds.push_back(logo_led);
+}
+
+void RGBController_CMMM711Controller::SetupZones()
+{
+    SetupColors();
+}
+
+void RGBController_CMMM711Controller::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_CMMM711Controller::DeviceUpdateLEDs()
+{
+    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*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CMMM711Controller::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CMMM711Controller::SetCustomMode()
+{
+    for(std::size_t mode_index = 0; mode_index < modes.size(); mode_index++)
+    {
+        if (modes[mode_index].value == CM_MM711_MODE_CUSTOM)
+        {
+            active_mode = mode_index;
+            break;
+        }
+    }
+}
+
+void RGBController_CMMM711Controller::DeviceUpdateMode()
+{
+    RGBColor colour = 0;
+
+    if (modes[active_mode].value != CM_MM711_MODE_CUSTOM)
+    {
+        if( modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC )
+        {
+            colour = modes[active_mode].colors[0];
+        }
+
+        cmmm711->SendUpdate(modes[active_mode].value, modes[active_mode].speed, colour, modes[active_mode].brightness);
+    }
+}
+
+void RGBController_CMMM711Controller::DeviceSaveMode()
+{
+    DeviceUpdateMode();
+    cmmm711->SendSavePacket();
+}
@@ -0,0 +1,40 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMMM711Controller.h                                  |
+|                                                                     |
+|  Driver for Coolermaster MM711 Controller                           |
+|                                                                     |
+|  Chris M (Dr_No)          14th Feb 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CMMM711Controller.h"
+#include <vector>
+
+#define CM_MM_ARGB_BRIGHTNESS_MIN           0x00
+#define CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT   0xFF
+#define CM_MM_ARGB_BRIGHTNESS_MAX_SPECTRUM  0x7F
+
+class RGBController_CMMM711Controller : public RGBController
+{
+public:
+    RGBController_CMMM711Controller(CMMM711Controller* cmargb_ptr);
+    ~RGBController_CMMM711Controller();
+
+    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:
+    void        Init_Controller();
+    int         GetDeviceMode();
+
+    CMMM711Controller* cmmm711;
+};
@@ -28,35 +28,41 @@ RGBController_CMR6000Controller::RGBController_CMR6000Controller(CMR6000Controll
    Off.color_mode      = MODE_COLORS_NONE;
    modes.push_back(Off);

-    mode Static;
-    Static.name         = "Static";
-    Static.value        = CM_MR6000_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.colors.resize(1);
-    modes.push_back(Static);
+    mode Direct;
+    Direct.name         = "Direct";
+    Direct.value        = CM_MR6000_MODE_DIRECT;
+    Direct.flags        = MODE_FLAG_HAS_PER_LED_COLOR| MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.color_mode   = MODE_COLORS_PER_LED;
+    Direct.colors_min   = 1;
+    Direct.colors_max   = 1;
+    Direct.colors.resize(1);
+    Direct.brightness_min   = 0x00;
+    Direct.brightness_max   = 0xFF;
+    Direct.brightness       = 0xFF;
+    modes.push_back(Direct);

    mode ColorCycle;
-    ColorCycle.name       = "Color Cycle";
-    ColorCycle.value      = CM_MR6000_MODE_COLOR_CYCLE;
-    ColorCycle.flags      = MODE_FLAG_HAS_SPEED;
-    ColorCycle.speed_min  = MR6000_CYCLE_SPEED_SLOWEST;
-    ColorCycle.speed      = MR6000_CYCLE_SPEED_NORMAL;
-    ColorCycle.speed_max  = MR6000_CYCLE_SPEED_FASTEST;
-    ColorCycle.color_mode = MODE_COLORS_NONE;
-    ColorCycle.speed      = speed;
+    ColorCycle.name             = "Color Cycle";
+    ColorCycle.value            = CM_MR6000_MODE_COLOR_CYCLE;
+    ColorCycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    ColorCycle.speed_min        = MR6000_CYCLE_SPEED_SLOWEST;
+    ColorCycle.speed            = MR6000_CYCLE_SPEED_NORMAL;
+    ColorCycle.speed_max        = MR6000_CYCLE_SPEED_FASTEST;
+    ColorCycle.color_mode       = MODE_COLORS_NONE;
+    ColorCycle.speed            = speed;
+    ColorCycle.brightness_min   = 0x00;
+    ColorCycle.brightness_max   = 0xFF;
+    ColorCycle.brightness       = 0x7F;
    modes.push_back(ColorCycle);

    mode Breathing;
    Breathing.name       = "Breathing";
    Breathing.value      = CM_MR6000_MODE_BREATHE;
-    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
    Breathing.speed_min  = MR6000_BREATHE_SPEED_SLOWEST;
    Breathing.speed      = MR6000_BREATHE_SPEED_NORMAL;
    Breathing.speed_max  = MR6000_BREATHE_SPEED_FASTEST;
-    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
    Breathing.colors_min = 1;
    Breathing.colors_max = 1;
    Breathing.colors.resize(1);
@@ -64,19 +70,7 @@ RGBController_CMR6000Controller::RGBController_CMR6000Controller(CMR6000Controll
    modes.push_back(Breathing);    

    SetupZones();
-    active_mode = cmr6000->GetMode();
-    if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
-    {
-        modes[active_mode].colors[0] = ToRGBColor(cmr6000->GetLedRed(), cmr6000->GetLedGreen(), cmr6000->GetLedBlue());
-    }
-    if (modes[active_mode].flags & MODE_FLAG_HAS_RANDOM_COLOR)
-    {
-        modes[active_mode].color_mode = (cmr6000->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
-    }
-    if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
-    {
-        modes[active_mode].speed = cmr6000->GetLedSpeed();
-    }
+    active_mode = 1;
 }

 RGBController_CMR6000Controller::~RGBController_CMR6000Controller()
@@ -97,6 +91,7 @@ void RGBController_CMR6000Controller::SetupZones()

    led GP_led;
    GP_led.name = "Logo";
+    GP_led.value = 0;
    leds.push_back(GP_led);

    SetupColors();
@@ -116,16 +111,17 @@ void RGBController_CMR6000Controller::DeviceUpdateLEDs()
    unsigned char grn = 0;
    unsigned char blu = 0;

-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
    {
-        red = RGBGetRValue(modes[active_mode].colors[0]);
-        grn = RGBGetGValue(modes[active_mode].colors[0]);
-        blu = RGBGetBValue(modes[active_mode].colors[0]);
+        red = RGBGetRValue(colors[0]);
+        grn = RGBGetGValue(colors[0]);
+        blu = RGBGetBValue(colors[0]);
    }

    unsigned char rnd = (modes[active_mode].color_mode == MODE_COLORS_RANDOM) ? 0xA0 : 0x20;
+    unsigned char bri = (modes[active_mode].flags & MODE_FLAG_HAS_BRIGHTNESS) ? modes[active_mode].brightness : 0xFF;

-    cmr6000->SetMode(modes[active_mode].value, modes[active_mode].speed, red, grn, blu, rnd);
+    cmr6000->SetMode(modes[active_mode].value, modes[active_mode].speed, red, grn, blu, rnd, bri);
 }

 void RGBController_CMR6000Controller::UpdateZoneLEDs(int /*zone*/)
@@ -0,0 +1,274 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMRGBController.cpp                                  |
+|                                                                     |
+|  Driver for Coolermaster RGB USB Controller                         |
+|                                                                     |
+|  Nic W (midgetspy)        13th Apr 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBController_CMRGBController.h"
+
+/*-----------------------------------------------------------------------------------------------------------------------------------------*\
+| This controller has 4 ports, each for a 12v non-addressable LED item.                                                                     |
+|                                                                                                                                           |
+| It supports the following modes:                                                                                                          |
+|   Static: All 4 ports a single color. Has brightness option.                                                                              |
+|   Breathing: All ports a single color, fading in and out. Has brightness and speed option.                                                |
+|   Star: Some weird effect using all 4 ports and a single color. Has brightness and speed option.                                          |
+|   Color Cycle: All ports cycle through the rainbow in unison. Has brightness and speed option.                                            |
+|   Off: All 4 ports off                                                                                                                    |
+|                                                                                                                                           |
+| Plus some "special" modes:                                                                                                                |
+|   Multilayer: Each of the 4 ports can have any of the modes above applied individually                                                    |
+|   Multiple Color/Customize: Each port can be set to its own static color                                                                  |
+|   Mirage: A strobe effect that varies the LED pulse frequency which affects any of the above modes                                        |
+|                                                                                                                                           |
+| Note:                                                                                                                                     |
+|  Multiple Color/Customize is equivalent to Multilayer + Static, but the device supports both separately                                   |
+|  Static is equivalent to Multiple Color/Customize with the same color on each port, but the device supports both separately               |
+|                                                                                                                                           |
+| It can be controlled with 2 different pieces of software: MasterPlus+ or "RGB LED Controller". They appear to use different protocols.    |
+|                                                                                                                                           |
+| RGB LED Controller:                                                                                                                       |
+|   Sets changes temporarily and then applies them or cancels the changes separately                                                        |
+|   Supports all modes above                                                                                                                |
+|   Has 3 brightness increments                                                                                                             |
+|   Has two different colors for the Star effect (Star/Sky)                                                                                 |
+|                                                                                                                                           |
+| MasterPlus+:                                                                                                                              |
+|   Sets changes permanently as soon as you change anything in the UI                                                                       |
+|   Doesn't support Multilayer or Mirage                                                                                                    |
+|   Has 5 brightness increments                                                                                                             |
+|   Single color for Star                                                                                                                   |
+\*-----------------------------------------------------------------------------------------------------------------------------------------*/
+
+RGBController_CMRGBController::RGBController_CMRGBController(CMRGBController *cmrgb_ptr)
+{
+    cmrgb                       = cmrgb_ptr;
+
+    name                        = "Cooler Master RGB Controller";
+    vendor                      = "Cooler Master";
+    type                        = DEVICE_TYPE_LEDSTRIP;
+    description                 = cmrgb->GetDeviceName();
+    version                     = "";
+    serial                      = cmrgb->GetSerial();
+    location                    = cmrgb->GetLocation();
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = CM_RGBC_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(Static.colors_max);
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.brightness_min       = 0x00;
+    Static.brightness_max       = 0xFF;
+    Static.brightness           = 0xFF;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = CM_RGBC_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
+    Breathing.colors.resize(Breathing.colors_max);
+    Breathing.speed_min         = CM_RGBC_SPEED_BREATHING_SLOWEST;
+    Breathing.speed_max         = CM_RGBC_SPEED_BREATHING_FASTEST;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed             = CM_RGBC_SPEED_BREATHING_SLOWEST;
+    Breathing.brightness_min    = 0x00;
+    Breathing.brightness_max    = 0xFF;
+    Breathing.brightness        = 0xFF;
+    modes.push_back(Breathing);
+
+    mode ColorCycle;
+    ColorCycle.name             = "Spectrum Cycle";
+    ColorCycle.value            = CM_RGBC_MODE_COLOR_CYCLE;
+    ColorCycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorCycle.speed_min        = CM_RGBC_SPEED_COLOR_CYCLE_SLOWEST;
+    ColorCycle.speed_max        = CM_RGBC_SPEED_COLOR_CYCLE_FASTEST;
+    ColorCycle.color_mode       = MODE_COLORS_RANDOM;
+    ColorCycle.speed            = CM_RGBC_SPEED_COLOR_CYCLE_SLOWEST;
+    ColorCycle.brightness_min   = 0x00;
+    ColorCycle.brightness_max   = 0xFF;
+    ColorCycle.brightness       = 0xFF;
+    modes.push_back(ColorCycle);
+
+    mode Star;
+    Star.name                   = "Star";
+    Star.value                  = CM_RGBC_MODE_STAR;
+    Star.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Star.colors_min             = 2;
+    Star.colors_max             = 2;
+    Star.colors.resize(Star.colors_max);
+    Star.speed_min              = CM_RGBC_SPEED_STAR_SLOWEST;
+    Star.speed_max              = CM_RGBC_SPEED_STAR_FASTEST;
+    Star.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Star.speed                  = CM_RGBC_SPEED_STAR_SLOWEST;
+    Star.brightness_min         = 0x00;
+    Star.brightness_max         = 0xFF;
+    Star.brightness             = 0xFF;
+    modes.push_back(Star);
+
+    mode Multiple;
+    Multiple.name               = "Custom";
+    Multiple.value              = CM_RGBC_MODE_MULTIPLE;
+    Multiple.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Multiple.colors_min         = 1;
+    Multiple.colors_max         = 1;
+    Multiple.colors.resize(Multiple.colors_max);
+    Multiple.color_mode         = MODE_COLORS_PER_LED;
+    Multiple.speed              = 0;
+    Multiple.brightness_min     = 0x00;
+    Multiple.brightness_max     = 0xFF;
+    Multiple.brightness         = 0xFF;
+    modes.push_back(Multiple);
+
+    mode Off;
+    Off.name                = "Off";
+    Off.value               = CM_RGBC_MODE_OFF;
+    Off.color_mode          = MODE_COLORS_NONE;
+    Off.flags               = 0;
+    modes.push_back(Off);
+
+    SetupZones();
+
+    ReadAllModeConfigsFromDevice();
+}
+
+RGBController_CMRGBController::~RGBController_CMRGBController()
+{
+    delete cmrgb;
+}
+
+void RGBController_CMRGBController::ReadAllModeConfigsFromDevice()
+{
+    int device_mode = cmrgb->GetMode();
+
+    for(std::size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
+    {
+        if(device_mode == modes[mode_idx].value)
+        {
+            active_mode = mode_idx;
+            continue;
+        }
+
+        if(!modes[mode_idx].flags)
+        {
+            continue;
+        }
+
+        cmrgb->ReadModeConfig(modes[mode_idx].value);
+        LoadConfigFromDeviceController(mode_idx);
+    }
+
+    /*---------------------------------------------------------*\
+    | Do the active mode last so the device controller state    |
+    | is left with the active mode's config                     |
+    \*---------------------------------------------------------*/
+    if(active_mode != -1)
+    {
+        cmrgb->ReadModeConfig(modes[active_mode].value);
+        LoadConfigFromDeviceController(active_mode);
+    }
+}
+
+void RGBController_CMRGBController::LoadConfigFromDeviceController(int mode_idx)
+{
+    for(std::size_t color_idx = 0; color_idx < modes[mode_idx].colors.size(); color_idx++)
+    {
+        modes[mode_idx].colors[0] = cmrgb->GetModeColor(color_idx);
+    }
+
+    if(modes[mode_idx].flags & MODE_FLAG_HAS_PER_LED_COLOR)
+    {
+        for (std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+        {
+            SetLED(led_idx, cmrgb->GetPortColor(led_idx));
+        }
+    }
+
+    if(modes[mode_idx].flags & MODE_FLAG_HAS_SPEED)
+    {
+        modes[mode_idx].speed = cmrgb->GetSpeed();
+    }
+
+    if(modes[mode_idx].flags & MODE_FLAG_HAS_BRIGHTNESS)
+    {
+        modes[active_mode].brightness = cmrgb->GetBrightness();
+    }
+}
+
+
+void RGBController_CMRGBController::SetupZones()
+{
+    leds.clear();
+    zones.clear();
+    colors.clear();
+
+    /*-----------------------------------------------------*\
+    | One zone, 4 leds. This might not actually work with   |
+    | the Multilayer mode, but we'll deal with that later   |
+    \*-----------------------------------------------------*/
+    zone* new_zone          = new zone();
+    new_zone->name          = "Controller";
+    new_zone->type          = ZONE_TYPE_SINGLE;
+    new_zone->leds_min      = 1;
+    new_zone->leds_max      = 4;
+    new_zone->leds_count    = 4;
+    new_zone->matrix_map    = NULL;
+
+    for(int i = 1; i <= CM_RGBC_NUM_LEDS; i++)
+    {
+        led*  new_led  = new led();
+        new_led->name  = "LED " + std::to_string(i);
+        leds.push_back(*new_led);
+    }
+
+    zones.push_back(*new_zone);
+    SetupColors();
+}
+
+void RGBController_CMRGBController::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+}
+
+void RGBController_CMRGBController::DeviceUpdateLEDs()
+{
+    for(size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        UpdateZoneLEDs(zone_idx);
+    }
+}
+
+void RGBController_CMRGBController::UpdateZoneLEDs(int zone)
+{
+    cmrgb->SetLedsDirect(zones[zone].colors[0], zones[zone].colors[1], zones[zone].colors[2], zones[zone].colors[3]);
+}
+
+void RGBController_CMRGBController::UpdateSingleLED(int /*led*/)
+{
+}
+
+void RGBController_CMRGBController::SetCustomMode()
+{
+    for(std::size_t mode_idx = 0; mode_idx < modes.size() ; mode_idx++)
+    {
+        if (modes[mode_idx].value == CM_RGBC_MODE_MULTIPLE)
+        {
+            active_mode = mode_idx;
+            break;
+        }
+    }
+}
+
+void RGBController_CMRGBController::DeviceUpdateMode()
+{
+    RGBColor color_1 = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
+    RGBColor color_2 = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && modes[active_mode].colors.size() > 1) ? modes[active_mode].colors[1] : 0;
+
+    cmrgb->SetMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, color_1, color_2);
+}
@@ -0,0 +1,35 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMRGBController.h                                    |
+|                                                                     |
+|  Driver for Coolermaster RGB USB Controller                         |
+|                                                                     |
+|  Nic W (midgetspy)        13th Apr 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CMRGBController.h"
+#include <vector>
+
+class RGBController_CMRGBController : public RGBController
+{
+public:
+    RGBController_CMRGBController(CMRGBController* cmrgb_ptr);
+    ~RGBController_CMRGBController();
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    CMRGBController*    cmrgb;
+    void                LoadConfigFromDeviceController(int device_mode);
+    void                ReadAllModeConfigsFromDevice();
+};
@@ -11,106 +11,127 @@

 RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmallARGBController *cmargb_ptr)
 {
-    cmargb                  = cmargb_ptr;
-    unsigned char speed     = cmargb->GetLedSpeed();
+    cmargb                      = cmargb_ptr;
+    unsigned char speed         = cmargb->GetLedSpeed();

-    name                    = small_argb_header_data[cmargb->GetZoneIndex()].name;
-    vendor                  = "Cooler Master";
-    type                    = DEVICE_TYPE_LEDSTRIP;
-    description             = cmargb->GetDeviceName();
-    version                 = "1.0";
-    serial                  = cmargb->GetSerial();
-    location                = cmargb->GetLocation();
+    name                        = small_argb_header_data[cmargb->GetZoneIndex()].name;
+    vendor                      = "Cooler Master";
+    type                        = DEVICE_TYPE_LEDSTRIP;
+    description                 = cmargb->GetDeviceName();
+    version                     = "2.0 for FW0012";
+    serial                      = cmargb->GetSerial();
+    location                    = cmargb->GetLocation();

    mode Off;
-    Off.name                = "Turn Off";
-    Off.value               = CM_SMALL_ARGB_MODE_OFF;
-    Off.color_mode          = MODE_COLORS_NONE;
+    Off.name                    = "Turn Off";
+    Off.value                   = CM_SMALL_ARGB_MODE_OFF;
+    Off.color_mode              = MODE_COLORS_NONE;
    modes.push_back(Off);

    mode Reload;
-    Reload.name             = "Reload";
-    Reload.value            = CM_SMALL_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_SMALL_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_SMALL_ARGB_SPEED_SLOWEST;
-    Reload.speed_max        = CM_SMALL_ARGB_SPEED_FASTEST;
-    Reload.color_mode       = MODE_COLORS_RANDOM;
-    Reload.speed            = speed;
+    Reload.brightness_min       = 0;
+    Reload.brightness_max       = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Reload.brightness           = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Reload.speed_min            = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Reload.speed_max            = CM_SMALL_ARGB_SPEED_FASTEST;
+    Reload.color_mode           = MODE_COLORS_RANDOM;
+    Reload.speed                = speed;
    modes.push_back(Reload);

    mode Recoil;
-    Recoil.name             = "Recoil";
-    Recoil.value            = CM_SMALL_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_SMALL_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_SMALL_ARGB_SPEED_SLOWEST;
-    Recoil.speed_max        = CM_SMALL_ARGB_SPEED_FASTEST;
-    Recoil.color_mode       = MODE_COLORS_RANDOM;
-    Recoil.speed            = speed;
+    Recoil.brightness_min       = 0;
+    Recoil.brightness_max       = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Recoil.brightness           = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Recoil.speed_min            = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Recoil.speed_max            = CM_SMALL_ARGB_SPEED_FASTEST;
+    Recoil.color_mode           = MODE_COLORS_RANDOM;
+    Recoil.speed                = speed;
    modes.push_back(Recoil);

    mode Breathing;
-    Breathing.name          = "Breathing";
-    Breathing.value         = CM_SMALL_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_SMALL_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_SMALL_ARGB_SPEED_SLOWEST;
-    Breathing.speed_max     = CM_SMALL_ARGB_SPEED_FASTEST;
-    Breathing.color_mode    = MODE_COLORS_RANDOM;
-    Breathing.speed         = speed;
+    Breathing.brightness_min    = 0;
+    Breathing.brightness_max    = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Breathing.brightness        = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Breathing.speed_min         = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Breathing.speed_max         = CM_SMALL_ARGB_SPEED_FASTEST;
+    Breathing.color_mode        = MODE_COLORS_RANDOM;
+    Breathing.speed             = speed;
    modes.push_back(Breathing);

    mode Refill;
-    Refill.name             = "Refill";
-    Refill.value            = CM_SMALL_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_SMALL_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_SMALL_ARGB_SPEED_SLOWEST;
-    Refill.speed_max        = CM_SMALL_ARGB_SPEED_FASTEST;
-    Refill.color_mode       = MODE_COLORS_RANDOM;
-    Refill.speed            = speed;
+    Refill.brightness_min       = 0;
+    Refill.brightness_max       = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Refill.brightness           = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Refill.speed_min            = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Refill.speed_max            = CM_SMALL_ARGB_SPEED_FASTEST;
+    Refill.color_mode           = MODE_COLORS_RANDOM;
+    Refill.speed                = speed;
    modes.push_back(Refill);

    mode Demo;
-    Demo.name               = "Demo";
-    Demo.value              = CM_SMALL_ARGB_MODE_DEMO;
-    Demo.flags              = MODE_FLAG_HAS_SPEED;
-    Demo.speed_min          = CM_SMALL_ARGB_SPEED_SLOWEST;
-    Demo.speed_max          = CM_SMALL_ARGB_SPEED_FASTEST;
-    Demo.color_mode         = MODE_COLORS_NONE;
-    Demo.speed              = speed;
+    Demo.name                   = "Demo";
+    Demo.value                  = CM_SMALL_ARGB_MODE_DEMO;
+    Demo.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Demo.brightness_min         = 0;
+    Demo.brightness_max         = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Demo.brightness             = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Demo.speed_min              = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Demo.speed_max              = CM_SMALL_ARGB_SPEED_FASTEST;
+    Demo.color_mode             = MODE_COLORS_NONE;
+    Demo.speed                  = speed;
    modes.push_back(Demo);

    mode Spectrum;
-    Spectrum.name           = "Spectrum";
-    Spectrum.value          = CM_SMALL_ARGB_MODE_SPECTRUM;
-    Spectrum.flags          = MODE_FLAG_HAS_SPEED;
-    Spectrum.speed_min      = CM_SMALL_ARGB_SPEED_SLOWEST;
-    Spectrum.speed_max      = CM_SMALL_ARGB_SPEED_FASTEST;
-    Spectrum.color_mode     = MODE_COLORS_NONE;
-    Spectrum.speed          = speed;
+    Spectrum.name               = "Spectrum";
+    Spectrum.value              = CM_SMALL_ARGB_MODE_SPECTRUM;
+    Spectrum.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Spectrum.brightness_min     = 0;
+    Spectrum.brightness_max     = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Spectrum.brightness         = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Spectrum.speed_min          = CM_SMALL_ARGB_SPEED_SLOWEST;
+    Spectrum.speed_max          = CM_SMALL_ARGB_SPEED_FASTEST;
+    Spectrum.color_mode         = MODE_COLORS_NONE;
+    Spectrum.speed              = speed;
    modes.push_back(Spectrum);

    mode Direct;
-    Direct.name             = "Direct";
-    Direct.value            = CM_SMALL_ARGB_MODE_DIRECT;
-    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode       = MODE_COLORS_PER_LED;
+    Direct.name                 = "Direct";
+    Direct.value                = CM_SMALL_ARGB_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.brightness_min       = 0;
+    Direct.brightness_max       = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Direct.brightness           = CM_SMALL_ARGB_BRIGHTNESS_MAX;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
    modes.push_back(Direct);

    mode PassThru;
-    PassThru.name           = "Pass Thru";
-    PassThru.value          = CM_SMALL_ARGB_MODE_PASSTHRU;
-    PassThru.color_mode     = MODE_COLORS_NONE;
+    PassThru.name               = "Pass Thru";
+    PassThru.value              = CM_SMALL_ARGB_MODE_PASSTHRU;
+    PassThru.color_mode         = MODE_COLORS_NONE;
    modes.push_back(PassThru);

    Init_Controller();         //Only processed on first run
@@ -224,17 +245,17 @@ void RGBController_CMSmallARGBController::DeviceUpdateLEDs()
    }
 }

-void RGBController_CMSmallARGBController::UpdateZoneLEDs(int /*zone*/)
+void RGBController_CMSmallARGBController::UpdateZoneLEDs(int zone)
 {
-    //bool random_colours     = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-
-    //cmargb->SetLedsDirect(zones[zone].colors, random_colours);
+    if(serial >= CM_SMALL_ARGB_FW0012)
+    {
+        cmargb->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
+    }
 }

-void RGBController_CMSmallARGBController::UpdateSingleLED(int /*led*/)
+void RGBController_CMSmallARGBController::UpdateSingleLED(int led)
 {
-    //cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed );
-    //cmargb->SetLedsDirect( zones[0].colors, zones[0].leds_count );
+    UpdateZoneLEDs(led);
 }

 void RGBController_CMSmallARGBController::SetCustomMode()
@@ -247,5 +268,5 @@ void RGBController_CMSmallARGBController::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);
 }
@@ -12,8 +12,10 @@
 #include "CMSmallARGBController.h"
 #include <vector>

-#define CM_SMALL_ARGB_MIN_LEDS 4
-#define CM_SMALL_ARGB_MAX_LEDS 48
+#define CM_SMALL_ARGB_MIN_LEDS          4
+#define CM_SMALL_ARGB_MAX_LEDS          48
+#define CM_SMALL_ARGB_BRIGHTNESS_MAX    0xFF
+#define CM_SMALL_ARGB_FW0012            "A202104052336"

 class RGBController_CMSmallARGBController : public RGBController
 {
@@ -77,6 +77,14 @@ std::string CorsairLightingNodeController::GetSerialString()
    return(return_string);
 }

+void CorsairLightingNodeController::SetBrightness(unsigned char brightness)
+{
+    for(unsigned int channel = 0; channel < CORSAIR_LIGHTING_NODE_NUM_CHANNELS; channel++)
+    {
+        SendBrightness(channel, brightness);
+    }
+}
+
 void CorsairLightingNodeController::SetChannelEffect(unsigned char channel,
                                                unsigned char num_leds,
                                                unsigned char mode,
@@ -257,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()
@@ -285,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
@@ -448,12 +456,43 @@ 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()
+void CorsairLightingNodeController::SendBrightness
+    (
+    unsigned char   channel,
+    unsigned char   brightness
+    )
 {
+    unsigned char   usb_buf[65];

+    /*-----------------------------------------------------*\
+    | Brightness goes from 0-100                            |
+    \*-----------------------------------------------------*/
+    if(brightness > 100)
+    {
+        brightness = 100;
+    }
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Port State packet                              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_BRIGHTNESS;
+    usb_buf[0x02]   = channel;
+    usb_buf[0x03]   = brightness;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 17);
 }

 void CorsairLightingNodeController::SendLEDCount()
@@ -88,6 +88,8 @@ public:

    unsigned int    GetStripsOnChannel(unsigned int channel);

+    void            SetBrightness(unsigned char brightness);
+    
    void            SetChannelEffect(unsigned char channel,
                                     unsigned char num_leds,
                                     unsigned char mode,
@@ -171,7 +173,11 @@ private:
                        unsigned char   state
                        );

-    void            SendBrightness();
+    void            SendBrightness
+                        (
+                        unsigned char   channel,
+                        unsigned char   brightness
+                        );

    void            SendLEDCount();

@@ -23,145 +23,178 @@ RGBController_CorsairLightingNode::RGBController_CorsairLightingNode(CorsairLigh
    serial      = corsair->GetSerialString();

    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0xFFFF;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
+    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 RainbowWave;
-    RainbowWave.name       = "Rainbow Wave";
-    RainbowWave.value      = CORSAIR_LIGHTING_NODE_MODE_RAINBOW_WAVE;
-    RainbowWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    RainbowWave.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    RainbowWave.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    RainbowWave.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    RainbowWave.direction  = MODE_DIRECTION_RIGHT;
-    RainbowWave.color_mode = MODE_COLORS_NONE;
+    RainbowWave.name           = "Rainbow Wave";
+    RainbowWave.value          = CORSAIR_LIGHTING_NODE_MODE_RAINBOW_WAVE;
+    RainbowWave.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    RainbowWave.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    RainbowWave.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    RainbowWave.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    RainbowWave.direction      = MODE_DIRECTION_RIGHT;
+    RainbowWave.color_mode     = MODE_COLORS_NONE;
+    RainbowWave.brightness_min = 0;
+    RainbowWave.brightness_max = 100;
+    RainbowWave.brightness     = 100;
    modes.push_back(RainbowWave);

    mode ColorShift;
-    ColorShift.name       = "Color Shift";
-    ColorShift.value      = CORSAIR_LIGHTING_NODE_MODE_COLOR_SHIFT;
-    ColorShift.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    ColorShift.colors_min = 2;
-    ColorShift.colors_max = 2;
-    ColorShift.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    ColorShift.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    ColorShift.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    ColorShift.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorShift.name           = "Color Shift";
+    ColorShift.value          = CORSAIR_LIGHTING_NODE_MODE_COLOR_SHIFT;
+    ColorShift.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    ColorShift.colors_min     = 2;
+    ColorShift.colors_max     = 2;
+    ColorShift.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    ColorShift.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    ColorShift.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    ColorShift.color_mode     = MODE_COLORS_MODE_SPECIFIC;
    ColorShift.colors.resize(2);
+    ColorShift.brightness_min = 0;
+    ColorShift.brightness_max = 100;
+    ColorShift.brightness     = 100;
    modes.push_back(ColorShift);

    mode ColorPulse;
-    ColorPulse.name       = "Color Pulse";
-    ColorPulse.value      = CORSAIR_LIGHTING_NODE_MODE_COLOR_PULSE;
-    ColorPulse.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    ColorPulse.colors_min = 2;
-    ColorPulse.colors_max = 2;
-    ColorPulse.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    ColorPulse.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    ColorPulse.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    ColorPulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorPulse.name           = "Color Pulse";
+    ColorPulse.value          = CORSAIR_LIGHTING_NODE_MODE_COLOR_PULSE;
+    ColorPulse.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    ColorPulse.colors_min     = 2;
+    ColorPulse.colors_max     = 2;
+    ColorPulse.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    ColorPulse.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    ColorPulse.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    ColorPulse.color_mode     = MODE_COLORS_MODE_SPECIFIC;
    ColorPulse.colors.resize(2);
+    ColorPulse.brightness_min = 0;
+    ColorPulse.brightness_max = 100;
+    ColorPulse.brightness     = 100;
    modes.push_back(ColorPulse);

    mode ColorWave;
-    ColorWave.name       = "Color Wave";
-    ColorWave.value      = CORSAIR_LIGHTING_NODE_MODE_COLOR_WAVE;
-    ColorWave.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    ColorWave.colors_min = 2;
-    ColorWave.colors_max = 2;
-    ColorWave.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    ColorWave.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    ColorWave.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    ColorWave.direction  = MODE_DIRECTION_RIGHT;
-    ColorWave.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorWave.name           = "Color Wave";
+    ColorWave.value          = CORSAIR_LIGHTING_NODE_MODE_COLOR_WAVE;
+    ColorWave.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    ColorWave.colors_min     = 2;
+    ColorWave.colors_max     = 2;
+    ColorWave.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    ColorWave.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    ColorWave.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    ColorWave.direction      = MODE_DIRECTION_RIGHT;
+    ColorWave.color_mode     = MODE_COLORS_MODE_SPECIFIC;
    ColorWave.colors.resize(2);
+    ColorWave.brightness_min = 0;
+    ColorWave.brightness_max = 100;
+    ColorWave.brightness     = 100;
    modes.push_back(ColorWave);

    mode Static;
-    Static.name       = "Static";
-    Static.value      = CORSAIR_LIGHTING_NODE_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.name           = "Static";
+    Static.value          = CORSAIR_LIGHTING_NODE_MODE_STATIC;
+    Static.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Static.colors_min     = 1;
+    Static.colors_max     = 1;
+    Static.color_mode     = MODE_COLORS_MODE_SPECIFIC;
    Static.colors.resize(1);
+    Static.brightness_min = 0;
+    Static.brightness_max = 100;
+    Static.brightness     = 100;
    modes.push_back(Static);

    mode Temperature;
-    Temperature.name       = "Temperature";
-    Temperature.value      = CORSAIR_LIGHTING_NODE_MODE_TEMPERATURE;
-    Temperature.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Temperature.colors_min = 3;
-    Temperature.colors_max = 3;
-    Temperature.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Temperature.name           = "Temperature";
+    Temperature.value          = CORSAIR_LIGHTING_NODE_MODE_TEMPERATURE;
+    Temperature.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Temperature.colors_min     = 3;
+    Temperature.colors_max     = 3;
+    Temperature.color_mode     = MODE_COLORS_MODE_SPECIFIC;
    Temperature.colors.resize(3);
+    Temperature.brightness_min = 0;
+    Temperature.brightness_max = 100;
+    Temperature.brightness     = 100;
    modes.push_back(Temperature);

    mode Visor;
-    Visor.name       = "Visor";
-    Visor.value      = CORSAIR_LIGHTING_NODE_MODE_VISOR;
-    Visor.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Visor.colors_min = 2;
-    Visor.colors_max = 2;
-    Visor.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    Visor.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    Visor.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    Visor.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Visor.name           = "Visor";
+    Visor.value          = CORSAIR_LIGHTING_NODE_MODE_VISOR;
+    Visor.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Visor.colors_min     = 2;
+    Visor.colors_max     = 2;
+    Visor.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    Visor.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    Visor.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    Visor.color_mode     = MODE_COLORS_MODE_SPECIFIC;
    Visor.colors.resize(2);
+    Visor.brightness_min = 0;
+    Visor.brightness_max = 100;
+    Visor.brightness     = 100;
    modes.push_back(Visor);

    mode Marquee;
-    Marquee.name       = "Marquee";
-    Marquee.value      = CORSAIR_LIGHTING_NODE_MODE_MARQUEE;
-    Marquee.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Marquee.colors_min = 1;
-    Marquee.colors_max = 1;
-    Marquee.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    Marquee.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    Marquee.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    Marquee.direction  = MODE_DIRECTION_RIGHT;
-    Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Marquee.name           = "Marquee";
+    Marquee.value          = CORSAIR_LIGHTING_NODE_MODE_MARQUEE;
+    Marquee.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Marquee.colors_min     = 1;
+    Marquee.colors_max     = 1;
+    Marquee.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    Marquee.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    Marquee.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    Marquee.direction      = MODE_DIRECTION_RIGHT;
+    Marquee.color_mode     = MODE_COLORS_MODE_SPECIFIC;
    Marquee.colors.resize(1);
+    Marquee.brightness_min = 0;
+    Marquee.brightness_max = 100;
+    Marquee.brightness     = 100;
    modes.push_back(Marquee);

    mode Blink;
-    Blink.name       = "Blink";
-    Blink.value      = CORSAIR_LIGHTING_NODE_MODE_BLINK;
-    Blink.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Blink.colors_min = 2;
-    Blink.colors_max = 2;
-    Blink.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    Blink.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    Blink.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    Blink.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Blink.name           = "Blink";
+    Blink.value          = CORSAIR_LIGHTING_NODE_MODE_BLINK;
+    Blink.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Blink.colors_min     = 2;
+    Blink.colors_max     = 2;
+    Blink.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    Blink.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    Blink.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    Blink.color_mode     = MODE_COLORS_MODE_SPECIFIC;
    Blink.colors.resize(2);
+    Blink.brightness_min = 0;
+    Blink.brightness_max = 100;
+    Blink.brightness     = 100;
    modes.push_back(Blink);

    mode Sequential;
-    Sequential.name       = "Sequential";
-    Sequential.value      = CORSAIR_LIGHTING_NODE_MODE_SEQUENTIAL;
-    Sequential.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-    Sequential.colors_min = 1;
-    Sequential.colors_max = 1;
-    Sequential.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    Sequential.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    Sequential.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    Sequential.direction  = MODE_DIRECTION_RIGHT;
-    Sequential.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Sequential.name           = "Sequential";
+    Sequential.value          = CORSAIR_LIGHTING_NODE_MODE_SEQUENTIAL;
+    Sequential.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Sequential.colors_min     = 1;
+    Sequential.colors_max     = 1;
+    Sequential.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    Sequential.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    Sequential.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    Sequential.direction      = MODE_DIRECTION_RIGHT;
+    Sequential.color_mode     = MODE_COLORS_MODE_SPECIFIC;
    Sequential.colors.resize(1);
+    Sequential.brightness_min = 0;
+    Sequential.brightness_max = 100;
+    Sequential.brightness     = 100;
    modes.push_back(Sequential);

    mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = CORSAIR_LIGHTING_NODE_MODE_RAINBOW;
-    Rainbow.flags      = MODE_FLAG_HAS_SPEED;
-    Rainbow.speed_min  = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
-    Rainbow.speed_max  = CORSAIR_LIGHTING_NODE_SPEED_FAST;
-    Rainbow.speed      = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
-    Rainbow.color_mode = MODE_COLORS_NONE;
+    Rainbow.name           = "Rainbow";
+    Rainbow.value          = CORSAIR_LIGHTING_NODE_MODE_RAINBOW;
+    Rainbow.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
+    Rainbow.speed_min      = CORSAIR_LIGHTING_NODE_SPEED_SLOW;
+    Rainbow.speed_max      = CORSAIR_LIGHTING_NODE_SPEED_FAST;
+    Rainbow.speed          = CORSAIR_LIGHTING_NODE_SPEED_MEDIUM;
+    Rainbow.color_mode     = MODE_COLORS_NONE;
+    Rainbow.brightness_min = 0;
+    Rainbow.brightness_max = 100;
+    Rainbow.brightness     = 100;
    modes.push_back(Rainbow);

    SetupZones();
@@ -324,4 +357,13 @@ void RGBController_CorsairLightingNode::DeviceUpdateMode()
                                      mode_colors[8]);
        }
    }
+
+    if(modes[active_mode].flags & MODE_FLAG_HAS_BRIGHTNESS)
+    {
+        corsair->SetBrightness(modes[active_mode].brightness);
+    }
+    else
+    {
+        corsair->SetBrightness(100);
+    }
 }
@@ -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);
+}
@@ -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
@@ -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;
                }
@@ -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
@@ -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);
@@ -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);
+    }
+}
@@ -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
@@ -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];
@@ -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                                     |
    \*---------------------------------------------------------*/
@@ -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);
-}
+}
@@ -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;

@@ -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);
            }
        }
    }
--- a/Show More
+++ b/Show More