From 81b48adcf59303e0eb3a65e9cbb5a7690eda705a Mon Sep 17 00:00:00 2001 From: 1000001101000 <9817632-1000001101000@users.noreply.gitlab.com> Date: Wed, 24 Nov 2021 04:15:10 +0000 Subject: [PATCH] Gigabyte RGB Fusion 2 GPU controller Commit amended for code style and to rename Static to Direct mode by Adam Honse --- .../GigabyteRGBFusion2GPUController.cpp | 147 ++++++++++ .../GigabyteRGBFusion2GPUController.h | 83 ++++++ .../GigabyteRGBFusion2GPUControllerDetect.cpp | 111 ++++++++ .../RGBController_GigabyteRGBFusion2GPU.cpp | 259 ++++++++++++++++++ .../RGBController_GigabyteRGBFusion2GPU.h | 39 +++ OpenRGB.pro | 9 + pci_ids/pci_ids.h | 5 + 7 files changed, 653 insertions(+) create mode 100644 Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.cpp create mode 100644 Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.h create mode 100644 Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp create mode 100644 Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.cpp create mode 100644 Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.h diff --git a/Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.cpp b/Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.cpp new file mode 100644 index 00000000..742d09d2 --- /dev/null +++ b/Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.cpp @@ -0,0 +1,147 @@ +/*-----------------------------------------*\ +| GigabyteRGBFusion2GPUController.cpp | +| | +| Driver for Gigabyte Aorus RGB Fusion2 GPU| +| lighting controller | +| | +| based on original by | +| Adam Honse (CalcProgrammer1) | +\*-----------------------------------------*/ + +#include +#include +#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; + } +} diff --git a/Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.h b/Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.h new file mode 100644 index 00000000..8a2ee9dc --- /dev/null +++ b/Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUController.h @@ -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 +#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; + +}; diff --git a/Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp b/Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp new file mode 100644 index 00000000..5b7b1689 --- /dev/null +++ b/Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp @@ -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 +#include +#include + +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& 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); diff --git a/Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.cpp b/Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.cpp new file mode 100644 index 00000000..dc99d84e --- /dev/null +++ b/Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.cpp @@ -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(); +} diff --git a/Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.h b/Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.h new file mode 100644 index 00000000..6308c48e --- /dev/null +++ b/Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.h @@ -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 zoneIndexMap; +}; diff --git a/OpenRGB.pro b/OpenRGB.pro index 01964e63..c4053b03 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -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 \ diff --git a/pci_ids/pci_ids.h b/pci_ids/pci_ids.h index 72605176..f542a32a 100644 --- a/pci_ids/pci_ids.h +++ b/pci_ids/pci_ids.h @@ -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 |