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/EVGATuringGPUController/EVGAGPUv2Controller.cpp
+264
View File
@@ -0,0 +1,264 @@
/*---------------------------------------------------------*\
| EVGAGPUv2Controller.cpp |
| |
| Driver for EVGA V2 (Turing) GPU |
| |
| TheRogueZeta 15 Apr 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "EVGAGPUv2Controller.h"
EVGAGPUv2Controller::EVGAGPUv2Controller(i2c_smbus_interface* bus, evga_dev_id dev, std::string dev_name)
{
this->bus = bus;
this->dev = dev;
this->name = dev_name;
}
EVGAGPUv2Controller::~EVGAGPUv2Controller()
{
}
std::string EVGAGPUv2Controller::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 EVGAGPUv2Controller::GetDeviceName()
{
return(name);
}
unsigned char EVGAGPUv2Controller::GetBrightnessA()
{
return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_BRIGHTNESS));
}
RGBColor EVGAGPUv2Controller::GetColorA()
{
int red = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_RED);
int green = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_GREEN);
int blue = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_BLUE);
return(ToRGBColor(red, green, blue));
}
RGBColor EVGAGPUv2Controller::GetColorB()
{
int red = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_RED);
int green = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_GREEN);
int blue = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_BLUE);
return(ToRGBColor(red, green, blue));
}
unsigned char EVGAGPUv2Controller::GetMode()
{
unsigned char return_mode = 0;
unsigned char mode = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_MODE);
if(mode == 0xFF)
{
//Registers may not ready after saving config. Read again if 0xFF.
mode = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_MODE);
}
switch (mode)
{
case EVGA_GPU_V2_MODE_OFF:
{
return_mode = EVGA_GPU_V2_RGB_MODE_OFF;
}
break;
case EVGA_GPU_V2_MODE_STATIC:
{
return_mode = EVGA_GPU_V2_RGB_MODE_STATIC;
}
break;
case EVGA_GPU_V2_MODE_RAINBOW:
{
return_mode = EVGA_GPU_V2_RGB_MODE_RAINBOW;
}
break;
case EVGA_GPU_V2_MODE_BREATHING:
{
u16_to_u8 speed_16 = { (uint16_t) 0 };
speed_16.lsb = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_B_TO_A_SPEED_LSB);
speed_16.msb = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_B_TO_A_SPEED_MSB);
if (speed_16.u16 == 0)
{
return_mode = EVGA_GPU_V2_RGB_MODE_PULSE;
}
else
{
return_mode = EVGA_GPU_V2_RGB_MODE_BREATHING;
}
}
break;
default:
break;
}
return(return_mode);
}
unsigned char EVGAGPUv2Controller::GetSpeed()
{
u16_to_u8 speed_16 = { (uint16_t) 0 };
speed_16.lsb = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_LSB);
speed_16.msb = bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_MSB);
speed_16.u16 /= SPEED_MULTIPLIER;
return (unsigned char) speed_16.u16;
}
void EVGAGPUv2Controller::SetMode(uint8_t mode, RGBColor color1, RGBColor color2, uint16_t speed, uint8_t brightness)
{
EnableWrite(true);
switch (mode)
{
case EVGA_GPU_V2_RGB_MODE_OFF:
{
SendMode(EVGA_GPU_V2_MODE_OFF);
}
break;
case EVGA_GPU_V2_RGB_MODE_STATIC:
{
SendMode(EVGA_GPU_V2_MODE_STATIC);
SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(color1), RGBGetGValue(color1), RGBGetBValue(color1), brightness);
}
break;
case EVGA_GPU_V2_RGB_MODE_RAINBOW:
{
SendMode(EVGA_GPU_V2_MODE_RAINBOW);
SendBrightness(brightness); //Default = 0x64
// Set Rainbow speed? No control in the GUI but this register is only set in Ranbow mode.
bus->i2c_smbus_write_byte_data(dev, 0x19, 0x11);;
}
break;
case EVGA_GPU_V2_RGB_MODE_BREATHING:
case EVGA_GPU_V2_RGB_MODE_PULSE:
{
SendMode(EVGA_GPU_V2_MODE_BREATHING);
/*---------------------------------------------------------*\
| It is expected that color2 will be 0x000000 (black) for |
| 1 color mode otherwise set correctly therfore no further |
| inspection is required. |
\*---------------------------------------------------------*/
SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(color1), RGBGetGValue(color1), RGBGetBValue(color1), brightness);
SendColor(EVGA_GPU_V2_REG_COLOR_B_RED, RGBGetRValue(color2), RGBGetGValue(color2), RGBGetBValue(color2), brightness);
/*-----------------------------------------------------------------*\
| Breathing mode speeds are consistent for B_TO_A and A_TO_B |
| Pulse (Blink) mode is on/off ergo B_TO_A and A_TO_B = 0 (instant) |
\*-----------------------------------------------------------------*/
u16_to_u8 speed_16 = { (uint16_t) (speed * SPEED_MULTIPLIER) };
u16_to_u8 rise_fall_un_16 = { (mode == EVGA_GPU_V2_RGB_MODE_PULSE) ? (uint16_t) 0 : speed_16.u16 };
SendSpeed(speed_16, speed_16, rise_fall_un_16, rise_fall_un_16, rise_fall_un_16);
// 0x61 = 0x01
bus->i2c_smbus_write_byte_data(dev, 0x61, 0x01);
// 0x6A and 0x6B = 0x00
bus->i2c_smbus_write_byte_data(dev, 0x6A, 0x00);
bus->i2c_smbus_write_byte_data(dev, 0x6B, 0x00);
}
break;
default:
break;
}
//Disable writes
EnableWrite(false);
}
void EVGAGPUv2Controller::EnableWrite(bool boolEnable)
{
if(boolEnable)
{
bus->i2c_smbus_write_byte_data(dev, 0x0E, 0xE5);
bus->i2c_smbus_write_byte_data(dev, 0x0E, 0xE9);
bus->i2c_smbus_write_byte_data(dev, 0x0E, 0xF5);
bus->i2c_smbus_write_byte_data(dev, 0x0E, 0xF9);
}
else
{
bus->i2c_smbus_write_byte_data(dev, 0x08, 0x01);
//Dissable commands
bus->i2c_smbus_write_byte_data(dev, 0x0E, 0xF0);
bus->i2c_smbus_write_byte_data(dev, 0x0E, 0xE0);
}
}
void EVGAGPUv2Controller::SaveSettings()
{
bus->i2c_smbus_write_byte_data(dev, 0x0E, 0xE5);
bus->i2c_smbus_write_byte_data(dev, 0x0E, 0xE9);
bus->i2c_smbus_write_byte_data(dev, 0x0E, 0xF0);
bus->i2c_smbus_write_byte_data(dev, 0x1F, 0xE5);
bus->i2c_smbus_write_byte_data(dev, 0x23, 0xE5);
bus->i2c_smbus_write_byte_data(dev, 0x0E, 0xE0);
bus->i2c_smbus_write_byte_data(dev, 0x0E, 0xE0);
}
void EVGAGPUv2Controller::SendBrightness(uint8_t brightness)
{
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_BRIGHTNESS, brightness);
}
void EVGAGPUv2Controller::SendColor(uint8_t start_register, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness)
{
bus->i2c_smbus_write_byte_data(dev, start_register, red);
bus->i2c_smbus_write_byte_data(dev, (start_register + 1), green);
bus->i2c_smbus_write_byte_data(dev, (start_register + 2), blue);
bus->i2c_smbus_write_byte_data(dev, (start_register + 3), brightness);
}
void EVGAGPUv2Controller::SendMode(uint8_t mode)
{
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_MODE, mode);
}
void EVGAGPUv2Controller::SendSpeed(u16_to_u8 aOnTime, u16_to_u8 bOnTime, u16_to_u8 b2a, u16_to_u8 a2b, u16_to_u8 speed_un)
{
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_UN_LSB, (unsigned char) speed_un.lsb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_UN_MSB, (unsigned char) speed_un.msb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_B_TO_A_SPEED_LSB, (unsigned char) b2a.lsb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_B_TO_A_SPEED_MSB, (unsigned char) b2a.msb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_ONTIME_LSB, (unsigned char) bOnTime.lsb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_B_ONTIME_MSB, (unsigned char) bOnTime.msb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_A_TO_B_SPEED_LSB, (unsigned char) a2b.lsb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_A_TO_B_SPEED_MSB, (unsigned char) a2b.msb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_LSB, (unsigned char) aOnTime.lsb );
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_MSB, (unsigned char) aOnTime.msb );
}
void EVGAGPUv2Controller::SetColor(RGBColor colorA, RGBColor colorB, uint8_t brightness)
{
EnableWrite(true);
SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(colorA), RGBGetGValue(colorA), RGBGetBValue(colorA), brightness);
SendColor(EVGA_GPU_V2_REG_COLOR_B_RED, RGBGetRValue(colorB), RGBGetGValue(colorB), RGBGetBValue(colorB), brightness);
EnableWrite(false);
}
Controllers/EVGATuringGPUController/EVGAGPUv2Controller.h
+115
View File
@@ -0,0 +1,115 @@
/*---------------------------------------------------------*\
| EVGAGPUv2Controller.h |
| |
| Driver for EVGA V2 (Turing) GPU |
| |
| TheRogueZeta 15 Apr 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 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"
union u16_to_u8
{
uint16_t u16;
struct
{
uint8_t lsb;
uint8_t msb;
};
};
enum
{
EVGA_GPU_V2_REG_MODE = 0x60,
EVGA_GPU_V2_REG_A_TO_B_SPEED_LSB = 0x62,
EVGA_GPU_V2_REG_A_TO_B_SPEED_MSB = 0x63,
EVGA_GPU_V2_REG_B_TO_A_SPEED_LSB = 0x64,
EVGA_GPU_V2_REG_B_TO_A_SPEED_MSB = 0x65,
EVGA_GPU_V2_REG_COLOR_A_ONTIME_LSB = 0x66,
EVGA_GPU_V2_REG_COLOR_A_ONTIME_MSB = 0x67,
EVGA_GPU_V2_REG_COLOR_B_ONTIME_LSB = 0x68,
EVGA_GPU_V2_REG_COLOR_B_ONTIME_MSB = 0x69,
EVGA_GPU_V2_REG_COLOR_A_RED = 0x6C,
EVGA_GPU_V2_REG_COLOR_A_GREEN = 0x6D,
EVGA_GPU_V2_REG_COLOR_A_BLUE = 0x6E,
EVGA_GPU_V2_REG_COLOR_A_BRIGHTNESS = 0x6F,
EVGA_GPU_V2_REG_COLOR_B_RED = 0x70,
EVGA_GPU_V2_REG_COLOR_B_GREEN = 0x71,
EVGA_GPU_V2_REG_COLOR_B_BLUE = 0x72,
EVGA_GPU_V2_REG_COLOR_B_BRIGHTNESS = 0x73,
EVGA_GPU_V2_REG_COLOR_B_UN_LSB = 0x74,
EVGA_GPU_V2_REG_COLOR_B_UN_MSB = 0x75,
};
enum
{
EVGA_GPU_V2_RGB_MODE_OFF = 0x00,
EVGA_GPU_V2_RGB_MODE_STATIC = 0x01,
EVGA_GPU_V2_RGB_MODE_RAINBOW = 0x02,
EVGA_GPU_V2_RGB_MODE_BREATHING = 0x03,
EVGA_GPU_V2_RGB_MODE_PULSE = 0x04,
};
enum
{
EVGA_GPU_V2_MODE_OFF = 0x00,
EVGA_GPU_V2_MODE_STATIC = 0x01,
EVGA_GPU_V2_MODE_RAINBOW = 0x0F,
EVGA_GPU_V2_MODE_BREATHING = 0x22,
};
enum
{
EVGA_GPU_V2_SPEED_BREATHING_SLOWEST = 0x7D,
EVGA_GPU_V2_SPEED_BREATHING_NORMAL = 0x4B,
EVGA_GPU_V2_SPEED_BREATHING_FASTEST = 0x19,
EVGA_GPU_V2_SPEED_PULSE_SLOWEST = 0xFA,
EVGA_GPU_V2_SPEED_PULSE_NORMAL = 0x96,
EVGA_GPU_V2_SPEED_PULSE_FASTEST = 0x32,
};
class EVGAGPUv2Controller
{
public:
EVGAGPUv2Controller(i2c_smbus_interface* bus, evga_dev_id dev, std::string dev_name);
~EVGAGPUv2Controller();
std::string GetDeviceLocation();
std::string GetDeviceName();
unsigned char GetBrightnessA();
RGBColor GetColorA();
RGBColor GetColorB();
unsigned char GetMode();
unsigned char GetSpeed();
void SetColor(RGBColor colorA, RGBColor colorB, uint8_t brightness);
void SetMode(uint8_t mode, RGBColor color1, RGBColor color2, uint16_t speed, uint8_t brightness);
void SaveSettings();
private:
void EnableWrite(bool enable);
void SendBrightness(uint8_t brightness);
void SendColor(uint8_t start_register, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness);
void SendMode(uint8_t mode);
void SendSpeed(u16_to_u8 aOnTime, u16_to_u8 bOnTime, u16_to_u8 b2a, u16_to_u8 a2b, u16_to_u8 speed_un);
i2c_smbus_interface* bus;
evga_dev_id dev;
std::string name;
};
Controllers/EVGATuringGPUController/EVGATuringGPUControllerDetect.cpp
+65
View File
@@ -0,0 +1,65 @@
/*---------------------------------------------------------*\
| EVGATuringGPUControllerDetect.cpp |
| |
| Detector for EVGA V2 (Turing) GPU |
| |
| TheRogueZeta 15 Apr 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "Detector.h"
#include "EVGAGPUv2Controller.h"
#include "RGBController_EVGAGPUv2.h"
#include "i2c_smbus.h"
#include "pci_ids.h"
/******************************************************************************************\
* *
* DetectEVGATuringGPUControllers *
* *
* Detect EVGA Turing GPU controllers on the enumerated I2C busses at address 0x49. *
* *
* bus - pointer to i2c_smbus_interface where EVGA GPU device is connected *
* dev - I2C address of EVGA GPU device *
* *
\******************************************************************************************/
void DetectEVGATuringGPUControllers(i2c_smbus_interface* bus, uint8_t address, const std::string& name)
{
if(bus->port_id == 1)
{
EVGAGPUv2Controller* controller = new EVGAGPUv2Controller(bus, address, name);
RGBController_EVGAGPUv2* rgb_controller = new RGBController_EVGAGPUv2(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
} /* DetectEVGATuringGPUControllers() */
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 XC Black" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_DEV, EVGA_SUB_VEN, EVGA_RTX2070_XC_BLACK_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 XC Gaming" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070_XC_GAMING_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 XC OC" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070_XC_OC_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 FTW3 Ultra OC" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070_FTW3_ULTRA_OC_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 SUPER XC Gaming" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_XC_GAMING_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 SUPER XC Ultra" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_XC_ULTRA_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 SUPER XC Ultra+" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_XC_ULTRA_PLUS_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 SUPER FTW3 Ultra" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_FTW3_ULTRA_OC_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2070 SUPER FTW3 Ultra+" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_FTW3_ULTRA_PLUS_OC_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 Black" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_DEV, EVGA_SUB_VEN, EVGA_RTX2080_BLACK_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 XC Black" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080_XC_BLACK_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 XC Gaming" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080_XC_GAMING_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 XC Ultra Gaming" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080_XC_ULTRA_GAMING_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 XC Hybrid Gaming" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080_XC_HYBRID_GAMING_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 SUPER XC Gaming" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_XC_GAMING_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 SUPER XC Ultra" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_XC_ULTRA_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 SUPER XC Hybrid Gaming" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_XC_HYBRID_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 SUPER FTW3 Ultra" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_FTW3_ULTRA_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 SUPER FTW3 Hybrid OC" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_FTW3_HYBRID_OC_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 SUPER FTW3 Ultra Hydro Copper" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_FTW3_ULTRA_HC_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 Ti Black" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_BLACK_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 Ti XC Ultra" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_XC_ULTRA_GAMING_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 Ti XC HYBRID GAMING" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_XC_HYBRID_GAMING_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 Ti XC HYDRO COPPER" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_XC_HYDRO_COPPER_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 Ti FTW3 Ultra" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_FTW3_ULTRA_SUB_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("EVGA GeForce RTX 2080 Ti FTW3 Ultra Hydro Copper" , DetectEVGATuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_FTW3_ULTRA_HYDRO_COPPER_SUB_DEV, 0x49);
Controllers/EVGATuringGPUController/RGBController_EVGAGPUv2.cpp
+225
View File
@@ -0,0 +1,225 @@
/*---------------------------------------------------------*\
| RGBController_EVGAGPUv2.cpp |
| |
| RGBController for EVGA V2 (Turing) GPU |
| |
| TheRogueZeta 15 Apr 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_EVGAGPUv2.h"
/**------------------------------------------------------------------*\
@name EVGA RGB v2 GPU
@category GPU
@type I2C
@save :white_check_mark:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectEVGATuringGPUControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_EVGAGPUv2::RGBController_EVGAGPUv2(EVGAGPUv2Controller* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "EVGA";
description = "EVGA Turing RGB GPU Device";
location = controller->GetDeviceLocation();
type = DEVICE_TYPE_GPU;
mode Off;
Off.name = "Off";
Off.value = EVGA_GPU_V2_RGB_MODE_OFF;
Off.flags = 0; //pretty sure not needed
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Static;
Static.name = "Direct";
Static.value = EVGA_GPU_V2_RGB_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
Static.color_mode = MODE_COLORS_PER_LED;
Static.colors_min = 1;
Static.colors_max = 1;
Static.brightness_min = EVGA_GPU_V2_BRIGHTNESS_MIN;
Static.brightness = EVGA_GPU_V2_BRIGHTNESS_DEFAULT;
Static.brightness_max = EVGA_GPU_V2_BRIGHTNESS_MAX;
modes.push_back(Static);
mode Rainbow;
Rainbow.name = "Spectrum Cycle";
Rainbow.value = EVGA_GPU_V2_RGB_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.brightness_min = EVGA_GPU_V2_BRIGHTNESS_MIN;
Rainbow.brightness = EVGA_GPU_V2_BRIGHTNESS_DEFAULT;
Rainbow.brightness_max = EVGA_GPU_V2_BRIGHTNESS_MAX;
modes.push_back(Rainbow);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = EVGA_GPU_V2_RGB_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
Breathing.speed_min = EVGA_GPU_V2_SPEED_BREATHING_SLOWEST;
Breathing.speed = EVGA_GPU_V2_SPEED_BREATHING_NORMAL;
Breathing.speed_max = EVGA_GPU_V2_SPEED_BREATHING_FASTEST;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.brightness_min = EVGA_GPU_V2_BRIGHTNESS_MIN;
Breathing.brightness = EVGA_GPU_V2_BRIGHTNESS_DEFAULT;
Breathing.brightness_max = EVGA_GPU_V2_BRIGHTNESS_MAX;
Breathing.colors_min = 1;
Breathing.colors_max = 2;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode Pulse;
Pulse.name = "Flashing";
Pulse.value = EVGA_GPU_V2_RGB_MODE_PULSE;
Pulse.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
Pulse.speed_min = EVGA_GPU_V2_SPEED_PULSE_SLOWEST;
Pulse.speed = EVGA_GPU_V2_SPEED_PULSE_NORMAL;
Pulse.speed_max = EVGA_GPU_V2_SPEED_PULSE_FASTEST;
Pulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
Pulse.colors_min = 1;
Pulse.colors_max = 2;
Pulse.brightness_min = EVGA_GPU_V2_BRIGHTNESS_MIN;
Pulse.brightness = EVGA_GPU_V2_BRIGHTNESS_DEFAULT;
Pulse.brightness_max = EVGA_GPU_V2_BRIGHTNESS_MAX;
Pulse.colors.resize(1);
modes.push_back(Pulse);
SetupZones();
// Initialize active mode
active_mode = getModeIndex(controller->GetMode());
/*---------------------------------------------------------*\
| The LED color (color[0]) will always be set. Mode colors |
| are only set for the MODE_COLORS_MODE_SPECIFIC modes and |
| by extension colorB is only necessary if its not black |
\*---------------------------------------------------------*/
colors[0] = controller->GetColorA();
RGBColor colorB = controller->GetColorB();
int breathing_mode_index = getModeIndex(EVGA_GPU_V2_RGB_MODE_BREATHING);
int pulse_mode_index = getModeIndex(EVGA_GPU_V2_RGB_MODE_PULSE);
// Pre fill in colors for mode specific colors
modes[breathing_mode_index].colors[0] = colors[0];
modes[pulse_mode_index].colors[0] = colors[0];
// Add colors if colorB is not equal to 0.
if(colorB != 0)
{
modes[breathing_mode_index].colors.push_back(colorB);
modes[pulse_mode_index].colors.push_back(colorB);
}
// Load speed settings from the card:
modes[active_mode].speed = controller->GetSpeed();
modes[active_mode].brightness = controller->GetBrightnessA();
}
RGBController_EVGAGPUv2::~RGBController_EVGAGPUv2()
{
delete controller;
}
int RGBController_EVGAGPUv2::getModeIndex(unsigned char mode_value)
{
for(int mode_index = 0; mode_index < (int)modes.size(); mode_index++)
{
if(modes[mode_index].value == mode_value)
{
return(mode_index);
}
}
return(0);
}
void RGBController_EVGAGPUv2::SetupZones()
{
/*---------------------------------------------------------*\
| This device only has one LED, so create a single zone and |
| LED for it |
\*---------------------------------------------------------*/
zone* new_zone = new zone();
led* new_led = new led();
new_zone->name = "GPU Zone";
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 = "GPU LED";
/*---------------------------------------------------------*\
| Push the zone and LED on to device vectors |
\*---------------------------------------------------------*/
leds.push_back(*new_led);
zones.push_back(*new_zone);
SetupColors();
}
void RGBController_EVGAGPUv2::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_EVGAGPUv2::DeviceUpdateLEDs()
{
/*---------------------------------------------------------*\
| DeviceUpdateLEDs() is only used in MODE_COLORS_PER_LED |
| modes and as such colorB will always be black (0x000000) |
\*---------------------------------------------------------*/
controller->SetColor(colors[0], /* colorB*/ 0, modes[active_mode].brightness);
}
void RGBController_EVGAGPUv2::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_EVGAGPUv2::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_EVGAGPUv2::DeviceUpdateMode()
{
/*---------------------------------------------------------*\
| Modes with MODE_COLORS_MODE_SPECIFIC may have either |
| 1 or 2 colors associated with it. The device controller |
| expects colorB as black (0x000000) in 1 color scenarios |
\*---------------------------------------------------------*/
RGBColor colorA = colors[0];
RGBColor colorB = 0;
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
{
colorA = modes[active_mode].colors[0];
colorB = (modes[active_mode].colors.size() == 2) ? modes[active_mode].colors[1] : 0 ;
}
controller->SetMode( modes[active_mode].value, colorA, colorB, modes[active_mode].speed, modes[active_mode].brightness);
}
void RGBController_EVGAGPUv2::DeviceSaveMode()
{
controller->SaveSettings();
}
Controllers/EVGATuringGPUController/RGBController_EVGAGPUv2.h
+38
View File
@@ -0,0 +1,38 @@
/*---------------------------------------------------------*\
| RGBController_EVGAGPUv2.h |
| |
| RGBController for EVGA V2 (Turing) GPU |
| |
| TheRogueZeta 15 Apr 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "EVGAGPUv2Controller.h"
class RGBController_EVGAGPUv2 : public RGBController
{
public:
RGBController_EVGAGPUv2(EVGAGPUv2Controller* controller_ptr);
~RGBController_EVGAGPUv2();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
EVGAGPUv2Controller* controller;
int getModeIndex(unsigned char mode_value);
};