mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-03-24 08:51:07 -04:00
Code Issues Packages Projects Releases Wiki Activity

Split EVGA GPU controllers into individual controllers/folders

Browse Source
This commit is contained in:
TheRogueZeta
2022-02-11 18:52:38 +00:00
committed by Adam Honse
parent 236154da67
commit 5ae6ef2c79
24 changed files with 413 additions and 267 deletions
Download Patch File Download Diff File Expand all files Collapse all files

256
Controllers/EVGATuringGPUController/EVGAGPUv2Controller.cpp Normal file
View File

@@ -0,0 +1,256 @@
/*-----------------------------------------*\
| EVGAGPUv2Controller.cpp |
| |
| Driver for EVGA GPU RGB V2 (Turing) |
| lighting controller |
| |
| TheRogueZeta 4/15/2021 |
\*-----------------------------------------*/
#include "EVGAGPUv2Controller.h"
EVGAGPUv2Controller::EVGAGPUv2Controller(i2c_smbus_interface* bus, evga_dev_id dev)
{
this->bus = bus;
this->dev = dev;
}
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);
}
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);
}

111
Controllers/EVGATuringGPUController/EVGAGPUv2Controller.h Normal file
View File

@@ -0,0 +1,111 @@
/*-----------------------------------------*\
| EVGAGPUv2Controller.h |
| |
| Definitions and types for EVGA GPU RGB |
| V2 (Turing) lighting controller |
| |
| TheRogueZeta 4/15/2021 |
\*-----------------------------------------*/
#include <string>
#include "i2c_smbus.h"
#include "RGBController.h"
#pragma once
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);
~EVGAGPUv2Controller();
std::string GetDeviceLocation();
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;
};

85
Controllers/EVGATuringGPUController/EVGATuringGPUControllerDetect.cpp Normal file
View File

@@ -0,0 +1,85 @@
#include "Detector.h"
#include "EVGAGPUv2Controller.h"
#include "LogManager.h"
#include "RGBController.h"
#include "RGBController_EVGAGPUv2.h"
#include "i2c_smbus.h"
#include "pci_ids.h"
#include <vector>
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
int pci_vendor;
int pci_device;
int pci_subsystem_vendor;
int pci_subsystem_device;
const char * name;
} gpu_pci_device;
#define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
static const gpu_pci_device device_list[] =
{
{ NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070_XC_GAMING_SUB_DEV, "EVGA GeForce RTX 2070 XC Gaming" },
{ NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070_XC_OC_SUB_DEV, "EVGA GeForce RTX 2070 XC OC" },
{ NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_BLACK_SUB_DEV, "EVGA GeForce RTX 2070 SUPER Black" },
{ NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_XC_ULTRA_SUB_DEV, "EVGA GeForce RTX 2070 SUPER XC Ultra" },
{ NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_XC_ULTRA_PLUS_SUB_DEV, "EVGA GeForce RTX 2070 SUPER XC Ultra+" },
{ NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_FTW3_ULTRA_PLUS_OC_SUB_DEV, "EVGA GeForce RTX 2070 SUPER FTW3 Ultra+" },
{ NVIDIA_VEN, NVIDIA_RTX2080_DEV, EVGA_SUB_VEN, EVGA_RTX2080_BLACK_SUB_DEV, "EVGA GeForce RTX 2080 Black" },
{ NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080_XC_BLACK_SUB_DEV, "EVGA GeForce RTX 2080 XC Black" },
{ NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080_XC_GAMING_SUB_DEV, "EVGA GeForce RTX 2080 XC Gaming" },
{ NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080_XC_ULTRA_GAMING_SUB_DEV, "EVGA GeForce RTX 2080 XC Ultra Gaming" },
{ NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_XC_GAMING_SUB_DEV, "EVGA GeForce RTX 2080 SUPER XC Gaming" },
{ NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_XC_ULTRA_SUB_DEV, "EVGA GeForce RTX 2080 SUPER XC Ultra" },
{ NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_FTW3_ULTRA_SUB_DEV, "EVGA GeForce RTX 2080 SUPER FTW3 Ultra" },
{ NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_FTW3_HYBRID_OC_SUB_DEV, "EVGA GeForce RTX 2080 SUPER FTW3 Hybrid OC" },
{ NVIDIA_VEN, NVIDIA_RTX2080S_DEV, EVGA_SUB_VEN, EVGA_RTX2080S_FTW3_ULTRA_HC_SUB_DEV, "EVGA GeForce RTX 2080 SUPER FTW3 Ultra Hydro Copper" },
{ NVIDIA_VEN, NVIDIA_RTX2080TI_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_BLACK_SUB_DEV, "EVGA GeForce RTX 2080Ti Black" },
{ NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_XC_ULTRA_GAMING_SUB_DEV, "EVGA GeForce RTX 2080Ti XC Ultra" },
{ NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_XC_HYBRID_GAMING_SUB_DEV, "EVGA GeForce RTX 2080Ti XC HYBRID GAMING" },
{ NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, EVGA_SUB_VEN, EVGA_RTX2080TI_FTW3_ULTRA_SUB_DEV, "EVGA GeForce RTX 2080Ti FTW3 Ultra" },
};
/******************************************************************************************\
* *
* 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(std::vector<i2c_smbus_interface*>& busses)
{
for (unsigned int bus = 0; bus < busses.size(); bus++)
{
for(unsigned int dev_idx = 0; dev_idx < GPU_NUM_DEVICES; dev_idx++)
{
if (busses[bus]->port_id != 1)
{
break;
}
if(busses[bus]->pci_vendor == device_list[dev_idx].pci_vendor &&
busses[bus]->pci_device == device_list[dev_idx].pci_device &&
busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
{
LOG_DEBUG(GPU_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;
new_controller = new EVGAGPUv2Controller(busses[bus], 0x49);
new_rgbcontroller = new RGBController_EVGAGPUv2(new_controller);
new_rgbcontroller->name = device_list[dev_idx].name;
ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
}
}
}
} /* DetectEVGATuringGPUControllers() */
REGISTER_I2C_DETECTOR("EVGA Turing GPU", DetectEVGATuringGPUControllers);

218
Controllers/EVGATuringGPUController/RGBController_EVGAGPUv2.cpp Normal file
View File

@@ -0,0 +1,218 @@
/*-----------------------------------------*\
| RGBController_EVGAGPUv2.cpp |
| |
| Generic RGB Interface for OpenRGB EVGA |
| GPU V2 (Turing) Driver |
| |
| TheRogueZeta 4/15/2021 |
\*-----------------------------------------*/
#include "RGBController_EVGAGPUv2.h"
RGBController_EVGAGPUv2::RGBController_EVGAGPUv2(EVGAGPUv2Controller* evga_ptr)
{
evga = evga_ptr;
name = "EVGA GPU";
vendor = "EVGA";
description = "EVGA Turing RGB GPU Device";
location = evga->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(evga->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] = evga->GetColorA();
RGBColor colorB = evga->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 = evga->GetSpeed();
modes[active_mode].brightness = evga->GetBrightnessA();
}
RGBController_EVGAGPUv2::~RGBController_EVGAGPUv2()
{
delete evga;
}
int RGBController_EVGAGPUv2::getModeIndex(unsigned char mode_value)
{
for(std::size_t mode_index = 0; mode_index < 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) |
\*---------------------------------------------------------*/
evga->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::SetCustomMode()
{
active_mode = getModeIndex(EVGA_GPU_V2_RGB_MODE_STATIC);
}
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 ;
}
evga->SetMode( modes[active_mode].value, colorA, colorB, modes[active_mode].speed, modes[active_mode].brightness);
}
void RGBController_EVGAGPUv2::DeviceSaveMode()
{
evga->SaveSettings();
}

36
Controllers/EVGATuringGPUController/RGBController_EVGAGPUv2.h Normal file
View File

@@ -0,0 +1,36 @@
/*-----------------------------------------*\
| RGBController_EVGAGPUv2.h |
| |
| Generic RGB Interface for OpenRGB |
| EVGA GPU RGB V2 (Turing) Driver |
| |
| TheRogueZeta 4/15/2021 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "EVGAGPUv2Controller.h"
class RGBController_EVGAGPUv2 : public RGBController
{
public:
RGBController_EVGAGPUv2(EVGAGPUv2Controller* evga_ptr);
~RGBController_EVGAGPUv2();
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:
int getModeIndex(unsigned char mode_value);
EVGAGPUv2Controller* evga;
};