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

Implements EVGA K|NGP|N 1080 Ti and 1080 ftw2

Browse source
This commit is contained in:
Qwex 2021-11-18 03:10:05 +00:00 • committed by Adam Honse
parent 92dda2f390
commit 9fe43eb3a6
7 changed files with 455 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

131
Controllers/EVGAGPUController/EVGAGP102Controller.cpp Normal file
View file

@ -0,0 +1,131 @@
/*-----------------------------------------*\
| EVGAGP102Controller.cpp |
| |
| Driver for EVGA GP102-based Nvidia GPUs |
| RGB controller for use with GeForce |
| GTX 1080 Ti FTW3 and K|NGP|N. |
| |
| Fabricio Murta (avengerx) 1/31/2021 |
\*-----------------------------------------*/
#include "EVGAGP102Controller.h"
#include "LogManager.h"
EVGAGP102Controller::EVGAGP102Controller(i2c_smbus_interface* bus_ptr, zoneinfo info)
{
bus = bus_ptr;
zi = info;
}
EVGAGP102Controller::~EVGAGP102Controller()
{
}
std::string EVGAGP102Controller::GetDeviceLocation()
{
std::string return_string(bus->device_name);
char addr[5];
snprintf(addr, 5, "0x%02X", zi.dev_addr);
return_string.append(", address ");
return_string.append(addr);
return("I2C: " + return_string);
}
void EVGAGP102Controller::SetColor(unsigned char red, unsigned char green, unsigned char blue)
{
SendCommand(EVGA_GP102_CMD_BEGIN);
SendCommand(EVGA_GP102_CMD_COLOR);
if (CommandAcknowledged())
{
unsigned char rgb[] = { red, green, blue };
for (int i = 0; i < 3; i++)
{
bus->i2c_smbus_write_byte_data(zi.dev_addr, zi.color_addrs[i], rgb[i]);
}
SendCommand(EVGA_GP102_CMD_END);
if (!CommandCompleted())
{
LOG_WARNING("[%s] Non-clear status report from hardware.", EVGA_GP102_CONTROLLER_NAME);
}
}
}
std::array<unsigned char, 3> EVGAGP102Controller::GetColor()
{
return { GetRed(), GetGreen(), GetBlue() };
}
bool EVGAGP102Controller::IsValid()
{
for (int i = 0; i < 3; i++)
{
char res = bus->i2c_smbus_read_byte_data(zi.dev_addr, EVGA_GP102_REG_VALID);
if (res == 0x1F)
{
LOG_TRACE("[%s] Zone discovery successful on address: 0x%02X.", EVGA_GP102_CONTROLLER_NAME, zi.dev_addr);
return true;
}
LOG_DEBUG("[%s] Zone discovery failed on address: 0x%02X expected: 0x1F received: 0x%02X.", EVGA_GP102_CONTROLLER_NAME, zi.dev_addr, res);
}
return false;
}
void EVGAGP102Controller::SetMode(unsigned char mode)
{
bus->i2c_smbus_write_byte_data(zi.dev_addr, EVGA_GP102_REG_MODE, mode);
}
unsigned char EVGAGP102Controller::GetMode()
{
return(bus->i2c_smbus_read_byte_data(zi.dev_addr, EVGA_GP102_REG_MODE));
}
void EVGAGP102Controller::SendCommand(s32 command)
{
bus->i2c_smbus_write_byte_data(zi.dev_addr, EVGA_GP102_REG_CMD, command);
}
s32 EVGAGP102Controller::QueryCommand(s32 command)
{
return bus->i2c_smbus_read_byte_data(zi.dev_addr, command);
}
bool EVGAGP102Controller::CommandAcknowledged()
{
return QueryCommand(EVGA_GP102_REG_CMD) == zi.resp_ready;
}
bool EVGAGP102Controller::CommandCompleted()
{
return QueryCommand(EVGA_GP102_REG_CMD) == zi.resp_clear;
}
unsigned char EVGAGP102Controller::GetRed()
{
return(bus->i2c_smbus_read_byte_data(zi.dev_addr, zi.color_addrs[EVGA_GP102_CIDX_RED]));
}
unsigned char EVGAGP102Controller::GetGreen()
{
return(bus->i2c_smbus_read_byte_data(zi.dev_addr, zi.color_addrs[EVGA_GP102_CIDX_GREEN]));
}
unsigned char EVGAGP102Controller::GetBlue()
{
return(bus->i2c_smbus_read_byte_data(zi.dev_addr, zi.color_addrs[EVGA_GP102_CIDX_BLUE]));
}
void EVGAGP102Controller::SaveSettings()
{
//Tested and not worked
//bus->i2c_smbus_write_byte_data(zi.dev_addr, 0x21, 0xE5);
//bus->i2c_smbus_write_byte_data(zi.dev_addr, 0x22, 0xE7);
}
std::string EVGAGP102Controller::GetName()
{
return zi.zone_name;
}

102
Controllers/EVGAGPUController/EVGAGP102Controller.h Normal file
View file

@ -0,0 +1,102 @@
/*-----------------------------------------*\
| EVGAGP102Controller.h |
| |
| Definitions and types for EVGA |
| GP102-based Nvidia GPUs' RGB controller |
| GeForce GTX 1080 Ti K|NGP|N and FTW3. |
| |
| Fabricio Murta (avengerx) 1/31/2021 |
\*-----------------------------------------*/
#include <string>
#include "i2c_smbus.h"
#include <vector>
#pragma once
#define EVGA_GP102_CONTROLLER_NAME "EVGA GP102 Nvidia GPU"
enum
{
EVGA_GP102_REG_MODE = 0x0C,
EVGA_GP102_REG_CMD = 0x0E,
EVGA_GP102_REG_VALID = 0x04
};
enum
{
EVGA_GP102_MODE_OFF = 0x00,
EVGA_GP102_MODE_CUSTOM = 0x01
// TODO: Other LEDSync modes (rainbow, breath, pulse)
};
enum
{
EVGA_GP102_CIDX_RED = 0,
EVGA_GP102_CIDX_GREEN = 1,
EVGA_GP102_CIDX_BLUE = 2
};
enum
{
EVGA_GP102_CMD_BEGIN = 0xE5,
EVGA_GP102_CMD_COLOR = 0xE9,
EVGA_GP102_CMD_END = 0xE0
};
typedef struct
{
std::string zone_name;
s32 dev_addr;
s32 color_addrs[3];
s32 resp_ready;
s32 resp_clear;
} zoneinfo;
const static zoneinfo gpuzoneinfos[]
{
{
"Nameplate",
0x4A,
{0x09, 0x0A, 0x0B},
0x03,
0x00
},
{
"Backplate",
0x2A,
{0x30, 0x31, 0x32},
0xE9,
0xE0
}
};
class EVGAGP102Controller
{
public:
EVGAGP102Controller(i2c_smbus_interface* bus, zoneinfo info);
~EVGAGP102Controller();
bool IsValid();
std::string GetDeviceLocation();
std::string GetName();
unsigned char GetMode();
void SetColor(unsigned char red, unsigned char green, unsigned char blue);
std::array<unsigned char, 3> GetColor();
void SetMode(unsigned char mode);
void SaveSettings();
private:
bool CommandAcknowledged();
bool CommandCompleted();
s32 QueryCommand(s32 command);
void SendCommand(s32 command);
unsigned char GetRed();
unsigned char GetGreen();
unsigned char GetBlue();
i2c_smbus_interface* bus;
zoneinfo zi;
};

34
Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp
View file

@ -1,10 +1,12 @@
#include "Detector.h"
#include "EVGAGPUCommon.h"
#include "EVGAGP102Controller.h"
#include "EVGAGPUv1Controller.h"
#include "EVGAGPUv2Controller.h"
#include "EVGAGPUv3Controller.h"
#include "LogManager.h"
#include "RGBController.h"
#include "RGBController_EVGAGP102.h"
#include "RGBController_EVGAGPUv1.h"
#include "RGBController_EVGAGPUv2.h"
#include "RGBController_EVGAGPUv3.h"
@ -16,6 +18,7 @@
enum
{
EVGA_RGB_GP102,
EVGA_RGB_V1,
EVGA_RGB_V2,
EVGA_RGB_V3,
@ -39,6 +42,10 @@ static const gpu_pci_device device_list[] =
{ NVIDIA_VEN, NVIDIA_GTX1070_DEV, EVGA_SUB_VEN, EVGA_GTX1070_FTW_SUB_DEV, EVGA_RGB_V1, "EVGA GeForce GTX 1070 FTW" },
{ NVIDIA_VEN, NVIDIA_GTX1070TI_DEV, EVGA_SUB_VEN, EVGA_GTX1070TI_FTW2_SUB_DEV, EVGA_RGB_V1, "EVGA GeForce GTX 1070 Ti FTW2" },
{ NVIDIA_VEN, NVIDIA_GTX1080_DEV, EVGA_SUB_VEN, EVGA_GTX1080_FTW_SUB_DEV, EVGA_RGB_V1, "EVGA GeForce GTX 1080 FTW" },
{ NVIDIA_VEN, NVIDIA_GTX1080_DEV, EVGA_SUB_VEN, EVGA_GTX1080_FTW2_SUB_DEV, EVGA_RGB_GP102, "EVGA GeForce GTX 1080 FTW2" },
{ NVIDIA_VEN, NVIDIA_GTX1080TI_DEV, EVGA_SUB_VEN, EVGA_GTX1080TI_FTW3_SUB_DEV, EVGA_RGB_GP102, "EVGA GTX 1080 Ti FTW3" },
{ NVIDIA_VEN, NVIDIA_GTX1080TI_DEV, EVGA_SUB_VEN, EVGA_GTX1080TI_FTW3_HYBRID_SUB_DEV, EVGA_RGB_GP102, "EVGA 1080Ti FTW3 Hybrid" },
{ NVIDIA_VEN, NVIDIA_GTX1080TI_DEV, EVGA_SUB_VEN, EVGA_GTX1080TI_KINGPIN_SUB_DEV, EVGA_RGB_GP102, "EVGA GTX 1080 Ti K|NGP|N" },
{ NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070_XC_GAMING_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2070 XC Gaming" },
{ NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, EVGA_SUB_VEN, EVGA_RTX2070_XC_OC_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2070 XC OC" },
{ NVIDIA_VEN, NVIDIA_RTX2070S_DEV, EVGA_SUB_VEN, EVGA_RTX2070S_BLACK_SUB_DEV, EVGA_RGB_V2, "EVGA GeForce RTX 2070 SUPER Black" },
@ -100,7 +107,6 @@ static const gpu_pci_device device_list[] =
{ NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_KINGPIN_HYBRID_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3090 K|NGP|N Hybrid" },
{ NVIDIA_VEN, NVIDIA_RTX3090_DEV, EVGA_SUB_VEN, EVGA_RTX3090_KINGPIN_HC_SUB_DEV, EVGA_RGB_V3, "EVGA GeForce RTX 3090 K|NGP|N Hydro Copper" },
};
/******************************************************************************************\
* *
* DetectEVGAGPUControllers *
@ -178,6 +184,32 @@ void DetectEVGAGPUControllers(std::vector<i2c_smbus_interface*>& busses)
}
}
break;
case EVGA_RGB_GP102:
{
LOG_DEBUG(EVGA_DETECT_MESSAGE, EVGA_GP102_CONTROLLER_NAME, bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name );
RGBController_EVGAGP102* new_rgbcontroller;
std::vector<EVGAGP102Controller*> controllers;
for(unsigned int i = 0; i < sizeof(gpuzoneinfos) / sizeof(zoneinfo); i++)
{
EVGAGP102Controller* contr = new EVGAGP102Controller(busses[bus], gpuzoneinfos[i]);
if (contr->IsValid())
{
controllers.push_back(contr);
}
else
{
delete contr;
}
}
if(controllers.size() != 0)
{
new_rgbcontroller = new RGBController_EVGAGP102(controllers);
new_rgbcontroller->name = device_list[dev_idx].name;
ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
}
}
break;
}
}
}

146
Controllers/EVGAGPUController/RGBController_EVGAGP102.cpp Normal file
View file

@ -0,0 +1,146 @@
/*-----------------------------------------*\
| RGBController_EVGAGPUv1.cpp |
| |
| Generic RGB Interface for OpenRGB EVGA |
| GP102-based Nvidia GPUs. |
| |
| Fabricio Murta (avengerx) 1/31/2021 |
\*-----------------------------------------*/
#include "RGBController_EVGAGP102.h"
#include <array>
RGBController_EVGAGP102::RGBController_EVGAGP102(std::vector<EVGAGP102Controller*> evga_ptr)
{
evga = evga_ptr;
name = "EVGA GP102 GPU";
vendor = "EVGA";
description = "EVGA GP102-based RGB GPU Device";
for(unsigned int i = 0; i < zones.size(); i++)
{
location += evga[i]->GetDeviceLocation() + " ";
}
type = DEVICE_TYPE_GPU;
mode Off;
Off.name = "Off";
Off.value = EVGA_GP102_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Direct;
Direct.name = "Direct";
Direct.value = EVGA_GP102_MODE_CUSTOM;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
// Initialize active mode and stored color
unsigned char raw_active_mode = evga[0]->GetMode();
active_mode = 0;
for(unsigned int i = 0; i < modes.size(); i++)
{
if (modes[i].value == raw_active_mode)
{
active_mode = i;
break;
}
}
for(unsigned int i = 0; i < zones.size(); i++)
{
std::array<unsigned char, 3> rgb = evga[i]->GetColor();
colors[i] = ToRGBColor(rgb[0], rgb[1], rgb[2]);
}
}
RGBController_EVGAGP102::~RGBController_EVGAGP102()
{
for(unsigned int i = 0; i < evga.size(); i++)
{
delete evga[i];
}
}
void RGBController_EVGAGP102::SetupZones()
{
/*---------------------------------------------------------*\
| This device basically has two controllable zones, one at |
| the top of the board with GeForce 1080 Ti and another for |
| the backplate logo (K|NGP|N logo, or EVGA GeForce 1080 Ti |
| for the FTW3).
\*---------------------------------------------------------*/
for(unsigned int i = 0; i < evga.size(); i++)
{
zone new_zone;
led new_led;
new_zone.name = evga[i]->GetName();
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[i]->GetName();
leds.push_back(new_led);
zones.push_back(new_zone);
}
SetupColors();
}
void RGBController_EVGAGP102::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_EVGAGP102::DeviceUpdateLEDs()
{
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
UpdateZoneLEDs(zone_idx);
}
}
void RGBController_EVGAGP102::UpdateZoneLEDs(int zone)
{
RGBColor color = colors[zone];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
evga[zone]->SetColor(red, grn, blu);
}
void RGBController_EVGAGP102::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_EVGAGP102::SetCustomMode()
{
active_mode = 1;
}
void RGBController_EVGAGP102::DeviceUpdateMode()
{
for (int i = 0; i < evga.size(); i++)
{
evga[i]->SetMode((unsigned char)modes[(unsigned int)active_mode].value);
}
}
void RGBController_EVGAGP102::DeviceSaveMode()
{
}

35
Controllers/EVGAGPUController/RGBController_EVGAGP102.h Normal file
View file

@ -0,0 +1,35 @@
/*-----------------------------------------*\
| RGBController_EVGAGP102.h |
| |
| EVGA Generic RGB Interface for OpenRGB |
| EVGA GP102-based Nvidia GPUs. |
| |
| Fabricio Murta (avengerx) 1/31/2021 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "EVGAGP102Controller.h"
class RGBController_EVGAGP102 : public RGBController
{
public:
RGBController_EVGAGP102(std::vector<EVGAGP102Controller*> evga_ptr);
~RGBController_EVGAGP102();
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:
std::vector<EVGAGP102Controller*> evga;
};

4
OpenRGB.pro
View file

@ -287,10 +287,12 @@ HEADERS +=
Controllers/ENESMBusController/RGBController_ENESMBus.h \
Controllers/EspurnaController/EspurnaController.h \
Controllers/EspurnaController/RGBController_Espurna.h \
Controllers/EVGAGPUController/EVGAGP102Controller.h \
Controllers/EVGAGPUController/EVGAGPUCommon.h \
Controllers/EVGAGPUController/EVGAGPUv1Controller.h \
Controllers/EVGAGPUController/EVGAGPUv2Controller.h \
Controllers/EVGAGPUController/EVGAGPUv3Controller.h \
Controllers/EVGAGPUController/RGBController_EVGAGP102.h \
Controllers/EVGAGPUController/RGBController_EVGAGPUv1.h \
Controllers/EVGAGPUController/RGBController_EVGAGPUv2.h \
Controllers/EVGAGPUController/RGBController_EVGAGPUv3.h \
@ -662,10 +664,12 @@ SOURCES +=
Controllers/EspurnaController/EspurnaController.cpp \
Controllers/EspurnaController/EspurnaControllerDetect.cpp \
Controllers/EspurnaController/RGBController_Espurna.cpp \
Controllers/EVGAGPUController/EVGAGP102Controller.cpp \
Controllers/EVGAGPUController/EVGAGPUv1Controller.cpp \
Controllers/EVGAGPUController/EVGAGPUv2Controller.cpp \
Controllers/EVGAGPUController/EVGAGPUv3Controller.cpp \
Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp \
Controllers/EVGAGPUController/RGBController_EVGAGP102.cpp \
Controllers/EVGAGPUController/RGBController_EVGAGPUv1.cpp \
Controllers/EVGAGPUController/RGBController_EVGAGPUv2.cpp \
Controllers/EVGAGPUController/RGBController_EVGAGPUv3.cpp \

4
pci_ids/pci_ids.h
View file

@ -141,6 +141,10 @@
#define EVGA_GTX1070_FTW_SUB_DEV 0x6276
#define EVGA_GTX1070TI_FTW2_SUB_DEV 0x6775
#define EVGA_GTX1080_FTW_SUB_DEV 0x6286
#define EVGA_GTX1080_FTW2_SUB_DEV 0x6687
#define EVGA_GTX1080TI_FTW3_SUB_DEV 0x6696
#define EVGA_GTX1080TI_FTW3_HYBRID_SUB_DEV 0x6698
#define EVGA_GTX1080TI_KINGPIN_SUB_DEV 0x6798
#define EVGA_RTX2070_XC_GAMING_SUB_DEV 0x2172
#define EVGA_RTX2070_XC_OC_SUB_DEV 0x2173
#define EVGA_RTX2070S_BLACK_SUB_DEV 0x3071