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/GainwardGPUController/GainwardGPUControllerDetect.cpp
+114
View File
@@ -0,0 +1,114 @@
/*---------------------------------------------------------*\
| GainwardGPUControllerDetect.cpp |
| |
| Detector for Gainward GPU |
| |
| TheRogueZeta 05 Nov 2020 |
| KundaPanda 04 Jan 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "Detector.h"
#include "GainwardGPUv1Controller.h"
#include "GainwardGPUv2Controller.h"
#include "RGBController_GainwardGPUv1.h"
#include "RGBController_GainwardGPUv2.h"
#include "i2c_smbus.h"
#include "pci_ids.h"
/******************************************************************************************\
* *
* TestForGainwardGPUController *
* *
* Tests the given address to see if a Gainward GPU controller exists there. *
* *
\******************************************************************************************/
bool TestForGainwardGPUController(i2c_smbus_interface* bus, uint8_t i2c_addr)
{
bool pass = false;
switch(i2c_addr)
{
/*-----------------------------------------------------------------*\
| V1 Controller |
\*-----------------------------------------------------------------*/
case 0x08:
pass = bus->i2c_smbus_write_quick(i2c_addr, I2C_SMBUS_WRITE);
break;
/*-----------------------------------------------------------------*\
| V2 Controller |
\*-----------------------------------------------------------------*/
case 0x49:
/*-------------------------------------------------------------*\
| This detection might need some modifications |
| Reading 0x6F*0x73 and comparing to 0x64 might be a possibility|
\*-------------------------------------------------------------*/
s32 data = bus->i2c_smbus_read_byte_data(i2c_addr, 0x0);
s32 mode_data = bus->i2c_smbus_read_byte_data(i2c_addr, 0xe0);
pass = (data == 0x0) && (mode_data < 0x5);
break;
}
return(pass);
} /* TestForGainwardGPUController() */
/******************************************************************************************\
* *
* DetectGainwardGPUControllers *
* *
* Detect Gainward GPU controllers on the enumerated I2C busses. *
* *
\******************************************************************************************/
void DetectGainwardGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
{
if(TestForGainwardGPUController(bus, i2c_addr))
{
switch(i2c_addr)
{
/*-----------------------------------------------------------------*\
| V1 Controller |
\*-----------------------------------------------------------------*/
case 0x08:
{
GainwardGPUv1Controller* controller = new GainwardGPUv1Controller(bus, i2c_addr, name);
RGBController_GainwardGPUv1* rgb_controller = new RGBController_GainwardGPUv1(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
break;
/*-----------------------------------------------------------------*\
| V2 Controller |
\*-----------------------------------------------------------------*/
case 0x49:
{
GainwardGPUv2Controller* controller = new GainwardGPUv2Controller(bus, i2c_addr, name);
RGBController_GainwardGPUv2* rgb_controller = new RGBController_GainwardGPUv2(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
break;
}
}
} /* DetectGainwardGPUControllers() */
REGISTER_I2C_PCI_DETECTOR("Gainward GeForce GTX 1080 Phoenix", DetectGainwardGPUControllers, NVIDIA_VEN, NVIDIA_GTX1080_DEV, GAINWARD_SUB_VEN, GAINWARD_GTX_1080_PHOENIX, 0x08);
REGISTER_I2C_PCI_DETECTOR("Gainward GeForce GTX 1080 Ti Phoenix", DetectGainwardGPUControllers, NVIDIA_VEN, NVIDIA_GTX1080TI_DEV, GAINWARD_SUB_VEN, GAINWARD_GTX_1080TI_PHOENIX, 0x08);
REGISTER_I2C_PCI_DETECTOR("Gainward GeForce GTX 1660 SUPER Ghost", DetectGainwardGPUControllers, NVIDIA_VEN, NVIDIA_GTX1660S_DEV, NVIDIA_SUB_VEN, NVIDIA_GTX1660S_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 2070 SUPER Phantom", DetectGainwardGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, GAINWARD_SUB_VEN, NVIDIA_RTX2070S_OC_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 2080 Phoenix GS", DetectGainwardGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_DEV, GAINWARD_SUB_VEN, NVIDIA_RTX2080_A_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3060 Pegasus 12G", DetectGainwardGPUControllers, NVIDIA_VEN, NVIDIA_RTX3060_DEV, NVIDIA_SUB_VEN, NVIDIA_RTX3060_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3070 Phantom", DetectGainwardGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_DEV, GAINWARD_SUB_VEN, GAINWARD_RTX_3070_PHANTOM, 0x49);
REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3070 Phoenix", DetectGainwardGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_DEV, GAINWARD_SUB_VEN, NVIDIA_RTX3070_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3070 Ti Phoenix", DetectGainwardGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070TI_DEV, GAINWARD_SUB_VEN, NVIDIA_RTX3070TI_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3080 Phoenix", DetectGainwardGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080_DEV, GAINWARD_SUB_VEN, NVIDIA_RTX3080_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3080 Ti Phoenix", DetectGainwardGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, GAINWARD_SUB_VEN, NVIDIA_RTX3080TI_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3090 Phoenix", DetectGainwardGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090_DEV, GAINWARD_SUB_VEN, NVIDIA_RTX3090_DEV, 0x49);
REGISTER_I2C_PCI_DETECTOR("Gainward GeForce RTX 3090 Ti Phantom", DetectGainwardGPUControllers, NVIDIA_VEN, NVIDIA_RTX3090TI_DEV, GAINWARD_SUB_VEN, GAINWARD_RTX_3090TI_PHANTOM, 0x49);
Controllers/GainwardGPUController/GainwardGPUv1Controller/GainwardGPUv1Controller.cpp
+78
View File
@@ -0,0 +1,78 @@
/*---------------------------------------------------------*\
| GainwardGPUv1Controller.cpp |
| |
| Driver for Gainward v1 GPU |
| |
| TheRogueZeta 05 Nov 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "GainwardGPUv1Controller.h"
GainwardGPUv1Controller::GainwardGPUv1Controller(i2c_smbus_interface* bus, gainward_gpu_dev_id dev, std::string dev_name)
{
this->bus = bus;
this->dev = dev;
this->name = dev_name;
}
GainwardGPUv1Controller::~GainwardGPUv1Controller()
{
}
std::string GainwardGPUv1Controller::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 GainwardGPUv1Controller::GetDeviceName()
{
return(name);
}
unsigned char GainwardGPUv1Controller::GetLEDRed()
{
return(GainwardGPURegisterRead(GAINWARD_RED_REGISTER));
}
unsigned char GainwardGPUv1Controller::GetLEDGreen()
{
return(GainwardGPURegisterRead(GAINWARD_GREEN_REGISTER));
}
unsigned char GainwardGPUv1Controller::GetLEDBlue()
{
return(GainwardGPURegisterRead(GAINWARD_BLUE_REGISTER));
}
void GainwardGPUv1Controller::SetLEDColors(unsigned char red, unsigned char green, unsigned char blue)
{
GainwardGPURegisterWrite(GAINWARD_RED_REGISTER, red);
GainwardGPURegisterWrite(GAINWARD_GREEN_REGISTER, green);
GainwardGPURegisterWrite(GAINWARD_BLUE_REGISTER, blue);
GainwardGPURegisterWrite(GAINWARD_06_REGISTER, 0xFF);
}
void GainwardGPUv1Controller::SetMode()
{
}
unsigned char GainwardGPUv1Controller::GainwardGPURegisterRead(unsigned char reg)
{
return(bus->i2c_smbus_read_byte_data(dev, reg));
}
void GainwardGPUv1Controller::GainwardGPURegisterWrite(unsigned char reg, unsigned char val)
{
bus->i2c_smbus_write_byte_data(dev, reg, val);
}
Controllers/GainwardGPUController/GainwardGPUv1Controller/GainwardGPUv1Controller.h
+50
View File
@@ -0,0 +1,50 @@
/*---------------------------------------------------------*\
| GainwardGPUv1Controller.h |
| |
| Driver for Gainward v1 GPU |
| |
| TheRogueZeta 05 Nov 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include "i2c_smbus.h"
typedef unsigned char gainward_gpu_dev_id;
enum
{
/* RGB Registers */
GAINWARD_RED_REGISTER = 0x03, /* Red Register */
GAINWARD_GREEN_REGISTER = 0x04, /* Green Register */
GAINWARD_BLUE_REGISTER = 0x05, /* Blue Register */
GAINWARD_06_REGISTER = 0x06, /* Unknown (Brightness/Mode?) Register */
};
class GainwardGPUv1Controller
{
public:
GainwardGPUv1Controller(i2c_smbus_interface* bus, gainward_gpu_dev_id, std::string dev_name);
~GainwardGPUv1Controller();
std::string GetDeviceLocation();
std::string GetDeviceName();
unsigned char GetLEDRed();
unsigned char GetLEDGreen();
unsigned char GetLEDBlue();
void SetLEDColors(unsigned char red, unsigned char green, unsigned char blue);
void SetMode();
unsigned char GainwardGPURegisterRead(unsigned char reg);
void GainwardGPURegisterWrite(unsigned char reg, unsigned char val);
private:
i2c_smbus_interface * bus;
gainward_gpu_dev_id dev;
std::string name;
};
Controllers/GainwardGPUController/GainwardGPUv1Controller/RGBController_GainwardGPUv1.cpp
+121
View File
@@ -0,0 +1,121 @@
/*---------------------------------------------------------*\
| RGBController_GainwardGPUv1.cpp |
| |
| RGBController for Gainward v1 GPU |
| |
| TheRogueZeta 05 Nov 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_GainwardGPUv1.h"
int RGBController_GainwardGPUv1::GetDeviceMode()
{
active_mode = 1;
return(active_mode);
}
/**------------------------------------------------------------------*\
@name Gainward GPU v1
@category GPU
@type I2C
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectGainwardGPUControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_GainwardGPUv1::RGBController_GainwardGPUv1(GainwardGPUv1Controller* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "Gainward";
type = DEVICE_TYPE_GPU;
description = "Gainward GPU V1 Device";
location = controller->GetDeviceLocation();
mode Direct;
Direct.name = "Direct";
Direct.value = 1;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
}
RGBController_GainwardGPUv1::~RGBController_GainwardGPUv1()
{
delete controller;
}
void RGBController_GainwardGPUv1::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zone |
\*---------------------------------------------------------*/
zone gainward_gpu_zone;
gainward_gpu_zone.name = "GPU";
gainward_gpu_zone.type = ZONE_TYPE_SINGLE;
gainward_gpu_zone.leds_min = 1;
gainward_gpu_zone.leds_max = 1;
gainward_gpu_zone.leds_count = 1;
gainward_gpu_zone.matrix_map = NULL;
zones.push_back(gainward_gpu_zone);
/*---------------------------------------------------------*\
| Set up LED |
\*---------------------------------------------------------*/
led gainward_gpu_led;
gainward_gpu_led.name = "GPU";
leds.push_back(gainward_gpu_led);
SetupColors();
/*---------------------------------------------------------*\
| Initialize color |
\*---------------------------------------------------------*/
unsigned char red = controller->GetLEDRed();
unsigned char grn = controller->GetLEDGreen();
unsigned char blu = controller->GetLEDBlue();
colors[0] = ToRGBColor(red, grn, blu);
}
void RGBController_GainwardGPUv1::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_GainwardGPUv1::DeviceUpdateLEDs()
{
for(std::size_t led = 0; led < colors.size(); led++)
{
unsigned char red = RGBGetRValue(colors[led]);
unsigned char grn = RGBGetGValue(colors[led]);
unsigned char blu = RGBGetBValue(colors[led]);
controller->SetLEDColors(red, grn, blu);
}
}
void RGBController_GainwardGPUv1::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_GainwardGPUv1::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_GainwardGPUv1::DeviceUpdateMode()
{
}
Controllers/GainwardGPUController/GainwardGPUv1Controller/RGBController_GainwardGPUv1.h
+37
View File
@@ -0,0 +1,37 @@
/*---------------------------------------------------------*\
| RGBController_GainwardGPUv1.h |
| |
| RGBController for Gainward v1 GPU |
| |
| TheRogueZeta 05 Nov 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "GainwardGPUv1Controller.h"
class RGBController_GainwardGPUv1 : public RGBController
{
public:
RGBController_GainwardGPUv1(GainwardGPUv1Controller* controller_ptr);
~RGBController_GainwardGPUv1();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
GainwardGPUv1Controller* controller;
int GetDeviceMode();
};
Controllers/GainwardGPUController/GainwardGPUv2Controller/GainwardGPUv2Controller.cpp
+97
View File
@@ -0,0 +1,97 @@
/*---------------------------------------------------------*\
| GainwardGPUv2Controller.cpp |
| |
| Driver for Gainward v2 GPU |
| |
| KundaPanda 04 Jan 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "GainwardGPUv2Controller.h"
GainwardGPUv2Controller::GainwardGPUv2Controller(i2c_smbus_interface* bus, gainward_gpu_dev_id dev, std::string dev_name)
{
this->bus = bus;
this->dev = dev;
this->name = dev_name;
}
GainwardGPUv2Controller::~GainwardGPUv2Controller() = default;
std::string GainwardGPUv2Controller::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 GainwardGPUv2Controller::GetDeviceName()
{
return(name);
}
unsigned char GainwardGPUv2Controller::GetLEDRed()
{
return(bus->i2c_smbus_read_byte_data(dev, GAINWARD_V2_RED_REGISTER));
}
unsigned char GainwardGPUv2Controller::GetLEDGreen()
{
return(bus->i2c_smbus_read_byte_data(dev, GAINWARD_V2_GREEN_REGISTER));
}
unsigned char GainwardGPUv2Controller::GetLEDBlue()
{
return(bus->i2c_smbus_read_byte_data(dev, GAINWARD_V2_BLUE_REGISTER));
}
void GainwardGPUv2Controller::SetLEDColors(unsigned char red, unsigned char green, unsigned char blue, unsigned char color_register)
{
switch (color_register)
{
default:
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_RED_REGISTER, red);
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_GREEN_REGISTER, green);
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BLUE_REGISTER, blue);
break;
case GAINWARD_V2_COLOR_REGISTER_SECONDARY:
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_RED_SECONDARY_REGISTER, red);
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_GREEN_SECONDARY_REGISTER, green);
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BLUE_SECONDARY_REGISTER, blue);
break;
case GAINWARD_V2_COLOR_REGISTER_TERTIARY:
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_RED_TERTIARY_REGISTER, red);
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_GREEN_TERTIARY_REGISTER, green);
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BLUE_TERTIARY_REGISTER, blue);
break;
}
}
void GainwardGPUv2Controller::SetMode(unsigned char mode, unsigned char speed, unsigned char static_mode)
{
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_MODE_REGISTER, mode);
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_STATIC_CONTROL_REGISTER, static_mode);
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_SPEED_REGISTER, speed);
}
void GainwardGPUv2Controller::SetDirection(unsigned char direction)
{
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_MODE_DIRECTION_REGISTER, direction);
}
void GainwardGPUv2Controller::SetBreathingSpeed(unsigned int speed)
{
unsigned char lower = speed & 0xFF;
unsigned char upper = (speed >> 2 * 4) & 0xFF;
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BREATHE_SPEED_REGISTER_A, lower);
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BREATHE_SPEED_SECONDARY_REGISTER_A, lower);
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BREATHE_SPEED_REGISTER_B, upper);
bus->i2c_smbus_write_byte_data(dev, GAINWARD_V2_BREATHE_SPEED_SECONDARY_REGISTER_B, upper);
}
Controllers/GainwardGPUController/GainwardGPUv2Controller/GainwardGPUv2Controller.h
+101
View File
@@ -0,0 +1,101 @@
/*---------------------------------------------------------*\
| GainwardGPUv2Controller.h |
| |
| Driver for Gainward v2 GPU |
| |
| KundaPanda 04 Jan 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"
typedef unsigned char gainward_gpu_dev_id;
/*---------------------------------------------------------------------------------*\
| Newer Gainward models seem to use addresses very similar to those used by EVGA |
\*-------------------------------------------------------------------------------**/
enum
{
/* RGB Registers */
GAINWARD_V2_RED_REGISTER = 0x6C, /* Red Register */
GAINWARD_V2_GREEN_REGISTER = 0x6D, /* Green Register */
GAINWARD_V2_BLUE_REGISTER = 0x6E, /* Blue Register */
GAINWARD_V2_RED_SECONDARY_REGISTER = 0x70, /* Red Register 2 */
GAINWARD_V2_GREEN_SECONDARY_REGISTER = 0x71, /* Green Register 2 */
GAINWARD_V2_BLUE_SECONDARY_REGISTER = 0x72, /* Blue Register 2 */
GAINWARD_V2_RED_TERTIARY_REGISTER = 0xE4, /* Red Register 3 */
GAINWARD_V2_GREEN_TERTIARY_REGISTER = 0xE5, /* Green Register 3 */
GAINWARD_V2_BLUE_TERTIARY_REGISTER = 0xE6, /* Blue Register 3 */
GAINWARD_V2_MODE_REGISTER = 0xE0, /* Mode Register */
/* Direct mode switch register
* 0x1 Software control
* 0x22 Breathing */
GAINWARD_V2_STATIC_CONTROL_REGISTER = 0x60,
GAINWARD_V2_BREATHE_SPEED_REGISTER_A = 0x62, /* Lower part of speed control for breathe effect */
GAINWARD_V2_BREATHE_SPEED_REGISTER_B = 0x63, /* Upper part of speed control for breathe effect */
GAINWARD_V2_BREATHE_SPEED_SECONDARY_REGISTER_A = 0x64, /* Lower part of speed control for breathe effect - prob. secondary color */
GAINWARD_V2_BREATHE_SPEED_SECONDARY_REGISTER_B = 0x65, /* Upper part of speed control for breathe effect - prob. secondary color */
/* Mode direction Register
* 0x0
* 0x1 */
GAINWARD_V2_MODE_DIRECTION_REGISTER = 0xE1,
/* Mode speed Register
* 0x0 MAX
* 0xF MIN */
GAINWARD_V2_SPEED_REGISTER = 0xE2,
};
enum
{
/* Manual color selection using primary registers */
GAINWARD_V2_MODE_STATIC = 0x00,
/* Rainbow cycling with direction and speed controls */
GAINWARD_V2_MODE_CYCLE = 0x01,
/* One strobing color running around the fan
* Color using primary registers, direction and speed control */
GAINWARD_V2_MODE_STROBE = 0x02,
};
enum
{
GAINWARD_V2_COLOR_REGISTER_PRIMARY,
GAINWARD_V2_COLOR_REGISTER_SECONDARY,
GAINWARD_V2_COLOR_REGISTER_TERTIARY,
};
enum
{
/* Software controlled direct mode */
GAINWARD_V2_STATIC_SOFTWARE = 0x01,
/* GPU controlled direct mode with breathing effect */
GAINWARD_V2_STATIC_BREATHING = 0x22,
};
class GainwardGPUv2Controller
{
public:
GainwardGPUv2Controller(i2c_smbus_interface* bus, gainward_gpu_dev_id, std::string dev_name);
~GainwardGPUv2Controller();
std::string GetDeviceLocation();
std::string GetDeviceName();
unsigned char GetLEDRed();
unsigned char GetLEDGreen();
unsigned char GetLEDBlue();
void SetLEDColors(unsigned char red, unsigned char green, unsigned char blue, unsigned char color_register = GAINWARD_V2_COLOR_REGISTER_PRIMARY);
void SetMode(unsigned char mode, unsigned char speed, unsigned char direct_mode = GAINWARD_V2_STATIC_SOFTWARE);
void SetBreathingSpeed(unsigned int speed);
void SetDirection(unsigned char direction);
private:
i2c_smbus_interface * bus;
gainward_gpu_dev_id dev;
std::string name;
};
Controllers/GainwardGPUController/GainwardGPUv2Controller/RGBController_GainwardGPUv2.cpp
+193
View File
@@ -0,0 +1,193 @@
/*---------------------------------------------------------*\
| RGBController_GainwardGPUv2.cpp |
| |
| RGBController for Gainward v2 GPU |
| |
| KundaPanda 04 Jan 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_GainwardGPUv2.h"
/**------------------------------------------------------------------*\
@name Gainward GPU v2
@category GPU
@type I2C
@save :x:
@direct :x:
@effects :white_check_mark:
@detectors DetectGainwardGPUControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_GainwardGPUv2::RGBController_GainwardGPUv2(GainwardGPUv2Controller* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "Gainward";
type = DEVICE_TYPE_GPU;
description = "Gainward GPU V2 Device";
location = controller->GetDeviceLocation();
mode Static;
Static.name = "Static";
Static.value = GAINWARD_V2_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Breathe;
Breathe.name = "Breathing";
Breathe.value = GAINWARD_V2_MODE_STATIC;
Breathe.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
Breathe.speed_max = 0x000a;
Breathe.speed_min = 0x1324;
Breathe.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathe.colors_min = 2;
Breathe.colors_max = 2;
Breathe.colors.resize(2);
modes.push_back(Breathe);
mode RainbowWave;
RainbowWave.name = "Rainbow Wave";
RainbowWave.value = GAINWARD_V2_MODE_CYCLE;
RainbowWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
RainbowWave.speed_max = 0x0;
RainbowWave.speed_min = 0xF;
RainbowWave.color_mode = MODE_COLORS_NONE;
modes.push_back(RainbowWave);
mode Strobe;
Strobe.name = "Strobe";
Strobe.value = GAINWARD_V2_MODE_STROBE;
Strobe.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Strobe.color_mode = MODE_COLORS_MODE_SPECIFIC;
Strobe.colors_min = 1;
Strobe.colors_max = 1;
Strobe.colors.resize(1);
Strobe.speed_max = 0x0;
Strobe.speed_min = 0xF;
modes.push_back(Strobe);
SetupZones();
/*-------------------------*\
| Initialize active mode |
\*-------------------------*/
active_mode = 0;
}
RGBController_GainwardGPUv2::~RGBController_GainwardGPUv2()
{
delete controller;
}
void RGBController_GainwardGPUv2::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zone |
\*---------------------------------------------------------*/
zone gainward_gpu_zone;
gainward_gpu_zone.name = "GPU";
gainward_gpu_zone.type = ZONE_TYPE_SINGLE;
gainward_gpu_zone.leds_min = 1;
gainward_gpu_zone.leds_max = 1;
gainward_gpu_zone.leds_count = 1;
gainward_gpu_zone.matrix_map = NULL;
zones.push_back(gainward_gpu_zone);
/*---------------------------------------------------------*\
| Set up LED |
\*---------------------------------------------------------*/
led gainward_gpu_led;
gainward_gpu_led.name = "GPU";
leds.push_back(gainward_gpu_led);
SetupColors();
/*---------------------------------------------------------*\
| Initialize color |
\*---------------------------------------------------------*/
unsigned char red = controller->GetLEDRed();
unsigned char grn = controller->GetLEDGreen();
unsigned char blu = controller->GetLEDBlue();
colors[0] = ToRGBColor(red, grn, blu);
}
void RGBController_GainwardGPUv2::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_GainwardGPUv2::DeviceUpdateLEDs()
{
for(unsigned int color : colors)
{
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
controller->SetLEDColors(red, grn, blu);
controller->SetMode(GAINWARD_V2_MODE_STATIC, 0x2);
}
}
void RGBController_GainwardGPUv2::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_GainwardGPUv2::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_GainwardGPUv2::DeviceUpdateMode()
{
mode current_mode = modes[(unsigned int)active_mode];
switch (active_mode)
{
case 1:
{
controller->SetBreathingSpeed(current_mode.speed);
unsigned char r1 = RGBGetRValue(current_mode.colors[0]);
unsigned char g1 = RGBGetGValue(current_mode.colors[0]);
unsigned char b1 = RGBGetBValue(current_mode.colors[0]);
controller->SetLEDColors(r1, g1, b1);
unsigned char r2 = RGBGetRValue(current_mode.colors[1]);
unsigned char g2 = RGBGetGValue(current_mode.colors[1]);
unsigned char b2 = RGBGetBValue(current_mode.colors[1]);
controller->SetLEDColors(r2, g2, b2, GAINWARD_V2_COLOR_REGISTER_SECONDARY);
controller->SetMode(GAINWARD_V2_MODE_STATIC, 0x2, GAINWARD_V2_STATIC_BREATHING);
}
break;
/*---------------------------------------------*\
| Case 3 intentionally falls through to case 2 |
\*---------------------------------------------*/
case 3:
{
unsigned char r = RGBGetRValue(current_mode.colors[0]);
unsigned char g = RGBGetGValue(current_mode.colors[0]);
unsigned char b = RGBGetBValue(current_mode.colors[0]);
controller->SetLEDColors(r, g, b, GAINWARD_V2_COLOR_REGISTER_TERTIARY);
}
case 2:
controller->SetMode((unsigned char)(current_mode.value), (unsigned char)(current_mode.speed));
controller->SetDirection(current_mode.direction);
break;
default:
controller->SetMode((unsigned char)(current_mode.value), (unsigned char)(current_mode.speed));
break;
}
}
Controllers/GainwardGPUController/GainwardGPUv2Controller/RGBController_GainwardGPUv2.h
+35
View File
@@ -0,0 +1,35 @@
/*---------------------------------------------------------*\
| RGBController_GainwardGPUv2.h |
| |
| RGBController for Gainward v2 GPU |
| |
| KundaPanda 04 Jan 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "GainwardGPUv2Controller.h"
class RGBController_GainwardGPUv2 : public RGBController
{
public:
RGBController_GainwardGPUv2(GainwardGPUv2Controller* controller_ptr);
~RGBController_GainwardGPUv2();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
GainwardGPUv2Controller* controller;
};