Jens/LumaOps-Public
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Publish LumaOps source

Browse Source
This commit is contained in:
LumaOps release export
2026-09-03 01:18:36 +02:00
commit 7f1c0e5f71
2363 changed files with 501543 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Controllers/EVGAAmpereGPUController/EVGAAmpereGPUControllerDetect.cpp
+112
View File
@@ -0,0 +1,112 @@
/*---------------------------------------------------------*\
| EVGAAmpereGPUControllerDetect.cpp |
| |
| Detector for EVGA V3 (Ampere) GPU |
| |
| TheRogueZeta 15 Jul 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "Detector.h"
#include "EVGAGPUv3Controller.h"
#include "LogManager.h"
#include "RGBController_EVGAGPUv3.h"
#include "i2c_smbus.h"
#include "pci_ids.h"
/******************************************************************************************\
* *
* DetectEVGAAmpereGPUControllers *
* *
* Detect EVGA Ampere GPU controllers on the enumerated I2C busses at address 0x2D. *
* *
* bus - pointer to i2c_smbus_interface where EVGA GPU device is connected *
* dev - I2C address of EVGA GPU device *
* *
\******************************************************************************************/
void DetectEVGAAmpereGPUControllers(i2c_smbus_interface* bus, uint8_t address, const std::string& name)
{
if(bus->port_id == 1)
{
EVGAGPUv3Controller* controller;
RGBController_EVGAGPUv3* rgb_controller;
controller = new EVGAGPUv3Controller(bus, address, name);
if(controller-> ReadFWVersion() != "")
{
rgb_controller = new RGBController_EVGAGPUv3(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
else
{
LOG_INFO("[%s] Failed to get a valid FW version, does the i2c interface support `i2c_smbus_read_i2c_block_data`?", controller->GetDeviceName().c_str());
delete controller;
}
}
} /* DetectEVGAAmpereGPUControllers() */
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3060 Ti FTW3 Gaming" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3060TI_DEV, EVGA_SUB_VEN, EVGA_RTX3060TI_FTW3_GAMING_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3060 Ti FTW3 Ultra" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3060TI_DEV, EVGA_SUB_VEN, EVGA_RTX3060TI_FTW3_ULTRA_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3060 Ti FTW3 Ultra LHR" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3060TI_FTW3_ULTRA_KL_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3060 Ti FTW3 Ultra Gaming LHR" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3060TI_FTW3_ULTRA_GAMING_LHR_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 Black Gaming" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_DEV, EVGA_SUB_VEN, EVGA_RTX3070_XC3_BLACK_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 XC3 Gaming" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_DEV, EVGA_SUB_VEN, EVGA_RTX3070_XC3_GAMING_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 XC3 Ultra" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_DEV, EVGA_SUB_VEN, EVGA_RTX3070_XC3_ULTRA_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 XC3 Ultra LHR" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3070_XC3_ULTRA_LHR_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 XC3 Ultra Gaming" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3070_XC3_ULTRA_GAMING_LHR_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 FTW3 Ultra" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_DEV, EVGA_SUB_VEN, EVGA_RTX3070_FTW3_ULTRA_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 FTW3 Ultra LHR" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3070_FTW3_ULTRA_LHR_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 FTW3 Ultra LHR" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3070_FTW3_ULTRA_LHR_ALT_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 Ti XC3 Gaming" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070TI_DEV, EVGA_SUB_VEN, EVGA_RTX3070TI_XC3_GAMING_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 Ti XC3 Ultra" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070TI_DEV, EVGA_SUB_VEN, EVGA_RTX3070TI_XC3_ULTRA_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 Ti XC3 Ultra v2" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070TI_DEV, EVGA_SUB_VEN, EVGA_RTX3070TI_XC3_ULTRA_V2_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 Ti FTW3 Ultra" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070TI_DEV, EVGA_SUB_VEN, EVGA_RTX3070TI_FTW3_ULTRA_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3070 Ti FTW3 Ultra v2" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070TI_DEV, EVGA_SUB_VEN, EVGA_RTX3070TI_FTW3_ULTRA_V2_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Black" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_BLACK_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Black LHR" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_BLACK_LHR_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Gaming" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_GAMING_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Gaming LHR" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_GAMING_LHR_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Ultra" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_ULTRA_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Ultra LHR" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_ULTRA_LHR_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Ultra Hybrid" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_ULTRA_HYBRID_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Ultra Hybrid LHR" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_ULTRA_HYBRID_LHR_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Ultra Hydro Copper" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_XC3_ULTRA_HC_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Gaming" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_FTW3_GAMING_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_FTW3_ULTRA_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra v2 LHR" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_FTW3_ULTRA_LHR_V2_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra LHR" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_FTW3_ULTRA_LHR_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hybrid" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_FTW3_ULTRA_HYBRID_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hybrid LHR" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_FTW3_ULTRA_HYBRID_LHR_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hybrid Gaming LHR" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_FTW3_ULTRA_HYBRID_GAMING_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hydro Copper" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_DEV, EVGA_SUB_VEN, EVGA_RTX3080_FTW3_ULTRA_HC_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 XC3 Ultra 12G" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_12G_XC3_ULTRA_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra 12GB" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_12G_FTW3_ULTRA_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 FTW3 Ultra Hydro Copper 12G" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_12G_LHR_DEV, EVGA_SUB_VEN, EVGA_RTX3080_12G_FTW3_ULTRA_HC_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 Ti XC3 Gaming" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, EVGA_SUB_VEN, EVGA_RTX3080TI_XC3_GAMING_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 Ti XC3 Ultra Gaming" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, EVGA_SUB_VEN, EVGA_RTX3080TI_XC3_ULTRA_GAMING_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 Ti XC3 Gaming Hybrid" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, EVGA_SUB_VEN, EVGA_RTX3080TI_XC3_GAMING_HYBRID_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 Ti XC3 Gaming Hydro Copper" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, EVGA_SUB_VEN, EVGA_RTX3080TI_XC3_GAMING_HC_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 Ti FTW3 Ultra" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, EVGA_SUB_VEN, EVGA_RTX3080TI_FTW3_ULTRA_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 Ti FTW3 Ultra Hybrid" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, EVGA_SUB_VEN, EVGA_RTX3080TI_FTW3_ULTRA_HYBRID_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3080 Ti FTW3 Ultra Hydro Copper" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, EVGA_SUB_VEN, EVGA_RTX3080TI_FTW3_ULTRA_HC_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 XC3 Black" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_XC3_BLACK_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 XC3 Gaming" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_XC3_GAMING_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 XC3 Ultra" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_XC3_ULTRA_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 XC3 Ultra Hybrid" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_XC3_ULTRA_HYBRID_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 XC3 Ultra Hydro Copper" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_XC3_ULTRA_HC_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 FTW3 Ultra" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_FTW3_ULTRA_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 FTW3 Ultra v2" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_FTW3_ULTRA_V2_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 FTW3 Ultra v3" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_FTW3_ULTRA_V3_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 FTW3 Ultra Hybrid" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_FTW3_ULTRA_HYBRID_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 FTW3 Ultra Hydro Copper" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_FTW3_ULTRA_HC_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 K|NGP|N Hybrid" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_KINGPIN_HYBRID_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 K|NGP|N Hydro Copper" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_KINGPIN_HC_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 Ti FTW3 Black Gaming" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090TI_DEV, EVGA_SUB_VEN, EVGA_RTX3090TI_FTW3_BLACK_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 Ti FTW3 Gaming" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090TI_DEV, EVGA_SUB_VEN, EVGA_RTX3090TI_FTW3_GAMING_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 Ti FTW3 Ultra Gaming" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090TI_DEV, EVGA_SUB_VEN, EVGA_RTX3090TI_FTW3_ULTRA_GAMING_SUB_DEV, 0x2D);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 3090 Ti FTW3 Ultra Hybrid Gaming" , DetectEVGAAmpereGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090TI_DEV, EVGA_SUB_VEN, EVGA_RTX3090TI_FTW3_ULTRA_HYBRID_GAMING_SUB_DEV,0x2D);
Controllers/EVGAAmpereGPUController/EVGAGPUv3Controller.cpp
+523
View File
@@ -0,0 +1,523 @@
/*---------------------------------------------------------*\
| EVGAGPUv3Controller.cpp |
| |
| Driver for EVGA V3 (Ampere) GPU |
| |
| TheRogueZeta 15 Jul 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "EVGAGPUv3Controller.h"
#include "LogManager.h"
EVGAGPUv3Controller::EVGAGPUv3Controller(i2c_smbus_interface* bus, evga_dev_id dev, std::string dev_name)
{
this->bus = bus;
this->dev = dev;
this->name = dev_name;
}
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);
}
std::string EVGAGPUv3Controller::GetDeviceName()
{
return(name);
}
void EVGAGPUv3Controller::GetDeviceModes()
{
LOG_DEBUG("[%s] Getting Zone and LED count from HW", name.c_str());
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", name.c_str(), zone + 1, zone_led_count[zone], zone_modes[zone]);
}
zone_sync = data_pkt[9];
LOG_DEBUG("[%s] Zone Sync is %1d", name.c_str(), zone_sync);
}
else
{
LOG_DEBUG("[%s] Invalid block read result: %02d", name.c_str(), 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", name.c_str());
uint8_t data_pkt[I2C_SMBUS_BLOCK_MAX] = {};
std::string return_string = "";
char version[10];
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, 10, "1.%02d.%02d", major, minor);
return_string.append(version);
LOG_TRACE("[%s] Firmware %s", name.c_str(), 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", name.c_str(), 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.", name.c_str(), 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", name.c_str(), color_index, zone_config.colors[color_index]);
}
LOG_DEBUG("[%s] Done loading Zone %1d configuration from HW", name.c_str(), 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", name.c_str(), 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", name.c_str());
return;
}
void EVGAGPUv3Controller::SaveConfig()
{
LOG_DEBUG("[%s] Sending save packet", name.c_str());
//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", name.c_str(), 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.", name.c_str(), 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", name.c_str(), 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", name.c_str(), mode);
}
break;
}
}
Controllers/EVGAAmpereGPUController/EVGAGPUv3Controller.h
+130
View File
@@ -0,0 +1,130 @@
/*---------------------------------------------------------*\
| EVGAGPUv3Controller.h |
| |
| Driver for EVGA V3 (Ampere) GPU |
| |
| TheRogueZeta 15 Jul 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include "i2c_smbus.h"
#include "RGBController.h"
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"
union u16_to_u8
{
uint16_t u16;
struct
{
uint8_t lsb;
uint8_t msb;
};
};
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, std::string dev_name);
~EVGAGPUv3Controller();
uint8_t zone_led_count[4];
uint8_t zone_modes[4];
std::string GetDeviceLocation();
std::string GetDeviceName();
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;
std::string fwVersion;
std::string name;
void initCard();
};
Controllers/EVGAAmpereGPUController/RGBController_EVGAGPUv3.cpp
+321
View File
@@ -0,0 +1,321 @@
/*---------------------------------------------------------*\
| RGBController_EVGAGPUv3.cpp |
| |
| RGBController for EVGA V3 (Ampere) GPU |
| |
| TheRogueZeta 15 Jul 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_EVGAGPUv3.h"
#include "LogManager.h"
static const char* evga_v3_zone_names[] =
{
"Front Logo",
"End plate Logo",
"Back Logo",
"Addressable Header"
};
/**------------------------------------------------------------------*\
@name EVGA RGB v3 GPU
@category GPU
@type I2C
@save :white_check_mark:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectEVGAAmpereGPUControllers
@comment EVGA has not exposed a per LED control method yet so OpenRGB
is only able to set all LED's to a single color.
\*-------------------------------------------------------------------*/
RGBController_EVGAGPUv3::RGBController_EVGAGPUv3(EVGAGPUv3Controller* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "EVGA";
description = "EVGA Ampere RGB GPU Device";
location = controller->GetDeviceLocation();
version = controller->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 = controller->GetZoneMode(0); // Hard coding zone 0 until per zone modes are available.
if(active_mode != EVGA_GPU_V3_MODE_OFF)
{
EVGAv3_config hw_config = controller->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 controller;
}
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 |
\*---------------------------------------------------------*/
controller->GetDeviceModes();
for(uint8_t zone_idx = 0; zone_idx < 4; zone_idx++)
{
if(controller->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)
{
controller->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", controller->evgaGPUName, zone_idx);
controller->SetZone(zoneIndexMap[zone_idx], modes[active_mode].value, zone_config);
}
}
void RGBController_EVGAGPUv3::UpdateZoneLEDs(int /*zone*/)
{
//LOG_TRACE("[%s] Updating zone %1d", controller->evgaGPUName, zone);
DeviceUpdateLEDs();
}
void RGBController_EVGAGPUv3::UpdateSingleLED(int /*led*/)
{
//LOG_TRACE("[%s] Updating single LED %1d", controller->evgaGPUName, led);
DeviceUpdateLEDs();
}
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++)
{
controller->SetZoneMode(zone, modes[active_mode].value);
}
*/
//LOG_TRACE("[%s] Updating to mode %1d", controller->evgaGPUName, modes[active_mode].value);
DeviceUpdateLEDs();
controller->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()
{
controller->SaveConfig();
}
Controllers/EVGAAmpereGPUController/RGBController_EVGAGPUv3.h
+39
View File
@@ -0,0 +1,39 @@
/*---------------------------------------------------------*\
| RGBController_EVGAGPUv3.h |
| |
| RGBController for EVGA V3 (Ampere) GPU |
| |
| TheRogueZeta 15 Jul 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "EVGAGPUv3Controller.h"
class RGBController_EVGAGPUv3 : public RGBController
{
public:
RGBController_EVGAGPUv3(EVGAGPUv3Controller* controller_ptr);
~RGBController_EVGAGPUv3();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
EVGAGPUv3Controller* controller;
std::vector<uint8_t> zoneIndexMap;
uint8_t getModeIndex(uint8_t mode_value);
};