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

Gigabyte RGB Fusion 2 GPU controller

Browse source 
Commit amended for code style and to rename Static to Direct mode by Adam Honse <calcprogrammer1@gmail.com>
This commit is contained in:
1000001101000 2021-11-24 04:15:10 +00:00 • committed by Adam Honse
parent e36b52136c
commit 81b48adcf5
7 changed files with 653 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

147
Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.cpp Normal file
View file

@ -0,0 +1,147 @@
/*-----------------------------------------*\
| GigabyteRGBFusion2GPUController.cpp |
| |
| Driver for Gigabyte Aorus RGB Fusion2 GPU|
| lighting controller |
| |
| based on original by |
| Adam Honse (CalcProgrammer1) |
\*-----------------------------------------*/
#include <chrono>
#include <thread>
#include "GigabyteRGBFusion2GPUController.h"
#include "LogManager.h"
using namespace std::chrono_literals;
RGBFusion2GPUController::RGBFusion2GPUController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev)
{
this->bus = bus;
this->dev = dev;
}
RGBFusion2GPUController::~RGBFusion2GPUController()
{
}
std::string RGBFusion2GPUController::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);
}
void RGBFusion2GPUController::SaveConfig()
{
uint8_t data_pkt[8] = { 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
bus->i2c_write_block(dev, sizeof(data_pkt), data_pkt);
}
void RGBFusion2GPUController::SetMode(uint8_t zone, uint8_t mode, fusion2_config zone_config, uint8_t mystery_flag)
{
uint8_t zone_pkt[8] = { RGB_FUSION2_GPU_REG_MODE, mode, zone_config.speed, zone_config.brightness, mystery_flag, (zone + 1), 0x00, 0x00 };
bus->i2c_write_block(dev, sizeof(zone_pkt), zone_pkt);
uint8_t zone_pkt2[8] = { RGB_FUSION2_GPU_REG_COLOR, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]), (zone + 1), 0x00, 0x00, 0x00 };
bus->i2c_write_block(dev, sizeof(zone_pkt2), zone_pkt2);
}
void RGBFusion2GPUController::SetZone(uint8_t zone, uint8_t mode, fusion2_config zone_config)
{
std::string mode_name;
uint8_t mystery_flag = 0x00;
switch(mode)
{
case RGB_FUSION2_GPU_MODE_STATIC:
{
SetMode(zone, mode, zone_config, mystery_flag);
}
break;
case RGB_FUSION2_GPU_MODE_BREATHING:
{
SetMode(zone, mode, zone_config, mystery_flag);
}
break;
case RGB_FUSION2_GPU_MODE_COLOR_CYCLE:
{
uint8_t zone_pkt[8] = { RGB_FUSION2_GPU_REG_MODE, mode, zone_config.speed, zone_config.brightness, mystery_flag, (zone + 1), 0x00, 0x00 };
bus->i2c_write_block(dev, sizeof(zone_pkt), zone_pkt);
}
break;
case RGB_FUSION2_GPU_MODE_GRADIENT:
{
mystery_flag = 0x08;
SetMode(zone, mode, zone_config, mystery_flag);
}
break;
case RGB_FUSION2_GPU_MODE_FLASHING:
{
SetMode(zone, mode, zone_config, mystery_flag);
}
break;
case RGB_FUSION2_GPU_MODE_DUAL_FLASHING:
{
SetMode(zone, mode, zone_config, mystery_flag);
}
break;
case RGB_FUSION2_GPU_MODE_WAVE:
{
SetMode(zone, mode, zone_config, mystery_flag);
}
break;
case RGB_FUSION2_GPU_MODE_COLOR_SHIFT:
{
mystery_flag = zone_config.numberOfColors;
uint8_t zone_pkt[8] = { RGB_FUSION2_GPU_REG_MODE, mode, zone_config.speed, zone_config.brightness, mystery_flag, (zone + 1), 0x00, 0x00 };
bus->i2c_write_block(dev, sizeof(zone_pkt), zone_pkt);
uint8_t bank = (0xB0 + (zone * 4));
uint8_t zone_pktA[8] = { bank, mode, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]), RGBGetRValue(zone_config.colors[1]), RGBGetGValue(zone_config.colors[1]), RGBGetBValue(zone_config.colors[1]) };
bus->i2c_write_block(dev, sizeof(zone_pktA), zone_pktA);
uint8_t zone_pktB[8] = { (bank + 1), mode, RGBGetRValue(zone_config.colors[2]), RGBGetGValue(zone_config.colors[2]), RGBGetBValue(zone_config.colors[2]), RGBGetRValue(zone_config.colors[3]), RGBGetGValue(zone_config.colors[3]), RGBGetBValue(zone_config.colors[3]) };
bus->i2c_write_block(dev, sizeof(zone_pktB), zone_pktB);
uint8_t zone_pktC[8] = { (bank + 2), mode, RGBGetRValue(zone_config.colors[4]), RGBGetGValue(zone_config.colors[4]), RGBGetBValue(zone_config.colors[4]), RGBGetRValue(zone_config.colors[5]), RGBGetGValue(zone_config.colors[5]), RGBGetBValue(zone_config.colors[5]) };
bus->i2c_write_block(dev, sizeof(zone_pktC), zone_pktC);
uint8_t zone_pktD[8] = { (bank + 3), mode, RGBGetRValue(zone_config.colors[6]), RGBGetGValue(zone_config.colors[6]), RGBGetBValue(zone_config.colors[6]), RGBGetRValue(zone_config.colors[7]), RGBGetGValue(zone_config.colors[7]), RGBGetBValue(zone_config.colors[7]) };
bus->i2c_write_block(dev, sizeof(zone_pktD), zone_pktD);
}
break;
case RGB_FUSION2_GPU_MODE_TRICOLOR:
{
mystery_flag = 0x08;
uint8_t zone_pkt[8] = { RGB_FUSION2_GPU_REG_MODE, mode, zone_config.speed, zone_config.brightness, mystery_flag, (zone + 1), 0x00, 0x00 };
bus->i2c_write_block(dev, sizeof(zone_pkt), zone_pkt);
uint8_t bank = (0xB0 + (zone * 4));
uint8_t zone_pktA[8] = { bank, mode, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]), RGBGetRValue(zone_config.colors[1]), RGBGetGValue(zone_config.colors[1]), RGBGetBValue(zone_config.colors[1]) };
bus->i2c_write_block(dev, sizeof(zone_pktA), zone_pktA);
uint8_t zone_pktB[8] = { (bank + 1), mode, RGBGetRValue(zone_config.colors[2]), RGBGetGValue(zone_config.colors[2]), RGBGetBValue(zone_config.colors[2]), RGBGetRValue(zone_config.colors[3]), RGBGetGValue(zone_config.colors[3]), RGBGetBValue(zone_config.colors[3]) };
bus->i2c_write_block(dev, sizeof(zone_pktB), zone_pktB);
uint8_t zone_pktC[8] = { (bank + 2), mode, RGBGetRValue(zone_config.colors[4]), RGBGetGValue(zone_config.colors[4]), RGBGetBValue(zone_config.colors[4]), RGBGetRValue(zone_config.colors[5]), RGBGetGValue(zone_config.colors[5]), RGBGetBValue(zone_config.colors[5]) };
bus->i2c_write_block(dev, sizeof(zone_pktC), zone_pktC);
uint8_t zone_pktD[8] = { (bank + 3), mode, RGBGetRValue(zone_config.colors[6]), RGBGetGValue(zone_config.colors[6]), RGBGetBValue(zone_config.colors[6]), RGBGetRValue(zone_config.colors[7]), RGBGetGValue(zone_config.colors[7]), RGBGetBValue(zone_config.colors[7]) };
bus->i2c_write_block(dev, sizeof(zone_pktD), zone_pktD);
}
break;
default:
{
LOG_TRACE("[%s] Mode %02d not found", "fusion2 gpu", mode);
}
break;
}
}

83
Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.h Normal file
View file

@ -0,0 +1,83 @@
/*------------------------------------------*\
| GigabyteRGBFusion2GPUController.h |
| |
| Definitions and types for Gigabyte Aorus |
| RGB Fusion2 GPU lighting controller |
| |
| based on original by |
| Adam Honse (CalcProgrammer1) 2/20/2020 |
\*------------------------------------------*/
#include <string>
#include "i2c_smbus.h"
#include "RGBController.h"
#pragma once
typedef unsigned char rgb_fusion_dev_id;
struct fusion2_config
{
uint8_t brightness;
RGBColor colors[8];
uint8_t numberOfColors;
uint8_t speed;
uint8_t direction;
};
enum
{
RGB_FUSION2_GPU_REG_COLOR = 0x40,
RGB_FUSION2_GPU_REG_MODE = 0x88
};
enum
{
RGB_FUSION2_GPU_MODE_STATIC = 0x01,
RGB_FUSION2_GPU_MODE_BREATHING = 0x02,
RGB_FUSION2_GPU_MODE_COLOR_CYCLE = 0x03,
RGB_FUSION2_GPU_MODE_FLASHING = 0x04,
RGB_FUSION2_GPU_MODE_GRADIENT = 0x05,
RGB_FUSION2_GPU_MODE_COLOR_SHIFT = 0x06,
RGB_FUSION2_GPU_MODE_WAVE = 0x07,
RGB_FUSION2_GPU_MODE_DUAL_FLASHING = 0x08,
RGB_FUSION2_GPU_MODE_TRICOLOR = 0x0B
};
enum
{
RGB_FUSION2_GPU_SPEED_SLOWEST = 0x00,
RGB_FUSION2_GPU_SPEED_NORMAL = 0x02,
RGB_FUSION2_GPU_SPEED_FASTEST = 0x05
};
enum
{
RGB_FUSION2_GPU_BRIGHTNESS_MIN = 0x00,
RGB_FUSION2_GPU_BRIGHTNESS_MAX = 0x63
};
class RGBFusion2GPUController
{
public:
RGBFusion2GPUController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev);
~RGBFusion2GPUController();
uint8_t zone_led_count[4];
uint8_t zone_modes[4];
std::string GetDeviceLocation();
void GetDeviceModes();
uint8_t GetZoneMode(uint8_t zone);
fusion2_config GetZoneConfig(uint8_t zone, uint8_t mode);
void SaveConfig();
void SetZone(uint8_t zone, uint8_t mode, fusion2_config zone_config);
void SetMode(uint8_t zone, uint8_t mode, fusion2_config zone_config, uint8_t mystery_flag);
private:
i2c_smbus_interface* bus;
rgb_fusion_dev_id dev;
};

111
Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp Normal file
View file

@ -0,0 +1,111 @@
#include "Detector.h"
#include "GigabyteRGBFusion2GPUController.h"
#include "LogManager.h"
#include "RGBController.h"
#include "RGBController_GigabyteRGBFusion2GPU.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;
unsigned char controller_address;
const char * name;
} gpu_pci_device;
#define GIGABYTEGPU_CONTROLLER_NAME2 "Gigabyte RGB Fusion2 GPU"
#define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
static const gpu_pci_device device_list[] =
{
{ NVIDIA_VEN, NVIDIA_RTX3060TI_DEV, GIGABYTE_SUB_VEN, GIGABYTE_RTX3060TI_GAMING_OC_PRO_SUB_DEV, 0x62, "GeForce RTX 3060 Ti GAMING OC PRO 8G" },
{ NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV, GIGABYTE_SUB_VEN, GIGABYTE_RTX3060_ELITE_12GB_SUB_DEV, 0x70, "GeForce RTX 3060 AORUS ELITE 12G" },
{ NVIDIA_VEN, NVIDIA_RTX3070_DEV, GIGABYTE_SUB_VEN, GIGABYTE_RTX3070_MASTER_OC_SUB_DEV, 0x66, "GeForce RTX 3070 AORUS MASTER 8G" },
{ NVIDIA_VEN, NVIDIA_RTX2070S_DEV, GIGABYTE_SUB_VEN, GIGABYTE_RTX2070S_GAMING_OC_SUB_DEV2, 0x50, "GeForce RTX 2070 AORUS SUPER 8G" },
{ NVIDIA_VEN, NVIDIA_RTX3080_LHR_DEV, GIGABYTE_SUB_VEN, GIGABYTE_RTX3080_XTREME_WATERFORCE_SUB_DEV, 0x64, "GeForce RTX 3080 AORUS XTREME WATERFORCE WB 10G"},
{ NVIDIA_VEN, NVIDIA_RTX3090_DEV, GIGABYTE_SUB_VEN, GIGABYTE_RTX3090_XTREME_WATERFORCE_SUB_DEV, 0x64, "GeForce RTX 3090 AORUS XTREME WATERFORCE WB 24G"},
};
/******************************************************************************************\
* *
* TestForGigabyteRGBFusion2GPUController *
* *
* Tests the given address to see if an RGB Fusion2 controller exists there. First *
* does a quick write to test for a response *
* *
\******************************************************************************************/
bool TestForGigabyteRGBFusion2GPUController(i2c_smbus_interface* bus, unsigned char address)
{
bool pass = false;
int res, pktsz;
const int read_sz = 4;
const int write_sz = 8;
uint8_t data_pkt[write_sz] = { 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint8_t data_readpkt[read_sz] = {};
res = bus->i2c_write_block(address, write_sz, data_pkt);
pass = true;
pktsz = read_sz;
res = bus->i2c_read_block(address, &pktsz, data_readpkt);
//What we have seen returned so far...
//GeForce RTX 3070 AORUS MASTER 8G 0xAB 0x11 0x52 0x03
//GeForce RTX 3060 Ti GAMING OC PRO 8G 0xAB 0x10 0x01 0x02
//GeForce RTX 3070 AORUS ELITE 12G 0xAB 0x11 0x52 0x03
//GeForce RTX 3080 AORUS XTREME WATERFORCE WB 10G 0xAB 0x10 0x01 0x00
if(res < 0)
{
LOG_DEBUG("[%s] at 0x%02X address expected 0x04 but recieved: 0x%02X", GIGABYTEGPU_CONTROLLER_NAME2, address, res);
pass = false;
}
return(pass);
} /* TestForRGBFusion2GPUController() */
/*******************************************************************************************\
* *
* DetectRGBFusion2GPUControllers *
* *
* Detect GigabyteRGB Fusion2 controllers on the enumerated I2C busses at address 0x70.*
* *
* bus - pointer to i2c_smbus_interface where RGB Fusion2 device is connected *
* dev - I2C address of RGB Fusion2 device *
* *
\*******************************************************************************************/
void DetectGigabyteRGBFusion2GPUControllers(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]->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)
{
// Check for RGB Fusion2 controller
if(TestForGigabyteRGBFusion2GPUController(busses[bus], device_list[dev_idx].controller_address))
{
RGBFusion2GPUController* controller = new RGBFusion2GPUController(busses[bus], device_list[dev_idx].controller_address);
RGBController_RGBFusion2GPU* rgb_controller = new RGBController_RGBFusion2GPU(controller);
rgb_controller->name = device_list[dev_idx].name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
}
}
} /* DetectGigabyteRGBFusion2GPUControllers() */
REGISTER_I2C_DETECTOR("Gigabyte RGB Fusion2 GPU", DetectGigabyteRGBFusion2GPUControllers);

259
Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.cpp Normal file
View file

@ -0,0 +1,259 @@
/*-----------------------------------------*\
| RGBController_GigabyteRGBFusion2GPU.cpp |
| |
| Generic RGB Interface for OpenRGB |
| Gigabyte RGB Fusion2 GPU Driver |
| |
| based on original by |
| Adam Honse (CalcProgrammer1) |
\*-----------------------------------------*/
#include "RGBController_GigabyteRGBFusion2GPU.h"
static const char* gigabyte_fusion2_gpu_zone[] =
{
"gpu zone 1",
"gpu zone 2",
"gpu zone 3",
"gpu zone 4"
};
RGBController_RGBFusion2GPU::RGBController_RGBFusion2GPU(RGBFusion2GPUController* controller_ptr)
{
controller = controller_ptr;
name = "Gigabyte GPU";
vendor = "Gigabyte";
description = "Gigabyte RGB Fusion 2 GPU";
location = controller->GetDeviceLocation();
type = DEVICE_TYPE_GPU;
mode Direct;
Direct.name = "Direct";
Direct.value = RGB_FUSION2_GPU_MODE_STATIC;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Direct.color_mode = MODE_COLORS_PER_LED;
Direct.brightness_min = RGB_FUSION2_GPU_BRIGHTNESS_MIN;
Direct.brightness_max = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
Direct.brightness = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
modes.push_back(Direct);
mode Breathing;
Breathing.name = "Pulse";
Breathing.value = RGB_FUSION2_GPU_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
Breathing.speed_min = RGB_FUSION2_GPU_SPEED_SLOWEST;
Breathing.speed_max = RGB_FUSION2_GPU_SPEED_FASTEST;
Breathing.speed = RGB_FUSION2_GPU_SPEED_NORMAL;
Breathing.color_mode = MODE_COLORS_PER_LED;
Breathing.brightness_min = RGB_FUSION2_GPU_BRIGHTNESS_MIN;
Breathing.brightness_max = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
Breathing.brightness = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
modes.push_back(Breathing);
mode Flashing;
Flashing.name = "Flash";
Flashing.value = RGB_FUSION2_GPU_MODE_FLASHING;
Flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Flashing.speed_min = RGB_FUSION2_GPU_SPEED_SLOWEST;
Flashing.speed_max = RGB_FUSION2_GPU_SPEED_FASTEST;
Flashing.speed = RGB_FUSION2_GPU_SPEED_NORMAL;
Flashing.color_mode = MODE_COLORS_PER_LED;
Flashing.brightness_min = RGB_FUSION2_GPU_BRIGHTNESS_MIN;
Flashing.brightness_max = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
Flashing.brightness = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
modes.push_back(Flashing);
mode DualFlashing;
DualFlashing.name = "Double Flash";
DualFlashing.value = RGB_FUSION2_GPU_MODE_DUAL_FLASHING;
DualFlashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
DualFlashing.speed_min = RGB_FUSION2_GPU_SPEED_SLOWEST;
DualFlashing.speed_max = RGB_FUSION2_GPU_SPEED_FASTEST;
DualFlashing.speed = RGB_FUSION2_GPU_SPEED_NORMAL;
DualFlashing.color_mode = MODE_COLORS_PER_LED;
DualFlashing.brightness_min = RGB_FUSION2_GPU_BRIGHTNESS_MIN;
DualFlashing.brightness_max = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
DualFlashing.brightness = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
modes.push_back(DualFlashing);
mode SpectrumCycle;
SpectrumCycle.name = "Color Cycle";
SpectrumCycle.value = RGB_FUSION2_GPU_MODE_COLOR_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;;
SpectrumCycle.speed_min = RGB_FUSION2_GPU_SPEED_SLOWEST;
SpectrumCycle.speed_max = RGB_FUSION2_GPU_SPEED_FASTEST;
SpectrumCycle.speed = RGB_FUSION2_GPU_SPEED_NORMAL;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
SpectrumCycle.brightness_min = RGB_FUSION2_GPU_BRIGHTNESS_MIN;
SpectrumCycle.brightness_max = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
SpectrumCycle.brightness = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
modes.push_back(SpectrumCycle);
mode Gradient;
Gradient.name = "Gradient";
Gradient.value = RGB_FUSION2_GPU_MODE_GRADIENT;
Gradient.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Gradient.speed_min = RGB_FUSION2_GPU_SPEED_SLOWEST;
Gradient.speed_max = RGB_FUSION2_GPU_SPEED_FASTEST;
Gradient.speed = RGB_FUSION2_GPU_SPEED_NORMAL;
Gradient.color_mode = MODE_COLORS_PER_LED;
Gradient.brightness_min = RGB_FUSION2_GPU_BRIGHTNESS_MIN;
Gradient.brightness_max = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
Gradient.brightness = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
modes.push_back(Gradient);
mode Wave;
Wave.name = "Wave";
Wave.value = RGB_FUSION2_GPU_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Wave.speed_min = RGB_FUSION2_GPU_SPEED_SLOWEST;
Wave.speed_max = RGB_FUSION2_GPU_SPEED_FASTEST;
Wave.speed = RGB_FUSION2_GPU_SPEED_NORMAL;
Wave.color_mode = MODE_COLORS_NONE;
Wave.brightness_min = RGB_FUSION2_GPU_BRIGHTNESS_MIN;
Wave.brightness_max = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
Wave.brightness = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
modes.push_back(Wave);
mode Shift;
Shift.name = "Color Shift";
Shift.value = RGB_FUSION2_GPU_MODE_COLOR_SHIFT;
Shift.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Shift.speed_min = RGB_FUSION2_GPU_SPEED_SLOWEST;
Shift.speed_max = RGB_FUSION2_GPU_SPEED_FASTEST;
Shift.speed = RGB_FUSION2_GPU_SPEED_NORMAL;
Shift.color_mode = MODE_COLORS_MODE_SPECIFIC;
Shift.colors_min = 1;
Shift.colors_max = 8;
Shift.colors.resize(8);
Shift.brightness_min = RGB_FUSION2_GPU_BRIGHTNESS_MIN;
Shift.brightness_max = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
Shift.brightness = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
modes.push_back(Shift);
mode Tricolor;
Tricolor.name = "Tricolor";
Tricolor.value = RGB_FUSION2_GPU_MODE_TRICOLOR;
Tricolor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Tricolor.speed_min = RGB_FUSION2_GPU_SPEED_SLOWEST;
Tricolor.speed_max = RGB_FUSION2_GPU_SPEED_FASTEST;
Tricolor.speed = RGB_FUSION2_GPU_SPEED_NORMAL;
Tricolor.color_mode = MODE_COLORS_MODE_SPECIFIC;
Tricolor.colors.resize(3);
Tricolor.brightness_min = RGB_FUSION2_GPU_BRIGHTNESS_MIN;
Tricolor.brightness_max = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
Tricolor.brightness = RGB_FUSION2_GPU_BRIGHTNESS_MAX;
modes.push_back(Tricolor);
SetupZones();
}
RGBController_RGBFusion2GPU::~RGBController_RGBFusion2GPU()
{
delete controller;
}
uint8_t RGBController_RGBFusion2GPU::getModeIndex(uint8_t mode_value)
{
for (uint8_t mode_index = 0; mode_index < modes.size(); mode_index++)
{
if (modes[mode_index].value == mode_value)
{
return mode_index;
}
}
return 0;
}
void RGBController_RGBFusion2GPU::SetupZones()
{
/*---------------------------------------------------------*\
| This device only allows setting the entire zone for all |
| LED's in the zone and does not allow per LED control. |
\*---------------------------------------------------------*/
//controller->GetDeviceModes();
for(uint8_t zone_idx = 0; zone_idx < 4; zone_idx++)
{
if(controller->zone_led_count[zone_idx] > 0)
{
zone* new_zone = new zone();
led* new_led = new led();
new_zone->name = gigabyte_fusion2_gpu_zone[zone_idx];
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 = gigabyte_fusion2_gpu_zone[zone_idx];
/*---------------------------------------------------------*\
| Push the zone and LED on to device vectors |
\*---------------------------------------------------------*/
leds.push_back(*new_led);
zones.push_back(*new_zone);
zoneIndexMap.push_back(zone_idx);
}
}
SetupColors();
}
void RGBController_RGBFusion2GPU::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_RGBFusion2GPU::DeviceUpdateLEDs()
{
fusion2_config zone_config;
zone_config.brightness = modes[active_mode].brightness;
zone_config.speed = modes[active_mode].speed;
zone_config.direction = modes[active_mode].direction;
zone_config.numberOfColors = (uint8_t)modes[active_mode].colors.size();
for (uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
{
zone_config.colors[0] = colors[zone_idx];
if (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
{
for (uint8_t i = 0; i < zone_config.numberOfColors; i++)
{
zone_config.colors[i] = modes[active_mode].colors[i];
}
}
controller->SetZone(zoneIndexMap[zone_idx], modes[active_mode].value, zone_config);
}
}
void RGBController_RGBFusion2GPU::UpdateZoneLEDs(int zone)
{
DeviceUpdateLEDs();
}
void RGBController_RGBFusion2GPU::UpdateSingleLED(int led)
{
DeviceUpdateLEDs();
}
void RGBController_RGBFusion2GPU::SetCustomMode()
{
active_mode = 0;
}
void RGBController_RGBFusion2GPU::DeviceUpdateMode()
{
DeviceUpdateLEDs();
}
void RGBController_RGBFusion2GPU::DeviceSaveMode()
{
controller->SaveConfig();
}

39
Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.h Normal file
View file

@ -0,0 +1,39 @@
/*-----------------------------------------*\
| RGBController_GigabyteRGBFusion2GPU.h |
| |
| Generic RGB Interface for OpenRGB |
| Gigabyte RGB Fusion2 GPU Driver |
| |
| based on original by |
| Adam Honse (CalcProgrammer1) 2/23/2020 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "GigabyteRGBFusion2GPUController.h"
class RGBController_RGBFusion2GPU : public RGBController
{
public:
RGBController_RGBFusion2GPU(RGBFusion2GPUController* controller_ptr);
~RGBController_RGBFusion2GPU();
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:
uint8_t getModeIndex(uint8_t mode_value);
RGBFusion2GPUController* controller;
std::vector<uint8_t> zoneIndexMap;
};

9
OpenRGB.pro
View file

@ -110,6 +110,7 @@ INCLUDEPATH +=
Controllers/GigabyteRGBFusion2USBController/ \
Controllers/GigabyteRGBFusionController/ \
Controllers/GigabyteRGBFusionGPUController/ \
Controllers/GigabyteRGBFusion2GPUController/ \
Controllers/HoltekController/ \
Controllers/HPOmen30LController/ \
Controllers/HyperXDRAMController/ \
@ -322,6 +323,8 @@ HEADERS +=
Controllers/GigabyteRGBFusionController/RGBController_GigabyteRGBFusion.h \
Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUController.h \
Controllers/GigabyteRGBFusionGPUController/RGBController_GigabyteRGBFusionGPU.h \
Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.h \
Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.h \
Controllers/HoltekController/HoltekA070Controller.h \
Controllers/HoltekController/HoltekA1FAController.h \
Controllers/HoltekController/RGBController_HoltekA070.h \
@ -710,6 +713,9 @@ SOURCES +=
Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUController.cpp \
Controllers/GigabyteRGBFusionGPUController/GigabyteRGBFusionGPUControllerDetect.cpp \
Controllers/GigabyteRGBFusionGPUController/RGBController_GigabyteRGBFusionGPU.cpp \
Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.cpp \
Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp \
Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.cpp \
Controllers/HoltekController/HoltekA070Controller.cpp \
Controllers/HoltekController/HoltekA1FAController.cpp \
Controllers/HoltekController/HoltekControllerDetect.cpp \
@ -1241,6 +1247,9 @@ macx {
DEFINES += \
USE_HID_USAGE \
QMAKE_CXXFLAGS += \
-Wno-narrowing \
HEADERS += \
AutoStart/AutoStart-MacOS.h \

5
pci_ids/pci_ids.h
View file

@ -258,24 +258,29 @@
#define GIGABYTE_RTX2070_GAMING_OC_SUB_DEV 0x37AD
#define GIGABYTE_RTX2070_WINDFORCE_SUB_DEV 0x37C2
#define GIGABYTE_RTX2070S_GAMING_OC_SUB_DEV 0x3FEB
#define GIGABYTE_RTX2070S_GAMING_OC_SUB_DEV2 0x3FF6
#define GIGABYTE_RTX2070S_GAMING_OC_3X_SUB_DEV 0x4008
#define GIGABYTE_RTX2070S_GAMING_OC_3X_WHITE_SUB_DEV 0x400D
#define GIGABYTE_RTX2080_A_GAMING_OC_SUB_DEV 0x37A7
#define GIGABYTE_RTX2080_GAMING_OC_SUB_DEV 0x37D6
#define GIGABYTE_RTX2080S_GAMING_OC_SUB_DEV 0x3FE9
#define GIGABYTE_RTX3060_GAMING_OC_12GB_SUB_DEV 0x4074
#define GIGABYTE_RTX3060_ELITE_12GB_SUB_DEV 0x407B
#define GIGABYTE_RTX3060TI_EAGLE_OC_SUB_DEV 0x405B
#define GIGABYTE_RTX3060TI_GAMING_OC_SUB_DEV 0x405A
#define GIGABYTE_RTX3060TI_GAMING_OC_PRO_SUB_DEV 0x405E
#define GIGABYTE_RTX3070_GAMING_OC_SUB_DEV 0x404C
#define GIGABYTE_RTX3070_VISION_OC_SUB_DEV 0x404D
#define GIGABYTE_RTX3070_MASTER_OC_SUB_DEV 0x4069
#define GIGABYTE_RTX3070TI_GAMING_OC_SUB_DEV 0x408F
#define GIGABYTE_RTX3070TI_EAGLE_SUB_DEV 0x408C
#define GIGABYTE_RTX3070TI_VISION_OC_SUB_DEV 0x4090
#define GIGABYTE_RTX3080_GAMING_OC_SUB_DEV 0x403F
#define GIGABYTE_RTX3080_VISION_OC_SUB_DEV 0x404B
#define GIGABYTE_RTX3080_XTREME_WATERFORCE_SUB_DEV 0x4038
#define GIGABYTE_RTX3080TI_EAGLE_SUB_DEV 0x4085
#define GIGABYTE_RTX3090_GAMING_OC_24GB_SUB_DEV 0x4043
#define GIGABYTE_RTX3090_XTREME_WATERFORCE_SUB_DEV 0x403A
/*-----------------------------------------------------*\
| MSI Sub-Device IDs |