jalr/OpenRGB
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add EVGAv3 controller and supprort for EVGA Ampere cards

Browse source
This commit is contained in:
TheRogueZeta 2021-10-17 19:51:36 -07:00 • committed by Adam Honse
parent 3095572260
commit 7bb745823d
10 changed files with 1150 additions and 30 deletions
Download patch file Download diff file Expand all files Collapse all files

21
Controllers/EVGAGPUController/EVGAGPUCommon.h Normal file
View file

@ -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"

113
Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp
View file

@ -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 <vector>
@ -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<i2c_smbus_interface*>& 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<i2c_smbus_interface*>& 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<i2c_smbus_interface*>& 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;
}
}
}

2
Controllers/EVGAGPUController/EVGAGPUv1Controller.h
View file

@ -14,6 +14,8 @@
typedef unsigned char evga_dev_id;
#define EVGAGPUV1_CONTROLLER_NAME "EVGAv1"
enum
{
EVGA_GPU_V1_REG_MODE = 0x0C,

12
Controllers/EVGAGPUController/EVGAGPUv2Controller.h
View file

@ -10,6 +10,7 @@
#include <string>
#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:

515
Controllers/EVGAGPUController/EVGAGPUv3Controller.cpp Normal file
View file

@ -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;
}
}

117
Controllers/EVGAGPUController/EVGAGPUv3Controller.h Normal file
View file

@ -0,0 +1,117 @@
/*-----------------------------------------*\
| EVGAGPUv3Controller.h |
| |
| Definitions and types for EVGA GPU RGB |
| V3 (Ampere) lighting controller |
| |
| TheRogueZeta 7/15/2021 |
\*-----------------------------------------*/
#include <string>
#include "i2c_smbus.h"
#include "RGBController.h"
#include "EVGAGPUCommon.h"
#pragma once
typedef unsigned char evga_dev_id;
#define SPEED_MULTIPLIER 10
#define EVGAGPUV3_MODE_PACKET_SIZE 10
#define EVGAGPUV3_LEDS_MIN 01
#define EVGAGPUV3_LEDS_MAX 60
#define EVGAGPUV3_INIT 0xFF
#define EVGAGPUV3_CONTROLLER_NAME "EVGAv3"
struct EVGAv3_config
{
uint8_t brightness;
RGBColor colors[7];
uint8_t numberOfColors;
uint16_t speed;
uint8_t direction;
};
enum //Control registers and offsets
{
EVGA_GPU_V3_REG_FIRMWARE = 0xB1,
EVGA_GPU_V3_REG_ENABLE = 0xB2,
EVGA_GPU_V3_REG_MODE = 0xC0,
EVGA_GPU_V3_OFFSET_ZONE_1 = 0x00,
EVGA_GPU_V3_OFFSET_ZONE_2 = 0x01,
EVGA_GPU_V3_OFFSET_ZONE_3 = 0x02,
EVGA_GPU_V3_OFFSET_ZONE_4 = 0x03,
EVGA_GPU_V3_REG_STATIC = 0xC1,
EVGA_GPU_V3_REG_BREATHING = 0xC5,
EVGA_GPU_V3_REG_RAINBOW = 0xC9,
EVGA_GPU_V3_REG_COLOR_CYCLE = 0xCD,
EVGA_GPU_V3_REG_RAINBOW_WAVE = 0xD1,
EVGA_GPU_V3_REG_WAVE = 0xD5,
EVGA_GPU_V3_REG_STAR = 0xD9,
EVGA_GPU_V3_REG_COLOR_STACK = 0xDD,
EVGA_GPU_V3_REG_COLOR_CYCLE_COUNT = 0xE5,
EVGA_GPU_V3_REG_COLOR_STACK_COLOR_COUNT = 0xE6,
EVGA_GPU_V3_REG_COLOR_STACK_DIRECTION = 0xEB,
EVGA_GPU_V3_REG_SAVE = 0x90,
};
enum //Mode values for EVGA_GPU_V3_REG_MODE
{
EVGA_GPU_V3_MODE_OFF = 0x00,
EVGA_GPU_V3_MODE_STATIC = 0x01,
EVGA_GPU_V3_MODE_BREATHING = 0x02,
EVGA_GPU_V3_MODE_RAINBOW = 0x03,
EVGA_GPU_V3_MODE_COLOR_CYCLE = 0x04,
EVGA_GPU_V3_MODE_RAINBOW_WAVE = 0x05,
EVGA_GPU_V3_MODE_WAVE = 0x06,
EVGA_GPU_V3_MODE_STAR = 0x07,
EVGA_GPU_V3_MODE_COLOR_STACK = 0x08,
};
enum // Value limits for speeds
{
EVGA_GPU_V3_BRIGHTNESS_MIN = 0x0,
EVGA_GPU_V3_BRIGHTNESS_DEFAULT = 0xFF,
EVGA_GPU_V3_BRIGHTNESS_MAX = 0xFF,
EVGA_GPU_V3_SPEED_GENERIC_SLOWEST = 0x4E20, //20000
EVGA_GPU_V3_SPEED_GENERIC_NORMAL = 0x1388, //5000
EVGA_GPU_V3_SPEED_GENERIC_FASTEST = 0x03E8, //1000
EVGA_GPU_V3_SPEED_WAVE_SLOWEST = 0x0148, //355
EVGA_GPU_V3_SPEED_WAVE_NORMAL = 0x0028, //40
EVGA_GPU_V3_SPEED_WAVE_FASTEST = 0x000A, //10
EVGA_GPU_V3_SPEED_STAR_SLOWEST = 0x2710, //10000
EVGA_GPU_V3_SPEED_STAR_NORMAL = 0x07D0, //2000
EVGA_GPU_V3_SPEED_STAR_FASTEST = 0x01F4, //500
};
class EVGAGPUv3Controller
{
public:
EVGAGPUv3Controller(i2c_smbus_interface* bus, evga_dev_id dev);
~EVGAGPUv3Controller();
uint8_t zone_led_count[4];
uint8_t zone_modes[4];
const char * evgaGPUName;
std::string GetDeviceLocation();
std::string GetFWVersion();
std::string ReadFWVersion();
void GetDeviceModes();
uint8_t GetZoneMode(uint8_t zone);
EVGAv3_config GetZoneConfig(uint8_t zone, uint8_t mode);
void SaveConfig();
void ResizeARGB(uint8_t newSize);
void SetAllModes(uint8_t zone0, uint8_t zone1, uint8_t zone2, uint8_t zone3, bool sync);
void SetZoneMode(uint8_t zone, uint8_t mode);
void SetZone(uint8_t zone, uint8_t mode, EVGAv3_config zone_config);
private:
i2c_smbus_interface* bus;
evga_dev_id dev;
bool zone_sync;
void initCard();
std::string fwVersion;
};

313
Controllers/EVGAGPUController/RGBController_EVGAGPUv3.cpp Normal file
View file

@ -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();
}

37
Controllers/EVGAGPUController/RGBController_EVGAGPUv3.h Normal file
View file

@ -0,0 +1,37 @@
/*-----------------------------------------*\
| RGBController_EVGAGPUv3.h |
| |
| Generic RGB Interface for OpenRGB |
| EVGA GPU RGB V3 (Ampere) Driver |
| |
| TheRogueZeta 7/15/2021 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "EVGAGPUv3Controller.h"
class RGBController_EVGAGPUv3 : public RGBController
{
public:
RGBController_EVGAGPUv3(EVGAGPUv3Controller* evga_ptr);
~RGBController_EVGAGPUv3();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
void DeviceSaveMode();
private:
uint8_t getModeIndex(uint8_t mode_value);
EVGAGPUv3Controller* evga;
std::vector<uint8_t> zoneIndexMap;
};

5
OpenRGB.pro
View file

@ -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 \

45
pci_ids/pci_ids.h
View file

@ -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 |