diff --git a/Controllers/EVGAGPUController/EVGAGPUCommon.h b/Controllers/EVGAGPUController/EVGAGPUCommon.h new file mode 100644 index 00000000..540cd4b6 --- /dev/null +++ b/Controllers/EVGAGPUController/EVGAGPUCommon.h @@ -0,0 +1,21 @@ +/*-------------------------------------------------------------------*\ +| EVGAGPUCommon.h | +| | +| Common classes and functions for EVGA GPUs | +| | +| Chris M (Dr_No) 11th July 2021 | +\*-------------------------------------------------------------------*/ + +#pragma once + +union u16_to_u8 +{ + uint16_t u16; + struct + { + uint8_t LSB; + uint8_t MSB; + }; +}; + +#define EVGA_DETECT_MESSAGE "[%s] Found a device match at Bus %02d for Device %04x and SubDevice %04x: %s" \ No newline at end of file diff --git a/Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp b/Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp index 24266b71..5a7ee302 100644 --- a/Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp +++ b/Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp @@ -1,9 +1,13 @@ #include "Detector.h" +#include "EVGAGPUCommon.h" #include "EVGAGPUv1Controller.h" #include "EVGAGPUv2Controller.h" +#include "EVGAGPUv3Controller.h" +#include "LogManager.h" #include "RGBController.h" #include "RGBController_EVGAGPUv1.h" #include "RGBController_EVGAGPUv2.h" +#include "RGBController_EVGAGPUv3.h" #include "i2c_smbus.h" #include "pci_ids.h" #include @@ -14,6 +18,7 @@ enum { EVGA_RGB_V1, EVGA_RGB_V2, + EVGA_RGB_V3, }; typedef struct @@ -30,26 +35,69 @@ typedef struct static const gpu_pci_device device_list[] = { - { NVIDIA_VEN, NVIDIA_GTX1070_DEV, EVGA_SUB_VEN, EVGA_GTX1070_FTW_SUB_DEV, EVGA_RGB_V1, "EVGA GeForce GTX 1070 FTW" }, - { NVIDIA_VEN, NVIDIA_GTX1070TI_DEV, EVGA_SUB_VEN, EVGA_GTX1070TI_FTW2_SUB_DEV, EVGA_RGB_V1, "EVGA GeForce GTX 1070 Ti FTW2" }, - { NVIDIA_VEN, NVIDIA_GTX1080_DEV, EVGA_SUB_VEN, EVGA_GTX1080_FTW_SUB_DEV, EVGA_RGB_V1, "EVGA GeForce GTX 1080 FTW" }, - { NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070_XC_GAMING_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2070 XC Gaming" }, - { NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070_XC_OC_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2070 XC OC" }, - { NVIDIA_VEN, NVIDIA_RTX2070S_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_BLACK_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2070 SUPER Black" }, - { NVIDIA_VEN, NVIDIA_RTX2070S_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_XC_ULTRA_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2070 SUPER XC Ultra" }, - { NVIDIA_VEN, NVIDIA_RTX2070S_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_XC_ULTRA_PLUS_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2070 SUPER XC Ultra+" }, - { NVIDIA_VEN, NVIDIA_RTX2080_DEV, EVGA_SUB_VEN, EVGA_RTX2080_BLACK_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 Black" }, - { NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080_XC_BLACK_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 XC Black" }, - { NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080_XC_GAMING_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 XC Gaming" }, - { NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080_XC_ULTRA_GAMING_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 XC Ultra Gaming" }, - { NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_XC_GAMING_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 SUPER XC Gaming" }, - { NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_FTW3_ULTRA_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 SUPER FTW3 Ultra" }, - { NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_FTW3_ULTRA_HC_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 SUPER FTW3 Ultra Hydro Copper" }, - { NVIDIA_VEN, NVIDIA_RTX2080TI_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_BLACK_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080Ti Black" }, - { NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_XC_ULTRA_GAMING_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080Ti XC Ultra" }, - { NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_XC_HYBRID_GAMING_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080Ti XC HYBRID GAMING" }, - { NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_FTW3_ULTRA_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080Ti FTW3 Ultra" }, - + { NVIDIA_VEN, NVIDIA_GTX1070_DEV, EVGA_SUB_VEN, EVGA_GTX1070_FTW_SUB_DEV, EVGA_RGB_V1, "EVGA GeForce GTX 1070 FTW" }, + { NVIDIA_VEN, NVIDIA_GTX1070TI_DEV, EVGA_SUB_VEN, EVGA_GTX1070TI_FTW2_SUB_DEV, EVGA_RGB_V1, "EVGA GeForce GTX 1070 Ti FTW2" }, + { NVIDIA_VEN, NVIDIA_GTX1080_DEV, EVGA_SUB_VEN, EVGA_GTX1080_FTW_SUB_DEV, EVGA_RGB_V1, "EVGA GeForce GTX 1080 FTW" }, + { NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070_XC_GAMING_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2070 XC Gaming" }, + { NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070_XC_OC_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2070 XC OC" }, + { NVIDIA_VEN, NVIDIA_RTX2070S_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_BLACK_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2070 SUPER Black" }, + { NVIDIA_VEN, NVIDIA_RTX2070S_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_XC_ULTRA_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2070 SUPER XC Ultra" }, + { NVIDIA_VEN, NVIDIA_RTX2070S_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_XC_ULTRA_PLUS_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2070 SUPER XC Ultra+" }, + { NVIDIA_VEN, NVIDIA_RTX2080_DEV, EVGA_SUB_VEN, EVGA_RTX2080_BLACK_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 Black" }, + { NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080_XC_BLACK_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 XC Black" }, + { NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080_XC_GAMING_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 XC Gaming" }, + { NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080_XC_ULTRA_GAMING_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 XC Ultra Gaming" }, + { NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_XC_GAMING_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 SUPER XC Gaming" }, + { NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_FTW3_ULTRA_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 SUPER FTW3 Ultra" }, + { NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_FTW3_ULTRA_HC_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 SUPER FTW3 Ultra Hydro Copper" }, + { NVIDIA_VEN, NVIDIA_RTX2080TI_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_BLACK_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080Ti Black" }, + { NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_XC_ULTRA_GAMING_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080Ti XC Ultra" }, + { NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_XC_HYBRID_GAMING_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080Ti XC HYBRID GAMING" }, + { NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_FTW3_ULTRA_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080Ti FTW3 Ultra" }, + { NVIDIA_VEN, NVIDIA_RTX3060TI_DEV, EVGA_SUB_VEN, EVGA_RTX3060TI_FTW3_GAMING_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3060TI FTW3 Gaming" }, + { NVIDIA_VEN, NVIDIA_RTX3060TI_DEV, EVGA_SUB_VEN, EVGA_RTX3060TI_FTW3_ULTRA_KL_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3060TI FTW3 Ultra LHR" }, + { NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3060TI_FTW3_ULTRA_KL_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3060TI FTW3 Ultra LHR" }, + { NVIDIA_VEN, NVIDIA_RTX3070_DEV, EVGA_SUB_VEN, EVGA_RTX3070_XC3_BLACK_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3070 Black Gaming" }, + { NVIDIA_VEN, NVIDIA_RTX3070_DEV, EVGA_SUB_VEN, EVGA_RTX3070_XC3_GAMING_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3070 XC3 Gaming" }, + { NVIDIA_VEN, NVIDIA_RTX3070_DEV, EVGA_SUB_VEN, EVGA_RTX3070_XC3_ULTRA_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3070 XC3 Ultra" }, + { NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3070_XC3_ULTRA_LHR_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3070 XC3 Ultra LHR" }, + { NVIDIA_VEN, NVIDIA_RTX3070_DEV, EVGA_SUB_VEN, EVGA_RTX3070_FTW3_ULTRA_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3070 FTW3 Ultra" }, + { NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3070_FTW3_ULTRA_LHR_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3070 FTW3 Ultra LHR" }, + { NVIDIA_VEN, NVIDIA_RTX3070TI_DEV, EVGA_SUB_VEN, EVGA_RTX3070TI_XC3_GAMING_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3070Ti XC3 Gaming" }, + { NVIDIA_VEN, NVIDIA_RTX3070TI_DEV, EVGA_SUB_VEN, EVGA_RTX3070TI_XC3_ULTRA_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3070Ti XC3 Ultra" }, + { NVIDIA_VEN, NVIDIA_RTX3070TI_DEV, EVGA_SUB_VEN, EVGA_RTX3070TI_FTW3_ULTRA_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3070Ti FTW3 Ultra" }, + { NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_BLACK_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 XC3 Black" }, + { NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_BLACK_LHR_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 XC3 Black LHR" }, + { NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_GAMING_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 XC3 Gaming" }, + { NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_GAMING_LHR_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 XC3 Gaming LHR" }, + { NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_ULTRA_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 XC3 Ultra" }, + { NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_ULTRA_LHR_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 XC3 Ultra LHR" }, + { NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_ULTRA_HYBRID_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 XC3 Ultra Hybrid" }, + { NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_ULTRA_HYBRID_LHR_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 XC3 Ultra Hybrid LHR" }, + { NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_ULTRA_HC_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 XC3 Ultra Hydro Copper" }, + { NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_FTW3_GAMING_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 FTW3 Gaming" }, + { NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_FTW3_ULTRA_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 FTW3 Ultra" }, + { NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_FTW3_ULTRA_LHR_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 FTW3 Ultra LHR" }, + { NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_FTW3_ULTRA_HYBRID_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 FTW3 Ultra Hybrid" }, + { NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_FTW3_ULTRA_HYBRID_LHR_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 FTW3 Ultra Hybrid LHR" }, + { NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_FTW3_ULTRA_HC_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080 FTW3 Ultra Hydro Copper" }, + { NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, EVGA_SUB_VEN, EVGA_RTX3080TI_XC3_GAMING_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080Ti XC3 Gaming" }, + { NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, EVGA_SUB_VEN, EVGA_RTX3080TI_XC3_GAMING_HYBRID_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080Ti XC3 Gaming Hybrid" }, + { NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, EVGA_SUB_VEN, EVGA_RTX3080TI_XC3_GAMING_HC_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080Ti XC3 Gaming Hydro Copper" }, + { NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, EVGA_SUB_VEN, EVGA_RTX3080TI_FTW3_ULTRA_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080Ti FTW3 Ultra" }, + { NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, EVGA_SUB_VEN, EVGA_RTX3080TI_FTW3_ULTRA_HYBRID_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080Ti FTW3 Ultra Hybrid" }, + { NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, EVGA_SUB_VEN, EVGA_RTX3080TI_FTW3_ULTRA_HC_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3080Ti FTW3 Ultra Hydro Copper" }, + { NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_XC3_BLACK_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3090 XC3 Black" }, + { NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_XC3_GAMING_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3090 XC3 Gaming" }, + { NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_XC3_ULTRA_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3090 XC3 Ultra" }, + { NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_XC3_ULTRA_HYBRID_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3090 XC3 Ultra Hybrid" }, + { NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_XC3_ULTRA_HC_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3090 XC3 Ultra Hydro Copper" }, + { NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_FTW3_ULTRA_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3090 FTW3 Ultra" }, + { NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_FTW3_ULTRA_V2_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3090 FTW3 Ultra v2" }, + { NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_FTW3_ULTRA_HYBRID_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3090 FTW3 Ultra Hybrid" }, + { NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_FTW3_ULTRA_HC_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3090 FTW3 Ultra Hydro Copper" }, + { NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_KINGPIN_HYBRID_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3090 K|NGP|N Hybrid" }, + { NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_KINGPIN_HC_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3090 K|NGP|N Hydro Copper" }, }; /******************************************************************************************\ @@ -83,6 +131,7 @@ void DetectEVGAGPUControllers(std::vector& busses) { case EVGA_RGB_V1: { + LOG_DEBUG(EVGA_DETECT_MESSAGE, EVGAGPUV1_CONTROLLER_NAME, bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name ); EVGAGPUv1Controller* new_controller; RGBController_EVGAGPUv1* new_rgbcontroller; @@ -95,6 +144,7 @@ void DetectEVGAGPUControllers(std::vector& busses) case EVGA_RGB_V2: { + LOG_DEBUG(EVGA_DETECT_MESSAGE, EVGAGPUV2_CONTROLLER_NAME, bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name ); EVGAGPUv2Controller* new_controller; RGBController_EVGAGPUv2* new_rgbcontroller; @@ -104,6 +154,29 @@ void DetectEVGAGPUControllers(std::vector& busses) ResourceManager::get()->RegisterRGBController(new_rgbcontroller); } break; + + case EVGA_RGB_V3: + { + LOG_DEBUG(EVGA_DETECT_MESSAGE, EVGAGPUV3_CONTROLLER_NAME, bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name ); + EVGAGPUv3Controller* new_controller; + RGBController_EVGAGPUv3* new_rgbcontroller; + + new_controller = new EVGAGPUv3Controller(busses[bus], 0x2D); + new_controller-> evgaGPUName = device_list[dev_idx].name; // Pass name of the card into the controller for logging. + + if(new_controller-> ReadFWVersion() != "") + { + new_rgbcontroller = new RGBController_EVGAGPUv3(new_controller); + new_rgbcontroller->name = device_list[dev_idx].name; + ResourceManager::get()->RegisterRGBController(new_rgbcontroller); + } + else + { + LOG_INFO("[%s] Failed to get a valid FW version, does the i2c interface support `i2c_smbus_read_i2c_block_data`?", new_controller-> evgaGPUName); + delete new_controller; + } + } + break; } } } diff --git a/Controllers/EVGAGPUController/EVGAGPUv1Controller.h b/Controllers/EVGAGPUController/EVGAGPUv1Controller.h index a1c69d53..e33bf8e6 100644 --- a/Controllers/EVGAGPUController/EVGAGPUv1Controller.h +++ b/Controllers/EVGAGPUController/EVGAGPUv1Controller.h @@ -14,6 +14,8 @@ typedef unsigned char evga_dev_id; +#define EVGAGPUV1_CONTROLLER_NAME "EVGAv1" + enum { EVGA_GPU_V1_REG_MODE = 0x0C, diff --git a/Controllers/EVGAGPUController/EVGAGPUv2Controller.h b/Controllers/EVGAGPUController/EVGAGPUv2Controller.h index 7d39e280..23c219a3 100644 --- a/Controllers/EVGAGPUController/EVGAGPUv2Controller.h +++ b/Controllers/EVGAGPUController/EVGAGPUv2Controller.h @@ -10,6 +10,7 @@ #include #include "i2c_smbus.h" #include "RGBController.h" +#include "EVGAGPUCommon.h" #pragma once @@ -19,6 +20,7 @@ typedef unsigned char evga_dev_id; #define EVGA_GPU_V2_BRIGHTNESS_MIN 0x01 #define EVGA_GPU_V2_BRIGHTNESS_DEFAULT 0x64 #define EVGA_GPU_V2_BRIGHTNESS_MAX 0x64 +#define EVGAGPUV2_CONTROLLER_NAME "EVGAv2" enum { @@ -70,16 +72,6 @@ enum EVGA_GPU_V2_SPEED_PULSE_FASTEST = 0x32, }; -typedef union -{ - uint16_t u16; - struct - { - uint8_t LSB; - uint8_t MSB; - }; -} u16_to_u8; - class EVGAGPUv2Controller { public: diff --git a/Controllers/EVGAGPUController/EVGAGPUv3Controller.cpp b/Controllers/EVGAGPUController/EVGAGPUv3Controller.cpp new file mode 100644 index 00000000..5921ebec --- /dev/null +++ b/Controllers/EVGAGPUController/EVGAGPUv3Controller.cpp @@ -0,0 +1,515 @@ +/*-----------------------------------------*\ +| EVGAGPUv3Controller.cpp | +| | +| Driver for EVGA GPU RGB V3 (Ampere) | +| lighting controller | +| | +| TheRogueZeta 7/15/2021 | +\*-----------------------------------------*/ + +#include "EVGAGPUv3Controller.h" +#include "LogManager.h" + +EVGAGPUv3Controller::EVGAGPUv3Controller(i2c_smbus_interface* bus, evga_dev_id dev) +{ + this->bus = bus; + this->dev = dev; +} + +EVGAGPUv3Controller::~EVGAGPUv3Controller() +{ + +} + +std::string EVGAGPUv3Controller::GetDeviceLocation() +{ + std::string return_string(bus->device_name); + char addr[5]; + + snprintf(addr, 5, "0x%02X", dev); + return_string.append(", address "); + return_string.append(addr); + return("I2C: " + return_string); +} + +void EVGAGPUv3Controller::GetDeviceModes() +{ + LOG_DEBUG("[%s] Getting Zone and LED count from HW", evgaGPUName); + uint8_t data_pkt[I2C_SMBUS_BLOCK_MAX] = {}; + + uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_MODE, 10, data_pkt); + if (result == 10) + { + for(uint8_t zone = 0 ; zone < 4; zone ++) + { + zone_modes[zone] = data_pkt[zone + 1]; + zone_led_count[zone] = data_pkt[zone + 5]; + LOG_DEBUG("[%s] Zone %1d LED count: %02d, mode: %02d", evgaGPUName, zone + 1, zone_led_count[zone], zone_modes[zone]); + } + zone_sync = data_pkt[9]; + LOG_DEBUG("[%s] Zone Sync is %1d", evgaGPUName, zone_sync); + } + else + { + LOG_DEBUG("[%s] Invalid block read result: %02d", evgaGPUName, result); + memset(zone_led_count, 0, sizeof(zone_led_count)); + memset(zone_modes, 0, sizeof(zone_modes)); + } + initCard(); +} + +std::string EVGAGPUv3Controller::GetFWVersion() +{ + return(fwVersion); +} + +std::string EVGAGPUv3Controller::ReadFWVersion() +{ + LOG_TRACE("[%s] Getting FW from HW", evgaGPUName); + uint8_t data_pkt[I2C_SMBUS_BLOCK_MAX] = {}; + std::string return_string = ""; + char version[8]; + + uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_FIRMWARE, 6, data_pkt); + if (result == 6) + { + uint8_t major = data_pkt[4]; + uint8_t minor = data_pkt[5]; + + snprintf(version, 8, "1.%02d.%02d", major, minor); + return_string.append(version); + LOG_TRACE("[%s] Firmware %s", evgaGPUName, version); + fwVersion = return_string; + return(return_string); + } + else + { + return ""; + } +} + +uint8_t EVGAGPUv3Controller::GetZoneMode(uint8_t zone) +{ + return zone_modes[zone]; +} + +EVGAv3_config EVGAGPUv3Controller::GetZoneConfig(uint8_t zone, uint8_t mode) +{ + EVGAv3_config zone_config; + u16_to_u8 speed16; + bool readFail = false; + + zone_config.brightness = EVGA_GPU_V3_BRIGHTNESS_DEFAULT; + zone_config.direction = 0; + zone_config.numberOfColors = 0; + zone_config.speed = EVGA_GPU_V3_SPEED_GENERIC_NORMAL; + + LOG_DEBUG("[%s] Retriving Zone %1d config for mode %1d from HW", evgaGPUName, zone, mode); + uint8_t data_pkt[I2C_SMBUS_BLOCK_MAX] = {}; + + switch (mode) + { + case EVGA_GPU_V3_MODE_STATIC: + { + uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + zone, 5, data_pkt); + if (result == 5) + { + //Load data + zone_config.brightness = data_pkt[1]; + uint8_t red = data_pkt[2]; + uint8_t green = data_pkt[3]; + uint8_t blue = data_pkt[4]; + zone_config.colors[0] = ToRGBColor(red, green, blue); + zone_config.numberOfColors = 1; + zone_config.speed = 0; + zone_config.direction = 0; + } + else + { + readFail = true; + } + } + break; + + case EVGA_GPU_V3_MODE_BREATHING: + { + uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_BREATHING + zone, 10, data_pkt); + if (result == 10) + { + //Load data + zone_config.brightness = data_pkt[1]; + uint8_t red1 = data_pkt[2]; + uint8_t green1 = data_pkt[3]; + uint8_t blue1 = data_pkt[4]; + zone_config.colors[0] = ToRGBColor(red1, green1, blue1); + uint8_t red2 = data_pkt[5]; + uint8_t green2 = data_pkt[6]; + uint8_t blue2 = data_pkt[7]; + zone_config.colors[1] = ToRGBColor(red2, green2, blue2); + zone_config.numberOfColors= (zone_config.colors[1] != 0 ) ? 2 : 1 ; + speed16.LSB = data_pkt[8]; + speed16.MSB = data_pkt[9]; + zone_config.speed = speed16.u16; + zone_config.direction = 0; + } + else + { + readFail = true; + } + } + break; + + case EVGA_GPU_V3_MODE_RAINBOW: + case EVGA_GPU_V3_MODE_RAINBOW_WAVE: + case EVGA_GPU_V3_MODE_STAR: + { + uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, 4, data_pkt); + if (result == 4) + { + //Load data + zone_config.brightness = data_pkt[1]; + zone_config.numberOfColors = 0; + speed16.LSB = data_pkt[2]; + speed16.MSB = data_pkt[3]; + zone_config.speed = speed16.u16; + } + else + { + readFail = true; + } + } + break; + + case EVGA_GPU_V3_MODE_WAVE: + { + uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, 7, data_pkt); + if (result == 7) + { + //Load data + zone_config.brightness = data_pkt[1]; + uint8_t red = data_pkt[2]; + uint8_t green = data_pkt[3]; + uint8_t blue = data_pkt[4]; + zone_config.colors[0] = ToRGBColor(red, green, blue); + zone_config.numberOfColors = 1; + speed16.LSB = data_pkt[5]; + speed16.MSB = data_pkt[6]; + zone_config.speed = speed16.u16; + } + else + { + readFail = true; + } + } + break; + + case EVGA_GPU_V3_MODE_COLOR_CYCLE: + case EVGA_GPU_V3_MODE_COLOR_STACK: + { + uint8_t cd_pkt[5]; + + if(mode == EVGA_GPU_V3_MODE_COLOR_STACK) + { + uint8_t color_count = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_COLOR_STACK_COLOR_COUNT, 5, cd_pkt); + + if(color_count == 5) + { + zone_config.numberOfColors = cd_pkt[zone + 1]; + } + else + { + readFail = true; + } + + uint8_t direction = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_COLOR_STACK_DIRECTION, 5, cd_pkt); + if(direction == 5) + { + zone_config.direction = cd_pkt[zone + 1]; + } + else + { + readFail = true; + } + + } + else + { + uint8_t color_count = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_COLOR_CYCLE_COUNT, 5, cd_pkt); + + if(color_count == 5) + { + zone_config.numberOfColors = cd_pkt[zone + 1]; + } + else + { + readFail = true; + } + } + + uint8_t result = bus->i2c_smbus_read_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, 31, data_pkt); + if (result == 31) + { + zone_config.brightness = data_pkt[1]; + for(uint8_t color_index = 0; color_index < zone_config.numberOfColors; color_index++) + { + uint8_t red = data_pkt[(color_index * 4) + 2]; + uint8_t green = data_pkt[(color_index * 4) + 3]; + uint8_t blue = data_pkt[(color_index * 4) + 4]; + zone_config.colors[color_index] = ToRGBColor(red, green, blue); + } + speed16.LSB = data_pkt[29]; + speed16.MSB = data_pkt[30]; + zone_config.speed = speed16.u16; + } + else + { + readFail = true; + } + } + break; + + default: + break; + } + + if(readFail == false) + { + LOG_TRACE("[%s] Zone %1d Brightness: 0x%02X, Colors: %1d, Speed: 0x%04X, Direction %1d.", evgaGPUName, zone, zone_config.brightness, zone_config.numberOfColors, zone_config.speed, zone_config.direction); + for(uint8_t color_index = 0; color_index < zone_config.numberOfColors; color_index++) + { + LOG_TRACE("[%s] Color Index [%2d]: 0x%06X", evgaGPUName, color_index, zone_config.colors[color_index]); + } + LOG_DEBUG("[%s] Done loading Zone %1d configuration from HW", evgaGPUName, zone); + } + else + { + zone_config.direction = 0; + zone_config.numberOfColors = 0; + for(uint8_t i = 0; i < 7; i++) + { + zone_config.colors[i] = 0; + } + LOG_DEBUG("[%s] Failed while loading Zone %1d configuration from HW", evgaGPUName, zone); + } + return zone_config; +} + +void EVGAGPUv3Controller::initCard() +{ + // This command needs to be sent before the card will respond to OpenRGB commands + // NvAPI_I2CWriteEx: Dev: 0x2D RegSize: 0x01 Reg: 0xB2 Size: 0x05 Data: 0x04 0xC6 0xEB 0xEA 0x15 + uint8_t data_pkt[5] = {0x04, 0xC6, 0xEB, 0xEA, 0x15}; + bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_ENABLE, sizeof(data_pkt), data_pkt); + LOG_TRACE("[%s] Sending SW int packet", evgaGPUName); + return; +} + +void EVGAGPUv3Controller::SaveConfig() +{ + LOG_DEBUG("[%s] Sending save packet", evgaGPUName); + + //NvAPI_I2CWriteEx: Dev: 0x2D RegSize: 0x01 Reg: 0x90 Size: 0x05 Data: 0x04 0x9E 0xEB 0x00 0x90 //Sent on close of PX1 + uint8_t data_pkt[5] = {0x04, 0x9E, 0xEB, 0x00, 0x90}; + + bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_SAVE, sizeof(data_pkt), data_pkt); + return; +} + +void EVGAGPUv3Controller::ResizeARGB(uint8_t newSize) +{ + if(newSize < EVGAGPUV3_LEDS_MIN) + { + newSize = EVGAGPUV3_LEDS_MIN; + } + else if(newSize > EVGAGPUV3_LEDS_MAX) + { + newSize = EVGAGPUV3_LEDS_MAX; + } + + LOG_DEBUG("[%s] Resizing ARGB header with %02d size", evgaGPUName, newSize); + uint8_t data_pkt[EVGAGPUV3_MODE_PACKET_SIZE] = { 0x09, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, + EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, newSize, EVGAGPUV3_INIT}; + + bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_MODE, sizeof(data_pkt), data_pkt); + return; +} + +void EVGAGPUv3Controller::SetAllModes(uint8_t zone_0_mode, uint8_t zone_1_mode,uint8_t zone_2_mode,uint8_t zone_3_mode, bool sync) +{ + uint8_t mode_pkt[EVGAGPUV3_MODE_PACKET_SIZE] = { EVGAGPUV3_MODE_PACKET_SIZE - 1, + EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, + EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, 0x0 }; + + // Hack to keep card in sync after power loss (standby) without requireing a rescan. + // To be replaced with code that calls this once upon system resume once OpenRGB + // knows about system power states. + initCard(); + + // Keep zone_modes in sync + zone_modes[0] = zone_0_mode; + zone_modes[1] = zone_1_mode; + zone_modes[2] = zone_2_mode; + zone_modes[3] = zone_3_mode; + + // Prep packet + mode_pkt[1] = zone_0_mode; + mode_pkt[2] = zone_1_mode; + mode_pkt[3] = zone_2_mode; + mode_pkt[4] = zone_3_mode; + mode_pkt[9] = sync; + + bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_MODE, EVGAGPUV3_MODE_PACKET_SIZE, mode_pkt); + //LOG_TRACE("[%s] Setting all zones to mode: %02d, %2d, %2d, %2d, zone sync %1d.", evgaGPUName, zone_0_mode, zone_1_mode, zone_2_mode, zone_3_mode, sync); +} + +void EVGAGPUv3Controller::SetZoneMode(uint8_t zone, uint8_t mode) +{ + uint8_t mode_pkt[EVGAGPUV3_MODE_PACKET_SIZE] = { EVGAGPUV3_MODE_PACKET_SIZE - 1, + EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, + EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, 0x0 }; + + // Hack to keep card in sync after power loss (standby) without requireing a rescan. + // To be replaced with code that calls this once upon system resume once OpenRGB + // knows about system power states. + initCard(); + + // Keep zone_modes in sync + zone_modes[zone] = mode; + // Prep packet + mode_pkt[zone + 1] = mode; + + bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_MODE, EVGAGPUV3_MODE_PACKET_SIZE, mode_pkt); + //LOG_TRACE("[%s] Setting individual zone %1d to mode %02d", evgaGPUName, zone, mode); +} + +void EVGAGPUv3Controller::SetZone(uint8_t zone, uint8_t mode, EVGAv3_config zone_config) +{ + std::string mode_name; + u16_to_u8 speed16 = { (uint16_t) zone_config.speed }; + + switch (mode) + { + case EVGA_GPU_V3_MODE_OFF: + break; + + case EVGA_GPU_V3_MODE_STATIC: + { + uint8_t zone_pkt[5] = {EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT, EVGAGPUV3_INIT}; + + zone_pkt[0] = sizeof(zone_pkt) - 1; + zone_pkt[1] = zone_config.brightness; + zone_pkt[2] = RGBGetRValue(zone_config.colors[0]); + zone_pkt[3] = RGBGetGValue(zone_config.colors[0]); + zone_pkt[4] = RGBGetBValue(zone_config.colors[0]); + + bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + zone, sizeof(zone_pkt), zone_pkt); + } + break; + + case EVGA_GPU_V3_MODE_BREATHING: + { + uint8_t zone_pkt[10]; + memset(zone_pkt, EVGAGPUV3_INIT, sizeof(zone_pkt)); + + zone_pkt[0] = sizeof(zone_pkt) - 1; + zone_pkt[1] = zone_config.brightness; + zone_pkt[2] = RGBGetRValue(zone_config.colors[0]); + zone_pkt[3] = RGBGetGValue(zone_config.colors[0]); + zone_pkt[4] = RGBGetBValue(zone_config.colors[0]); + if(zone_config.numberOfColors == 1) + { + zone_config.colors[1] = 0; + } + zone_pkt[5] = RGBGetRValue(zone_config.colors[1]); + zone_pkt[6] = RGBGetGValue(zone_config.colors[1]); + zone_pkt[7] = RGBGetBValue(zone_config.colors[1]); + zone_pkt[8] = speed16.LSB; + zone_pkt[9] = speed16.MSB; + + bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, sizeof(zone_pkt), zone_pkt); + } + break; + + case EVGA_GPU_V3_MODE_RAINBOW: + case EVGA_GPU_V3_MODE_RAINBOW_WAVE: + case EVGA_GPU_V3_MODE_STAR: + { + uint8_t zone_pkt[4]; + memset(zone_pkt, EVGAGPUV3_INIT, sizeof(zone_pkt)); + + zone_pkt[0] = sizeof(zone_pkt) - 1; + zone_pkt[1] = zone_config.brightness; + zone_pkt[2] = speed16.LSB; + zone_pkt[3] = speed16.MSB; + + bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, sizeof(zone_pkt), zone_pkt); + } + break; + + case EVGA_GPU_V3_MODE_WAVE: + { + uint8_t zone_pkt[7]; + memset(zone_pkt, EVGAGPUV3_INIT, sizeof(zone_pkt)); + + zone_pkt[0] = sizeof(zone_pkt) - 1; + zone_pkt[1] = zone_config.brightness; + zone_pkt[2] = RGBGetRValue(zone_config.colors[0]); + zone_pkt[3] = RGBGetGValue(zone_config.colors[0]); + zone_pkt[4] = RGBGetBValue(zone_config.colors[0]); + zone_pkt[5] = speed16.LSB; + zone_pkt[6] = speed16.MSB; + + bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, sizeof(zone_pkt), zone_pkt); + } + break; + + case EVGA_GPU_V3_MODE_COLOR_CYCLE: + case EVGA_GPU_V3_MODE_COLOR_STACK: + { + uint8_t zone_pkt[31];; + memset(zone_pkt, EVGAGPUV3_INIT, sizeof(zone_pkt)); + uint8_t color_cnt_pkt[5]; + memset(color_cnt_pkt, EVGAGPUV3_INIT, sizeof(color_cnt_pkt)); + + // Zone packet construction + zone_pkt[0] = sizeof(zone_pkt) - 1; + for(uint8_t color_index = 0; color_index < zone_config.numberOfColors; color_index++) + { + zone_pkt[1 + color_index * 4] = zone_config.brightness; + zone_pkt[2 + color_index * 4] = RGBGetRValue(zone_config.colors[color_index]); + zone_pkt[3 + color_index * 4] = RGBGetGValue(zone_config.colors[color_index]); + zone_pkt[4 + color_index * 4] = RGBGetBValue(zone_config.colors[color_index]); + } + zone_pkt[29] = speed16.LSB; + zone_pkt[30] = speed16.MSB; + + // Color Count packet construction + color_cnt_pkt[0] = sizeof(color_cnt_pkt) - 1; + color_cnt_pkt[zone+1] = zone_config.numberOfColors; + + if(mode == EVGA_GPU_V3_MODE_COLOR_STACK) + { + uint8_t direction_pkt[5]; + memset(direction_pkt, EVGAGPUV3_INIT, sizeof(direction_pkt)); + // Direction packet construction + direction_pkt[0] = sizeof(direction_pkt) - 1; + direction_pkt[zone+1] = zone_config.direction; + + bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, sizeof(zone_pkt), zone_pkt); + bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_COLOR_STACK_COLOR_COUNT, sizeof(color_cnt_pkt), color_cnt_pkt); + bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_COLOR_STACK_DIRECTION, sizeof(direction_pkt), direction_pkt); + } + else + { + bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_STATIC + ((mode -1) * 4) + zone, sizeof(zone_pkt), zone_pkt); + bus->i2c_smbus_write_i2c_block_data(dev, EVGA_GPU_V3_REG_COLOR_CYCLE_COUNT, sizeof(color_cnt_pkt), color_cnt_pkt); + } + } + break; + default: + { + LOG_TRACE("[%s] Mode %02d not found", evgaGPUName, mode); + } + break; + } +} diff --git a/Controllers/EVGAGPUController/EVGAGPUv3Controller.h b/Controllers/EVGAGPUController/EVGAGPUv3Controller.h new file mode 100644 index 00000000..06355189 --- /dev/null +++ b/Controllers/EVGAGPUController/EVGAGPUv3Controller.h @@ -0,0 +1,117 @@ +/*-----------------------------------------*\ +| EVGAGPUv3Controller.h | +| | +| Definitions and types for EVGA GPU RGB | +| V3 (Ampere) lighting controller | +| | +| TheRogueZeta 7/15/2021 | +\*-----------------------------------------*/ + +#include +#include "i2c_smbus.h" +#include "RGBController.h" +#include "EVGAGPUCommon.h" + +#pragma once + +typedef unsigned char evga_dev_id; + +#define SPEED_MULTIPLIER 10 +#define EVGAGPUV3_MODE_PACKET_SIZE 10 +#define EVGAGPUV3_LEDS_MIN 01 +#define EVGAGPUV3_LEDS_MAX 60 +#define EVGAGPUV3_INIT 0xFF +#define EVGAGPUV3_CONTROLLER_NAME "EVGAv3" + +struct EVGAv3_config +{ + uint8_t brightness; + RGBColor colors[7]; + uint8_t numberOfColors; + uint16_t speed; + uint8_t direction; +}; + +enum //Control registers and offsets +{ + EVGA_GPU_V3_REG_FIRMWARE = 0xB1, + EVGA_GPU_V3_REG_ENABLE = 0xB2, + EVGA_GPU_V3_REG_MODE = 0xC0, + EVGA_GPU_V3_OFFSET_ZONE_1 = 0x00, + EVGA_GPU_V3_OFFSET_ZONE_2 = 0x01, + EVGA_GPU_V3_OFFSET_ZONE_3 = 0x02, + EVGA_GPU_V3_OFFSET_ZONE_4 = 0x03, + EVGA_GPU_V3_REG_STATIC = 0xC1, + EVGA_GPU_V3_REG_BREATHING = 0xC5, + EVGA_GPU_V3_REG_RAINBOW = 0xC9, + EVGA_GPU_V3_REG_COLOR_CYCLE = 0xCD, + EVGA_GPU_V3_REG_RAINBOW_WAVE = 0xD1, + EVGA_GPU_V3_REG_WAVE = 0xD5, + EVGA_GPU_V3_REG_STAR = 0xD9, + EVGA_GPU_V3_REG_COLOR_STACK = 0xDD, + EVGA_GPU_V3_REG_COLOR_CYCLE_COUNT = 0xE5, + EVGA_GPU_V3_REG_COLOR_STACK_COLOR_COUNT = 0xE6, + EVGA_GPU_V3_REG_COLOR_STACK_DIRECTION = 0xEB, + EVGA_GPU_V3_REG_SAVE = 0x90, +}; + +enum //Mode values for EVGA_GPU_V3_REG_MODE +{ + EVGA_GPU_V3_MODE_OFF = 0x00, + EVGA_GPU_V3_MODE_STATIC = 0x01, + EVGA_GPU_V3_MODE_BREATHING = 0x02, + EVGA_GPU_V3_MODE_RAINBOW = 0x03, + EVGA_GPU_V3_MODE_COLOR_CYCLE = 0x04, + EVGA_GPU_V3_MODE_RAINBOW_WAVE = 0x05, + EVGA_GPU_V3_MODE_WAVE = 0x06, + EVGA_GPU_V3_MODE_STAR = 0x07, + EVGA_GPU_V3_MODE_COLOR_STACK = 0x08, +}; + +enum // Value limits for speeds +{ + EVGA_GPU_V3_BRIGHTNESS_MIN = 0x0, + EVGA_GPU_V3_BRIGHTNESS_DEFAULT = 0xFF, + EVGA_GPU_V3_BRIGHTNESS_MAX = 0xFF, + EVGA_GPU_V3_SPEED_GENERIC_SLOWEST = 0x4E20, //20000 + EVGA_GPU_V3_SPEED_GENERIC_NORMAL = 0x1388, //5000 + EVGA_GPU_V3_SPEED_GENERIC_FASTEST = 0x03E8, //1000 + EVGA_GPU_V3_SPEED_WAVE_SLOWEST = 0x0148, //355 + EVGA_GPU_V3_SPEED_WAVE_NORMAL = 0x0028, //40 + EVGA_GPU_V3_SPEED_WAVE_FASTEST = 0x000A, //10 + EVGA_GPU_V3_SPEED_STAR_SLOWEST = 0x2710, //10000 + EVGA_GPU_V3_SPEED_STAR_NORMAL = 0x07D0, //2000 + EVGA_GPU_V3_SPEED_STAR_FASTEST = 0x01F4, //500 +}; + +class EVGAGPUv3Controller +{ +public: + EVGAGPUv3Controller(i2c_smbus_interface* bus, evga_dev_id dev); + ~EVGAGPUv3Controller(); + + uint8_t zone_led_count[4]; + uint8_t zone_modes[4]; + const char * evgaGPUName; + + std::string GetDeviceLocation(); + std::string GetFWVersion(); + std::string ReadFWVersion(); + + void GetDeviceModes(); + uint8_t GetZoneMode(uint8_t zone); + EVGAv3_config GetZoneConfig(uint8_t zone, uint8_t mode); + void SaveConfig(); + + void ResizeARGB(uint8_t newSize); + void SetAllModes(uint8_t zone0, uint8_t zone1, uint8_t zone2, uint8_t zone3, bool sync); + void SetZoneMode(uint8_t zone, uint8_t mode); + void SetZone(uint8_t zone, uint8_t mode, EVGAv3_config zone_config); + +private: + i2c_smbus_interface* bus; + evga_dev_id dev; + bool zone_sync; + void initCard(); + std::string fwVersion; +}; diff --git a/Controllers/EVGAGPUController/RGBController_EVGAGPUv3.cpp b/Controllers/EVGAGPUController/RGBController_EVGAGPUv3.cpp new file mode 100644 index 00000000..c254ffeb --- /dev/null +++ b/Controllers/EVGAGPUController/RGBController_EVGAGPUv3.cpp @@ -0,0 +1,313 @@ +/*-----------------------------------------*\ +| RGBController_EVGAGPUv3.cpp | +| | +| Generic RGB Interface for OpenRGB EVGA | +| GPU V3 (Ampere) Driver | +| | +| TheRogueZeta 7/15/2021 | +\*-----------------------------------------*/ + +#include "RGBController_EVGAGPUv3.h" +#include "LogManager.h" + +static const char* evga_v3_zone_names[] = +{ + "Front Logo", + "End plate Logo", + "Back Logo", + "Addressable Header" +}; + +RGBController_EVGAGPUv3::RGBController_EVGAGPUv3(EVGAGPUv3Controller* evga_ptr) +{ + evga = evga_ptr; + + name = "EVGA GPU"; + vendor = "EVGA"; + description = "EVGA Ampere RGB GPU Device"; + location = evga->GetDeviceLocation(); + version = evga->GetFWVersion(); + + type = DEVICE_TYPE_GPU; + + mode Off; + Off.name = "Off"; + Off.value = EVGA_GPU_V3_MODE_OFF; + Off.flags = MODE_FLAG_MANUAL_SAVE; + Off.color_mode = MODE_COLORS_NONE; + modes.push_back(Off); + + mode Static; + Static.name = "Direct"; + Static.value = EVGA_GPU_V3_MODE_STATIC; + Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Static.color_mode = MODE_COLORS_PER_LED; + Static.colors_min = 1; + Static.colors_max = 1; + Static.brightness_min = EVGA_GPU_V3_BRIGHTNESS_MIN; + Static.brightness = EVGA_GPU_V3_BRIGHTNESS_DEFAULT; + Static.brightness_max = EVGA_GPU_V3_BRIGHTNESS_MAX; + modes.push_back(Static); + + mode Breathing; + Breathing.name = "Breathing"; + Breathing.value = EVGA_GPU_V3_MODE_BREATHING; + Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Breathing.speed_min = EVGA_GPU_V3_SPEED_GENERIC_SLOWEST; + Breathing.speed = EVGA_GPU_V3_SPEED_GENERIC_NORMAL; + Breathing.speed_max = EVGA_GPU_V3_SPEED_GENERIC_FASTEST; + Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; + Breathing.colors_min = 1; + Breathing.colors_max = 2; + Breathing.colors.resize(1); + Breathing.brightness_min = EVGA_GPU_V3_BRIGHTNESS_MIN; + Breathing.brightness = EVGA_GPU_V3_BRIGHTNESS_DEFAULT; + Breathing.brightness_max = EVGA_GPU_V3_BRIGHTNESS_MAX; + modes.push_back(Breathing); + + mode Rainbow; + Rainbow.name = "Spectrum Cycle"; + Rainbow.value = EVGA_GPU_V3_MODE_RAINBOW; + Rainbow.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Rainbow.speed_min = EVGA_GPU_V3_SPEED_GENERIC_SLOWEST; + Rainbow.speed = EVGA_GPU_V3_SPEED_GENERIC_NORMAL; + Rainbow.speed_max = EVGA_GPU_V3_SPEED_GENERIC_FASTEST; + Rainbow.color_mode = MODE_COLORS_NONE; + Rainbow.brightness_min = EVGA_GPU_V3_BRIGHTNESS_MIN; + Rainbow.brightness = EVGA_GPU_V3_BRIGHTNESS_DEFAULT; + Rainbow.brightness_max = EVGA_GPU_V3_BRIGHTNESS_MAX; + modes.push_back(Rainbow); + + mode Color_Cycle; + Color_Cycle.name = "Color Cycle"; + Color_Cycle.value = EVGA_GPU_V3_MODE_COLOR_CYCLE; + Color_Cycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Color_Cycle.speed_min = EVGA_GPU_V3_SPEED_GENERIC_SLOWEST; + Color_Cycle.speed = EVGA_GPU_V3_SPEED_GENERIC_NORMAL; + Color_Cycle.speed_max = EVGA_GPU_V3_SPEED_GENERIC_FASTEST; + Color_Cycle.color_mode = MODE_COLORS_MODE_SPECIFIC; + Color_Cycle.colors_min = 2; + Color_Cycle.colors_max = 7; + Color_Cycle.colors.resize(2); + Color_Cycle.brightness_min = EVGA_GPU_V3_BRIGHTNESS_MIN; + Color_Cycle.brightness = EVGA_GPU_V3_BRIGHTNESS_DEFAULT; + Color_Cycle.brightness_max = EVGA_GPU_V3_BRIGHTNESS_MAX; + modes.push_back(Color_Cycle); + + mode Rainbow_Wave; + Rainbow_Wave.name = "Rainbow Wave"; + Rainbow_Wave.value = EVGA_GPU_V3_MODE_RAINBOW_WAVE; + Rainbow_Wave.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE; + Rainbow_Wave.speed_min = EVGA_GPU_V3_SPEED_GENERIC_SLOWEST; + Rainbow_Wave.speed = EVGA_GPU_V3_SPEED_GENERIC_NORMAL; + Rainbow_Wave.speed_max = EVGA_GPU_V3_SPEED_GENERIC_FASTEST; + Rainbow_Wave.color_mode = MODE_COLORS_NONE; + Rainbow_Wave.brightness_min = EVGA_GPU_V3_BRIGHTNESS_MIN; + Rainbow_Wave.brightness = EVGA_GPU_V3_BRIGHTNESS_DEFAULT; + Rainbow_Wave.brightness_max = EVGA_GPU_V3_BRIGHTNESS_MAX; + modes.push_back(Rainbow_Wave); + + mode Wave; + Wave.name = "Wave"; + Wave.value = EVGA_GPU_V3_MODE_WAVE; + Wave.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Wave.speed_min = EVGA_GPU_V3_SPEED_WAVE_SLOWEST; + Wave.speed = EVGA_GPU_V3_SPEED_WAVE_NORMAL; + Wave.speed_max = EVGA_GPU_V3_SPEED_WAVE_FASTEST; + Wave.color_mode = MODE_COLORS_PER_LED; + Wave.brightness_min = EVGA_GPU_V3_BRIGHTNESS_MIN; + Wave.brightness = EVGA_GPU_V3_BRIGHTNESS_DEFAULT; + Wave.brightness_max = EVGA_GPU_V3_BRIGHTNESS_MAX; + modes.push_back(Wave); + + mode Star; + Star.name = "Star"; + Star.value = EVGA_GPU_V3_MODE_STAR; + Star.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE; + Star.speed_min = EVGA_GPU_V3_SPEED_STAR_SLOWEST; + Star.speed = EVGA_GPU_V3_SPEED_STAR_NORMAL; + Star.speed_max = EVGA_GPU_V3_SPEED_STAR_FASTEST; + Star.color_mode = MODE_COLORS_NONE; + Star.brightness_min = EVGA_GPU_V3_BRIGHTNESS_MIN; + Star.brightness = EVGA_GPU_V3_BRIGHTNESS_DEFAULT; + Star.brightness_max = EVGA_GPU_V3_BRIGHTNESS_MAX; + modes.push_back(Star); + + mode Color_Stack; + Color_Stack.name = "Color Stack"; + Color_Stack.value = EVGA_GPU_V3_MODE_COLOR_STACK; + Color_Stack.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Color_Stack.speed_min = EVGA_GPU_V3_SPEED_WAVE_SLOWEST; + Color_Stack.speed = EVGA_GPU_V3_SPEED_WAVE_NORMAL; + Color_Stack.speed_max = EVGA_GPU_V3_SPEED_WAVE_FASTEST; + Color_Stack.color_mode = MODE_COLORS_MODE_SPECIFIC; + Color_Stack.colors_min = 2; + Color_Stack.colors_max = 7; + Color_Stack.colors.resize(2); + Color_Stack.brightness_min = EVGA_GPU_V3_BRIGHTNESS_MIN; + Color_Stack.brightness = EVGA_GPU_V3_BRIGHTNESS_DEFAULT; + Color_Stack.brightness_max = EVGA_GPU_V3_BRIGHTNESS_MAX; + modes.push_back(Color_Stack); + + + SetupZones(); + + // Initialize active mode + for( uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++) + { + active_mode = evga->GetZoneMode(0); // Hard coding zone 0 until per zone modes are available. + + if(active_mode != EVGA_GPU_V3_MODE_OFF) + { + EVGAv3_config hw_config = evga->GetZoneConfig(zoneIndexMap[zone_idx], active_mode); + + /*---------------------------------------------------------*\ + | The LED color (color[0]) will always be set. Mode colors | + | are only set for the MODE_COLORS_MODE_SPECIFIC modes | + \*---------------------------------------------------------*/ + + zones[zone_idx].colors[0] = hw_config.colors[0]; + + if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && zone_idx == 0) // Hard coding zone 0 until per zone modes are available. + { + for( uint8_t j = 0 ; j < hw_config.numberOfColors; j ++) + { + if(modes[active_mode].colors.size() > j) + { + modes[active_mode].colors[j] = hw_config.colors[j]; + } + else + { + modes[active_mode].colors.push_back(hw_config.colors[j]); + } + } + } + + modes[active_mode].speed = hw_config.speed; + modes[active_mode].brightness = hw_config.brightness; + modes[active_mode].direction = hw_config.direction; + } + } +} + +RGBController_EVGAGPUv3::~RGBController_EVGAGPUv3() +{ + delete evga; +} + +uint8_t RGBController_EVGAGPUv3::getModeIndex(uint8_t mode_value) +{ + for(uint8_t mode_index = 0; mode_index < modes.size(); mode_index++) + { + if (modes[mode_index].value == mode_value) + { + return mode_index; + } + } + return 0; +} + +void RGBController_EVGAGPUv3::SetupZones() +{ + /*---------------------------------------------------------*\ + | This device only allows setting the entire zone for all | + | LED's in the zone and does not allow per LED control. | + | Resizing is only possible on zone 4, addressable header | + \*---------------------------------------------------------*/ + + evga->GetDeviceModes(); + + for(uint8_t zone_idx = 0; zone_idx < 4; zone_idx++) + { + if(evga->zone_led_count[zone_idx] > 0) + { + zone* new_zone = new zone(); + led* new_led = new led(); + + new_zone->name = evga_v3_zone_names[zone_idx]; + new_zone->type = ZONE_TYPE_SINGLE; + new_zone->leds_min = 1; + new_zone->leds_max = 1; + new_zone->leds_count = 1; + new_zone->matrix_map = NULL; + + new_led->name = evga_v3_zone_names[zone_idx]; + /*---------------------------------------------------------*\ + | Push the zone and LED on to device vectors | + \*---------------------------------------------------------*/ + leds.push_back(*new_led); + zones.push_back(*new_zone); + zoneIndexMap.push_back(zone_idx); + } + } + SetupColors(); +} + +void RGBController_EVGAGPUv3::ResizeZone(int /*zone*/, int newSize) +{ + evga->ResizeARGB(newSize); +} + +void RGBController_EVGAGPUv3::DeviceUpdateLEDs() +{ + /*---------------------------------------------------------*\ + | DeviceUpdateLEDs() is only used in MODE_COLORS_PER_LED | + | modes and as such colorB will always be black (0x000000) | + \*---------------------------------------------------------*/ + EVGAv3_config zone_config; + + zone_config.brightness = modes[active_mode].brightness; + zone_config.speed = modes[active_mode].speed; + zone_config.direction = modes[active_mode].direction; + zone_config.numberOfColors = (uint8_t) modes[active_mode].colors.size(); + + for(uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++) + { + zone_config.colors[0] = colors[zone_idx]; + + if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) + { + for( uint8_t i = 0 ; i < zone_config.numberOfColors; i ++) + { + zone_config.colors[i] = modes[active_mode].colors[i]; + } + } + //LOG_TRACE("[%s] Updating LED %1d", evga->evgaGPUName, zone_idx); + evga->SetZone(zoneIndexMap[zone_idx], modes[active_mode].value, zone_config); + } +} + +void RGBController_EVGAGPUv3::UpdateZoneLEDs(int /*zone*/ zone) +{ + //LOG_TRACE("[%s] Updating zone %1d", evga->evgaGPUName, zone); + DeviceUpdateLEDs(); +} + +void RGBController_EVGAGPUv3::UpdateSingleLED(int /*led*/ led) +{ + //LOG_TRACE("[%s] Updating single LED %1d", evga->evgaGPUName, led); + DeviceUpdateLEDs(); +} + +void RGBController_EVGAGPUv3::SetCustomMode() +{ + active_mode = getModeIndex(EVGA_GPU_V3_MODE_STATIC); +} + +void RGBController_EVGAGPUv3::DeviceUpdateMode() +{ + /* Update all zone modes in a loop, each one with a packet to be use with per zone control + for(uint8_t zone = 0; zone < 4; zone++) + { + evga->SetZoneMode(zone, modes[active_mode].value); + } + */ + //LOG_TRACE("[%s] Updating to mode %1d", evga->evgaGPUName, modes[active_mode].value); + DeviceUpdateLEDs(); + evga->SetAllModes(modes[active_mode].value, modes[active_mode].value, modes[active_mode].value,modes[active_mode].value, true); //Set all zones to the same mode +} + +void RGBController_EVGAGPUv3::DeviceSaveMode() +{ + evga->SaveConfig(); +} diff --git a/Controllers/EVGAGPUController/RGBController_EVGAGPUv3.h b/Controllers/EVGAGPUController/RGBController_EVGAGPUv3.h new file mode 100644 index 00000000..4fa7e7b2 --- /dev/null +++ b/Controllers/EVGAGPUController/RGBController_EVGAGPUv3.h @@ -0,0 +1,37 @@ +/*-----------------------------------------*\ +| RGBController_EVGAGPUv3.h | +| | +| Generic RGB Interface for OpenRGB | +| EVGA GPU RGB V3 (Ampere) Driver | +| | +| TheRogueZeta 7/15/2021 | +\*-----------------------------------------*/ + +#pragma once + +#include "RGBController.h" +#include "EVGAGPUv3Controller.h" + +class RGBController_EVGAGPUv3 : public RGBController +{ +public: + RGBController_EVGAGPUv3(EVGAGPUv3Controller* evga_ptr); + ~RGBController_EVGAGPUv3(); + + void SetupZones(); + + void ResizeZone(int zone, int new_size); + + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void SetCustomMode(); + void DeviceUpdateMode(); + void DeviceSaveMode(); + +private: + uint8_t getModeIndex(uint8_t mode_value); + EVGAGPUv3Controller* evga; + std::vector zoneIndexMap; +}; diff --git a/OpenRGB.pro b/OpenRGB.pro index 85a4724c..67dd44f6 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -286,10 +286,13 @@ HEADERS += Controllers/EKController/RGBController_EKController.h \ Controllers/EspurnaController/EspurnaController.h \ Controllers/EspurnaController/RGBController_Espurna.h \ + Controllers/EVGAGPUController/EVGAGPUCommon.h \ Controllers/EVGAGPUController/EVGAGPUv1Controller.h \ Controllers/EVGAGPUController/EVGAGPUv2Controller.h \ + Controllers/EVGAGPUController/EVGAGPUv3Controller.h \ Controllers/EVGAGPUController/RGBController_EVGAGPUv1.h \ Controllers/EVGAGPUController/RGBController_EVGAGPUv2.h \ + Controllers/EVGAGPUController/RGBController_EVGAGPUv3.h \ Controllers/EVisionKeyboardController/EVisionKeyboardController.h \ Controllers/EVisionKeyboardController/RGBController_EVisionKeyboard.h \ Controllers/FanBusController/FanBusController.h \ @@ -658,9 +661,11 @@ SOURCES += Controllers/EspurnaController/RGBController_Espurna.cpp \ Controllers/EVGAGPUController/EVGAGPUv1Controller.cpp \ Controllers/EVGAGPUController/EVGAGPUv2Controller.cpp \ + Controllers/EVGAGPUController/EVGAGPUv3Controller.cpp \ Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp \ Controllers/EVGAGPUController/RGBController_EVGAGPUv1.cpp \ Controllers/EVGAGPUController/RGBController_EVGAGPUv2.cpp \ + Controllers/EVGAGPUController/RGBController_EVGAGPUv3.cpp \ Controllers/EVisionKeyboardController/EVisionKeyboardController.cpp \ Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp \ Controllers/EVisionKeyboardController/RGBController_EVisionKeyboard.cpp \ diff --git a/pci_ids/pci_ids.h b/pci_ids/pci_ids.h index a1337bef..0163384b 100644 --- a/pci_ids/pci_ids.h +++ b/pci_ids/pci_ids.h @@ -151,6 +151,51 @@ #define EVGA_RTX2080TI_XC_ULTRA_GAMING_SUB_DEV 0x2383 #define EVGA_RTX2080TI_XC_HYBRID_GAMING_SUB_DEV 0x2384 #define EVGA_RTX2080TI_FTW3_ULTRA_SUB_DEV 0x2487 +#define EVGA_RTX3060TI_FTW3_GAMING_SUB_DEV 0x3665 +#define EVGA_RTX3060TI_FTW3_ULTRA_SUB_DEV 0x3667 +#define EVGA_RTX3060TI_FTW3_ULTRA_KL_SUB_DEV 0x4667 +#define EVGA_RTX3070_XC3_BLACK_SUB_DEV 0x3751 +#define EVGA_RTX3070_XC3_GAMING_SUB_DEV 0x3753 +#define EVGA_RTX3070_XC3_ULTRA_SUB_DEV 0x3755 +#define EVGA_RTX3070_XC3_ULTRA_LHR_SUB_DEV 0x4755 +#define EVGA_RTX3070_FTW3_ULTRA_SUB_DEV 0x3767 +#define EVGA_RTX3070_FTW3_ULTRA_LHR_SUB_DEV 0x4767 +#define EVGA_RTX3070TI_XC3_GAMING_SUB_DEV 0x3783 +#define EVGA_RTX3070TI_XC3_ULTRA_SUB_DEV 0x3785 +#define EVGA_RTX3070TI_FTW3_ULTRA_SUB_DEV 0x3797 +#define EVGA_RTX3080_XC3_BLACK_SUB_DEV 0x3881 +#define EVGA_RTX3080_XC3_BLACK_LHR_SUB_DEV 0x4881 +#define EVGA_RTX3080_XC3_GAMING_SUB_DEV 0x3883 +#define EVGA_RTX3080_XC3_GAMING_LHR_SUB_DEV 0x4883 +#define EVGA_RTX3080_XC3_ULTRA_SUB_DEV 0x3885 +#define EVGA_RTX3080_XC3_ULTRA_LHR_SUB_DEV 0x4885 +#define EVGA_RTX3080_XC3_ULTRA_HYBRID_SUB_DEV 0x3888 +#define EVGA_RTX3080_XC3_ULTRA_HYBRID_LHR_SUB_DEV 0x4888 +#define EVGA_RTX3080_XC3_ULTRA_HC_SUB_DEV 0x3889 +#define EVGA_RTX3080_FTW3_GAMING_SUB_DEV 0x3895 +#define EVGA_RTX3080_FTW3_ULTRA_SUB_DEV 0x3897 +#define EVGA_RTX3080_FTW3_ULTRA_LHR_SUB_DEV 0x4897 +#define EVGA_RTX3080_FTW3_ULTRA_HYBRID_SUB_DEV 0x3898 +#define EVGA_RTX3080_FTW3_ULTRA_HYBRID_LHR_SUB_DEV 0x4898 +#define EVGA_RTX3080_FTW3_ULTRA_HC_SUB_DEV 0x3899 +#define EVGA_RTX3080TI_XC3_GAMING_SUB_DEV 0x3953 +#define EVGA_RTX3080TI_XC3_GAMING_HYBRID_SUB_DEV 0x3958 +#define EVGA_RTX3080TI_XC3_GAMING_HC_SUB_DEV 0x3959 +#define EVGA_RTX3080TI_FTW3_ULTRA_SUB_DEV 0x3967 +#define EVGA_RTX3080TI_FTW3_ULTRA_HYBRID_SUB_DEV 0x3968 +#define EVGA_RTX3080TI_FTW3_ULTRA_HC_SUB_DEV 0x3969 +#define EVGA_RTX3090_XC3_BLACK_SUB_DEV 0x3971 +#define EVGA_RTX3090_XC3_GAMING_SUB_DEV 0x3973 +#define EVGA_RTX3090_XC3_ULTRA_SUB_DEV 0x3975 +#define EVGA_RTX3090_XC3_ULTRA_HYBRID_SUB_DEV 0x3978 +#define EVGA_RTX3090_XC3_ULTRA_HC_SUB_DEV 0x3979 +#define EVGA_RTX3090_FTW3_GAMING_SUB_DEV 0x3985 +#define EVGA_RTX3090_FTW3_ULTRA_SUB_DEV 0x3987 +#define EVGA_RTX3090_FTW3_ULTRA_V2_SUB_DEV 0x3982 +#define EVGA_RTX3090_FTW3_ULTRA_HYBRID_SUB_DEV 0x3988 +#define EVGA_RTX3090_FTW3_ULTRA_HC_SUB_DEV 0x3989 +#define EVGA_RTX3090_KINGPIN_HYBRID_SUB_DEV 0x3998 +#define EVGA_RTX3090_KINGPIN_HC_SUB_DEV 0x3999 /*-----------------------------------------------------*\ | Gainward Sub-Device IDs |