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/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;
};