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

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

68
Controllers/EVGAPascalGPUController/EVGAGPUv1Controller.cpp Normal file
View file

@ -0,0 +1,68 @@
/*-----------------------------------------*\
| EVGAGPUv1Controller.cpp |
| |
| Driver for EVGA GPU RGB V1 (Pascal) |
| lighting controller |
| |
| Adam Honse (CalcProgrammer1) 9/11/2020 |
\*-----------------------------------------*/
#include "EVGAGPUv1Controller.h"
EVGAGPUv1Controller::EVGAGPUv1Controller(i2c_smbus_interface* bus, evga_dev_id dev)
{
this->bus = bus;
this->dev = dev;
}
EVGAGPUv1Controller::~EVGAGPUv1Controller()
{
}
std::string EVGAGPUv1Controller::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 EVGAGPUv1Controller::GetMode()
{
return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V1_REG_MODE));
}
unsigned char EVGAGPUv1Controller::GetRed()
{
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_V1_REG_GREEN));
}
unsigned char EVGAGPUv1Controller::GetBlue()
{
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_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_V1_REG_MODE, mode);
}
void EVGAGPUv1Controller::SaveSettings()
{
bus->i2c_smbus_write_byte_data(dev, 0x23, 0xE5);
}

56
Controllers/EVGAPascalGPUController/EVGAGPUv1Controller.h Normal file
View file

@ -0,0 +1,56 @@
/*-----------------------------------------*\
| EVGAGPUv1Controller.h |
| |
| Definitions and types for EVGA GPU RGB |
| V1 (Pascal) lighting controller |
| |
| Adam Honse (CalcProgrammer1) 9/11/2020 |
\*-----------------------------------------*/
#include <string>
#include "i2c_smbus.h"
#pragma once
typedef unsigned char evga_dev_id;
#define EVGAGPUV1_CONTROLLER_NAME "EVGAv1"
enum
{
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_V1_MODE_OFF = 0x00,
EVGA_GPU_V1_MODE_CUSTOM = 0x01,
EVGA_GPU_V1_MODE_RAINBOW = 0x02,
EVGA_GPU_V1_MODE_BREATHING = 0x05,
};
class EVGAGPUv1Controller
{
public:
EVGAGPUv1Controller(i2c_smbus_interface* bus, evga_dev_id dev);
~EVGAGPUv1Controller();
std::string GetDeviceLocation();
unsigned char GetMode();
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);
void SaveSettings();
private:
i2c_smbus_interface* bus;
evga_dev_id dev;
};

71
Controllers/EVGAPascalGPUController/EVGAPascalGPUControllerDetect.cpp Normal file
View file

@ -0,0 +1,71 @@
#include "Detector.h"
#include "EVGAGPUv1Controller.h"
#include "LogManager.h"
#include "RGBController.h"
#include "RGBController_EVGAGPUv1.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_GTX1070_DEV, EVGA_SUB_VEN, EVGA_GTX1070_FTW_DT_GAMING_SUB_DEV, "EVGA GeForce GTX 1070 FTW DT Gaming" },
{ 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_HYBRID_SUB_DEV, "EVGA GeForce GTX 1070 FTW HYBRID" },
{ NVIDIA_VEN, NVIDIA_GTX1070TI_DEV, EVGA_SUB_VEN, EVGA_GTX1070TI_FTW2_SUB_DEV, "EVGA GeForce GTX 1070 Ti FTW2" },
{ NVIDIA_VEN, NVIDIA_GTX1080_DEV, EVGA_SUB_VEN, EVGA_GTX1080_FTW_SUB_DEV, "EVGA GeForce GTX 1080 FTW" },
};
/******************************************************************************************\
* *
* DetectEVGAGPUControllers *
* *
* Detect EVGA Pascal 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 DetectEVGAPascalGPUControllers(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, EVGAGPUV1_CONTROLLER_NAME, bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name );
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;
ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
}
}
}
} /* DetectEVGAPascalGPUControllers() */
REGISTER_I2C_DETECTOR("EVGA Pascal GPU", DetectEVGAPascalGPUControllers);

147
Controllers/EVGAPascalGPUController/RGBController_EVGAGPUv1.cpp Normal file
View file

@ -0,0 +1,147 @@
/*-----------------------------------------*\
| RGBController_EVGAGPUv1.cpp |
| |
| Generic RGB Interface for OpenRGB EVGA |
| GPU V1 (Pascal) Driver |
| |
| Adam Honse (CalcProgrammer1) 9/11/2020 |
\*-----------------------------------------*/
#include "RGBController_EVGAGPUv1.h"
RGBController_EVGAGPUv1::RGBController_EVGAGPUv1(EVGAGPUv1Controller* evga_ptr)
{
evga = evga_ptr;
name = "EVGA GPU";
vendor = "EVGA";
description = "EVGA RGB v1 GPU Device";
location = evga->GetDeviceLocation();
type = DEVICE_TYPE_GPU;
mode Off;
Off.name = "Off";
Off.value = EVGA_GPU_V1_MODE_OFF;
Off.flags = MODE_FLAG_MANUAL_SAVE;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Direct;
Direct.name = "Direct";
Direct.value = EVGA_GPU_V1_MODE_CUSTOM;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = EVGA_GPU_V1_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_MANUAL_SAVE;
Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = EVGA_GPU_V1_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
Breathing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Breathing);
SetupZones();
// Initialize active mode and stored color
unsigned char raw_active_mode = evga->GetMode();
active_mode = 0;
for(unsigned int i = 0; i < modes.size(); i++)
{
if (modes[i].value == raw_active_mode)
{
active_mode = i;
break;
}
}
unsigned char r = evga->GetRed();
unsigned char g = evga->GetGreen();
unsigned char b = evga->GetBlue();
RGBColor color = ToRGBColor(r, g, b);
colors[0] = color;
}
RGBController_EVGAGPUv1::~RGBController_EVGAGPUv1()
{
delete evga;
}
void RGBController_EVGAGPUv1::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_EVGAGPUv1::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_EVGAGPUv1::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_EVGAGPUv1::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_EVGAGPUv1::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_EVGAGPUv1::SetCustomMode()
{
active_mode = 1;
}
void RGBController_EVGAGPUv1::DeviceUpdateMode()
{
evga->SetMode((unsigned char)modes[(unsigned int)active_mode].value);
}
void RGBController_EVGAGPUv1::DeviceSaveMode()
{
evga->SaveSettings();
}

35
Controllers/EVGAPascalGPUController/RGBController_EVGAGPUv1.h Normal file
View file

@ -0,0 +1,35 @@
/*-----------------------------------------*\
| RGBController_EVGAGPUv1.h |
| |
| Generic RGB Interface for OpenRGB |
| EVGA GPU RGB V1 (Pascal) Driver |
| |
| Adam Honse (CalcProgrammer1) 9/11/2020 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "EVGAGPUv1Controller.h"
class RGBController_EVGAGPUv1 : public RGBController
{
public:
RGBController_EVGAGPUv1(EVGAGPUv1Controller* evga_ptr);
~RGBController_EVGAGPUv1();
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:
EVGAGPUv1Controller* evga;
};