Add ROG Strix Scope TKL to Aura Keyboard detector

Amended for code style by Adam Honse <[email protected]>

.gitlab-ci.yml

@@ -16,6 +16,7 @@
   
 stages:
   - build
+  - test
 
 before_script:
  - echo "started by ${GITLAB_USER_NAME}"
@@ -23,21 +24,22 @@ before_script:
 #reusable templates
 .ccache_init: &ccache_init
   before_script:
-    - apt update
-    - apt install -y build-essential qtcreator qt5-default libusb-1.0-0-dev libhidapi-dev pkgconf wget git
+    - export QT_SELECT=qt5
+    - export APPIMAGE_EXTRACT_AND_RUN=1
 
 #-----------------------------------------------------------------------#
 # Linux (AppImage) 32-bit Build Target                                  #
 #-----------------------------------------------------------------------#
-build_linux_32:
+"Linux 32 AppImage":
   <<: *ccache_init
-  image: i386/ubuntu:bionic
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
   stage: build
   script:
   - export $(dpkg-architecture)
   - ./scripts/build-appimage.sh
   
   artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_32_${CI_COMMIT_SHORT_SHA}"
     paths:
     - OpenRGB-i386.AppImage
     - 60-openrgb.rules
@@ -47,15 +49,16 @@ build_linux_32:
 #-----------------------------------------------------------------------#
 # Linux (AppImage) 64-bit Build Target                                  #
 #-----------------------------------------------------------------------#
-build_linux_64:
+"Linux 64 AppImage":
   <<: *ccache_init
-  image: ubuntu:bionic
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
   stage: build
   script:
   - export $(dpkg-architecture)
   - ./scripts/build-appimage.sh
   
   artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_64_${CI_COMMIT_SHORT_SHA}"
     paths:
     - OpenRGB-x86_64.AppImage
     - 60-openrgb.rules
@@ -65,18 +68,18 @@ build_linux_64:
 #-----------------------------------------------------------------------#
 # Linux (.deb) 32-bit Build Target                                      #
 #-----------------------------------------------------------------------#
-build_linux_deb32:
+"Linux 32 deb":
   <<: *ccache_init
-  image: i386/ubuntu:bionic
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
   stage: build
   script:
-  - apt install -y debhelper
   - dpkg-architecture -l
   - dpkg-buildpackage --target-arch i386 -us -B
-  - rm -v ../openrgb-dbgsym*.ddeb
+  - 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:
@@ -86,28 +89,287 @@ build_linux_deb32:
 #-----------------------------------------------------------------------#
 # Linux (.deb) 64-bit Build Target                                      #
 #-----------------------------------------------------------------------#
-build_linux_deb64:
+"Linux 64 deb":
   <<: *ccache_init
-  image: ubuntu:bionic
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
   stage: build
   script:
-  - apt install -y debhelper
   - dpkg-architecture -l
   - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.ddeb
+  - 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                                      #
+#-----------------------------------------------------------------------#
+"Linux 64 rpm":
+  image: fedora:34
+  stage: build
+  script:
+  - dnf install rpmdevtools dnf-plugins-core -y 
+  - rpmdev-setuptree 
+  - ls /root/
+  - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
+  - cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
+  - cd /root/rpmbuild/SOURCES
+  - tar -cf OpenRGB.tar.gz OpenRGB/
+  - cd ..
+  - dnf builddep SPECS/OpenRGB.spec -y
+  - rpmbuild -ba SPECS/OpenRGB.spec
+  - cd RPMS/x86_64/
+  - mv openrgb*.rpm ${CI_PROJECT_DIR}/
+  - cd ${CI_PROJECT_DIR}
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_64_rpm_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.rpm
+    expire_in: 30 days
+  
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Bullseye 32-bit Build Target                      #
+#-----------------------------------------------------------------------#
+"Linux 32 deb Bullseye":
+  <<: *ccache_init
+  image: i386/debian:bullseye
+  stage: build
+  script:
+  - apt update
+  - apt install -y build-essential qtcreator qtbase5-dev libusb-1.0-0-dev libhidapi-dev libmbedtls-dev pkgconf wget git file debhelper
+  - dpkg-architecture -l
+  - dpkg-buildpackage --target-arch i386 -us -B
+  - rm -v ../openrgb-dbgsym*.deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.deb
+    expire_in: 30 days
+
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Bullseye 64-bit Build Target                      #
+#-----------------------------------------------------------------------#
+"Linux 64 deb Bullseye":
+  <<: *ccache_init
+  image: debian:bullseye
+  stage: build
+  script:
+  - apt update
+  - apt install -y build-essential qtcreator qtbase5-dev libusb-1.0-0-dev libhidapi-dev libmbedtls-dev pkgconf wget git file debhelper
+  - dpkg-architecture -l
+  - dpkg-buildpackage -us -B
+  - rm -v ../openrgb-dbgsym*.deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.deb
+    expire_in: 30 days
+
+#-----------------------------------------------------------------------#
+# Debian 32 Buster test                                                 #
+#-----------------------------------------------------------------------#
+"Debian 32 Buster":
+  image: i386/debian:buster
+  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 32 Bullseye test                                               #
+#-----------------------------------------------------------------------#
+"Debian 32 Bullseye":
+  image: i386/debian:bullseye
+  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"
+
+# #-----------------------------------------------------------------------#
+# # 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"
+
+#-----------------------------------------------------------------------#
+# Debian 64 Bullseye test                                               #
+#-----------------------------------------------------------------------#
+"Debian 64 Bullseye":
+  image: debian:bullseye
+  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"
+
+#-----------------------------------------------------------------------#
+# Fedora 64 v34 test                                                    #
+#-----------------------------------------------------------------------#
+"Fedora 64 v34":
+  image: fedora:34
+  stage: test
+  script:
+  - yum -y localinstall ./openrgb*64.rpm
+  - openrgb --version
+  - openrgb -l
+  - yum -y remove openrgb
+  dependencies:
+  - "Linux 64 rpm"
+  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                                         #
 #-----------------------------------------------------------------------#
-build_windows_32:
+"Windows 32":
   extends:
   - .shared_windows_runners
   stage: build
@@ -160,26 +422,23 @@ build_windows_32:
   - ..\_qt\5.15.0\msvc2019\bin\windeployqt --no-angle --no-translations --no-opengl-sw --no-system-d3d-compiler --no-compiler-runtime --no-webkit2 .\release\
   - _fold_final_
   
-  - _fold_start_ 'compressing the release folder so that we can upload it as artifact'
-  - mv release 'OpenRGB Windows 32-bit'
-  - ${datetime} = Get-Date ([datetime]::UtcNow) -Format "yyyy-MM-ddTHH-mm-ss"
-  - ${revision} = ((git rev-parse --short HEAD) | Out-String).Trim()
-  - ${rversion} = (((Get-Content '..\OpenRGB.pro' | Select-String -Pattern "VERSION     =") | Out-String).Trim().Split("="))[1].Trim()
-  - 7z a -mx9 -r -y "OpenRGB_${rversion}_32_${revision}_nightly_${datetime}.7z" 'OpenRGB Windows 32-bit'
+  - _fold_start_ 'Moving results for upload'
+  - mv release ../'OpenRGB Windows 32-bit'
   - _fold_final_
 #  cache:
 #    key: same-key
 #    paths:
 #    - C:\vcpkg\installed\
   artifacts:
+    name: "${CI_PROJECT_NAME}_Windows_32_${CI_COMMIT_SHORT_SHA}"
     paths:
-    - _build/*.7z
+    - 'OpenRGB Windows 32-bit'
     expire_in: 30 days
 
 #-----------------------------------------------------------------------#
 # Windows (64-bit) Build Target                                         #
 #-----------------------------------------------------------------------#
-build_windows_64:
+"Windows 64":
   extends:
   - .shared_windows_runners
   stage: build
@@ -232,26 +491,23 @@ build_windows_64:
   - ..\_qt\5.15.0\msvc2019_64\bin\windeployqt --no-angle --no-translations --no-opengl-sw --no-system-d3d-compiler --no-compiler-runtime --no-webkit2 .\release\
   - _fold_final_
   
-  - _fold_start_ 'compressing the release folder so that we can upload it as artifact'
-  - mv release 'OpenRGB Windows 64-bit'
-  - ${datetime} = Get-Date ([datetime]::UtcNow) -Format "yyyy-MM-ddTHH-mm-ss"
-  - ${revision} = ((git rev-parse --short HEAD) | Out-String).Trim()
-  - ${rversion} = (((Get-Content '..\OpenRGB.pro' | Select-String -Pattern "VERSION     =") | Out-String).Trim().Split("="))[1].Trim()
-  - 7z a -mx9 -r -y "OpenRGB_${rversion}_64_${revision}_nightly_${datetime}.7z" 'OpenRGB Windows 64-bit'
+  - _fold_start_ 'Moving results for upload'
+  - mv release ../'OpenRGB Windows 64-bit'
   - _fold_final_
 #  cache:
 #    key: same-key
 #    paths:
 #    - C:\vcpkg\installed\
   artifacts:
+    name: "${CI_PROJECT_NAME}_Windows_64_${CI_COMMIT_SHORT_SHA}"
     paths:
-    - _build/*.7z
+    - 'OpenRGB Windows 64-bit'
     expire_in: 30 days
 
 #-----------------------------------------------------------------------#
 # MacOS Build Target                                                    #
 #-----------------------------------------------------------------------#
-build_macos_arm64:
+"MacOS ARM64":
   tags:
   - macos
   stage: build
@@ -262,6 +518,7 @@ build_macos_arm64:
   - macdeployqt OpenRGB.app -codesign=OpenRGB
 
   artifacts:
+    name: "${CI_PROJECT_NAME}_MacOS_ARM64_${CI_COMMIT_SHORT_SHA}"
     paths:
     - OpenRGB.app
     expire_in: 30 days
@@ -272,7 +529,7 @@ build_macos_arm64:
   - if: '$BUILD_MACOS =~ /.+/'
     when: on_success
 
-build_macos_intel:
+"MacOS Intel":
   tags:
   - macos
   stage: build
@@ -283,6 +540,7 @@ build_macos_intel:
   - arch -x86_64 macdeployqt OpenRGB.app -codesign=OpenRGB
 
   artifacts:
+    name: "${CI_PROJECT_NAME}_MacOS_Intel_${CI_COMMIT_SHORT_SHA}"
     paths:
     - OpenRGB.app
     expire_in: 30 days
@@ -291,4 +549,4 @@ build_macos_intel:
   - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
     when: on_success
   - if: '$BUILD_MACOS =~ /.+/'
-    when: on_success
+    when: on_success

60-openrgb.rules

@@ -53,6 +53,18 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1872", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1889", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a3", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18f3", TAG+="uaccess"
+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"
 
 #---------------------------------------------------------------#
 #  ASUS TUF Laptops (faustus)                                   #
@@ -70,8 +82,29 @@ ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /s
 #                                                               #
 #  Mousemats:                                                   #
 #       Cooler Master MP750                                     #
+#  Controllers:                                                 #
+#       ARGB Device                                             #
+#       Small ARGB Device                                       #
+#  Graphics Cards:                                              #
+#       Radeon RX6000 Series Reference Cards                    #
+#  Keyboards:                                                   #
+#       Masterkeys Pro L                                        #
+#       Masterkeys Pro L White                                  #
+#       Masterkeys Pro S                                        #
+#       Masterkeys MK750                                        #
+#       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"
 
 #---------------------------------------------------------------#
 #  Corsair Hydro Series Devices                                 #
@@ -84,6 +117,23 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c15", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c13", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c12", TAG+="uaccess"
 
+#---------------------------------------------------------------#
+#  Corsair Hydro Platinum Series Devices                        #
+#                                                               #
+#       Corsair H100i Platinum RGB                              #
+#       Corsair H100i Platinum SE RGB                           #
+#       Corsair H115i Platinum RGB                              #
+#       Corsair H100i Pro XT RGB                                #
+#       Corsair H115i Pro XT RGB                                #
+#       Corsair H150i Pro XT RGB                                #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c18", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c19", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c17", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c20", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c21", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c22", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  Corsair Lighting Node Devices                                #
 #                                                               #
@@ -101,7 +151,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c10", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c1e", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1d00", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1d04", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0a32", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c23", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  Corsair Peripheral Devices                                   #
@@ -126,6 +176,12 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0a32", TAG+="uacces
 #  Mice:                                                        #
 #       Corsair M65 Pro                                         #
 #       Corsair M65 RGB Elite                                   #
+#       Corsair Glaive RGB                                      #
+#       Corsair Glaive RGB Pro                                  #
+#       Corsair Harpoon RGB                                     #
+#       Corsair Harpoon RGB Pro                                 #
+#       Corsair Scimitar Pro RGB                                #
+#       Corsair Sabre RGB                                       #
 #                                                               #
 #  Mousemats:                                                   #
 #       Corsair MM800 RGB Polaris                               #
@@ -149,29 +205,103 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b2d", TAG+="uacces
 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}=="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}=="1b2e", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b5a", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b3e", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b2f", TAG+="uaccess"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b3b", TAG+="uaccess"
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0a34", TAG+="uaccess"
 
+#---------------------------------------------------------------#
+#  Corsair Wireless Devices                                     #
+#                                                               #
+#  Keyboards:                                                   #
+#        Corsair K57 RGB Wired                                  #
+#        Corsair K57 RGB Wireless                               #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b6e", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b62", TAG+="uaccess"
+
+#---------------------------------------------------------------#
+#  Creative Devices                                             #
+#                                                               #
+#  Devices:                                                     #
+#        Creative SoundblasterX G6                              #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="041e", ATTR{idProduct}=="3256", TAG+="uaccess"
+
+#---------------------------------------------------------------#
+#  Ducky Keyboard Devices                                       #
+#                                                               #
+#  Keyboards:                                                   #
+#        Ducky Shine 7 One 2 RGB                                #
+#        Ducky One 2 RGB TKL                                    #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="0348", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="0356", TAG+="uaccess"
+
+#---------------------------------------------------------------#
+#  EK Controller Devices                                        #
+#                                                               #
+#  Controllers:                                                 #
+#        EK Loop Connect                                        #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="5750", TAG+="uaccess"
+
+#---------------------------------------------------------------#
+#  Holtek Devices                                               #
+#                                                               #
+#  Mice:                                                        #
+#        Holtek A070                                            #
+#  Mousemats:                                                   #
+#        Holtek A1FA                                            #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="a070", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="a1fa", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  HyperX Peripheral Devices                                    #
 #                                                               #
 #  Keyboards:                                                   #
 #       HyperX Alloy Elite                                      #
+#       HyperX Alloy Elite 2                                    #
+#       HyperX Alloy FPS RGB                                    #
+#       HyperX Alloy Origins                                    #
+#       HyperX Alloy Origins Core                               #
 #                                                               #
 #  Mice:                                                        #
 #       HyperX Pulsefire Surge                                  #
+#       HyperX Pulsefire FPS Pro                                #
+#       HyperX Pulsefire Dart Wireless                          #
+#       HyperX Pulsefire Dart Wired                             #
 #                                                               #
 #  Mousemats:                                                   #
 #       HyperX Fury Ultra                                       #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16be", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="1711", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16dc", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16e5", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16e6", TAG+="uaccess"
+
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16d3", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16d7", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16e1", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16e2", TAG+="uaccess"
+
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="1705", TAG+="uaccess"
 
+#---------------------------------------------------------------#
+#  Lian Li Uni Hub                                              #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="0cf2", ATTR{idProduct}=="7750", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  Logitech Peripheral Devices                                  #
 #                                                               #
@@ -179,53 +309,87 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="1705", TAG+="uacces
 #       Logitech G213                                           #
 #       Logitech G512                                           #
 #       Logitech G512 RGB                                       #
-#       Logitech G610                                           #
+#       Logitech G610 #1                                        #
+#       Logitech G610 #2                                        #
 #       Logitech G810 #1                                        #
 #       Logitech G810 #2                                        #
+#       Logitech G813                                           #
+#       Logitech G815                                           #
 #                                                               #
 #  Mice:                                                        #
 #       Logitech G203 Prodigy                                   #
 #       Logitech G203 Lightsync                                 #
+#       Logitech G303                                           #
 #       Logitech G403 Prodigy                                   #
 #       Logitech G403 Hero                                      #
 #       Logitech G502 Proteus Spectrum                          #
+#       Logitech G502 Hero                                      #
+#       Logitech G502 Wireless                                  #
+#       Logitech G703 Wireless                                  #
+#       Logitech G900 Wireless                                  #
+#       Logitech G903 Wireless                                  #
 #       Logitech G Lightspeed Wireless Gaming Mouse             #
 #       Logitech G Pro Wireless Gaming Mouse (Wired)            #
+#       Logitech G Pro Hero Gaming Mouse (Wired)                #
 #                                                               #
 #  Mousemats:                                                   #
 #       Logitech G Powerplay Mousepad with Lightspeed           #
 #                                                               #
+#  Speakers:                                                    #
+#       Logitech G560                                           #
+#                                                               #
 #---------------------------------------------------------------#
 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}=="c084", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c092", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c083", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08f", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c082", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="405d", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c332", TAG+="uaccess"
 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}=="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}=="0a78", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  Metadot Das Keyboard 4Q + 5Q                                 #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="24f0", ATTR{idProduct}=="2037", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="24f0", ATTR{idProduct}=="202b", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="24f0", ATTR{idProduct}=="2020", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  MSI Mysticlight                                              #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="3EA4", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="4559", 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"
@@ -263,6 +427,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C95", TAG+="uacces
 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"
 
 #---------------------------------------------------------------#
@@ -279,15 +444,163 @@ KERNEL=="ttyACM[0-9]*", ATTR{idVendor}=="04D8", ATTR{idProduct}=="00DF", TAG+="u
 #  NZXT Hue 2 Devices                                           #
 #                                                               #
 #       NZXT Hue 2                                              #
+#       NZXT Hue 2 Ambient                                      #
+#       NZXT Motherboard                                        #
 #       NZXT Smart Device V2                                    #
+#       NZXT Kraken X3                                          #
+#       NZXT RGB Fan Controller                                 #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2001", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2002", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2005", TAG+="uaccess"
 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"
 
 #---------------------------------------------------------------#
 #  NZXT Kraken                                                  #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="170e", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="1715", TAG+="uaccess"
+
+#---------------------------------------------------------------#
+#  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}=="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}=="0240", 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}=="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}=="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}=="0234", 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}=="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}=="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}=="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}=="0243", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0207", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="021E", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="025D", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0208", 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}=="0042", 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}=="0083", TAG+="uaccess"
+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}=="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}=="0071", 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}=="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}=="0070", 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}=="0046", 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}=="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}=="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}=="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}=="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}=="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}=="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}=="0517", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0518", TAG+="uaccess"
+
+#---------------------------------------------------------------#
+#  Roccat Devices                                               #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1e7d", ATTR{idProduct}=="2e2c", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1e7d", ATTR{idProduct}=="2e27", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  Redragon Peripheral Devices                                  #
@@ -327,6 +640,13 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="258a", ATTR{idProduct}=="0036", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="258a", ATTR{idProduct}=="0033", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="258a", ATTR{idProduct}=="0029", TAG+="uaccess"
 
+#---------------------------------------------------------------#
+#  Sony Devices                                                 #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="05c4", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="09cc", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="0ba0", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  SteelSeries Peripheral Devices                               #
 #                                                               #
@@ -342,22 +662,62 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="258a", ATTR{idProduct}=="0029", TAG+="uacces
 #       SteelSeries Rival 300 CS:GO Hyperbeast Edition          #
 #       SteelSeries Rival 300 Dota 2 Edition                    #
 #       SteelSeries Rival 300 HP Omen Edition                   #
+#       SteelSeries Rival 300 Blackops Edition                  #
+#       SteelSeries Rival 310                                   #
+#       SteelSeries Rival 310 CS:GO Howl Edition                #
+#       SteelSeries Rival 310 PubG Edition                      #
+#       SteelSeries Rival Sensei Ten                            #
+#       SteelSeries Rival Sensei Ten CS:GO Neon Rider           #
+#       SteelSeries Rival Sensei 310                            #
 #  Headsets:                                                    #
 #       SteelSeries Siberia 350                                 #
+#  Keyboards:                                                   #
+#       SteelSeries Apex 5                                      #
+#       SteelSeries Apex 7                                      #
+#       SteelSeries Apex 7 TKL                                  #
+#       SteelSeries Apex Pro                                    #
+#       SteelSeries Apex Pro TKL                                #
+#       SteelSeries Apex M750                                   #
+#       SteelSeries Apex OG                                     #
+#       SteelSeries Apex 350                                    #
+#  Mousemats:                                                   #
+#       SteelSeries QCK Prism Cloth                             #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1702", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="170c", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1814", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1729", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1384", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1710", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1714", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1394", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1716", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="171a", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1392", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1718", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1720", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="171e", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1736", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1832", TAG+="uaccess"
+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}=="1229", TAG+="uaccess"
 
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="161c", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1612", TAG+="uaccess"
+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}=="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}=="150d", TAG+="uaccess"
+
+#---------------------------------------------------------------#
+#  Tecknet Devices                                              #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc05", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  Thermaltake Poseidon Z RGB Keyboard                          #
@@ -371,3 +731,14 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FA[5-9]", TAG+="ua
 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"
+
+#---------------------------------------------------------------#
+#  Wooting Devices                                              #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff01", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff02", TAG+="uaccess"
+
+#---------------------------------------------------------------#
+#  Zalman ZSync Devices                                         #
+#---------------------------------------------------------------#
+SUBSYSTEMS=="usb", ATTR{idVendor}=="1c57", ATTR{idProduct}=="7ed0", TAG+="uaccess"

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -52,7 +52,12 @@ char* AMDWraithPrismController::GetDeviceName()
 std::string AMDWraithPrismController::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());

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -54,8 +54,13 @@ std::string PolychromeUSBController::GetDeviceName()
 std::string PolychromeUSBController::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());
 
@@ -179,7 +184,8 @@ void PolychromeUSBController::WriteRGSwap
 void PolychromeUSBController::WriteHeader
     (
     unsigned char   cfg,
-    unsigned char   configstring[]
+    unsigned char*  configstring,
+    unsigned int    configsize
     )
 {
     unsigned char usb_buf[65];
@@ -194,7 +200,7 @@ void PolychromeUSBController::WriteHeader
     \*-----------------------------------------------------*/
     usb_buf[0x01] = POLYCHROME_USB_WRITE_HEADER;
 	usb_buf[0x03] = cfg;
-    memcpy(&usb_buf[4], configstring, sizeof(configstring));
+    memcpy(&usb_buf[4], configstring, configsize);
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
@@ -207,7 +213,7 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
 {
     unsigned char       usb_buf[65];
     PolychromeZoneInfo  zoneinfo;
-    unsigned char       all;
+    //unsigned char       all;
     unsigned char       r;
     unsigned char       g;
     unsigned char       b;
@@ -242,7 +248,7 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
     zoneinfo.color  = ToRGBColor(r,g,b);  
     zoneinfo.speed  = usb_buf[0x08];
     zoneinfo.zone   = usb_buf[0x03];
-    all             = usb_buf[0x10];
+    //all             = usb_buf[0x10];
 
     return(zoneinfo);
 }

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

@@ -128,8 +128,9 @@ public:
 
     void                                        WriteHeader
                                                     (
-                                                    unsigned char cfg,
-                                                    unsigned char configstring []
+                                                    unsigned char   cfg,
+                                                    unsigned char*  configstring,
+                                                    unsigned int    configsize
                                                     );
 
 protected:

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBControllerDetect.cpp

@@ -20,7 +20,7 @@
 #define ASROCK_MOTHERBOARD_1_PID                    0x01A2
 #define ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID   0x01A6
 
-void DetectPolychromeUSBControllers(hid_device_info* info, const std::string& name)
+void DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*name*/)
 {
     hid_device* dev = hid_open_path(info->path);
 
@@ -33,4 +33,4 @@ void DetectPolychromeUSBControllers(hid_device_info* info, const std::string& na
 }
 
 REGISTER_HID_DETECTOR("ASRock Polychrome USB", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);
-REGISTER_HID_DETECTOR("ASRock Deskmini Addressable LED Strip", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID);
+REGISTER_HID_DETECTOR("ASRock Deskmini Addressable LED Strip", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID);

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -171,16 +171,6 @@ RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController
 
 void RGBController_PolychromeUSB::SetupZones()
 {
-    /*-------------------------------------------------*\
-    | Only set LED count on the first run               |
-    \*-------------------------------------------------*/
-    bool first_run = false;
-
-    if(zones.size() == 0)
-    {
-        first_run = true;
-    }
-
     /*-------------------------------------------------*\
     | Clear any existing color/LED configuration        |
     \*-------------------------------------------------*/
@@ -191,7 +181,6 @@ void RGBController_PolychromeUSB::SetupZones()
     /*-------------------------------------------------*\
     | Set zones and leds                                |
     \*-------------------------------------------------*/
-    int addressableCounter = 1;
     for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
     {
         PolychromeDeviceInfo device_info = polychrome->GetPolychromeDevices()[channel_idx];
@@ -269,8 +258,8 @@ void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
         zonecfg[i]=zones[i].leds_count;
     }
 
-    unsigned char zonecmd = POLYCHROME_USB_LEDCOUNT_CFG;
-    // WriteHeader(zonecmd, zonecfg);
+    // unsigned char zonecmd = POLYCHROME_USB_LEDCOUNT_CFG;
+    // WriteHeader(zonecmd, zonecfg, sizeof(zonecfg));
 }
 
 void RGBController_PolychromeUSB::DeviceUpdateLEDs()
@@ -316,7 +305,6 @@ void RGBController_PolychromeUSB::UpdateSingleLED(int led)
 unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)
 {
     int dev_mode;
-    int color_mode = MODE_COLORS_PER_LED;
 
     dev_mode    = polychrome->GetZoneConfig(zone).mode;
     active_mode = dev_mode;

Controllers/AsusAuraCoreController/AsusAuraCoreController.cpp

@@ -40,7 +40,12 @@ std::string AuraCoreController::GetDeviceLocation()
 std::string AuraCoreController::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());

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -32,14 +32,26 @@ typedef struct
 
 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_GTX1660TI_DEV,   ASUS_SUB_VEN,       ASUS_ROG_GTX1660TI_OC,              0x2A,   "ASUS ROG GTX 1660 Ti OC 6G"        },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_A8G_GAMING,  0x29,   "ASUS ROG Strix GTX1080 A8G Gaming" },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_GAMING,    0x29,   "ASUS ROG Strix GTX1080 Ti 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_RX580_STRIX_GAMING_OC,         0x29,   "ASUS RX 580 Strix Gaming OC"       }
-};
+    { 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_RX580_STRIX_GAMING_OC,             0x29,   "ASUS RX 580 Strix Gaming OC"               }
+};  
 
 /******************************************************************************************\
 *                                                                                          *

Controllers/AsusAuraSMBusController/AsusAuraSMBusController.cpp

@@ -194,38 +194,38 @@ unsigned char AuraSMBusController::GetLEDBlue(unsigned int led)
     return(AuraRegisterRead(direct_reg + ( 3 * led ) + 1));
 }
 
-void AuraSMBusController::SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue)
+void AuraSMBusController::SetAllColorsDirect(RGBColor* colors)
 {
-    unsigned char* colors = new unsigned char[led_count * 3];
+    unsigned char* color_buf = new unsigned char[led_count * 3];
 
     for (unsigned int i = 0; i < (led_count * 3); i += 3)
     {
-        colors[i + 0] = red;
-        colors[i + 1] = blue;
-        colors[i + 2] = green;
+        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, colors, led_count * 3);
+    AuraRegisterWriteBlock(direct_reg, color_buf, led_count * 3);
 
-    delete colors;
+    delete color_buf;
 }
 
-void AuraSMBusController::SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
+void AuraSMBusController::SetAllColorsEffect(RGBColor* colors)
 {
-    unsigned char* colors = new unsigned char[led_count * 3];
+    unsigned char* color_buf = new unsigned char[led_count * 3];
 
     for (unsigned int i = 0; i < (led_count * 3); i += 3)
     {
-        colors[i + 0] = red;
-        colors[i + 1] = blue;
-        colors[i + 2] = green;
+        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, colors, led_count * 3);
-    
+    AuraRegisterWriteBlock(effect_reg, color_buf, led_count * 3);
+
     AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
 
-    delete[] colors;
+    delete[] color_buf;
 }
 
 void AuraSMBusController::SetDirect(unsigned char direct)

Controllers/AsusAuraSMBusController/AsusAuraSMBusController.h

@@ -7,6 +7,8 @@
 |  Adam Honse (CalcProgrammer1) 8/19/2018   |
 \*-----------------------------------------*/
 
+#include "RGBController.h"
+
 #include <string>
 #include "i2c_smbus.h"
 
@@ -87,8 +89,8 @@ public:
     unsigned char GetLEDRed(unsigned int led);
     unsigned char GetLEDGreen(unsigned int led);
     unsigned char GetLEDBlue(unsigned int led);
-    void          SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
-    void          SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
+    void          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);

Controllers/AsusAuraSMBusController/AsusAuraSMBusControllerDetect.cpp

@@ -1,5 +1,6 @@
 #include "Detector.h"
 #include "AsusAuraSMBusController.h"
+#include "LogManager.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraSMBus.h"
 #include "i2c_smbus.h"
@@ -7,6 +8,7 @@
 #include <vector>
 #include <stdio.h>
 #include <stdlib.h>
+#include "dependencies/dmiinfo.h"
 
 using namespace std::chrono_literals;
 
@@ -87,21 +89,32 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr
 {
     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);
@@ -122,24 +135,24 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses)
+void DetectAsusAuraSMBusDRAMControllers(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;
 
         IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            // Remap Aura-enabled RAM modules on 0x77
+            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;
                 }
 
@@ -149,6 +162,8 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses)
 
                     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
@@ -159,6 +174,8 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses)
 
                 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));
                 }
@@ -169,14 +186,25 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses)
             {
                 if (TestForAsusAuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]))
                 {
-                    new_aura = new AuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]);
-                    new_controller = new RGBController_AuraSMBus(new_aura);
-                    ResourceManager::get()->RegisterRGBController(new_controller);
+                    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)
@@ -185,9 +213,11 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses)
             {
                 if (TestForAsusAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
                 {
-                    new_aura = new AuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]);
-                    new_controller = new RGBController_AuraSMBus(new_aura);
-                    ResourceManager::get()->RegisterRGBController(new_controller);
+                    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);
@@ -195,6 +225,7 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses)
         }
     }
 
-}   /* DetectAuraSMBusControllers() */
+}   /* DetectAuraSMBusMotherboardControllers() */
 
-REGISTER_I2C_DETECTOR("ASUS Aura SMBus", DetectAsusAuraSMBusControllers);
+REGISTER_I2C_DETECTOR("ASUS Aura SMBus DRAM", DetectAsusAuraSMBusDRAMControllers);
+REGISTER_I2C_DETECTOR("ASUS Aura SMBus Motherboard", DetectAsusAuraSMBusMotherboardControllers);

Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.cpp

@@ -58,20 +58,13 @@ int RGBController_AuraSMBus::GetDeviceMode()
 
 void RGBController_AuraSMBus::DeviceUpdateLEDs()
 {
-    for(std::size_t led = 0; led < colors.size(); led++)
+    if(GetMode() == 0)
     {
-        unsigned char red = RGBGetRValue(colors[led]);
-        unsigned char grn = RGBGetGValue(colors[led]);
-        unsigned char blu = RGBGetBValue(colors[led]);
-
-        if (GetMode() == 0)
-        {
-            aura->SetLEDColorDirect(led, red, grn, blu);
-        }
-        else
-        {
-            aura->SetLEDColorEffect(led, red, grn, blu);
-        }
+        aura->SetAllColorsDirect(&colors[0]);
+    }
+    else
+    {
+        aura->SetAllColorsEffect(&colors[0]);
     }
 }
 

Controllers/AsusAuraUSBController/AsusAuraAddressableController.cpp

@@ -17,7 +17,7 @@ AuraAddressableController::AuraAddressableController(hid_device* dev_handle, con
     \*-----------------------------------------------------*/
     for(int i = 0; i < config_table[0x02]; ++i)
     {
-        device_info.push_back({0x01, (unsigned char)i, 0x01, AuraDeviceType::ADDRESSABLE});
+        device_info.push_back({0x01, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
     }
 }
 

Controllers/AsusAuraUSBController/AsusAuraKeyboardController.cpp

@@ -30,7 +30,12 @@ std::string AuraKeyboardController::GetDeviceLocation()
 std::string AuraKeyboardController::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());

Controllers/AsusAuraUSBController/AsusAuraMainboardController.cpp

@@ -12,17 +12,26 @@
 
 AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path), mode(AURA_MODE_DIRECT)
 {
+    unsigned char num_total_mainboard_leds  = config_table[0x1B];
+    unsigned char num_rgb_headers           = config_table[0x1D];
+    unsigned char num_addressable_headers   = config_table[0x02];
+
+    if(num_total_mainboard_leds < num_rgb_headers)
+    {
+        num_rgb_headers = 0;
+    }
+
     /*-----------------------------------------------------*\
     | Add mainboard device                                  |
     \*-----------------------------------------------------*/
-    device_info.push_back({0x00, 0x04, config_table[0x1B], AuraDeviceType::FIXED});
+    device_info.push_back({0x00, 0x04, num_total_mainboard_leds, num_rgb_headers, AuraDeviceType::FIXED});
 
     /*-----------------------------------------------------*\
     | Add addressable devices                               |
     \*-----------------------------------------------------*/
-    for(int i = 0; i < config_table[0x02]; ++i)
+    for(int i = 0; i < num_addressable_headers; i++)
     {
-        device_info.push_back({0x01, (unsigned char)i, 0x01, AuraDeviceType::ADDRESSABLE});
+        device_info.push_back({0x01, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
     }
 }
 
@@ -142,7 +151,7 @@ void AuraMainboardController::SendEffect
 
 void AuraMainboardController::SendColor
     (
-    unsigned char   channel,
+    unsigned char   /*channel*/,
     unsigned char   start_led,
     unsigned char   led_count,
     unsigned char*  led_data
@@ -196,4 +205,4 @@ void AuraMainboardController::SendCommit()
     | Send packet                                           |
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 65);
-}
+}

Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp

@@ -30,7 +30,12 @@ std::string AuraMouseController::GetDeviceLocation()
 std::string AuraMouseController::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());

Controllers/AsusAuraUSBController/AsusAuraUSBController.cpp

@@ -42,7 +42,12 @@ std::string AuraUSBController::GetDeviceName()
 std::string AuraUSBController::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());

Controllers/AsusAuraUSBController/AsusAuraUSBController.h

@@ -53,6 +53,7 @@ struct AuraDeviceInfo
     unsigned char effect_channel;
     unsigned char direct_channel;
     unsigned char num_leds;
+    unsigned char num_headers;
     AuraDeviceType device_type;
 };
 

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -9,6 +9,7 @@
 #include "RGBController_AsusAuraMouse.h"
 #include <stdexcept>
 #include <hidapi/hidapi.h>
+#include "dependencies/dmiinfo.h"
 
 #define AURA_USB_VID                            0x0B05
 #define AURA_TERMINAL_PID                       0x1889
@@ -18,6 +19,7 @@
 #define AURA_ADDRESSABLE_4_PID                  0x18A5
 #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
 #define AURA_ROG_STRIX_FLARE_PID                0x1875
@@ -26,9 +28,10 @@
 #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_STRIX_SCOPE_TKL_PID            0x190C
 #define AURA_ROG_CHAKRAM_WIRED_2_PID            0x1958
 
-void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
 
@@ -41,6 +44,20 @@ 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);
+
+    if(dev)
+    {
+        DMIInfo dmi;
+        AuraAddressableController* controller = new AuraAddressableController(dev, info->path);
+        RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
+        rgb_controller->name = "ASUS " + dmi.getMainboard() + " Addressable";
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& name)
 {
     hid_device* dev = hid_open_path(info->path);
@@ -48,9 +65,10 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& nam
     {
         try
         {
+            DMIInfo dmi;
             AuraMainboardController* controller = new AuraMainboardController(dev, info->path);
             RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
-            rgb_controller->name = name;
+            rgb_controller->name = "ASUS " + dmi.getMainboard();
             ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
         catch(std::runtime_error&)
@@ -84,13 +102,14 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
     }
 }
 
-REGISTER_HID_DETECTOR   ("ASUS ROG AURA Terminal",              DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_TERMINAL_PID);
+REGISTER_HID_DETECTOR   ("ASUS ROG AURA Terminal",              DetectAsusAuraUSBTerminal,      AURA_USB_VID, AURA_TERMINAL_PID);
 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);
 REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_4_PID);
 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);
 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);
@@ -99,4 +118,5 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",         DetectAsusAuraUS
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,             0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_2_PID,             0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG 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 Flare PNK LTD",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,         1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL",            DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID,             1,  0xFF00);

Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp

@@ -13,12 +13,12 @@
 #define NA  0xFFFFFFFF
 
 static unsigned int matrix_map[6][22] =
-    { {   0,  NA,  12,  17,  22,  27,  37,  42,  48,  53,  59,  64,  67,  68,  NA,  74,  78,  83,  NA,  NA,  NA,  NA },
-      {   1,   7,  13,  18,  23,  28,  33,  38,  43,  49,  54,  60,  65,  69,  NA,  75,  79,  84,  87,  92,  96, 101 },
-      {   2,  NA,   8,  14,  19,  24,  29,  34,  39,  44,  50,  55,  61,  66,  70,  76,  80,  85,  88,  93,  97, 102 },
-      {   3,  NA,   9,  15,  20,  25,  30,  35,  40,  45,  51,  56,  62,  71,  NA,  NA,  NA,  NA,  89,  94,  98,  NA },
-      {   4,  NA,  10,  16,  21,  26,  31,  36,  41,  46,  52,  57,  NA,  NA,  72,  NA,  81,  NA,  90,  95,  99, 103 },
-      {   5,   6,  11,  NA,  NA,  NA,  NA,  32,  NA,  47,  NA,  58,  63,  73,  NA,  77,  82,  86,  91,  NA, 100,  NA } };
+    { {   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 },
+      {   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[] =
 {
@@ -36,7 +36,7 @@ static zone_type zone_types[] =
 
 static const unsigned int zone_sizes[] =
 {
-    104,
+    106,
     1,
     2,
 };
@@ -56,6 +56,7 @@ static const led_type led_names[] =
     { "Key: Caps Lock",         0x03    },
     { "Key: Left Shift",        0x04    },
     { "Key: Left Control",      0x05    },
+    { "Key: \\ (ISO)",          0x0C    },
     { "Key: Left Windows",      0x0D    },
     { "Key: 1",                 0x11    },
     { "Key: Q",                 0x12    },
@@ -117,6 +118,7 @@ static const led_type led_names[] =
     { "Key: F10",               0x68    },
     { "Key: =",                 0x69    },
     { "Key: ]",                 0x6A    },
+    { "Key: #",                 0x6B    },
     { "Key: F11",               0x70    },
     { "Key: F12",               0x78    },
     { "Key: Backspace",         0x79    },
@@ -237,7 +239,7 @@ void RGBController_AuraKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AuraKeyboard::DeviceUpdateLEDs()
 {
-unsigned char frame_buf[107 * 4];
+unsigned char frame_buf[109 * 4];
 
 /*---------------------------------------------------------*\
 | TODO: Send packets with multiple LED frames               |
@@ -250,7 +252,7 @@ for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     frame_buf[(led_idx * 4) + 3] = RGBGetBValue(colors[led_idx]);
 }
 
-aura->SendDirect(107, frame_buf);
+aura->SendDirect(109, frame_buf);
 }
 
 void RGBController_AuraKeyboard::UpdateZoneLEDs(int /*zone*/)

Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -159,13 +159,24 @@ void RGBController_AuraUSB::SetupZones()
             }
         }
 
-
+        unsigned int num_mainboard_leds = device_info.num_leds - device_info.num_headers;
         for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
         {
+            unsigned led_idx = led_ch_idx + 1;
             led new_led;
+
             new_led.name = zones[channel_idx].name;
-            new_led.name.append(", LED ");
-            new_led.name.append(std::to_string(led_ch_idx + 1));
+            if(device_info.device_type == AuraDeviceType::FIXED && led_ch_idx >= num_mainboard_leds)
+            {
+                new_led.name.append(", RGB Header ");
+                led_idx -= num_mainboard_leds;
+            }
+            else
+            {
+                new_led.name.append(", LED ");
+            }
+            new_led.name.append(std::to_string(led_idx));
+
             new_led.value = channel_idx;
 
             leds.push_back(new_led);

Controllers/CoolerMasterController/CMARGBcontroller.cpp

@@ -204,7 +204,7 @@ void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_cou
     /*---------------------------------------------*\
     | Set up the RGB triplets to send               |
     \*---------------------------------------------*/
-    for(int i = 0; i < led_count; i++)
+    for(unsigned int i = 0; i < led_count; i++)
     {
         RGBColor      colour            = led_colours[i];
 

Controllers/CoolerMasterController/CMMKController.cpp

@@ -0,0 +1,167 @@
+/*-------------------------------------------------------------------*\
+|  CMMKController.cpp                                                 |
+|                                                                     |
+|  Driver for Coolermaster MasterKeys Keyboards                       |
+|                                                                     |
+|  Lukas N (chmod222)       28th Jun 2020                             |
+|  Tam D (too.manyhobbies)  25th Apr 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "CMMKController.h"
+
+CMMKController::CMMKController(hid_device* dev, hid_device_info* dev_info)
+{
+    location        =  dev_info->path;
+
+    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());
+
+    hid_get_product_string(dev, tmpName, szTemp);
+    wName  = std::wstring(tmpName);
+    device_name.append(" ").append(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);
+
+    firmware_version = buf;
+}
+
+CMMKController::~CMMKController()
+{
+    cmmk_detach(&cmmk_handle);
+}
+
+std::string CMMKController::GetDeviceName()
+{
+    return device_name;
+}
+
+std::string CMMKController::GetLocation()
+{
+    return location;
+}
+
+std::string CMMKController::GetFirmwareVersion()
+{
+    return firmware_version;
+}
+
+void CMMKController::SetFirmwareControl()
+{
+    ActivateMode(CMMK_FIRMWARE);
+}
+
+void CMMKController::SetManualControl()
+{
+    ActivateMode(CMMK_MANUAL);
+}
+
+void CMMKController::SetSingle(int row, int col, struct rgb color)
+{
+    cmmk_set_single_key(&cmmk_handle, row, col, &color);
+}
+
+void CMMKController::SetAll(struct cmmk_color_matrix const& colors)
+{
+    cmmk_set_leds(&cmmk_handle, &colors);
+}
+
+void CMMKController::SetAllSingle(struct rgb color)
+{
+    cmmk_set_all_single(&cmmk_handle, &color);
+}
+
+void CMMKController::SetMode(cmmk_effect_fully_lit eff)
+{
+    ActivateEffect(CMMK_EFFECT_FULLY_LIT);
+    cmmk_set_effect_fully_lit(&cmmk_handle, &eff);
+}
+
+void CMMKController::SetMode(cmmk_effect_breathe eff)
+{
+    ActivateEffect(CMMK_EFFECT_BREATHE);
+    cmmk_set_effect_breathe(&cmmk_handle, &eff);
+}
+
+void CMMKController::SetMode(cmmk_effect_cycle eff)
+{
+    ActivateEffect(CMMK_EFFECT_CYCLE);
+    cmmk_set_effect_cycle(&cmmk_handle, &eff);
+}
+
+void CMMKController::SetMode(cmmk_effect_single eff)
+{
+    ActivateEffect(CMMK_EFFECT_SINGLE);
+    cmmk_set_effect_single(&cmmk_handle, &eff);
+}
+
+void CMMKController::SetMode(cmmk_effect_wave eff)
+{
+    ActivateEffect(CMMK_EFFECT_WAVE);
+    cmmk_set_effect_wave(&cmmk_handle, &eff);
+}
+
+void CMMKController::SetMode(cmmk_effect_ripple eff)
+{
+    ActivateEffect(CMMK_EFFECT_RIPPLE);
+    cmmk_set_effect_ripple(&cmmk_handle, &eff); 
+}
+
+void CMMKController::SetMode(cmmk_effect_cross eff)
+{
+    ActivateEffect(CMMK_EFFECT_CROSS);
+    cmmk_set_effect_cross(&cmmk_handle, &eff); 
+}
+
+void CMMKController::SetMode(cmmk_effect_raindrops eff)
+{
+    ActivateEffect(CMMK_EFFECT_RAINDROPS);
+    cmmk_set_effect_raindrops(&cmmk_handle, &eff); 
+}
+
+void CMMKController::SetMode(cmmk_effect_stars eff)
+{
+    ActivateEffect(CMMK_EFFECT_STARS);
+    cmmk_set_effect_stars(&cmmk_handle, &eff); 
+}
+
+void CMMKController::SetMode(cmmk_effect_snake eff)
+{
+    ActivateEffect(CMMK_EFFECT_SNAKE);
+    cmmk_set_effect_snake(&cmmk_handle, &eff); 
+}
+
+bool CMMKController::PositionValid(int y, int x)
+{
+    return(cmmk_lookup_key_id(&cmmk_handle, y, x) >= 0);
+}
+
+void CMMKController::ActivateMode(int mode)
+{
+    if (current_mode != mode)
+    {
+        cmmk_set_control_mode(&cmmk_handle, mode);
+
+        current_mode = mode;
+        current_effect = -1;
+    }
+}
+
+void CMMKController::ActivateEffect(int effect)
+{
+    ActivateMode(CMMK_EFFECT);
+
+    if (current_effect != effect)
+    {
+        cmmk_set_active_effect(&cmmk_handle, (enum cmmk_effect_id)effect);
+
+        current_effect = effect;
+    }
+}

Controllers/CoolerMasterController/CMMKController.h

@@ -0,0 +1,58 @@
+/*-------------------------------------------------------------------*\
+|  CMMKController.h                                                   |
+|                                                                     |
+|  Driver for Coolermaster MasterKeys keyboards                       |
+|                                                                     |
+|  Lukas N (chmod222)       28th Jun 2020                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include <libcmmk/libcmmk.h>
+
+#pragma once
+
+class CMMKController
+{
+public:
+    CMMKController(hid_device* dev_handle, hid_device_info* dev_info);
+    ~CMMKController();
+
+    std::string GetDeviceName();
+    std::string GetLocation();
+    std::string GetFirmwareVersion();
+
+    void SetFirmwareControl();
+    void SetManualControl();
+
+    void SetSingle(int row, int col, struct rgb color);
+    void SetAll(struct cmmk_color_matrix const& colors);
+    void SetAllSingle(struct rgb color);
+
+    void SetMode(cmmk_effect_fully_lit eff);
+    void SetMode(cmmk_effect_breathe eff);
+    void SetMode(cmmk_effect_cycle eff);
+    void SetMode(cmmk_effect_single eff);
+    void SetMode(cmmk_effect_wave eff);
+    void SetMode(cmmk_effect_ripple eff);
+    void SetMode(cmmk_effect_cross eff);
+    void SetMode(cmmk_effect_raindrops eff);
+    void SetMode(cmmk_effect_stars eff);
+    void SetMode(cmmk_effect_snake eff);
+
+    bool PositionValid(int y, int x);
+
+private:
+    void ActivateMode(int mode);
+    void ActivateEffect(int effect);
+
+    int         current_mode    = -1;
+    int         current_effect  = -1;
+
+    std::string device_name;
+    std::string location;
+    std::string firmware_version;
+
+    mutable struct cmmk cmmk_handle;
+};

Controllers/CoolerMasterController/CMSmallARGBController.cpp

@@ -147,7 +147,7 @@ void CMSmallARGBController::SetMode(unsigned char mode, unsigned char speed, RGB
     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
     /*

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -3,20 +3,28 @@
 #include "CMARGBcontroller.h"
 #include "CMSmallARGBController.h"
 #include "CMR6000Controller.h"
+#include "CMMKController.h"
 #include "RGBController.h"
 #include "RGBController_CMMP750Controller.h"
 #include "RGBController_CMARGBController.h"
 #include "RGBController_CMSmallARGBController.h"
 #include "RGBController_CMR6000Controller.h"
+#include "RGBController_CMMKController.h"
 #include <hidapi/hidapi.h>
 
-#define COOLERMASTER_VID                0x2516
+#define COOLERMASTER_VID                        0x2516
 
-#define COOLERMASTER_MP750_XL_PID       0x0109
-#define COOLERMASTER_MP750_MEDIUM_PID   0x0105
-#define COOLERMASTER_ARGB_PID           0x1011
-#define COOLERMASTER_SMALL_ARGB_PID     0x1000
-#define COOLERMASTER_RADEON_6000_PID    0x014D
+#define COOLERMASTER_MP750_XL_PID               0x0109
+#define COOLERMASTER_MP750_MEDIUM_PID           0x0105
+#define COOLERMASTER_ARGB_PID                   0x1011
+#define COOLERMASTER_SMALL_ARGB_PID             0x1000
+#define COOLERMASTER_RADEON_6000_PID            0x014D
+#define COOLERMASTER_MASTERKEYS_PRO_L_PID       CMMK_USB_MASTERKEYS_MK750
+#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
+#define COOLERMASTER_MASTERKEYS_SK630_PID       CMMK_USB_MASTERKEYS_SK630
+#define COOLERMASTER_MASTERKEYS_SK650_PID       CMMK_USB_MASTERKEYS_SK650
 
 /******************************************************************************************\
 *                                                                                          *
@@ -77,8 +85,27 @@ void DetectCoolerMasterGPU(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);
-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_I  ("Cooler Master Radeon 6000 GPU",  DetectCoolerMasterGPU,          COOLERMASTER_VID, COOLERMASTER_RADEON_6000_PID,                 1);
+void DetectCoolerMasterKeyboards(hid_device_info* info, const std::string&)
+{
+
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        CMMKController* controller                   = new CMMKController(dev, info);
+        RGBController_CMMKController* rgb_controller = new RGBController_CMMKController(controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 XL",                 DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_XL_PID,                  0xFF00, 1        );
+REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 Medium",             DetectCoolerMasterMousemats,    COOLERMASTER_VID,   COOLERMASTER_MP750_MEDIUM_PID,              0xFF00, 1        );
+REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L",         DetectCoolerMasterKeyboards,    COOLERMASTER_VID,   COOLERMASTER_MASTERKEYS_PRO_L_PID,          1,      0xFF00, 1);
+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_I  ("Cooler Master Radeon 6000 GPU",          DetectCoolerMasterGPU,          COOLERMASTER_VID,   COOLERMASTER_RADEON_6000_PID,               1                );

Controllers/CoolerMasterController/RGBController_CMARGBController.cpp

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

Controllers/CoolerMasterController/RGBController_CMMKController.cpp

@@ -0,0 +1,467 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMMKController.cpp                                   |
+|                                                                     |
+|  Driver for Coolermaster MasterKeys keyboards                       |
+|                                                                     |
+|  Lukas N (chmod222)          28th Jun 2020                          |
+|  Tam D (too.manyhobbies)  25th Apr 2021                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBController_CMMKController.h"
+
+#include <sstream>
+
+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
+
+RGBController_CMMKController::RGBController_CMMKController(CMMKController* cmmk_ctrl)
+{
+    cmmk        = cmmk_ctrl;
+
+    name        = cmmk->GetDeviceName();
+    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;
+    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.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.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;
+    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.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.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.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.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.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.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;
+    modes.push_back(Snake);
+
+    mode FirmwareControl;
+    FirmwareControl.name  = "Firmware Controlled";
+    FirmwareControl.value = 0xFF;
+    FirmwareControl.flags = 0;
+    modes.push_back(FirmwareControl);
+
+    SetupZones();
+}
+
+RGBController_CMMKController::~RGBController_CMMKController()
+{
+    delete cmmk;
+}
+
+void RGBController_CMMKController::SetupMatrixMap()
+{
+    for(int y = 0; y < CMMK_ROWS_MAX; y++)
+    {
+        for(int x = 0; x < CMMK_COLS_MAX; x++)
+        {
+            matrix_map[y][x] = 0xFFFFFFFF;
+        }
+    }
+
+    for(size_t i = 0; i < leds.size(); i++)
+    {
+        led& l  = leds[i];
+
+        int y   = (l.value & 0xFF00) >> 8;
+        int x   = (l.value & 0xFF);
+
+        matrix_map[y][x] = i;
+    }
+}
+
+void RGBController_CMMKController::SetupZones()
+{
+    for(int y = 0; y < CMMK_ROWS_MAX; y++)
+    {
+        for(int x = 0; x < CMMK_COLS_MAX; x++)
+        {
+            if(!cmmk->PositionValid(y, x))
+            {
+                continue;
+            }
+
+            std::stringstream namestrm;
+
+            led key;
+            
+            namestrm << "Key @ Row " << (y + 1) << ", Column" << (x + 1);
+
+            key.name = namestrm.str();
+            key.value = (y & 0xFF) << 8 | (x & 0xFF);
+
+            leds.push_back(key);
+        }
+    }
+
+    zone KeyboardZone;
+    KeyboardZone.name               = "Keyboard";
+    KeyboardZone.type               = ZONE_TYPE_MATRIX;
+    KeyboardZone.leds_min           = leds.size();
+    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->map    = (unsigned int *)&matrix_map;
+
+    zones.push_back(KeyboardZone);
+
+    SetupMatrixMap();
+    SetupColors();
+}
+
+void RGBController_CMMKController::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+struct rgb map_to_cmmk_rgb(RGBColor input)
+{
+    return rgb
+    {
+        (uint8_t)RGBGetRValue(input),
+        (uint8_t)RGBGetGValue(input),
+        (uint8_t)RGBGetBValue(input)
+    };
+}
+
+enum cmmk_wave_direction map_to_cmmk_dir(int input)
+{
+    switch(input)
+    {
+        case MODE_DIRECTION_LEFT:
+            return CMMK_RIGHT_TO_LEFT;
+
+        case MODE_DIRECTION_RIGHT:
+            return CMMK_LEFT_TO_RIGHT;
+
+        case MODE_DIRECTION_UP:
+            return CMMK_FRONT_TO_BACK;
+
+        case MODE_DIRECTION_DOWN:
+            return CMMK_BACK_TO_FRONT;
+
+        default:
+            return CMMK_RIGHT_TO_LEFT;
+    }
+}
+
+void copy_buffers(led* buf,  RGBColor* colbuf, size_t n, struct cmmk_color_matrix& mat, std::atomic<bool>& dirty)
+{
+    dirty.store(false);
+
+    for(size_t i = 0; i < n; i++)
+    {
+        led const& selected_led = buf[i];
+
+        int y = (selected_led.value & 0xFF00) >> 8;
+        int x = selected_led.value & 0xFF;
+
+        struct rgb col = map_to_cmmk_rgb(colbuf[i]);
+        struct rgb ecol = mat.data[y][x];
+
+        if(ecol.R != col.R || ecol.G != col.G || ecol.B != col.B)
+        {
+            dirty.store(true);
+
+            mat.data[y][x] = col;
+        }
+    }
+}
+
+void RGBController_CMMKController::DeviceUpdateLEDs()
+{
+    copy_buffers(leds.data(), colors.data(), leds.size(), current_matrix, dirty);
+
+    if(force_update.load() || dirty.load())
+    {
+        cmmk->SetAll(current_matrix);
+
+        force_update.store(false);
+    }
+}
+
+void RGBController_CMMKController::UpdateZoneLEDs(int zone_idx)
+{
+    zone& z = zones[zone_idx];
+
+    copy_buffers(z.leds, z.colors, z.leds_count, current_matrix, dirty);
+
+    if(force_update.load() || dirty.load())
+    {
+        cmmk->SetAll(current_matrix);
+
+        force_update.store(false);
+    }
+}
+
+void RGBController_CMMKController::UpdateSingleLED(int led_idx)
+{
+    led& selected_led = leds[led_idx];
+
+    int y = (selected_led.value & 0xFF00) >> 8;
+    int x = selected_led.value & 0xFF;
+
+    current_matrix.data[y][x] = map_to_cmmk_rgb(colors[led_idx]);
+
+    cmmk->SetSingle(y, x, map_to_cmmk_rgb(colors[led_idx]));
+    dirty.store(false);
+}
+
+void RGBController_CMMKController::SetCustomMode()
+{
+    active_mode = 1;
+}
+
+void RGBController_CMMKController::DeviceUpdateMode()
+{
+    force_update.store(true);
+
+    switch(modes[active_mode].value)
+    {
+        case CMMK_MODE_FIRMWARE:
+            cmmk->SetFirmwareControl();
+            break;
+        
+        case CMMK_MODE_MANUAL:
+            cmmk->SetManualControl();
+            break;
+
+        case CMMK_EFFECT_FULLY_LIT:
+            {
+                cmmk_effect_fully_lit fully_lit_effect;
+
+                fully_lit_effect.color  = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+
+                cmmk->SetMode(fully_lit_effect);
+            }
+            break;
+
+        case CMMK_EFFECT_BREATHE:
+            {
+                cmmk_effect_breathe breathe_effect;
+
+                breathe_effect.speed    = (uint8_t)modes[active_mode].speed;
+                breathe_effect.color    = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+
+                cmmk->SetMode(breathe_effect);
+            }
+            break;
+
+        case CMMK_EFFECT_CYCLE:
+            {
+                cmmk_effect_cycle cycle_effect;
+
+                cycle_effect.speed  = (uint8_t)modes[active_mode].speed;
+
+                cmmk->SetMode(cycle_effect);
+            }
+            break;
+        
+        case CMMK_EFFECT_SINGLE:
+            {
+                cmmk_effect_single single_effect;
+
+                single_effect.speed     = (uint8_t)modes[active_mode].speed;
+                single_effect.active    = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+                single_effect.rest      = map_to_cmmk_rgb(modes[active_mode].colors[1]);
+
+                cmmk->SetMode(single_effect);
+            }
+            break;
+        
+        case CMMK_EFFECT_WAVE:
+            {
+                cmmk_effect_wave wave_effect;
+
+                wave_effect.speed       = (uint8_t)modes[active_mode].speed;
+                wave_effect.direction   = map_to_cmmk_dir(modes[active_mode].direction);
+                wave_effect.start       = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+
+                cmmk->SetMode(wave_effect);
+            }
+            break;
+        
+        case CMMK_EFFECT_RIPPLE:
+            {
+                cmmk_effect_ripple ripple_effect;
+
+                ripple_effect.speed             = (uint8_t)modes[active_mode].speed;
+                ripple_effect.active            = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+                ripple_effect.rest              = map_to_cmmk_rgb(modes[active_mode].colors[1]);
+
+                if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
+                {
+                    ripple_effect.ripple_type   = CMMK_RIPPLE_RANDOM_COLOR;
+                }
+                else
+                {
+                    ripple_effect.ripple_type   = CMMK_RIPPLE_GIVEN_COLOR;
+                }
+
+                cmmk->SetMode(ripple_effect);
+            }
+            break;
+        
+        case CMMK_EFFECT_CROSS:
+            {
+                cmmk_effect_cross cross_effect;
+
+                cross_effect.speed  = (uint8_t)modes[active_mode].speed;
+                cross_effect.active = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+                cross_effect.rest   = map_to_cmmk_rgb(modes[active_mode].colors[1]);
+
+                cmmk->SetMode(cross_effect);
+            }
+            break;
+        
+        case CMMK_EFFECT_RAINDROPS:
+            {
+                cmmk_effect_raindrops raindrops_effect;
+
+                raindrops_effect.speed      = (uint8_t)modes[active_mode].speed;
+                raindrops_effect.interval   = CMMK_SPEED_MID;
+                raindrops_effect.active     = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+                raindrops_effect.rest       = map_to_cmmk_rgb(modes[active_mode].colors[1]);
+
+                cmmk->SetMode(raindrops_effect);
+            }
+            break;
+
+        case CMMK_EFFECT_STARS:
+            {
+                cmmk_effect_stars stars_effect;
+                
+                stars_effect.speed      = (uint8_t)modes[active_mode].speed;
+                stars_effect.interval   = CMMK_SPEED_MID;
+                stars_effect.active     = map_to_cmmk_rgb(modes[active_mode].colors[0]);
+                stars_effect.rest       = map_to_cmmk_rgb(modes[active_mode].colors[1]);
+    
+                cmmk->SetMode(stars_effect);
+            }
+            break;
+
+        case CMMK_EFFECT_SNAKE:
+            {
+                cmmk_effect_snake snake_effect;
+                
+                snake_effect.speed = (uint8_t)modes[active_mode].speed;
+
+                cmmk->SetMode(snake_effect);
+            }
+            break;
+    }
+}

Controllers/CoolerMasterController/RGBController_CMMKController.h

@@ -0,0 +1,42 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_CMMKController.h                                     |
+|                                                                     |
+|  Driver for Coolermaster MasterKeys keyboards                       |
+|                                                                     |
+|  Lukas N (chmod222)          28th Jun 2020                          |
+|  Tam D (too.manyhobbies)     25th Apr 2021                          |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "CMMKController.h"
+
+class RGBController_CMMKController : public RGBController
+{
+public:
+    RGBController_CMMKController(CMMKController* cmmk_ptr);
+    ~RGBController_CMMKController();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
+
+    void SetCustomMode();
+    void DeviceUpdateMode();
+
+private:
+    void SetupMatrixMap();
+
+    CMMKController* cmmk;
+
+    int matrix_map[CMMK_ROWS_MAX][CMMK_COLS_MAX];
+    struct cmmk_color_matrix current_matrix;
+
+    std::atomic<bool> dirty;
+    std::atomic<bool> force_update;
+};

Controllers/CoolerMasterController/RGBController_CMMP750Controller.cpp

@@ -87,7 +87,7 @@ RGBController_CMMP750Controller::~RGBController_CMMP750Controller()
 int RGBController_CMMP750Controller::GetDeviceMode()
 {
     int temp_mode = cmmp750->GetMode();
-    for( int i = 0; i < modes.size(); i++)
+    for(unsigned int i = 0; i < modes.size(); i++)
     {
         if (temp_mode == modes[i].value)
         {

Controllers/CoolerMasterController/RGBController_CMR6000Controller.cpp

@@ -140,7 +140,7 @@ void RGBController_CMR6000Controller::UpdateSingleLED(int /*led*/)
 
 void RGBController_CMR6000Controller::SetCustomMode()
 {
-    
+    active_mode = 1;
 }
 
 void RGBController_CMR6000Controller::DeviceUpdateMode()

Controllers/CoolerMasterController/RGBController_CMSmallARGBController.cpp

@@ -224,14 +224,14 @@ 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);
+    //bool random_colours     = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
 
     //cmargb->SetLedsDirect(zones[zone].colors, random_colours);
 }
 
-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 );

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.cpp

@@ -0,0 +1,276 @@
+/*---------------------------------------------------------*\
+|  CorsairCommanderCoreController.cpp                       |
+|                                                           |
+|  Processing Code for Corsair Commander Core               |
+|                                                           |
+|  Jeff P.                                                  |
+\*---------------------------------------------------------*/
+
+#include "CorsairCommanderCoreController.h"
+
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+
+using namespace std::chrono_literals;
+
+CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_handle, const char* path)
+{
+    dev                     = dev_handle;
+    location                = path;
+    keepalive_thread_run    = 1;
+    controller_ready        = 0;
+
+    /*-----------------------------------------------------*\
+    | Initialize controller                                 |
+    \*-----------------------------------------------------*/
+    InitController();
+
+    /*-----------------------------------------------------*\
+    | Start keepalive thread                                |
+    \*-----------------------------------------------------*/
+    keepalive_thread = new std::thread(&CorsairCommanderCoreController::KeepaliveThread, this);
+}
+
+CorsairCommanderCoreController::~CorsairCommanderCoreController()
+{
+    /*-----------------------------------------------------*\
+    | Close keepalive thread                                |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = 0;
+    keepalive_thread->join();
+    delete keepalive_thread;
+
+    /*-----------------------------------------------------*\
+    | Close HID device                                      |
+    \*-----------------------------------------------------*/
+    hid_close(dev);
+}
+
+void CorsairCommanderCoreController::InitController()
+{
+    /*-----------------------------------------------------*\
+    | Packet sequence to put controller into direct mode    |
+    \*-----------------------------------------------------*/
+    unsigned char buffarray[][5] =
+    {
+        {0x08, 0x01, 0x03, 0x00, 0x02},
+        {0x08, 0x0D, 0x00, 0x22, 0x00},
+    };
+
+    SendMultiPkt(buffarray, sizeof(buffarray) / sizeof(buffarray[0]), sizeof(buffarray)[0] / sizeof(buffarray[0][0]));
+    SetFanMode();
+}
+
+std::string CorsairCommanderCoreController::GetLocationString()
+{
+    return("HID: " + location);
+}
+
+void CorsairCommanderCoreController::KeepaliveThread()
+{
+    while(keepalive_thread_run.load())
+    {
+        if (controller_ready)
+        {
+            if((std::chrono::steady_clock::now() - last_commit_time) > std::chrono::seconds(10))
+            {
+                SendCommit();
+            }
+        }
+        std::this_thread::sleep_for(1s);
+    }
+}
+
+void CorsairCommanderCoreController::SendCommit()
+{
+    if(!lastcolors.empty())
+    {
+        /*-----------------------------------------------------*\
+        | If colors remain to be sent, send them                |
+        \*-----------------------------------------------------*/
+        SetDirectColor(lastcolors, lastzones);
+    }
+    else
+    {
+        unsigned char   usb_buf[1025];
+
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0x00, sizeof(usb_buf));
+
+        /*-----------------------------------------------------*\
+        | Update last commit time                               |
+        \*-----------------------------------------------------*/
+        last_commit_time    = std::chrono::steady_clock::now();
+
+        /*-----------------------------------------------------*\
+        | Set up Commit packet                                  |
+        \*-----------------------------------------------------*/
+        memset(usb_buf, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+
+        usb_buf[0]          = 0x00;
+        usb_buf[1]          = 0x08;
+        usb_buf[2]          = 0x06;
+        usb_buf[4]          = 0xBD;
+        usb_buf[5]          = 0x02;
+        usb_buf[8]          = 0x12;
+
+        hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    }
+}
+
+
+void CorsairCommanderCoreController::SendMultiPkt(unsigned char buffarray[][5], int r, int c)
+{
+    /*---------------------------------------------------------*\
+    | Private function to send multiple packets                 |
+    \*---------------------------------------------------------*/
+    unsigned char* hidtemp = new unsigned char[CORSAIR_COMMANDER_CORE_PACKET_SIZE];
+
+    for(unsigned int i = 0; i < r; i++)
+    {
+        memset(hidtemp, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    
+        for(unsigned int j = 0; j < c; j++)
+        {
+            hidtemp[j+1] = buffarray[i][j];
+        }
+
+        hid_write(dev, hidtemp, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+        hid_read(dev, hidtemp, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    }
+}
+
+void CorsairCommanderCoreController::SetDirectColor
+    (
+        std::vector<RGBColor> colors,
+        std::vector<zone> zones
+    )
+{
+    if(controller_ready == 1 && ((std::chrono::steady_clock::now() - last_commit_time) > std::chrono::milliseconds(33)))
+    {
+        lastcolors              = colors;
+        lastzones               = zones;
+        int packet_offset       = CORSAIR_COMMANDER_CORE_PREAMBLE_OFFSET;
+        int led_idx             = 0;
+        int channel_idx         = 0;
+        unsigned char* usb_buf  = new unsigned char[CORSAIR_COMMANDER_CORE_PACKET_SIZE];
+
+        memset(usb_buf, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+
+        /*-----------------------------------------------------*\
+        | Prepare color information packet                      |
+        \*-----------------------------------------------------*/
+        usb_buf[0]              = 0x00;
+        usb_buf[1]              = 0x08;
+        usb_buf[2]              = 0x06;
+        usb_buf[4]              = 0xBD;
+        usb_buf[5]              = 0x02;
+        usb_buf[8]              = 0x12;
+
+        for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+        {
+            /*-------------------------------------------------*\
+            | Add led colors                                    |
+            \*-------------------------------------------------*/
+            for(unsigned int i = led_idx; i < led_idx + zones[zone_idx].leds_count; i++)
+            {
+                usb_buf[packet_offset]   = RGBGetRValue(colors[i]);
+                usb_buf[packet_offset+1] = RGBGetGValue(colors[i]);
+                usb_buf[packet_offset+2] = RGBGetBValue(colors[i]);
+
+                packet_offset = packet_offset + 3;
+            }
+
+            led_idx = led_idx + zones[zone_idx].leds_count;
+
+            /*-------------------------------------------------*\
+            | Move offset for pump zone with less than 29 LEDs  |
+            \*-------------------------------------------------*/
+            if(zone_idx == 0)
+            {
+                packet_offset = packet_offset + 3 * (29 - zones[zone_idx].leds_count);
+            }
+
+            /*-------------------------------------------------*\
+            | Move offset for fans with less than 34 LEDs       |
+            \*-------------------------------------------------*/
+            if(zone_idx != 0)
+            {
+                packet_offset = packet_offset + 3 * (34 - zones[zone_idx].leds_count);
+            }
+
+            channel_idx++;
+        }
+
+        /*-----------------------------------------------------*\
+        | Sending a direct mode color packet resets the timeout |
+        \*-----------------------------------------------------*/
+        last_commit_time = std::chrono::steady_clock::now();
+
+        hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    }
+}
+
+void CorsairCommanderCoreController::SetFanMode()
+{
+    /*--------------------------------------------------------------------------------------------------*\
+    | Force controller to 6 QL fan mode to expose maximum number of LEDs per rgb port (34 LEDs per port) |
+    \*--------------------------------------------------------------------------------------------------*/
+
+    unsigned char usb_buf[1025];
+
+    unsigned char buffarray4[][5] =
+    {
+        {0x08, 0x05, 0x01, 0x01, 0x00},
+        {0x08, 0x0D, 0x01, 0x1E, 0x00},
+        {0x08, 0x09, 0x01, 0x00, 0x00}
+    };
+
+    SendMultiPkt(buffarray4, sizeof(buffarray4) / sizeof(buffarray4[0]), sizeof(buffarray4)[0] / sizeof(buffarray4[0][0]));
+
+    memset(usb_buf, 0, sizeof(usb_buf));
+
+    usb_buf[0]          = 0x00;
+    usb_buf[1]          = 0x08;
+    usb_buf[2]          = 0x06;
+    usb_buf[3]          = 0x01;
+    usb_buf[4]          = 0x11;
+    usb_buf[8]          = 0x0D;
+    usb_buf[10]         = 0x07;
+    usb_buf[11]         = 0x01;
+    usb_buf[12]         = 0x08;
+
+    for(unsigned int i = 13; i < 25; i = i + 2)
+    {
+        usb_buf[i]      = 0x01;
+        usb_buf[i + 1]  = 0x06;
+    }
+
+    hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    hid_read(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+
+    unsigned char buffarray2[][5] =
+    {
+        {0x08, 0x05, 0x01, 0x01, 0x00},
+        {0x08, 0x15, 0x01, 0x00, 0x00}
+    };
+
+    SendMultiPkt(buffarray2, sizeof(buffarray2) / sizeof(buffarray2[0]), sizeof(buffarray2)[0] / sizeof(buffarray2[0][0]));
+
+    memset(usb_buf, 0, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+
+    usb_buf[0]          = 0x00;
+    usb_buf[1]          = 0x08;
+    usb_buf[2]          = 0x06;
+    usb_buf[4]          = 0xBD;
+    usb_buf[5]          = 0x02;
+    usb_buf[8]          = 0x12;
+
+    hid_write(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    hid_read(dev, usb_buf, CORSAIR_COMMANDER_CORE_PACKET_SIZE);
+    
+    controller_ready    = 1;
+}

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreController.h

@@ -0,0 +1,65 @@
+/*---------------------------------------------------------*\
+|  CorsairCommanderCoreController.h                         |
+|                                                           |
+|  Definitions for Corsair Commander Core                   |
+|  Based on code by:                                        |
+|  Adam Honse ([email protected]), 8/17/2020        |
+|                                                           |
+|  Jeff P.                                                  |
+\*---------------------------------------------------------*/
+
+#include "RGBController.h"
+#include <vector>
+#include <chrono>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+#define CORSAIR_COMMANDER_CORE_PACKET_SIZE      1025
+#define CORSAIR_COMMANDER_CORE_PREAMBLE_OFFSET  10
+#define CORSAIR_ELITE_CAPELLIX_PUMP_LED_OFFSET  87
+#define CORSAIR_QL_FAN_ZONE_OFFSET              102
+#define CORSAIR_COMMANDER_CORE_NUM_CHANNELS     6
+
+enum
+{
+    CORSAIR_COMMANDER_CORE_MODE_DIRECT          = 0x00,
+};
+
+class CorsairCommanderCoreController
+{
+public:
+    CorsairCommanderCoreController(hid_device* dev_handle, const char* path);
+    ~CorsairCommanderCoreController();
+
+    std::string GetLocationString();
+
+    void        SetDirectColor
+                (
+                    std::vector<RGBColor>,
+                    std::vector<zone>
+                );
+
+    void        KeepaliveThread();
+    void        SetFanMode();
+
+private:
+    hid_device*             dev;
+    std::thread*            keepalive_thread;
+    std::atomic<bool>       keepalive_thread_run;
+    std::atomic<bool>       controller_ready;
+    std::string             location;
+    std::vector<RGBColor>   lastcolors;
+    std::vector<zone>       lastzones;
+    std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
+
+    void        SendMultiPkt
+                (
+                    unsigned char buffarray[][5],
+                    int r,
+                    int c
+                );
+
+    void        SendCommit();
+    void        InitController();
+};

Controllers/CorsairCommanderCoreController/CorsairCommanderCoreControllerDetect.cpp

@@ -0,0 +1,41 @@
+#include "Detector.h"
+#include "CorsairCommanderCoreController.h"
+#include "RGBController.h"
+#include "RGBController_CorsairCommanderCore.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Corsair vendor ID                                     |
+\*-----------------------------------------------------*/
+#define CORSAIR_VID                         0x1B1C
+
+/*-----------------------------------------------------*\
+| Commander Core product IDs                            |
+\*-----------------------------------------------------*/
+#define CORSAIR_H150I_COMMANDER_CORE_PID    0x0C1C
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCorsairCapellixControllers                                                       *
+*                                                                                          *
+*       Tests the USB address to see if a Corsair RGB Cooler controller exists there.      *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectCorsairCapellixHIDControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        CorsairCommanderCoreController*     controller     = new CorsairCommanderCoreController(dev, info->path);
+        RGBController_CorsairCommanderCore* rgb_controller = new RGBController_CorsairCommanderCore(controller);
+
+        rgb_controller->name = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR_PU("Corsair Commander Core",  DetectCorsairCapellixHIDControllers, CORSAIR_VID, CORSAIR_H150I_COMMANDER_CORE_PID, 0xFF42, 0x01);

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.cpp

@@ -0,0 +1,125 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairCapellix.cpp        |
+|                                           |
+|  Generic RGB Interface for Corsair        |
+|  Commander Core                           |
+|                                           |
+|  Jeff P.                                  |
+\*-----------------------------------------*/
+
+#include "RGBController_CorsairCommanderCore.h"
+
+RGBController_CorsairCommanderCore::RGBController_CorsairCommanderCore(CorsairCommanderCoreController* corsair_ptr)
+{
+    corsair     = corsair_ptr;
+
+    vendor      = "Corsair";
+    description = "Corsair Commander Core";
+    type        = DEVICE_TYPE_COOLER;
+    location    = corsair->GetLocationString();
+
+    SetupZones();
+
+    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);
+}
+
+RGBController_CorsairCommanderCore::~RGBController_CorsairCommanderCore()
+{
+    delete corsair;
+}
+
+void RGBController_CorsairCommanderCore::SetupZones()
+{
+    std::atomic<bool> first_run;
+    first_run = 0;
+
+    if(zones.size() == 0)
+    {
+        first_run = 1;
+    }
+
+    zones.resize(7);
+    zones[0].name                   = "Pump";
+    zones[0].type                   = ZONE_TYPE_LINEAR;
+    zones[0].leds_min               = 0;
+    zones[0].leds_max               = 29;
+
+    for(unsigned int i = 1; i < (CORSAIR_COMMANDER_CORE_NUM_CHANNELS + 1); i++)
+    {
+        zones[i].name               = "RGB Port " + std::to_string(i);
+        zones[i].type               = ZONE_TYPE_LINEAR;
+        zones[i].leds_min           = 0;
+        zones[i].leds_max           = 34;
+
+        if(first_run)
+        {
+            zones[i].leds_count = 0;
+        }
+    }
+
+    leds.clear();
+    colors.clear();
+
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        for (unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
+        {
+            led new_led;
+            new_led.name            = zones[zone_idx].name + " LED " + std::to_string(led_idx+1);
+
+            leds.push_back(new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_CorsairCommanderCore::ResizeZone(int zone, int new_size)
+{
+    if((size_t) zone >= zones.size())
+    {
+        return;
+    }
+
+    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    {
+        zones[zone].leds_count = new_size;
+
+        SetupZones();
+    }
+}
+
+void RGBController_CorsairCommanderCore::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_CorsairCommanderCore::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CorsairCommanderCore::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CorsairCommanderCore::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_CorsairCommanderCore::DeviceUpdateMode()
+{
+    switch(modes[active_mode].value)
+    {
+        case CORSAIR_COMMANDER_CORE_MODE_DIRECT:
+            corsair->SetDirectColor(colors, zones);
+            break;
+    }
+}

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairCapellix.h          |
+|                                           |
+|  Generic RGB Interface for Corsair        |
+|  Commander Core                           |
+|                                           |
+|  Jeff P.                                  |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CorsairCommanderCoreController.h"
+
+class RGBController_CorsairCommanderCore : public RGBController
+{
+public:
+    RGBController_CorsairCommanderCore(CorsairCommanderCoreController* corsair_ptr);
+    ~RGBController_CorsairCommanderCore();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    CorsairCommanderCoreController*     corsair;
+    std::vector<int>                    fanleds{0};
+};

Controllers/CorsairHydroController/CorsairHydroControllerDetect.cpp

@@ -47,16 +47,15 @@ static const corsair_hydro_device device_list[] =
 
 void DetectCorsairHydroControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    libusb_context * ctx;
-    libusb_init(&ctx);
+    libusb_init(NULL);
 
     #ifdef _WIN32
-    libusb_set_option(ctx, LIBUSB_OPTION_USE_USBDK);
+    libusb_set_option(NULL, LIBUSB_OPTION_USE_USBDK);
     #endif
 
     for(std::size_t device_idx = 0; device_idx < CORSAIR_NUM_DEVICES; device_idx++)
     {
-        libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+        libusb_device_handle * dev = libusb_open_device_with_vid_pid(NULL, device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
 
         //Look for Corsair RGB Peripheral
         if(dev)

Controllers/CorsairHydroPlatinumController/CorsairHydroPlatinumController.h

@@ -15,7 +15,7 @@
 #include <hidapi/hidapi.h>
 
 #define CORSAIR_HYDRO_PLATINUM_PACKET_SIZE 65
-#define CORSAIR_HYDRO_PLATINUM_PACKET_DELAY 3
+#define CORSAIR_HYDRO_PLATINUM_PACKET_DELAY 5
 
 enum
 {

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -64,7 +64,12 @@ std::string CorsairLightingNodeController::GetLocationString()
 std::string CorsairLightingNodeController::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());

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -48,6 +48,9 @@ static unsigned int keys_k95[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
 
 static unsigned int st100[] = { 0x00, 0x01, 0x02, 0x03, 0x05, 0x06, 0x07, 0x08, 0x04 };
 
+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 };
+
 CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle, const char* path)
 {
     dev         = dev_handle;
@@ -56,18 +59,18 @@ CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle,
     ReadFirmwareInfo();
 
     /*-----------------------------------------------------*\
-    | K95 Platinum requires additional steps                |
+    | K55 and K95 Platinum require additional steps         |
     \*-----------------------------------------------------*/
-    if (logical_layout == CORSAIR_TYPE_K95_PLAT)
+    if (logical_layout == CORSAIR_TYPE_K55 || logical_layout == CORSAIR_TYPE_K95_PLAT)
     {
         SpecialFunctionControl();
     }
 
     LightingControl();
 
-    if (logical_layout == CORSAIR_TYPE_K95_PLAT)
+    if (logical_layout == CORSAIR_TYPE_K55 || logical_layout == CORSAIR_TYPE_K95_PLAT)
     {
-        SetupK95LightingControl();
+        SetupK55AndK95LightingControl();
     }
 }
 
@@ -109,7 +112,12 @@ std::string CorsairPeripheralController::GetName()
 std::string CorsairPeripheralController::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());
@@ -229,7 +237,6 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
     SubmitKeyboardFullColors(3, 3, 2);
 }
 
-
 void CorsairPeripheralController::SetLEDsMouse(std::vector<RGBColor> colors)
 {
     SubmitMouseColors(colors.size(), &colors[0]);
@@ -367,7 +374,7 @@ void CorsairPeripheralController::LightingControl()
 | Probably a key mapping packet?                        |
 \*-----------------------------------------------------*/
 
-void CorsairPeripheralController::SetupK95LightingControl()
+void CorsairPeripheralController::SetupK55AndK95LightingControl()
 {
     char usb_buf[65];
 
@@ -391,7 +398,16 @@ void CorsairPeripheralController::SetupK95LightingControl()
     \*-----------------------------------------------------*/
     hid_write(dev, (unsigned char *)usb_buf, 65);
 
-    int identifier = 0;
+    unsigned int* skipped_identifiers = key_mapping_k95_plat_ansi;
+    int skipped_identifiers_count = sizeof(key_mapping_k95_plat_ansi) / sizeof(key_mapping_k95_plat_ansi[0]);
+    
+    if (physical_layout == CORSAIR_LAYOUT_ISO)
+    {
+        skipped_identifiers = key_mapping_k95_plat_iso;
+        skipped_identifiers_count = sizeof(key_mapping_k95_plat_iso) / sizeof(key_mapping_k95_plat_iso[0]);
+    }
+
+    unsigned int identifier = 0;
     for (int i = 0; i < 4; i++)
     {
         /*-----------------------------------------------------*\
@@ -409,11 +425,12 @@ void CorsairPeripheralController::SetupK95LightingControl()
 
         for (int j = 0; j < 30; j++)
         {
-            while (identifier == 0x31 || identifier == 0x41 || identifier == 0x42 || identifier == 0x48
-                || identifier == 0x49 || identifier == 0x51 || identifier == 0x55 || identifier == 0x6f
-                || identifier == 0x7e || identifier == 0x7f || identifier == 0x80 || identifier == 0x81)
+            for (int j = 0; j < skipped_identifiers_count; j++)
             {
-                identifier++;
+                if (identifier == skipped_identifiers[j])
+                {
+                    identifier++;
+                }
             }
 
             usb_buf[5 + 2 * j]      = identifier++;
@@ -522,7 +539,6 @@ void CorsairPeripheralController::ReadFirmwareInfo()
 
                     case 0x1B3D:
                     logical_layout = CORSAIR_TYPE_K55;
-                    SpecialFunctionControl();
                     break;
 
                     default:

Controllers/CorsairPeripheralController/CorsairPeripheralController.h

@@ -97,7 +97,7 @@ private:
     int                     logical_layout;    //Normal, K95 or K95 Platinum
 
     void    LightingControl();
-    void    SetupK95LightingControl();
+    void    SetupK55AndK95LightingControl();
     void    SpecialFunctionControl();
 
     void    ReadFirmwareInfo();

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -91,7 +91,7 @@ void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string
 /*-----------------------------------------------------------------------------------------------------*\
 | Keyboards                                                                                             |
 \*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID,           1, 0xFFC2); // Not per-key, disabled for now
+REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID,           1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K65 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_PID,           1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K65 LUX RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_LUX_RGB_PID,       1, 0xFFC2);
 REGISTER_HID_DETECTOR_IP("Corsair K65 RGB RAPIDFIRE",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_RAPIDFIRE_PID, 1, 0xFFC2);

Controllers/CorsairWirelessController/CorsairWirelessController.cpp

@@ -0,0 +1,222 @@
+/*-----------------------------------------*\
+|  CorsairWirelessController.cpp            |
+|                                           |
+|  Driver for Corsair RGB wireless keyboard |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/8/2021    |
+\*-----------------------------------------*/
+
+#include "CorsairWirelessController.h"
+
+#include <cstring>
+
+using namespace std::chrono_literals;
+
+CorsairWirelessController::CorsairWirelessController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+
+    type        = DEVICE_TYPE_KEYBOARD;
+
+    EnterDirectMode();
+}
+
+CorsairWirelessController::~CorsairWirelessController()
+{
+    hid_close(dev);
+}
+
+device_type CorsairWirelessController::GetDeviceType()
+{
+    return type;
+}
+
+std::string CorsairWirelessController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string CorsairWirelessController::GetFirmwareString()
+{
+    return firmware_version;
+}
+
+std::string CorsairWirelessController::GetName()
+{
+    return name;
+}
+
+std::string CorsairWirelessController::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 CorsairWirelessController::SetLEDs(std::vector<RGBColor>colors)
+{
+    unsigned char buf[3 * 137];
+
+    for(int color = 0; color < 137; color++)
+    {
+        buf[0 + color]   = RGBGetRValue(colors[color]);
+        buf[137 + color] = RGBGetGValue(colors[color]);
+        buf[274+color]   = RGBGetBValue(colors[color]);
+    }
+
+    StartDirectMode();
+
+    SendDirectFrame(true,  &buf[0]);
+    SendDirectFrame(false, &buf[57]);
+    SendDirectFrame(false, &buf[118]);
+    SendDirectFrame(false, &buf[179]);
+    SendDirectFrame(false, &buf[240]);
+    SendDirectFrame(false, &buf[301]);
+    SendDirectFrame(false, &buf[362]);
+}
+
+void CorsairWirelessController::SetLEDsKeyboardFull(std::vector<RGBColor> colors)
+{
+}
+
+void CorsairWirelessController::SetName(std::string device_name)
+{
+    name = device_name;
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void CorsairWirelessController::EnterDirectMode()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Submit Mouse Colors packet                     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x80;
+    usb_buf[0x02]   = 0x01;
+    usb_buf[0x03]   = 0x03;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = 0x02;
+
+    /*-----------------------------------------------------*\
+    | Send packet using feature reports, as headset stand   |
+    | seems to not update completely using HID writes       |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+}
+
+void CorsairWirelessController::StartDirectMode()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Submit Mouse Colors packet                     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x80;
+    usb_buf[0x02]   = 0x0D;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet using feature reports, as headset stand   |
+    | seems to not update completely using HID writes       |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+}
+
+void CorsairWirelessController::ExitDirectMode()
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Submit Mouse Colors packet                     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x80;
+    usb_buf[0x02]   = 0x01;
+    usb_buf[0x03]   = 0x03;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet using feature reports, as headset stand   |
+    | seems to not update completely using HID writes       |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+
+}
+
+void CorsairWirelessController::SendDirectFrame(bool first_frame, unsigned char* data)
+{
+    char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Submit Mouse Colors packet                     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x80;
+    usb_buf[0x02]   = first_frame ? 0x06 : 0x07;
+    usb_buf[0x03]   = 0x00;
+
+    if(first_frame)
+    {
+        usb_buf[0x04]   = 0x9B;
+        usb_buf[0x05]   = 0x01;
+    }
+
+    /*-----------------------------------------------------*\
+    | Copy in colors in <RED> <GREEN> <BLUE> order          |
+    \*-----------------------------------------------------*/
+    if(first_frame)
+    {
+        memcpy(&usb_buf[0x08], data, 57);
+    }
+    else
+    {
+        memcpy(&usb_buf[0x04], data, 61);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet using feature reports, as headset stand   |
+    | seems to not update completely using HID writes       |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 65);
+}

Controllers/CorsairWirelessController/CorsairWirelessController.h

@@ -0,0 +1,45 @@
+/*-----------------------------------------*\
+|  CorsairWirelessController.h              |
+|                                           |
+|  Definitions and types for Corsair RGB    |
+|  wireless keyboard lighting controller    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/8/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class CorsairWirelessController
+{
+public:
+    CorsairWirelessController(hid_device* dev_handle, const char* path);
+    ~CorsairWirelessController();
+
+    device_type     GetDeviceType();
+    std::string     GetDeviceLocation();
+    std::string     GetFirmwareString();
+    std::string     GetName();
+    std::string     GetSerialString();
+
+    void            SetLEDs(std::vector<RGBColor> colors);
+    void            SetLEDsKeyboardFull(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;
+
+    void            EnterDirectMode();
+    void            ExitDirectMode();
+    void            StartDirectMode();
+    void            SendDirectFrame(bool first_frame, unsigned char* data);
+};

Controllers/CorsairWirelessController/CorsairWirelessControllerDetect.cpp

@@ -0,0 +1,50 @@
+#include "Detector.h"
+#include "CorsairWirelessController.h"
+#include "RGBController.h"
+#include "RGBController_CorsairWireless.h"
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Corsair vendor ID                                     |
+\*-----------------------------------------------------*/
+#define CORSAIR_VID                     0x1B1C
+
+/*-----------------------------------------------------*\
+| Keyboard product IDs                                  |
+\*-----------------------------------------------------*/
+#define CORSAIR_K57_RGB_WIRED_PID       0x1B6E
+#define CORSAIR_K57_RGB_WIRELESS_PID    0x1B62
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCorsairWirelessControllers                                                       *
+*                                                                                          *
+*       Tests the USB address to see if a Corsair RGB Keyboard controller exists there.    *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectCorsairWirelessControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
+    {
+        CorsairWirelessController* controller = new CorsairWirelessController(dev, info->path);
+        controller->SetName(name);
+
+        if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
+        {
+            RGBController_CorsairWireless* rgb_controller = new RGBController_CorsairWireless(controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+        else
+        {
+            delete controller;
+        }
+    }
+}   /* DetectCorsairWirelessControllers() */
+
+/*-----------------------------------------------------------------------------------------------------*\
+| Keyboards                                                                                             |
+\*-----------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Corsair K57 RGB (Wired)",         DetectCorsairWirelessControllers,   CORSAIR_VID,    CORSAIR_K57_RGB_WIRED_PID,     1,  0xFF42, 1);
+//REGISTER_HID_DETECTOR_IPU("Corsair K57 RGB (Wireless)",      DetectCorsairWirelessControllers,   CORSAIR_VID,    CORSAIR_K57_RGB_WIRELESS_PID,  1,  0xFF42, 1);

Controllers/CorsairWirelessController/RGBController_CorsairWireless.cpp

@@ -0,0 +1,326 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairWireless.cpp        |
+|                                           |
+|  Generic RGB Interface for Corsair RGB    |
+|  wireless keyboard devices                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/8/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController_CorsairWireless.h"
+
+using namespace std::chrono_literals;
+
+//0xFFFFFFFF indicates an unused entry in matrix
+#define NA  0xFFFFFFFF
+
+static unsigned int matrix_map[7][24] =
+    { {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,   0,   1,  NA,  NA,  NA },
+      { 131,  41,  NA,  58,  59,  60,  61,  NA,  62,  63,  64,  65,  NA,  66,  67,  68,  69,  70,  71,  72,  NA,  NA,  NA,  NA },
+      { 132,  53,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  NA,  45,  46,  42,  NA,  73,  74,  75,  83,  84,  85,  86 },
+      { 133,  43,  NA,  20,  26,   8,  21,  NA,  23,  28,  24,  12,  18,  19,  47,  48,  49,  76,  77,  78,  95,  96,  97,  87 },
+      { 134,  57,  NA,   4,  22,   7,   9,  NA,  10,  11,  13,  14,  15,  51,  52,  NA,  40,  NA,  NA,  NA,  92,  93,  94,  NA },
+      { 135, 106,  NA,  29,  27,   6,  25,  NA,   5,  NA,  17,  16,  54,  55,  56, 110,  NA,  NA,  82,  NA,  89,  90,  91,  88 },
+      { 136, 105, 108, 107,  NA,  NA,  NA,  NA,  44,  NA,  NA,  NA,  NA, 111, 122, 101, 109,  80,  81,  79,  98,  NA,  99,  NA } };
+
+static const char* zone_names[] =
+{
+    "Keyboard",
+};
+
+static const unsigned int zone_sizes[] =
+{
+    137
+};
+
+static const zone_type zone_types[] =
+{
+    ZONE_TYPE_MATRIX,
+};
+
+static const char* led_names[] =
+{
+    "Power/Wireless Indicator",
+    "Lock/Macro Indicator",
+    "N/A",
+    "N/A",
+    "Key: A",
+    "Key: B",
+    "Key: C",
+    "Key: D",
+    "Key: E",
+    "Key: F",
+    "Key: G",
+    "Key: H",
+    "Key: I",
+    "Key: J",
+    "Key: K",
+    "Key: L",
+    "Key: M",
+    "Key: N",
+    "Key: O",
+    "Key: P",
+    "Key: Q",
+    "Key: R",
+    "Key: S",
+    "Key: T",
+    "Key: U",
+    "Key: V",
+    "Key: W",
+    "Key: X",
+    "Key: Y",
+    "Key: Z",
+    "Key: 1",
+    "Key: 2",
+    "Key: 3",
+    "Key: 4",
+    "Key: 5",
+    "Key: 6",
+    "Key: 7",
+    "Key: 8",
+    "Key: 9",
+    "Key: 0",
+    "Key: Enter",
+    "Key: Escape",
+    "Key: Backspace",
+    "Key: Tab",
+    "Key: Space",
+    "Key: -",
+    "Key: =",
+    "Key: [",
+    "Key: ]",
+    "Key: \\ (ANSI)",
+    "Unused",
+    "Key: ;",
+    "Key: '",
+    "Key: `",
+    "Key: ,",
+    "Key: .",
+    "Key: /",
+    "Key: Caps Lock",
+    "Key: F1",
+    "Key: F2",
+    "Key: F3",
+    "Key: F4",
+    "Key: F5",
+    "Key: F6",
+    "Key: F7",
+    "Key: F8",
+    "Key: F9",
+    "Key: F10",
+    "Key: F11",
+    "Key: F12",
+    "Key: Print Screen",
+    "Key: Scroll Lock",
+    "Key: Pause/Break",
+    "Key: Insert",
+    "Key: Home",
+    "Key: Page Up",
+    "Key: Delete",
+    "Key: End",
+    "Key: Page Down",
+    "Key: Right Arrow",
+    "Key: Left Arrow",
+    "Key: Down Arrow",
+    "Key: Up Arrow",
+    "Key: Num Lock",
+    "Key: Number Pad /",
+    "Key: Number Pad *",
+    "Key: Number Pad -",
+    "Key: Number Pad +",
+    "Key: Number Pad Enter",
+    "Key: Number Pad 1",
+    "Key: Number Pad 2",
+    "Key: Number Pad 3",
+    "Key: Number Pad 4",
+    "Key: Number Pad 5",
+    "Key: Number Pad 6",
+    "Key: Number Pad 7",
+    "Key: Number Pad 8",
+    "Key: Number Pad 9",
+    "Key: Number Pad 0",
+    "Key: Number Pad .",
+    "Unused",
+    "Key: Menu",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Left Control",
+    "Left Shift",
+    "Left Alt",
+    "Left Windows",
+    "Right Control",
+    "Right Shift",
+    "Right Alt",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Key: Right Fn",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Unused",
+    "Key: G1",
+    "Key: G2",
+    "Key: G3",
+    "Key: G4",
+    "Key: G5",
+    "Key: G6",
+};
+
+RGBController_CorsairWireless::RGBController_CorsairWireless(CorsairWirelessController* corsair_ptr)
+{
+    corsair = corsair_ptr;
+
+    name        = corsair->GetName();
+    vendor      = "Corsair";
+    description = "Corsair RGB Peripheral Device";
+    type        = corsair->GetDeviceType();
+    version     = corsair->GetFirmwareString();
+    location    = corsair->GetDeviceLocation();
+    serial      = corsair->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+
+    /*-----------------------------------------------------*\
+    | The Corsair Lighting Node Pro requires a packet within|
+    | 20 seconds of sending the lighting change in order    |
+    | to not revert back into rainbow mode.  Start a thread |
+    | to continuously send a keepalive packet every 5s      |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = 1;
+    keepalive_thread = new std::thread(&RGBController_CorsairWireless::KeepaliveThread, this);
+}
+
+RGBController_CorsairWireless::~RGBController_CorsairWireless()
+{
+    /*---------------------------------------------------------*\
+    | 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 corsair;
+}
+
+void RGBController_CorsairWireless::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Determine number of zones                                 |
+    |   For now, keyboard has 2 zones and mousemat has 1        |
+    \*---------------------------------------------------------*/
+    unsigned int num_zones = 1;
+
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    unsigned int total_led_count = 0;
+    for(unsigned int zone_idx = 0; zone_idx < num_zones; 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 += new_zone.leds_count;
+    }
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
+    {
+        led new_led;
+
+        new_led.name = led_names[led_idx];
+
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_CorsairWireless::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_CorsairWireless::DeviceUpdateLEDs()
+{
+    last_update_time = std::chrono::steady_clock::now();
+
+    corsair->SetLEDs(colors);
+}
+
+void RGBController_CorsairWireless::UpdateZoneLEDs(int /*zone*/)
+{
+    corsair->SetLEDs(colors);
+}
+
+void RGBController_CorsairWireless::UpdateSingleLED(int /*led*/)
+{
+    corsair->SetLEDs(colors);
+}
+
+void RGBController_CorsairWireless::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_CorsairWireless::DeviceUpdateMode()
+{
+
+}
+
+void RGBController_CorsairWireless::KeepaliveThread()
+{
+    while(keepalive_thread_run.load())
+    {
+        if(active_mode == 0)
+        {
+            if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(5000))
+            {
+                DeviceUpdateLEDs();
+            }
+        }
+        std::this_thread::sleep_for(1000ms);
+    }
+}

Controllers/CorsairWirelessController/RGBController_CorsairWireless.h

@@ -0,0 +1,41 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairWireless.h          |
+|                                           |
+|  Generic RGB Interface for Corsair RGB    |
+|  wireless keyboard devices                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/8/2021    |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CorsairWirelessController.h"
+
+class RGBController_CorsairWireless : public RGBController
+{
+public:
+    RGBController_CorsairWireless(CorsairWirelessController* corsair_ptr);
+    ~RGBController_CorsairWireless();
+
+    int         physical_layout;
+    int         logical_layout;
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+    void        KeepaliveThread();
+
+private:
+    CorsairWirelessController*      corsair;
+    std::thread*                    keepalive_thread;
+    std::atomic<bool>               keepalive_thread_run;
+    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
+};

Controllers/CreativeController/CreativeControllerDetect.cpp

@@ -0,0 +1,30 @@
+#include "CreativeSoundBlasterXG6Controller.h"
+#include "RGBController_CreativeSoundBlasterXG6.h"
+#include "Detector.h"
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Creative vendor ID                                    |
+\*-----------------------------------------------------*/
+#define CREATIVE_VID                            0x041E
+/*-----------------------------------------------------*\
+| SoundCards                                            |
+\*-----------------------------------------------------*/
+#define CREATIVE_SOUNDBLASTERX_G6_PID           0x3256
+
+void DetectCreativeDevice(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        CreativeSoundBlasterXG6Controller*     controller     = new CreativeSoundBlasterXG6Controller(dev, info->path);
+        RGBController_CreativeSoundBlasterXG6* rgb_controller = new RGBController_CreativeSoundBlasterXG6(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Sound Cards                                                                                                                                       |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_I("Creative SoundBlasterX G6",               DetectCreativeDevice,         CREATIVE_VID,     CREATIVE_SOUNDBLASTERX_G6_PID, 4);

Controllers/CreativeController/CreativeSoundBlasterXG6Controller.cpp

@@ -0,0 +1,82 @@
+#include "CreativeSoundBlasterXG6Controller.h"
+
+CreativeSoundBlasterXG6Controller::CreativeSoundBlasterXG6Controller(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+CreativeSoundBlasterXG6Controller::~CreativeSoundBlasterXG6Controller()
+{
+    hid_close(dev);
+}
+
+std::string CreativeSoundBlasterXG6Controller::GetDeviceLocation()
+{
+    return("HID " + location);
+}
+
+void CreativeSoundBlasterXG6Controller::SetLedColor (unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    //5A 3A 02 06 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+    usb_buf[0x01]           = 0x5A;
+    usb_buf[0x02]           = 0x3A;
+    usb_buf[0x03]           = 0x02;
+    usb_buf[0x04]           = 0x06;
+    usb_buf[0x05]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 64);
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    //5A 3A 06 04 00 03 01 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+    usb_buf[0x01]           = 0x5A;
+    usb_buf[0x02]           = 0x3A;
+    usb_buf[0x03]           = 0x06;
+    usb_buf[0x04]           = 0x04;
+    usb_buf[0x06]           = 0x03;
+    usb_buf[0x07]           = 0x01;
+    usb_buf[0x09]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 64);
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    //5A 3A 09 0A 00 03 01 01 FF BB GG RR
+    usb_buf[0x01]           = 0x5A;
+    usb_buf[0x02]           = 0x3A;
+    usb_buf[0x03]           = 0x09;
+    usb_buf[0x04]           = 0x0A;
+    usb_buf[0x06]           = 0x03;
+    usb_buf[0x07]           = 0x01;
+    usb_buf[0x08]           = 0x01;
+    usb_buf[0x09]           = 0x0FF;
+
+    usb_buf[0x0A]           = blue;
+    usb_buf[0x0B]           = green;
+    usb_buf[0x0C]           = red;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 64);
+}

Controllers/CreativeController/CreativeSoundBlasterXG6Controller.h

@@ -0,0 +1,20 @@
+#include "RGBController.h"
+#include <cstring>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class CreativeSoundBlasterXG6Controller
+{
+public:
+    CreativeSoundBlasterXG6Controller(hid_device* dev_handle, const char* path);
+    ~CreativeSoundBlasterXG6Controller();
+    void            SetLedColor (unsigned char red, unsigned char green, unsigned char blue);
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+private:
+    hid_device*             dev;
+    std::string             location;
+};

Controllers/CreativeController/RGBController_CreativeSoundBlasterXG6.cpp

@@ -0,0 +1,81 @@
+#include "RGBController_CreativeSoundBlasterXG6.h"
+
+RGBController_CreativeSoundBlasterXG6::RGBController_CreativeSoundBlasterXG6(CreativeSoundBlasterXG6Controller* creative_device)
+{
+    creative    = creative_device;
+
+    name        = "Creative SoundBlasterX G6 Device";
+    vendor      = "Creative";
+    type        = DEVICE_TYPE_HEADSET;
+    description = "Creative SoundBlasterX G6 Device";
+    location    = creative_device->GetDeviceLocation();
+    serial      = "";
+
+    mode Static;
+    Static.name                     = "Direct";
+    Static.value                    = 0;
+    Static.flags                    = MODE_COLORS_PER_LED;
+    Static.color_mode               = MODE_COLORS_PER_LED;
+    modes.push_back(Static);
+
+    SetupZones();
+}
+
+RGBController_CreativeSoundBlasterXG6::~RGBController_CreativeSoundBlasterXG6()
+{
+    delete creative;
+}
+
+void RGBController_CreativeSoundBlasterXG6::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;
+    zones.push_back(logo_zone);
+
+    led logo_led;
+    logo_led.name = "Logo";
+    leds.push_back(logo_led);
+
+    SetupColors();
+}
+
+void RGBController_CreativeSoundBlasterXG6::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_CreativeSoundBlasterXG6::DeviceUpdateLEDs()
+{
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+
+    creative->SetLedColor(red, grn, blu);
+}
+
+void RGBController_CreativeSoundBlasterXG6::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CreativeSoundBlasterXG6::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CreativeSoundBlasterXG6::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_CreativeSoundBlasterXG6::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}

Controllers/CreativeController/RGBController_CreativeSoundBlasterXG6.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "RGBController.h"
+#include "CreativeSoundBlasterXG6Controller.h"
+
+class RGBController_CreativeSoundBlasterXG6: public RGBController
+{
+public:
+    RGBController_CreativeSoundBlasterXG6(CreativeSoundBlasterXG6Controller* creative_device);
+    ~RGBController_CreativeSoundBlasterXG6();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    CreativeSoundBlasterXG6Controller*   creative;
+};

Controllers/DasKeyboardController/DasKeyboardController.cpp

@@ -38,7 +38,7 @@ std::string DasKeyboardController::GetSerialString()
     int     err                = hid_get_serial_number_string(dev, serial_string, 128);
 
     std::string return_string;
-    if(!err)
+    if(err == 0)
     {
         std::wstring return_wstring = serial_string;
         return_string = std::string(return_wstring.begin(), return_wstring.end());

Controllers/DuckyKeyboardController/DuckyKeyboardController.cpp

@@ -31,7 +31,12 @@ std::string DuckyKeyboardController::GetDeviceLocation()
 std::string DuckyKeyboardController::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());

Controllers/DuckyKeyboardController/RGBController_DuckyKeyboard.cpp

@@ -16,8 +16,8 @@ static unsigned int matrix_map[6][23] =
     { {   0,  NA,  12,  18,  24,  30,  NA,  42,  48,  54,  60,  NA,  66,  72,  78,  84,  90,  96, 102, 108, 114, 120, 126 },
       {   1,   7,  13,  19,  25,  31,  37,  43,  49,  55,  61,  NA,  67,  73,  85,  NA,  91,  97, 103, 109, 115, 121, 127 },
       {   2,  NA,   8,  14,  20,  26,  NA,  32,  38,  44,  50,  56,  62,  68,  74,  86,  92,  98, 104, 110, 116, 122, 128 },
-      {   3,  NA,   9,  15,  21,  27,  NA,  33,  39,  45,  51,  57,  63,  69,  87,  NA,  NA,  NA,  NA, 111, 117, 123,  NA },
-      {   4,  NA,  16,  22,  28,  34,  NA,  40,  NA,  46,  52,  58,  64,  70,  82,  NA,  NA, 100,  NA, 112, 118, 124, 131 },
+      {   3,  NA,   9,  15,  21,  27,  NA,  33,  39,  45,  51,  57,  63,  69,  75,  87,  NA,  NA,  NA, 111, 117, 123,  NA },
+      {   4,  10,  16,  22,  28,  34,  NA,  40,  NA,  46,  52,  58,  64,  70,  82,  NA,  NA, 100,  NA, 112, 118, 124, 131 },
       {   5,  11,  17,  NA,  NA,  NA,  NA,  41,  NA,  NA,  NA,  NA,  65,  77,  83,  89,  95, 101, 107, 113,  NA, 125,  NA } };
 
 static const char* zone_names[] =
@@ -47,7 +47,7 @@ static const char *led_names[] =
     "Key: 1",
     "Key: Q",
     "Key: A",
-    "Unused",
+    "Key: \\ (ISO)",
     "Key: Left Windows",
     "Key: F1",
     "Key: 2",
@@ -112,7 +112,7 @@ static const char *led_names[] =
     "Key: F10",
     "Key: =",
     "Key: ]",
-    "Unused",
+    "Key: #",
     "Unused",
     "Key: Right Windows",
     "Key: F11",

Controllers/E131Controller/RGBController_E131.cpp

@@ -293,9 +293,13 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
 
 RGBController_E131::~RGBController_E131()
 {
-    keepalive_thread_run = 0;
-    keepalive_thread->join();
-    delete keepalive_thread;
+    if(keepalive_thread != nullptr)
+    {
+        keepalive_thread_run = 0;
+        keepalive_thread->join();
+        delete keepalive_thread;
+    }
+
     /*---------------------------------------------------------*\
     | Delete the matrix map                                     |
     \*---------------------------------------------------------*/

Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp

@@ -41,6 +41,7 @@ static const gpu_pci_device device_list[] =
     { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_GAMING_SUB_DEV,         EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Gaming"         },
     { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_ULTRA_GAMING_SUB_DEV,   EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC Ultra Gaming"   },
     { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_XC_ULTRA_GAMING_SUB_DEV, EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti XC Ultra"        },
+    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080TI_FTW3_ULTRA_SUB_DEV     , EVGA_RGB_V2,    "EVGA GeForce RTX 2080Ti FTW3 Ultra"      },
 
 };
 

Controllers/EVGAGPUController/RGBController_EVGAGPUv2.cpp

@@ -124,6 +124,8 @@ int RGBController_EVGAGPUv2::getModeIndex(unsigned char mode_value)
             return mode_index;
         }
     }
+
+    return 0;
 }
 
 void RGBController_EVGAGPUv2::SetupZones()
@@ -182,7 +184,7 @@ void RGBController_EVGAGPUv2::UpdateSingleLED(int /*led*/)
 
 void RGBController_EVGAGPUv2::SetCustomMode()
 {
-    active_mode = getModeIndex(EVGA_GPU_V2_MODE_DIRECT);
+    active_mode = getModeIndex(EVGA_GPU_V2_RGB_MODE_DIRECT);
 }
 
 void RGBController_EVGAGPUv2::DeviceUpdateMode()

Controllers/EVisionKeyboardController/EVisionKeyboardController.cpp

@@ -33,7 +33,12 @@ std::string EVisionKeyboardController::GetDeviceLocation()
 std::string EVisionKeyboardController::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());

Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp

@@ -24,7 +24,7 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectEVisionKeyboards(hid_device_info* info, const std::string& name)
+void DetectEVisionKeyboards(hid_device_info* info, const std::string& /*name*/)
 {
     hid_device* dev = hid_open_path(info->path);
     if( dev )
@@ -43,4 +43,4 @@ REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5204",  DetectEVisionKeyboards,
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5104",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   REDRAGON_K552_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5004",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   REDRAGON_K556_PID,         1, EVISION_KEYBOARD_USAGE_PAGE);
 REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:652F",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   TECWARE_PHANTOM_ELITE_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
-REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:8520",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   WARRIOR_KANE_TC235,        1, EVISION_KEYBOARD_USAGE_PAGE);
+REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:8520",  DetectEVisionKeyboards, EVISION_KEYBOARD_VID,   WARRIOR_KANE_TC235,        1, EVISION_KEYBOARD_USAGE_PAGE);

Controllers/FanBusController/FanBusInterface.cpp

@@ -113,7 +113,7 @@ void FanBusInterface::write_queue
 {
     unsigned char fanbus_msg[] = { 0x00, int_addr, dev_addr, val, 0xFF };
 
-    for(int i = 0; i < sizeof(fanbus_msg); i++)
+    for(unsigned int i = 0; i < sizeof(fanbus_msg); i++)
     {
         fanbus_msg_queued.push_back(fanbus_msg[i]);
     }

Controllers/FanBusController/RGBController_FanBus.cpp

@@ -43,7 +43,7 @@ void RGBController_FanBus::SetupZones()
     led_zone.matrix_map = NULL;
     zones.push_back(led_zone);
 
-    for(int led_idx = 0; led_idx < led_zone.leds_count; led_idx++)
+    for(unsigned int led_idx = 0; led_idx < led_zone.leds_count; led_idx++)
     {
         led new_led;
         new_led.name = "LED ";

Controllers/GainwardGPUController/GainwardGPUControllerDetect.cpp

@@ -41,6 +41,7 @@ typedef struct
 static const gpu_pci_device device_list[] =
 {
     { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,     GAINWARD_SUB_VEN,       GAINWARD_GTX_1080_PHOENIX,     RGB_V1,     "Gainward GTX 1080 Phoenix"             },
+    { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,    GAINWARD_SUB_VEN,       NVIDIA_RTX2070S_DEV,           RGB_V2,     "Gainward RTX 2070 Super Phantom"       },
     { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,     GAINWARD_SUB_VEN,       NVIDIA_RTX3070_DEV,            RGB_V2,     "Gainward RTX 3070 Phoenix"             },
 };
 

Controllers/GigabyteAorusCPUCoolerController/ATC800Controller.cpp

@@ -30,7 +30,12 @@ std::string ATC800Controller::GetDeviceLocation()
 std::string ATC800Controller::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());

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUController.cpp

@@ -36,6 +36,15 @@ void RGBFusionGPUController::SetColor(unsigned char red, unsigned char green, un
     bus->i2c_smbus_write_byte(dev, red);
     bus->i2c_smbus_write_byte(dev, green);
     bus->i2c_smbus_write_byte(dev, blue);
+
+    // Pad commands with 4 zero-bytes for NVIDIA_RTX3060_DEV
+    if (dev == 0x62)
+    {
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+    }
 }
 
 void RGBFusionGPUController::SetMode(unsigned char mode, unsigned char speed)
@@ -44,4 +53,13 @@ void RGBFusionGPUController::SetMode(unsigned char mode, unsigned char speed)
     bus->i2c_smbus_write_byte(dev, mode);
     bus->i2c_smbus_write_byte(dev, speed);
     bus->i2c_smbus_write_byte(dev, 0x63);
+
+    // Pad commands with 4 zero-bytes for NVIDIA_RTX3060_DEV
+    if (dev == 0x62)
+    {
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+        bus->i2c_smbus_write_byte(dev, 0x00);
+    }
 }

Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUControllerDetect.cpp

@@ -34,14 +34,16 @@ static const gpu_pci_device device_list[] =
     { NVIDIA_VEN,   NVIDIA_GTX1650_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_GTX1650_GAMING_OC_SUB_DEV,             0x55,   "Gigabyte GTX1650 Gaming OC"                    },
     { NVIDIA_VEN,   NVIDIA_GTX1660S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_GTX1660S_GAMING_OC_SUB_DEV,            0x47,   "Gigabyte GTX1660 SUPER Gaming OC"              },
     { NVIDIA_VEN,   NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_SUB_DEV,             0x47,   "Gigabyte RTX2060 Gaming OC"                    },
-    { NVIDIA_VEN,   NVIDIA_RTX2060S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_SUB_DEV,               0x47,   "Gigabyte RTX2060 SUPER Gaming"                 },
+    { NVIDIA_VEN,   NVIDIA_RTX2060_TU106_DEV,   GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060_GAMING_OC_PRO_SUB_DEV,         0x47,   "Gigabyte RTX2060 Gaming OC PRO"                },
+    { NVIDIA_VEN,   NVIDIA_RTX2060S_OC_DEV,     GIGABYTE_SUB_VEN,   GIGABYTE_RTX2060S_GAMING_SUB_DEV,               0x47,   "Gigabyte RTX2060 SUPER Gaming"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070_GAMING_OC_SUB_DEV,             0x47,   "Gigabyte RTX2070 Gaming OC 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070_WINDFORCE_SUB_DEV,             0x47,   "Gigabyte RTX2070 Windforce 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_SUB_DEV,            0x47,   "Gigabyte RTX2070S Gaming OC"                   },
     { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX2070S_GAMING_OC_3X_SUB_DEV,         0x55,   "Gigabyte RTX2070S Gaming OC 3X"                },
     { NVIDIA_VEN,   NVIDIA_RTX2080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080_GAMING_OC_SUB_DEV,             0x47,   "Gigabyte RTX2080 Gaming OC 8G"                 },
     { NVIDIA_VEN,   NVIDIA_RTX2080_A_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX2080_A_GAMING_OC_SUB_DEV,           0x47,   "Gigabyte RTX2080 Gaming OC 8G"                 },
-    { NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_EAGLE_OC_SUB_DEV,            0x63,   "Gigabyte RTX3060 EAGLE OC 8G"                  },
+    { NVIDIA_VEN,   NVIDIA_RTX3060_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060_GAMING_OC_12GB_SUB_DEV,        0x62,   "Gigabyte RTX3060 Gaming OC 12G"                },
+    { NVIDIA_VEN,   NVIDIA_RTX3060TI_DEV,       GIGABYTE_SUB_VEN,   GIGABYTE_RTX3060TI_EAGLE_OC_SUB_DEV,            0x63,   "Gigabyte RTX3060 Ti EAGLE OC 8G"               },
     { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX3070_VISION_OC_SUB_DEV,             0x63,   "Gigabyte RTX3070 Vision 8G"                    },
 };
 
@@ -67,6 +69,15 @@ bool TestForGigabyteRGBFusionGPUController(i2c_smbus_interface* bus, unsigned ch
         bus->i2c_smbus_write_byte(address, 0x00);
         bus->i2c_smbus_write_byte(address, 0x00);
         bus->i2c_smbus_write_byte(address, 0x00);
+        
+        // NVIDIA_RTX3060_DEV requires additional bytes to initialise
+        if (address == 0x62)
+        {
+            bus->i2c_smbus_write_byte(address, 0x00);
+            bus->i2c_smbus_write_byte(address, 0x00);
+            bus->i2c_smbus_write_byte(address, 0x00);
+            bus->i2c_smbus_write_byte(address, 0x00);
+        }
 
         pass = true;
 

Controllers/HoltekController/HoltekA070Controller.cpp

@@ -29,7 +29,12 @@ std::string HoltekA070Controller::GetDeviceLocation()
 std::string HoltekA070Controller::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());

Controllers/HoltekController/HoltekA1FAController.cpp

@@ -30,7 +30,12 @@ std::string HoltekA1FAController::GetDeviceLocation()
 std::string HoltekA1FAController::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());

Controllers/HoltekController/RGBController_HoltekA1FA.cpp

@@ -129,7 +129,7 @@ void RGBController_HoltekA1FA::DeviceUpdateMode()
     if((active_mode < HOLTEK_A1FA_MODE_NEON) && (previous_mode < HOLTEK_A1FA_MODE_NEON))
     {
         //If we're switching from and to static and breathing then sync the mode colors
-        for ( int i = 0; i < modes[active_mode].colors_max; i++)
+        for(unsigned int i = 0; i < modes[active_mode].colors_max; i++)
         {
            modes[active_mode].colors[i] = modes[previous_mode].colors[i];
         }

Controllers/HyperXKeyboardController/HyperXAlloyElite2Controller.cpp

@@ -35,7 +35,12 @@ std::string HyperXAlloyElite2Controller::GetDeviceLocation()
 std::string HyperXAlloyElite2Controller::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());

Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.cpp

@@ -33,7 +33,12 @@ std::string HyperXAlloyOriginsController::GetDeviceLocation()
 std::string HyperXAlloyOriginsController::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());

Controllers/HyperXKeyboardController/HyperXKeyboardController.cpp

@@ -46,7 +46,12 @@ std::string HyperXKeyboardController::GetDeviceLocation()
 std::string HyperXKeyboardController::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());

Controllers/HyperXMouseController/HyperXPulsefireDartController.cpp

@@ -30,7 +30,12 @@ std::string HyperXPulsefireDartController::GetDeviceLocation()
 std::string HyperXPulsefireDartController::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());

Controllers/HyperXMouseController/HyperXPulsefireFPSProController.cpp

@@ -30,7 +30,12 @@ std::string HyperXPulsefireFPSProController::GetDeviceLocation()
 std::string HyperXPulsefireFPSProController::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());

Controllers/HyperXMouseController/HyperXPulsefireSurgeController.cpp

@@ -30,7 +30,12 @@ std::string HyperXPulsefireSurgeController::GetDeviceLocation()
 std::string HyperXPulsefireSurgeController::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());

Controllers/HyperXMousematController/HyperXMousematController.cpp

@@ -30,7 +30,12 @@ std::string HyperXMousematController::GetDeviceLocation()
 std::string HyperXMousematController::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());

Controllers/LEDStripController/LEDStripController.cpp

@@ -184,7 +184,7 @@ void LEDStripController::SetLEDsKeyboardVisualizer(std::vector<RGBColor> colors)
     \*-------------------------------------------------------------*/
     unsigned short sum          = 0;
 
-    for (int i = 0; i < (payload_size + 1); i++)
+    for(unsigned int i = 0; i < (payload_size + 1); i++)
     {
         sum += serial_buf[i];
     }
@@ -317,4 +317,4 @@ void LEDStripController::SetLEDsTPM2(std::vector<RGBColor> colors)
     }
 
     delete[] serial_buf;
-}
+}

Controllers/LianLiController/LianLiControllerDetect.cpp

@@ -0,0 +1,75 @@
+/*-----------------------------------------*\
+|  LianLiControllerDetect.cpp               |
+|                                           |
+|  Detector for Lian Li Uni Hub USB         |
+|  lighting controller                      |
+|                                           |
+|  Luca Lovisa 2/20/2021                    |
+\*-----------------------------------------*/
+
+#include <string>
+#include <vector>
+
+#include "Detector.h"
+#include "LianLiUniHubController.h"
+#include "RGBController_LianLiUniHub.h"
+#include "ResourceManager.h"
+
+#include <libusb-1.0/libusb.h>
+
+#define UNI_HUB_VID 0x0CF2
+#define UNI_HUB_PID 0x7750
+
+/*----------------------------------------------------------------------------*\
+| The Uni Hub is controlled by sending control transfers to various wIndex     |
+| addresses, allthough it announces some kind of hid interface. Hence it       |
+| requires libusb as hidapi provides no wIndex customization.                  |
+\*----------------------------------------------------------------------------*/
+
+void DetectLianLiUniHub(std::vector<RGBController*>&)
+{
+    libusb_device** devices = nullptr;
+
+    int ret;
+
+    ret = libusb_init(NULL);
+    if(ret < 0)
+    {
+        return;
+    }
+
+    ret = libusb_get_device_list(NULL, &devices);
+    if(ret < 0)
+    {
+        return;
+    }
+
+    int deviceCount = ret;
+
+    for(int i = 0; i < deviceCount; i++)
+    {
+        libusb_device* device = devices[i];
+        libusb_device_descriptor descriptor;
+        ret = libusb_get_device_descriptor(device, &descriptor);
+
+        if (ret < 0)
+        {
+            continue;
+        }
+
+        if( descriptor.idVendor  == UNI_HUB_VID
+         && descriptor.idProduct == UNI_HUB_PID)
+        {
+            LianLiUniHubController*     controller     = new LianLiUniHubController(device, &descriptor);
+            RGBController_LianLiUniHub* rgb_controller = new RGBController_LianLiUniHub(controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+    }
+
+    if(devices != nullptr)
+    {
+        libusb_free_device_list(devices, 1);
+    }
+}
+
+REGISTER_DETECTOR("Lian Li Uni Hub", DetectLianLiUniHub);

Controllers/LianLiController/LianLiUniHubController.cpp

@@ -0,0 +1,700 @@
+/*-----------------------------------------*\
+|  LianLiUniHubController.cpp               |
+|                                           |
+|  Driver for Lian Li Uni Hub USB           |
+|  lighting controller                      |
+|                                           |
+|  Luca Lovisa 2/20/2021                    |
+\*-----------------------------------------*/
+
+#include "LianLiUniHubController.h"
+
+#include <cstring>
+
+using namespace std::chrono_literals;
+
+/*----------------------------------------------------------------------------*\
+| The Uni Hub is controlled by sending control transfers to various wIndex     |
+| addresses, allthough it announces some kind of hid interface. Hence it       |
+| requires libusb as hidapi provides no wIndex customization.                  |
+\*----------------------------------------------------------------------------*/
+
+LianLiUniHubController::LianLiUniHubController
+    (
+    libusb_device*              device,
+    libusb_device_descriptor*   descriptor
+    )
+{
+    int ret;
+
+    /*--------------------------------------------------------------------*\
+    | Open the libusb device.                                              |
+    \*--------------------------------------------------------------------*/
+    ret = libusb_open(device, &handle);
+
+    if(ret < 0)
+    {
+        return;
+    }
+
+    /*--------------------------------------------------------------------*\
+    | Fill in the location string from USB port numbers.                   |
+    \*--------------------------------------------------------------------*/
+    uint8_t ports[7];
+
+    ret = libusb_get_port_numbers(device, ports, sizeof(ports));
+
+    if(ret > 0)
+    {
+        location = "USB: ";
+
+        for (int i = 0; i < ret; i ++)
+        {
+            location += std::to_string(ports[i]);
+            location.push_back(':');
+        }
+
+        location.pop_back();
+    }
+
+    /*--------------------------------------------------------------------*\
+    | Fill in the serial string from the string descriptor                 |
+    \*--------------------------------------------------------------------*/
+    char serialStr[64];
+
+    ret = libusb_get_string_descriptor_ascii(handle, descriptor->iSerialNumber, reinterpret_cast<unsigned char*>(serialStr), sizeof(serialStr));
+
+    if(ret > 0)
+    {
+        serial = std::string(serialStr, ret);
+    }
+
+    /*--------------------------------------------------------------------*\
+    | Fill in the version string by reading version from device.           |
+    \*--------------------------------------------------------------------*/
+    version = ReadVersion();
+
+    /*--------------------------------------------------------------------*\
+    | Create channels with their static configuration and "sane" defaults. |
+    \*--------------------------------------------------------------------*/
+    Channel channel1;
+    channel1.index                = 0;
+    channel1.anyFanCountOffset    = UNIHUB_ANY_C1_FAN_COUNT_OFFSET;
+    channel1.anyFanCount          = UNIHUB_ANY_FAN_COUNT_001;
+    channel1.ledActionAddress     = UNIHUB_LED_C1_ACTION_ADDRESS;
+    channel1.ledCommitAddress     = UNIHUB_LED_C1_COMMIT_ADDRESS;
+    channel1.ledModeAddress       = UNIHUB_LED_C1_MODE_ADDRESS;
+    channel1.ledSpeedAddress      = UNIHUB_LED_C1_SPEED_ADDRESS;
+    channel1.ledDirectionAddress  = UNIHUB_LED_C1_DIRECTION_ADDRESS;
+    channel1.ledBrightnessAddress = UNIHUB_LED_C1_BRIGHTNESS_ADDRESS;
+    channel1.ledMode              = UNIHUB_LED_MODE_RAINBOW;
+    channel1.ledSpeed             = UNIHUB_LED_SPEED_100;
+    channel1.ledDirection         = UNIHUB_LED_DIRECTION_LTR;
+    channel1.ledBrightness        = UNIHUB_LED_BRIGHTNESS_100;
+    channel1.fanHubActionAddress  = UNIHUB_FAN_C1_HUB_ACTION_ADDRESS;
+    channel1.fanHubCommitAddress  = UNIHUB_FAN_C1_HUB_COMMIT_ADDRESS;
+    channel1.fanPwmActionAddress  = UNIHUB_FAN_C1_PWM_ACTION_ADDRESS;
+    channel1.fanPwmCommitAddress  = UNIHUB_FAN_C1_PWM_COMMIT_ADDRESS;
+    channel1.fanRpmActionAddress  = UNIHUB_FAN_C1_RPM_ACTION_ADDRESS;
+    channel1.fanSpeed             = UNIHUB_FAN_SPEED_QUIET;
+    channels[0] = channel1;
+
+    Channel channel2;
+    channel2.index                = 1;
+    channel2.anyFanCountOffset    = UNIHUB_ANY_C2_FAN_COUNT_OFFSET;
+    channel2.anyFanCount          = UNIHUB_ANY_FAN_COUNT_001;
+    channel2.ledActionAddress     = UNIHUB_LED_C2_ACTION_ADDRESS;
+    channel2.ledCommitAddress     = UNIHUB_LED_C2_COMMIT_ADDRESS;
+    channel2.ledModeAddress       = UNIHUB_LED_C2_MODE_ADDRESS;
+    channel2.ledSpeedAddress      = UNIHUB_LED_C2_SPEED_ADDRESS;
+    channel2.ledDirectionAddress  = UNIHUB_LED_C2_DIRECTION_ADDRESS;
+    channel2.ledBrightnessAddress = UNIHUB_LED_C2_BRIGHTNESS_ADDRESS;
+    channel2.ledMode              = UNIHUB_LED_MODE_RAINBOW;
+    channel2.ledSpeed             = UNIHUB_LED_SPEED_100;
+    channel2.ledDirection         = UNIHUB_LED_DIRECTION_LTR;
+    channel2.ledBrightness        = UNIHUB_LED_BRIGHTNESS_100;
+    channel2.fanHubActionAddress  = UNIHUB_FAN_C2_HUB_ACTION_ADDRESS;
+    channel2.fanHubCommitAddress  = UNIHUB_FAN_C2_HUB_COMMIT_ADDRESS;
+    channel2.fanPwmActionAddress  = UNIHUB_FAN_C2_PWM_ACTION_ADDRESS;
+    channel2.fanPwmCommitAddress  = UNIHUB_FAN_C2_PWM_COMMIT_ADDRESS;
+    channel2.fanRpmActionAddress  = UNIHUB_FAN_C2_RPM_ACTION_ADDRESS;
+    channel2.fanSpeed             = UNIHUB_FAN_SPEED_QUIET;
+    channels[1] = channel2;
+
+    Channel channel3;
+    channel3.index                = 2;
+    channel3.anyFanCountOffset    = UNIHUB_ANY_C3_FAN_COUNT_OFFSET;
+    channel3.anyFanCount          = UNIHUB_ANY_FAN_COUNT_001;
+    channel3.ledActionAddress     = UNIHUB_LED_C3_ACTION_ADDRESS;
+    channel3.ledCommitAddress     = UNIHUB_LED_C3_COMMIT_ADDRESS;
+    channel3.ledModeAddress       = UNIHUB_LED_C3_MODE_ADDRESS;
+    channel3.ledSpeedAddress      = UNIHUB_LED_C3_SPEED_ADDRESS;
+    channel3.ledDirectionAddress  = UNIHUB_LED_C3_DIRECTION_ADDRESS;
+    channel3.ledBrightnessAddress = UNIHUB_LED_C3_BRIGHTNESS_ADDRESS;
+    channel3.ledMode              = UNIHUB_LED_MODE_RAINBOW;
+    channel3.ledSpeed             = UNIHUB_LED_SPEED_100;
+    channel3.ledDirection         = UNIHUB_LED_DIRECTION_LTR;
+    channel3.ledBrightness        = UNIHUB_LED_BRIGHTNESS_100;
+    channel3.fanHubActionAddress  = UNIHUB_FAN_C3_HUB_ACTION_ADDRESS;
+    channel3.fanHubCommitAddress  = UNIHUB_FAN_C3_HUB_COMMIT_ADDRESS;
+    channel3.fanPwmActionAddress  = UNIHUB_FAN_C3_PWM_ACTION_ADDRESS;
+    channel3.fanPwmCommitAddress  = UNIHUB_FAN_C3_PWM_COMMIT_ADDRESS;
+    channel3.fanRpmActionAddress  = UNIHUB_FAN_C3_RPM_ACTION_ADDRESS;
+    channel3.fanSpeed             = UNIHUB_FAN_SPEED_QUIET;
+    channels[2] = channel3;
+
+    Channel channel4;
+    channel4.index                = 3;
+    channel4.anyFanCountOffset    = UNIHUB_ANY_C4_FAN_COUNT_OFFSET;
+    channel4.anyFanCount          = UNIHUB_ANY_FAN_COUNT_001;
+    channel4.ledActionAddress     = UNIHUB_LED_C4_ACTION_ADDRESS;
+    channel4.ledCommitAddress     = UNIHUB_LED_C4_COMMIT_ADDRESS;
+    channel4.ledModeAddress       = UNIHUB_LED_C4_MODE_ADDRESS;
+    channel4.ledSpeedAddress      = UNIHUB_LED_C4_SPEED_ADDRESS;
+    channel4.ledDirectionAddress  = UNIHUB_LED_C4_DIRECTION_ADDRESS;
+    channel4.ledBrightnessAddress = UNIHUB_LED_C4_BRIGHTNESS_ADDRESS;
+    channel4.ledMode              = UNIHUB_LED_MODE_RAINBOW;
+    channel4.ledSpeed             = UNIHUB_LED_SPEED_100;
+    channel4.ledDirection         = UNIHUB_LED_DIRECTION_LTR;
+    channel4.ledBrightness        = UNIHUB_LED_BRIGHTNESS_100;
+    channel4.fanHubActionAddress  = UNIHUB_FAN_C4_HUB_ACTION_ADDRESS;
+    channel4.fanHubCommitAddress  = UNIHUB_FAN_C4_HUB_COMMIT_ADDRESS;
+    channel4.fanPwmActionAddress  = UNIHUB_FAN_C4_PWM_ACTION_ADDRESS;
+    channel4.fanPwmCommitAddress  = UNIHUB_FAN_C4_PWM_COMMIT_ADDRESS;
+    channel4.fanRpmActionAddress  = UNIHUB_FAN_C4_RPM_ACTION_ADDRESS;
+    channel4.fanSpeed             = UNIHUB_FAN_SPEED_QUIET;
+    channels[3] = channel4;
+}
+
+LianLiUniHubController::~LianLiUniHubController()
+{
+    CloseLibusb();
+}
+
+std::string LianLiUniHubController::GetVersion()
+{
+    return version;
+}
+
+std::string LianLiUniHubController::GetLocation()
+{
+    return location;
+}
+
+std::string LianLiUniHubController::GetSerial()
+{
+    return serial;
+}
+
+void LianLiUniHubController::SetAnyFanCount(size_t channel, uint8_t count)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_CHANNEL_COUNT)
+    {
+        return;
+    }
+
+    channels[channel].anyFanCount = count;
+}
+
+void LianLiUniHubController::SetLedColors(size_t channel, RGBColor* colors, size_t count)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_CHANNEL_COUNT)
+    {
+        return;
+    }
+
+    /*-------------------------------------*\
+    | Check for invalid count               |
+    \*-------------------------------------*/
+    if(count > UNIHUB_CHANLED_COUNT)
+    {
+        count = UNIHUB_CHANLED_COUNT;
+    }
+
+    size_t i = 0;
+    for(; i < count; i++)
+    {
+        channels[channel].colors[i].r = RGBGetRValue(colors[i]);
+        channels[channel].colors[i].b = RGBGetBValue(colors[i]);
+        channels[channel].colors[i].g = RGBGetGValue(colors[i]);
+    }
+
+    /* Set all remaining leds to black */
+    for(; i < UNIHUB_CHANLED_COUNT; i++)
+    {
+        channels[channel].colors[i].r = 0x00;
+        channels[channel].colors[i].b = 0x00;
+        channels[channel].colors[i].g = 0x00;
+    }
+}
+
+void LianLiUniHubController::SetLedMode(size_t channel, uint8_t mode)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_CHANNEL_COUNT)
+    {
+        return;
+    }
+
+    channels[channel].ledMode = mode;
+}
+
+void LianLiUniHubController::SetLedSpeed(size_t channel, uint8_t speed)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_CHANNEL_COUNT)
+    {
+        return;
+    }
+
+    channels[channel].ledSpeed = speed;
+}
+
+void LianLiUniHubController::SetLedDirection(size_t channel, uint8_t direction)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_CHANNEL_COUNT)
+    {
+        return;
+    }
+
+    channels[channel].ledDirection = direction;
+}
+
+void LianLiUniHubController::SetLedBrightness(size_t channel, uint8_t brightness)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_CHANNEL_COUNT)
+    {
+        return;
+    }
+
+    channels[channel].ledBrightness = brightness;
+}
+
+uint16_t LianLiUniHubController::GetFanSpeed(size_t channel)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_CHANNEL_COUNT)
+    {
+        return 0;
+    }
+
+    return channels[channel].fanSpeed;
+}
+
+void LianLiUniHubController::SetFanSpeed(size_t channel, uint16_t speed)
+{
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel >= UNIHUB_CHANNEL_COUNT)
+    {
+        return;
+    }
+
+    channels[channel].fanSpeed = speed;
+}
+
+void LianLiUniHubController::EnableRgbhMode()
+{
+    rgbhModeEnabled = true;
+}
+
+void LianLiUniHubController::DisableRgbhMode()
+{
+    rgbhModeEnabled = false;
+}
+
+void LianLiUniHubController::EnableSyncMode()
+{
+    syncModeEnabled = true;
+}
+
+void LianLiUniHubController::DisableSyncMode()
+{
+    syncModeEnabled = false;
+}
+
+/*----------------------------------------------------------------------------*\
+| The Uni Hub is a PWM and LED controller designed specifically for the Lian   |
+| Li Uni Fans. It can control them by itself using the built-in effect engine  |
+| can also be connected to the mainboard via 4-pin PWM and 3-pin RGB cables    |
+| and forward these signals. The protocol implementation below was build as    |
+| close a possible to the Lian Li L-Connect software.                          |
+|                                                                              |
+| The commands to control the fan speeds and to switch between controller and  |
+| mainboard control is already included, but currently deactivated as OpenRGB  |
+| had no fan control module or controller specific configuration at the time   |
+| of writing.                                                                  |
+\*----------------------------------------------------------------------------*/
+void LianLiUniHubController::Synchronize()
+{
+    /*---------------------------------------------------------------------*\
+    | Configure common settings.                                            |
+    \*---------------------------------------------------------------------*/
+
+    /*---------------------------------------------------------------------*\
+    | Still unsure about this. Probably some sort of configuration          |
+    | initialization                                                        |
+    \*---------------------------------------------------------------------*/
+    uint8_t config_initialization[1] = { 0x34 };
+
+    SendConfig(UNIHUB_ACTION_ADDRESS, config_initialization, sizeof(config_initialization));
+    SendCommit(UNIHUB_COMMIT_ADDRESS);
+
+    for(const Channel& channel : channels)
+    {
+        /*-------------------------------------*\
+        | The Uni Hub doesn't know zero fans    |
+        \*-------------------------------------*/
+        uint8_t anyFanCount = channel.anyFanCount;
+
+        if(anyFanCount == UNIHUB_ANY_FAN_COUNT_000)
+        {
+            anyFanCount =  UNIHUB_ANY_FAN_COUNT_001;
+        }
+
+        /*-------------------------------------*\
+        | Configure the physical fan count      |
+        \*-------------------------------------*/
+        uint8_t config_fan_count[2] = { 0x32, (uint8_t)(channel.anyFanCountOffset | anyFanCount) };
+
+        SendConfig(UNIHUB_ACTION_ADDRESS, config_fan_count, sizeof(config_fan_count));
+        SendCommit(UNIHUB_COMMIT_ADDRESS);
+    }
+
+    /*--------------------------------------------------------------------*\
+    | Configure channels for sync effects                                  |
+    \*--------------------------------------------------------------------*/
+    if(syncModeEnabled)
+    {
+        uint8_t config_sync[6];
+        uint8_t config_sync_index = 0;
+
+        config_sync[config_sync_index++] = 0x33;
+
+        for(const Channel& channel : channels)
+        {
+            if(channel.anyFanCount != UNIHUB_ANY_FAN_COUNT_000)
+            {
+                config_sync[config_sync_index++] = channel.index;
+            }
+        }
+
+        config_sync[config_sync_index++] = 0x08;
+
+        SendConfig(UNIHUB_ACTION_ADDRESS, config_sync, config_sync_index);
+        SendCommit(UNIHUB_COMMIT_ADDRESS);
+    }
+
+    /*--------------------------------------------------------------------*\
+    | Configure led settings.                                              |
+    \*--------------------------------------------------------------------*/
+    for(const Channel& channel : channels)
+    {
+        if(channel.anyFanCount != UNIHUB_ANY_FAN_COUNT_000)
+        {
+            /*-----------------------------*\
+            | Configure led colors          |
+            \*-----------------------------*/
+            uint8_t config_colors[192];
+            memcpy(config_colors, channel.colors, sizeof(config_colors));
+
+            /*-----------------------------*\
+            | No idea what this does ...    |
+            \*-----------------------------*/
+            if (syncModeEnabled)
+            {
+                config_colors[0x06] = 0x66;
+                config_colors[0x07] = 0x33;
+                config_colors[0x08] = 0xCC;
+
+                memset(config_colors + 0x09, 0x00, sizeof(config_colors) - 0x09);
+            }
+
+            SendConfig(channel.ledActionAddress, config_colors, sizeof(config_colors));
+
+            /*-----------------------------*\
+            | Configure led mode            |
+            \*-----------------------------*/
+            uint8_t config_mode[1] = { channel.ledMode };
+
+            SendConfig(channel.ledModeAddress, config_mode, sizeof(config_mode));
+        }
+        /*-----------------------------------------------------------------*\
+        | The Uni Hub doesn't know zero fans so we set them to black        |
+        \*-----------------------------------------------------------------*/
+        else
+        {
+            /*-----------------------------*\
+            | Configure led colors          |
+            \*-----------------------------*/
+            uint8_t config_colors[192];
+            memset(config_colors, 0x00, sizeof(config_colors));
+
+            SendConfig(channel.ledActionAddress, config_colors, sizeof(config_colors));
+
+            /*-----------------------------*\
+            | Configure led mode            |
+            \*-----------------------------*/
+            uint8_t config_mode[1] = { UNIHUB_LED_MODE_STATIC_COLOR };
+
+            SendConfig(channel.ledModeAddress, config_mode, sizeof(config_mode));
+        }
+
+        /*---------------------------------*\
+        | Configure led speed               |
+        \*---------------------------------*/
+        uint8_t config_speed[1] = { channel.ledSpeed };
+
+        SendConfig(channel.ledSpeedAddress, config_speed, sizeof(config_speed));
+
+        /*---------------------------------*\
+        | Configure led direction           |
+        \*---------------------------------*/
+        uint8_t config_direction[1] = { channel.ledDirection };
+
+        SendConfig(channel.ledDirectionAddress, config_direction, sizeof(config_direction));
+
+        /*---------------------------------*\
+        | Configure led brightness          |
+        \*---------------------------------*/
+        uint8_t config_brightness[1] = { channel.ledBrightness };
+
+        SendConfig(channel.ledBrightnessAddress, config_brightness, sizeof(config_brightness));
+
+        /*---------------------------------*\
+        | Commit only once for all led      |
+        | settings                          |
+        \*---------------------------------*/
+        SendCommit(channel.ledCommitAddress);
+    }
+
+    /*--------------------------------------------------------------------*\
+    | Configure fan settings. Comment out until enabling fan control       |
+    \*--------------------------------------------------------------------*/
+//    uint8_t control = 0;
+
+//    /*-------------------------------------*\
+//    | Configure fan settings                |
+//    \*-------------------------------------*/
+//    for(const Channel& channel : channels)
+//    {
+//        if(channel.fanSpeed == UNIHUB_FAN_SPEED_PWM)
+//        {
+//            /*-----------------------------*\
+//            | Configure the fan to pwm      |
+//            | control                       |
+//            \*-----------------------------*/
+//            uint8_t config_pwm[1] = { 0x00 };
+
+//            control |= (0x01 << channel.index);
+
+//            SendConfig(channel.fanPwmActionAddress, config_pwm, sizeof(config_pwm));
+//            SendCommit(channel.fanPwmCommitAddress);
+//        }
+//        else
+//        {
+//            /*-----------------------------*\
+//            | Configure the fan to hub      |
+//            | control and set speed         |
+//            \*-----------------------------*/
+//            uint8_t config_hub[2] = { (uint8_t)(channel.fanSpeed >> 0x08), (uint8_t)(channel.fanSpeed &  0xFF) };
+
+//            SendConfig(channel.fanHubActionAddress, config_hub, sizeof(config_hub));
+//            SendCommit(channel.fanHubCommitAddress);
+//        }
+//    }
+
+//    /*-------------------------------------*\
+//    | Configure fan control modes           |
+//    \*-------------------------------------*/
+//    uint8_t config_fan_mode[2] = { 0x31, (uint8_t)(0xF0 | control) };
+
+//    SendConfig(UNIHUB_ACTION_ADDRESS, config_fan_mode, sizeof(config_fan_mode));
+//    SendCommit(UNIHUB_COMMIT_ADDRESS);
+
+    /*--------------------------------------------------------------------*\
+    | Configure led settings.                                              |
+    \*--------------------------------------------------------------------*/
+    if(rgbhModeEnabled)
+    {
+        /*-------------------------------------*\
+        | Configure the leds to hdr control.    |
+        \*-------------------------------------*/
+        uint8_t config_hdr[2] = { 0x30, 0x01 };
+
+        SendConfig(UNIHUB_ACTION_ADDRESS, config_hdr, sizeof(config_hdr));
+        SendCommit(UNIHUB_COMMIT_ADDRESS);
+    }
+    else
+    {
+        /*-------------------------------------*\
+        | Configure the leds to hub control     |
+        \*-------------------------------------*/
+        uint8_t config_hub[2] = { 0x30, 0x00 };
+
+        SendConfig(UNIHUB_ACTION_ADDRESS, config_hub, sizeof(config_hub));
+        SendCommit(UNIHUB_COMMIT_ADDRESS);
+    }
+}
+
+uint16_t LianLiUniHubController::ReadFanSpeed(size_t channel)
+{
+    /*-------------------------------------*\
+    | Check for invalid handle              |
+    \*-------------------------------------*/
+    if(handle == nullptr)
+    {
+        return(0);
+    }
+
+    /*-------------------------------------*\
+    | Check for invalid channel             |
+    \*-------------------------------------*/
+    if(channel > UNIHUB_CHANNEL_COUNT)
+    {
+        return(0);
+    }
+
+    uint8_t buffer[2];
+    uint8_t length = sizeof(buffer);
+
+    uint16_t wIndex = channels[channel].fanRpmActionAddress;
+
+    /*-------------------------------------*\
+    | Send packet                           |
+    \*-------------------------------------*/
+    size_t ret = libusb_control_transfer(handle,    /* dev_handle       */
+                                         0xC0,      /* bmRequestType    */
+                                         0x81,      /* bRequest         */
+                                         0x00,      /* wValue           */
+                                         wIndex,    /* wIndex           */
+                                         buffer,    /* data             */
+                                         length,    /* wLength          */
+                                         1000);     /* timeout          */
+
+    /*-------------------------------------*\
+    | Check for communication error         |
+    \*-------------------------------------*/
+    if(ret != length)
+    {
+        return(0);
+    }
+
+    return(*(uint16_t*)buffer);
+}
+
+void LianLiUniHubController::CloseLibusb()
+{
+    if (handle != nullptr)
+    {
+        libusb_close(handle);
+        handle = nullptr;
+    }
+}
+
+std::string LianLiUniHubController::ReadVersion()
+{
+    /*-------------------------------------*\
+    | Check for invalid handle              |
+    \*-------------------------------------*/
+    if(handle == nullptr)
+    {
+        return("");
+    }
+
+    uint8_t buffer[5];
+    uint8_t length = sizeof(buffer);
+
+    /*-------------------------------------*\
+    | Send packet                           |
+    \*-------------------------------------*/
+    size_t ret = libusb_control_transfer(handle,    /* dev_handle       */
+                                         0xC0,      /* bmRequestType    */
+                                         0x81,      /* bRequest         */
+                                         0x00,      /* wValue           */
+                                         0xB500,    /* wIndex           */
+                                         buffer,    /* data             */
+                                         length,    /* wLength          */
+                                         1000);     /* timeout          */
+
+    /*-------------------------------------*\
+    | Check for communication error         |
+    \*-------------------------------------*/
+    if(ret != length)
+    {
+        return("");
+    }
+
+    /*-------------------------------------*\
+    | Format version string                 |
+    \*-------------------------------------*/
+    char version[14];
+    int  vlength = std::snprintf(version, sizeof(version), "%x.%x.%x.%x.%x", buffer[0], buffer[1], buffer[2], buffer[3], buffer[4]);
+
+    return(std::string(version, vlength));
+}
+
+void LianLiUniHubController::SendConfig(uint16_t wIndex, uint8_t  *config, size_t length)
+{
+    /*-------------------------------------*\
+    | Check for invalid handle              |
+    \*-------------------------------------*/
+    if(handle == nullptr)
+    {
+        return;
+    }
+
+    /*-------------------------------------*\
+    | Send packet                           |
+    \*-------------------------------------*/
+    size_t ret = libusb_control_transfer(handle,    /* dev_handle       */
+                                         0x40,      /* bmRequestType    */
+                                         0x80,      /* bRequest         */
+                                         0x00,      /* wValue           */
+                                         wIndex,    /* wIndex           */
+                                         config,    /* data             */
+                                         length,    /* wLength          */
+                                         1000);     /* timeout          */
+
+    /*-------------------------------------*\
+    | Check for communication error         |
+    \*-------------------------------------*/
+    if(ret != length)
+    {
+        return;
+    }
+}
+
+void LianLiUniHubController::SendCommit(uint16_t wIndex)
+{
+    /*-------------------------------------*\
+    | Set up config packet                  |
+    \*-------------------------------------*/
+    uint8_t config[1] = { 0x01 };
+
+    /*-------------------------------------*\
+    | Send packet                           |
+    \*-------------------------------------*/
+    SendConfig(wIndex, config, sizeof(config));
+
+    std::this_thread::sleep_for(5ms);
+}

Controllers/LianLiController/LianLiUniHubController.h

@@ -0,0 +1,263 @@
+/*-----------------------------------------*\
+|  LianLiUniHubController.h                 |
+|                                           |
+|  Definitions and types for Lian Li Uni    |
+|  Hub USB RGB lighting controller          |
+|                                           |
+|  Luca Lovisa 2/20/2021                    |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include <cstdint>
+#include <mutex>
+#include <string>
+
+#include "RGBController.h"
+
+#include <libusb-1.0/libusb.h>
+
+/*----------------------------------------------------------------------------*\
+| Global definitions.                                                          |
+\*----------------------------------------------------------------------------*/
+
+enum
+{
+    UNIHUB_CHANNEL_COUNT              = 0x04,   /* Channel count              */
+    UNIHUB_CHANLED_COUNT              = 0x40,   /* Max-LED per channel count  */
+};
+
+enum
+{
+    UNIHUB_ACTION_ADDRESS             = 0xe021, /* Global action address      */
+    UNIHUB_COMMIT_ADDRESS             = 0xe02f, /* Global commit address      */
+};
+
+enum
+{
+    UNIHUB_ANY_C1_FAN_COUNT_OFFSET    = 0x00,   /* Channel 1 fan count offset */
+    UNIHUB_ANY_C2_FAN_COUNT_OFFSET    = 0x10,   /* Channel 2 fan count offset */
+    UNIHUB_ANY_C3_FAN_COUNT_OFFSET    = 0x20,   /* Channel 3 fan count offset */
+    UNIHUB_ANY_C4_FAN_COUNT_OFFSET    = 0x30,   /* Channel 4 fan count offset */
+};
+
+enum
+{
+    UNIHUB_ANY_FAN_COUNT_000          = 0xFF,   /* Fan count for 0 fans (dummy value) */
+    UNIHUB_ANY_FAN_COUNT_001          = 0x00,   /* Fan count for 1 fan        */
+    UNIHUB_ANY_FAN_COUNT_002          = 0x01,   /* Fan count for 2 fans       */
+    UNIHUB_ANY_FAN_COUNT_003          = 0x02,   /* Fan count for 3 fans       */
+    UNIHUB_ANY_FAN_COUNT_004          = 0x03,   /* Fan count for 4 fans       */
+};
+
+/*----------------------------------------------------------------------------*\
+| Definitions related to led configuration.                                    |
+\*----------------------------------------------------------------------------*/
+
+enum
+{
+    UNIHUB_LED_C1_ACTION_ADDRESS      = 0xe300, /* Channel 1 led action address     */
+    UNIHUB_LED_C1_COMMIT_ADDRESS      = 0xe02f, /* Channel 1 led commit address     */
+    UNIHUB_LED_C1_MODE_ADDRESS        = 0xe021, /* Channel 1 led mode address       */
+    UNIHUB_LED_C1_SPEED_ADDRESS       = 0xe022, /* Channel 1 led speed address      */
+    UNIHUB_LED_C1_DIRECTION_ADDRESS   = 0xe023, /* Channel 1 led direction address  */
+    UNIHUB_LED_C1_BRIGHTNESS_ADDRESS  = 0xe029, /* Channel 1 led brightness address */
+
+    UNIHUB_LED_C2_ACTION_ADDRESS      = 0xe3c0, /* Channel 2 led action address     */
+    UNIHUB_LED_C2_COMMIT_ADDRESS      = 0xe03f, /* Channel 2 led commit address     */
+    UNIHUB_LED_C2_MODE_ADDRESS        = 0xe031, /* Channel 2 led mode address       */
+    UNIHUB_LED_C2_SPEED_ADDRESS       = 0xe032, /* Channel 2 led speed address      */
+    UNIHUB_LED_C2_DIRECTION_ADDRESS   = 0xe033, /* Channel 2 led direction address  */
+    UNIHUB_LED_C2_BRIGHTNESS_ADDRESS  = 0xe039, /* Channel 2 led brightness address */
+
+    UNIHUB_LED_C3_ACTION_ADDRESS      = 0xe480, /* Channel 3 led action address     */
+    UNIHUB_LED_C3_COMMIT_ADDRESS      = 0xe04f, /* Channel 3 led commit address     */
+    UNIHUB_LED_C3_MODE_ADDRESS        = 0xe041, /* Channel 3 led mode address       */
+    UNIHUB_LED_C3_SPEED_ADDRESS       = 0xe042, /* Channel 3 led speed address      */
+    UNIHUB_LED_C3_DIRECTION_ADDRESS   = 0xe043, /* Channel 3 led direction address  */
+    UNIHUB_LED_C3_BRIGHTNESS_ADDRESS  = 0xe049, /* Channel 3 led brightness address */
+
+    UNIHUB_LED_C4_ACTION_ADDRESS      = 0xe540, /* Channel 4 led action address     */
+    UNIHUB_LED_C4_COMMIT_ADDRESS      = 0xe05f, /* Channel 4 led commit address     */
+    UNIHUB_LED_C4_MODE_ADDRESS        = 0xe051, /* Channel 4 led mode address       */
+    UNIHUB_LED_C4_SPEED_ADDRESS       = 0xe052, /* Channel 4 led speed address      */
+    UNIHUB_LED_C4_DIRECTION_ADDRESS   = 0xe053, /* Channel 4 led direction address  */
+    UNIHUB_LED_C4_BRIGHTNESS_ADDRESS  = 0xe059, /* Channel 4 led brightness address */
+};
+
+enum
+{
+    UNIHUB_LED_MODE_RAINBOW           = 0x05,   /* Rainbow mode            */
+    UNIHUB_LED_MODE_STATIC_COLOR      = 0x01,   /* Static Color mode       */
+    UNIHUB_LED_MODE_BREATHING         = 0x02,   /* Breathing mode          */
+    UNIHUB_LED_MODE_COLOR_CYCLE       = 0x04,   /* Color Cycle mode        */
+    UNIHUB_LED_MODE_RUNWAY            = 0x1c,   /* Runway mode             */
+    UNIHUB_LED_MODE_RUNWAY_SYNC       = 0x1c,   /* Runway Sync mode        */
+    UNIHUB_LED_MODE_STAGGGERED        = 0x18,   /* Stagggered mode         */
+    UNIHUB_LED_MODE_MIXING            = 0x1a,   /* Mixing mode             */
+    UNIHUB_LED_MODE_METEOR            = 0x07,   /* Meteor mode             */
+    UNIHUB_LED_MODE_METEOR_SYNC       = 0x07,   /* Meteor Sync mode        */
+    UNIHUB_LED_MODE_FIREWORK          = 0x1f,   /* Firework mode           */
+    UNIHUB_LED_MODE_STACK             = 0x21,   /* Stack mode              */
+    UNIHUB_LED_MODE_STACK_MULTI_COLOR = 0x22,   /* Stack Multi Color mode  */
+    UNIHUB_LED_MODE_NEON              = 0x23,   /* Neon mode               */
+};
+
+enum
+{
+    UNIHUB_LED_SPEED_000              = 0x04,   /* Very slow speed         */
+    UNIHUB_LED_SPEED_025              = 0x03,   /* Rather slow speed       */
+    UNIHUB_LED_SPEED_050              = 0x02,   /* Medium speed            */
+    UNIHUB_LED_SPEED_075              = 0x01,   /* Rather fast speed       */
+    UNIHUB_LED_SPEED_100              = 0x00,   /* Very fast speed         */
+};
+
+enum
+{
+    UNIHUB_LED_DIRECTION_LTR          = 0x00,   /* Left-to-Right direction */
+    UNIHUB_LED_DIRECTION_RTL          = 0x01,   /* Right-to-Left direction */
+};
+
+enum
+{
+    UNIHUB_LED_BRIGHTNESS_000         = 0x08,   /* Very dark (off)         */
+    UNIHUB_LED_BRIGHTNESS_025         = 0x03,   /* Rather dark             */
+    UNIHUB_LED_BRIGHTNESS_050         = 0x02,   /* Medium bright           */
+    UNIHUB_LED_BRIGHTNESS_075         = 0x01,   /* Rather bright           */
+    UNIHUB_LED_BRIGHTNESS_100         = 0x00,   /* Very bright             */
+};
+
+/*----------------------------------------------------------------------------*\
+| Definitions related to fan configuration.                                    |
+\*----------------------------------------------------------------------------*/
+
+enum
+{
+    UNIHUB_FAN_C1_HUB_ACTION_ADDRESS  = 0xe8a0, /* Channel 1 fan action address for hub control */
+    UNIHUB_FAN_C1_HUB_COMMIT_ADDRESS  = 0xe890, /* Channel 1 fan commit address for hub control */
+    UNIHUB_FAN_C1_PWM_ACTION_ADDRESS  = 0xe890, /* Channel 1 fan action address for pwm control */
+    UNIHUB_FAN_C1_PWM_COMMIT_ADDRESS  = 0xe818, /* Channel 1 fan commit address for pwm control */
+    UNIHUB_FAN_C1_RPM_ACTION_ADDRESS  = 0xe800, /* Channel 1 fan pwm read address               */
+
+    UNIHUB_FAN_C2_HUB_ACTION_ADDRESS  = 0xe8a2, /* Channel 2 fan action address for hub control */
+    UNIHUB_FAN_C2_HUB_COMMIT_ADDRESS  = 0xe891, /* Channel 2 fan commit address for hub control */
+    UNIHUB_FAN_C2_PWM_ACTION_ADDRESS  = 0xe891, /* Channel 2 fan action address for pwm control */
+    UNIHUB_FAN_C2_PWM_COMMIT_ADDRESS  = 0xe81a, /* Channel 2 fan commit address for pwm control */
+    UNIHUB_FAN_C2_RPM_ACTION_ADDRESS  = 0xe802, /* Channel 1 fan pwm read address               */
+
+    UNIHUB_FAN_C3_HUB_ACTION_ADDRESS  = 0xe8a4, /* Channel 3 fan action address for hub control */
+    UNIHUB_FAN_C3_HUB_COMMIT_ADDRESS  = 0xe892, /* Channel 3 fan commit address for hub control */
+    UNIHUB_FAN_C3_PWM_ACTION_ADDRESS  = 0xe892, /* Channel 3 fan action address for pwm control */
+    UNIHUB_FAN_C3_PWM_COMMIT_ADDRESS  = 0xe81c, /* Channel 3 fan commit address for pwm control */
+    UNIHUB_FAN_C3_RPM_ACTION_ADDRESS  = 0xe804, /* Channel 1 fan pwm read address               */
+
+    UNIHUB_FAN_C4_HUB_ACTION_ADDRESS  = 0xe8a6, /* Channel 4 fan action address for hub control */
+    UNIHUB_FAN_C4_HUB_COMMIT_ADDRESS  = 0xe893, /* Channel 4 fan commit address for hub control */
+    UNIHUB_FAN_C4_PWM_ACTION_ADDRESS  = 0xe893, /* Channel 4 fan action address for pwm control */
+    UNIHUB_FAN_C4_PWM_COMMIT_ADDRESS  = 0xe81e, /* Channel 4 fan commit address for pwm control */
+    UNIHUB_FAN_C4_RPM_ACTION_ADDRESS  = 0xe806, /* Channel 1 fan pwm read address               */
+};
+
+enum
+{
+    UNIHUB_FAN_SPEED_QUIET            = 0x2003, /* Rather slow */
+    UNIHUB_FAN_SPEED_HIGH_SPEED       = 0x2206, /* Rather fast */
+    UNIHUB_FAN_SPEED_FULL_SPEED       = 0x6c07, /* BRRRRRRRRRR */
+    UNIHUB_FAN_SPEED_PWM              = 0xffff, /* PWM Control */
+};
+
+/*----------------------------------------------------------------------------*\
+| Uni Hub controller.                                                          |
+\*----------------------------------------------------------------------------*/
+
+class LianLiUniHubController
+{
+private:
+    /* The Uni Hub requires colors in RBG order */
+    struct Color
+    {
+        uint8_t r;
+        uint8_t b;
+        uint8_t g;
+    };
+
+    /* The values correspond to the definitions above */
+    struct Channel
+    {
+        uint8_t  index;
+
+        uint8_t  anyFanCountOffset;
+        uint8_t  anyFanCount;
+
+        uint16_t ledActionAddress;
+        uint16_t ledCommitAddress;
+        uint16_t ledModeAddress;
+        uint16_t ledSpeedAddress;
+        uint16_t ledDirectionAddress;
+        uint16_t ledBrightnessAddress;
+
+        Color    colors[UNIHUB_CHANLED_COUNT];
+
+        uint8_t  ledMode;
+        uint8_t  ledSpeed;
+        uint8_t  ledDirection;
+        uint8_t  ledBrightness;
+
+        uint16_t fanHubActionAddress;
+        uint16_t fanHubCommitAddress;
+
+        uint16_t fanPwmActionAddress;
+        uint16_t fanPwmCommitAddress;
+        uint16_t fanRpmActionAddress;
+
+        uint16_t fanSpeed;
+    };
+
+public:
+    LianLiUniHubController
+        (
+        libusb_device*              device,
+        libusb_device_descriptor*   descriptor
+        );
+    ~LianLiUniHubController();
+
+    std::string GetVersion();
+    std::string GetLocation();
+    std::string GetSerial();
+
+    void        SetAnyFanCount(size_t channel, uint8_t count);
+    void        SetLedColors(size_t channel, RGBColor* colors, size_t count);
+    void        SetLedMode(size_t channel, uint8_t mode);
+    void        SetLedSpeed(size_t channel, uint8_t speed);
+    void        SetLedDirection(size_t channel, uint8_t direction);
+    void        SetLedBrightness(size_t channel, uint8_t brightness);
+    uint16_t    GetFanSpeed(size_t channel);
+    void        SetFanSpeed(size_t channel, uint16_t speed);
+    void        EnableRgbhMode();
+    void        DisableRgbhMode();
+    void        EnableSyncMode();
+    void        DisableSyncMode();
+    uint16_t    ReadFanSpeed(size_t channel);
+
+    /*-----------------------------------------------------*\
+    | Synchronize the current configuration to the Uni Hub. |
+    \*-----------------------------------------------------*/
+    void        Synchronize();
+
+private:
+    libusb_device_handle* handle = nullptr;
+
+    std::string version;
+    std::string location;
+    std::string serial;
+
+    bool rgbhModeEnabled = false;
+    bool syncModeEnabled = false;
+
+    Channel channels[UNIHUB_CHANNEL_COUNT];
+
+    void        CloseLibusb();
+    std::string ReadVersion();
+    void        SendConfig(uint16_t wIndex, uint8_t  *config, size_t length);
+    void        SendCommit(uint16_t wIndex);
+};

Controllers/LianLiController/RGBController_LianLiUniHub.cpp

@@ -0,0 +1,475 @@
+/*-----------------------------------------*\
+|  RGBController_LianLiUniHub.cpp           |
+|                                           |
+|  Generic RGB Interface for Lian Li Uni    |
+|  Hub USB controller driver                |
+|                                           |
+|  Luca Lovisa 2/20/2021                    |
+\*-----------------------------------------*/
+
+#include "RGBController_LianLiUniHub.h"
+
+#include <string>
+
+mode makeMode()
+{
+  mode Mode;
+
+  Mode.value      = 0;
+  Mode.flags      = 0;
+  Mode.speed_min  = 0;
+  Mode.speed_max  = 0;
+  Mode.colors_min = 0;
+  Mode.colors_max = 0;
+  Mode.speed      = 0;
+  Mode.direction  = 0;
+  Mode.color_mode = 0;
+
+  return Mode;
+}
+
+RGBController_LianLiUniHub::RGBController_LianLiUniHub(LianLiUniHubController* uniHub_ptr)
+{
+    uniHub      = uniHub_ptr;
+
+    name        = "Lian Li Uni Hub";
+    vendor      = "Lian Li";
+    version     = uniHub->GetVersion();
+    type        = DEVICE_TYPE_COOLER;
+    description = "Lian Li Uni Hub";
+    location    = uniHub->GetLocation();
+    serial      = uniHub->GetSerial();
+
+    initializedMode = false;
+
+    mode StaticColor       = makeMode();
+    StaticColor.name       = "Custom";
+    StaticColor.value      = UNIHUB_LED_MODE_STATIC_COLOR;
+    StaticColor.flags      = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
+    StaticColor.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(StaticColor);
+
+    mode Rainbow       = makeMode();
+    Rainbow.name       = "Rainbow Wave";
+    Rainbow.value      = UNIHUB_LED_MODE_RAINBOW;
+    Rainbow.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
+    Rainbow.speed_min  = 1;
+    Rainbow.speed_max  = 5;
+    Rainbow.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Rainbow);
+
+    mode Breathing       = makeMode();
+    Breathing.name       = "Breathing";
+    Breathing.value      = UNIHUB_LED_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.speed_min  = 1;
+    Breathing.speed_max  = 5;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Breathing);
+
+    mode ColorCycle       = makeMode();
+    ColorCycle.name       = "Color Cycle";
+    ColorCycle.value      = UNIHUB_LED_MODE_COLOR_CYCLE;
+    ColorCycle.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    ColorCycle.speed_min  = 1;
+    ColorCycle.speed_max  = 5;
+    ColorCycle.colors_min = 3;
+    ColorCycle.colors_max = 3;
+    ColorCycle.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorCycle.colors.resize(3);
+    modes.push_back(ColorCycle);
+
+    mode Runway       = makeMode();
+    Runway.name       = "Runway";
+    Runway.value      = UNIHUB_LED_MODE_RUNWAY;
+    Runway.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Runway.speed_min  = 1;
+    Runway.speed_max  = 5;
+    Runway.colors_min = 2;
+    Runway.colors_max = 2;
+    Runway.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Runway.colors.resize(2);
+    modes.push_back(Runway);
+
+    mode RunwaySync       = makeMode();
+    RunwaySync.name       = "Runway Sync";
+    RunwaySync.value      = UNIHUB_LED_MODE_RUNWAY_SYNC | 0x0100;
+    RunwaySync.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    RunwaySync.speed_min  = 1;
+    RunwaySync.speed_max  = 5;
+    RunwaySync.colors_min = 2;
+    RunwaySync.colors_max = 2;
+    RunwaySync.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    RunwaySync.colors.resize(2);
+    modes.push_back(RunwaySync);
+
+    mode Staggered       = makeMode();
+    Staggered.name       = "Staggered";
+    Staggered.value      = UNIHUB_LED_MODE_STAGGGERED;
+    Staggered.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Staggered.speed_min  = 1;
+    Staggered.speed_max  = 5;
+    Staggered.colors_min = 2;
+    Staggered.colors_max = 2;
+    Staggered.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Staggered.colors.resize(2);
+    modes.push_back(Staggered);
+
+    mode Mixing       = makeMode();
+    Mixing.name       = "Mixing";
+    Mixing.value      = UNIHUB_LED_MODE_MIXING;
+    Mixing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Mixing.speed_min  = 1;
+    Mixing.speed_max  = 5;
+    Mixing.colors_min = 2;
+    Mixing.colors_max = 2;
+    Mixing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Mixing.colors.resize(2);
+    modes.push_back(Mixing);
+
+    mode Meteor       = makeMode();
+    Meteor.name       = "Meteor";
+    Meteor.value      = UNIHUB_LED_MODE_METEOR;
+    Meteor.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Meteor.speed_min  = 1;
+    Meteor.speed_max  = 5;
+    Meteor.colors_min = 2;
+    Meteor.colors_max = 2;
+    Meteor.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Meteor.colors.resize(2);
+    modes.push_back(Meteor);
+
+    mode MeteorSync       = makeMode();
+    MeteorSync.name       = "Meteor Sync";
+    MeteorSync.value      = UNIHUB_LED_MODE_METEOR_SYNC | 0x0100;
+    MeteorSync.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    MeteorSync.speed_min  = 1;
+    MeteorSync.speed_max  = 5;
+    MeteorSync.colors_min = 2;
+    MeteorSync.colors_max = 2;
+    MeteorSync.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    MeteorSync.colors.resize(2);
+    modes.push_back(MeteorSync);
+
+    mode Firework       = makeMode();
+    Firework.name       = "Firework";
+    Firework.value      = UNIHUB_LED_MODE_FIREWORK;
+    Firework.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Firework.speed_min  = 1;
+    Firework.speed_max  = 5;
+    Firework.colors_min = 2;
+    Firework.colors_max = 2;
+    Firework.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Firework.colors.resize(2);
+    modes.push_back(Firework);
+
+    mode Stack       = makeMode();
+    Stack.name       = "Stack";
+    Stack.value      = UNIHUB_LED_MODE_STACK;
+    Stack.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Stack.speed_min  = 1;
+    Stack.speed_max  = 5;
+    Stack.colors_min = 1;
+    Stack.colors_max = 1;
+    Stack.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Stack.colors.resize(1);
+    modes.push_back(Stack);
+
+    mode StackMultiColor       = makeMode();
+    StackMultiColor.name       = "Stack Multi Color";
+    StackMultiColor.value      = UNIHUB_LED_MODE_STACK_MULTI_COLOR;
+    StackMultiColor.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
+    StackMultiColor.speed_min  = 1;
+    StackMultiColor.speed_max  = 5;
+    StackMultiColor.color_mode = MODE_COLORS_NONE;
+    modes.push_back(StackMultiColor);
+
+    mode Neon       = makeMode();
+    Neon.name       = "Neon";
+    Neon.value      = UNIHUB_LED_MODE_NEON;
+    Neon.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Neon.speed_min  = 1;
+    Neon.speed_max  = 5;
+    Neon.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Neon);
+
+    mode Rgbh       = makeMode();
+    Rgbh.name       = "RGB Header";
+    Rgbh.value      = UNIHUB_LED_MODE_STATIC_COLOR | 0x0200;
+    Rgbh.flags      = 0;
+    Rgbh.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Rgbh);
+
+    RGBController_LianLiUniHub::SetupZones();
+}
+
+void RGBController_LianLiUniHub::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Only set LED count on the first run               |
+    \*-------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
+    {
+        first_run = true;
+    }
+
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+    zones.resize(UNIHUB_CHANNEL_COUNT);
+
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    int addressableCounter = 1;
+    for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    {
+        zones[channel_idx].name       = "Channel ";
+        zones[channel_idx].name.append(std::to_string(addressableCounter));
+
+        addressableCounter++;
+
+        zones[channel_idx].type       = ZONE_TYPE_LINEAR;
+
+        zones[channel_idx].leds_min   = 0;
+        zones[channel_idx].leds_max   = UNIHUB_CHANLED_COUNT;
+
+        if(first_run)
+        {
+            zones[channel_idx].leds_count = zones[channel_idx].leds_min;
+        }
+
+        for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
+        {
+            led new_led;
+            new_led.name = zones[channel_idx].name;
+            new_led.name.append(", LED ");
+            new_led.name.append(std::to_string(led_ch_idx + 1));
+            new_led.value = channel_idx;
+
+            leds.push_back(new_led);
+        }
+
+        zones[channel_idx].matrix_map = NULL;
+    }
+
+    SetupColors();
+}
+
+void RGBController_LianLiUniHub::ResizeZone(int zone, int new_size)
+{
+    if((size_t) zone >= zones.size())
+    {
+        return;
+    }
+
+    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    {
+        zones[zone].leds_count = new_size;
+
+        SetupZones();
+    }
+}
+
+void RGBController_LianLiUniHub::DeviceUpdateLEDs()
+{
+    if(!initializedMode)
+    {
+        DeviceUpdateMode();
+    }
+    for(size_t channel = 0; channel < zones.size(); channel++)
+    {
+        uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
+        uniHub->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
+        uniHub->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
+    }
+
+    uniHub->Synchronize();
+}
+
+void RGBController_LianLiUniHub::UpdateZoneLEDs(int zone)
+{
+    if(!initializedMode)
+    {
+        DeviceUpdateMode();
+    }
+    unsigned int channel = zone;
+
+    uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
+    uniHub->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
+    uniHub->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
+
+    uniHub->Synchronize();
+}
+
+void RGBController_LianLiUniHub::UpdateSingleLED(int led)
+{
+    if(!initializedMode)
+    {
+        DeviceUpdateMode();
+    }
+    unsigned int channel = leds[led].value;
+
+    uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
+    uniHub->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
+    uniHub->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
+
+    uniHub->Synchronize();
+}
+
+void RGBController_LianLiUniHub::DeviceUpdateMode()
+{
+    initializedMode = true;
+
+    for (size_t channel = 0; channel < zones.size(); channel++)
+    {
+        uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
+        uniHub->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
+
+        switch (modes[active_mode].color_mode)
+        {
+            case MODE_COLORS_PER_LED:
+                uniHub->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
+                break;
+
+            case MODE_COLORS_MODE_SPECIFIC:
+                uniHub->SetLedColors(channel, modes[active_mode].colors.data(), modes[active_mode].colors.size());
+                break;
+
+            default:
+                uniHub->SetLedColors(channel, nullptr, 0);
+                break;
+        }
+
+        uniHub->SetLedMode(channel, modes[active_mode].value);
+
+        if(modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
+        {
+            uniHub->SetLedSpeed(channel, convertLedSpeed(modes[active_mode].speed));
+        }
+        else
+        {
+            uniHub->SetLedSpeed(channel, UNIHUB_LED_SPEED_000);
+        }
+
+        if(modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR)
+        {
+            uniHub->SetLedDirection(channel, convertLedDirection(modes[active_mode].direction));
+        }
+        else
+        {
+            uniHub->SetLedDirection(channel, UNIHUB_LED_DIRECTION_LTR);
+        }
+    }
+
+    if(modes[active_mode].value & 0x0200)
+    {
+        uniHub->EnableRgbhMode();
+        uniHub->DisableSyncMode();
+    }
+    else if (modes[active_mode].value & 0x0100)
+    {
+        uniHub->DisableRgbhMode();
+        uniHub->EnableSyncMode();
+    }
+    else
+    {
+        uniHub->DisableRgbhMode();
+        uniHub->DisableSyncMode();
+    }
+
+    uniHub->Synchronize();
+}
+
+void RGBController_LianLiUniHub::SetCustomMode()
+{
+    /*-------------------------------------------------*\
+    | Set mode to Static Color                          |
+    \*-------------------------------------------------*/
+    active_mode = 0;
+}
+
+uint8_t RGBController_LianLiUniHub::convertAnyFanCount(uint8_t count)
+{
+    switch (count)
+    {
+        case 0:
+            return UNIHUB_ANY_FAN_COUNT_000;
+
+        case 1:
+            return UNIHUB_ANY_FAN_COUNT_001;
+
+        case 2:
+            return UNIHUB_ANY_FAN_COUNT_002;
+
+        case 3:
+            return UNIHUB_ANY_FAN_COUNT_003;
+
+        case 4:
+            return UNIHUB_ANY_FAN_COUNT_004;
+
+        default:
+            return UNIHUB_ANY_FAN_COUNT_001;
+    }
+}
+
+uint8_t RGBController_LianLiUniHub::convertLedSpeed(uint8_t speed)
+{
+    switch (speed)
+    {
+        case 1:
+            return UNIHUB_LED_SPEED_000;
+
+        case 2:
+            return UNIHUB_LED_SPEED_025;
+
+        case 3:
+            return UNIHUB_LED_SPEED_050;
+
+        case 4:
+            return UNIHUB_LED_SPEED_075;
+
+        case 5:
+            return UNIHUB_LED_SPEED_100;
+
+        default:
+            return UNIHUB_LED_SPEED_050;
+    }
+}
+
+uint8_t RGBController_LianLiUniHub::convertLedDirection(uint8_t direction)
+{
+    switch (direction)
+    {
+        case 0:
+            return UNIHUB_LED_DIRECTION_LTR;
+
+        case 1:
+            return UNIHUB_LED_DIRECTION_RTL;
+
+        default:
+            return UNIHUB_LED_DIRECTION_LTR;
+    }
+}
+
+uint8_t RGBController_LianLiUniHub::convertLedCountToFanCount(uint8_t count)
+{
+    /*-------------------------------------------------*\
+    | Converts 0 to 0, 1-16 to 1, 17-32 to 2, 33-48 to  |
+    | 3  and 49-64+ to 4                                |
+    \*-------------------------------------------------*/
+    if (count == 0x00)
+    {
+        return 0x00;
+    }
+    if (count >= 0x40)
+    {
+        count = 0x40;
+    }
+
+    return((count -1) / 16 + 1);
+}

Controllers/LianLiController/RGBController_LianLiUniHub.h

@@ -0,0 +1,45 @@
+/*-----------------------------------------*\
+|  RGBController_LianLiUniHub.h             |
+|                                           |
+|  Generic RGB Interface for Lian Li Uni    |
+|  Hub USB controller driver                |
+|                                           |
+|  Luca Lovisa 2/20/2021                    |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "LianLiUniHubController.h"
+#include "RGBController.h"
+
+class RGBController_LianLiUniHub : public RGBController
+{
+public:
+    RGBController_LianLiUniHub(LianLiUniHubController* uniHub_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:
+    uint8_t convertAnyFanCount(uint8_t count);
+    uint8_t convertLedSpeed(uint8_t speed);
+    uint8_t convertLedDirection(uint8_t direction);
+
+    uint8_t convertLedCountToFanCount(uint8_t count);
+
+private:
+    LianLiUniHubController* uniHub;
+    bool                    initializedMode;
+};

Controllers/LogitechController/LogitechControllerDetect.cpp

@@ -1,26 +1,24 @@
 #include "Detector.h"
-#include "LogitechG203Controller.h"
+#include "LogManager.h"
+#include "LogitechProtocolCommon.h"
 #include "LogitechG203LController.h"
 #include "LogitechG213Controller.h"
-#include "LogitechG303Controller.h"
-#include "LogitechG403Controller.h"
-#include "LogitechG502PSController.h"
 #include "LogitechG560Controller.h"
 #include "LogitechG810Controller.h"
+#include "LogitechG910Controller.h"
 #include "LogitechG815Controller.h"
-#include "LogitechGProWirelessController.h"
-#include "LogitechGPowerPlayController.h"
+#include "LogitechGLightsyncController.h"
+#include "LogitechLightspeedController.h"
 #include "RGBController.h"
-#include "RGBController_LogitechG203.h"
 #include "RGBController_LogitechG203L.h"
 #include "RGBController_LogitechG213.h"
-#include "RGBController_LogitechG303.h"
-#include "RGBController_LogitechG403.h"
-#include "RGBController_LogitechG502PS.h"
 #include "RGBController_LogitechG560.h"
 #include "RGBController_LogitechG810.h"
+#include "RGBController_LogitechG910.h"
 #include "RGBController_LogitechG815.h"
-#include "RGBController_LogitechGProWireless.h"
+#include "RGBController_LogitechGLightsync.h"
+#include "RGBController_LogitechGLightsync1zone.h"
+#include "RGBController_LogitechLightspeed.h"
 #include "RGBController_LogitechGPowerPlay.h"
 #include <vector>
 #include <hidapi/hidapi.h>
@@ -29,6 +27,7 @@
 | Logitech vendor ID                                    |
 \*-----------------------------------------------------*/
 #define LOGITECH_VID                            0x046D
+
 /*-----------------------------------------------------*\
 | Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
@@ -41,29 +40,72 @@
 #define LOGITECH_G810_2_PID                     0xC337
 #define LOGITECH_G813_PID                       0xC232
 #define LOGITECH_G815_PID                       0xC33F
+#define LOGITECH_G910_ORION_SPARK_PID           0xC32B
+#define LOGITECH_G910_PID                       0xC335
+
 /*-----------------------------------------------------*\
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
 #define LOGITECH_G203_PID                       0xC084
-#define LOGITECH_G203L_PID                      0xC092
+#define LOGITECH_G203_LIGHTSYNC_PID             0xC092
 #define LOGITECH_G303_PID                       0xC080
 #define LOGITECH_G403_PID                       0xC083
-#define LOGITECH_G403H_PID                      0xC08F
-#define LOGITECH_G502_PS_PID                    0xC332
-#define LOGITECH_G502H_PID                      0xC08B
-#define LOGITECH_G_LIGHTSPEED_WIRELESS_PID      0xC539
-#define LOGITECH_GPRO_WIRED_PID                 0xC085
-#define LOGITECH_GPRO_HERO_WIRED_PID            0xC08C
-#define LOGITECH_GPRO_WIRELESS_PID              0xC088
+#define LOGITECH_G403_HERO_PID                  0xC08F
+#define LOGITECH_G403_LIGHTSPEED_PID            0xC082
+#define LOGITECH_G502_PROTEUS_SPECTRUM_PID      0xC332
+#define LOGITECH_G502_HERO_PID                  0xC08B
+#define LOGITECH_G502_LIGHTSPEED_PID            0xC08D
+#define LOGITECH_G703_LIGHTSPEED_PID            0xC087
+#define LOGITECH_G900_LIGHTSPEED_PID            0xC081
+#define LOGITECH_G903_LIGHTSPEED_PID            0xC086
+#define LOGITECH_G_PRO_PID                      0xC085
+#define LOGITECH_G_PRO_HERO_PID                 0xC08C
+#define LOGITECH_G_PRO_WIRELESS_PID             0xC088
+
 /*-----------------------------------------------------*\
 | Mousemat product IDs                                  |
 \*-----------------------------------------------------*/
 #define LOGITECH_G_LIGHTSPEED_POWERPLAY_PID     0xC53A
+
 /*-----------------------------------------------------*\
 | Speaker product IDs                                   |
 \*-----------------------------------------------------*/
 #define LOGITECH_G560_PID                       0x0A78
 
+/*-----------------------------------------------------*\
+| Unifying Device IDs (Including Lightspeed receivers)  |
+|   NB: Not used but preserved for debugging            |
+\*-----------------------------------------------------*/
+#define LOGITECH_G_UNIFYING_RECEIVER_1_PID              0xC52B
+#define LOGITECH_G_NANO_RECEIVER_PID                    0xC52F
+#define LOGITECH_G_G700_RECEIVER_PID                    0xC531
+#define LOGITECH_G_UNIFYING_RECEIVER_2_PID              0xC532
+#define LOGITECH_G_G602_RECEIVER_PID                    0xC537
+
+#define LOGITECH_G_LIGHTSPEED_RECEIVER_PID              0xC539
+#define LOGITECH_G403_LIGHTSPEED_VIRTUAL_PID            0x405D
+#define LOGITECH_G502_LIGHTSPEED_VIRTUAL_PID            0x407F
+#define LOGITECH_G703_LIGHTSPEED_VIRTUAL_PID            0x4070
+#define LOGITECH_G900_LIGHTSPEED_VIRTUAL_PID            0x4053
+#define LOGITECH_G903_LIGHTSPEED_VIRTUAL_PID            0x4067
+#define LOGITECH_G_PRO_WIRELESS_VIRTUAL_PID             0x4079
+
+/*-----------------------------------------------------*\
+| Logitech Keyboards                                    |
+\*-----------------------------------------------------*/
+void DetectLogitechKeyboardG213(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        LogitechG213Controller*     controller     = new LogitechG213Controller(dev, info->path);
+        RGBController_LogitechG213* rgb_controller = new RGBController_LogitechG213(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 void DetectLogitechKeyboardG810(hid_device_info* info, const std::string& name)
 {
     /*-------------------------------------------------------------------------------------------------*\
@@ -71,49 +113,51 @@ void DetectLogitechKeyboardG810(hid_device_info* info, const std::string& name)
     | Usage 0x0602 for 20 byte, usage 0x0604 for 64 byte, both are on usage page 0xFF43                 |
     \*-------------------------------------------------------------------------------------------------*/
 #ifdef USE_HID_USAGE
-     hid_device* dev_usage_0x0602 = nullptr;
-     hid_device* dev_usage_0x0604 = nullptr;
-     hid_device_info* info_temp = info;
-     while(info_temp)
-     {
-         if(info_temp->vendor_id        == info->vendor_id        // constant LOGITECH_VID
-         && info_temp->product_id       == info->product_id       // NON-constant
-         && info_temp->interface_number == info->interface_number // constant 1
-         && info_temp->usage_page       == info->usage_page)      // constant 0xFF43
-         {
-             if(info_temp->usage == 0x0602)
-             {
+    hid_device* dev_usage_0x0602 = nullptr;
+    hid_device* dev_usage_0x0604 = nullptr;
+    hid_device_info* info_temp = info;
+
+    while(info_temp)
+    {
+        if(info_temp->vendor_id        == info->vendor_id           // constant LOGITECH_VID
+        && info_temp->product_id       == info->product_id          // NON-constant
+        && info_temp->interface_number == info->interface_number    // constant 1
+        && info_temp->usage_page       == info->usage_page)         // constant 0xFF43
+        {
+            if(info_temp->usage == 0x0602)
+            {
                 dev_usage_0x0602 = hid_open_path(info_temp->path);
-             }
-             else if(info_temp->usage == 0x0604)
-             {
-                 dev_usage_0x0604 = hid_open_path(info_temp->path);
-             }
-         }
-         if(dev_usage_0x0602 && dev_usage_0x0604)
-         {
-             break;
-         }
-         info_temp = info_temp->next;
-     }
-     if(dev_usage_0x0602 && dev_usage_0x0604)
-     {
-         LogitechG810Controller* controller = new LogitechG810Controller(dev_usage_0x0602, dev_usage_0x0604);
-         RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
-         rgb_controller->name = name;
-         ResourceManager::get()->RegisterRGBController(rgb_controller);
-     }
-     else
-     {
-         // Not all of them could be opened, do some cleanup
-         hid_close(dev_usage_0x0602);
-         hid_close(dev_usage_0x0604);
-     }
+            }
+            else if(info_temp->usage == 0x0604)
+            {
+                dev_usage_0x0604 = hid_open_path(info_temp->path);
+            }
+        }
+        if(dev_usage_0x0602 && dev_usage_0x0604)
+        {
+            break;
+        }
+        info_temp = info_temp->next;
+    }
+    if(dev_usage_0x0602 && dev_usage_0x0604)
+    {
+        LogitechG810Controller*     controller     = new LogitechG810Controller(dev_usage_0x0602, dev_usage_0x0604);
+        RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+    else
+    {
+        // Not all of them could be opened, do some cleanup
+        hid_close(dev_usage_0x0602);
+        hid_close(dev_usage_0x0604);
+    }
 #else
     hid_device* dev = hid_open_path(info->path);
+
     if(dev)
     {
-        LogitechG810Controller* controller = new LogitechG810Controller(dev, dev);
+        LogitechG810Controller*     controller     = new LogitechG810Controller(dev, dev);
         RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
         rgb_controller->name = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -121,120 +165,63 @@ void DetectLogitechKeyboardG810(hid_device_info* info, const std::string& name)
 #endif
 }
 
-void DetectLogitechKeyboardG213(hid_device_info* info, const std::string& name)
+void DetectLogitechKeyboardG910(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
+    /*-------------------------------------------------------------------------------------------------*\
+    | Logitech keyboards use two different usages, one for 20-byte packets and one for 64-byte packets  |
+    | Usage 0x0602 for 20 byte, usage 0x0604 for 64 byte, both are on usage page 0xFF43                 |
+    \*-------------------------------------------------------------------------------------------------*/
+#ifdef USE_HID_USAGE
+    hid_device* dev_usage_0x0602 = nullptr;
+    hid_device* dev_usage_0x0604 = nullptr;
+    hid_device_info* info_temp = info;
+
+    while(info_temp)
     {
-        LogitechG213Controller* controller = new LogitechG213Controller(dev, info->path);
-        RGBController_LogitechG213* rgb_controller = new RGBController_LogitechG213(controller);
+        if(info_temp->vendor_id        == info->vendor_id           // constant LOGITECH_VID
+        && info_temp->product_id       == info->product_id          // NON-constant
+        && info_temp->interface_number == info->interface_number    // constant 1
+        && info_temp->usage_page       == info->usage_page)         // constant 0xFF43
+        {
+            if(info_temp->usage == 0x0602)
+            {
+                dev_usage_0x0602 = hid_open_path(info_temp->path);
+            }
+            else if(info_temp->usage == 0x0604)
+            {
+                dev_usage_0x0604 = hid_open_path(info_temp->path);
+            }
+        }
+        if(dev_usage_0x0602 && dev_usage_0x0604)
+        {
+            break;
+        }
+        info_temp = info_temp->next;
+    }
+    if(dev_usage_0x0602 && dev_usage_0x0604)
+    {
+        LogitechG910Controller*     controller     = new LogitechG910Controller(dev_usage_0x0602, dev_usage_0x0604);
+        RGBController_LogitechG910* rgb_controller = new RGBController_LogitechG910(controller);
         rgb_controller->name = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-}
-
-void DetectLogitechMouseG203(hid_device_info* info, const std::string& name)
-{
+    else
+    {
+        // Not all of them could be opened, do some cleanup
+        hid_close(dev_usage_0x0602);
+        hid_close(dev_usage_0x0604);
+    }
+#else
     hid_device* dev = hid_open_path(info->path);
+
     if(dev)
     {
-        LogitechG203Controller* controller = new LogitechG203Controller(dev, info->path);
-        RGBController_LogitechG203* rgb_controller = new RGBController_LogitechG203(controller);
+        LogitechG910Controller*     controller     = new LogitechG910Controller(dev, dev);
+        RGBController_LogitechG910* rgb_controller = new RGBController_LogitechG910(controller);
         rgb_controller->name = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-}
-
-void DetectLogitechMouseG203L(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        LogitechG203LController* controller = new LogitechG203LController(dev, info->path);
-        RGBController_LogitechG203L* rgb_controller = new RGBController_LogitechG203L(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectLogitechMouseG303(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        LogitechG303Controller* controller = new LogitechG303Controller(dev, info->path);
-        RGBController_LogitechG303* rgb_controller = new RGBController_LogitechG303(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectLogitechMouseG403(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        LogitechG403Controller* controller = new LogitechG403Controller(dev, info->path);
-        RGBController_LogitechG403* rgb_controller = new RGBController_LogitechG403(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectLogitechMouseG502PS(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        LogitechG502PSController* controller = new LogitechG502PSController(dev, info->path);
-        RGBController_LogitechG502PS* rgb_controller = new RGBController_LogitechG502PS(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectLogitechMouseGPRO(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        LogitechGProWirelessController* controller = new LogitechGProWirelessController(dev, info->path);
-        RGBController_LogitechGProWireless* rgb_controller = new RGBController_LogitechGProWireless(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectLogitechMouseGLS(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        //Add mouse
-        LogitechGProWirelessController* mouse_controller = new LogitechGProWirelessController(dev, info->path);
-        RGBController_LogitechGProWireless* mouse_rgb_controller = new RGBController_LogitechGProWireless(mouse_controller);
-        mouse_rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(mouse_rgb_controller);
-
-        //Add Powerplay mousemat
-        LogitechGPowerPlayController* mousemat_controller = new LogitechGPowerPlayController(dev, info->path);
-        RGBController_LogitechGPowerPlay* mousemat_rgb_controller = new RGBController_LogitechGPowerPlay(mousemat_controller);
-        mousemat_rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(mousemat_rgb_controller);
-    }
-}
-
-void DetectLogitechG560(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        //Add G560 Speaker
-        LogitechG560Controller* speaker_controller = new LogitechG560Controller(dev, info->path);
-        RGBController_LogitechG560* speaker_rgb_controller = new RGBController_LogitechG560(speaker_controller);
-        speaker_rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(speaker_rgb_controller);
-    }
+#endif
 }
 
 void DetectLogitechKeyboardG815(hid_device_info* info, const std::string& name)
@@ -243,56 +230,60 @@ void DetectLogitechKeyboardG815(hid_device_info* info, const std::string& name)
     | Logitech keyboards use two different usages, one for 20-byte packets and one for 64-byte packets  |
     | Usage 0x0602 for 20 byte, usage 0x0604 for 64 byte, both are on usage page 0xFF43                 |
     \*-------------------------------------------------------------------------------------------------*/
-#ifdef _WIN32
-     hid_device* dev_usage_0x0602 = nullptr;
-     hid_device* dev_usage_0x0604 = nullptr;
-     hid_device_info* info_temp = info;
-     while(info_temp)
-     {
-         if(info_temp->vendor_id        == info->vendor_id        // constant LOGITECH_VID
-         && info_temp->product_id       == info->product_id       // NON-constant
-         && info_temp->interface_number == info->interface_number // constant 1
-         && info_temp->usage_page       == info->usage_page)      // constant 0xFF43
-         {
-             if(info_temp->usage == 0x0602)
-             {
-                dev_usage_0x0602 = hid_open_path(info_temp->path);
-             }
-             else if(info_temp->usage == 0x0604)
-             {
-                 dev_usage_0x0604 = hid_open_path(info_temp->path);
-             }
-         }
-         if(dev_usage_0x0602 && dev_usage_0x0604)
-         {
-             break;
-         }
-         info_temp = info_temp->next;
-     }
-     if(dev_usage_0x0602 && dev_usage_0x0604)
-     {
-         LogitechG815Controller* controller = new LogitechG815Controller(dev_usage_0x0602, dev_usage_0x0604);
-         RGBController_LogitechG815* rgb_controller = new RGBController_LogitechG815(controller);
-         rgb_controller->name = name;
-         ResourceManager::get()->RegisterRGBController(rgb_controller);
-     }
-     else
-     {
-         // Not all of them could be opened, do some cleanup
-         if(dev_usage_0x0602)
-         {
-             hid_close(dev_usage_0x0602);
-         }
-         if(dev_usage_0x0604)
-         {
-             hid_close(dev_usage_0x0604);
-         }
-     }
+#ifdef USE_HID_USAGE
+    hid_device* dev_usage_0x0602 = nullptr;
+    hid_device* dev_usage_0x0604 = nullptr;
+    hid_device_info* info_temp = info;
+
+    while(info_temp)
+    {
+        if(info_temp->vendor_id        == info->vendor_id           // constant LOGITECH_VID
+        && info_temp->product_id       == info->product_id          // NON-constant
+        && info_temp->interface_number == info->interface_number    // constant 1
+        && info_temp->usage_page       == info->usage_page)         // constant 0xFF43
+        {
+            if(info_temp->usage == 0x0602)
+            {
+               dev_usage_0x0602 = hid_open_path(info_temp->path);
+            }
+            else if(info_temp->usage == 0x0604)
+            {
+                dev_usage_0x0604 = hid_open_path(info_temp->path);
+            }
+        }
+        if(dev_usage_0x0602 && dev_usage_0x0604)
+        {
+            break;
+        }
+        info_temp = info_temp->next;
+    }
+    if(dev_usage_0x0602 && dev_usage_0x0604)
+    {
+        LogitechG815Controller*     controller     = new LogitechG815Controller(dev_usage_0x0602, dev_usage_0x0604);
+        RGBController_LogitechG815* rgb_controller = new RGBController_LogitechG815(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+    else
+    {
+        /*-------------------------------------------------*\
+        | Not all of them could be opened, do some cleanup  |
+        \*-------------------------------------------------*/
+        if(dev_usage_0x0602)
+        {
+            hid_close(dev_usage_0x0602);
+        }
+        if(dev_usage_0x0604)
+        {
+            hid_close(dev_usage_0x0604);
+        }
+    }
 #else
     hid_device* dev = hid_open_path(info->path);
+
     if(dev)
     {
-        LogitechG815Controller* controller = new LogitechG815Controller(dev, dev);
+        LogitechG815Controller*     controller     = new LogitechG815Controller(dev, dev);
         RGBController_LogitechG815* rgb_controller = new RGBController_LogitechG815(controller);
         rgb_controller->name = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -300,38 +291,381 @@ void DetectLogitechKeyboardG815(hid_device_info* info, const std::string& name)
 #endif
 }
 
+/*-----------------------------------------------------*\
+| Logitech Mice                                         |
+\*-----------------------------------------------------*/
+static void addLogitechLightsyncMouse1zone(hid_device_info* info, const std::string& name, unsigned char hid_dev_index, unsigned char hid_feature_index, unsigned char hid_fctn_ase_id)
+{
+#ifdef USE_HID_USAGE
+    {
+        hid_device* dev_usage_1 = nullptr;
+        hid_device* dev_usage_2 = nullptr;
+        hid_device_info* info_temp = info;
+
+        while(info_temp)
+        {
+            if(info_temp->vendor_id        == info->vendor_id           // constant LOGITECH_VID
+            && info_temp->product_id       == info->product_id          // NON-constant
+            && info_temp->interface_number == info->interface_number    // constant 1
+            && info_temp->usage_page       == info->usage_page)         // constant 0x00FF
+            {
+                if (info_temp->usage == 1)
+                {
+                    dev_usage_1 = hid_open_path(info_temp->path);
+                }
+                else if (info_temp->usage == 2)
+                {
+                    dev_usage_2 = hid_open_path(info_temp->path);
+                }
+            }
+            if (dev_usage_1 && dev_usage_2)
+            {
+                break;
+            }
+            info_temp = info_temp->next;
+        }
+        if(dev_usage_1 && dev_usage_2)
+        {
+            LogitechGLightsyncController*          controller     = new LogitechGLightsyncController(dev_usage_1, dev_usage_2, info->path, hid_dev_index, hid_feature_index, hid_fctn_ase_id);
+            RGBController_LogitechGLightsync1zone* rgb_controller = new RGBController_LogitechGLightsync1zone (controller);
+            rgb_controller->name = name;
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+        else
+        {
+            LOG_NOTICE("Unable to open all device report endpoints, unable to add device");
+            hid_close(dev_usage_1);
+            hid_close(dev_usage_2);
+        }
+    }
+
+#else
+    {
+        hid_device* dev = hid_open_path(info->path);
+
+        if(dev)
+        {
+            LogitechGLightsyncController*          controller     = new LogitechGLightsyncController(dev, dev, info->path, hid_dev_index, hid_feature_index, hid_fctn_ase_id);
+            RGBController_LogitechGLightsync1zone* rgb_controller = new RGBController_LogitechGLightsync1zone(controller);
+            rgb_controller->name = name;
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+    }
+#endif
+}
+
+static void addLogitechLightsyncMouse2zone(hid_device_info* info, const std::string& name, unsigned char hid_dev_index, unsigned char hid_feature_index, unsigned char hid_fctn_ase_id)
+{
+#ifdef USE_HID_USAGE
+    {
+        hid_device* dev_usage_1 = nullptr;
+        hid_device* dev_usage_2 = nullptr;
+        hid_device_info* info_temp = info;
+
+        while(info_temp)
+        {
+            if(info_temp->vendor_id        == info->vendor_id           // constant LOGITECH_VID
+            && info_temp->product_id       == info->product_id          // NON-constant
+            && info_temp->interface_number == info->interface_number    // constant 1
+            && info_temp->usage_page       == info->usage_page)         // constant 0x00FF
+            {
+                if(info_temp->usage == 1)
+                {
+                    dev_usage_1 = hid_open_path(info_temp->path);
+                }
+                else if(info_temp->usage == 2)
+                {
+                    dev_usage_2 = hid_open_path(info_temp->path);
+                }
+            }
+            if(dev_usage_1 && dev_usage_2)
+            {
+                break;
+            }
+            info_temp = info_temp->next;
+        }
+        if(dev_usage_1 && dev_usage_2)
+        {
+            LogitechGLightsyncController*     controller     = new LogitechGLightsyncController(dev_usage_1, dev_usage_2, info->path, hid_dev_index, hid_feature_index, hid_fctn_ase_id);
+            RGBController_LogitechGLightsync* rgb_controller = new RGBController_LogitechGLightsync (controller);
+            rgb_controller->name = name;
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+        else
+        {
+            LOG_NOTICE("Unable to open all device report endpoints, unable to add device");
+            hid_close(dev_usage_1);
+            hid_close(dev_usage_2);
+        }
+    }
+#else
+    {
+        hid_device* dev = hid_open_path(info->path);
+    
+        if(dev)
+        {
+            LogitechGLightsyncController*     controller     = new LogitechGLightsyncController(dev, dev, info->path, hid_dev_index, hid_feature_index, hid_fctn_ase_id);
+            RGBController_LogitechGLightsync* rgb_controller = new RGBController_LogitechGLightsync(controller);
+            rgb_controller->name = name;
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
+        }
+    }
+#endif
+}
+
+void DetectLogitechMouseG203(hid_device_info* info, const std::string& name)
+{
+    addLogitechLightsyncMouse1zone(info, name, 0xFF, 0x0E, 0x3A);
+}
+
+void DetectLogitechMouseG203L(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        LogitechG203LController*     controller     = new LogitechG203LController(dev, info->path);
+        RGBController_LogitechG203L* rgb_controller = new RGBController_LogitechG203L(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectLogitechMouseG303(hid_device_info* info, const std::string& name)
+{
+    addLogitechLightsyncMouse2zone(info, name, 0xFF, 0x0E, 0x3A);
+}
+
+void DetectLogitechMouseG403(hid_device_info* info, const std::string& name)
+{
+    addLogitechLightsyncMouse2zone(info, name, 0xFF, 0x0E, 0x3A);
+}
+
+void DetectLogitechMouseG502PS(hid_device_info* info, const std::string& name)
+{
+    addLogitechLightsyncMouse2zone(info, name, 0xFF, 0x02, 0x3A);
+}
+
+void DetectLogitechMouseGPRO(hid_device_info* info, const std::string& name)
+{
+    addLogitechLightsyncMouse1zone(info, name, 0xFF, 0x0E, 0x3C);
+}
+
+/*-----------------------------------------------------*\
+| Other Logitech Devices                                |
+\*-----------------------------------------------------*/
+void DetectLogitechG560(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        /*---------------------------------------------*\
+        | Add G560 Speaker                              |
+        \*---------------------------------------------*/
+        LogitechG560Controller*     controller     = new LogitechG560Controller(dev, info->path);
+        RGBController_LogitechG560* rgb_controller = new RGBController_LogitechG560(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
 
 /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
 | Keyboards                                                                                                                                         |
 \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G213",                                 DetectLogitechKeyboardG213, LOGITECH_VID, LOGITECH_G213_PID,                   1, 0xFF43, 0x0602);
-REGISTER_HID_DETECTOR_IP ("Logitech G512",                                 DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G512_PID,                   1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G512 RGB",                             DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G512_RGB_PID,               1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G610 Orion",                           DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G610_1_PID,                 1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G610 Orion",                           DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G610_2_PID,                 1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G810 Orion Spectrum",                  DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G810_1_PID,                 1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G810 Orion Spectrum",                  DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G810_2_PID,                 1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G813 RGB Mechanical Gaming Keyboard",  DetectLogitechKeyboardG815, LOGITECH_VID, LOGITECH_G813_PID,                   1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G815 RGB Mechanical Gaming Keyboard",  DetectLogitechKeyboardG815, LOGITECH_VID, LOGITECH_G815_PID,                   1, 0xFF43);
+REGISTER_HID_DETECTOR_IPU("Logitech G213",                                  DetectLogitechKeyboardG213, LOGITECH_VID, LOGITECH_G213_PID,                    1, 0xFF43, 0x0602);
+REGISTER_HID_DETECTOR_IP ("Logitech G512",                                  DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G512_PID,                    1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G512 RGB",                              DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G512_RGB_PID,                1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G610 Orion",                            DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G610_1_PID,                  1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G610 Orion",                            DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G610_2_PID,                  1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G810 Orion Spectrum",                   DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G810_1_PID,                  1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G810 Orion Spectrum",                   DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G810_2_PID,                  1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G813 RGB Mechanical Gaming Keyboard",   DetectLogitechKeyboardG815, LOGITECH_VID, LOGITECH_G813_PID,                    1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G815 RGB Mechanical Gaming Keyboard",   DetectLogitechKeyboardG815, LOGITECH_VID, LOGITECH_G815_PID,                    1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G910 Orion Spark",                      DetectLogitechKeyboardG910, LOGITECH_VID, LOGITECH_G910_ORION_SPARK_PID,        1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G910 Orion Spectrum",                   DetectLogitechKeyboardG910, LOGITECH_VID, LOGITECH_G910_PID,                    1, 0xFF43);
 /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
 | Mice                                                                                                                                              |
 \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G203 Prodigy",                         DetectLogitechMouseG203,    LOGITECH_VID, LOGITECH_G203_PID,                   1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G203 Lightsync",                       DetectLogitechMouseG203L,   LOGITECH_VID, LOGITECH_G203L_PID,                  1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G303 Daedalus Apex",                   DetectLogitechMouseG303,    LOGITECH_VID, LOGITECH_G303_PID,                   1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G403 Prodigy",                         DetectLogitechMouseG403,    LOGITECH_VID, LOGITECH_G403_PID,                   1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G403 Hero",                            DetectLogitechMouseG403,    LOGITECH_VID, LOGITECH_G403H_PID,                  1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G502 Proteus Spectrum",                DetectLogitechMouseG502PS,  LOGITECH_VID, LOGITECH_G502_PS_PID,                1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G502 Hero",                            DetectLogitechMouseG502PS,  LOGITECH_VID, LOGITECH_G502H_PID,                  1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G Pro Gaming Mouse",                   DetectLogitechMouseG203,    LOGITECH_VID, LOGITECH_GPRO_WIRED_PID,             1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G Pro (HERO) Gaming Mouse",            DetectLogitechMouseG203,    LOGITECH_VID, LOGITECH_GPRO_HERO_WIRED_PID,        1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G Lightspeed Wireless Gaming Mouse",   DetectLogitechMouseGPRO,    LOGITECH_VID, LOGITECH_G_LIGHTSPEED_WIRELESS_PID,  2, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G Pro Wireless Gaming Mouse (Wired)",  DetectLogitechMouseGPRO,    LOGITECH_VID, LOGITECH_GPRO_WIRELESS_PID,          2, 0xFF00, 2);
-/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Mousemats                                                                                                                                         |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G Powerplay Mousepad with Lightspeed", DetectLogitechMouseGLS,     LOGITECH_VID, LOGITECH_G_LIGHTSPEED_POWERPLAY_PID, 2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IP ("Logitech G203 Prodigy",                          DetectLogitechMouseG203,    LOGITECH_VID, LOGITECH_G203_PID,                    1, 0xFF00);
+REGISTER_HID_DETECTOR_IPU("Logitech G203 Lightsync",                        DetectLogitechMouseG203L,   LOGITECH_VID, LOGITECH_G203_LIGHTSYNC_PID,          1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IP ("Logitech G303 Daedalus Apex",                    DetectLogitechMouseG303,    LOGITECH_VID, LOGITECH_G303_PID,                    1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G403 Hero",                             DetectLogitechMouseG403,    LOGITECH_VID, LOGITECH_G403_HERO_PID,               1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G502 Proteus Spectrum Gaming Mouse",    DetectLogitechMouseG502PS,  LOGITECH_VID, LOGITECH_G502_PROTEUS_SPECTRUM_PID,   1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G502 Hero Gaming Mouse",                DetectLogitechMouseG502PS,  LOGITECH_VID, LOGITECH_G502_HERO_PID,               1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G Pro Gaming Mouse",                    DetectLogitechMouseGPRO,    LOGITECH_VID, LOGITECH_G_PRO_PID,                   1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G Pro (HERO) Gaming Mouse",             DetectLogitechMouseGPRO,    LOGITECH_VID, LOGITECH_G_PRO_HERO_PID,              1, 0xFF00);
 /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
 | Speakers                                                                                                                                         |
 \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G560 Lightsync Speaker",               DetectLogitechG560,         LOGITECH_VID, LOGITECH_G560_PID,                   2, 0xFF43, 514);
+REGISTER_HID_DETECTOR_IPU("Logitech G560 Lightsync Speaker",                DetectLogitechG560,         LOGITECH_VID, LOGITECH_G560_PID,                    2, 0xFF43, 514);
+
+/*---------------------------------------------------------------------------------------------------------*\
+| Windows and MacOS Lightspeed Detection                                                                    |
+|                                                                                                           |
+| The Lightspeed receiver is a unifying receiver that will only accept 1 connection                         |
+| We must probe the receiver to check what is currently connected                                           |
+|                                                                                                           |
+| Hat tip - kernel driver  https://github.com/torvalds/linux/blob/master/drivers/hid/hid-logitech-dj.c      |
+|         - ltunify        https://github.com/Lekensteyn/ltunify/                                           |
+\*---------------------------------------------------------------------------------------------------------*/
+#if defined(_WIN32) || defined(__APPLE__)
+
+usages BundleLogitechUsages(hid_device_info* info)
+{
+    usages      temp_usages;
+
+    /*-----------------------------------------------------------------*\
+    | Need a unique ID to group usages for 1 device if multiple exist   |
+    |   Grab all usages that you can open. For normal Logitech FAP      |
+    |   devices this will be usage 1, 2 and 4                           |
+    \*-----------------------------------------------------------------*/
+    if(info->usage == 1)
+    {
+        while(info)
+        {
+            hid_device* dev = hid_open_path(info->path);
+
+            if(dev)
+            {
+                temp_usages.emplace((uint8_t)info->usage, dev);
+            }
+
+            info = info->next;
+        }
+    }
+
+    return temp_usages;
+}
+
+void CreateLogitechLightspeedDevice(char *path, usages device_usages, uint8_t device_index, bool wireless, std::shared_ptr<std::mutex> mutex_ptr)
+{
+    LogitechLightspeedController* controller          = new LogitechLightspeedController(device_usages.find(2)->second, path);
+    controller->lightspeed                              = new logitech_device(path, device_usages, device_index, wireless, mutex_ptr);
+    RGBController_LogitechLightspeed* rgb_controller  = new RGBController_LogitechLightspeed(controller);
+    ResourceManager::get()->RegisterRGBController(rgb_controller);
+}
+
+void DetectLogitechLightspeedReceiver(hid_device_info* info, const std::string& /*name*/)
+{
+    /*-----------------------------------------------------------------*\
+    | Need to save the PID and the device path before iterating         |
+    |    over "info" in BundleLogitechUsages()                          |
+    \*-----------------------------------------------------------------*/
+    char        *path           = info->path;
+    uint16_t    dev_pid         = info->product_id;
+    usages      device_usages   = BundleLogitechUsages(info);
+
+    wireless_map wireless_devices;
+    unsigned int device_count   = getWirelessDevice(device_usages, dev_pid, &wireless_devices);
+
+    /*-----------------------------------------------------------------*\
+    | Lightspeed Receivers will only have one paired /connected device  |
+    | Unifying Receivers can have up to 6 devices paired / connected    |
+    \*-----------------------------------------------------------------*/
+    if(device_count > 0)
+    {
+        /*-------------------------------------------------*\
+        | Create mutex to prevent the controllers sharing a |
+        |   receiver from interfering with each other       |
+        \*-------------------------------------------------*/
+        std::shared_ptr<std::mutex>       logitech_mutex = std::make_shared<std::mutex>();
+
+        for(wireless_map::iterator wd = wireless_devices.begin(); wd != wireless_devices.end(); wd++)
+        {
+            CreateLogitechLightspeedDevice(path, device_usages, wd->second, true, logitech_mutex);
+        }
+    }
+}
+
+void DetectLogitechWired(hid_device_info* info, const std::string& /*name*/)
+{
+    /*-----------------------------------------------------------------*\
+    | Need to save the device path before iterating                     |
+    |    over "info" in BundleLogitechUsages()                          |
+    \*-----------------------------------------------------------------*/
+    char        *path           = info->path;
+    usages      device_usages   = BundleLogitechUsages(info);
+
+    if(device_usages.size() > 0)
+    {
+        CreateLogitechLightspeedDevice(path, device_usages, 0xFF, false, nullptr);
+    }
+}
+
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Lightspeed Receivers (Windows Wireless)                                                                                                           |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("Logitech Lightspeed Receiver",                        DetectLogitechLightspeedReceiver,   LOGITECH_VID, LOGITECH_G_LIGHTSPEED_RECEIVER_PID,   2, 0xFF00);
+REGISTER_HID_DETECTOR_IP("Logitech G Powerplay Mousepad",                       DetectLogitechLightspeedReceiver,   LOGITECH_VID, LOGITECH_G_LIGHTSPEED_POWERPLAY_PID,  2, 0xFF00);
+
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Lightspeed Wireless Devices (Windows Wired)                                                                                                       |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("Logitech G403 Wireless Gaming Mouse (wired)",         DetectLogitechWired,                LOGITECH_VID, LOGITECH_G403_LIGHTSPEED_PID,         1, 0xFF00);
+REGISTER_HID_DETECTOR_IP("Logitech G502 Wireless Gaming Mouse (wired)",         DetectLogitechWired,                LOGITECH_VID, LOGITECH_G502_LIGHTSPEED_PID,         1, 0xFF00);
+REGISTER_HID_DETECTOR_IP("Logitech G703 Wireless Gaming Mouse (wired)",         DetectLogitechWired,                LOGITECH_VID, LOGITECH_G703_LIGHTSPEED_PID,         1, 0xFF00);
+REGISTER_HID_DETECTOR_IP("Logitech G900 Wireless Gaming Mouse (wired)",         DetectLogitechWired,                LOGITECH_VID, LOGITECH_G900_LIGHTSPEED_PID,         1, 0xFF00);
+REGISTER_HID_DETECTOR_IP("Logitech G903 Wireless Gaming Mouse (wired)",         DetectLogitechWired,                LOGITECH_VID, LOGITECH_G903_LIGHTSPEED_PID,         1, 0xFF00);
+REGISTER_HID_DETECTOR_IP("Logitech G Pro Wireless Gaming Mouse (wired)",        DetectLogitechWired,                LOGITECH_VID, LOGITECH_G_PRO_WIRELESS_PID,          2, 0xFF00);
+
+#endif
+
+/*---------------------------------------------------------------------------------------------------------*\
+| Linux Lightspeed Detection                                                                                |
+|                                                                                                           |
+| The Linux kernel handles detecting wireless devices connected to a Unifying Receiver.                     |
+\*---------------------------------------------------------------------------------------------------------*/
+#ifdef __linux__
+
+void CreateLogitechLightspeedDevice(hid_device_info* info, bool wireless)
+{
+    usages      device_usages;
+
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        device_usages.emplace((uint8_t)info->usage, dev);
+    }
+
+    if(device_usages.size() > 0)
+    {
+        LogitechLightspeedController* controller          = new LogitechLightspeedController(device_usages.find(0)->second, info->path);
+        controller->lightspeed                              = new logitech_device(info->path, device_usages, 0xFF, wireless);
+        RGBController_LogitechLightspeed* rgb_controller  = new RGBController_LogitechLightspeed(controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectLogitechWireless(hid_device_info* info, const std::string& /*name*/)
+{
+    CreateLogitechLightspeedDevice(info, true);
+}
+
+void DetectLogitechWired(hid_device_info* info, const std::string& /*name*/)
+{
+    CreateLogitechLightspeedDevice(info, false);
+}
+
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Lightspeed Devices (Linux Wireless)                                                                                                               |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Logitech G403 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G403_LIGHTSPEED_VIRTUAL_PID, 2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G502 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G502_LIGHTSPEED_VIRTUAL_PID, 2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G703 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G703_LIGHTSPEED_VIRTUAL_PID, 2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G900 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G900_LIGHTSPEED_VIRTUAL_PID, 2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G903 Wireless Gaming Mouse",                DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G903_LIGHTSPEED_VIRTUAL_PID, 2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G Pro Wireless Gaming Mouse",               DetectLogitechWireless,     LOGITECH_VID, LOGITECH_G_PRO_WIRELESS_VIRTUAL_PID,  2, 0xFF00, 2);
+
+/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Lightspeed Wireless Devices (Linux Wired)                                                                                                          |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Logitech G403 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G403_LIGHTSPEED_PID,         1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G502 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G502_LIGHTSPEED_PID,         1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G703 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G703_LIGHTSPEED_PID,         1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G900 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G900_LIGHTSPEED_PID,         1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G903 Wireless Gaming Mouse (wired)",        DetectLogitechWired,        LOGITECH_VID, LOGITECH_G903_LIGHTSPEED_PID,         1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G Pro Wireless Gaming Mouse (wired)",       DetectLogitechWired,        LOGITECH_VID, LOGITECH_G_PRO_WIRELESS_PID,          2, 0xFF00, 2);
+
+#endif

Controllers/LogitechController/LogitechG203Controller.cpp

@@ -1,95 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechG203Controller.cpp               |
-|                                           |
-|  Driver for Logitech G203 Prodigy mouse   |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/17/2020   |
-\*-----------------------------------------*/
-
-#include "LogitechG203Controller.h"
-
-#include <cstring>
-
-LogitechG203Controller::LogitechG203Controller(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-LogitechG203Controller::~LogitechG203Controller()
-{
-    hid_close(dev);
-}
-
-std::string LogitechG203Controller::GetDeviceLocation()
-{
-    return("HID " + location);
-}
-
-std::string LogitechG203Controller::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);
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void LogitechG203Controller::SendMouseMode
-    (
-    unsigned char       mode,
-    unsigned short      speed,
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-    )
-{
-    char usb_buf[20];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x11;
-    usb_buf[0x01]           = 0xFF;
-    usb_buf[0x02]           = 0x0E;
-    usb_buf[0x03]           = 0x3C;
-    usb_buf[0x04]           = 0x00;
-
-    usb_buf[0x05]           = mode;
-
-    usb_buf[0x06]           = red;
-    usb_buf[0x07]           = green;
-    usb_buf[0x08]           = blue;
-
-    speed = 100 * speed;
-    if(mode == LOGITECH_G203_MODE_CYCLE)
-    {
-        usb_buf[0x0B]       = speed >> 8;
-        usb_buf[0x0C]       = speed & 0xFF;
-        usb_buf[0x0D]       = 0x64;
-    }
-    else if(mode == LOGITECH_G203_MODE_BREATHING)
-    {
-        usb_buf[0x09]       = speed >> 8;
-        usb_buf[0x0A]       = speed & 0xFF;
-        usb_buf[0x0C]       = 0x64;
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 20);
-    hid_read(dev, (unsigned char *)usb_buf, 20);
-}

Controllers/LogitechController/LogitechG203Controller.h

@@ -1,57 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechG203Controller.h                 |
-|                                           |
-|  Definitions and types for Logitech G203  |
-|  Prodigy mouse lighting controller        |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/17/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    LOGITECH_G203_MODE_OFF               = 0x00,
-    LOGITECH_G203_MODE_STATIC            = 0x01,
-    LOGITECH_G203_MODE_CYCLE             = 0x02,
-    LOGITECH_G203_MODE_BREATHING         = 0x03,
-};
-
-/*---------------------------------------------------------------------------------------------*\
-| Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are multiplied by 100 later to give lots of GUI steps.                                 |
-\*---------------------------------------------------------------------------------------------*/
-enum
-{
-    LOGITECH_G203_SPEED_SLOWEST          = 0xC8,    /* Slowest speed                           */
-    LOGITECH_G203_SPEED_NORMAL           = 0x32,    /* Normal speed                            */
-    LOGITECH_G203_SPEED_FASTEST          = 0x0A,    /* Fastest speed                           */
-};
-
-class LogitechG203Controller
-{
-public:
-    LogitechG203Controller(hid_device* dev_handle, const char* path);
-    ~LogitechG203Controller();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void        SendMouseMode
-                   (
-                   unsigned char       mode,
-                   unsigned short      speed,
-                   unsigned char       red,
-                   unsigned char       green,
-                   unsigned char       blue
-                   );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-};

Controllers/LogitechController/LogitechG203LController.cpp

@@ -21,7 +21,12 @@ std::string LogitechG203LController::GetDeviceLocation()
 std::string LogitechG203LController::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());

Controllers/LogitechController/LogitechG213Controller.cpp

@@ -28,7 +28,12 @@ std::string LogitechG213Controller::GetDeviceLocation()
 std::string LogitechG213Controller::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());

Controllers/LogitechController/LogitechG303Controller.cpp

@@ -1,81 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechG303Controller.cpp               |
-|                                           |
-|  Driver for Logitech G303 Daedalus Apex   |
-|  mouse lighting controller                |
-|                                           |
-|  TheRogueZeta   02/14/2021                |
-\*-----------------------------------------*/
-
-#include "LogitechG303Controller.h"
-
-#include <cstring>
-
-LogitechG303Controller::LogitechG303Controller(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-LogitechG303Controller::~LogitechG303Controller()
-{
-    hid_close(dev);
-}
-
-std::string LogitechG303Controller::GetDeviceLocation()
-{
-    return(location);
-}
-
-void LogitechG303Controller::SendMouseMode
-    (
-    unsigned char       mode,
-    std::uint16_t       speed,
-    unsigned char       channel,
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-    )
-{
-    unsigned char usb_buf[20];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x11;
-    usb_buf[0x01]           = 0xFF;
-    usb_buf[0x02]           = 0x0E;
-    usb_buf[0x03]           = 0x3C;
-    usb_buf[0x04]           = channel;
-
-    usb_buf[0x05]           = mode;
-
-    usb_buf[0x06]           = red;
-    usb_buf[0x07]           = green;
-    usb_buf[0x08]           = blue;
-
-    speed = 100 * speed;
-    if(mode == LOGITECH_G303_MODE_CYCLE)
-    {
-        usb_buf[0x0B]   = speed >> 8;
-        usb_buf[0x0C]   = speed & 0xFF;
-        usb_buf[0x0D]   = 0x64;
-    }
-    else if(mode == LOGITECH_G303_MODE_BREATHING)
-    {
-        usb_buf[0x09]   = speed >> 8;
-        usb_buf[0x0A]   = speed & 0xFF;
-        usb_buf[0x0C]   = 0x64;
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 20);
-    hid_read(dev, usb_buf, 20);
-}

Controllers/LogitechController/LogitechG303Controller.h

@@ -1,57 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechG303Controller.h                 |
-|                                           |
-|  Definitions and types for Logitech G303  |
-|  Daedalus Apex mouse lighting controller  |
-|                                           |
-|  TheRogueZeta   02/14/2021                |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    LOGITECH_G303_MODE_OFF               = 0x00,
-    LOGITECH_G303_MODE_STATIC            = 0x01,
-    LOGITECH_G303_MODE_CYCLE             = 0x02,
-    LOGITECH_G303_MODE_BREATHING         = 0x03,
-};
-
-/*---------------------------------------------------------------------------------------------*\
-| Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are mutipled by 100 later to give lots of GUI steps.                                   |
-\*---------------------------------------------------------------------------------------------*/
-enum
-{
-    LOGITECH_G303_SPEED_SLOWEST          = 0xC8,    /* Slowest speed                           */
-    LOGITECH_G303_SPEED_NORMAL           = 0x32,    /* Normal speed                            */
-    LOGITECH_G303_SPEED_FASTEST          = 0x0A,    /* Fastest speed                           */
-};
-
-class LogitechG303Controller
-{
-public:
-    LogitechG303Controller(hid_device* dev_handle, const char* path);
-    ~LogitechG303Controller();
-
-    std::string GetDeviceLocation();
-
-    void        SendMouseMode
-                   (
-                    unsigned char       mode,
-                    unsigned short      speed,
-                    unsigned char       channel,
-                    unsigned char       red,
-                    unsigned char       green,
-                    unsigned char       blue
-                   );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-};

Controllers/LogitechController/LogitechG403Controller.cpp

@@ -1,92 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechG403Controller.cpp               |
-|                                           |
-|  Driver for Logitech G403 Prodigy mouse   |
-|  lighting controller                      |
-|                                           |
-|  Martin Hartl (inlart) 5/19/2020          |
-\*-----------------------------------------*/
-
-#include "LogitechG403Controller.h"
-
-#include <cstring>
-
-LogitechG403Controller::LogitechG403Controller(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-LogitechG403Controller::~LogitechG403Controller()
-{
-    hid_close(dev);
-}
-
-std::string LogitechG403Controller::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string LogitechG403Controller::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 LogitechG403Controller::SendMouseMode
-    (
-    unsigned char       mode,
-    std::uint16_t       speed,
-    unsigned char       channel,
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-    )
-{
-    unsigned char usb_buf[20];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x11;
-    usb_buf[0x01]           = 0xFF;
-    usb_buf[0x02]           = 0x0E;
-    usb_buf[0x03]           = 0x3C;
-    usb_buf[0x04]           = channel;
-
-    usb_buf[0x05]           = mode;
-
-    usb_buf[0x06]           = red;
-    usb_buf[0x07]           = green;
-    usb_buf[0x08]           = blue;
-
-    speed = 100 * speed;
-    if(mode == LOGITECH_G403_MODE_CYCLE)
-    {
-        usb_buf[0x0B]       = speed >> 8;
-        usb_buf[0x0C]       = speed & 0xFF;
-        usb_buf[0x0D]       = 0x64;
-    }
-    else if(mode == LOGITECH_G403_MODE_BREATHING)
-    {
-        usb_buf[0x09]       = speed >> 8;
-        usb_buf[0x0A]       = speed & 0xFF;
-        usb_buf[0x0C]       = 0x64;
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 20);
-    hid_read(dev, usb_buf, 20);
-}

Controllers/LogitechController/LogitechG403Controller.h

@@ -1,58 +0,0 @@
-/*-----------------------------------------*\
-|  LogitechG403Controller.h                 |
-|                                           |
-|  Definitions and types for Logitech G403  |
-|  Prodigy mouse lighting controller        |
-|                                           |
-|  Martin Hartl (inlart) 5/19/2020          |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    LOGITECH_G403_MODE_OFF               = 0x00,
-    LOGITECH_G403_MODE_STATIC            = 0x01,
-    LOGITECH_G403_MODE_CYCLE             = 0x02,
-    LOGITECH_G403_MODE_BREATHING         = 0x03,
-};
-
-/*---------------------------------------------------------------------------------------------*\
-| Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are multiplied by 100 later to give lots of GUI steps.                                 |
-\*---------------------------------------------------------------------------------------------*/
-enum
-{
-    LOGITECH_G403_SPEED_SLOWEST          = 0xC8,    /* Slowest speed                           */
-    LOGITECH_G403_SPEED_NORMAL           = 0x32,    /* Normal speed                            */
-    LOGITECH_G403_SPEED_FASTEST          = 0x0A,    /* Fastest speed                           */
-};
-
-class LogitechG403Controller
-{
-public:
-    LogitechG403Controller(hid_device* dev_handle, const char* path);
-    ~LogitechG403Controller();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void        SendMouseMode
-                   (
-                    unsigned char       mode,
-                    unsigned short      speed,
-                    unsigned char       channel,
-                    unsigned char       red,
-                    unsigned char       green,
-                    unsigned char       blue
-                   );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-};

Controllers/LogitechController/LogitechG502PSController.cpp

@@ -1,94 +0,0 @@
-/*-----------------------------------------*\
-|  Logitech502PSController.cpp              |
-|                                           |
-|  Driver for Logitech G502 Proteus         |
-|  Spectrum mouse lighting controller       |
-|                                           |
-|  kernzerfall 07/28/2020                   |
-\*-----------------------------------------*/
-
-#include "LogitechG502PSController.h"
-
-#include <cstring>
-
-LogitechG502PSController::LogitechG502PSController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-LogitechG502PSController::~LogitechG502PSController()
-{
-    hid_close(dev);
-}
-
-std::string LogitechG502PSController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string LogitechG502PSController::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 LogitechG502PSController::SendMouseMode
-    (
-    unsigned char       mode,
-    std::uint16_t       speed,
-    unsigned char       channel,
-    unsigned char       red,
-    unsigned char       green,
-    unsigned char       blue
-    )
-{
-    unsigned char usb_buf[20];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x11;
-    usb_buf[0x01]           = 0xFF;
-    usb_buf[0x02]           = 0x02;
-    usb_buf[0x03]           = 0x3A;
-    usb_buf[0x04]           = channel;
-
-    usb_buf[0x05]           = mode;
-
-    usb_buf[0x06]           = red;
-    usb_buf[0x07]           = green;
-    usb_buf[0x08]           = blue;
-
-    speed = 100 * speed;
-    if(mode == LOGITECH_G502_PS_MODE_CYCLE)
-    {
-        usb_buf[0x0B]       = speed >> 8;
-        usb_buf[0x0C]       = speed & 0xFF;
-        usb_buf[0x0D]       = 0x64;
-    }
-    else if(mode == LOGITECH_G502_PS_MODE_BREATHING)
-    {
-        usb_buf[0x09]       = speed >> 8;
-        usb_buf[0x0A]       = speed & 0xFF;
-        usb_buf[0x0C]       = 0x64;
-    }else if(mode == LOGITECH_G502_PS_MODE_STATIC){
-        usb_buf[0x09]       = 0x02;
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 20);
-    hid_read(dev, usb_buf, 20);
-}

Controllers/LogitechController/LogitechG502PSController.h

@@ -1,59 +0,0 @@
-/*-----------------------------------------*\
-|  Logitech502PSController.h                |
-|                                           |
-|  Definitions and types for Logitech       |
-|  G502 Proteus Spectrum mouse lighting     |
-|  controller                               |
-|                                           |
-|  kernzerfall 07/28/2020                   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    LOGITECH_G502_PS_MODE_OFF               = 0x00,
-    LOGITECH_G502_PS_MODE_STATIC            = 0x01,
-    LOGITECH_G502_PS_MODE_CYCLE             = 0x03,
-    LOGITECH_G502_PS_MODE_BREATHING         = 0x02
-};
-
-/*---------------------------------------------------------------------------------------------*\
-| Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are multiplied by 100 later to give lots of GUI steps.                                 |
-\*---------------------------------------------------------------------------------------------*/
-enum
-{
-    LOGITECH_G502_PS_SPEED_SLOWEST          = 0xC8,     /* Slowest speed                       */
-    LOGITECH_G502_PS_SPEED_NORMAL           = 0x32,     /* Normal speed                        */
-    LOGITECH_G502_PS_SPEED_FASTEST          = 0x0A,     /* Fastest speed                       */
-};
-
-class LogitechG502PSController
-{
-public:
-    LogitechG502PSController(hid_device* dev_handle, const char* path);
-    ~LogitechG502PSController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void        SendMouseMode
-                   (
-                    unsigned char       mode,
-                    unsigned short      speed,
-                    unsigned char       channel,
-                    unsigned char       red,
-                    unsigned char       green,
-                    unsigned char       blue
-                   );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-};

Controllers/LogitechController/LogitechG560Controller.cpp

@@ -134,7 +134,7 @@ void LogitechG560Controller::fail_retry_write(hid_device *device, const unsigned
         if(ret == 20)
         {
             std::this_thread::sleep_for(1ms);
-            hid_read_timeout(dev, usb_buf_out, LOGI_G560_LED_PACKET_SIZE, 200);
+            hid_read_timeout(dev, usb_buf_out, LOGI_G560_LED_PACKET_SIZE, 20);
             break;
         }
         else

Controllers/LogitechController/LogitechG810Controller.cpp

@@ -25,7 +25,12 @@ LogitechG810Controller::~LogitechG810Controller()
 std::string LogitechG810Controller::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev_pkt_0x11, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev_pkt_0x11, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/LogitechController/LogitechG815Controller.cpp

@@ -24,7 +24,12 @@ LogitechG815Controller::~LogitechG815Controller()
 std::string LogitechG815Controller::GetSerialString()
 {
     wchar_t serial_string[128];
-    hid_get_serial_number_string(dev_pkt_0x11, serial_string, 128);
+    int ret = hid_get_serial_number_string(dev_pkt_0x11, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
 
     std::wstring return_wstring = serial_string;
     std::string return_string(return_wstring.begin(), return_wstring.end());

Controllers/LogitechController/LogitechG910Controller.cpp

@@ -0,0 +1,186 @@
+/*-----------------------------------------*\
+|  LogitechG910Controller.cpp               |
+|                                           |
+|  Driver for Logitech G910 Orion Spectrum  |
+|  keyboard light controller                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/11/2020   |
+\*-----------------------------------------*/
+
+#include "LogitechG910Controller.h"
+#include <cstring>
+
+LogitechG910Controller::LogitechG910Controller(hid_device* dev_handle_0x11, hid_device* dev_handle_0x12)
+{
+    dev_pkt_0x11 = dev_handle_0x11;
+    dev_pkt_0x12 = dev_handle_0x12;
+}
+
+LogitechG910Controller::~LogitechG910Controller()
+{
+    hid_close(dev_pkt_0x11);
+    hid_close(dev_pkt_0x12);
+}
+
+std::string LogitechG910Controller::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev_pkt_0x11, 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 LogitechG910Controller::Commit()
+{
+    SendCommit();
+}
+
+void LogitechG910Controller::SetDirect
+    (
+    unsigned char       zone,
+    unsigned char       frame_count,
+    unsigned char *     frame_data
+    )
+{
+    SendDirectFrame(zone, frame_count, frame_data);
+}
+
+void LogitechG910Controller::SetMode
+    (
+    unsigned char       mode,
+    unsigned short      speed,
+    unsigned char       red,
+    unsigned char       green,
+    unsigned char       blue
+    )
+{
+    SendMode(LOGITECH_G910_ZONE_MODE_KEYBOARD, mode, speed, red, green, blue);
+    SendMode(LOGITECH_G910_ZONE_MODE_LOGO,     mode, speed, red, green, blue);
+
+    SendCommit();
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void LogitechG910Controller::SendCommit()
+{
+    char usb_buf[20];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x11;
+    usb_buf[0x01]           = 0xFF;
+    usb_buf[0x02]           = 0x0F;
+    usb_buf[0x03]           = 0x5F;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
+    hid_read(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
+}
+
+void LogitechG910Controller::SendDirectFrame
+    (
+    unsigned char       zone,
+    unsigned char       frame_count,
+    unsigned char *     frame_data
+    )
+{
+    char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Lighting Control packet                        |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x12;
+    usb_buf[0x01]           = 0xFF;
+    usb_buf[0x02]           = 0x0F;
+    usb_buf[0x03]           = 0x3F;
+    usb_buf[0x05]           = zone;
+    usb_buf[0x07]           = frame_count;
+
+    /*-----------------------------------------------------*\
+    | Copy in frame data                                    |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x08], frame_data, frame_count * 4);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev_pkt_0x12, (unsigned char *)usb_buf, 64);
+    hid_read(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
+}
+
+void LogitechG910Controller::SendMode
+    (
+    unsigned char       zone,
+    unsigned char       mode,
+    unsigned short      speed,
+    unsigned char       red,
+    unsigned char       green,
+    unsigned char       blue
+    )
+{
+    char usb_buf[20];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Lighting Control packet                        |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x11;
+    usb_buf[0x01]           = 0xFF;
+    usb_buf[0x02]           = 0x10;
+    usb_buf[0x03]           = 0x3B;
+    usb_buf[0x04]           = zone;
+
+    usb_buf[0x05]           = mode;
+
+    usb_buf[0x06]           = red;
+    usb_buf[0x07]           = green;
+    usb_buf[0x08]           = blue;
+
+    speed = 100 * speed;
+    if(mode == LOGITECH_G910_MODE_CYCLE)
+    {
+        usb_buf[0x0B]       = speed >> 8;
+        usb_buf[0x0C]       = speed & 0xFF;
+        usb_buf[0x0D]       = 0x64;
+    }
+    else if(mode == LOGITECH_G910_MODE_BREATHING)
+    {
+        usb_buf[0x09]       = speed >> 8;
+        usb_buf[0x0A]       = speed & 0xFF;
+        usb_buf[0x0C]       = 0x64;
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
+    hid_read(dev_pkt_0x11, (unsigned char *)usb_buf, 20);
+}

Controllers/LogitechController/LogitechG910Controller.h

@@ -0,0 +1,99 @@
+/*-----------------------------------------*\
+|  LogitechG910Controller.h                 |
+|                                           |
+|  Definitions and types for Logitech G910  |
+|  Orion Spectrum keyboard light controller |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/11/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    LOGITECH_G910_ZONE_MODE_KEYBOARD     = 0x00,
+    LOGITECH_G910_ZONE_MODE_LOGO         = 0x01,
+};
+
+enum
+{
+    LOGITECH_G910_ZONE_DIRECT_KEYBOARD   = 0x01,
+    LOGITECH_G910_ZONE_DIRECT_GKEYS      = 0x04,
+    LOGITECH_G910_ZONE_DIRECT_LOGO       = 0x10,
+    LOGITECH_G910_ZONE_DIRECT_INDICATORS = 0x40,
+};
+
+enum
+{
+    LOGITECH_G910_MODE_OFF               = 0x00,
+    LOGITECH_G910_MODE_STATIC            = 0x01,
+    LOGITECH_G910_MODE_BREATHING         = 0x02,
+    LOGITECH_G910_MODE_CYCLE             = 0x03,
+    LOGITECH_G910_MODE_WAVE              = 0x04,
+};
+
+/*---------------------------------------------------------------------------------------------*\
+| Speed is 1000 for fast and 20000 for slow.                                                    |
+| Values are multiplied by 100 later to give lots of GUI steps.                                 |
+\*---------------------------------------------------------------------------------------------*/
+enum
+{
+    LOGITECH_G910_SPEED_SLOWEST          = 0xC8,     /* Slowest speed                       */
+    LOGITECH_G910_SPEED_NORMAL           = 0x32,     /* Normal speed                        */
+    LOGITECH_G910_SPEED_FASTEST          = 0x0A,     /* Fastest speed                       */
+};
+
+class LogitechG910Controller
+{
+public:
+    LogitechG910Controller(hid_device* dev_handle_0x11, hid_device* dev_handle_0x12);
+    ~LogitechG910Controller();
+
+    std::string GetSerialString();
+
+    void        Commit();
+    
+    void        SetDirect
+                    (
+                    unsigned char       zone,
+                    unsigned char       frame_count,
+                    unsigned char *     frame_data
+                    );
+
+    void        SetMode
+                    (
+                    unsigned char       mode,
+                    unsigned short      speed,
+                    unsigned char       red,
+                    unsigned char       green,
+                    unsigned char       blue
+                    );
+
+private:
+    hid_device* dev_pkt_0x11;
+    hid_device* dev_pkt_0x12;
+
+    void        SendDirectFrame
+                    (
+                    unsigned char       zone,
+                    unsigned char       frame_count,
+                    unsigned char *     frame_data
+                    );
+
+    void        SendMode
+                    (
+                    unsigned char       zone,
+                    unsigned char       mode,
+                    unsigned short      speed,
+                    unsigned char       red,
+                    unsigned char       green,
+                    unsigned char       blue
+                    );
+
+    void        SendCommit();
+};