From aead384282d87fdd9657fb9a15db6eb7509eb6ae Mon Sep 17 00:00:00 2001 From: Jan Rettig Date: Wed, 19 Feb 2020 21:17:04 -0600 Subject: [PATCH] Aura GPU Support --- .../AuraGPUController/AuraGPUController.cpp | 84 +++++++++ .../AuraGPUController/AuraGPUController.h | 64 +++++++ .../AuraGPUControllerDetect.cpp | 94 ++++++++++ OpenRGB.cpp | 11 +- OpenRGB.pro | 6 + RGBController/RGBController_AuraGPU.cpp | 176 ++++++++++++++++++ RGBController/RGBController_AuraGPU.h | 29 +++ 7 files changed, 456 insertions(+), 8 deletions(-) create mode 100644 Controllers/AuraGPUController/AuraGPUController.cpp create mode 100644 Controllers/AuraGPUController/AuraGPUController.h create mode 100644 Controllers/AuraGPUController/AuraGPUControllerDetect.cpp create mode 100644 RGBController/RGBController_AuraGPU.cpp create mode 100644 RGBController/RGBController_AuraGPU.h diff --git a/Controllers/AuraGPUController/AuraGPUController.cpp b/Controllers/AuraGPUController/AuraGPUController.cpp new file mode 100644 index 00000000..4ee33c67 --- /dev/null +++ b/Controllers/AuraGPUController/AuraGPUController.cpp @@ -0,0 +1,84 @@ +/*-----------------------------------------*\ +| AuraGPUController.cpp | +| | +| Driver for ASUS Aura RGB on GPUs | +| | +| Jan Rettig (Klapstuhl) 14.02.2020 | +\*-----------------------------------------*/ + +#include "AuraGPUController.h" +#include + +AuraGPUController::AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id dev) +{ + this->bus = bus; + this->dev = dev; + + strcpy(device_name, "ASUS Aura GPU"); // Would be nice to get the actual GPU name. Using this as a placeholder. +} + +AuraGPUController::~AuraGPUController() +{ + +} + +std::string AuraGPUController::GetDeviceName() +{ + return(device_name); +} + +std::string AuraGPUController::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(return_string); +} + +unsigned char AuraGPUController::GetLEDRed() +{ + return(AuraGPURegisterRead(AURA_GPU_REG_RED)); +} + +unsigned char AuraGPUController::GetLEDGreen() +{ + return(AuraGPURegisterRead(AURA_GPU_REG_GREEN)); +} + +unsigned char AuraGPUController::GetLEDBlue() +{ + return(AuraGPURegisterRead(AURA_GPU_REG_BLUE)); +} + +void AuraGPUController::SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue) // Direct Mode is just Static Mode without applying color changes +{ + AuraGPURegisterWrite(AURA_GPU_REG_RED, red); + AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green); + AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue); +} + +void AuraGPUController::SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue) +{ + AuraGPURegisterWrite(AURA_GPU_REG_RED, red); + AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green); + AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue); + AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL); +} + +void AuraGPUController::SetMode(unsigned char mode) +{ + AuraGPURegisterWrite(AURA_GPU_REG_MODE, mode); + AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL); +} + +unsigned char AuraGPUController::AuraGPURegisterRead(unsigned char reg) +{ + return(bus->i2c_smbus_read_byte_data(dev, reg)); +} + +void AuraGPUController::AuraGPURegisterWrite(unsigned char reg, unsigned char val) +{ + bus->i2c_smbus_write_byte_data(dev, reg, val); +} \ No newline at end of file diff --git a/Controllers/AuraGPUController/AuraGPUController.h b/Controllers/AuraGPUController/AuraGPUController.h new file mode 100644 index 00000000..9d835e6e --- /dev/null +++ b/Controllers/AuraGPUController/AuraGPUController.h @@ -0,0 +1,64 @@ +/*-----------------------------------------*\ +| AuraGPUController.h | +| | +| Definitions for ASUS Aura RGB on GPUs | +| | +| Jan Rettig (Klapstuhl) 14.02.2020 | +\*-----------------------------------------*/ + +#include +#include "i2c_smbus.h" + +#pragma once + +typedef unsigned char aura_gpu_dev_id; + +#define AURA_GPU_MAGIC_VAL 0x1589 /* This magic value is present in all Aura GPU controllers */ +#define AURA_GPU_APPLY_VAL 0x01 /* Value for Apply Changes Register */ + +enum +{ + AURA_GPU_REG_RED = 0x04, /* AURA GPU RED Register */ + AURA_GPU_REG_GREEN = 0x05, /* AURA GPU GREEN Register */ + AURA_GPU_REG_BLUE = 0x06, /* AURA GPU BLUE Register */ + AURA_GPU_REG_MODE = 0x07, /* AURA GPU Mode Selection Register */ + AURA_GPU_REG_SYNC = 0x0C, /* AURA GPU "Sync" Register */ + AURA_GPU_REG_APPLY = 0x0E, /* AURA GPU Apply Chnages Register */ +}; + +enum +{ + AURA_GPU_MODE_OFF = 0, /* OFF mode (not a real Mode! Doesn't do anything!) */ + AURA_GPU_MODE_STATIC = 1, /* Static color mode */ + AURA_GPU_MODE_BREATHING = 2, /* Breathing effect mode */ + AURA_GPU_MODE_FLASHING = 3, /* Flashing effect mode */ + AURA_GPU_MODE_SPECTRUM_CYCLE = 4, /* Spectrum Cycle mode */ + AURA_GPU_MODE_DIRECT = 5, /* Direct mode (not a real Mode! Doesn't do anything!) */ + AURA_GPU_NUMBER_MODES +}; + +class AuraGPUController +{ +public: + AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id); + ~AuraGPUController(); + + std::string GetDeviceName(); + std::string GetDeviceLocation(); + unsigned char GetLEDRed(); + unsigned char GetLEDGreen(); + unsigned char GetLEDBlue(); + void SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue); + void SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue); + void SetMode(unsigned char mode); + + unsigned char AuraGPURegisterRead(unsigned char reg); + void AuraGPURegisterWrite(unsigned char reg, unsigned char val); + + bool direct = false; // Temporary solution to check if we are in "Direct" mode + +private: + char device_name[16]; + i2c_smbus_interface * bus; + aura_gpu_dev_id dev; +}; \ No newline at end of file diff --git a/Controllers/AuraGPUController/AuraGPUControllerDetect.cpp b/Controllers/AuraGPUController/AuraGPUControllerDetect.cpp new file mode 100644 index 00000000..4512a777 --- /dev/null +++ b/Controllers/AuraGPUController/AuraGPUControllerDetect.cpp @@ -0,0 +1,94 @@ +/*-----------------------------------------*\ +| AuraGPUControllerDetect.cpp | +| | +| Driver for ASUS Aura RGB on GPUs | +| | +| Jan Rettig (Klapstuhl) 14.02.2020 | +\*-----------------------------------------*/ + +#include "AuraGPUController.h" +#include "RGBController.h" +#include "RGBController_AuraGPU.h" +#include "i2c_smbus.h" +#include +#include +#include + +#ifdef WIN32 +#include +#else +#include + +static void Sleep(unsigned int milliseconds) +{ + usleep(1000 * milliseconds); +} +#endif + +/*-------------------------------------------------------------*\ +| This list contains the available I2C addresses for Aura GPUs | +\*-------------------------------------------------------------*/ +#define AURA_GPU_ADDRESS_COUNT 3 + +static const unsigned char aura_gpu_addresses[] = +{ + 0x29, + 0x2A, + 0x60 +}; + + +/******************************************************************************************\ +* * +* TestForAuraGPUController * +* * +* Tests the given address to see if an Aura GPU controller exists there. * +* * +\******************************************************************************************/ + +bool TestForAuraGPUController(i2c_smbus_interface* bus, unsigned char address) +{ + bool pass = false; + + unsigned char aura_gpu_magic_high = bus->i2c_smbus_read_byte_data(address, 0x20); // High Byte of magic (0x15) + unsigned char aura_gpu_magic_low = bus->i2c_smbus_read_byte_data(address, 0x21); // Low Byte of magic (0x89) + + if((aura_gpu_magic_high << 8) + aura_gpu_magic_low == AURA_GPU_MAGIC_VAL) + { + pass = true; + } + + return(pass); + +} /* TestForAuraGPUController() */ + + +/******************************************************************************************\ +* * +* DetectAuraGPUControllers * +* * +* Detect Aura GPU controllers on the enumerated I2C busses. * +* * +\******************************************************************************************/ + +void DetectAuraGPUControllers(std::vector &busses, std::vector &rgb_controllers) +{ + AuraGPUController* new_aura_gpu; + RGBController_AuraGPU* new_controller; + + for (unsigned int bus = 0; bus < busses.size(); bus++) + { + // Add Aura-enabled GPU controllers + for (unsigned int address_list_idx = 0; address_list_idx < AURA_GPU_ADDRESS_COUNT; address_list_idx++) + { + if (TestForAuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx])) + { + new_aura_gpu = new AuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]); + new_controller = new RGBController_AuraGPU(new_aura_gpu); + rgb_controllers.push_back(new_controller); + } + + Sleep(1); + } + } +} /* DetectAuraGPUControllers() */ \ No newline at end of file diff --git a/OpenRGB.cpp b/OpenRGB.cpp index e7cc95f9..bfad1c4d 100644 --- a/OpenRGB.cpp +++ b/OpenRGB.cpp @@ -218,14 +218,7 @@ void DetectI2CBusses() { read(test_fd, device_string, sizeof(device_string)); close(test_fd); - - //ignore nvidia adapters for now - if(strncmp(device_string, "NVIDIA", 6) == 0) - { - ent = readdir(dir); - continue; - } - + bus = new i2c_smbus_linux(); strcpy(bus->device_name, device_string); @@ -253,6 +246,7 @@ void DetectI2CBusses() #endif /* WIN32 */ void DetectAuraControllers(std::vector &busses, std::vector &rgb_controllers); +void DetectAuraGPUControllers(std::vector &busses, std::vector &rgb_controllers); void DetectCorsairControllers(std::vector &busses, std::vector &rgb_controllers); void DetectCorsairProControllers(std::vector &busses, std::vector &rgb_controllers); void DetectCrucialControllers(std::vector &busses, std::vector &rgb_controllers); @@ -290,6 +284,7 @@ void DetectRGBControllers(void) DetectI2CBusses(); DetectAuraControllers(busses, rgb_controllers); + DetectAuraGPUControllers(busses, rgb_controllers); DetectCorsairControllers(busses, rgb_controllers); DetectCorsairProControllers(busses, rgb_controllers); DetectCrucialControllers(busses, rgb_controllers); diff --git a/OpenRGB.pro b/OpenRGB.pro index 61acc68e..dfd914ac 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -14,6 +14,7 @@ INCLUDEPATH += \ super_io/ \ Controllers/AMDWraithPrismController/ \ Controllers/AuraController/ \ + Controllers/AuraGPUController/ \ Controllers/CorsairController/ \ Controllers/CorsairCmdrProController/ \ Controllers/CorsairKeyboardController/ \ @@ -55,6 +56,8 @@ SOURCES += \ Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp \ Controllers/AuraController/AuraController.cpp \ Controllers/AuraController/AuraControllerDetect.cpp \ + Controllers/AuraGPUController/AuraGPUController.cpp \ + Controllers/AuraGPUController/AuraGPUControllerDetect.cpp \ Controllers/CorsairController/CorsairController.cpp \ Controllers/CorsairController/CorsairControllerDetect.cpp \ Controllers/CorsairCmdrProController/CorsairCmdrProController.cpp \ @@ -97,6 +100,7 @@ SOURCES += \ RGBController/E131ControllerDetect.cpp \ RGBController/RGBController_AMDWraithPrism.cpp \ RGBController/RGBController_Aura.cpp \ + RGBController/RGBController_AuraGPU.cpp \ RGBController/RGBController_Corsair.cpp \ RGBController/RGBController_CorsairCmdrPro.cpp \ RGBController/RGBController_CorsairKeyboard.cpp \ @@ -132,6 +136,7 @@ HEADERS += \ super_io/super_io.h \ Controllers/AMDWraithPrismController/AMDWraithPrismController.h \ Controllers/AuraController/AuraController.h \ + Controllers/AuraGPUController/AuraGPUController.h \ Controllers/CorsairController/CorsairController.h \ Controllers/CorsairCmdrProController/CorsairCmdrProController.h \ Controllers/CorsairKeyboardController/CorsairKeyboardController.h \ @@ -154,6 +159,7 @@ HEADERS += \ RGBController/RGBController.h \ RGBController/RGBController_AMDWraithPrism.h \ RGBController/RGBController_Aura.h \ + RGBController/RGBController_AuraGPU.h \ RGBController/RGBController_Corsair.h \ RGBController/RGBController_CorsairCmdrPro.h \ RGBController/RGBController_CorsairNodePro.h \ diff --git a/RGBController/RGBController_AuraGPU.cpp b/RGBController/RGBController_AuraGPU.cpp new file mode 100644 index 00000000..3d4cd922 --- /dev/null +++ b/RGBController/RGBController_AuraGPU.cpp @@ -0,0 +1,176 @@ +/*-----------------------------------------*\ +| RGBController_AuraGPU.h | +| | +| Generic RGB Interface for Asus Aura GPU | +| | +| Jan Rettig (Klapstuhl) 14.02.2020 | +\*-----------------------------------------*/ + +#include "RGBController_AuraGPU.h" + +int RGBController_AuraGPU::GetDeviceMode() +{ + int dev_mode = aura_gpu->AuraGPURegisterRead(AURA_GPU_REG_MODE); + int color_mode = MODE_COLORS_PER_LED; + + if(dev_mode == AURA_GPU_MODE_STATIC) + { + if (aura_gpu->direct) + { + dev_mode = AURA_GPU_MODE_DIRECT; + } + } + + switch(dev_mode) + { + case AURA_GPU_MODE_OFF: + case AURA_GPU_MODE_SPECTRUM_CYCLE: + color_mode = MODE_COLORS_NONE; + break; + } + + for(int mode = 0; mode < modes.size(); mode++) + { + if(modes[mode].value == dev_mode) + { + active_mode = mode; + modes[mode].color_mode = color_mode; + } + } + + return(active_mode); +} + +void RGBController_AuraGPU::UpdateLEDs() +{ + 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]); + + if (GetMode() == 0) + { + aura_gpu->SetLEDColorsDirect(red, grn, blu); + } + else + { + aura_gpu->SetLEDColorsEffect(red, grn, blu); + } + } +} + +void RGBController_AuraGPU::UpdateZoneLEDs(int zone) +{ + UpdateLEDs(); +} + +void RGBController_AuraGPU::UpdateSingleLED(int led) +{ + UpdateLEDs(); +} + +RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * aura_gpu_ptr) +{ + aura_gpu = aura_gpu_ptr; + + + name = aura_gpu->GetDeviceName(); + version = "0.00.1"; + location = aura_gpu->GetDeviceLocation(); + type = DEVICE_TYPE_GPU; + + mode Direct; + Direct.name = "Direct"; + Direct.value = AURA_GPU_MODE_DIRECT; + Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; + Direct.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Direct); + + mode Off; + Off.name = "Off"; + Off.value = AURA_GPU_MODE_OFF; + Off.flags = 0; + Off.color_mode = MODE_COLORS_NONE; + modes.push_back(Off); + + mode Static; + Static.name = "Static"; + Static.value = AURA_GPU_MODE_STATIC; + Static.flags = MODE_FLAG_HAS_PER_LED_COLOR; + Static.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Static); + + mode Breathing; + Breathing.name = "Breathing"; + Breathing.value = AURA_GPU_MODE_BREATHING; + Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR; + Breathing.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Breathing); + + mode Flashing; + Flashing.name = "Flashing"; + Flashing.value = AURA_GPU_MODE_FLASHING; + Flashing.flags = MODE_FLAG_HAS_PER_LED_COLOR; + Flashing.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Flashing); + + mode Spectrum_Cycle; + Spectrum_Cycle.name = "Spectrum Cycle"; + Spectrum_Cycle.value = AURA_GPU_MODE_SPECTRUM_CYCLE; + Spectrum_Cycle.flags = 0; + Spectrum_Cycle.color_mode = MODE_COLORS_NONE; + modes.push_back(Spectrum_Cycle); + + colors.resize(1); + + led aura_gpu_led; + aura_gpu_led.name = "GPU"; + leds.push_back(aura_gpu_led); + + zone aura_gpu_zone; + aura_gpu_zone.name = "GPU"; + aura_gpu_zone.type = ZONE_TYPE_SINGLE; + + std::vector aura_gpu_zone_map; + aura_gpu_zone_map.push_back(0); + aura_gpu_zone.map.push_back(aura_gpu_zone_map); + zones.push_back(aura_gpu_zone); + + unsigned char red = aura_gpu->GetLEDRed(); + unsigned char grn = aura_gpu->GetLEDGreen(); + unsigned char blu = aura_gpu->GetLEDBlue(); + + colors[0] = ToRGBColor(red, grn, blu); + + active_mode = GetDeviceMode(); +} + +void RGBController_AuraGPU::SetCustomMode() +{ + active_mode = 0; +} + +void RGBController_AuraGPU::UpdateMode() +{ + int new_mode = modes[active_mode].value; + aura_gpu->direct = false; + + switch(new_mode) + { + + // Set all LEDs to 0 and Mode to static as a workaround for the non existing Off Mode + case AURA_GPU_MODE_OFF: + aura_gpu->SetLEDColorsEffect(0, 0, 0); + new_mode = AURA_GPU_MODE_STATIC; + break; + + // Direct mode is done by switching to Static and not applying color changes + case AURA_GPU_MODE_DIRECT: + aura_gpu->direct = true; + new_mode = AURA_GPU_MODE_STATIC; + break; + } + + aura_gpu->SetMode(new_mode); +} \ No newline at end of file diff --git a/RGBController/RGBController_AuraGPU.h b/RGBController/RGBController_AuraGPU.h new file mode 100644 index 00000000..a4546a27 --- /dev/null +++ b/RGBController/RGBController_AuraGPU.h @@ -0,0 +1,29 @@ +/*-----------------------------------------*\ +| RGBController_AuraGPU.h | +| | +| Generic RGB Interface for Asus Aura GPU | +| | +| Jan Rettig (Klapstuhl) 14.02.2020 | +\*-----------------------------------------*/ + +#pragma once + +#include "RGBController.h" +#include "AuraGPUController.h" + +class RGBController_AuraGPU : public RGBController +{ +public: + RGBController_AuraGPU(AuraGPUController* aura_gpu_ptr); + void UpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void SetCustomMode(); + void UpdateMode(); + +private: + AuraGPUController* aura_gpu; + + int GetDeviceMode(); +}; \ No newline at end of file