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

Add EVGA v2 controller for RTX2080 XC GAMING, only supports Off and Direct mode for now

Browse source
This commit is contained in:
Adam Honse 2020-09-13 20:12:50 -05:00
parent 62488cbc1e
commit 2d53a2c7f1
10 changed files with 331 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

45
Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp
View file

@ -1,7 +1,9 @@
#include "Detector.h"
#include "EVGAGPUv1Controller.h"
#include "EVGAGPUv2Controller.h"
#include "RGBController.h"
#include "RGBController_EVGAGPUv1.h"
#include "RGBController_EVGAGPUv2.h"
#include "i2c_smbus.h"
#include <vector>
#include <stdio.h>
@ -16,6 +18,7 @@
| NVidia device IDs |
\*-----------------------------------------------------*/
#define NVIDIA_GTX1070_DEV 0x1B81
#define NVIDIA_RTX2080_DEV 0x1E87
/*-----------------------------------------------------*\
| EVGA sub-vendor ID |
@ -26,6 +29,13 @@
| EVGA sub-device IDs |
\*-----------------------------------------------------*/
#define EVGA_GTX1070_FTW_SUB_DEV 0x6276
#define EVGA_RTX2080_XC_GAMING_SUB_DEV 0x2182
enum
{
EVGA_RGB_V1,
EVGA_RGB_V2,
};
typedef struct
{
@ -33,6 +43,7 @@ typedef struct
int pci_device;
int pci_subsystem_vendor;
int pci_subsystem_device;
int gpu_rgb_version;
const char * name;
} gpu_pci_device;
@ -40,7 +51,8 @@ typedef struct
static const gpu_pci_device device_list[] =
{
{ NVIDIA_VEN, NVIDIA_GTX1070_DEV, EVGA_SUB_VEN, EVGA_GTX1070_FTW_SUB_DEV, "EVGA GeForce GTX 1070 FTW" },
{ NVIDIA_VEN, NVIDIA_GTX1070_DEV, EVGA_SUB_VEN, EVGA_GTX1070_FTW_SUB_DEV, EVGA_RGB_V1, "EVGA GeForce GTX 1070 FTW" },
{ NVIDIA_VEN, NVIDIA_RTX2080_DEV, EVGA_SUB_VEN, EVGA_RTX2080_XC_GAMING_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2080 XC GAMING" },
};
/******************************************************************************************\
@ -70,13 +82,32 @@ void DetectEVGAGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::ve
busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
{
EVGAGPUv1Controller* new_controller;
RGBController_EVGAGPUv1* new_rgbcontroller;
switch(device_list[dev_idx].gpu_rgb_version)
{
case EVGA_RGB_V1:
{
EVGAGPUv1Controller* new_controller;
RGBController_EVGAGPUv1* new_rgbcontroller;
new_controller = new EVGAGPUv1Controller(busses[bus], 0x49);
new_rgbcontroller = new RGBController_EVGAGPUv1(new_controller);
new_rgbcontroller->name = device_list[dev_idx].name;
rgb_controllers.push_back(new_rgbcontroller);
new_controller = new EVGAGPUv1Controller(busses[bus], 0x49);
new_rgbcontroller = new RGBController_EVGAGPUv1(new_controller);
new_rgbcontroller->name = device_list[dev_idx].name;
rgb_controllers.push_back(new_rgbcontroller);
}
break;
case EVGA_RGB_V2:
{
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;
rgb_controllers.push_back(new_rgbcontroller);
}
break;
}
}
}
}

16
Controllers/EVGAGPUController/EVGAGPUv1Controller.cpp
View file

@ -1,5 +1,5 @@
/*-----------------------------------------*\
| EVGAGPUController.cpp |
| EVGAGPUv1Controller.cpp |
| |
| Driver for EVGA GPU RGB V1 (Pascal) |
| lighting controller |
@ -32,27 +32,27 @@ std::string EVGAGPUv1Controller::GetDeviceLocation()
unsigned char EVGAGPUv1Controller::GetRed()
{
return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_REG_RED));
return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V1_REG_RED));
}
unsigned char EVGAGPUv1Controller::GetGreen()
{
return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_REG_GREEN));
return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V1_REG_GREEN));
}
unsigned char EVGAGPUv1Controller::GetBlue()
{
return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_REG_BLUE));
return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V1_REG_BLUE));
}
void EVGAGPUv1Controller::SetColor(unsigned char red, unsigned char green, unsigned char blue)
{
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_REG_RED, red);
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_REG_GREEN, green);
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_REG_BLUE, blue);
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V1_REG_RED, red);
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V1_REG_GREEN, green);
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V1_REG_BLUE, blue);
}
void EVGAGPUv1Controller::SetMode(unsigned char mode)
{
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_REG_MODE, mode);
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V1_REG_MODE, mode);
}

16
Controllers/EVGAGPUController/EVGAGPUv1Controller.h
View file

@ -16,18 +16,18 @@ typedef unsigned char evga_dev_id;
enum
{
EVGA_GPU_REG_MODE = 0x0C,
EVGA_GPU_REG_RED = 0x09,
EVGA_GPU_REG_GREEN = 0x0A,
EVGA_GPU_REG_BLUE = 0x0B,
EVGA_GPU_V1_REG_MODE = 0x0C,
EVGA_GPU_V1_REG_RED = 0x09,
EVGA_GPU_V1_REG_GREEN = 0x0A,
EVGA_GPU_V1_REG_BLUE = 0x0B,
};
enum
{
EVGA_GPU_MODE_OFF = 0x00,
EVGA_GPU_MODE_CUSTOM = 0x01,
EVGA_GPU_MODE_RAINBOW = 0x02,
EVGA_GPU_MODE_BREATHING = 0x05,
EVGA_GPU_V1_MODE_OFF = 0x00,
EVGA_GPU_V1_MODE_CUSTOM = 0x01,
EVGA_GPU_V1_MODE_RAINBOW = 0x02,
EVGA_GPU_V1_MODE_BREATHING = 0x05,
};
class EVGAGPUv1Controller

59
Controllers/EVGAGPUController/EVGAGPUv2Controller.cpp Normal file
View file

@ -0,0 +1,59 @@
/*-----------------------------------------*\
| EVGAGPUv2Controller.cpp |
| |
| Driver for EVGA GPU RGB V2 (Turing) |
| lighting controller |
| |
| Adam Honse (CalcProgrammer1) 9/13/2020 |
\*-----------------------------------------*/
#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(return_string);
}
unsigned char EVGAGPUv2Controller::GetRed()
{
return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_RED));
}
unsigned char EVGAGPUv2Controller::GetGreen()
{
return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_GREEN));
}
unsigned char EVGAGPUv2Controller::GetBlue()
{
return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_BLUE));
}
void EVGAGPUv2Controller::SetColor(unsigned char red, unsigned char green, unsigned char blue)
{
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_RED, red);
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_GREEN, green);
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_BLUE, blue);
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_BRIGHTNESS, 0x64);
}
void EVGAGPUv2Controller::SetMode(unsigned char mode)
{
bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_MODE, mode);
}

57
Controllers/EVGAGPUController/EVGAGPUv2Controller.h Normal file
View file

@ -0,0 +1,57 @@
/*-----------------------------------------*\
| EVGAGPUv2Controller.h |
| |
| Definitions and types for EVGA GPU RGB |
| V2 (Turing) lighting controller |
| |
| Adam Honse (CalcProgrammer1) 9/13/2020 |
\*-----------------------------------------*/
#include <string>
#include "i2c_smbus.h"
#pragma once
typedef unsigned char evga_dev_id;
enum
{
EVGA_GPU_V2_REG_MODE = 0x60,
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,
};
enum
{
EVGA_GPU_V2_MODE_OFF = 0x00,
EVGA_GPU_V2_MODE_CUSTOM = 0x01,
EVGA_GPU_V2_MODE_RAINBOW = 0x0F,
EVGA_GPU_V2_MODE_BREATHING = 0x22,
};
class EVGAGPUv2Controller
{
public:
EVGAGPUv2Controller(i2c_smbus_interface* bus, evga_dev_id dev);
~EVGAGPUv2Controller();
std::string GetDeviceLocation();
unsigned char GetRed();
unsigned char GetGreen();
unsigned char GetBlue();
void SetColor(unsigned char red, unsigned char green, unsigned char blue);
void SetMode(unsigned char mode);
private:
i2c_smbus_interface* bus;
evga_dev_id dev;
};

4
OpenRGB.pro
View file

@ -140,6 +140,7 @@ HEADERS += \
Controllers/EKController/EKController.h \
Controllers/EspurnaController/EspurnaController.h \
Controllers/EVGAGPUController/EVGAGPUv1Controller.h \
Controllers/EVGAGPUController/EVGAGPUv2Controller.h \
Controllers/GalaxGPUController/GalaxGPUController.h \
Controllers/GloriousModelOController/GloriousModelOController.h \
Controllers/HoltekController/HoltekA070Controller.h \
@ -198,6 +199,7 @@ HEADERS += \
RGBController/RGBController_EKController.h \
RGBController/RGBController_Espurna.h \
RGBController/RGBController_EVGAGPUv1.h \
RGBController/RGBController_EVGAGPUv2.h \
RGBController/RGBController_GalaxGPU.h \
RGBController/RGBController_GloriousModelO.h \
RGBController/RGBController_HoltekA070.h \
@ -302,6 +304,7 @@ SOURCES += \
Controllers/EspurnaController/EspurnaController.cpp \
Controllers/EspurnaController/EspurnaControllerDetect.cpp \
Controllers/EVGAGPUController/EVGAGPUv1Controller.cpp \
Controllers/EVGAGPUController/EVGAGPUv2Controller.cpp \
Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp \
Controllers/GalaxGPUController/GalaxGPUController.cpp \
Controllers/GalaxGPUController/GalaxGPUControllerDetect.cpp \
@ -391,6 +394,7 @@ SOURCES += \
RGBController/RGBController_EKController.cpp \
RGBController/RGBController_Espurna.cpp \
RGBController/RGBController_EVGAGPUv1.cpp \
RGBController/RGBController_EVGAGPUv2.cpp \
RGBController/RGBController_GalaxGPU.cpp \
RGBController/RGBController_GloriousModelO.cpp \
RGBController/RGBController_HoltekA070.cpp \

10
RGBController/RGBController_EVGAGPUv1.cpp
View file

@ -1,5 +1,5 @@
/*-----------------------------------------*\
| RGBController_EVGAGPU.cpp |
| RGBController_EVGAGPUv1.cpp |
| |
| Generic RGB Interface for OpenRGB EVGA |
| GPU V1 (Pascal) Driver |
@ -21,28 +21,28 @@ RGBController_EVGAGPUv1::RGBController_EVGAGPUv1(EVGAGPUv1Controller* evga_ptr)
mode Off;
Off.name = "Off";
Off.value = EVGA_GPU_MODE_OFF;
Off.value = EVGA_GPU_V1_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Direct;
Direct.name = "Direct";
Direct.value = EVGA_GPU_MODE_CUSTOM;
Direct.value = EVGA_GPU_V1_MODE_CUSTOM;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = EVGA_GPU_MODE_RAINBOW;
Rainbow.value = EVGA_GPU_V1_MODE_RAINBOW;
Rainbow.flags = 0;
Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = EVGA_GPU_MODE_BREATHING;
Breathing.value = EVGA_GPU_V1_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Breathing);

2
RGBController/RGBController_EVGAGPUv1.h
View file

@ -1,5 +1,5 @@
/*-----------------------------------------*\
| RGBController_EVGAv1GPU.h |
| RGBController_EVGAGPUv1.h |
| |
| Generic RGB Interface for OpenRGB |
| EVGA GPU RGB V1 (Pascal) Driver |

118
RGBController/RGBController_EVGAGPUv2.cpp Normal file
View file

@ -0,0 +1,118 @@
/*-----------------------------------------*\
| RGBController_EVGAGPUv2.cpp |
| |
| Generic RGB Interface for OpenRGB EVGA |
| GPU V2 (Pascal) Driver |
| |
| Adam Honse (CalcProgrammer1) 9/13/2020 |
\*-----------------------------------------*/
#include "RGBController_EVGAGPUv2.h"
RGBController_EVGAGPUv2::RGBController_EVGAGPUv2(EVGAGPUv2Controller* evga_ptr)
{
evga = evga_ptr;
name = "EVGA GPU";
description = "EVGA RGB v2 GPU Device";
location = evga->GetDeviceLocation();
type = DEVICE_TYPE_GPU;
mode Off;
Off.name = "Off";
Off.value = EVGA_GPU_V2_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Direct;
Direct.name = "Direct";
Direct.value = EVGA_GPU_V2_MODE_CUSTOM;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
// mode Rainbow;
// Rainbow.name = "Rainbow";
// Rainbow.value = EVGA_GPU_V2_MODE_RAINBOW;
// Rainbow.flags = 0;
// Rainbow.color_mode = MODE_COLORS_NONE;
// modes.push_back(Rainbow);
// mode Breathing;
// Breathing.name = "Breathing";
// Breathing.value = EVGA_GPU_V2_MODE_BREATHING;
// Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR;
// Breathing.color_mode = MODE_COLORS_PER_LED;
// modes.push_back(Breathing);
SetupZones();
// Initialize active mode
active_mode = 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()
{
RGBColor color = colors[0];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
evga->SetColor(red, grn, blu);
}
void RGBController_EVGAGPUv2::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_EVGAGPUv2::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_EVGAGPUv2::SetCustomMode()
{
active_mode = 1;
}
void RGBController_EVGAGPUv2::DeviceUpdateMode()
{
evga->SetMode((unsigned char)modes[(unsigned int)active_mode].value);
}

33
RGBController/RGBController_EVGAGPUv2.h Normal file
View file

@ -0,0 +1,33 @@
/*-----------------------------------------*\
| RGBController_EVGAGPUv2.h |
| |
| Generic RGB Interface for OpenRGB |
| EVGA GPU RGB V2 (Turing) Driver |
| |
| Adam Honse (CalcProgrammer1) 9/13/2020 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "EVGAGPUv2Controller.h"
class RGBController_EVGAGPUv2 : public RGBController
{
public:
RGBController_EVGAGPUv2(EVGAGPUv2Controller* evga_ptr);
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
EVGAGPUv2Controller* evga;
};